Restore Top-Level Placeholder Restrictions in Expression Position

Respect the text of https://github.com/apple/swift-evolution/blob/main/proposals/0315-placeholder-types.md#top-level-type-placeholders and re-restrict the usage of placeholders in top-level expressions.

Author: CodaFi

lib/Sema/CSGen.cpp

@@ -1318,6 +1318,11 @@ namespace {
       if (result->hasError()) {
         return Type();
       }
+      // Diagnose top-level usages of placeholder types.
+      if (isa<TopLevelCodeDecl>(CS.DC) && isa<PlaceholderTypeRepr>(repr)) {
+        CS.getASTContext().Diags.diagnose(repr->getLoc(),
+                                          diag::placeholder_type_not_allowed);
+      }
       return result;
     }
 

test/Sema/placeholder_type.swift

@@ -10,7 +10,7 @@ let arr = [_](repeating: "hi", count: 3)
 func foo(_ arr: [_] = [0]) {} // expected-error {{type placeholder may not appear in top-level parameter}}
 // expected-note@-1 {{replace the placeholder with the inferred type 'Int'}}
 
-let foo = _.foo // expected-error {{could not infer type for placeholder}}
+let foo = _.foo // expected-error {{type placeholder not allowed here}} expected-error {{could not infer type for placeholder}}
 let zero: _ = .zero // expected-error {{cannot infer contextual base in reference to member 'zero'}}
 
 struct S<T> {
@@ -49,7 +49,7 @@ func dictionary<K, V>(ofType: [K: V].Type) -> [K: V] { [:] }
 
 let _: [String: _] = dictionary(ofType: [_: Int].self)
 let _: [_: _] = dictionary(ofType: [String: Int].self)
-let _: [String: Int] = dictionary(ofType: _.self)
+let _: [String: Int] = dictionary(ofType: _.self) // expected-error {{type placeholder not allowed here}}
 
 let _: @convention(c) _ = { 0 } // expected-error {{@convention attribute only applies to function types}}
 let _: @convention(c) (_) -> _ = { (x: Double) in 0 }
@@ -107,18 +107,18 @@ extension Bar {
 }
 
 // FIXME: We should probably have better diagnostics for these situations--the user probably meant to use implicit member syntax
-let _: Int = _() // expected-error {{type of expression is ambiguous without more context}}
-let _: () -> Int = { _() } // expected-error {{unable to infer closure type in the current context}}
-let _: Int = _.init() // expected-error {{could not infer type for placeholder}}
-let _: () -> Int = { _.init() } // expected-error {{could not infer type for placeholder}}
+let _: Int = _() // expected-error {{type placeholder not allowed here}} expected-error {{type of expression is ambiguous without more context}}
+let _: () -> Int = { _() } // expected-error 2 {{type placeholder not allowed here}} expected-error {{unable to infer closure type in the current context}}
+let _: Int = _.init() // expected-error {{type placeholder not allowed here}} expected-error {{could not infer type for placeholder}}
+let _: () -> Int = { _.init() } // expected-error 2 {{type placeholder not allowed here}} expected-error {{could not infer type for placeholder}}
 
 func returnsInt() -> Int { _() } // expected-error {{type of expression is ambiguous without more context}}
 func returnsIntClosure() -> () -> Int { { _() } } // expected-error {{unable to infer closure type in the current context}}
 func returnsInt2() -> Int { _.init() }  // expected-error {{could not infer type for placeholder}}
 func returnsIntClosure2() -> () -> Int { { _.init() } } // expected-error {{could not infer type for placeholder}}
 
 let _: Int.Type = _ // expected-error {{'_' can only appear in a pattern or on the left side of an assignment}}
-let _: Int.Type = _.self
+let _: Int.Type = _.self // expected-error {{type placeholder not allowed here}}
 
 struct SomeSuperLongAndComplexType {}
 func getSomething() -> SomeSuperLongAndComplexType? { .init() }
@@ -200,13 +200,13 @@ extension Publisher {
     }
 }
 
-let _: SetFailureType<Int, String> = Just<Int>().setFailureType(to: _.self)
+let _: SetFailureType<Int, String> = Just<Int>().setFailureType(to: _.self) // expected-error {{type placeholder not allowed here}}
 let _: SetFailureType<Int, [String]> = Just<Int>().setFailureType(to: [_].self)
 let _: SetFailureType<Int, (String) -> Double> = Just<Int>().setFailureType(to: ((_) -> _).self)
 let _: SetFailureType<Int, (String, Double)> = Just<Int>().setFailureType(to: (_, _).self)
 
 // TODO: Better error message here? Would be nice if we could point to the placeholder...
-let _: SetFailureType<Int, String> = Just<Int>().setFailureType(to: _.self).setFailureType(to: String.self) // expected-error {{generic parameter 'T' could not be inferred}}
+let _: SetFailureType<Int, String> = Just<Int>().setFailureType(to: _.self).setFailureType(to: String.self) // expected-error {{type placeholder not allowed here}} expected-error {{generic parameter 'T' could not be inferred}}
 
 let _: (_) = 0 as Int
 let _: Int = 0 as (_)
@@ -225,7 +225,7 @@ _ = (1...10)
         x.boolValue ? intValue : 0
     }
 
-let _: SetFailureType<Int, String> = Just<Int>().setFailureType(to: _.self).setFailureType(to: String.self) // expected-error {{generic parameter 'T' could not be inferred}}
+let _: SetFailureType<Int, String> = Just<Int>().setFailureType(to: _.self).setFailureType(to: String.self) // expected-error {{type placeholder not allowed here}} expected-error {{generic parameter 'T' could not be inferred}}
 
 // N.B. The parallel structure of the annotation and inferred default
 // initializer types is all wrong. Plus, we do not trust

test/expr/expressions.swift

@@ -865,7 +865,7 @@ func r20802757(_ z: inout Int = &g20802757) { // expected-error {{cannot provide
   print(z)
 }
 
-_ = _.foo // expected-error {{could not infer type for placeholder}}
+_ = _.foo // expected-error {{type placeholder not allowed here}} expected-error {{could not infer type for placeholder}}
 
 // <rdar://problem/22211854> wrong arg list crashing sourcekit
 func r22211854() {