AST: Remove TypeRepr::clone()

Author: slavapestov

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/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>>";