Merge pull request #77851 from AnthonyLatsis/day-2

Author: AnthonyLatsis

include/swift/AST/Type.h

@@ -190,7 +190,13 @@ enum class ForeignRepresentableKind : uint8_t {
 /// therefore, the result type is in covariant position relative to the function
 /// type.
 struct TypePosition final {
-  enum : uint8_t { Covariant, Contravariant, Invariant, Shape };
+  enum : uint8_t {
+    Covariant = 1 << 0,
+    Contravariant = 1 << 1,
+    Invariant = 1 << 2,
+    Shape = 1 << 3,
+    Last_Position = Shape,
+  };
 
 private:
   decltype(Covariant) kind;
@@ -213,6 +219,10 @@ struct TypePosition final {
 
   operator decltype(kind)() const { return kind; }
 };
+enum : unsigned {
+  NumTypePositions =
+      countBitsUsed(static_cast<unsigned>(TypePosition::Last_Position))
+};
 
 /// Type - This is a simple value object that contains a pointer to a type
 /// class.  This is potentially sugared.  We use this throughout the codebase

lib/Sema/CSSimplify.cpp

@@ -9914,10 +9914,16 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
     const auto isUnsupportedExistentialMemberAccess = [&] {
       // We may not be able to derive a well defined type for an existential
       // member access if the member's signature references 'Self'.
-      if (instanceTy->isExistentialType() &&
-          decl->getDeclContext()->getSelfProtocolDecl()) {
-        if (!isMemberAvailableOnExistential(instanceTy, decl)) {
+      if (instanceTy->isExistentialType()) {
+        switch (isMemberAvailableOnExistential(instanceTy, decl)) {
+        case ExistentialMemberAccessLimitation::Unsupported:
+        // TODO: Write-only accesses are not supported yet.
+        case ExistentialMemberAccessLimitation::WriteOnly:
           return true;
+
+        case ExistentialMemberAccessLimitation::ReadOnly:
+        case ExistentialMemberAccessLimitation::None:
+          break;
         }
       }
 

lib/Sema/OpenedExistentials.cpp

@@ -29,13 +29,10 @@ using namespace swift;
 
 GenericParameterReferenceInfo &
 GenericParameterReferenceInfo::operator|=(const GenericParameterReferenceInfo &other) {
-  hasCovariantSelfResult |= other.hasCovariantSelfResult;
-  if (other.selfRef > selfRef) {
-    selfRef = other.selfRef;
-  }
-  if (other.assocTypeRef > assocTypeRef) {
-    assocTypeRef = other.assocTypeRef;
-  }
+  DirectRefs |= other.DirectRefs;
+  DepMemberTyRefs |= other.DepMemberTyRefs;
+  HasCovariantGenericParamResult |= other.HasCovariantGenericParamResult;
+
   return *this;
 }
 
@@ -296,9 +293,9 @@ findGenericParameterReferencesRec(CanGenericSignature genericSig,
   // A direct reference to 'Self'.
   if (type->is<GenericTypeParamType>()) {
     if (position == TypePosition::Covariant && canBeCovariantResult)
-      return GenericParameterReferenceInfo::forCovariantResult();
+      return GenericParameterReferenceInfo::forCovariantGenericParamResult();
 
-    return GenericParameterReferenceInfo::forSelfRef(position);
+    return GenericParameterReferenceInfo::forDirectRef(position);
   }
 
   if (origParam != openedParam) {
@@ -332,7 +329,7 @@ findGenericParameterReferencesRec(CanGenericSignature genericSig,
   }
 
   // A reference to an associated type rooted on 'Self'.
-  return GenericParameterReferenceInfo::forAssocTypeRef(position);
+  return GenericParameterReferenceInfo::forDependentMemberTypeRef(position);
 }
 
 GenericParameterReferenceInfo
@@ -393,7 +390,7 @@ bool HasSelfOrAssociatedTypeRequirementsRequest::evaluate(
     // For value members, look at their type signatures.
     if (auto valueMember = dyn_cast<ValueDecl>(member)) {
       const auto info = findExistentialSelfReferences(valueMember);
-      if (info.selfRef > TypePosition::Covariant || info.assocTypeRef) {
+      if (info.hasNonCovariantRef() || info.hasDependentMemberTypeRef()) {
         return true;
       }
     }
@@ -516,39 +513,81 @@ static bool doesMemberHaveUnfulfillableConstraintsWithExistentialBase(
   return false;
 }
 
-bool swift::isMemberAvailableOnExistential(
-    Type baseTy, const ValueDecl *member) {
+ExistentialMemberAccessLimitation
+swift::isMemberAvailableOnExistential(Type baseTy, const ValueDecl *member) {
+  auto *dc = member->getDeclContext();
+  if (!dc->getSelfProtocolDecl()) {
+    return ExistentialMemberAccessLimitation::None;
+  }
 
   auto &ctx = member->getASTContext();
   auto existentialSig = ctx.getOpenedExistentialSignature(baseTy);
 
-  auto *dc = member->getDeclContext();
-  ASSERT(dc->getSelfProtocolDecl());
-
   auto origParam = dc->getSelfInterfaceType()->castTo<GenericTypeParamType>();
   auto openedParam = existentialSig.SelfType->castTo<GenericTypeParamType>();
 
+  // An accessor or non-storage member is not available if its interface type
+  // contains a non-covariant reference to a 'Self'-rooted type parameter in the
+  // context of the base type's existential signature.
   auto info = findGenericParameterReferences(
       member, existentialSig.OpenedSig, origParam, openedParam,
       std::nullopt);
 
-  if (info.selfRef > TypePosition::Covariant ||
-      info.assocTypeRef > TypePosition::Covariant) {
-    return false;
-  }
+  auto result = ExistentialMemberAccessLimitation::None;
+  if (!info) {
+    // Nothing to do.
+  } else if (info.hasRef(TypePosition::Invariant)) {
+    // An invariant reference is decisive.
+    result = ExistentialMemberAccessLimitation::Unsupported;
+  } else if (isa<AbstractFunctionDecl>(member)) {
+    // Anything non-covariant is decisive for functions.
+    if (info.hasRef(TypePosition::Contravariant)) {
+      result = ExistentialMemberAccessLimitation::Unsupported;
+    }
+  } else {
+    const auto isGetterUnavailable = info.hasRef(TypePosition::Contravariant);
+    auto isSetterUnavailable = true;
+
+    if (isa<VarDecl>(member)) {
+      // For properties, the setter is unavailable if the interface type has a
+      // covariant reference, which becomes contravariant is the setter.
+      isSetterUnavailable = info.hasRef(TypePosition::Covariant);
+    } else {
+      // For subscripts specifically, we must scan the setter directly because
+      // whether a covariant reference in the interface type becomes
+      // contravariant in the setter depends on the location of the reference
+      // (in the indices or the result type).
+      auto *setter =
+          cast<SubscriptDecl>(member)->getAccessor(AccessorKind::Set);
+      const auto setterInfo = setter ? findGenericParameterReferences(
+                                           setter, existentialSig.OpenedSig,
+                                           origParam, openedParam, std::nullopt)
+                                     : GenericParameterReferenceInfo();
+
+      isSetterUnavailable = setterInfo.hasRef(TypePosition::Contravariant);
+    }
 
-  // FIXME: Appropriately diagnose assignments instead.
-  if (auto *const storageDecl = dyn_cast<AbstractStorageDecl>(member)) {
-    if (info.hasCovariantSelfResult && storageDecl->supportsMutation())
-      return false;
+    if (isGetterUnavailable && isSetterUnavailable) {
+      result = ExistentialMemberAccessLimitation::Unsupported;
+    } else if (isGetterUnavailable) {
+      result = ExistentialMemberAccessLimitation::WriteOnly;
+    } else if (isSetterUnavailable) {
+      result = ExistentialMemberAccessLimitation::ReadOnly;
+    }
   }
 
+  // If the member access is not supported whatsoever, we are done.
+  if (result == ExistentialMemberAccessLimitation::Unsupported)
+    return result;
+
+  // Before proceeding with the result, see if we find a generic requirement
+  // that cannot be satisfied; if we do, the member is unavailable after all.
   if (doesMemberHaveUnfulfillableConstraintsWithExistentialBase(existentialSig,
                                                                 member)) {
-    return false;
+    return ExistentialMemberAccessLimitation::Unsupported;
   }
 
-  return true;
+  return result;
 }
 
 std::optional<std::tuple<GenericTypeParamType *, TypeVariableType *,
@@ -686,8 +725,7 @@ swift::canOpenExistentialCallArgument(ValueDecl *callee, unsigned paramIdx,
       callee, existentialSig.OpenedSig, genericParam,
       existentialSig.SelfType->castTo<GenericTypeParamType>(),
       /*skipParamIdx=*/paramIdx);
-  if (referenceInfo.selfRef > TypePosition::Covariant ||
-      referenceInfo.assocTypeRef > TypePosition::Covariant)
+  if (referenceInfo.hasNonCovariantRef())
     return std::nullopt;
 
   return std::make_tuple(genericParam, paramTypeVar, argTy, adjustments);
@@ -898,4 +936,4 @@ Type swift::typeEraseOpenedArchetypesFromEnvironment(
 
         return Type();
       });
-}
+}

lib/Sema/OpenedExistentials.h

@@ -22,52 +22,82 @@ namespace swift {
 class CanGenericSignature;
 class GenericTypeParamType;
 
-/// Describes the least favorable positions at which a requirement refers
-/// to a given generic parameter in terms of variance, for use in the
-/// is-inheritable and is-available-existential checks.
+/// Stores the variance positions at which a type references a specific
+/// generic parameter.
 class GenericParameterReferenceInfo final {
-  using OptionalTypePosition = OptionalEnum<decltype(TypePosition::Covariant)>;
+  static constexpr unsigned NumTypePositionBits = 4;
+  static_assert(NumTypePositions <= NumTypePositionBits,
+                "Not enough bits to store all cases");
+
+  uint8_t DirectRefs : NumTypePositionBits;
+  uint8_t DepMemberTyRefs : NumTypePositionBits;
+
+  /// Whether there is a reference to the generic parameter at hand in covariant
+  /// result type position. This position is the uncurried interface type of a
+  /// declaration, stipped of any optionality. For example, this is true for
+  /// 'Self' in 'func foo(Int) -> () -> Self?'.
+  bool HasCovariantGenericParamResult;
+
+  GenericParameterReferenceInfo(uint8_t DirectRefs, uint8_t DepMemberTyRefs,
+                                bool HasCovariantGenericParamResult)
+      : DirectRefs(DirectRefs), DepMemberTyRefs(DepMemberTyRefs),
+        HasCovariantGenericParamResult(HasCovariantGenericParamResult) {}
 
 public:
-  /// Whether the uncurried interface type of the declaration, stripped of any
-  /// optionality, is a direct reference to the generic parameter at hand. For
-  /// example, "func foo(x: Int) -> () -> Self?" has a covariant 'Self' result.
-  bool hasCovariantSelfResult;
+  GenericParameterReferenceInfo()
+      : GenericParameterReferenceInfo(0, 0, false) {}
 
-  OptionalTypePosition selfRef;
-  OptionalTypePosition assocTypeRef;
+  /// A direct reference to the generic parameter.
+  static GenericParameterReferenceInfo forDirectRef(TypePosition pos) {
+    return GenericParameterReferenceInfo(pos, 0, false);
+  }
 
-  /// A reference to 'Self'.
-  static GenericParameterReferenceInfo forSelfRef(TypePosition position) {
-    return GenericParameterReferenceInfo(false, position, std::nullopt);
+  /// A direct reference to the generic parameter in covariant result type
+  /// position.
+  static GenericParameterReferenceInfo forCovariantGenericParamResult() {
+    return GenericParameterReferenceInfo(TypePosition::Covariant, 0, true);
   }
 
-  /// A reference to the generic parameter in covariant result position.
-  static GenericParameterReferenceInfo forCovariantResult() {
-    return GenericParameterReferenceInfo(true, TypePosition::Covariant,
-                                         std::nullopt);
+  /// A reference to a dependent member type rooted on the generic parameter.
+  static GenericParameterReferenceInfo
+  forDependentMemberTypeRef(TypePosition pos) {
+    return GenericParameterReferenceInfo(0, pos, false);
   }
 
-  /// A reference to 'Self' through an associated type.
-  static GenericParameterReferenceInfo forAssocTypeRef(TypePosition position) {
-    return GenericParameterReferenceInfo(false, std::nullopt, position);
+  bool hasDirectRef(std::optional<TypePosition> pos = std::nullopt) const {
+    if (!pos) {
+      return DirectRefs;
+    }
+
+    return DirectRefs & pos.value();
   }
 
-  GenericParameterReferenceInfo &operator|=(const GenericParameterReferenceInfo &other);
+  bool hasDependentMemberTypeRef(
+      std::optional<TypePosition> pos = std::nullopt) const {
+    if (!pos) {
+      return DepMemberTyRefs;
+    }
 
-  explicit operator bool() const {
-    return hasCovariantSelfResult || selfRef || assocTypeRef;
+    return DepMemberTyRefs & pos.value();
   }
 
-  GenericParameterReferenceInfo()
-      : hasCovariantSelfResult(false), selfRef(std::nullopt),
-        assocTypeRef(std::nullopt) {}
-
-private:
-  GenericParameterReferenceInfo(bool hasCovariantSelfResult, OptionalTypePosition selfRef,
-                    OptionalTypePosition assocTypeRef)
-      : hasCovariantSelfResult(hasCovariantSelfResult), selfRef(selfRef),
-        assocTypeRef(assocTypeRef) {}
+  bool hasRef(std::optional<TypePosition> pos = std::nullopt) const {
+    return hasDirectRef(pos) || hasDependentMemberTypeRef(pos);
+  }
+
+  bool hasNonCovariantRef() const {
+    const uint8_t notCovariant = ~TypePosition::Covariant;
+    return (DirectRefs & notCovariant) || (DepMemberTyRefs & notCovariant);
+  }
+
+  bool hasCovariantGenericParamResult() const {
+    return HasCovariantGenericParamResult;
+  }
+
+  GenericParameterReferenceInfo &
+  operator|=(const GenericParameterReferenceInfo &other);
+
+  explicit operator bool() const { return hasRef(); }
 };
 
 /// Find references to the given generic parameter in the type signature of the
@@ -84,12 +114,23 @@ findGenericParameterReferences(const ValueDecl *value, CanGenericSignature sig,
 /// Find references to 'Self' in the type signature of this declaration.
 GenericParameterReferenceInfo findExistentialSelfReferences(const ValueDecl *value);
 
-/// Determine whether referencing the given member on the
-/// given existential base type is supported. This is the case only if the
-/// type of the member, spelled in the context of \p baseTy, does not contain
-/// 'Self' or 'Self'-rooted dependent member types in non-covariant position.
-bool isMemberAvailableOnExistential(Type baseTy,
-                                    const ValueDecl *member);
+/// Describes the limitation on accessing a protocol member on a value of
+/// existential type.
+enum class ExistentialMemberAccessLimitation : uint8_t {
+  /// The member can be freely accessed on the existential.
+  None,
+  /// The storage member is available only for reads.
+  ReadOnly,
+  /// The storage member is available only for writes.
+  WriteOnly,
+  /// Accessing the member on the existential is not supported.
+  Unsupported,
+};
+
+/// Compute the limitations on accessing the given member on a value of the
+/// given existential base type.
+ExistentialMemberAccessLimitation
+isMemberAvailableOnExistential(Type baseTy, const ValueDecl *member);
 
 /// Flags that should be applied to the existential argument type after
 /// opening.
@@ -138,4 +179,4 @@ Type typeEraseOpenedArchetypesFromEnvironment(Type type,
 
 } // end namespace swift
 
-#endif
+#endif