AST: Kill Type::getAllGenericArgs()

This was almost identical to getMemberSubstitutions(), except
protocol and protocol extension members are not properly
supported.

Now that this method is no longer used by the ASTPrinter, there
are only two remaining usages, both trivially refactorable to
use better APIs.

Author: slavapestov

include/swift/AST/Types.h

@@ -554,12 +554,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// specialized, but the type Vector is not.
   bool isSpecialized();
 
-  /// Retrieve the complete set of generic arguments for a specialized type.
-  ///
-  /// \param scratch Scratch space to use when the complete list needs to be
-  /// stitched together from multiple lists of generic arguments.
-  ArrayRef<Type> getAllGenericArgs(SmallVectorImpl<Type> &scratch);
-
   /// Gather all of the substitutions used to produce the given specialized type
   /// from its unspecialized type.
   ///

lib/AST/Type.cpp

@@ -277,69 +277,6 @@ bool TypeBase::isSpecialized() {
   });
 }
 
-ArrayRef<Type> TypeBase::getAllGenericArgs(SmallVectorImpl<Type> &scratch) {
-  Type type(this);
-  SmallVector<ArrayRef<Type>, 2> allGenericArgs;
-
-  while (type) {
-    // Gather generic arguments from a bound generic type.
-    if (auto bound = type->getAs<BoundGenericType>()) {
-      allGenericArgs.push_back(bound->getGenericArgs());
-
-      // Continue up to the parent.
-      type = bound->getParent();
-      continue;
-    }
-
-    // Use the generic type parameter types for an unbound generic type.
-    if (auto unbound = type->getAs<UnboundGenericType>()) {
-      auto genericSig = unbound->getDecl()->getGenericSignature();
-      auto genericParams = genericSig->getInnermostGenericParams();
-      allGenericArgs.push_back(
-        llvm::makeArrayRef((const Type *)genericParams.data(),
-                           genericParams.size()));
-
-      // Continue up to the parent.
-      type = unbound->getParent();
-      continue;
-    }
-
-    // For a protocol type, use its Self parameter.
-    if (auto protoType = type->getAs<ProtocolType>()) {
-      auto proto = protoType->getDecl();
-      allGenericArgs.push_back(
-        llvm::makeArrayRef(proto->getSelfInterfaceType()));
-
-      // Continue up to the parent.
-      type = protoType->getParent();
-      continue;
-    }
-
-    // Look through non-generic nominal types.
-    if (auto nominal = type->getAs<NominalType>()) {
-      type = nominal->getParent();
-      continue;
-    }
-
-    break;
-  }
-
-  // Trivial case: no generic arguments.
-  if (allGenericArgs.empty())
-    return { };
-
-  // Common case: a single set of generic arguments, for which we need no
-  // allocation.
-  if (allGenericArgs.size() == 1)
-    return allGenericArgs.front();
-
-  // General case: concatenate all of the generic argument lists together.
-  scratch.clear();
-  for (auto args : reversed(allGenericArgs))
-    scratch.append(args.begin(), args.end());
-  return scratch;
-}
-
 bool TypeBase::isUnspecializedGeneric() {
   CanType CT = getCanonicalType();
   if (CT.getPointer() != this)

lib/Sema/CSDiag.cpp

@@ -4074,10 +4074,11 @@ bool FailureDiagnosis::diagnoseContextualConversionError() {
 
   // When converting from T to [T] or UnsafePointer<T>, we can offer fixit to wrap
   // the expr with brackets.
-  if (auto *contextDecl = contextualType->getAnyNominal()) {
+  auto *genericType = contextualType->getAs<BoundGenericType>();
+  if (genericType) {
+    auto *contextDecl = genericType->getDecl();
     if (contextDecl == CS->TC.Context.getArrayDecl()) {
-      SmallVector<Type, 4> scratch;
-      for (Type arg : contextualType->getAllGenericArgs(scratch)) {
+      for (Type arg : genericType->getGenericArgs()) {
         if (arg->isEqual(exprType)) {
           diagnose(expr->getLoc(), diagID, exprType, contextualType).
             fixItInsert(expr->getStartLoc(), "[").fixItInsert(
@@ -4090,8 +4091,7 @@ bool FailureDiagnosis::diagnoseContextualConversionError() {
                contextDecl == CS->TC.Context.getUnsafeMutablePointerDecl() ||
                contextDecl == CS->TC.Context.getUnsafeRawPointerDecl() ||
                contextDecl == CS->TC.Context.getUnsafeMutableRawPointerDecl()) {
-      SmallVector<Type, 4> scratch;
-      for (Type arg : contextualType->getAllGenericArgs(scratch)) {
+      for (Type arg : genericType->getGenericArgs()) {
         if (arg->isEqual(exprType) && expr->getType()->isLValueType()) {
           diagnose(expr->getLoc(), diagID, exprType, contextualType).
             fixItInsert(expr->getStartLoc(), "&");

lib/Sema/TypeCheckGeneric.cpp

@@ -980,32 +980,31 @@ void TypeChecker::revertGenericFuncSignature(AbstractFunctionDecl *func) {
 /// \param types The types that will be scanned for generic type parameters,
 /// which will be used in the resulting type.
 ///
-/// \param genericParams The actual generic parameters, whose names will be used
+/// \param genericSig The actual generic parameters, whose names will be used
 /// in the resulting text.
 ///
 /// \param substitutions The generic parameter -> generic argument substitutions
 /// that will have been applied to these types. These are used to produce the
 /// "parameter = argument" bindings in the test.
 static std::string gatherGenericParamBindingsText(
                      ArrayRef<Type> types,
-                     ArrayRef<GenericTypeParamType *> genericParams,
-                     TypeSubstitutionMap &substitutions) {
+                     GenericSignature *genericSig,
+                     const TypeSubstitutionMap &substitutions) {
   llvm::SmallPtrSet<GenericTypeParamType *, 2> knownGenericParams;
   for (auto type : types) {
-    type.findIf([&](Type type) -> bool {
+    type.visit([&](Type type) {
       if (auto gp = type->getAs<GenericTypeParamType>()) {
         knownGenericParams.insert(gp->getCanonicalType()
                                     ->castTo<GenericTypeParamType>());
       }
-      return false;
     });
   }
 
   if (knownGenericParams.empty())
     return "";
 
   SmallString<128> result;
-  for (auto gp : genericParams) {
+  for (auto gp : genericSig->getGenericParams()) {
     auto canonGP = gp->getCanonicalType()->castTo<GenericTypeParamType>();
     if (!knownGenericParams.count(canonGP))
       continue;
@@ -1016,7 +1015,12 @@ static std::string gatherGenericParamBindingsText(
       result += ", ";
     result += gp->getName().str();
     result += " = ";
-    result += substitutions[canonGP].getString();
+
+    auto found = substitutions.find(canonGP);
+    if (found == substitutions.end())
+      return "";
+
+    result += found->second.getString();
   }
 
   result += "]";
@@ -1027,31 +1031,7 @@ bool TypeChecker::checkGenericArguments(DeclContext *dc, SourceLoc loc,
                                         SourceLoc noteLoc,
                                         Type owner,
                                         GenericSignature *genericSig,
-                                        ArrayRef<Type> genericArgs) {
-  // Form the set of generic substitutions required
-  TypeSubstitutionMap substitutions;
-
-  auto genericParams = genericSig->getGenericParams();
-
-  unsigned count = 0;
-
-  // If the type is nested inside a generic function, skip
-  // substitutions from the outer context.
-  unsigned start = (genericParams.size() - genericArgs.size());
-
-  for (auto gp : genericParams) {
-    if (count >= start) {
-      auto gpTy = gp->getCanonicalType()->castTo<GenericTypeParamType>();
-      substitutions[gpTy] = genericArgs[count - start];
-    }
-
-    count++;
-  }
-
-  // The number of generic type arguments being bound must be equal to the
-  // total number of generic parameters in the current generic type context.
-  assert(count - start == genericArgs.size());
-
+                                        const TypeSubstitutionMap &substitutions) {
   // Check each of the requirements.
   Module *module = dc->getParentModule();
   for (const auto &req : genericSig->getRequirements()) {
@@ -1099,7 +1079,7 @@ bool TypeChecker::checkGenericArguments(DeclContext *dc, SourceLoc loc,
                  req.getFirstType(), req.getSecondType(),
                  gatherGenericParamBindingsText(
                    {req.getFirstType(), req.getSecondType()},
-                   genericParams, substitutions));
+                   genericSig, substitutions));
         return true;
       }
       continue;
@@ -1113,7 +1093,7 @@ bool TypeChecker::checkGenericArguments(DeclContext *dc, SourceLoc loc,
                  req.getFirstType(), req.getSecondType(),
                  gatherGenericParamBindingsText(
                    {req.getFirstType(), req.getSecondType()},
-                   genericParams, substitutions));
+                   genericSig, substitutions));
         return true;
       }
       continue;

lib/Sema/TypeCheckType.cpp

@@ -582,19 +582,19 @@ Type TypeChecker::applyUnboundGenericArguments(
     // FIXME: Record that we're checking substitutions, so we can't end up
     // with infinite recursion.
 
-    // Collect the complete set of generic arguments.
-    SmallVector<Type, 4> scratch;
-    ArrayRef<Type> allGenericArgs = BGT->getAllGenericArgs(scratch);
-
     // Check the generic arguments against the generic signature.
     auto genericSig = decl->getGenericSignature();
     if (!decl->hasType() || decl->isValidatingGenericSignature()) {
       diagnose(loc, diag::recursive_requirement_reference);
       return nullptr;
     }
+
+    // Collect the complete set of generic arguments.
     assert(genericSig != nullptr);
+    auto substitutions = BGT->getMemberSubstitutions(BGT->getDecl());
+
     if (checkGenericArguments(dc, loc, noteLoc, UGT, genericSig,
-                              allGenericArgs))
+                              substitutions))
       return nullptr;
 
     useObjectiveCBridgeableConformancesOfArgs(dc, BGT);

lib/Sema/TypeChecker.h

@@ -1088,14 +1088,14 @@ class TypeChecker final : public LazyResolver {
   /// \param noteLoc The location at which any notes will be printed.
   /// \param owner The type that owns the generic signature.
   /// \param genericSig The actual generic signature.
-  /// \param genericArgs The generic arguments.
+  /// \param substitutions Substitutions from interface types of the signature.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool checkGenericArguments(DeclContext *dc, SourceLoc loc,
                              SourceLoc noteLoc,
                              Type owner,
                              GenericSignature *genericSig,
-                             ArrayRef<Type> genericArgs);
+                             const TypeSubstitutionMap &substitutions);
 
   /// Resolve the superclass of the given class.
   void resolveSuperclass(ClassDecl *classDecl) override;