[MiscDiagnostics] Produce warnings about confusable self iff its explicit

Restrict the warning to diagnose only explicit instances of `self` reference
that do not mention the parent type via dot syntax e.g. `MyStruct.self`.

Resolves: SR-15897
Resolves: SR-15691
Resolves: rdar://90624344
(cherry picked from commit e52c3a0)

Author: xedin

lib/Sema/MiscDiagnostics.cpp

@@ -4717,31 +4717,43 @@ static void diagUnqualifiedAccessToMethodNamedSelf(const Expr *E,
       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();
-              if (!baseType->getEnumOrBoundGenericEnum()) {
-                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);
-              }
-            }
-          }
-        }
+      auto *DRE = dyn_cast<DeclRefExpr>(E);
+      // If this is not an explicit 'self' reference, let's keep searching.
+      if (!DRE || DRE->isImplicit())
+        return {true, E};
+
+      // If this not 'self' or it's not a function reference, it's unrelated.
+      if (!(DRE->getDecl()->getBaseName() == Ctx.Id_self &&
+            DRE->getType()->is<AnyFunctionType>()))
+        return {true, E};
+
+      auto typeContext = DC->getInnermostTypeContext();
+      // Use of 'self' in enums is not confusable.
+      if (!typeContext || typeContext->getSelfEnumDecl())
+        return {true, E};
+
+      // self(...) is not easily confusable.
+      if (auto *parentExpr = Parent.getAsExpr()) {
+        if (isa<CallExpr>(parentExpr))
+          return {true, E};
+
+        // Explicit call to a static method 'self' of some type is not
+        // confusable.
+        if (isa<DotSyntaxCallExpr>(parentExpr) && !parentExpr->isImplicit())
+          return {true, E};
       }
 
+      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};
     }
   };

test/Parse/self_rebinding.swift

@@ -126,3 +126,8 @@ enum EnumCaseNamedSelf {
         self = EnumCaseNamedSelf.`self` // OK
     }
 }
+
+// rdar://90624344 - warning about `self` which cannot be fixed because it's located in implicitly generated code.
+struct TestImplicitSelfUse : Codable {
+  let `self`: Int // Ok
+}