[CSGen] Turn invalid decls into holes

Instead of failing constraint generation upon encountering
an invalid declaration, let's turn that declaration into a
potential hole and keep going. Doing so enables the solver
to reach a solution and diagnose any other issue with
expression.

Author: xedin

lib/Sema/CSGen.cpp

@@ -1227,9 +1227,11 @@ namespace {
         if (knownType) {
           // If the known type has an error, bail out.
           if (knownType->hasError()) {
+            auto *hole = CS.createTypeVariable(locator, TVO_CanBindToHole);
+            (void)CS.recordFix(AllowRefToInvalidDecl::create(CS, locator));
             if (!CS.hasType(E))
-              CS.setType(E, knownType);
-            return nullptr;
+              CS.setType(E, hole);
+            return hole;
           }
 
           if (!knownType->hasHole()) {
@@ -1258,14 +1260,13 @@ namespace {
         }
       }
 
-      // If we're referring to an invalid declaration, don't type-check.
-      //
-      // FIXME: If the decl is in error, we get no information from this.
-      // We may, alternatively, want to use a type variable in that case,
-      // and possibly infer the type of the variable that way.
+      // If declaration is invalid, let's turn it into a potential hole
+      // and keep generating constraints.
       if (!knownType && E->getDecl()->isInvalid()) {
-        CS.setType(E, E->getDecl()->getInterfaceType());
-        return nullptr;
+        auto *hole = CS.createTypeVariable(locator, TVO_CanBindToHole);
+        (void)CS.recordFix(AllowRefToInvalidDecl::create(CS, locator));
+        CS.setType(E, hole);
+        return hole;
       }
 
       // Create an overload choice referencing this declaration and immediately

test/ClangImporter/MixedSource/can_import_objc_idempotent.swift

@@ -30,6 +30,7 @@
   // expected-error@-1 {{cannot find 'CGRect' in scope}}
 
   let (r, s) = square.divided(atDistance: 50, from: .minXEdge)
+  // expected-error@-1 {{type of expression is ambiguous without more context}}
 #endif
 
 #if canImport(MixedWithHeader)

test/ClangImporter/cf.swift

@@ -5,7 +5,7 @@
 import CoreCooling
 import CFAndObjC
 
-func assertUnmanaged<T>(_ t: Unmanaged<T>) {}
+func assertUnmanaged<T>(_ t: Unmanaged<T>) {} // expected-note {{in call to function 'assertUnmanaged'}}
 func assertManaged<T: AnyObject>(_ t: T) {}
 
 func test0(_ fridge: CCRefrigerator) {
@@ -15,7 +15,7 @@ func test0(_ fridge: CCRefrigerator) {
 func test1(_ power: Unmanaged<CCPowerSupply>) {
   assertUnmanaged(power)
   let fridge = CCRefrigeratorCreate(power) // expected-error {{cannot convert value of type 'Unmanaged<CCPowerSupply>' to expected argument type 'CCPowerSupply?'}}
-  assertUnmanaged(fridge)
+  assertUnmanaged(fridge) // expected-error {{generic parameter 'T' could not be inferred}}
 }
 
 func test2() {

test/NameLookup/name_lookup.swift

@@ -650,6 +650,6 @@ struct PatternBindingWithTwoVars3 { var x = y, y = x }
 
 // https://bugs.swift.org/browse/SR-9015
 func sr9015() {
-  let closure1 = { closure2() } // expected-error {{circular reference}} expected-note {{through reference here}} expected-note {{through reference here}} expected-error {{unable to infer closure}}
-  let closure2 = { closure1() } // expected-note {{through reference here}} expected-note {{through reference here}} expected-note {{through reference here}} expected-error {{unable to infer closure}}
+  let closure1 = { closure2() } // expected-error {{circular reference}} expected-note {{through reference here}} expected-note {{through reference here}}
+  let closure2 = { closure1() } // expected-note {{through reference here}} expected-note {{through reference here}} expected-note {{through reference here}}
 }

test/attr/attr_noescape.swift

@@ -184,8 +184,8 @@ class SomeClass {
 // Implicit conversions (in this case to @convention(block)) are ok.
 @_silgen_name("whatever") 
 func takeNoEscapeAsObjCBlock(_: @noescape @convention(block) () -> Void)  // expected-error{{unknown attribute 'noescape'}}
-func takeNoEscapeTest2(_ fn : @noescape () -> ()) {  // expected-error{{unknown attribute 'noescape'}}
-  takeNoEscapeAsObjCBlock(fn)
+func takeNoEscapeTest2(_ fn : @noescape () -> ()) {  // expected-error{{unknown attribute 'noescape'}} expected-note {{parameter 'fn' is implicitly non-escaping}}
+  takeNoEscapeAsObjCBlock(fn) // expected-error {{passing non-escaping parameter 'fn' to function expecting an @escaping closure}}
 }
 
 // Autoclosure implies noescape..
@@ -290,14 +290,14 @@ typealias CompletionHandler = (_ success: Bool) -> ()
 
 var escape : CompletionHandlerNE
 var escapeOther : CompletionHandler
-func doThing1(_ completion: (_ success: Bool) -> ()) {
-  escape = completion
+func doThing1(_ completion: (_ success: Bool) -> ()) { // expected-note {{parameter 'completion' is implicitly non-escaping}}
+  escape = completion // expected-error {{assigning non-escaping parameter 'completion' to an @escaping closure}}
 }
 func doThing2(_ completion: CompletionHandlerNE) {
   escape = completion
 }
-func doThing3(_ completion: CompletionHandler) {
-  escape = completion
+func doThing3(_ completion: CompletionHandler) { // expected-note {{parameter 'completion' is implicitly non-escaping}}
+  escape = completion // expected-error {{assigning non-escaping parameter 'completion' to an @escaping closure}}
 }
 func doThing4(_ completion: @escaping CompletionHandler) {
   escapeOther = completion

test/expr/closure/closures.swift

@@ -119,7 +119,6 @@ assert(f0(1) == 1)
 var selfRef = { selfRef() }
 // expected-note@-1 2{{through reference here}}
 // expected-error@-2 {{circular reference}}
-// expected-error@-3 {{unable to infer closure type in the current context}}
 
 var nestedSelfRef = {
   var recursive = { nestedSelfRef() }

validation-test/Sema/type_checker_perf/slow/fast-operator-typechecking.swift

@@ -5,6 +5,7 @@ func checksum(value: UInt16) -> UInt16 {
   var checksum = (((value >> 2) ^ (value >> 8) ^ (value >> 12) ^ (value >> 14)) & 0x01) << 1
   // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
   checksum |= (((value) ^ (value >> UInt16(4)) ^ (value >> UInt16(6)) ^ (value >> UInt16(10))) & 0x01)
+  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
   checksum ^= 0x02
   return checksum
 }