Sema: Remove isInterfaceTypeNoncopyable()

Author: slavapestov

lib/AST/GenericEnvironment.cpp

@@ -404,7 +404,7 @@ GenericEnvironment::maybeApplyOuterContextSubstitutions(Type type) const {
 
 Type GenericEnvironment::mapTypeIntoContext(GenericEnvironment *env,
                                             Type type) {
-  assert((!type->hasArchetype() || type->hasOpenedExistential()) &&
+  assert((!type->hasArchetype() || type->hasLocalArchetype()) &&
          "already have a contextual type");
   assert((env || !type->hasTypeParameter()) &&
          "no generic environment provided for type with type parameters");

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -88,15 +88,6 @@ static Type containsParameterizedProtocolType(Type inheritedTy) {
   return Type();
 }
 
-bool swift::isInterfaceTypeNoncopyable(Type type, GenericEnvironment *env) {
-  assert(!type->hasTypeParameter() || env && "must have a generic environment");
-
-  if (env)
-    type = env->mapTypeIntoContext(type);
-
-  return type->isNoncopyable();
-}
-
 /// Check the inheritance clause of a type declaration or extension thereof.
 ///
 /// This routine performs detailed checking of the inheritance clause of the
@@ -2753,8 +2744,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       // accessors since this means that we cannot call mutating methods without
       // copying. We do not want to support types that one cannot define a
       // modify operation via a get/set or a modify.
-      if (isInterfaceTypeNoncopyable(var->getInterfaceType(),
-                                     DC->getGenericEnvironmentOfContext())) {
+      if (var->getTypeInContext()->isNoncopyable()) {
         if (auto *read = var->getAccessor(AccessorKind::Read)) {
           if (!read->isImplicit()) {
             if (auto *set = var->getAccessor(AccessorKind::Set)) {
@@ -2847,8 +2837,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     // Reject noncopyable typed subscripts with read/set accessors since we
     // cannot define modify operations upon them without copying the read.
-    if (isInterfaceTypeNoncopyable(SD->getElementInterfaceType(),
-                                   SD->getGenericEnvironment())) {
+    if (SD->mapTypeIntoContext(SD->getElementInterfaceType())->isNoncopyable()) {
       if (auto *read = SD->getAccessor(AccessorKind::Read)) {
         if (!read->isImplicit()) {
           if (auto *set = SD->getAccessor(AccessorKind::Set)) {

lib/Sema/TypeCheckStorage.cpp

@@ -793,13 +793,8 @@ OpaqueReadOwnershipRequest::evaluate(Evaluator &evaluator,
   if (storage->getAttrs().hasAttribute<BorrowedAttr>())
     return usesBorrowed(DiagKind::BorrowedAttr);
 
-  GenericEnvironment *env = nullptr;
-  if (auto *gc = storage->getAsGenericContext())
-    env = gc->getGenericEnvironment();
-  else
-    env = storage->getDeclContext()->getGenericEnvironmentOfContext();
-
-  if (isInterfaceTypeNoncopyable(storage->getValueInterfaceType(), env))
+  if (storage->getInnermostDeclContext()->mapTypeIntoContext(
+        storage->getValueInterfaceType())->isNoncopyable())
     return usesBorrowed(DiagKind::NoncopyableType);
 
   return OpaqueReadOwnership::Owned;

lib/Sema/TypeCheckType.cpp

@@ -2532,7 +2532,6 @@ bool swift::diagnoseMissingOwnership(ParamSpecifier ownership,
   auto options = resolution.getOptions();
 
   assert(!ty->hasError());
-  assert(!options.contains(TypeResolutionFlags::SILType));
 
   if (options.hasBase(TypeResolverContext::EnumElementDecl))
     return false; // no need for ownership in enum cases.
@@ -2879,8 +2878,8 @@ TypeResolver::resolveOpenedExistentialArchetype(
     // The constraint type is written with respect to the surrounding
     // generic environment.
     constraintType = GenericEnvironment::mapTypeIntoContext(
-               resolution.getGenericSignature().getGenericEnvironment(),
-               constraintType);
+        resolution.getGenericSignature().getGenericEnvironment(),
+        constraintType);
 
     // The opened existential type is formed by mapping the interface type
     // into a new opened generic environment.
@@ -3781,8 +3780,7 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
 
     // Validate the presence of ownership for a noncopyable parameter.
     if (inStage(TypeResolutionStage::Interface)
-        && !ty->hasUnboundGenericType()
-        && !options.contains(TypeResolutionFlags::SILMode)) {
+        && !ty->hasUnboundGenericType()) {
       diagnoseMissingOwnership(ownership, eltTypeRepr, ty, resolution);
 
       // @_staticExclusiveOnly types cannot be passed as 'inout' in function
@@ -5243,14 +5241,14 @@ NeverNullType TypeResolver::resolveVarargType(VarargTypeRepr *repr,
   }
 
   // do not allow move-only types as the element of a vararg
-  if (!element->hasError()
-      && inStage(TypeResolutionStage::Interface)
-      && !options.contains(TypeResolutionFlags::SILMode)
-      && isInterfaceTypeNoncopyable(
-          element, getDeclContext()->getGenericEnvironmentOfContext())) {
-    diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_variadic,
-                    element);
-    return ErrorType::get(getASTContext());
+  if (inStage(TypeResolutionStage::Interface)) {
+    auto contextTy = GenericEnvironment::mapTypeIntoContext(
+        resolution.getGenericSignature().getGenericEnvironment(), element);
+    if (!contextTy->hasError() && contextTy->isNoncopyable()) {
+      diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_variadic,
+                      element);
+      return ErrorType::get(getASTContext());
+    }
   }
 
   return element;
@@ -5401,7 +5399,6 @@ NeverNullType TypeResolver::resolvePackElement(PackElementTypeRepr *repr,
 NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
                                              TypeResolutionOptions options) {
   auto &ctx = getASTContext();
-  auto *dc = getDeclContext();
 
   SmallVector<TupleTypeElt, 8> elements;
   elements.reserve(repr->getNumElements());
@@ -5429,13 +5426,16 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
     // Track the presence of a noncopyable field for diagnostic purposes only.
     // 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)
-        && !options.contains(TypeResolutionFlags::SILMode)
-        && !ty->hasUnboundGenericType()
-        && isInterfaceTypeNoncopyable(ty, dc->getGenericEnvironmentOfContext())
-        && !ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples)
-        && !moveOnlyElementIndex.has_value() && !isa<TupleTypeRepr>(tyR)) {
-      moveOnlyElementIndex = i;
+    if (!ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples) &&
+        !options.contains(TypeResolutionFlags::SILMode) &&
+        inStage(TypeResolutionStage::Interface) &&
+        !moveOnlyElementIndex.has_value() &&
+        !ty->hasUnboundGenericType() &&
+        !isa<TupleTypeRepr>(tyR)) {
+      auto contextTy = GenericEnvironment::mapTypeIntoContext(
+          resolution.getGenericSignature().getGenericEnvironment(), ty);
+      if (contextTy->isNoncopyable())
+        moveOnlyElementIndex = i;
     }
 
     auto eltName = repr->getElementName(i);

lib/Sema/TypeChecker.h

@@ -1403,10 +1403,6 @@ 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 possibly a generic environment,
-/// is the type ever noncopyable?
-bool isInterfaceTypeNoncopyable(Type interfaceTy, GenericEnvironment *env);
-
 /// Returns `true` iff `AdditiveArithmetic` derived conformances are enabled.
 bool isAdditiveArithmeticConformanceDerivationEnabled(SourceFile &SF);