Variadic templates: extend the Expr class with a bit that specifies

whether the expression contains an unexpanded parameter pack, in the
same vein as the changes to the Type hierarchy. Compute this bit
within all of the Expr subclasses.

This change required a bunch of reshuffling of dependency
calculations, mainly to consolidate them inside the constructors and
to fuse multiple loops that iterate over arguments to determine type
dependence, value dependence, and (now) containment of unexpanded
parameter packs.

Again, testing is painfully sparse, because all of the diagnostics
will change and it is more important to test the to-be-written visitor
that collects unexpanded parameter packs.



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

6 files changed, 177 insertions, 128 deletions

diff --git a/include/clang/AST/DeclarationName.h b/include/clang/AST/DeclarationName.h
index 9adc15980c..309535be50 100644
--- a/include/clang/AST/DeclarationName.h
+++ b/include/clang/AST/DeclarationName.h
@@ -492,6 +492,10 @@ public:
     LocInfo.CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();
   }
 
+  /// \brief Determine whether this name contains an unexpanded
+  /// parameter pack.
+  bool containsUnexpandedParameterPack() const;
+
   /// getAsString - Retrieve the human-readable string for this name.
   std::string getAsString() const;
 
diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 5039baa03a..d46ef43ee6 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -57,13 +57,12 @@ class Expr : public Stmt {
 
 protected:
   Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK,
-       bool TD, bool VD) : Stmt(SC) {
+       bool TD, bool VD, bool ContainsUnexpandedParameterPack) : Stmt(SC) {
     ExprBits.TypeDependent = TD;
     ExprBits.ValueDependent = VD;
     ExprBits.ValueKind = VK;
     ExprBits.ObjectKind = OK;
-    // FIXME: Variadic templates.
-    ExprBits.ContainsUnexpandedParameterPack = false;
+    ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
     setType(T);
   }
 
@@ -132,6 +131,12 @@ public:
     return ExprBits.ContainsUnexpandedParameterPack; 
   }
 
+  /// \brief Set the bit that describes whether this expression
+  /// contains an unexpanded parameter pack.
+  void setContainsUnexpandedParameterPack(bool PP = true) {
+    ExprBits.ContainsUnexpandedParameterPack = PP;
+  }
+
   /// SourceLocation tokens are not useful in isolation - they are low level
   /// value objects created/interpreted by SourceManager. We assume AST
   /// clients will have a pointer to the respective SourceManager.
@@ -568,6 +573,8 @@ struct ExplicitTemplateArgumentList {
   }
 
   void initializeFrom(const TemplateArgumentListInfo &List);
+  void initializeFrom(const TemplateArgumentListInfo &List,
+                      bool &Dependent, bool &ContainsUnexpandedParameterPack);
   void copyInto(TemplateArgumentListInfo &List) const;
   static std::size_t sizeFor(unsigned NumTemplateArgs);
   static std::size_t sizeFor(const TemplateArgumentListInfo &List);
@@ -631,7 +638,7 @@ class DeclRefExpr : public Expr {
 
 public:
   DeclRefExpr(ValueDecl *d, QualType t, ExprValueKind VK, SourceLocation l) :
-    Expr(DeclRefExprClass, t, VK, OK_Ordinary, false, false),
+    Expr(DeclRefExprClass, t, VK, OK_Ordinary, false, false, false),
     DecoratedD(d, 0), Loc(l) {
     computeDependence();
   }
@@ -795,7 +802,8 @@ private:
 public:
   PredefinedExpr(SourceLocation l, QualType type, IdentType IT)
     : Expr(PredefinedExprClass, type, VK_LValue, OK_Ordinary,
-           type->isDependentType(), type->isDependentType()),
+           type->isDependentType(), type->isDependentType(), 
+           /*ContainsUnexpandedParameterPack=*/false),
       Loc(l), Type(IT) {}
 
   /// \brief Construct an empty predefined expression.
@@ -882,7 +890,8 @@ public:
   // or UnsignedLongLongTy
   IntegerLiteral(ASTContext &C, const llvm::APInt &V,
                  QualType type, SourceLocation l)
-    : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary, false, false),
+    : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
+           false),
       Loc(l) {
     assert(type->isIntegerType() && "Illegal type in IntegerLiteral");
     setValue(C, V);
@@ -920,7 +929,8 @@ class CharacterLiteral : public Expr {
 public:
   // type should be IntTy
   CharacterLiteral(unsigned value, bool iswide, QualType type, SourceLocation l)
-    : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false),
+    : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
+           false),
       Value(value), Loc(l), IsWide(iswide) {
   }
 
@@ -955,7 +965,8 @@ class FloatingLiteral : public Expr {
 
   FloatingLiteral(ASTContext &C, const llvm::APFloat &V, bool isexact,
                   QualType Type, SourceLocation L)
-    : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary, false, false),
+    : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary, false, false,
+           false),
       IsExact(isexact), Loc(L) {
     setValue(C, V);
   }
@@ -1006,7 +1017,8 @@ class ImaginaryLiteral : public Expr {
   Stmt *Val;
 public:
   ImaginaryLiteral(Expr *val, QualType Ty)
-    : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false),
+    : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false,
+           false),
       Val(val) {}
 
   /// \brief Build an empty imaginary literal.
@@ -1052,7 +1064,7 @@ class StringLiteral : public Expr {
   SourceLocation TokLocs[1];
 
   StringLiteral(QualType Ty) :
-    Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary, false, false) {}
+    Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary, false, false, false) {}
 
 public:
   /// This is the "fully general" constructor that allows representation of
@@ -1140,7 +1152,8 @@ public:
   ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
     : Expr(ParenExprClass, val->getType(),
            val->getValueKind(), val->getObjectKind(),
-           val->isTypeDependent(), val->isValueDependent()),
+           val->isTypeDependent(), val->isValueDependent(),
+           val->containsUnexpandedParameterPack()),
       L(l), R(r), Val(val) {}
 
   /// \brief Construct an empty parenthesized expression.
@@ -1196,7 +1209,8 @@ public:
                 ExprValueKind VK, ExprObjectKind OK, SourceLocation l)
     : Expr(UnaryOperatorClass, type, VK, OK,
            input->isTypeDependent() || type->isDependentType(),
-           input->isValueDependent()),
+           input->isValueDependent(),
+           input->containsUnexpandedParameterPack()),
       Opc(opc), Loc(l), Val(input) {}
 
   /// \brief Build an empty unary operator.
@@ -1483,7 +1497,8 @@ public:
       Expr(SizeOfAlignOfExprClass, resultType, VK_RValue, OK_Ordinary,
            false, // Never type-dependent (C++ [temp.dep.expr]p3).
            // Value-dependent if the argument is type-dependent.
-           TInfo->getType()->isDependentType()),
+           TInfo->getType()->isDependentType(),
+           TInfo->getType()->containsUnexpandedParameterPack()),
       isSizeof(issizeof), isType(true), OpLoc(op), RParenLoc(rp) {
     Argument.Ty = TInfo;
   }
@@ -1494,7 +1509,8 @@ public:
       Expr(SizeOfAlignOfExprClass, resultType, VK_RValue, OK_Ordinary,
            false, // Never type-dependent (C++ [temp.dep.expr]p3).
            // Value-dependent if the argument is type-dependent.
-           E->isTypeDependent()),
+           E->isTypeDependent(),
+           E->containsUnexpandedParameterPack()),
       isSizeof(issizeof), isType(false), OpLoc(op), RParenLoc(rp) {
     Argument.Ex = E;
   }
@@ -1569,7 +1585,9 @@ public:
                      SourceLocation rbracketloc)
   : Expr(ArraySubscriptExprClass, t, VK, OK,
          lhs->isTypeDependent() || rhs->isTypeDependent(),
-         lhs->isValueDependent() || rhs->isValueDependent()),
+         lhs->isValueDependent() || rhs->isValueDependent(),
+         (lhs->containsUnexpandedParameterPack() ||
+          rhs->containsUnexpandedParameterPack())),
     RBracketLoc(rbracketloc) {
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
@@ -1790,7 +1808,8 @@ public:
              const DeclarationNameInfo &NameInfo, QualType ty,
              ExprValueKind VK, ExprObjectKind OK)
     : Expr(MemberExprClass, ty, VK, OK,
-           base->isTypeDependent(), base->isValueDependent()),
+           base->isTypeDependent(), base->isValueDependent(),
+           base->containsUnexpandedParameterPack()),
       Base(base), MemberDecl(memberdecl), MemberLoc(NameInfo.getLoc()),
       MemberDNLoc(NameInfo.getInfo()), IsArrow(isarrow),
       HasQualifierOrFoundDecl(false), HasExplicitTemplateArgumentList(false) {
@@ -1805,7 +1824,8 @@ public:
              SourceLocation l, QualType ty,
              ExprValueKind VK, ExprObjectKind OK)
     : Expr(MemberExprClass, ty, VK, OK,
-           base->isTypeDependent(), base->isValueDependent()),
+           base->isTypeDependent(), base->isValueDependent(),
+           base->containsUnexpandedParameterPack()),
       Base(base), MemberDecl(memberdecl), MemberLoc(l), MemberDNLoc(),
       IsArrow(isarrow),
       HasQualifierOrFoundDecl(false), HasExplicitTemplateArgumentList(false) {}
@@ -1991,11 +2011,12 @@ class CompoundLiteralExpr : public Expr {
   Stmt *Init;
   bool FileScope;
 public:
-  // FIXME: Can compound literals be value-dependent?
   CompoundLiteralExpr(SourceLocation lparenloc, TypeSourceInfo *tinfo,
                       QualType T, ExprValueKind VK, Expr *init, bool fileScope)
     : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary,
-           tinfo->getType()->isDependentType(), false),
+           tinfo->getType()->isDependentType(), 
+           init->isValueDependent(),
+           init->containsUnexpandedParameterPack()),
       LParenLoc(lparenloc), TInfo(tinfo), Init(init), FileScope(fileScope) {}
 
   /// \brief Construct an empty compound literal.
@@ -2119,7 +2140,9 @@ protected:
          ty->isDependentType(),
          // Cast expressions are value-dependent if the type is
          // dependent or if the subexpression is value-dependent.
-         ty->isDependentType() || (op && op->isValueDependent())),
+         ty->isDependentType() || (op && op->isValueDependent()),
+         (ty->containsUnexpandedParameterPack() ||
+          op->containsUnexpandedParameterPack())),
     Op(op) {
     assert(kind != CK_Invalid && "creating cast with invalid cast kind");
     CastExprBits.Kind = kind;
@@ -2351,7 +2374,9 @@ public:
                  SourceLocation opLoc)
     : Expr(BinaryOperatorClass, ResTy, VK, OK,
            lhs->isTypeDependent() || rhs->isTypeDependent(),
-           lhs->isValueDependent() || rhs->isValueDependent()),
+           lhs->isValueDependent() || rhs->isValueDependent(),
+           (lhs->containsUnexpandedParameterPack() ||
+            rhs->containsUnexpandedParameterPack())),
       Opc(opc), OpLoc(opLoc) {
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
@@ -2450,7 +2475,9 @@ protected:
                  SourceLocation opLoc, bool dead)
     : Expr(CompoundAssignOperatorClass, ResTy, VK, OK,
            lhs->isTypeDependent() || rhs->isTypeDependent(),
-           lhs->isValueDependent() || rhs->isValueDependent()),
+           lhs->isValueDependent() || rhs->isValueDependent(),
+           (lhs->containsUnexpandedParameterPack() ||
+            rhs->containsUnexpandedParameterPack())),
       Opc(opc), OpLoc(opLoc) {
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
@@ -2519,7 +2546,10 @@ public:
            ((lhs && lhs->isTypeDependent()) || (rhs && rhs->isTypeDependent())),
            (cond->isValueDependent() ||
             (lhs && lhs->isValueDependent()) ||
-            (rhs && rhs->isValueDependent()))),
+            (rhs && rhs->isValueDependent())),
+           (cond->containsUnexpandedParameterPack() ||
+            (lhs && lhs->containsUnexpandedParameterPack()) ||
+            (rhs && rhs->containsUnexpandedParameterPack()))),
       QuestionLoc(QLoc),
       ColonLoc(CLoc) {
     SubExprs[COND] = cond;
@@ -2589,7 +2619,7 @@ class AddrLabelExpr : public Expr {
 public:
   AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelStmt *L,
                 QualType t)
-    : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary, false, false),
+    : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary, false, false, false),
       AmpAmpLoc(AALoc), LabelLoc(LLoc), Label(L) {}
 
   /// \brief Build an empty address of a label expression.
@@ -2632,7 +2662,7 @@ public:
   StmtExpr(CompoundStmt *substmt, QualType T,
            SourceLocation lp, SourceLocation rp) :
     Expr(StmtExprClass, T, VK_RValue, OK_Ordinary,
-         T->isDependentType(), false),
+         T->isDependentType(), false, false),
     SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) { }
 
   /// \brief Build an empty statement expression.
@@ -2679,19 +2709,9 @@ class ShuffleVectorExpr : public Expr {
   unsigned NumExprs;
 
 public:
-  // FIXME: Can a shufflevector be value-dependent?  Does type-dependence need
-  // to be computed differently?
   ShuffleVectorExpr(ASTContext &C, Expr **args, unsigned nexpr,
                     QualType Type, SourceLocation BLoc,
-                    SourceLocation RP) :
-    Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary,
-         Type->isDependentType(), false),
-    BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(nexpr) {
-
-    SubExprs = new (C) Stmt*[nexpr];
-    for (unsigned i = 0; i < nexpr; i++)
-      SubExprs[i] = args[i];
-  }
+                    SourceLocation RP);
 
   /// \brief Build an empty vector-shuffle expression.
   explicit ShuffleVectorExpr(EmptyShell Empty)
@@ -2755,7 +2775,10 @@ public:
   ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
              QualType t, ExprValueKind VK, ExprObjectKind OK,
              SourceLocation RP, bool TypeDependent, bool ValueDependent)
-    : Expr(ChooseExprClass, t, VK, OK, TypeDependent, ValueDependent),
+    : Expr(ChooseExprClass, t, VK, OK, TypeDependent, ValueDependent,
+           (cond->containsUnexpandedParameterPack() ||
+            lhs->containsUnexpandedParameterPack() ||
+            rhs->containsUnexpandedParameterPack())),
       BuiltinLoc(BLoc), RParenLoc(RP) {
       SubExprs[COND] = cond;
       SubExprs[LHS] = lhs;
@@ -2813,7 +2836,7 @@ class GNUNullExpr : public Expr {
 
 public:
   GNUNullExpr(QualType Ty, SourceLocation Loc)
-    : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary, false, false),
+    : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary, false, false, false),
       TokenLoc(Loc) { }
 
   /// \brief Build an empty GNU __null expression.
@@ -2845,7 +2868,9 @@ public:
   VAArgExpr(SourceLocation BLoc, Expr* e, TypeSourceInfo *TInfo,
             SourceLocation RPLoc, QualType t)
     : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary,
-           t->isDependentType(), false),
+           t->isDependentType(), false,
+           (TInfo->getType()->containsUnexpandedParameterPack() ||
+            e->containsUnexpandedParameterPack())),
       Val(e), TInfo(TInfo),
       BuiltinLoc(BLoc),
       RParenLoc(RPLoc) { }
@@ -3346,7 +3371,7 @@ class ImplicitValueInitExpr : public Expr {
 public:
   explicit ImplicitValueInitExpr(QualType ty)
     : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary,
-           false, false) { }
+           false, false, false) { }
 
   /// \brief Construct an empty implicit value initialization.
   explicit ImplicitValueInitExpr(EmptyShell Empty)
@@ -3434,7 +3459,8 @@ public:
                        IdentifierInfo &accessor, SourceLocation loc)
     : Expr(ExtVectorElementExprClass, ty, VK,
            (VK == VK_RValue ? OK_Ordinary : OK_VectorComponent),
-           base->isTypeDependent(), base->isValueDependent()),
+           base->isTypeDependent(), base->isValueDependent(),
+           base->containsUnexpandedParameterPack()),
       Base(base), Accessor(&accessor), AccessorLoc(loc) {}
 
   /// \brief Build an empty vector element expression.
@@ -3490,7 +3516,7 @@ protected:
 public:
   BlockExpr(BlockDecl *BD, QualType ty, bool hasBlockDeclRefExprs)
     : Expr(BlockExprClass, ty, VK_RValue, OK_Ordinary,
-           ty->isDependentType(), false),
+           ty->isDependentType(), false, false),
       TheBlock(BD), HasBlockDeclRefExprs(hasBlockDeclRefExprs) {}
 
   /// \brief Build an empty block expression.
@@ -3541,7 +3567,7 @@ public:
                    SourceLocation l, bool ByRef, bool constAdded = false,
                    Stmt *copyConstructorVal = 0)
     : Expr(BlockDeclRefExprClass, t, VK, OK_Ordinary,
-           (!t.isNull() && t->isDependentType()), false),
+           (!t.isNull() && t->isDependentType()), false, false),
     D(d), Loc(l), IsByRef(ByRef),
     ConstQualAdded(constAdded),  CopyConstructorVal(copyConstructorVal) {}
 
@@ -3591,7 +3617,7 @@ class OpaqueValueExpr : public Expr {
 public:
   OpaqueValueExpr(QualType T, ExprValueKind VK, ExprObjectKind OK = OK_Ordinary)
     : Expr(OpaqueValueExprClass, T, VK, OK,
-           T->isDependentType(), T->isDependentType()) {
+           T->isDependentType(), T->isDependentType(), false) {
   }
 
   explicit OpaqueValueExpr(EmptyShell Empty)
diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h
index 6b18561424..403ee04321 100644
--- a/include/clang/AST/ExprCXX.h
+++ b/include/clang/AST/ExprCXX.h
@@ -283,7 +283,8 @@ class CXXBoolLiteralExpr : public Expr {
   SourceLocation Loc;
 public:
   CXXBoolLiteralExpr(bool val, QualType Ty, SourceLocation l) :
-    Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false),
+    Expr(CXXBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
+         false),
     Value(val), Loc(l) {}
 
   explicit CXXBoolLiteralExpr(EmptyShell Empty)
@@ -312,7 +313,8 @@ class CXXNullPtrLiteralExpr : public Expr {
   SourceLocation Loc;
 public:
   CXXNullPtrLiteralExpr(QualType Ty, SourceLocation l) :
-    Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false),
+    Expr(CXXNullPtrLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
+         false),
     Loc(l) {}
 
   explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
@@ -348,15 +350,17 @@ public:
            // typeid is never type-dependent (C++ [temp.dep.expr]p4)
            false,
            // typeid is value-dependent if the type or expression are dependent
-           Operand->getType()->isDependentType()),
+           Operand->getType()->isDependentType(),
+           Operand->getType()->containsUnexpandedParameterPack()),
       Operand(Operand), Range(R) { }
   
   CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
     : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary,
         // typeid is never type-dependent (C++ [temp.dep.expr]p4)
-        false,
+           false,
         // typeid is value-dependent if the type or expression are dependent
-        Operand->isTypeDependent() || Operand->isValueDependent()),
+           Operand->isTypeDependent() || Operand->isValueDependent(),
+           Operand->containsUnexpandedParameterPack()),
       Operand(Operand), Range(R) { }
 
   CXXTypeidExpr(EmptyShell Empty, bool isExpr)
@@ -419,12 +423,14 @@ private:
 public:
   CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
     : Expr(CXXUuidofExprClass, Ty, VK_RValue, OK_Ordinary,
-        false, Operand->getType()->isDependentType()),
+           false, Operand->getType()->isDependentType(),
+           Operand->getType()->containsUnexpandedParameterPack()),
       Operand(Operand), Range(R) { }
   
   CXXUuidofExpr(QualType Ty, Expr *Operand, SourceRange R)
     : Expr(CXXUuidofExprClass, Ty, VK_RValue, OK_Ordinary,
-        false, Operand->isTypeDependent()),
+           false, Operand->isTypeDependent(),
+           Operand->containsUnexpandedParameterPack()),
       Operand(Operand), Range(R) { }
 
   CXXUuidofExpr(EmptyShell Empty, bool isExpr)
@@ -495,7 +501,8 @@ public:
     : Expr(CXXThisExprClass, Type, VK_RValue, OK_Ordinary,
            // 'this' is type-dependent if the class type of the enclosing
            // member function is dependent (C++ [temp.dep.expr]p2)
-           Type->isDependentType(), Type->isDependentType()),
+           Type->isDependentType(), Type->isDependentType(),
+           /*ContainsUnexpandedParameterPack=*/false),
       Loc(L), Implicit(isImplicit) { }
 
   CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}
@@ -530,7 +537,8 @@ public:
   // exepression.  The l is the location of the throw keyword.  expr
   // can by null, if the optional expression to throw isn't present.
   CXXThrowExpr(Expr *expr, QualType Ty, SourceLocation l) :
-    Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary, false, false),
+    Expr(CXXThrowExprClass, Ty, VK_RValue, OK_Ordinary, false, false,
+         expr && expr->containsUnexpandedParameterPack()),
     Op(expr), ThrowLoc(l) {}
   CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}
 
@@ -578,14 +586,15 @@ class CXXDefaultArgExpr : public Expr {
              ? param->getType().getNonReferenceType()
              : param->getDefaultArg()->getType(),
            param->getDefaultArg()->getValueKind(),
-           param->getDefaultArg()->getObjectKind(), false, false),
+           param->getDefaultArg()->getObjectKind(), false, false, false),
       Param(param, false), Loc(Loc) { }
 
   CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *param, 
                     Expr *SubExpr)
     : Expr(SC, SubExpr->getType(),
            SubExpr->getValueKind(), SubExpr->getObjectKind(),
-           false, false), Param(param, true), Loc(Loc) {
+           false, false, false), 
+      Param(param, true), Loc(Loc) {
     *reinterpret_cast<Expr **>(this + 1) = SubExpr;
   }
   
@@ -680,11 +689,12 @@ class CXXBindTemporaryExpr : public Expr {
 
   Stmt *SubExpr;
 
-  CXXBindTemporaryExpr(CXXTemporary *temp, Expr* subexpr, 
-                       bool TD=false, bool VD=false)
-   : Expr(CXXBindTemporaryExprClass, subexpr->getType(),
-          VK_RValue, OK_Ordinary, TD, VD),
-     Temp(temp), SubExpr(subexpr) { }
+  CXXBindTemporaryExpr(CXXTemporary *temp, Expr* SubExpr)
+   : Expr(CXXBindTemporaryExprClass, SubExpr->getType(),
+          VK_RValue, OK_Ordinary, SubExpr->isTypeDependent(), 
+          SubExpr->isValueDependent(),
+          SubExpr->containsUnexpandedParameterPack()),
+     Temp(temp), SubExpr(SubExpr) { }
 
 public:
   CXXBindTemporaryExpr(EmptyShell Empty)
@@ -935,7 +945,7 @@ public:
                          TypeSourceInfo *TypeInfo,
                          SourceLocation rParenLoc ) :
     Expr(CXXScalarValueInitExprClass, Type, VK_RValue, OK_Ordinary,
-         false, false),
+         false, false, false),
     RParenLoc(rParenLoc), TypeInfo(TypeInfo) {}
 
   explicit CXXScalarValueInitExpr(EmptyShell Shell)
@@ -1147,7 +1157,8 @@ public:
   CXXDeleteExpr(QualType ty, bool globalDelete, bool arrayForm,
                 bool arrayFormAsWritten, FunctionDecl *operatorDelete,
                 Expr *arg, SourceLocation loc)
-    : Expr(CXXDeleteExprClass, ty, VK_RValue, OK_Ordinary, false, false),
+    : Expr(CXXDeleteExprClass, ty, VK_RValue, OK_Ordinary, false, false,
+           arg->containsUnexpandedParameterPack()),
       GlobalDelete(globalDelete),
       ArrayForm(arrayForm), ArrayFormAsWritten(arrayFormAsWritten),
       OperatorDelete(operatorDelete), Argument(arg), Loc(loc) { }
@@ -1408,7 +1419,8 @@ public:
                      TypeSourceInfo *queried, bool value,
                      SourceLocation rparen, QualType ty)
     : Expr(UnaryTypeTraitExprClass, ty, VK_RValue, OK_Ordinary,
-           false,  queried->getType()->isDependentType()),
+           false,  queried->getType()->isDependentType(),
+           queried->getType()->containsUnexpandedParameterPack()),
       UTT(utt), Value(value), Loc(loc), RParen(rparen), QueriedType(queried) { }
 
   explicit UnaryTypeTraitExpr(EmptyShell Empty)
@@ -1466,7 +1478,9 @@ public:
                      bool value, SourceLocation rparen, QualType ty)
     : Expr(BinaryTypeTraitExprClass, ty, VK_RValue, OK_Ordinary, false, 
            lhsType->getType()->isDependentType() ||
-           rhsType->getType()->isDependentType()),
+           rhsType->getType()->isDependentType(),
+           (lhsType->getType()->containsUnexpandedParameterPack() ||
+            rhsType->getType()->containsUnexpandedParameterPack())),
       BTT(btt), Value(value), Loc(loc), RParen(rparen),
       LhsType(lhsType), RhsType(rhsType) { }
 
@@ -1522,27 +1536,29 @@ class OverloadExpr : public Expr {
   /// The source range of the scope specifier.
   SourceRange QualifierRange;
 
+  friend class ASTStmtReader;
+
 protected:
   /// True if the name was a template-id.
   bool HasExplicitTemplateArgs;
 
-  OverloadExpr(StmtClass K, ASTContext &C, QualType T, bool Dependent,
+  OverloadExpr(StmtClass K, ASTContext &C,
                NestedNameSpecifier *Qualifier, SourceRange QRange,
                const DeclarationNameInfo &NameInfo,
-               bool HasTemplateArgs,
-               UnresolvedSetIterator Begin, UnresolvedSetIterator End);
+               const TemplateArgumentListInfo *TemplateArgs,
+               UnresolvedSetIterator Begin, UnresolvedSetIterator End,
+               bool KnownDependent = false,
+               bool KnownContainsUnexpandedParameterPack = false);
 
   OverloadExpr(StmtClass K, EmptyShell Empty)
     : Expr(K, Empty), Results(0), NumResults(0),
       Qualifier(0), HasExplicitTemplateArgs(false) { }
 
-public:
-  /// Computes whether an unresolved lookup on the given declarations
-  /// and optional template arguments is type- and value-dependent.
-  static bool ComputeDependence(UnresolvedSetIterator Begin,
-                                UnresolvedSetIterator End,
-                                const TemplateArgumentListInfo *Args);
+  void initializeResults(ASTContext &C,
+                         UnresolvedSetIterator Begin,
+                         UnresolvedSetIterator End);
 
+public:
   struct FindResult {
     OverloadExpr *Expression;
     bool IsAddressOfOperand;
@@ -1586,9 +1602,6 @@ public:
     return UnresolvedSetIterator(Results + NumResults);
   }
   
-  void initializeResults(ASTContext &C,
-                         UnresolvedSetIterator Begin,UnresolvedSetIterator End);
-
   /// Gets the number of declarations in the unresolved set.
   unsigned getNumDecls() const { return NumResults; }
 
@@ -1667,15 +1680,15 @@ class UnresolvedLookupExpr : public OverloadExpr {
   /// against the qualified-lookup bits.
   CXXRecordDecl *NamingClass;
 
-  UnresolvedLookupExpr(ASTContext &C, QualType T, bool Dependent, 
+  UnresolvedLookupExpr(ASTContext &C, 
                        CXXRecordDecl *NamingClass,
                        NestedNameSpecifier *Qualifier, SourceRange QRange,
                        const DeclarationNameInfo &NameInfo,
-                       bool RequiresADL, bool Overloaded, bool HasTemplateArgs,
+                       bool RequiresADL, bool Overloaded, 
+                       const TemplateArgumentListInfo *TemplateArgs,
                        UnresolvedSetIterator Begin, UnresolvedSetIterator End)
-    : OverloadExpr(UnresolvedLookupExprClass, C, T,
-                   Dependent, Qualifier,  QRange, NameInfo, HasTemplateArgs,
-                   Begin, End),
+    : OverloadExpr(UnresolvedLookupExprClass, C, Qualifier,  QRange, NameInfo, 
+                   TemplateArgs, Begin, End),
       RequiresADL(RequiresADL), Overloaded(Overloaded), NamingClass(NamingClass)
   {}
 
@@ -1686,7 +1699,6 @@ class UnresolvedLookupExpr : public OverloadExpr {
 
 public:
   static UnresolvedLookupExpr *Create(ASTContext &C,
-                                      bool Dependent,
                                       CXXRecordDecl *NamingClass,
                                       NestedNameSpecifier *Qualifier,
                                       SourceRange QualifierRange,
@@ -1694,16 +1706,12 @@ public:
                                       bool ADL, bool Overloaded,
                                       UnresolvedSetIterator Begin, 
                                       UnresolvedSetIterator End) {
-    return new(C) UnresolvedLookupExpr(C,
-                                       Dependent ? C.DependentTy : C.OverloadTy,
-                                       Dependent, NamingClass,
-                                       Qualifier, QualifierRange, NameInfo,
-                                       ADL, Overloaded, false,
-                                       Begin, End);
+    return new(C) UnresolvedLookupExpr(C, NamingClass, Qualifier, 
+                                       QualifierRange, NameInfo, ADL, 
+                                       Overloaded, 0, Begin, End);
   }
 
   static UnresolvedLookupExpr *Create(ASTContext &C,
-                                      bool Dependent,
                                       CXXRecordDecl *NamingClass,
                                       NestedNameSpecifier *Qualifier,
                                       SourceRange QualifierRange,
@@ -1825,12 +1833,7 @@ class DependentScopeDeclRefExpr : public Expr {
                             NestedNameSpecifier *Qualifier,
                             SourceRange QualifierRange,
                             const DeclarationNameInfo &NameInfo,
-                            bool HasExplicitTemplateArgs)
-    : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
-           true, true),
-      NameInfo(NameInfo), QualifierRange(QualifierRange), Qualifier(Qualifier),
-      HasExplicitTemplateArgs(HasExplicitTemplateArgs)
-  {}
+                            const TemplateArgumentListInfo *Args);
 
 public:
   static DependentScopeDeclRefExpr *Create(ASTContext &C,
@@ -2161,20 +2164,13 @@ class CXXDependentScopeMemberExpr : public Expr {
 
 public:
   CXXDependentScopeMemberExpr(ASTContext &C,
-                          Expr *Base, QualType BaseType,
-                          bool IsArrow,
-                          SourceLocation OperatorLoc,
-                          NestedNameSpecifier *Qualifier,
-                          SourceRange QualifierRange,
-                          NamedDecl *FirstQualifierFoundInScope,
-                          DeclarationNameInfo MemberNameInfo)
-  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
-         VK_LValue, OK_Ordinary, true, true),
-    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
-    HasExplicitTemplateArgs(false), OperatorLoc(OperatorLoc),
-    Qualifier(Qualifier), QualifierRange(QualifierRange),
-    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
-    MemberNameInfo(MemberNameInfo) { }
+                              Expr *Base, QualType BaseType,
+                              bool IsArrow,
+                              SourceLocation OperatorLoc,
+                              NestedNameSpecifier *Qualifier,
+                              SourceRange QualifierRange,
+                              NamedDecl *FirstQualifierFoundInScope,
+                              DeclarationNameInfo MemberNameInfo);
 
   static CXXDependentScopeMemberExpr *
   Create(ASTContext &C,
@@ -2384,8 +2380,7 @@ class UnresolvedMemberExpr : public OverloadExpr {
   /// \brief The location of the '->' or '.' operator.
   SourceLocation OperatorLoc;
 
-  UnresolvedMemberExpr(ASTContext &C, QualType T, bool Dependent,
-                       bool HasUnresolvedUsing,
+  UnresolvedMemberExpr(ASTContext &C, bool HasUnresolvedUsing,
                        Expr *Base, QualType BaseType, bool IsArrow,
                        SourceLocation OperatorLoc,
                        NestedNameSpecifier *Qualifier,
@@ -2400,7 +2395,7 @@ class UnresolvedMemberExpr : public OverloadExpr {
 
 public:
   static UnresolvedMemberExpr *
-  Create(ASTContext &C, bool Dependent, bool HasUnresolvedUsing,
+  Create(ASTContext &C, bool HasUnresolvedUsing,
          Expr *Base, QualType BaseType, bool IsArrow,
          SourceLocation OperatorLoc,
          NestedNameSpecifier *Qualifier,
@@ -2553,7 +2548,8 @@ public:
                   SourceLocation Keyword, SourceLocation RParen)
     : Expr(CXXNoexceptExprClass, Ty, VK_RValue, OK_Ordinary,
            /*TypeDependent*/false,
-           /*ValueDependent*/Val == CT_Dependent),
+           /*ValueDependent*/Val == CT_Dependent,
+           Operand->containsUnexpandedParameterPack()),
       Value(Val == CT_Cannot), Operand(Operand), Range(Keyword, RParen)
   { }
 
diff --git a/include/clang/AST/ExprObjC.h b/include/clang/AST/ExprObjC.h
index 263ba17a02..0eba6ba9f2 100644
--- a/include/clang/AST/ExprObjC.h
+++ b/include/clang/AST/ExprObjC.h
@@ -29,7 +29,8 @@ class ObjCStringLiteral : public Expr {
   SourceLocation AtLoc;
 public:
   ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)
-    : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary, false, false),
+    : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
+           false),
       String(SL), AtLoc(L) {}
   explicit ObjCStringLiteral(EmptyShell Empty)
     : Expr(ObjCStringLiteralClass, Empty) {}
@@ -66,7 +67,8 @@ public:
                  SourceLocation at, SourceLocation rp)
     : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary,
            EncodedType->getType()->isDependentType(),
-           EncodedType->getType()->isDependentType()), 
+           EncodedType->getType()->isDependentType(),
+           EncodedType->getType()->containsUnexpandedParameterPack()), 
       EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {}
 
   explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){}
@@ -105,7 +107,8 @@ class ObjCSelectorExpr : public Expr {
 public:
   ObjCSelectorExpr(QualType T, Selector selInfo,
                    SourceLocation at, SourceLocation rp)
-  : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary, false, false),
+    : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary, false, false, 
+           false),
     SelName(selInfo), AtLoc(at), RParenLoc(rp){}
   explicit ObjCSelectorExpr(EmptyShell Empty)
    : Expr(ObjCSelectorExprClass, Empty) {}
@@ -145,8 +148,9 @@ class ObjCProtocolExpr : public Expr {
 public:
   ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol,
                    SourceLocation at, SourceLocation rp)
-  : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary, false, false),
-    TheProtocol(protocol), AtLoc(at), RParenLoc(rp) {}
+    : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary, false, false,
+           false),
+      TheProtocol(protocol), AtLoc(at), RParenLoc(rp) {}
   explicit ObjCProtocolExpr(EmptyShell Empty)
     : Expr(ObjCProtocolExprClass, Empty) {}
 
@@ -185,9 +189,9 @@ public:
                   SourceLocation l, Expr *base,
                   bool arrow = false, bool freeIvar = false) :
     Expr(ObjCIvarRefExprClass, t, VK_LValue, OK_Ordinary,
-         /*TypeDependent=*/false, base->isValueDependent()), D(d),
-         Loc(l), Base(base), IsArrow(arrow),
-         IsFreeIvar(freeIvar) {}
+         /*TypeDependent=*/false, base->isValueDependent(), 
+         base->containsUnexpandedParameterPack()), 
+    D(d), Loc(l), Base(base), IsArrow(arrow), IsFreeIvar(freeIvar) {}
 
   explicit ObjCIvarRefExpr(EmptyShell Empty)
     : Expr(ObjCIvarRefExprClass, Empty) {}
@@ -248,7 +252,8 @@ public:
                       ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation l, Expr *base)
     : Expr(ObjCPropertyRefExprClass, t, VK, OK,
-           /*TypeDependent=*/false, base->isValueDependent()),
+           /*TypeDependent=*/false, base->isValueDependent(),
+           base->containsUnexpandedParameterPack()),
       PropertyOrGetter(PD, false), Setter(0),
       IdLoc(l), ReceiverLoc(), Receiver(base) {
   }
@@ -257,7 +262,8 @@ public:
                       ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation l, SourceLocation sl, QualType st)
     : Expr(ObjCPropertyRefExprClass, t, VK, OK,
-           /*TypeDependent=*/false, false),
+           /*TypeDependent=*/false, false, 
+           st->containsUnexpandedParameterPack()),
       PropertyOrGetter(PD, false), Setter(0),
       IdLoc(l), ReceiverLoc(sl), Receiver(st.getTypePtr()) {
   }
@@ -266,7 +272,8 @@ public:
                       QualType T, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation IdLoc, Expr *Base)
     : Expr(ObjCPropertyRefExprClass, T, VK, OK, false,
-           Base->isValueDependent()),
+           Base->isValueDependent(), 
+           Base->containsUnexpandedParameterPack()),
       PropertyOrGetter(Getter, true), Setter(Setter),
       IdLoc(IdLoc), ReceiverLoc(), Receiver(Base) {
   }
@@ -275,7 +282,7 @@ public:
                       QualType T, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation IdLoc,
                       SourceLocation SuperLoc, QualType SuperTy)
-    : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false),
+    : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false),
       PropertyOrGetter(Getter, true), Setter(Setter),
       IdLoc(IdLoc), ReceiverLoc(SuperLoc), Receiver(SuperTy.getTypePtr()) {
   }
@@ -284,7 +291,7 @@ public:
                       QualType T, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation IdLoc,
                       SourceLocation ReceiverLoc, ObjCInterfaceDecl *Receiver)
-    : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false),
+    : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false),
       PropertyOrGetter(Getter, true), Setter(Setter),
       IdLoc(IdLoc), ReceiverLoc(ReceiverLoc), Receiver(Receiver) {
   }
@@ -808,7 +815,8 @@ class ObjCIsaExpr : public Expr {
 public:
   ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, QualType ty)
     : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary,
-           /*TypeDependent=*/false, base->isValueDependent()),
+           /*TypeDependent=*/false, base->isValueDependent(),
+           /*ContainsUnexpandedParameterPack=*/false),
       Base(base), IsaMemberLoc(l), IsArrow(isarrow) {}
 
   /// \brief Build an empty expression.
diff --git a/include/clang/AST/Stmt.h b/include/clang/AST/Stmt.h
index 124977d97f..01e0ae56c9 100644
--- a/include/clang/AST/Stmt.h
+++ b/include/clang/AST/Stmt.h
@@ -143,7 +143,18 @@ protected:
     friend class DeclRefExpr; // computeDependence
     friend class InitListExpr; // ctor
     friend class DesignatedInitExpr; // ctor
-    friend class ASTStmtReader;
+    friend class ASTStmtReader; // deserialization
+    friend class CXXNewExpr; // ctor
+    friend class DependentScopeDeclRefExpr; // ctor
+    friend class CXXConstructExpr; // ctor
+    friend class CallExpr; // ctor
+    friend class OffsetOfExpr; // ctor
+    friend class ObjCMessageExpr; // ctor
+    friend class ShuffleVectorExpr; // ctor
+    friend class ParenListExpr; // ctor
+    friend class CXXUnresolvedConstructExpr; // ctor
+    friend class CXXDependentScopeMemberExpr; // ctor
+    friend class OverloadExpr; // ctor
     unsigned : NumStmtBits;
 
     unsigned ValueKind : 2;
diff --git a/include/clang/AST/TemplateBase.h b/include/clang/AST/TemplateBase.h
index e5057e547e..df1bbe98e0 100644
--- a/include/clang/AST/TemplateBase.h
+++ b/include/clang/AST/TemplateBase.h
@@ -182,6 +182,10 @@ public:
   /// \brief Determine whether this template argument has no value.
   bool isNull() const { return Kind == Null; }
 
+  /// \brief Whether this template argument is dependent on a template
+  /// parameter.
+  bool isDependent() const;
+
   /// \brief Whether this template argument contains an unexpanded
   /// parameter pack.
   bool containsUnexpandedParameterPack() const;