[no-implicit-copy] Remove rest of the unnecessary code from SILFunctionType.

Previously I thought that we would have @_noImplicitCopy change the
SILFunctionType (but not the AST level type). This caused other problems and was
unnecessary. So I removed all such changes in this commit. Specifically:

1. We no longer thread through no implicit copy in SILFunctionType.cpp.
2. noImplicitCopy no longer by default makes an argument an owned
argument. Instead we use the default convention and handle it appropriately.

Author: gottesmm

lib/SIL/IR/SILFunctionType.cpp

@@ -17,6 +17,7 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "libsil"
+
 #include "swift/AST/AnyFunctionRef.h"
 #include "swift/AST/CanTypeVisitor.h"
 #include "swift/AST/Decl.h"
@@ -1388,16 +1389,13 @@ class DestructureInputs {
   AbstractionPattern TopLevelOrigType = AbstractionPattern::getInvalid();
   SmallVectorImpl<SILParameterInfo> &Inputs;
   unsigned NextOrigParamIndex = 0;
-  Optional<SmallBitVector> NoImplicitCopyIndices;
 
 public:
   DestructureInputs(TypeExpansionContext expansion, TypeConverter &TC,
                     const Conventions &conventions, const ForeignInfo &foreign,
-                    SmallVectorImpl<SILParameterInfo> &inputs,
-                    Optional<SmallBitVector> noImplicitCopyIndices)
+                    SmallVectorImpl<SILParameterInfo> &inputs)
       : expansion(expansion), TC(TC), Convs(conventions), Foreign(foreign),
-        Inputs(inputs),
-        NoImplicitCopyIndices(noImplicitCopyIndices) {}
+        Inputs(inputs) {}
 
   void destructure(AbstractionPattern origType,
                    CanAnyFunctionType::CanParamArrayRef params,
@@ -1435,18 +1433,14 @@ class DestructureInputs {
     // Add any foreign parameters that are positioned here.
     maybeAddForeignParameters();
 
-    bool hasNoImplicitCopy =
-        NoImplicitCopyIndices.hasValue() && NoImplicitCopyIndices->any();
-
     // Process all the non-self parameters.
     for (unsigned i = 0; i != numNonSelfParams; ++i) {
       auto ty = params[i].getParameterType();
       auto eltPattern = origType.getFunctionParamType(i);
       auto flags = params[i].getParameterFlags();
 
       visit(flags.getValueOwnership(), /*forSelf=*/false, eltPattern, ty,
-            flags.isNoDerivative(),
-            hasNoImplicitCopy && (*NoImplicitCopyIndices)[i]);
+            flags.isNoDerivative());
     }
 
     // Process the self parameter.  Note that we implicitly drop self
@@ -1457,8 +1451,7 @@ class DestructureInputs {
       auto eltPattern = origType.getFunctionParamType(numNonSelfParams);
       auto flags = selfParam.getParameterFlags();
 
-      visit(flags.getValueOwnership(), /*forSelf=*/true, eltPattern, ty, false,
-            false);
+      visit(flags.getValueOwnership(), /*forSelf=*/true, eltPattern, ty, false);
     }
 
     TopLevelOrigType = AbstractionPattern::getInvalid();
@@ -1467,7 +1460,7 @@ class DestructureInputs {
 
   void visit(ValueOwnership ownership, bool forSelf,
              AbstractionPattern origType, CanType substType,
-             bool isNonDifferentiable, bool isNoImplicitCopy) {
+             bool isNonDifferentiable) {
     assert(!isa<InOutType>(substType));
 
     // Tuples get handled specially, in some cases:
@@ -1485,7 +1478,7 @@ class DestructureInputs {
           assert(ownership == ValueOwnership::Default);
           assert(!elt.isVararg());
           visit(ownership, forSelf, origType.getTupleElementType(i),
-                CanType(elt.getRawType()), false, false);
+                CanType(elt.getRawType()), false);
         }
         return;
       case ValueOwnership::InOut:
@@ -1511,8 +1504,6 @@ class DestructureInputs {
       convention = ParameterConvention::Direct_Unowned;
     } else {
       // If we are no implicit copy, our ownership is always Owned.
-      if (isNoImplicitCopy)
-        ownership = ValueOwnership::Owned;
       convention = Convs.getDirect(ownership, forSelf, origParamIndex, origType,
                                    substTLConv);
       assert(!isIndirectFormalParameter(convention));
@@ -1579,7 +1570,7 @@ class DestructureInputs {
       // This is a "self", but it's not a Swift self, we handle it differently.
       visit(ForeignSelf->SubstSelfParam.getValueOwnership(),
             /*forSelf=*/false, ForeignSelf->OrigSelfParam,
-            ForeignSelf->SubstSelfParam.getParameterType(), false, false);
+            ForeignSelf->SubstSelfParam.getParameterType(), false);
     }
     return true;
   }
@@ -1892,8 +1883,7 @@ static CanSILFunctionType getSILFunctionType(
     SILExtInfoBuilder extInfoBuilder, const Conventions &conventions,
     const ForeignInfo &foreignInfo, Optional<SILDeclRef> origConstant,
     Optional<SILDeclRef> constant, Optional<SubstitutionMap> reqtSubs,
-    ProtocolConformanceRef witnessMethodConformance,
-    Optional<SmallBitVector> noImplicitCopyIndices) {
+    ProtocolConformanceRef witnessMethodConformance) {
   // Find the generic parameters.
   CanGenericSignature genericSig =
     substFnInterfaceType.getOptGenericSignature();
@@ -2053,8 +2043,7 @@ static CanSILFunctionType getSILFunctionType(
   SmallVector<SILParameterInfo, 8> inputs;
   {
     DestructureInputs destructurer(expansionContext, TC, conventions,
-                                   foreignInfo, inputs,
-                                   noImplicitCopyIndices);
+                                   foreignInfo, inputs);
     destructurer.destructure(origType, substFnInterfaceType.getParams(),
                              extInfoBuilder);
   }
@@ -2337,15 +2326,14 @@ static CanSILFunctionType getNativeSILFunctionType(
     AbstractionPattern origType, CanAnyFunctionType substInterfaceType,
     SILExtInfoBuilder extInfoBuilder, Optional<SILDeclRef> origConstant,
     Optional<SILDeclRef> constant, Optional<SubstitutionMap> reqtSubs,
-    ProtocolConformanceRef witnessMethodConformance,
-    Optional<SmallBitVector> noImplicitCopyIndices) {
+    ProtocolConformanceRef witnessMethodConformance) {
   assert(bool(origConstant) == bool(constant));
   auto getSILFunctionTypeForConventions =
       [&](const Conventions &convs) -> CanSILFunctionType {
     return getSILFunctionType(TC, context, origType, substInterfaceType,
                               extInfoBuilder, convs, ForeignInfo(),
                               origConstant, constant, reqtSubs,
-                              witnessMethodConformance, noImplicitCopyIndices);
+                              witnessMethodConformance);
   };
   switch (extInfoBuilder.getRepresentation()) {
   case SILFunctionType::Representation::Block:
@@ -2409,7 +2397,7 @@ CanSILFunctionType swift::getNativeSILFunctionType(
 
   return ::getNativeSILFunctionType(
       TC, context, origType, substType, silExtInfo.intoBuilder(), origConstant,
-      substConstant, reqtSubs, witnessMethodConformance, None);
+      substConstant, reqtSubs, witnessMethodConformance);
 }
 
 /// Build a generic signature and environment for a re-abstraction thunk.
@@ -3076,7 +3064,7 @@ static CanSILFunctionType getSILFunctionTypeForClangDecl(
     return getSILFunctionType(
         TC, TypeExpansionContext::minimal(), origPattern, substInterfaceType,
         extInfoBuilder, ObjCMethodConventions(method), foreignInfo, constant,
-        constant, None, ProtocolConformanceRef(), None);
+        constant, None, ProtocolConformanceRef());
   }
 
   if (auto method = dyn_cast<clang::CXXMethodDecl>(clangDecl)) {
@@ -3088,7 +3076,7 @@ static CanSILFunctionType getSILFunctionTypeForClangDecl(
     return getSILFunctionType(TC, TypeExpansionContext::minimal(), origPattern,
                               substInterfaceType, extInfoBuilder, conventions,
                               foreignInfo, constant, constant, None,
-                              ProtocolConformanceRef(), None);
+                              ProtocolConformanceRef());
   }
 
   if (auto func = dyn_cast<clang::FunctionDecl>(clangDecl)) {
@@ -3101,7 +3089,7 @@ static CanSILFunctionType getSILFunctionTypeForClangDecl(
     return getSILFunctionType(TC, TypeExpansionContext::minimal(), origPattern,
                               substInterfaceType, extInfoBuilder,
                               CFunctionConventions(func), foreignInfo, constant,
-                              constant, None, ProtocolConformanceRef(), None);
+                              constant, None, ProtocolConformanceRef());
   }
 
   llvm_unreachable("call to unknown kind of C function");
@@ -3129,15 +3117,15 @@ static CanSILFunctionType getSILFunctionTypeForAbstractCFunction(
       return getSILFunctionType(
           TC, TypeExpansionContext::minimal(), origType, substType,
           extInfoBuilder, CFunctionTypeConventions(fnType), ForeignInfo(),
-          constant, constant, None, ProtocolConformanceRef(), None);
+          constant, constant, None, ProtocolConformanceRef());
     }
   }
 
   // TODO: Ought to support captures in block funcs.
   return getSILFunctionType(TC, TypeExpansionContext::minimal(), origType,
                             substType, extInfoBuilder,
                             DefaultBlockConventions(), ForeignInfo(), constant,
-                            constant, None, ProtocolConformanceRef(), None);
+                            constant, None, ProtocolConformanceRef());
 }
 
 /// Try to find a clang method declaration for the given function.
@@ -3305,7 +3293,7 @@ static CanSILFunctionType getSILFunctionTypeForObjCSelectorFamily(
       TC, TypeExpansionContext::minimal(), AbstractionPattern(origType),
       substInterfaceType, extInfoBuilder, ObjCSelectorFamilyConventions(family),
       foreignInfo, constant, constant,
-      /*requirement subs*/ None, ProtocolConformanceRef(), None);
+      /*requirement subs*/ None, ProtocolConformanceRef());
 }
 
 static bool isImporterGeneratedAccessor(const clang::Decl *clangDecl,
@@ -3375,23 +3363,9 @@ static CanSILFunctionType getUncachedSILFunctionTypeForConstant(
       }
     }();
 
-    Optional<SmallBitVector> noImplicitCopyIndices;
-    if (constant.hasDecl()) {
-      auto decl = constant.getDecl();
-      if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(decl)) {
-        noImplicitCopyIndices.emplace(funcDecl->getParameters()->size());
-        for (auto p : llvm::enumerate(*funcDecl->getParameters())) {
-          if (p.value()->isNoImplicitCopy()) {
-            noImplicitCopyIndices->set(p.index());
-          }
-        }
-      }
-    }
-
     return ::getNativeSILFunctionType(
         TC, context, origType, origLoweredInterfaceType, extInfoBuilder,
-        constant, constant, None, witnessMethodConformance,
-        noImplicitCopyIndices);
+        constant, constant, None, witnessMethodConformance);
   }
 
   ForeignInfo foreignInfo;

lib/SIL/IR/TypeLowering.cpp

@@ -2432,7 +2432,7 @@ TypeConverter::computeLoweredRValueType(TypeExpansionContext forExpansion,
               .build();
 
       return ::getNativeSILFunctionType(TC, forExpansion, origType, substFnType,
-                                        silExtInfo);
+                                        silExtInfo, None, None, None, {});
     }
 
     // Ignore dynamic self types.