Sema: Compute existential member access limitations for storage declarations

Author: AnthonyLatsis

lib/Sema/CSSimplify.cpp

@@ -9878,8 +9878,15 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
       // member access if the member's signature references 'Self'.
       if (instanceTy->isExistentialType() &&
           decl->getDeclContext()->getSelfProtocolDecl()) {
-        if (!isMemberAvailableOnExistential(instanceTy, decl)) {
+        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

@@ -513,8 +513,8 @@ static bool doesMemberHaveUnfulfillableConstraintsWithExistentialBase(
   return false;
 }
 
-bool swift::isMemberAvailableOnExistential(
-    Type baseTy, const ValueDecl *member) {
+ExistentialMemberAccessLimitation
+swift::isMemberAvailableOnExistential(Type baseTy, const ValueDecl *member) {
 
   auto &ctx = member->getASTContext();
   auto existentialSig = ctx.getOpenedExistentialSignature(baseTy);
@@ -525,27 +525,68 @@ bool swift::isMemberAvailableOnExistential(
   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.hasNonCovariantRef()) {
-    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.hasCovariantGenericParamResult() &&
-        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 *,

lib/Sema/OpenedExistentials.h

@@ -81,6 +81,10 @@ class GenericParameterReferenceInfo final {
     return DepMemberTyRefs & pos.value();
   }
 
+  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);
@@ -93,9 +97,7 @@ class GenericParameterReferenceInfo final {
   GenericParameterReferenceInfo &
   operator|=(const GenericParameterReferenceInfo &other);
 
-  explicit operator bool() const {
-    return hasDirectRef() || hasDependentMemberTypeRef();
-  }
+  explicit operator bool() const { return hasRef(); }
 };
 
 /// Find references to the given generic parameter in the type signature of the
@@ -112,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.

lib/Sema/TypeOfReference.cpp

@@ -505,6 +505,9 @@ static bool doesStorageProduceLValue(
   if (!storage->isSetterAccessibleFrom(useDC))
     return false;
 
+  //  if (baseType) {
+  //    isMemberAvailableOnExistential(baseType, storage)
+  //  }
   // If there is no base, or the base is an lvalue, then a reference
   // produces an lvalue.
   if (!baseType || baseType->is<LValueType>())