[NCGenerics] remove arg from isNoncopyable(DC)

It should be the responsibility of callers to map the type to a
contextual type, as needed. When it's not possible or repetitive to do
so, there is a special-purpose function `isInterfaceTypeNoncopyable` for
 Sema.

Author: kavon

include/swift/AST/Types.h

@@ -650,21 +650,12 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   bool isPlaceholder();
 
-  /// Returns true if this type lacks conformance to Copyable in the context,
-  /// if provided.
-  bool isNoncopyable(GenericEnvironment *env = nullptr);
-  bool isNoncopyable(const DeclContext *dc) {
-    assert(dc);
-    return isNoncopyable(dc->getGenericEnvironmentOfContext());
-  };
+  /// Returns true if this contextual type does not satisfy a conformance to
+  /// Copyable.
+  bool isNoncopyable();
 
-  /// Returns true if this type conforms to Escapable in the context,
-  /// if provided.
-  bool isEscapable(GenericEnvironment *env = nullptr);
-  bool isEscapable(const DeclContext *dc) {
-    assert(dc);
-    return isEscapable(dc->getGenericEnvironmentOfContext());
-  };
+  /// Returns true if this contextual type satisfies a conformance to Escapable.
+  bool isEscapable();
 
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }

lib/AST/Type.cpp

@@ -178,8 +178,7 @@ static bool alwaysNoncopyable(Type ty) {
 }
 
 /// Preprocesses a type before querying whether it conforms to an invertible.
-static CanType preprocessTypeForInvertibleQuery(GenericEnvironment *env,
-                                                Type orig) {
+static CanType preprocessTypeForInvertibleQuery(Type orig) {
   Type type = orig;
 
   // Strip off any StorageType wrapper.
@@ -189,31 +188,34 @@ static CanType preprocessTypeForInvertibleQuery(GenericEnvironment *env,
   if (auto wrapper = type->getAs<SILMoveOnlyWrappedType>())
     type = wrapper->getInnerType();
 
-  // Turn any type parameters into archetypes.
-  if (env)
-    if (!type->hasArchetype() || type->hasOpenedExistential())
-      type = GenericEnvironment::mapTypeIntoContext(env, type);
+  // Pack expansions such as `repeat T` themselves do not have conformances,
+  // so check its pattern type for conformance.
+  if (auto *pet = type->getAs<PackExpansionType>()) {
+    type = pet->getPatternType()->getCanonicalType();
+  }
 
   // Strip @lvalue and canonicalize.
   auto canType = type->getRValueType()->getCanonicalType();
   return canType;
 }
 
 /// \returns true iff this type lacks conformance to Copyable.
-bool TypeBase::isNoncopyable(GenericEnvironment *env) {
-  auto canType = preprocessTypeForInvertibleQuery(env, this);
+bool TypeBase::isNoncopyable() {
+  auto canType = preprocessTypeForInvertibleQuery(this);
   auto &ctx = canType->getASTContext();
 
   // for legacy-mode queries that are not dependent on conformances to Copyable
   if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
     return alwaysNoncopyable(canType);
 
+  assert(!hasTypeParameter()
+             && "requires a contextual type; use mapTypeIntoContext");
   IsNoncopyableRequest request{canType};
   return evaluateOrDefault(ctx.evaluator, request, /*default=*/true);
 }
 
-bool TypeBase::isEscapable(GenericEnvironment *env) {
-  auto canType = preprocessTypeForInvertibleQuery(env, this);
+bool TypeBase::isEscapable() {
+  auto canType = preprocessTypeForInvertibleQuery(this);
   auto &ctx = canType->getASTContext();
 
   // for legacy-mode queries that are not dependent on conformances to Escapable
@@ -224,6 +226,8 @@ bool TypeBase::isEscapable(GenericEnvironment *env) {
       return true;
   }
 
+  assert(!hasTypeParameter()
+    && "requires a contextual type; use mapTypeIntoContext");
   IsEscapableRequest request{canType};
   return evaluateOrDefault(ctx.evaluator, request, /*default=*/false);
 }

lib/ClangImporter/ClangImporter.cpp

@@ -5545,10 +5545,11 @@ makeBaseClassMemberAccessors(DeclContext *declContext,
                              AbstractStorageDecl *baseClassVar) {
   auto &ctx = declContext->getASTContext();
   auto computedType = computedVar->getInterfaceType();
+  auto contextTy = declContext->mapTypeIntoContext(computedType);
 
   // Use 'address' or 'mutableAddress' accessors for non-copyable
   // types, unless the base accessor returns it by value.
-  bool useAddress = computedType->isNoncopyable(declContext) &&
+  bool useAddress = contextTy->isNoncopyable() &&
                     (baseClassVar->getReadImpl() == ReadImplKind::Stored ||
                      baseClassVar->getAccessor(AccessorKind::Address));
 
@@ -5699,9 +5700,11 @@ cloneBaseMemberDecl(ValueDecl *decl, DeclContext *newContext) {
   }
 
   if (auto subscript = dyn_cast<SubscriptDecl>(decl)) {
+    auto contextTy =
+        newContext->mapTypeIntoContext(subscript->getElementInterfaceType());
     // Subscripts that return non-copyable types are not yet supported.
     // See: https://github.com/apple/swift/issues/70047.
-    if (subscript->getElementInterfaceType()->isNoncopyable(newContext))
+    if (contextTy->isNoncopyable())
       return nullptr;
     auto out = SubscriptDecl::create(
         subscript->getASTContext(), subscript->getName(), subscript->getStaticLoc(),

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -1756,9 +1756,10 @@ SwiftDeclSynthesizer::makeDereferencedPointeeProperty(FuncDecl *getter,
                              : rawElementTy;
   // Use 'address' or 'mutableAddress' accessors for non-copyable
   // types that are returned indirectly.
-  bool isImplicit = !elementTy->isNoncopyable(dc);
+  bool isNoncopyable = dc->mapTypeIntoContext(elementTy)->isNoncopyable();
+  bool isImplicit = !isNoncopyable;
   bool useAddress =
-      rawElementTy->getAnyPointerElementType() && elementTy->isNoncopyable(dc);
+      rawElementTy->getAnyPointerElementType() && isNoncopyable;
 
   auto result = new (ctx)
       VarDecl(/*isStatic*/ false, VarDecl::Introducer::Var,

lib/Sema/AssociatedTypeInference.cpp

@@ -137,7 +137,7 @@ checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
     return CheckTypeWitnessResult::forError();
 
   if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)
-      && type->isNoncopyable(dc)) {
+      && type->isNoncopyable()) {
     // No move-only type can witness an associatedtype requirement.
     // Pretend the failure is a lack of Copyable conformance.
     auto *copyable = ctx.getProtocol(KnownProtocolKind::Copyable);

lib/Sema/CSSimplify.cpp

@@ -3889,7 +3889,7 @@ ConstraintSystem::matchExistentialTypes(Type type1, Type type2,
   }
 
   // move-only types (and their metatypes) cannot match with existential types.
-  if (type1->getMetatypeInstanceType()->isNoncopyable(DC)) {
+  if (type1->getMetatypeInstanceType()->isNoncopyable()) {
     // tailor error message
     if (shouldAttemptFixes()) {
       auto *fix = MustBeCopyable::create(*this,
@@ -11886,7 +11886,7 @@ ConstraintSystem::simplifyBridgingConstraint(Type type1,
 
   // Noncopyable types can't be involved in bridging conversions since a bridged
   // type assumes the ability to copy.
-  if (type1->isNoncopyable(DC)) {
+  if (type1->isNoncopyable()) {
     return SolutionKind::Error;
   }
 

lib/Sema/MiscDiagnostics.cpp

@@ -325,7 +325,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
                                 tupleExpr->getElementNames());
 
         // Diagnose attempts to form a tuple with any noncopyable elements.
-        if (E->getType()->isNoncopyable(DC)
+        if (E->getType()->isNoncopyable()
             && !Ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples)) {
           auto noncopyableTy = E->getType();
           assert(noncopyableTy->is<TupleType>() && "will use poor wording");
@@ -388,7 +388,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       if (!castType)
         return;
 
-      if (castType->isNoncopyable(DC)) {
+      if (castType->isNoncopyable()) {
         // can't cast anything to move-only; there should be no valid ones.
         Ctx.Diags.diagnose(cast->getLoc(), diag::noncopyable_cast);
         return;
@@ -398,7 +398,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       // as of now there is no type it could be cast to except itself, so
       // there's no reason for it to happen at runtime.
       if (auto fromType = cast->getSubExpr()->getType()) {
-        if (fromType->isNoncopyable(DC)) {
+        if (fromType->isNoncopyable()) {
           // can't cast move-only to anything.
           Ctx.Diags.diagnose(cast->getLoc(), diag::noncopyable_cast);
           return;
@@ -4103,7 +4103,7 @@ diagnoseMoveOnlyPatternMatchSubject(ASTContext &C,
   auto subjectType = subjectExpr->getType();
   if (!subjectType
       || subjectType->hasError()
-      || !subjectType->isNoncopyable(DC)) {
+      || !subjectType->isNoncopyable()) {
     return;
   }
 

lib/Sema/TypeCheckAttr.cpp

@@ -7319,8 +7319,7 @@ void AttributeChecker::visitStaticExclusiveOnlyAttr(
   // Can only be applied to structs.
   auto structDecl = cast<StructDecl>(D);
 
-  if (!structDecl->getDeclaredInterfaceType()
-                 ->isNoncopyable(D->getDeclContext())) {
+  if (structDecl->canBeCopyable() != TypeDecl::CBI_Never) {
     diagnoseAndRemoveAttr(attr, diag::attr_static_exclusive_only_noncopyable);
   }
 }

lib/Sema/TypeCheckConstraints.cpp

@@ -1726,8 +1726,8 @@ TypeChecker::typeCheckCheckedCast(Type fromType, Type toType,
   //
   // Thus, right now, a move-only type is only a subtype of itself.
   // We also want to prevent conversions of a move-only type's metatype.
-  if (fromType->getMetatypeInstanceType()->isNoncopyable(dc)
-      || toType->getMetatypeInstanceType()->isNoncopyable(dc))
+  if (fromType->getMetatypeInstanceType()->isNoncopyable()
+      || toType->getMetatypeInstanceType()->isNoncopyable())
     return CheckedCastKind::Unresolved;
 
   // Check for a bridging conversion.

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -90,8 +90,10 @@ static Type containsParameterizedProtocolType(Type inheritedTy) {
 bool swift::isInterfaceTypeNoncopyable(Type type, GenericEnvironment *env) {
   // Turn any type parameters into archetypes.
   if (env)
-    if (!type->hasArchetype() || type->hasOpenedExistential())
-      type = GenericEnvironment::mapTypeIntoContext(env, type);
+    type = GenericEnvironment::mapTypeIntoContext(env, type);
+
+  if (auto sugar = dyn_cast<SugarType>(type))
+    type = sugar->getDesugaredType();
 
   if (!type->hasTypeParameter())
     return type->isNoncopyable();
@@ -100,8 +102,12 @@ bool swift::isInterfaceTypeNoncopyable(Type type, GenericEnvironment *env) {
   if (auto *generic = type->getAnyGeneric())
     return generic->canBeCopyable() != swift::TypeDecl::CBI_Always;
   else if (auto gtpt = type->getAs<GenericTypeParamType>())
-    return gtpt->getDecl()->canBeCopyable() != swift::TypeDecl::CBI_Always;
+    if (auto *gtpd = gtpt->getDecl())
+      return gtpd->canBeCopyable() != swift::TypeDecl::CBI_Always;
 
+  #ifndef NDEBUG
+    type->dump();
+  #endif
   llvm_unreachable("unhandled type kind");
 }
 

lib/Sema/TypeCheckInvertible.cpp

@@ -164,16 +164,10 @@ static bool conformsToInvertible(CanType type, InvertibleProtocolKind ip) {
   auto *invertible = ctx.getProtocol(getKnownProtocolKind(ip));
   assert(invertible);
 
-  // Pack expansions such as `repeat T` themselves do not have conformances,
-  // so check its pattern type for conformance.
-  if (auto *pet = type->getAs<PackExpansionType>()) {
-    type = pet->getPatternType()->getCanonicalType();
-  }
+  // Must not have a type parameter!
+  assert(!type->hasTypeParameter() && "caller forgot to mapTypeIntoContext!");
 
-  // Must either not have a type parameter, or in the case of a
-  // BoundGenericXType, have a nominal available.
-  assert(!type->hasTypeParameter() || type.getAnyNominal()
-          && "caller forgot to mapTypeIntoContext!");
+  assert(!type->is<PackExpansionType>());
 
   // The SIL types in the AST do not have real conformances, and should have
   // been handled earlier.
@@ -281,11 +275,11 @@ static bool checkInvertibleConformanceCommon(ProtocolConformance *conformance,
       // For a type conforming to IP, ensure that the storage conforms to IP.
       switch (IP) {
       case InvertibleProtocolKind::Copyable:
-        if (!type->isNoncopyable(DC))
+        if (!type->isNoncopyable())
           return false;
         break;
       case InvertibleProtocolKind::Escapable:
-        if (type->isEscapable(DC))
+        if (type->isEscapable())
           return false;
         break;
       }

lib/Sema/TypeCheckType.cpp

@@ -2371,7 +2371,7 @@ bool swift::diagnoseMissingOwnership(ASTContext &ctx, DeclContext *dc,
   if (options.hasBase(TypeResolverContext::EnumElementDecl))
     return false; // no need for ownership in enum cases.
 
-  if (!ty->isNoncopyable(dc))
+  if (!isInterfaceTypeNoncopyable(ty, dc->getGenericEnvironmentOfContext()))
     return false; // copyable types do not need ownership
 
   if (ownership != ParamSpecifier::Default)
@@ -4776,7 +4776,8 @@ NeverNullType TypeResolver::resolveVarargType(VarargTypeRepr *repr,
   // do not allow move-only types as the element of a vararg
   if (!element->hasError()
       && inStage(TypeResolutionStage::Interface)
-      && element->isNoncopyable(getDeclContext())) {
+      && isInterfaceTypeNoncopyable(
+          element, getDeclContext()->getGenericEnvironmentOfContext())) {
     diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_variadic,
                     element);
     return ErrorType::get(getASTContext());
@@ -4956,7 +4957,8 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
     // Track the presence of a noncopyable field for diagnostic purposes.
     // We don't need to re-diagnose if a tuple contains another tuple, though,
     // since we should've diagnosed the inner tuple already.
-    if (inStage(TypeResolutionStage::Interface) && ty->isNoncopyable(dc)
+    if (inStage(TypeResolutionStage::Interface)
+        && isInterfaceTypeNoncopyable(ty, dc->getGenericEnvironmentOfContext())
         && !moveOnlyElementIndex.has_value() && !isa<TupleTypeRepr>(tyR)) {
       moveOnlyElementIndex = i;
     }

lib/Sema/TypeChecker.h

@@ -1400,7 +1400,8 @@ bool isOverrideBasedOnType(const ValueDecl *decl, Type declTy,
 /// could fulfill a protocol requirement for it.
 bool isMemberOperator(FuncDecl *decl, Type type);
 
-/// Given an interface type and a decl context, is the type ever noncopyable?
+/// Given an interface type and possibly a generic environment,
+/// is the type ever noncopyable?
 bool isInterfaceTypeNoncopyable(Type interfaceTy, GenericEnvironment *env);
 
 /// Returns `true` iff `AdditiveArithmetic` derived conformances are enabled.

test/Generics/inverse_generics.swift

@@ -393,3 +393,25 @@ func checkExistentialAndClasses(
     _ b: any Soup & Copyable & ~Escapable & ~Copyable, // expected-error {{composition involving class requirement 'Soup' cannot contain '~Copyable'}}
     _ c: some (~Escapable & Removed) & Soup // expected-error {{composition involving class requirement 'Soup' cannot contain '~Escapable'}}
     ) {}
+
+protocol HasNCBuddy: ~Copyable {
+  associatedtype NCBuddy: HasNCBuddy, ~Copyable
+
+  associatedtype Buddy: HasMember
+}
+
+protocol HasMember : HasNCBuddy {
+  associatedtype Member: HasMember
+
+  associatedtype NCMember: ~Copyable
+}
+
+func checkOwnership<T: HasMember>(_ t: T,
+                                  _ l: T.NCBuddy.Buddy.Member.Buddy,
+                                  _ m: T.Member.Member,
+                                  _ n: T.Member.NCMember,
+// expected-error@-1 {{parameter of noncopyable type 'T.Member.NCMember' must specify ownership}} // expected-note@-1 3{{add}}
+
+                                  _ o: T.Member.NCBuddy.NCBuddy
+// expected-error@-1 {{parameter of noncopyable type 'T.Member.NCBuddy.NCBuddy' must specify ownership}} // expected-note@-1 3{{add}}
+) {}