Restore the circular pattern binding validation hack

Overload resolution performs a lookup rooted at a pattern binding's
initializer that scoops up the var decl bound by the pattern.  This
forces it to validate the variable while type checking said variable's
initializer.  The old answer to this problem was to skip validation
which returns a temporary ErrorType.  We should patch lookup so it
doesn't consider these variables.

Author: CodaFi

lib/Sema/TypeCheckDecl.cpp

@@ -4243,6 +4243,14 @@ void TypeChecker::validateDecl(ValueDecl *D) {
       // attempt to infer the interface type using the initializer expressions.
       if (!PBD->isBeingValidated()) {
         validatePatternBindingEntries(*this, PBD);
+      } else if (!VD->getNamingPattern()) {
+        // FIXME: This acts as a circularity breaker for overload resolution
+        // during pattern binding validation, which is allowed to lookup and
+        // find the very VarDecl attached to the binding it's trying to check.
+        // In order to tell it to back off, we surface an error type but don't
+        // set the interface type so a different caller can come along and
+        // do the right thing.
+        return;
       }
 
       if (PBD->isInvalid()) {

test/NameBinding/name_lookup.swift

@@ -616,15 +616,15 @@ struct PatternBindingWithTwoVars1 { var x = 3, y = x }
 // expected-error@-1 {{cannot use instance member 'x' within property initializer; property initializers run before 'self' is available}}
 
 struct PatternBindingWithTwoVars2 { var x = y, y = 3 }
-// expected-error@-1 {{variable 'y' is not bound by any pattern}}
+// expected-error@-1 {{type 'PatternBindingWithTwoVars2' has no member 'y'}}
 
 // This one should be accepted, but for now PatternBindingDecl validation
 // circularity detection is not fine grained enough.
 struct PatternBindingWithTwoVars3 { var x = y, y = x }
-// expected-error@-1 {{variable 'y' is not bound by any pattern}}
+// expected-error@-1 {{type 'PatternBindingWithTwoVars3' has no member 'y'}}
 
 // https://bugs.swift.org/browse/SR-9015
 func sr9015() {
-  let closure1 = { closure2() } // expected-error {{variable 'closure1' is not bound by any pattern}}
+  let closure1 = { closure2() } // expected-error {{let 'closure1' references itself}}
   let closure2 = { closure1() }
 }

test/decl/protocol/conforms/circular_validation.swift

@@ -10,7 +10,6 @@ protocol P {
 struct S : P { // expected-error {{type 'S' does not conform to protocol 'P'}}
   static var x = 0 // expected-note {{candidate operates on a type, not an instance as required}}
   var x = S.x // expected-note {{candidate references itself}}
-  // expected-error@-1 {{variable 'x' is not bound by any pattern}}
 }
 
 // FIXME: Lousy diagnostics on this case.

test/decl/var/overload_cycle.swift

@@ -0,0 +1,9 @@
+// RUN: %target-typecheck-verify-swift
+
+// Validating the pattern binding initializer for `raw` causes recursive
+// validation of the VarDecl. Overload resolution relies on getting back an
+// ErrorType from VarDecl validation to disqualify the recursive candidate.
+public struct Cyclic {
+  static func pickMe(please: Bool) -> Int { return 42 }
+  public static let pickMe = Cyclic.pickMe(please: true)
+}

test/decl/var/variables.swift

@@ -66,7 +66,7 @@ class SomeClass {}
 weak let V = SomeClass()  // expected-error {{'weak' must be a mutable variable, because it may change at runtime}}
 
 let a = b ; let b = a
-// expected-error@-1 {{variable 'a' is not bound by any pattern}}
+// expected-error@-1 {{let 'a' references itself}}
 
 // <rdar://problem/17501765> Swift should warn about immutable default initialized values
 let uselessValue : String?