Frontend: Don't interleave parsing and typechecking for the main file

slavapestov · slavapestov · commit 1df3d1a33cc8 · 2019-12-05T08:45:55.000-05:00
SIL files still require this behavior; if we cleaned that up we could simplify a fair bit of code here. Fixes <https://bugs.swift.org/browse/SR-284>, <https://bugs.swift.org/browse/SR-4426>.
diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp
@@ -851,8 +851,8 @@ void CompilerInstance::parseAndCheckTypesUpTo(
 
   // Type-check main file after parsing all other files so that
   // it can use declarations from other files.
-  // In addition, the main file has parsing and type-checking
-  // interwined.
+  // In addition, in SIL mode the main file has parsing and
+  // type-checking interwined.
   if (MainBufferID != NO_SUCH_BUFFER) {
     parseAndTypeCheckMainFileUpTo(limitStage);
   }
@@ -977,24 +977,35 @@ void CompilerInstance::parseAndTypeCheckMainFileUpTo(
     parseIntoSourceFile(MainFile, MainFile.getBufferID().getValue(), &Done,
                         TheSILModule ? &SILContext : nullptr,
                         PersistentState.get(),
-                        /*DelayedBodyParsing=*/false);
+                        !mainIsPrimary);
 
-    if (mainIsPrimary && (Done || CurTUElem < MainFile.Decls.size())) {
+    // For SIL we actually have to interleave parsing and type checking
+    // because the SIL parser expects to see fully type checked declarations.
+    if (TheSILModule) {
+      if (Done || CurTUElem < MainFile.Decls.size()) {
+        assert(mainIsPrimary);
+        performTypeChecking(MainFile, CurTUElem);
+      }
+    }
+
+    CurTUElem = MainFile.Decls.size();
+  } while (!Done);
+
+  if (!TheSILModule) {
+    if (mainIsPrimary) {
       switch (LimitStage) {
       case SourceFile::Parsing:
       case SourceFile::Parsed:
         llvm_unreachable("invalid limit stage");
       case SourceFile::NameBound:
-        performNameBinding(MainFile, CurTUElem);
+        performNameBinding(MainFile);
         break;
       case SourceFile::TypeChecked:
-        performTypeChecking(MainFile, CurTUElem);
+        performTypeChecking(MainFile);
         break;
       }
     }
-
-    CurTUElem = MainFile.Decls.size();
-  } while (!Done);
+  }
 
   Diags.setSuppressWarnings(DidSuppressWarnings);
 
@@ -1003,8 +1014,10 @@ void CompilerInstance::parseAndTypeCheckMainFileUpTo(
     performDebuggerTestingTransform(MainFile);
   }
 
-  if (!mainIsPrimary) {
-    performNameBinding(MainFile);
+  if (!TheSILModule) {
+    if (!mainIsPrimary) {
+      performNameBinding(MainFile);
+    }
   }
 }
 
diff --git a/test/Constraints/closures.swift b/test/Constraints/closures.swift
@@ -763,6 +763,7 @@ overloaded { print("hi"); print("bye") } // multiple expression closure without
 // expected-error@-1 {{ambiguous use of 'overloaded'}}
 
 func not_overloaded(_ handler: () -> Int) {}
+// expected-note@-1 {{'not_overloaded' declared here}}
 
 not_overloaded { } // empty body
 // expected-error@-1 {{cannot convert value of type '()' to closure result type 'Int'}}
diff --git a/test/Constraints/diagnostics.swift b/test/Constraints/diagnostics.swift
@@ -72,7 +72,7 @@ f3(
 f4(i, d) // expected-error {{extra argument in call}}
 
 // Missing member.
-i.wobble() // expected-error{{value of type 'Int' has no member 'wobble'}}
+i.missingMember() // expected-error{{value of type 'Int' has no member 'missingMember'}}
 
 // Generic member does not conform.
 extension Int {
@@ -100,11 +100,11 @@ func f7() -> (c: Int, v: A) {
 }
 
 func f8<T:P2>(_ n: T, _ f: @escaping (T) -> T) {}  // expected-note {{where 'T' = 'Int'}}
-// expected-note@-1 {{required by global function 'f8' where 'T' = 'Tup' (aka '(Int, Double)')}}
+// expected-note@-1 {{required by global function 'f8' where 'T' = '(Int, Double)'}}
 f8(3, f4) // expected-error {{global function 'f8' requires that 'Int' conform to 'P2'}}
 typealias Tup = (Int, Double)
 func f9(_ x: Tup) -> Tup { return x }
-f8((1,2.0), f9) // expected-error {{type 'Tup' (aka '(Int, Double)') cannot conform to 'P2'; only struct/enum/class types can conform to protocols}}
+f8((1,2.0), f9) // expected-error {{type '(Int, Double)' cannot conform to 'P2'; only struct/enum/class types can conform to protocols}}
 
 // <rdar://problem/19658691> QoI: Incorrect diagnostic for calling nonexistent members on literals
 1.doesntExist(0)  // expected-error {{value of type 'Int' has no member 'doesntExist'}}
@@ -1144,24 +1144,6 @@ for var i in 0..<10 { // expected-warning {{variable 'i' was never mutated; cons
   _ = i + 1
 }
 
-// rdar://problem/32726044 - shrink reduced domains too far
-
-public protocol P_32726044 {}
-
-extension Int: P_32726044 {}
-extension Float: P_32726044 {}
-
-public func *(lhs: P_32726044, rhs: P_32726044) -> Double {
-  fatalError()
-}
-
-func rdar32726044() -> Float {
-  var f: Float = 0
-  f = Float(1) * 100 // Ok
-  let _: Float = Float(42) + 0 // Ok
-  return f
-}
-
 // SR-5045 - Attempting to return result of reduce(_:_:) in a method with no return produces ambiguous error
 func sr5045() {
   let doubles: [Double] = [1, 2, 3]
@@ -1294,16 +1276,18 @@ func unresolvedTypeExistential() -> Bool {
 func rdar43525641(_ a: Int, _ b: Int = 0, c: Int = 0, _ d: Int) {}
 rdar43525641(1, c: 2, 3) // Ok
 
-struct Array {}
-let foo: Swift.Array = Array() // expected-error {{cannot convert value of type 'Array' to specified type 'Array<Element>'}}
-// expected-error@-1 {{generic parameter 'Element' could not be inferred}}
+do {
+  struct Array {}
+  let foo: Swift.Array = Array() // expected-error {{cannot convert value of type 'Array' to specified type 'Array<Element>'}}
+  // expected-error@-1 {{generic parameter 'Element' could not be inferred}}
 
-struct Error {}
-let bar: Swift.Error = Error() //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
-let baz: (Swift.Error) = Error() //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
-let baz2: Swift.Error = (Error()) //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
-let baz3: (Swift.Error) = (Error()) //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
-let baz4: ((Swift.Error)) = (Error()) //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
+  struct Error {}
+  let bar: Swift.Error = Error() //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
+  let baz: (Swift.Error) = Error() //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
+  let baz2: Swift.Error = (Error()) //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
+  let baz3: (Swift.Error) = (Error()) //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
+  let baz4: ((Swift.Error)) = (Error()) //expected-error {{value of type 'diagnostics.Error' does not conform to specified type 'Swift.Error'}}
+}
 
 // SyntaxSugarTypes with unresolved types
 func takesGenericArray<T>(_ x: [T]) {}
diff --git a/test/Constraints/dynamic_lookup.swift b/test/Constraints/dynamic_lookup.swift
@@ -267,7 +267,7 @@ func rdar29960565(_ o: AnyObject) {
 
 @objc class DynamicIUO : NSObject, Q {
   @objc var t: String! = ""
-  @objc func bar() -> String! {}
+  @objc func baz() -> String! {}
   @objc subscript(_: DynamicIUO) -> DynamicIUO! {
     get {
       return self
@@ -299,11 +299,11 @@ let _: String = o.t
 let _: String = o.t!
 let _: String = o.t!!
 let _: String? = o.t
-let _: String = o.bar()
-let _: String = o.bar!()
-let _: String = o.bar()!
-let _: String = o.bar!()!
-let _: String? = o.bar()
+let _: String = o.baz()
+let _: String = o.baz!()
+let _: String = o.baz()!
+let _: String = o.baz!()!
+let _: String? = o.baz()
 let _: DynamicIUO = o[dyn_iuo]
 let _: DynamicIUO = o[dyn_iuo]!
 let _: DynamicIUO = o[dyn_iuo]!!
diff --git a/test/Constraints/members.swift b/test/Constraints/members.swift
@@ -567,15 +567,15 @@ func rdar_48114578() {
 }
 
 struct S_Min {
-  var min: Int = 42
+  var xmin: Int = 42
 }
 
-func min(_: Int, _: Float) -> Int { return 0 }
-func min(_: Float, _: Int) -> Int { return 0 }
+func xmin(_: Int, _: Float) -> Int { return 0 }
+func xmin(_: Float, _: Int) -> Int { return 0 }
 
 extension S_Min : CustomStringConvertible {
   public var description: String {
-    return "\(min)" // Ok
+    return "\(xmin)" // Ok
   }
 }
 
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
@@ -87,7 +87,7 @@ default:
 }
 
 // Raise an error if pattern productions are used in expressions.
-var b = var a // expected-error{{expected initial value after '='}} expected-error {{type annotation missing in pattern}} expected-error {{consecutive statements on a line must be separated by ';'}} {{8-8=;}}
+var b = var x // expected-error{{expected initial value after '='}} expected-error {{type annotation missing in pattern}} expected-error {{consecutive statements on a line must be separated by ';'}} {{8-8=;}}
 var c = is Int // expected-error{{expected initial value after '='}} expected-error {{expected expression}}  expected-error {{consecutive statements on a line must be separated by ';'}} {{8-8=;}}
 
 // TODO: Bad recovery in these cases. Although patterns are never valid
diff --git a/test/Constraints/rdar32726044.swift b/test/Constraints/rdar32726044.swift
@@ -0,0 +1,18 @@
+// RUN: %target-typecheck-verify-swift
+
+// rdar://problem/32726044 - shrink reduced domains too far
+public protocol P_32726044 {}
+
+extension Int: P_32726044 {}
+extension Float: P_32726044 {}
+
+public func *(lhs: P_32726044, rhs: P_32726044) -> Double {
+  fatalError()
+}
+
+func rdar32726044() -> Float {
+  var f: Float = 0
+  f = Float(1) * 100 // Ok
+  let _: Float = Float(42) + 0 // Ok
+  return f
+}
diff --git a/test/Constraints/tuple_arguments.swift b/test/Constraints/tuple_arguments.swift
@@ -1695,6 +1695,7 @@ class Mappable<T> {
 }
 
 let x = Mappable(())
+// expected-note@-1 2{{'x' declared here}}
 _ = x.map { (_: Void) in return () }
 _ = x.map { (_: ()) in () }
 
diff --git a/test/Frontend/debug-diagnostic-names.swift b/test/Frontend/debug-diagnostic-names.swift
@@ -5,19 +5,19 @@ let x =
 // CHECK_NAMES: error: expected initial value after '=' [expected_init_value]{{$}}
 // CHECK_NONAMES: error: expected initial value after '='{{$}}
 
+// CHECK_NAMES: warning: expression following 'return' is treated as an argument of the 'return' [unindented_code_after_return]{{$}}
+// CHECK_NAMES: note: indent the expression to silence this warning [indent_expression_to_silence]{{$}}
+// CHECK_NONAMES: warning: expression following 'return' is treated as an argument of the 'return'{{$}}
+// CHECK_NONAMES: note: indent the expression to silence this warning{{$}}
+func foo() -> Int {
+  return
+  42
+}
+
 guard let y = 0 else {}
 // CHECK_NAMES: error: initializer for conditional binding must have Optional type, not 'Int' [condition_optional_element_pattern_not_valid_type]{{$}}
 // CHECK_NONAMES: error: initializer for conditional binding must have Optional type, not 'Int'{{$}}
 
 let z: Double = ""
 // CHECK_NAMES: error: cannot convert value of type 'String' to specified type 'Double' [cannot_convert_initializer_value]{{$}}
 // CHECK_NONAMES: error: cannot convert value of type 'String' to specified type 'Double'{{$}}
-
-func foo() -> Int {
-  return
-  42
-}
-// CHECK_NAMES: warning: expression following 'return' is treated as an argument of the 'return' [unindented_code_after_return]{{$}}
-// CHECK_NAMES: note: indent the expression to silence this warning [indent_expression_to_silence]{{$}}
-// CHECK_NONAMES: warning: expression following 'return' is treated as an argument of the 'return'{{$}}
-// CHECK_NONAMES: note: indent the expression to silence this warning{{$}}
diff --git a/test/NameBinding/accessibility.swift b/test/NameBinding/accessibility.swift
@@ -64,6 +64,7 @@ _ = PrivateInit() // expected-error {{'PrivateInit' initializer is inaccessible
 // TESTABLE: :[[@LINE-1]]:{{[^:]+}}: error: 'PrivateInit' initializer is inaccessible due to 'private' protection level
 
 var s = StructWithPrivateSetter()
+// expected-note@-1 3{{did you mean 's'?}}
 s.x = 42 // expected-error {{cannot assign to property: 'x' setter is inaccessible}}
 
 class Sub : Base {
diff --git a/test/NameBinding/name-binding.swift b/test/NameBinding/name-binding.swift
@@ -62,9 +62,9 @@ func test_varname_binding() {
 // ForwardIndex referencing of types.
 //===----------------------------------------------------------------------===//
 
-// We don't allow namebinding to look forward past a var declaration in the
+// We allow namebinding to look forward past a var declaration in the
 // main module
-var x : x_ty  // expected-error {{use of undeclared type 'x_ty'}}
+var x : x_ty
 typealias x_ty = Int
 
 // We allow namebinding to look forward past a function declaration (and other
diff --git a/test/Parse/ConditionalCompilation/pound-if-top-level-4.swift b/test/Parse/ConditionalCompilation/pound-if-top-level-4.swift
@@ -11,8 +11,7 @@ func foo() {}
 
 struct B {}
 
-// If '#if' contains active non-decls, we don't support forward reference.
-typealias C = D // expected-error {{use of undeclared type 'D'}}
+typealias C = D
 
 #if true
 print("ok")
diff --git a/test/Parse/recovery.swift b/test/Parse/recovery.swift
@@ -679,7 +679,7 @@ func a(s: S[{{g) -> Int {}
 // expected-error@+3{{expected '(' for initializer parameters}}
 // expected-error@+2{{initializers may only be declared within a type}}
 // expected-error@+1{{expected an identifier to name generic parameter}}
-func F() { init<( } )} // expected-note {{did you mean 'F'?}}
+func F() { init<( } )} // expected-note 2{{did you mean 'F'?}}
 
 struct InitializerWithName {
   init x() {} // expected-error {{initializers cannot have a name}} {{8-9=}}
@@ -838,7 +838,7 @@ func postfixDot(a : String) {
 }
 
 // <rdar://problem/22290244> QoI: "UIColor." gives two issues, should only give one
-func f() {
+func f() { // expected-note 2{{did you mean 'f'?}}
   _ = ClassWithStaticDecls.  // expected-error {{expected member name following '.'}}
 }
 
diff --git a/test/Sema/typo_correction.swift b/test/Sema/typo_correction.swift
@@ -27,9 +27,9 @@ func *(x: Whatever, y: Whatever) {}
 // This works even for single-character identifiers.
 func test_very_short() {
   // Note that we don't suggest operators.
-  let x = 0 // expected-note {{'x' declared here}}
+  let x = 0 // expected-note {{did you mean 'x'?}}
   let longer = y
-  // expected-error@-1 {{use of unresolved identifier 'y'; did you mean 'x'?}}
+  // expected-error@-1 {{use of unresolved identifier 'y'}}
 }
 
 // It does not trigger in a variable's own initializer.
@@ -113,12 +113,14 @@ struct Generic<T> { // expected-note {{'T' declared as parameter to type 'Generi
 }
 
 protocol P { // expected-note {{'P' previously declared here}}
-  // expected-note@-1 {{did you mean 'P'?}}
+  // expected-note@-1 2{{did you mean 'P'?}}
+  // expected-note@-2 {{'P' declared here}}
   typealias a = Generic
 }
 
 protocol P {} // expected-error {{invalid redeclaration of 'P'}}
-// expected-note@-1 {{did you mean 'P'?}}
+// expected-note@-1 2{{did you mean 'P'?}}
+// expected-note@-2 {{'P' declared here}}
 
 func hasTypo() {
   _ = P.a.a // expected-error {{type 'Generic<T>' has no member 'a'}}
@@ -141,7 +143,7 @@ enum Foo {
   case flashing // expected-note {{'flashing' declared here}}
 }
 
-func foo(_ a: Foo) {
+func foo(_ a: Foo) { // expected-note {{'foo' declared here}}
 }
 
 func bar() {
diff --git a/test/Serialization/class.swift b/test/Serialization/class.swift
@@ -46,9 +46,9 @@ var p = Pair(a: 1, b: 2.5)
 p.first = 2
 p.second = 5.0
 
-struct Int {}
+struct MyInt {}
 
-var gc = GenericCtor<Int>(42)
+var gc = GenericCtor<MyInt>(42)
 gc.doSomething(42)
 
 
diff --git a/test/decl/ext/protocol.swift b/test/decl/ext/protocol.swift
@@ -1039,9 +1039,9 @@ protocol Empty2 {}
 struct Concrete1 {}
 extension Concrete1 : Empty1 & Empty2 {}
 
-typealias T = Empty1 & Empty2
+typealias TA = Empty1 & Empty2
 struct Concrete2 {}
-extension Concrete2 : T {}
+extension Concrete2 : TA {}
 
 func f<T : Empty1 & Empty2>(_: T) {}
 
diff --git a/test/decl/func/operator.swift b/test/decl/func/operator.swift
@@ -168,7 +168,7 @@ prefix operator ++
 prefix postfix func ++(x: Int) {} // expected-error {{'postfix' contradicts previous modifier 'prefix'}} {{8-16=}}
 postfix prefix func ++(x: Float) {} // expected-error {{'prefix' contradicts previous modifier 'postfix'}} {{9-16=}}
 postfix prefix infix func ++(x: Double) {} // expected-error {{'prefix' contradicts previous modifier 'postfix'}} {{9-16=}} expected-error {{'infix' contradicts previous modifier 'postfix'}} {{16-22=}}
-infix prefix func +-+(x: Int, y: Int) {} // expected-error {{'infix' modifier is not required or allowed on func declarations}} {{1-7=}} expected-error{{'prefix' contradicts previous modifier 'infix'}} {{7-14=}}
+infix prefix func +-+(x: Double, y: Double) {} // expected-error {{'infix' modifier is not required or allowed on func declarations}} {{1-7=}} expected-error{{'prefix' contradicts previous modifier 'infix'}} {{7-14=}}
 
 // Don't allow one to define a postfix '!'; it's built into the
 // language. Also illegal to have any postfix operator starting with '!'.
diff --git a/test/decl/overload.swift b/test/decl/overload.swift
@@ -5,8 +5,10 @@ var_redecl1 = 0
 var var_redecl1: UInt // expected-error {{invalid redeclaration of 'var_redecl1'}}
 
 var var_redecl2: Int // expected-note {{previously declared here}}
-var_redecl2 = 0
+// expected-note@-1 {{found this candidate}}
+var_redecl2 = 0 // expected-error {{ambiguous use of 'var_redecl2'}}
 var var_redecl2: Int // expected-error {{invalid redeclaration of 'var_redecl2'}}
+// expected-note@-1 {{found this candidate}}
 
 var var_redecl3: (Int) -> () { get {} } // expected-note {{previously declared here}}
 var var_redecl3: () -> () { get {} } // expected-error {{invalid redeclaration of 'var_redecl3'}}
diff --git a/test/decl/var/properties.swift b/test/decl/var/properties.swift
diff --git a/test/expr/expressions.swift b/test/expr/expressions.swift

Original file line number	Diff line number	Diff line change
`@@ -567,15 +567,15 @@ func rdar_48114578() {`
`567`	`567`	`}`
`568`	`568`
`569`	`569`	`struct S_Min {`
`570`		`- var min: Int = 42`
	`570`	`+ var xmin: Int = 42`
`571`	`571`	`}`
`572`	`572`
`573`		`-func min(_: Int, _: Float) -> Int { return 0 }`
`574`		`-func min(_: Float, _: Int) -> Int { return 0 }`
	`573`	`+func xmin(_: Int, _: Float) -> Int { return 0 }`
	`574`	`+func xmin(_: Float, _: Int) -> Int { return 0 }`
`575`	`575`
`576`	`576`	`extension S_Min : CustomStringConvertible {`
`577`	`577`	`public var description: String {`
`578`		`- return "\(min)" // Ok`
	`578`	`+ return "\(xmin)" // Ok`
`579`	`579`	`}`
`580`	`580`	`}`
`581`	`581`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ default:`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`// Raise an error if pattern productions are used in expressions.`
`90`		`-var b = var a // expected-error{{expected initial value after '='}} expected-error {{type annotation missing in pattern}} expected-error {{consecutive statements on a line must be separated by ';'}} {{8-8=;}}`
	`90`	`+var b = var x // expected-error{{expected initial value after '='}} expected-error {{type annotation missing in pattern}} expected-error {{consecutive statements on a line must be separated by ';'}} {{8-8=;}}`
`91`	`91`	`var c = is Int // expected-error{{expected initial value after '='}} expected-error {{expected expression}} expected-error {{consecutive statements on a line must be separated by ';'}} {{8-8=;}}`
`92`	`92`
`93`	`93`	`// TODO: Bad recovery in these cases. Although patterns are never valid`
Original file line number	Diff line number	Diff line change
`@@ -1695,6 +1695,7 @@ class Mappable<T> {`
`1695`	`1695`	`}`
`1696`	`1696`
`1697`	`1697`	`let x = Mappable(())`
	`1698`	`+// expected-note@-1 2{{'x' declared here}}`
`1698`	`1699`	`_ = x.map { (_: Void) in return () }`
`1699`	`1700`	`_ = x.map { (_: ()) in () }`
`1700`	`1701`