Merge pull request #6665 from slavapestov/scalability-fix-and-cleanups

Scalability fix and cleanups

Author: slavapestov

include/swift/SILOptimizer/Utils/Local.h

@@ -137,21 +137,17 @@ ProjectBoxInst *getOrCreateProjectBox(AllocBoxInst *ABI, unsigned Index);
 /// if possible.
 void replaceDeadApply(ApplySite Old, ValueBase *New);
 
-/// \brief Return true if the substitution map contains a
-/// substitution that is an unbound generic type.
-bool hasUnboundGenericTypes(const TypeSubstitutionMap &SubsMap);
+/// \brief Return true if the substitution map contains replacement types
+/// that are dependent on the type parameters of the caller.
+bool hasTypeParameterTypes(SubstitutionMap &SubsMap);
 
-/// Return true if the substitution list contains a substitution
-/// that is an unbound generic.
-bool hasUnboundGenericTypes(ArrayRef<Substitution> Subs);
+/// \brief Return true if the substitution list contains replacement types
+/// that are dependent on the type parameters of the caller.
+bool hasArchetypes(ArrayRef<Substitution> Subs);
 
 /// \brief Return true if the substitution map contains a
 /// substitution that refers to the dynamic Self type.
-bool hasDynamicSelfTypes(const TypeSubstitutionMap &SubsMap);
-
-/// \brief Return true if the substitution list contains a
-/// substitution that refers to the dynamic Self type.
-bool hasDynamicSelfTypes(ArrayRef<Substitution> Subs);
+bool hasDynamicSelfTypes(const SubstitutionMap &SubsMap);
 
 /// \brief Return true if any call inside the given function may bind dynamic
 /// 'Self' to a generic argument of the callee.

lib/AST/ASTVerifier.cpp

@@ -1249,17 +1249,17 @@ struct ASTNodeBase {};
         Out << "\n";
         abort();
       }
-      CanType InputExprTy = E->getArg()->getType()->getCanonicalType();
-      CanType ResultExprTy = E->getType()->getCanonicalType();
-      if (ResultExprTy != FT->getResult()->getCanonicalType()) {
+      Type InputExprTy = E->getArg()->getType();
+      Type ResultExprTy = E->getType();
+      if (!ResultExprTy->isEqual(FT->getResult())) {
         Out << "result of ApplyExpr does not match result type of callee:";
         E->getType().print(Out);
         Out << " vs. ";
         FT->getResult()->print(Out);
         Out << "\n";
         abort();
       }
-      if (InputExprTy != FT->getInput()->getCanonicalType()) {
+      if (!InputExprTy->isEqual(FT->getInput())) {
         TupleType *TT = FT->getInput()->getAs<TupleType>();
         if (isa<SelfApplyExpr>(E)) {
           Type InputExprObjectTy;
@@ -1274,8 +1274,7 @@ struct ASTNodeBase {};
           checkSameOrSubType(InputExprObjectTy, FunctionInputObjectTy,
                              "object argument and 'self' parameter");
         } else if (!TT || TT->getNumElements() != 1 ||
-                   TT->getElement(0).getType()->getCanonicalType()
-                     != InputExprTy) {
+                   !TT->getElement(0).getType()->isEqual(InputExprTy)) {
           Out << "Argument type does not match parameter type in ApplyExpr:"
                  "\nArgument type: ";
           E->getArg()->getType().print(Out);
@@ -1892,8 +1891,7 @@ struct ASTNodeBase {};
         return;
       }
 
-      if (type->getCanonicalType() !=
-            conformance.getConcrete()->getType()->getCanonicalType()) {
+      if (!type->isEqual(conformance.getConcrete()->getType())) {
         Out << "conforming type does not match conformance\n";
         Out << "conforming type:\n";
         type.dump(Out, 2);
@@ -2518,7 +2516,7 @@ struct ASTNodeBase {};
     }
 
     void checkSameType(Type T0, Type T1, const char *what) {
-      if (T0->getCanonicalType() == T1->getCanonicalType())
+      if (T0->isEqual(T1))
         return;
 
       Out << "different types for " << what << ": ";
@@ -2568,7 +2566,7 @@ struct ASTNodeBase {};
     }
 
     void checkSameOrSubType(Type T0, Type T1, const char *what) {
-      if (T0->getCanonicalType() == T1->getCanonicalType())
+      if (T0->isEqual(T1))
         return;
 
       // Protocol subtyping.

lib/AST/Availability.cpp

@@ -188,7 +188,7 @@ class AvailabilityInferenceTypeWalker : public TypeWalker {
   AvailabilityInferenceTypeWalker(ASTContext &AC) : AC(AC) {}
 
   Action walkToTypePre(Type ty) override {
-    if (auto *nominalDecl = ty->getCanonicalType()->getAnyNominal()) {
+    if (auto *nominalDecl = ty->getAnyNominal()) {
       AvailabilityInfo.intersectWith(
           AvailabilityInference::availableRange(nominalDecl, AC));
     }

lib/AST/DiagnosticEngine.cpp

@@ -391,7 +391,7 @@ static void formatDiagnosticArgument(StringRef Modifier,
       showAKA = false;
 
     // Don't show generic type parameters.
-    if (showAKA && type->getCanonicalType()->hasTypeParameter())
+    if (showAKA && type->hasTypeParameter())
       showAKA = false;
 
     if (showAKA)

lib/AST/GenericSignature.cpp

@@ -466,7 +466,7 @@ Type GenericSignature::getRepresentative(Type type, ModuleDecl &mod) {
   if (rep->isConcreteType()) return rep->getConcreteType();
   if (pa == rep) {
     assert(rep->getDependentType(getGenericParams(), /*allowUnresolved*/ false)
-              ->getCanonicalType() == type->getCanonicalType());
+              ->isEqual(type));
     return type;
   }
   return rep->getDependentType(getGenericParams(), /*allowUnresolved*/ false);

lib/AST/ProtocolConformance.cpp

@@ -414,8 +414,7 @@ SpecializedProtocolConformance::getTypeWitnessSubstAndDecl(
     assert((conforms ||
             specializedType->isTypeVariableOrMember() ||
             specializedType->isTypeParameter() ||
-            specializedType->hasError() ||
-            specializedType->getCanonicalType()->hasError()) &&
+            specializedType->hasError()) &&
            "Improperly checked substitution");
     conformances.push_back(conforms ? *conforms 
                                     : ProtocolConformanceRef(proto));

lib/AST/Substitution.cpp

@@ -29,7 +29,7 @@ bool Substitution::operator==(const Substitution &other) const {
   // The archetypes may be missing, but we can compare them directly
   // because archetypes are always canonical.
   return
-    Replacement->getCanonicalType() == other.Replacement->getCanonicalType() &&
+    Replacement->isEqual(other.Replacement) &&
     Conformance.equals(other.Conformance);
 }
 

lib/IDE/CodeCompletion.cpp

@@ -3708,18 +3708,17 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
         // We can only say .foo where foo is a static member of the contextual
         // type and has the same type (or if the member is a function, then the
         // same result type) as the contextual type.
-        auto contextCanT = T->getCanonicalType();
         FilteredDeclConsumer consumer(*this, [=](ValueDecl *VD, DeclVisibilityKind reason) {
           if (!VD->hasInterfaceType()) {
             TypeResolver->resolveDeclSignature(VD);
             if (!VD->hasInterfaceType())
               return false;
           }
 
-          auto T = VD->getInterfaceType();
-          while (auto FT = T->getAs<AnyFunctionType>())
-            T = FT->getResult();
-          return T->getCanonicalType() == contextCanT;
+          auto declTy = VD->getInterfaceType();
+          while (auto FT = declTy->getAs<AnyFunctionType>())
+            declTy = FT->getResult();
+          return declTy->isEqual(T);
         });
 
         auto baseType = MetatypeType::get(T);

lib/IDE/TypeReconstruction.cpp

@@ -945,10 +945,10 @@ static void VisitNodeConstructor(
 
             const AnyFunctionType *type_func =
                 type_result._types.front()->getAs<AnyFunctionType>();
-            if (identifier_func->getResult()->getCanonicalType() ==
-                    type_func->getResult()->getCanonicalType() &&
-                identifier_func->getInput()->getCanonicalType() ==
-                    type_func->getInput()->getCanonicalType()) {
+            if (identifier_func->getResult()->isEqual(
+                    type_func->getResult()) &&
+                identifier_func->getInput()->isEqual(
+                    type_func->getInput())) {
               result._module = kind_type_result._module;
               result._decls.push_back(kind_type_result._decls[i]);
               result._types.push_back(
@@ -1481,8 +1481,8 @@ static void VisitNodeSetterGetter(
     const AnyFunctionType *type_func =
         type_result._types.front()->getAs<AnyFunctionType>();
 
-    CanType type_result_type = type_func->getResult()->getCanonicalType();
-    CanType type_input_type = type_func->getInput()->getCanonicalType();
+    Type type_result_type = type_func->getResult();
+    Type type_input_type = type_func->getInput();
 
     FuncDecl *identifier_func = nullptr;
 
@@ -1520,14 +1520,12 @@ static void VisitNodeSetterGetter(
             const AnyFunctionType *identifier_uncurried_result =
                 identifier_func_type->getResult()->getAs<AnyFunctionType>();
             if (identifier_uncurried_result) {
-              CanType identifier_result_type =
-                  identifier_uncurried_result->getResult()
-                      ->getCanonicalType();
-              CanType identifier_input_type =
-                  identifier_uncurried_result->getInput()
-                      ->getCanonicalType();
-              if (identifier_result_type == type_result_type &&
-                  identifier_input_type == type_input_type) {
+              Type identifier_result_type =
+                  identifier_uncurried_result->getResult();
+              Type identifier_input_type =
+                  identifier_uncurried_result->getInput();
+              if (identifier_result_type->isEqual(type_result_type) &&
+                  identifier_input_type->isEqual(type_input_type)) {
                 break;
               }
             }

lib/SILOptimizer/IPO/UsePrespecialized.cpp

@@ -94,14 +94,9 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
     if (!SpecType)
       continue;
 
-    // Bail if any generic types parameters of the concrete type
-    // are unbound.
-    if (SpecType->hasArchetype())
-      continue;
-
-    // Bail if any generic types parameters of the concrete type
-    // are unbound.
-    if (hasUnboundGenericTypes(Subs))
+    // Bail any callee generic type parameters are dependent on the generic
+    // parameters of the caller.
+    if (SpecType->hasArchetype() || hasArchetypes(Subs))
       continue;
 
     // Create a name of the specialization.