NCGenerics: simplify isInterfaceTypeNoncopyable

We can greatly simplify our noncopyable checks if we skip running these
diagnostic checks while in SIL mode, where it's not really needed. The
challenge with doing the checks in SIL mode is that there is sometimes
no generic environment when doing these queries. Whether that itself is
simply a bug or fundamental limitation, I haven't investigated.

Author: kavon

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -88,27 +88,12 @@ static Type containsParameterizedProtocolType(Type inheritedTy) {
 }
 
 bool swift::isInterfaceTypeNoncopyable(Type type, GenericEnvironment *env) {
-  // Turn any type parameters into archetypes.
-  if (env)
-    type = GenericEnvironment::mapTypeIntoContext(env, type);
-
-  if (auto sugar = dyn_cast<SugarType>(type))
-    type = sugar->getDesugaredType();
+  assert(!type->hasTypeParameter() || env && "must have a generic environment");
 
-  if (!type->hasTypeParameter())
-    return type->isNoncopyable();
-
-  // Handle types containing unbound generic parameters.
-  if (auto *generic = type->getAnyGeneric())
-    return generic->canBeCopyable() != swift::TypeDecl::CanBeInvertible::Always;
-  else if (auto gtpt = type->getAs<GenericTypeParamType>())
-    if (auto *gtpd = gtpt->getDecl())
-      return gtpd->canBeCopyable() != swift::TypeDecl::CanBeInvertible::Always;
+  if (env)
+    type = env->mapTypeIntoContext(type);
 
-  #ifndef NDEBUG
-    type->dump();
-  #endif
-  llvm_unreachable("unhandled type kind");
+  return type->isNoncopyable();
 }
 
 /// Check the inheritance clause of a type declaration or extension thereof.
@@ -2796,7 +2781,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(),
-                                   DC->getGenericEnvironmentOfContext())) {
+                                   SD->getGenericEnvironment())) {
       if (auto *read = SD->getAccessor(AccessorKind::Read)) {
         if (!read->isImplicit()) {
           if (auto *set = SD->getAccessor(AccessorKind::Set)) {

lib/Sema/TypeCheckStorage.cpp

@@ -784,7 +784,12 @@ OpaqueReadOwnershipRequest::evaluate(Evaluator &evaluator,
   if (storage->getAttrs().hasAttribute<BorrowedAttr>())
     return usesBorrowed(DiagKind::BorrowedAttr);
 
-  auto *env = storage->getDeclContext()->getGenericEnvironmentOfContext();
+  GenericEnvironment *env = nullptr;
+  if (auto *gc = storage->getAsGenericContext())
+    env = gc->getGenericEnvironment();
+  else
+    env = storage->getDeclContext()->getGenericEnvironmentOfContext();
+
   if (isInterfaceTypeNoncopyable(storage->getValueInterfaceType(), env))
     return usesBorrowed(DiagKind::NoncopyableType);
 

lib/Sema/TypeCheckType.cpp

@@ -3593,7 +3593,8 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
     }
 
     // Validate the presence of ownership for a noncopyable parameter.
-    if (inStage(TypeResolutionStage::Interface)) {
+    if (inStage(TypeResolutionStage::Interface)
+        && !options.contains(TypeResolutionFlags::SILMode)) {
       diagnoseMissingOwnership(getASTContext(), dc, ownership,
                                eltTypeRepr, ty, options);
 
@@ -4776,6 +4777,7 @@ 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,
@@ -4954,11 +4956,13 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
       hadError = true;
     }
     // Tuples with move-only elements aren't yet supported.
-    // Track the presence of a noncopyable field for diagnostic purposes.
+    // 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)
         && isInterfaceTypeNoncopyable(ty, dc->getGenericEnvironmentOfContext())
+        && !ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples)
         && !moveOnlyElementIndex.has_value() && !isa<TupleTypeRepr>(tyR)) {
       moveOnlyElementIndex = i;
     }
@@ -5011,9 +5015,7 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
       return ParenType::get(ctx, elements[0].getType());
   }
 
-  if (moveOnlyElementIndex.has_value()
-      && !options.contains(TypeResolutionFlags::SILType)
-      && !ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples)) {
+  if (moveOnlyElementIndex.has_value()) {
     auto noncopyableTy = elements[*moveOnlyElementIndex].getType();
     auto loc = repr->getElementType(*moveOnlyElementIndex)->getLoc();
     assert(!noncopyableTy->is<TupleType>() && "will use poor wording");