Remove TypeRepr::clone()

include/swift/AST/TypeLoc.h

@@ -65,8 +65,6 @@ class alignas(1 << TypeLocAlignInBits) TypeLoc {
   void setInvalidType(ASTContext &C);
   void setType(Type Ty);
 
-  TypeLoc clone(ASTContext &ctx) const;
-
   friend llvm::hash_code hash_value(const TypeLoc &owner) {
     return llvm::hash_combine(owner.Ty.getPointer(), owner.TyR);
   }

include/swift/AST/TypeRepr.h

@@ -163,9 +163,6 @@ class alignas(8) TypeRepr {
   void print(raw_ostream &OS, const PrintOptions &Opts = PrintOptions()) const;
   void print(ASTPrinter &Printer, const PrintOptions &Opts) const;
   SWIFT_DEBUG_DUMP;
-
-  /// Clone the given type representation.
-  TypeRepr *clone(const ASTContext &ctx) const;
 };
 
 /// A TypeRepr for a type with a syntax error.  Can be used both as a

lib/AST/Decl.cpp

@@ -924,53 +924,13 @@ GenericParamList::clone(DeclContext *dc) const {
       GenericTypeParamDecl::InvalidDepth,
       param->getIndex());
     params.push_back(newParam);
-
-    SmallVector<TypeLoc, 2> inherited;
-    for (auto loc : param->getInherited())
-      inherited.push_back(loc.clone(ctx));
-    newParam->setInherited(ctx.AllocateCopy(inherited));
-  }
-
-  SmallVector<RequirementRepr, 2> requirements;
-  for (auto reqt : getRequirements()) {
-    switch (reqt.getKind()) {
-    case RequirementReprKind::TypeConstraint: {
-      auto first = reqt.getSubjectLoc();
-      auto second = reqt.getConstraintLoc();
-      reqt = RequirementRepr::getTypeConstraint(
-          first.clone(ctx),
-          reqt.getSeparatorLoc(),
-          second.clone(ctx));
-      break;
-    }
-    case RequirementReprKind::SameType: {
-      auto first = reqt.getFirstTypeLoc();
-      auto second = reqt.getSecondTypeLoc();
-      reqt = RequirementRepr::getSameType(
-          first.clone(ctx),
-          reqt.getSeparatorLoc(),
-          second.clone(ctx));
-      break;
-    }
-    case RequirementReprKind::LayoutConstraint: {
-      auto first = reqt.getSubjectLoc();
-      auto layout = reqt.getLayoutConstraintLoc();
-      reqt = RequirementRepr::getLayoutConstraint(
-          first.clone(ctx),
-          reqt.getSeparatorLoc(),
-          layout);
-      break;
-    }
-    }
-
-    requirements.push_back(reqt);
   }
 
   return GenericParamList::create(ctx,
                                   getLAngleLoc(),
                                   params,
                                   getWhereLoc(),
-                                  requirements,
+                                  /*requirements=*/{},
                                   getRAngleLoc());
 }
 
@@ -6152,8 +6112,6 @@ ParamDecl *ParamDecl::cloneWithoutType(const ASTContext &Ctx, ParamDecl *PD) {
       nullptr, PD->DefaultValueAndFlags.getInt());
   Clone->Bits.ParamDecl.defaultArgumentKind =
       PD->Bits.ParamDecl.defaultArgumentKind;
-  if (auto *repr = PD->getTypeRepr())
-    Clone->setTypeRepr(repr->clone(Ctx));
 
   Clone->setSpecifier(PD->getSpecifier());
   Clone->setImplicitlyUnwrappedOptional(PD->isImplicitlyUnwrappedOptional());

lib/AST/Type.cpp

@@ -90,13 +90,6 @@ SourceRange TypeLoc::getSourceRange() const {
   return SourceRange();
 }
 
-TypeLoc TypeLoc::clone(ASTContext &ctx) const {
-  if (TyR) {
-    return TypeLoc(TyR->clone(ctx), Ty);
-  }
-  return *this;
-}
-
 SourceLoc TypeLoc::getLoc() const {
   if (TyR) return TyR->getLoc();
   return SourceLoc();

lib/AST/TypeRepr.cpp

@@ -116,158 +116,6 @@ void TypeRepr::print(ASTPrinter &Printer, const PrintOptions &Opts) const {
   llvm_unreachable("unknown kind!");
 }
 
-namespace {
-  class CloneVisitor : public TypeReprVisitor<CloneVisitor, TypeRepr *> {
-    const ASTContext &Ctx;
-
-  public:
-    explicit CloneVisitor(const ASTContext &ctx) : Ctx(ctx) { }
-
-#define TYPEREPR(CLASS, PARENT) \
-    TypeRepr *visit##CLASS##TypeRepr(CLASS##TypeRepr* type);
-#include "swift/AST/TypeReprNodes.def"
-  };
-} // end anonymous namespace
-
-TypeRepr *CloneVisitor::visitErrorTypeRepr(ErrorTypeRepr *T) {
-  return new (Ctx) ErrorTypeRepr(T->getSourceRange());
-}
-
-TypeRepr *CloneVisitor::visitAttributedTypeRepr(AttributedTypeRepr *T) {
-  return new (Ctx) AttributedTypeRepr(T->getAttrs(), visit(T->getTypeRepr()));
-}
-
-TypeRepr *CloneVisitor::visitSimpleIdentTypeRepr(SimpleIdentTypeRepr *T) {
-  return new (Ctx) SimpleIdentTypeRepr(T->getNameLoc(), T->getNameRef());
-}
-
-TypeRepr *CloneVisitor::visitGenericIdentTypeRepr(GenericIdentTypeRepr *T) {
-  // Clone the generic arguments.
-  SmallVector<TypeRepr*, 8> genericArgs;
-  genericArgs.reserve(T->getGenericArgs().size());
-  for (auto &arg : T->getGenericArgs()) {
-    genericArgs.push_back(visit(arg));
-  }
-  return GenericIdentTypeRepr::create(Ctx, T->getNameLoc(), T->getNameRef(),
-                                        genericArgs, T->getAngleBrackets());
-}
-
-TypeRepr *CloneVisitor::visitCompoundIdentTypeRepr(CompoundIdentTypeRepr *T) {
-  // Clone the components.
-  SmallVector<ComponentIdentTypeRepr*, 8> components;
-  components.reserve(T->getComponents().size());
-  for (auto &component : T->getComponents()) {
-    components.push_back(cast<ComponentIdentTypeRepr>(visit(component)));
-  }
-  return CompoundIdentTypeRepr::create(Ctx, components);
-}
-
-TypeRepr *CloneVisitor::visitFunctionTypeRepr(FunctionTypeRepr *T) {
-  return new (Ctx) FunctionTypeRepr(
-                              /*FIXME: Clone?*/T->getGenericParams(),
-                              cast<TupleTypeRepr>(visit(T->getArgsTypeRepr())),
-                              T->getThrowsLoc(),
-                              T->getArrowLoc(),
-                              visit(T->getResultTypeRepr()));
-}
-
-TypeRepr *CloneVisitor::visitArrayTypeRepr(ArrayTypeRepr *T) {
-  return new (Ctx) ArrayTypeRepr(visit(T->getBase()), T->getBrackets());
-}
-
-TypeRepr *CloneVisitor::visitDictionaryTypeRepr(DictionaryTypeRepr *T) {
-  return new (Ctx) DictionaryTypeRepr(visit(T->getKey()), visit(T->getValue()),
-                                      T->getColonLoc(), T->getBrackets());
-}
-
-TypeRepr *CloneVisitor::visitOptionalTypeRepr(OptionalTypeRepr *T) {
-  return new (Ctx) OptionalTypeRepr(visit(T->getBase()), T->getQuestionLoc());
-}
-
-TypeRepr * CloneVisitor::visitImplicitlyUnwrappedOptionalTypeRepr(
-             ImplicitlyUnwrappedOptionalTypeRepr *T) {
-  return new (Ctx) ImplicitlyUnwrappedOptionalTypeRepr(visit(T->getBase()),
-                                                       T->getExclamationLoc());
-}
-
-TypeRepr *CloneVisitor::visitTupleTypeRepr(TupleTypeRepr *T) {
-  SmallVector<TupleTypeReprElement, 8> elements;
-  elements.reserve(T->getNumElements());
-  for (auto arg : T->getElements()) {
-    arg.Type = visit(arg.Type);
-    elements.push_back(arg);
-  }
-  return TupleTypeRepr::create(Ctx, elements,
-                               T->getParens(),
-                               T->getEllipsisLoc(),
-                               T->getEllipsisIndex());
-}
-
-TypeRepr *CloneVisitor::visitCompositionTypeRepr(CompositionTypeRepr *T) {
-  // Clone the protocols.
-  SmallVector<TypeRepr*, 8> types;
-  types.reserve(T->getTypes().size());
-  for (auto &type : T->getTypes()) {
-    types.push_back(cast<TypeRepr>(visit(type)));
-  }
-
-  return CompositionTypeRepr::create(Ctx, types, T->getStartLoc(),
-                                     T->getCompositionRange());
-}
-
-TypeRepr *CloneVisitor::visitMetatypeTypeRepr(MetatypeTypeRepr *T) {
-  return new (Ctx) MetatypeTypeRepr(visit(T->getBase()), T->getMetaLoc());
-}
-
-TypeRepr *CloneVisitor::visitProtocolTypeRepr(ProtocolTypeRepr *T) {
-  return new (Ctx) ProtocolTypeRepr(visit(T->getBase()), T->getProtocolLoc());
-}
-
-TypeRepr *CloneVisitor::visitInOutTypeRepr(InOutTypeRepr *T) {
-  return new (Ctx) InOutTypeRepr(visit(T->getBase()), T->getSpecifierLoc());
-}
-
-TypeRepr *CloneVisitor::visitSharedTypeRepr(SharedTypeRepr *T) {
-  return new (Ctx) SharedTypeRepr(visit(T->getBase()), T->getSpecifierLoc());
-}
-
-TypeRepr *CloneVisitor::visitOwnedTypeRepr(OwnedTypeRepr *T) {
-  return new (Ctx) OwnedTypeRepr(visit(T->getBase()), T->getSpecifierLoc());
-}
-
-TypeRepr *CloneVisitor::visitFixedTypeRepr(FixedTypeRepr *T) {
-  return new (Ctx) FixedTypeRepr(T->getType(), T->getLoc());
-}
-
-TypeRepr *CloneVisitor::visitSILBoxTypeRepr(SILBoxTypeRepr *type) {
-  SmallVector<SILBoxTypeRepr::Field, 4> cloneFields;
-  SmallVector<TypeRepr *, 4> cloneArgs;
-
-  for (auto &field : type->getFields())
-    cloneFields.push_back({field.getLoc(), field.isMutable(),
-                           visit(field.getFieldType())});
-  for (auto *arg : type->getGenericArguments())
-    cloneArgs.push_back(visit(arg));
-
-  return new (Ctx) SILBoxTypeRepr(/*FIXME: Clone?*/type->getGenericParams(),
-                                type->getLBraceLoc(),
-                                Ctx.AllocateCopy(cloneFields),
-                                type->getRBraceLoc(),
-                                type->getArgumentLAngleLoc(),
-                                Ctx.AllocateCopy(cloneArgs),
-                                type->getArgumentRAngleLoc());
-}
-
-TypeRepr *CloneVisitor::visitOpaqueReturnTypeRepr(OpaqueReturnTypeRepr *type) {
-  return new (Ctx) OpaqueReturnTypeRepr(type->getOpaqueLoc(),
-                                        visit(type->getConstraint()));
-}
-
-TypeRepr *TypeRepr::clone(const ASTContext &ctx) const {
-  CloneVisitor visitor(ctx);
-  return visitor.visit(const_cast<TypeRepr *>(this));
-}
-
 void ErrorTypeRepr::printImpl(ASTPrinter &Printer,
                               const PrintOptions &Opts) const {
   Printer << "<<error type>>";

lib/Sema/CSSolver.cpp

@@ -991,13 +991,8 @@ void ConstraintSystem::shrink(Expr *expr) {
           auto typeRepr = castTypeLoc.getTypeRepr();
 
           if (typeRepr && isSuitableCollection(typeRepr)) {
-            // Clone representative to avoid modifying in-place,
-            // FIXME: We should try and silently resolve the type here,
-            // instead of cloning representative.
-            auto coercionRepr = typeRepr->clone(CS.getASTContext());
-            // Let's try to resolve coercion type from cloned representative.
             auto resolution = TypeResolution::forContextual(CS.DC, None);
-            auto coercionType = resolution.resolveType(coercionRepr);
+            auto coercionType = resolution.resolveType(typeRepr);
 
             // Looks like coercion type is invalid, let's skip this sub-tree.
             if (coercionType->hasError())