Add the ability to clone integer and string literals. Use it when instantiating template expressions.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@67030 91177308-0d34-0410-b5e6-96231b3b80d8

include/clang/AST/Expr.h

@@ -377,6 +377,9 @@ public:
     : Expr(IntegerLiteralClass, type), Value(V), Loc(l) {
     assert(type->isIntegerType() && "Illegal type in IntegerLiteral");
   }
+
+  IntegerLiteral* Clone(ASTContext &C) const;
+  
   const llvm::APInt &getValue() const { return Value; }
   virtual SourceRange getSourceRange() const { return SourceRange(Loc); }
 
@@ -515,7 +518,7 @@ public:
   /// strings formed from multiple concatenated tokens.
   static StringLiteral *Create(ASTContext &C, const char *StrData,
                                unsigned ByteLength, bool Wide, QualType Ty,
-                               SourceLocation *Loc, unsigned NumStrs);
+                               const SourceLocation *Loc, unsigned NumStrs);
 
   /// Simple constructor for string literals made from one token.
   static StringLiteral *Create(ASTContext &C, const char *StrData, 
@@ -523,7 +526,8 @@ public:
                                bool Wide, QualType Ty, SourceLocation Loc) {
     return Create(C, StrData, ByteLength, Wide, Ty, &Loc, 1);
   }
-  
+
+  StringLiteral* Clone(ASTContext &C) const;
   void Destroy(ASTContext &C);
   
   const char *getStrData() const { return StrData; }

lib/AST/Expr.cpp

@@ -26,6 +26,10 @@ using namespace clang;
 // Primary Expressions.
 //===----------------------------------------------------------------------===//
 
+IntegerLiteral* IntegerLiteral::Clone(ASTContext &C) const {
+  return new (C) IntegerLiteral(Value, getType(), Loc);
+}
+
 /// getValueAsApproximateDouble - This returns the value as an inaccurate
 /// double.  Note that this may cause loss of precision, but is useful for
 /// debugging dumps, etc.
@@ -40,7 +44,8 @@ double FloatingLiteral::getValueAsApproximateDouble() const {
 StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
                                      unsigned ByteLength, bool Wide,
                                      QualType Ty,
-                                     SourceLocation *Loc, unsigned NumStrs) {
+                                     const SourceLocation *Loc, 
+                                     unsigned NumStrs) {
   // Allocate enough space for the StringLiteral plus an array of locations for
   // any concatenated string tokens.
   void *Mem = C.Allocate(sizeof(StringLiteral)+
@@ -62,6 +67,10 @@ StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
   return SL;
 }
 
+StringLiteral* StringLiteral::Clone(ASTContext &C) const {
+  return Create(C, StrData, ByteLength, IsWide, getType(),
+                TokLocs, NumConcatenated);
+}
 
 void StringLiteral::Destroy(ASTContext &C) {
   C.Deallocate(const_cast<char*>(StrData));

lib/Sema/Sema.h

@@ -1867,6 +1867,14 @@ public:
                            ClassTemplateSpecializationDecl *ClassTemplateSpec,
                            bool ExplicitInstantiation);
 
+  // Simple function for cloning expressions.
+  template<typename T> 
+  OwningExprResult Clone(T *E) {
+    assert(!E->isValueDependent() && !E->isTypeDependent() &&
+           "expression is value or type dependent!");
+    return Owned(E->Clone(Context));
+  }
+  
   // Objective-C declarations.
   virtual DeclTy *ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
                                            IdentifierInfo *ClassName,

lib/Sema/SemaTemplateInstantiate.cpp

@@ -591,7 +591,8 @@ namespace {
     OwningExprResult VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
 
     // Base case. I'm supposed to ignore this.
-    Sema::OwningExprResult VisitStmt(Stmt *) { 
+    Sema::OwningExprResult VisitStmt(Stmt *S) { 
+      S->dump();
       assert(false && "Cannot instantiate this kind of expression");
       return SemaRef.ExprError(); 
     }
@@ -600,10 +601,7 @@ namespace {
 
 Sema::OwningExprResult 
 TemplateExprInstantiator::VisitIntegerLiteral(IntegerLiteral *E) {
-  // FIXME: Can't we just re-use the expression node?
-  return SemaRef.Owned(new (SemaRef.Context) IntegerLiteral(E->getValue(), 
-                                                            E->getType(),
-                                                            E->getLocation()));
+  return SemaRef.Clone(E);
 }
 
 Sema::OwningExprResult