[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");
 }