Merge pull request #77302 from xedin/se-0438-enhancements

[Frontend/ConstraintSystem] NFC: SE-0438 implementation enhancements

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -666,6 +666,13 @@ ERROR(expr_keypath_mutating_getter,none,
 ERROR(expr_keypath_static_member,none,
       "%select{key path|dynamic key path member lookup}1 cannot refer to static member %0",
       (const ValueDecl *, bool))
+ERROR(keypath_static_member_access_from_unsupported_module,none,
+     "%select{key path|dynamic key path member lookup}3 cannot refer "
+     "to static member %1 of type %0 from module %2",
+      (Type, const ValueDecl *, const ModuleDecl *, bool))
+NOTE(keypath_static_member_access_from_unsupported_module_note,none,
+     "rebuild %0 to enable static member use in key paths",
+     (const ModuleDecl *))
 ERROR(expr_keypath_enum_case,none,
       "%select{key path|dynamic key path member lookup}1 cannot refer to enum case %0",
       (const ValueDecl *, bool))

include/swift/Basic/Features.def

@@ -235,7 +235,6 @@ EXPERIMENTAL_FEATURE(MacrosOnImports, true)
 EXPERIMENTAL_FEATURE(TupleConformances, false)
 EXPERIMENTAL_FEATURE(FullTypedThrows, false)
 EXPERIMENTAL_FEATURE(SameElementRequirements, false)
-EXPERIMENTAL_FEATURE(KeyPathWithStaticMembers, false)
 
 // Whether to enable @_used and @_section attributes
 EXPERIMENTAL_FEATURE(SymbolLinkageMarkers, true)

include/swift/Sema/CSFix.h

@@ -2026,9 +2026,11 @@ class TreatKeyPathSubscriptIndexAsHashable final : public ConstraintFix {
 
 class AllowInvalidRefInKeyPath final : public ConstraintFix {
   enum RefKind {
+    // Allow invalid references to static members i.e. on instance of a type.
+    StaticMember,
     // Allow a reference to a static member as a key path component if it is
     // declared in a module with built with Swift 6.0 compiler version or older.
-    StaticMember,
+    UnsupportedStaticMember,
     // Allow a reference to a declaration with mutating getter as
     // a key path component.
     MutatingGetter,
@@ -2054,7 +2056,10 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
   std::string getName() const override {
     switch (Kind) {
     case RefKind::StaticMember:
-      return "allow reference to a static member as a key path component";
+      return "allow reference to a static member on invalid base in key path "
+             "context";
+    case RefKind::UnsupportedStaticMember:
+      return "allow unsupported static member reference";
     case RefKind::MutatingGetter:
       return "allow reference to a member with mutating getter as a key "
              "path component";

lib/AST/FeatureSet.cpp

@@ -198,7 +198,6 @@ UNINTERESTING_FEATURE(GroupActorErrors)
 UNINTERESTING_FEATURE(SameElementRequirements)
 UNINTERESTING_FEATURE(UnspecifiedMeansMainActorIsolated)
 UNINTERESTING_FEATURE(GlobalActorInferenceCutoff)
-UNINTERESTING_FEATURE(KeyPathWithStaticMembers)
 UNINTERESTING_FEATURE(GenerateForceToMainActorThunks)
 
 static bool usesFeatureSendingArgsAndResults(Decl *decl) {

lib/Sema/CSDiagnostics.cpp

@@ -6337,28 +6337,33 @@ SourceLoc InvalidMemberRefInKeyPath::getLoc() const {
 }
 
 bool InvalidStaticMemberRefInKeyPath::diagnoseAsError() {
-  auto *KPE = getAsExpr<KeyPathExpr>(getRawAnchor());
-  auto rootTyRepr = KPE->getExplicitRootType();
-  auto isProtocol = getBaseType()->isExistentialType();
-
-  if (!getConstraintSystem().getASTContext().LangOpts.hasFeature(
-          Feature::KeyPathWithStaticMembers)) {
-    emitDiagnostic(diag::expr_keypath_static_member, getMember(),
-                   isForKeyPathDynamicMemberLookup());
-  } else {
-    if (rootTyRepr && !isProtocol) {
-      emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
-                     DeclNameRef(getMember()->getName()))
-          .fixItInsert(rootTyRepr->getEndLoc(), ".Type");
-    } else {
+  auto diagnostic =
       emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
                      DeclNameRef(getMember()->getName()));
+
+  // Suggest adding `.Type` to an explicit root if possible.
+  if (auto *keyPath = getAsExpr<KeyPathExpr>(getRawAnchor())) {
+    if (auto *explicitRoot = keyPath->getExplicitRootType()) {
+      if (explicitRoot && !getBaseType()->isExistentialType())
+        diagnostic.fixItInsert(explicitRoot->getEndLoc(), ".Type");
     }
   }
 
   return true;
 }
 
+bool UnsupportedStaticMemberRefInKeyPath::diagnoseAsError() {
+  auto *member = getMember();
+  auto *module = member->getDeclContext()->getParentModule();
+
+  emitDiagnostic(diag::keypath_static_member_access_from_unsupported_module,
+                 BaseType->getMetatypeInstanceType(), member, module,
+                 getLocator()->isForKeyPathDynamicMemberLookup());
+  emitDiagnostic(
+      diag::keypath_static_member_access_from_unsupported_module_note, module);
+  return true;
+}
+
 bool InvalidEnumCaseRefInKeyPath::diagnoseAsError() {
   emitDiagnostic(diag::expr_keypath_enum_case, getMember(),
                  isForKeyPathDynamicMemberLookup());

lib/Sema/CSDiagnostics.h

@@ -1767,13 +1767,31 @@ class InvalidStaticMemberRefInKeyPath final : public InvalidMemberRefInKeyPath {
   InvalidStaticMemberRefInKeyPath(const Solution &solution, Type baseType,
                                   ValueDecl *member, ConstraintLocator *locator)
       : InvalidMemberRefInKeyPath(solution, member, locator),
-        BaseType(baseType->getRValueType()) {}
+        BaseType(resolveType(baseType)->getRValueType()) {}
 
   Type getBaseType() const { return BaseType; }
 
   bool diagnoseAsError() override;
 };
 
+/// Diagnose an attempt to reference a static member from an unsupported module.
+///
+/// Only modules built either from source with 6.1+ compiler or
+/// from .swiftinterface that was generated by 6.1+ compiler are supported.
+class UnsupportedStaticMemberRefInKeyPath final
+    : public InvalidMemberRefInKeyPath {
+  Type BaseType;
+
+public:
+  UnsupportedStaticMemberRefInKeyPath(const Solution &solution, Type baseType,
+                                      ValueDecl *member,
+                                      ConstraintLocator *locator)
+      : InvalidMemberRefInKeyPath(solution, member, locator),
+        BaseType(resolveType(baseType)->getRValueType()) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnose an attempt to reference an enum case as a key path component
 /// e.g.
 ///

lib/Sema/CSFix.cpp

@@ -1231,7 +1231,15 @@ bool AllowInvalidRefInKeyPath::diagnose(const Solution &solution,
                                         bool asNote) const {
   switch (Kind) {
   case RefKind::StaticMember: {
-    return false;
+    InvalidStaticMemberRefInKeyPath failure(solution, BaseType, Member,
+                                            getLocator());
+    return failure.diagnose(asNote);
+  }
+
+  case RefKind::UnsupportedStaticMember: {
+    UnsupportedStaticMemberRefInKeyPath failure(solution, BaseType, Member,
+                                                getLocator());
+    return failure.diagnose(asNote);
   }
 
   case RefKind::EnumCase: {
@@ -1281,12 +1289,23 @@ AllowInvalidRefInKeyPath *
 AllowInvalidRefInKeyPath::forRef(ConstraintSystem &cs, Type baseType,
                                  ValueDecl *member,
                                  ConstraintLocator *locator) {
+  if (member->isStatic() && !isa<FuncDecl>(member)) {
+    // References to static members are supported only for modules that
+    // are built with 6.1+ compilers, libraries produced by earlier
+    // compilers don't have required symbols.
+    if (auto *module = member->getDeclContext()->getParentModule()) {
+      if (module->isBuiltFromInterface() &&
+          module->getSwiftInterfaceCompilerVersion() <
+              llvm::VersionTuple(6, 1)) {
+        return AllowInvalidRefInKeyPath::create(
+            cs, baseType, RefKind::UnsupportedStaticMember, member, locator);
+      }
+    }
 
-  if (!cs.getASTContext().LangOpts.hasFeature(
-          Feature::KeyPathWithStaticMembers) &&
-      member->isStatic())
-    return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::StaticMember,
-                                            member, locator);
+    if (!baseType->getRValueType()->is<AnyMetatypeType>())
+      return AllowInvalidRefInKeyPath::create(
+          cs, baseType, RefKind::StaticMember, member, locator);
+  }
 
   // Referencing (instance or static) methods in key path is
   // not currently allowed.

test/Interpreter/keypath.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-feature -Xfrontend KeyPathWithStaticMembers) | %FileCheck %s
+// RUN: %target-run-simple-swift | %FileCheck %s
 
 // REQUIRES: asserts
 // REQUIRES: executable_test

test/Interpreter/static_keypaths.swift

@@ -2,13 +2,13 @@
 // RUN: split-file %s %t/src
 
 /// Build LibA
-// RUN: %host-build-swift %t/src/LibA.swift -swift-version 5 -enable-experimental-feature KeyPathWithStaticMembers -emit-module -emit-library -enable-library-evolution -module-name LibA -o %t/%target-library-name(LibA) -emit-module-interface-path %t/LibA.swiftinterface
+// RUN: %host-build-swift %t/src/LibA.swift -swift-version 5 -emit-module -emit-library -enable-library-evolution -module-name LibA -o %t/%target-library-name(LibA) -emit-module-interface-path %t/LibA.swiftinterface
 
 // Build LibB
-// RUN: %target-build-swift %t/src/LibB.swift -I %t -L %t -l LibA -swift-version 5 -enable-experimental-feature KeyPathWithStaticMembers -emit-module -emit-library -module-name LibB -o %t/%target-library-name(LibB)
+// RUN: %target-build-swift %t/src/LibB.swift -I %t -L %t -l LibA -swift-version 5 -emit-module -emit-library -module-name LibB -o %t/%target-library-name(LibB)
 
 // Build LibC
-// RUN: %target-build-swift %t/src/LibC.swift -I %t -L %t -l LibA -swift-version 5 -enable-experimental-feature KeyPathWithStaticMembers -emit-module -emit-library -module-name LibC -o %t/%target-library-name(LibC)
+// RUN: %target-build-swift %t/src/LibC.swift -I %t -L %t -l LibA -swift-version 5 -emit-module -emit-library -module-name LibC -o %t/%target-library-name(LibC)
 
 // Build & run main.swift
 // RUN: %target-build-swift -I %t -L %t -l LibA -l LibB -l LibC %t/src/main.swift -o %t/a.out

test/SILGen/keypaths.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-emit-silgen -enable-experimental-feature KeyPathWithStaticMembers -target %target-swift-5.1-abi-triple -disable-experimental-parser-round-trip -parse-stdlib -module-name keypaths %s | %FileCheck %s
+// RUN: %target-swift-emit-silgen -target %target-swift-5.1-abi-triple -disable-experimental-parser-round-trip -parse-stdlib -module-name keypaths %s | %FileCheck %s
 // FIXME: Remove '-disable-experimental-parser-round-trip'.
 
 // REQUIRES: asserts