[Parser] Remove custom diagnostic that relies on AST-level name lookup.

The parser was using an AST-level name lookup operation to provide a
slightly improved diagnostic (suggesting "self." if there was a member
of that name in the enclosing type context). This is a fairly unfortunate
layering violation: name lookup cannot produce correct results at this
point. Remove the custom diagnostic and the lookup; this can come back
when all lookup moves out of the parser.

Author: DougGregor

include/swift/AST/DiagnosticsParse.def

@@ -223,8 +223,6 @@ ERROR(disallowed_init,none,
       "initial value is not allowed here", ())
 ERROR(var_init_self_referential,none,
       "variable used within its own initial value", ())
-ERROR(expected_self_before_reference,none,
-      "variable used within its own initial value; use 'self.' to refer to the %0", (DescriptiveDeclKind))
 
 ERROR(disallowed_enum_element,none,
       "enum 'case' is not allowed outside of an enum", ())

lib/Parse/ParseExpr.cpp

@@ -2114,22 +2114,6 @@ DeclName Parser::parseUnqualifiedDeclName(bool afterDot,
   return DeclName(Context, baseName, argumentLabels);
 }
 
-static bool shouldAddSelfFixit(DeclContext* Current, DeclName Name,
-                               DescriptiveDeclKind &Kind) {
-  if (Current->isTypeContext() || !Current->getInnermostTypeContext())
-    return false;
-  if (auto *Nominal = Current->getInnermostTypeContext()->
-      getAsNominalTypeOrNominalTypeExtensionContext()){
-    // FIXME: we cannot resolve members appear later in the body of the nominal.
-    auto LookupResults = Nominal->lookupDirect(Name);
-    if (!LookupResults.empty()) {
-      Kind = LookupResults.front()->getDescriptiveKind();
-      return true;
-    }
-  }
-  return false;
-}
-
 ///   expr-identifier:
 ///     unqualified-decl-name generic-args?
 Expr *Parser::parseExprIdentifier() {
@@ -2180,14 +2164,7 @@ Expr *Parser::parseExprIdentifier() {
     } else {
       for (auto activeVar : DisabledVars) {
         if (activeVar->getFullName() == name) {
-          DescriptiveDeclKind Kind;
-          if (DisabledVarReason.ID == diag::var_init_self_referential.ID &&
-              shouldAddSelfFixit(CurDeclContext, name, Kind)) {
-            diagnose(loc.getBaseNameLoc(), diag::expected_self_before_reference,
-                    Kind).fixItInsert(loc.getBaseNameLoc(), "self.");
-          } else {
-            diagnose(loc.getBaseNameLoc(), DisabledVarReason);
-          }
+          diagnose(loc.getBaseNameLoc(), DisabledVarReason);
           return new (Context) ErrorExpr(loc.getSourceRange());
         }
       }

test/Sema/diag_variable_used_in_initial.swift

@@ -3,15 +3,15 @@
 class A1 {
   func foo1() {}
   func foo2() {
-    var foo1 = foo1() // expected-error {{variable used within its own initial value; use 'self.' to refer to the instance method}}{{16-16=self.}}
+    var foo1 = foo1() // expected-error {{variable used within its own initial value}}
   }
 }
 
 class A2 {
   var foo1 = 2
   func foo2() {
     // FIXME: "the var" doesn't sound right.
-    var foo1 = foo1 // expected-error {{variable used within its own initial value; use 'self.' to refer to the property}}{{16-16=self.}}
+    var foo1 = foo1 // expected-error {{variable used within its own initial value}}
   }
 }
 
@@ -33,21 +33,21 @@ func localContext() {
   class A5 {
     func foo1() {}
     func foo2() {
-      var foo1 = foo1() // expected-error {{variable used within its own initial value; use 'self.' to refer to the instance method}}{{18-18=self.}}
+      var foo1 = foo1() // expected-error {{variable used within its own initial value}}
     }
 
     class A6 {
       func foo1() {}
       func foo2() {
-        var foo1 = foo1() // expected-error {{variable used within its own initial value; use 'self.' to refer to the instance method}}{{20-20=self.}}
+        var foo1 = foo1() // expected-error {{variable used within its own initial value}}
       }
     }
 
     extension E { // expected-error {{declaration is only valid at file scope}}
       class A7 {
         func foo1() {}
         func foo2() {
-          var foo1 = foo1() // expected-error {{variable used within its own initial value; use 'self.' to refer to the instance method}}{{22-22=self.}}
+          var foo1 = foo1() // expected-error {{variable used within its own initial value}}
         }
       }
     }