ASTDemangler: Simplify createBoundGenericType()

It's clever how it leverages the type checker to check generic arguments,
but calling checkGenericArguments() would have been simpler, and it doesn't
work for interface types anyway, so we would fail to demangle those.

Let's just cut this all out for now and build a BoundGenericType directly.

Author: slavapestov

include/swift/AST/ASTDemangler.h

@@ -25,7 +25,6 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "swift/AST/Types.h"
-#include "swift/AST/TypeRepr.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/TypeDecoder.h"
 
@@ -134,30 +133,8 @@ class ASTBuilder {
                                               ForeignModuleKind lookupKind,
                                               Demangle::Node::Kind kind);
 
-  Type checkTypeRepr(TypeRepr *repr);
-
   static NominalTypeDecl *getAcceptableNominalTypeCandidate(ValueDecl *decl, 
                                                      Demangle::Node::Kind kind);
-
-  class TypeReprList {
-    SmallVector<FixedTypeRepr, 4> Reprs;
-    SmallVector<TypeRepr*, 4> Refs;
-
-  public:
-    explicit TypeReprList(ArrayRef<Type> types) {
-      Reprs.reserve(types.size());
-      Refs.reserve(types.size());
-
-      for (auto type : types) {
-        Reprs.emplace_back(type, SourceLoc());
-        Refs.push_back(&Reprs.back());
-      }
-    }
-
-    ArrayRef<TypeRepr*> getList() const {
-      return Refs;
-    }
-  };
 };
 
 }  // namespace Demangle

lib/AST/ASTDemangler.cpp

@@ -21,7 +21,6 @@
 
 #include "swift/AST/ASTDemangler.h"
 
-#include "swift/Subsystems.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericSignature.h"
@@ -155,90 +154,7 @@ Type ASTBuilder::createBoundGenericType(NominalTypeDecl *decl,
   if (!validateNominalParent(decl, parent))
     return Type();
 
-  // Make a generic type repr that's been resolved to this decl.
-  TypeReprList genericArgReprs(args);
-  auto genericRepr = GenericIdentTypeRepr::create(Ctx, SourceLoc(),
-                                                  decl->getName(),
-                                                  genericArgReprs.getList(),
-                                                  SourceRange());
-  // FIXME
-  genericRepr->setValue(decl, nullptr);
-
-  Type genericType;
-
-  // If we have a parent type, we need to build a compound type repr.
-  if (parent) {
-    // Life would be much easier if we could just use a FixedTypeRepr for
-    // the parent.  But we can't!  So we have to recursively expand
-    // like this; and recursing with a lambda isn't impossible, so it gets
-    // even worse.
-    SmallVector<Type, 4> ancestry;
-    for (auto p = parent; p; p = p->getNominalParent()) {
-      ancestry.push_back(p);
-    }
-
-    struct GenericRepr {
-      TypeReprList GenericArgs;
-      GenericIdentTypeRepr *Ident;
-
-      GenericRepr(const ASTContext &Ctx, BoundGenericType *type)
-        : GenericArgs(type->getGenericArgs()),
-          Ident(GenericIdentTypeRepr::create(Ctx, SourceLoc(),
-                                             type->getDecl()->getName(),
-                                             GenericArgs.getList(),
-                                             SourceRange())) {
-        // FIXME
-        Ident->setValue(type->getDecl(), nullptr);
-      }
-
-      // SmallVector::emplace_back will never need to call this because
-      // we reserve the right size, but it does try statically.
-      GenericRepr(const GenericRepr &other) : GenericArgs({}), Ident(nullptr) {
-        llvm_unreachable("should not be called dynamically");
-      }
-    };
-
-    // Pre-allocate the component vectors so that we can form references
-    // into them safely.
-    SmallVector<SimpleIdentTypeRepr, 4> simpleComponents;
-    SmallVector<GenericRepr, 4> genericComponents;
-    simpleComponents.reserve(ancestry.size());
-    genericComponents.reserve(ancestry.size());
-
-    // Build the parent hierarchy.
-    SmallVector<ComponentIdentTypeRepr*, 4> componentReprs;
-    for (size_t i = ancestry.size(); i != 0; --i) {
-      Type p = ancestry[i - 1];
-      if (auto boundGeneric = p->getAs<BoundGenericType>()) {
-        genericComponents.emplace_back(Ctx, boundGeneric);
-        componentReprs.push_back(genericComponents.back().Ident);
-      } else {
-        auto nominal = p->castTo<NominalType>();
-        simpleComponents.emplace_back(SourceLoc(),
-                                      nominal->getDecl()->getName());
-        // FIXME
-        simpleComponents.back().setValue(nominal->getDecl(), nullptr);
-        componentReprs.push_back(&simpleComponents.back());
-      }
-    }
-    componentReprs.push_back(genericRepr);
-
-    auto compoundRepr = CompoundIdentTypeRepr::create(Ctx, componentReprs);
-    genericType = checkTypeRepr(compoundRepr);
-  } else {
-    genericType = checkTypeRepr(genericRepr);
-  }
-
-  // If type-checking failed, we've failed.
-  if (!genericType) return Type();
-
-  // Validate that we used the right decl.
-  if (auto bgt = genericType->getAs<BoundGenericType>()) {
-    if (bgt->getDecl() != decl)
-      return Type();
-  }
-
-  return genericType;
+  return BoundGenericType::get(decl, parent, args);
 }
 
 Type ASTBuilder::createTupleType(ArrayRef<Type> eltTypes,
@@ -434,16 +350,6 @@ bool ASTBuilder::validateNominalParent(NominalTypeDecl *decl,
   return true;
 }
 
-Type ASTBuilder::checkTypeRepr(TypeRepr *repr) {
-  DeclContext *dc = getNotionalDC();
-
-  TypeLoc loc(repr);
-  if (performTypeLocChecking(Ctx, loc, dc, /*diagnose*/ false))
-    return Type();
-
-  return loc.getType();
-}
-
 NominalTypeDecl *
 ASTBuilder::getAcceptableNominalTypeCandidate(ValueDecl *decl, 
                                               Demangle::Node::Kind kind) {

test/TypeDecoder/nominal_types.swift

@@ -41,6 +41,12 @@ do {
   blackHole(x1, x2, x3)
 }
 
+protocol P {}
+
+struct Constrained<T : P> {}
+
+func generic<T>(_: Constrained<T>) {}
+
 // DEMANGLE: $s13nominal_types5OuterVD
 // CHECK: Outer
 
@@ -66,3 +72,6 @@ do {
 // DEMANGLE: $s13nominal_types12GenericOuterOySiSSGD
 // CHECK: GenericOuter<τ_0_0, τ_0_1>
 // CHECK: GenericOuter<Int, String>
+
+// DEMANGLE: $s13nominal_types11ConstrainedVyxGD
+// CHECK: Constrained<τ_0_0>