Merge pull request swiftlang#34523 from xedin/static-member-lookup-on-protocol

[SE-0299][TypeChecker] Allow static member references on protocol metatypes in generic contexts

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -1902,6 +1902,12 @@ ERROR(type_does_not_conform_owner,none,
 ERROR(type_does_not_conform_in_decl_ref,none,
       "referencing %0 %1 on %2 requires that %3 conform to %4",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))
+ERROR(contextual_member_ref_on_protocol_requires_self_requirement,none,
+      "contextual member reference to %0 %1 requires "
+      "'Self' constraint in the protocol extension",
+      (DescriptiveDeclKind, DeclName))
+NOTE(missing_sametype_requirement_on_self,none,
+      "missing same-type requirement on 'Self'", ())
 ERROR(type_does_not_conform_anyobject_in_decl_ref,none,
       "referencing %0 %1 on %2 requires that %3 be a class type",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))

include/swift/Sema/CSBindings.h

@@ -276,8 +276,20 @@ struct PotentialBindings {
 
   /// Determine whether the set of bindings is non-empty.
   explicit operator bool() const {
+    return hasViableBindings()|| isDirectHole();
+  }
+
+  /// Determine whether this set has any "viable" (or non-hole) bindings.
+  ///
+  /// A viable binding could be - a direct or transitive binding
+  /// inferred from a constraint, literal binding, or defaltable
+  /// binding.
+  ///
+  /// A hole is not considered a viable binding since it doesn't
+  /// add any new type information to constraint system.
+  bool hasViableBindings() const {
     return !Bindings.empty() || getNumViableLiteralBindings() > 0 ||
-           !Defaults.empty() || isDirectHole();
+           !Defaults.empty();
   }
 
   /// Determines whether this type variable could be `nil`,

include/swift/Sema/CSFix.h

@@ -307,6 +307,11 @@ enum class FixKind : uint8_t {
   /// convertible, but runtime does not support such convertions. e.g.
   /// function type casts.
   AllowUnsupportedRuntimeCheckedCast,
+
+  /// Allow reference to a static member on a protocol metatype
+  /// even though result type of the reference doesn't conform
+  /// to an expected protocol.
+  AllowInvalidStaticMemberRefOnProtocolMetatype,
 };
 
 class ConstraintFix {
@@ -2307,6 +2312,29 @@ class AllowUnsupportedRuntimeCheckedCast final
           CheckedCastKind kind, ConstraintLocator *locator);
 };
 
+class AllowInvalidStaticMemberRefOnProtocolMetatype final
+    : public ConstraintFix {
+  AllowInvalidStaticMemberRefOnProtocolMetatype(ConstraintSystem &cs,
+                                                ConstraintLocator *locator)
+      : ConstraintFix(cs,
+                      FixKind::AllowInvalidStaticMemberRefOnProtocolMetatype,
+                      locator) {}
+
+  public:
+  std::string getName() const override {
+    return "allow invalid static member reference on a protocol metatype";
+  }
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowInvalidStaticMemberRefOnProtocolMetatype *
+  create(ConstraintSystem &cs, ConstraintLocator *locator);
+};
+
 } // end namespace constraints
 } // end namespace swift
 

include/swift/Sema/Constraint.h

@@ -177,6 +177,16 @@ enum class ConstraintKind : char {
   /// - Handled specially by binding inference, specifically contributes
   ///   to the bindings only if there are no contextual types available.
   DefaultClosureType,
+  /// The first type represents a result of an unresolved member chain,
+  /// and the second type is its base type. This constraint acts almost
+  /// like `Equal` but also enforces following semantics:
+  ///
+  /// - It's possible to infer a base from a result type by looking through
+  ///   this constraint, but it's only solved when both types are bound.
+  ///
+  /// - If base is a protocol metatype, this constraint becomes a conformance
+  ///   check instead of an equality.
+  UnresolvedMemberChainBase,
 };
 
 /// Classification of the different kinds of constraints.
@@ -570,6 +580,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::OneWayEqual:
     case ConstraintKind::OneWayBindParam:
     case ConstraintKind::DefaultClosureType:
+    case ConstraintKind::UnresolvedMemberChainBase:
       return ConstraintClassification::Relational;
 
     case ConstraintKind::ValueMember:

include/swift/Sema/ConstraintSystem.h

@@ -1462,7 +1462,11 @@ struct MemberLookupResult {
     UR_ReferenceWritableKeyPathOnMutatingMember,
 
     /// This is a KeyPath whose root type is AnyObject
-    UR_KeyPathWithAnyObjectRootType
+    UR_KeyPathWithAnyObjectRootType,
+
+    /// This is a static member being access through a protocol metatype
+    /// but its result type doesn't conform to this protocol.
+    UR_InvalidStaticMemberOnProtocolMetatype,
   };
 
   /// This is a list of considered (but rejected) candidates, along with a
@@ -4570,6 +4574,12 @@ class ConstraintSystem {
                                         TypeMatchOptions flags,
                                         ConstraintLocatorBuilder locator);
 
+  /// Simplify an equality constraint between result and base types of
+  /// an unresolved member chain.
+  SolutionKind simplifyUnresolvedMemberChainBaseConstraint(
+      Type first, Type second, TypeMatchOptions flags,
+      ConstraintLocatorBuilder locator);
+
   /// Simplify a conversion constraint by applying the given
   /// reduction rule, which is known to apply at the outermost level.
   SolutionKind simplifyRestrictedConstraintImpl(
@@ -5531,6 +5541,11 @@ bool hasExplicitResult(ClosureExpr *closure);
 void performSyntacticDiagnosticsForTarget(
     const SolutionApplicationTarget &target, bool isExprStmt);
 
+/// Given a member of a protocol, check whether `Self` type of that
+/// protocol is contextually bound to some concrete type via same-type
+/// generic requirement and if so return that type or null type otherwise.
+Type getConcreteReplacementForProtocolSelfType(ValueDecl *member);
+
 } // end namespace constraints
 
 template<typename ...Args>

lib/Sema/CSApply.cpp

@@ -1166,6 +1166,38 @@ namespace {
         baseIsInstance = false;
         isExistentialMetatype = baseMeta->is<ExistentialMetatypeType>();
         baseTy = baseMeta->getInstanceType();
+
+        // A valid reference to a static member (computed property or a method)
+        // declared on a protocol is only possible if result type conforms to
+        // that protocol, otherwise it would be impossible to find a witness to
+        // use.
+        // Such means that (for valid references) base expression here could be
+        // adjusted to  point to a type conforming to a protocol as-if reference
+        // has originated directly from it e.g.
+        //
+        // \code
+        // protocol P {}
+        // struct S : P {}
+        //
+        // extension P {
+        //   static var foo: S { S() }
+        // }
+        //
+        // _ = P.foo
+        // \endcode
+        //
+        // Here `P.foo` would be replaced with `S.foo`
+        if (!isExistentialMetatype && baseTy->is<ProtocolType>() &&
+            member->isStatic()) {
+          auto selfParam =
+              overload.openedFullType->castTo<FunctionType>()->getParams()[0];
+
+          Type baseTy =
+              simplifyType(selfParam.getPlainType())->getMetatypeInstanceType();
+
+          base = TypeExpr::createImplicitHack(base->getLoc(), baseTy, context);
+          cs.cacheType(base);
+        }
       }
 
       // Build a member reference.

lib/Sema/CSBindings.cpp

@@ -57,6 +57,33 @@ bool PotentialBinding::isViableForJoin() const {
 }
 
 bool PotentialBindings::isDelayed() const {
+  if (auto *locator = TypeVar->getImpl().getLocator()) {
+    if (locator->isLastElement<LocatorPathElt::MemberRefBase>()) {
+      // If first binding is a "fallback" to a protocol type,
+      // it means that this type variable should be delayed
+      // until it either gains more contextual information, or
+      // there are no other type variables to attempt to make
+      // forward progress.
+      if (Bindings.empty())
+        return true;
+
+
+      if (Bindings[0].BindingType->is<ProtocolType>())
+        return true;
+    }
+
+    // Since force unwrap preserves l-valueness, resulting
+    // type variable has to be delayed until either l-value
+    // binding becomes available or there are no other
+    // variables to attempt.
+    if (locator->directlyAt<ForceValueExpr>() &&
+        TypeVar->getImpl().canBindToLValue()) {
+      return llvm::none_of(Bindings, [](const PotentialBinding &binding) {
+        return binding.BindingType->is<LValueType>();
+      });
+    }
+  }
+
   if (isHole()) {
     auto *locator = TypeVar->getImpl().getLocator();
     assert(locator && "a hole without locator?");
@@ -98,19 +125,6 @@ bool PotentialBindings::isDelayed() const {
     });
   }
 
-  if (auto *locator = TypeVar->getImpl().getLocator()) {
-    // Since force unwrap preserves l-valueness, resulting
-    // type variable has to be delayed until either l-value
-    // binding becomes available or there are no other
-    // variables to attempt.
-    if (locator->directlyAt<ForceValueExpr>() &&
-        TypeVar->getImpl().canBindToLValue()) {
-      return llvm::none_of(Bindings, [](const PotentialBinding &binding) {
-        return binding.BindingType->is<LValueType>();
-      });
-    }
-  }
-
   return !DelayedBy.empty();
 }
 
@@ -140,6 +154,25 @@ bool PotentialBindings::isPotentiallyIncomplete() const {
   if (!locator)
     return false;
 
+  if (locator->isLastElement<LocatorPathElt::MemberRefBase>() &&
+      !Bindings.empty()) {
+    // If the base of the unresolved member reference like `.foo`
+    // couldn't be resolved we'd want to bind it to a hole at the
+    // very last moment possible, just like generic parameters.
+    if (isHole())
+      return true;
+
+    auto &binding = Bindings.front();
+    // If base type of a member chain is inferred to be a protocol type,
+    // let's consider this binding set to be potentially incomplete since
+    // that's done as a last resort effort at resolving first member.
+    if (auto *constraint = binding.getSource()) {
+      if (binding.BindingType->is<ProtocolType>() &&
+          constraint->getKind() == ConstraintKind::ConformsTo)
+        return true;
+    }
+  }
+
   if (locator->isLastElement<LocatorPathElt::UnresolvedMemberChainResult>()) {
     // If subtyping is allowed and this is a result of an implicit member chain,
     // let's delay binding it to an optional until its object type resolved too or
@@ -159,12 +192,6 @@ bool PotentialBindings::isPotentiallyIncomplete() const {
   }
 
   if (isHole()) {
-    // If the base of the unresolved member reference like `.foo`
-    // couldn't be resolved we'd want to bind it to a hole at the
-    // very last moment possible, just like generic parameters.
-    if (locator->isLastElement<LocatorPathElt::MemberRefBase>())
-      return true;
-
     // Delay resolution of the code completion expression until
     // the very end to give it a chance to be bound to some
     // contextual type even if it's a hole.
@@ -408,6 +435,50 @@ void PotentialBindings::finalize(
         &inferredBindings) {
   inferTransitiveProtocolRequirements(inferredBindings);
   inferTransitiveBindings(inferredBindings);
+
+  if (auto *locator = TypeVar->getImpl().getLocator()) {
+    if (locator->isLastElement<LocatorPathElt::MemberRefBase>()) {
+      // If this is a base of an unresolved member chain, as a last
+      // resort effort let's infer base to be a protocol type based
+      // on contextual conformance requirements.
+      //
+      // This allows us to find solutions in cases like this:
+      //
+      // \code
+      // func foo<T: P>(_: T) {}
+      // foo(.bar) <- `.bar` should be a static member of `P`.
+      // \endcode
+      if (!hasViableBindings() && TransitiveProtocols.hasValue()) {
+        for (auto *constraint : *TransitiveProtocols) {
+          auto protocolTy = constraint->getSecondType();
+          addPotentialBinding(
+              {protocolTy, AllowedBindingKind::Exact, constraint});
+        }
+      }
+    }
+
+    if (CS.shouldAttemptFixes() &&
+        locator->isLastElement<LocatorPathElt::UnresolvedMemberChainResult>()) {
+      // Let's see whether this chain is valid, if it isn't then to avoid
+      // diagnosing the same issue multiple different ways, let's infer
+      // result of the chain to be a hole.
+      auto *resultExpr =
+          castToExpr<UnresolvedMemberChainResultExpr>(locator->getAnchor());
+      auto *baseLocator = CS.getConstraintLocator(
+          resultExpr->getChainBase(), ConstraintLocator::UnresolvedMember);
+
+      if (CS.hasFixFor(
+              baseLocator,
+              FixKind::AllowInvalidStaticMemberRefOnProtocolMetatype)) {
+        CS.recordPotentialHole(TypeVar);
+        // Clear all of the previously collected bindings which are inferred
+        // from inside of a member chain.
+        Bindings.remove_if([](const PotentialBinding &binding) {
+          return binding.Kind == AllowedBindingKind::Supertypes;
+        });
+      }
+    }
+  }
 }
 
 PotentialBindings::BindingScore
@@ -451,6 +522,14 @@ Optional<PotentialBindings> ConstraintSystem::determineBestBindings() {
   auto isViableForRanking = [this](const PotentialBindings &bindings) -> bool {
     auto *typeVar = bindings.TypeVar;
 
+    // Type variable representing a base of unresolved member chain should
+    // always be considered viable for ranking since it's allow to infer
+    // types from transitive protocol requirements.
+    if (auto *locator = typeVar->getImpl().getLocator()) {
+      if (locator->isLastElement<LocatorPathElt::MemberRefBase>())
+        return true;
+    }
+
     // If type variable is marked as a potential hole there is always going
     // to be at least one binding available for it.
     if (shouldAttemptFixes() && typeVar->getImpl().canBindToHole())
@@ -967,6 +1046,13 @@ PotentialBindings::inferFromRelational(Constraint *constraint) {
       if (!BGT || !isKnownKeyPathDecl(CS.getASTContext(), BGT->getDecl()))
         return None;
     }
+
+    // Don't allow a protocol type to get propagated from the base to the result
+    // type of a chain, Result should always be a concrete type which conforms
+    // to the protocol inferred for the base.
+    if (constraint->getKind() == ConstraintKind::UnresolvedMemberChainBase &&
+        kind == AllowedBindingKind::Subtypes && type->is<ProtocolType>())
+      return None;
   }
 
   // If the source of the binding is 'OptionalObject' constraint
@@ -1063,7 +1149,8 @@ PotentialBindings::inferFromRelational(Constraint *constraint) {
 
     case ConstraintKind::Bind:
     case ConstraintKind::BindParam:
-    case ConstraintKind::Equal: {
+    case ConstraintKind::Equal:
+    case ConstraintKind::UnresolvedMemberChainBase: {
       EquivalentTo.insert({bindingTypeVar, constraint});
       break;
     }
@@ -1118,7 +1205,8 @@ void PotentialBindings::infer(Constraint *constraint) {
   case ConstraintKind::Conversion:
   case ConstraintKind::ArgumentConversion:
   case ConstraintKind::OperatorArgumentConversion:
-  case ConstraintKind::OptionalObject: {
+  case ConstraintKind::OptionalObject:
+  case ConstraintKind::UnresolvedMemberChainBase: {
     auto binding = inferFromRelational(constraint);
     if (!binding)
       break;