Merge pull request swiftlang#37992 from jackgmarch/SR-4559

[SR-4559] Warn when unapplied reference to a function 'self' is referenced in property initialiser

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -3756,8 +3756,13 @@ NOTE(add_self_to_type,none,
 WARNING(warn_unqualified_access,none,
         "use of %0 treated as a reference to %1 in %2 %3",
         (Identifier, DescriptiveDeclKind, DescriptiveDeclKind, DeclName))
+WARNING(self_refers_to_method,none,
+       "'self' refers to the method '%0.self', which may be unexpected",
+       (StringRef))
 NOTE(fix_unqualified_access_member,none,
      "use 'self.' to silence this warning", ())
+NOTE(fix_unqualified_access_member_named_self,none,
+     "use '%0.self' to silence this warning", (StringRef))
 NOTE(fix_unqualified_access_top_level,none,
      "use '%0' to reference the %1",
      (StringRef, DescriptiveDeclKind, Identifier))

lib/Sema/MiscDiagnostics.cpp

@@ -4664,6 +4664,60 @@ static void diagnoseComparisonWithNaN(const Expr *E, const DeclContext *DC) {
   const_cast<Expr *>(E)->walk(Walker);
 }
 
+static void diagUnqualifiedAccessToMethodNamedSelf(const Expr *E,
+                                                   const DeclContext *DC) {
+  if (!E || isa<ErrorExpr>(E) || !E->getType())
+    return;
+
+  class DiagnoseWalker : public ASTWalker {
+    ASTContext &Ctx;
+    const DeclContext *DC;
+
+  public:
+    DiagnoseWalker(const DeclContext *DC) : Ctx(DC->getASTContext()), DC(DC) {}
+
+    bool shouldWalkIntoSeparatelyCheckedClosure(ClosureExpr *expr) override {
+      return false;
+    }
+
+    bool shouldWalkIntoTapExpression() override { return false; }
+
+    std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
+      if (!E || isa<ErrorExpr>(E) || !E->getType())
+        return {false, E};
+
+      if (auto *declRefExpr = dyn_cast<DeclRefExpr>(E)) {
+        if (declRefExpr->getDecl()->getBaseName() == Ctx.Id_self &&
+            declRefExpr->getType()->is<AnyFunctionType>()) {
+          if (auto typeContext = DC->getInnermostTypeContext()) {
+            // self() is not easily confusable
+            if (!isa<CallExpr>(Parent.getAsExpr())) {
+
+              auto baseType = typeContext->getDeclaredInterfaceType();
+              auto baseTypeString = baseType.getString();
+
+              Ctx.Diags.diagnose(E->getLoc(), diag::self_refers_to_method,
+                                 baseTypeString);
+
+              Ctx.Diags
+                  .diagnose(E->getLoc(),
+                            diag::fix_unqualified_access_member_named_self,
+                            baseTypeString)
+                  .fixItInsert(E->getLoc(), diag::insert_type_qualification,
+                               baseType);
+            }
+          }
+        }
+      }
+
+      return {true, E};
+    }
+  };
+
+  DiagnoseWalker Walker(DC);
+  const_cast<Expr *>(E)->walk(Walker);
+}
+
 namespace {
 
 class CompletionHandlerUsageChecker final : public ASTWalker {
@@ -4749,6 +4803,7 @@ void swift::performSyntacticExprDiagnostics(const Expr *E,
   if (ctx.LangOpts.EnableObjCInterop)
     diagDeprecatedObjCSelectors(DC, E);
   diagnoseConstantArgumentRequirement(E, DC);
+  diagUnqualifiedAccessToMethodNamedSelf(E, DC);
 }
 
 void swift::performStmtDiagnostics(const Stmt *S, DeclContext *DC) {

test/Parse/self_rebinding.swift

@@ -58,3 +58,61 @@ class MyCls {
         something() // this should still refer `MyCls.something`.
     }
 }
+
+// MARK: fix method called 'self' can be confused with regular 'self' https://bugs.swift.org/browse/SR-4559
+
+func funcThatReturnsSomething(_ any: Any) -> Any {
+    any
+}
+
+struct TypeWithSelfMethod {
+    
+    let property = self // expected-warning {{'self' refers to the method 'TypeWithSelfMethod.self', which may be unexpected}} expected-note{{use 'TypeWithSelfMethod.self' to silence this warning}} {{20-20=TypeWithSelfMethod.}}
+    
+    // Existing warning expected, not confusable
+    let property2 = self() // expected-error {{cannot use instance member 'self' within property initializer; property initializers run before 'self' is available}}
+    
+    let propertyFromClosure: () = {
+        print(self) // expected-warning {{'self' refers to the method 'TypeWithSelfMethod.self', which may be unexpected}} expected-note{{use 'TypeWithSelfMethod.self' to silence this warning}} {{15-15=TypeWithSelfMethod.}}
+    }()
+    
+    let propertyFromFunc = funcThatReturnsSomething(self) // expected-warning {{'self' refers to the method 'TypeWithSelfMethod.self', which may be unexpected}} expected-note{{use 'TypeWithSelfMethod.self' to silence this warning}} {{53-53=TypeWithSelfMethod.}}
+    
+    let propertyFromFunc2 = funcThatReturnsSomething(TypeWithSelfMethod.self) // OK
+    
+    func `self`() {
+        
+    }
+}
+
+/// Test fix_unqualified_access_member_named_self doesn't appear for computed var called `self`
+/// it can't currently be referenced as a static member -- unlike a method with the same name
+struct TypeWithSelfComputedVar {
+    
+    let property = self // expected-error {{cannot use instance member 'self' within property initializer; property initializers run before 'self' is available}}
+    
+    let propertyFromClosure: () = {
+        print(self) // expected-error {{cannot use instance member 'self' within property initializer; property initializers run before 'self' is available}}
+    }()
+    
+    let propertyFromFunc = funcThatReturnsSomething(self) // expected-error {{cannot use instance member 'self' within property initializer; property initializers run before 'self' is available}}
+    
+    var `self`: () {
+        ()
+    }
+}
+
+/// Test fix_unqualified_access_member_named_self doesn't appear appear for property called `self`
+/// it can't currently be referenced as a static member -- unlike a method with the same name
+struct TypeWithSelfProperty {
+    
+    let property = self // expected-error {{cannot use instance member 'self' within property initializer; property initializers run before 'self' is available}}
+    
+    let propertyFromClosure: () = {
+        print(self) // expected-error {{cannot use instance member 'self' within property initializer; property initializers run before 'self' is available}}
+    }()
+    
+    let propertyFromFunc = funcThatReturnsSomething(self) // expected-error {{cannot use instance member 'self' within property initializer; property initializers run before 'self' is available}}
+    
+    let `self`: () = ()
+}