Constify Pattern::operator new and remove Pattern::clone completely,

it is dead now.  NFC.

Author: lattner

include/swift/AST/Pattern.h

@@ -162,14 +162,12 @@ class alignas(8) Pattern {
       VD->setParentPatternStmt(S);
     });
   }
-  
-  Pattern *clone(ASTContext &context) const;
 
   static bool classof(const Pattern *P) { return true; }
 
   //*** Allocation Routines ************************************************/
 
-  void *operator new(size_t bytes, ASTContext &C);
+  void *operator new(size_t bytes, const ASTContext &C);
 
   // Make placement new and vanilla new/delete illegal for Patterns.
   void *operator new(size_t bytes) = delete;

lib/AST/Pattern.cpp

@@ -290,145 +290,8 @@ case PatternKind::ID: foundRefutablePattern = true; break;
   return foundRefutablePattern;
 }
 
-Pattern *Pattern::clone(ASTContext &context) const {
-  Pattern *result;
-  switch (getKind()) {
-  case PatternKind::Any: {
-    result = new (context) AnyPattern(cast<AnyPattern>(this)->getLoc());
-    break;
-  }
-
-  case PatternKind::Named: {
-    auto named = cast<NamedPattern>(this);
-    VarDecl *var = new (context) VarDecl(!named->getDecl()->isInstanceMember(),
-                                         named->getDecl()->isLet(),
-                                         named->getLoc(),
-                                         named->getBoundName(),
-                                         named->getDecl()->hasType()
-                                         ? named->getDecl()->getType()
-                                         : Type(),
-                                         named->getDecl()->getDeclContext());
-
-    if (var->isImplicit())
-      var->setImplicit();
-    result = new (context) NamedPattern(var);
-    break;
-  }
-
-  case PatternKind::Paren: {
-    auto paren = cast<ParenPattern>(this);
-    result = new (context) ParenPattern(paren->getLParenLoc(),
-                                        paren->getSubPattern()->clone(context),
-                                        paren->getRParenLoc());
-    break;
-  }
-
-  case PatternKind::Tuple: {
-    auto tuple = cast<TuplePattern>(this);
-    SmallVector<TuplePatternElt, 2> elts;
-    elts.reserve(tuple->getNumElements());
-    for (const auto &elt : tuple->getElements()) {
-      auto eltPattern = elt.getPattern()->clone(context);
-      elts.push_back(TuplePatternElt(elt.getLabel(), elt.getLabelLoc(),
-                                     eltPattern));
-    }
-
-    result = TuplePattern::create(context, tuple->getLParenLoc(), elts,
-                                  tuple->getRParenLoc());
-    break;
-  }
-
-  case PatternKind::Typed: {
-    auto typed = cast<TypedPattern>(this);
-    auto subP = typed->getSubPattern()->clone(context);
-    result = new(context) TypedPattern(subP,
-                                       typed->getTypeLoc().clone(context));
-    break;
-  }
-      
-  case PatternKind::Is: {
-    auto isa = cast<IsPattern>(this);
-    result = new(context) IsPattern(isa->getLoc(),
-                                     isa->getCastTypeLoc().clone(context),
-                                     isa->getSubPattern()->clone(context),
-                                     isa->getCastKind());
-    break;
-  }
-      
-  case PatternKind::NominalType: {
-    auto nom = cast<NominalTypePattern>(this);
-    SmallVector<NominalTypePattern::Element, 4> elts;
-    for (const auto &elt : nom->getElements()) {
-      elts.push_back(NominalTypePattern::Element(elt.getPropertyLoc(),
-                                         elt.getPropertyName(),
-                                         elt.getProperty(),
-                                         elt.getColonLoc(),
-                                         elt.getSubPattern()->clone(context)));
-    }
-    
-    result = NominalTypePattern::create(nom->getCastTypeLoc().clone(context),
-                                        nom->getLParenLoc(),
-                                        elts,
-                                        nom->getRParenLoc(), context);
-    break;
-  }
-      
-  case PatternKind::EnumElement: {
-    auto oof = cast<EnumElementPattern>(this);
-    Pattern *sub = nullptr;
-    if (oof->hasSubPattern())
-      sub = oof->getSubPattern()->clone(context);
-    result = new (context) EnumElementPattern(oof->getParentType()
-                                                .clone(context),
-                                              oof->getLoc(),
-                                              oof->getNameLoc(),
-                                              oof->getName(),
-                                              oof->getElementDecl(),
-                                              sub);
-    break;
-  }
-
-  case PatternKind::OptionalSome: {
-    auto osp = cast<OptionalSomePattern>(this);
-    auto *sub = osp->getSubPattern()->clone(context);
-    auto *r = new (context) OptionalSomePattern(sub, osp->getQuestionLoc());
-    r->setElementDecl(osp->getElementDecl());
-    result = r;
-    break;
-  }
-
-  case PatternKind::Bool: {
-    auto bp = cast<BoolPattern>(this);
-    result = new (context) BoolPattern(bp->getNameLoc(), bp->getValue());
-    break;
-  }
-
-  case PatternKind::Expr: {
-    auto expr = cast<ExprPattern>(this);
-    result = new(context) ExprPattern(expr->getSubExpr(),
-                                      expr->isResolved(),
-                                      expr->getMatchExpr(),
-                                      expr->getMatchVar());
-    break;
-  }
-      
-  case PatternKind::Var: {
-    auto var = cast<VarPattern>(this);
-    auto subP = var->getSubPattern()->clone(context);
-    result = new(context) VarPattern(var->getLoc(), var->isLet(), subP);
-  }
-  }
-
-  if (hasType())
-    result->setType(getType());
-  if (isImplicit())
-    result->setImplicit();
-
-  return result;
-}
-
 /// Standard allocator for Patterns.
-void *Pattern::operator new(size_t numBytes, ASTContext &C) {
+void *Pattern::operator new(size_t numBytes, const ASTContext &C) {
   return C.Allocate(numBytes, alignof(Pattern));
 }