The canonical type of typeof or decltype with a dependent type is itself,

not Context.DependentTy. I'll let Anders check in the test case for this one...


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

3 files changed, 16 insertions, 10 deletions

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index ffba78a3c8..2beaba637c 100644
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -1432,7 +1432,7 @@ public:
 /// TypeOfExprType (GCC extension).
 class TypeOfExprType : public Type {
   Expr *TOExpr;
-  TypeOfExprType(Expr *E, QualType can);
+  TypeOfExprType(Expr *E, QualType can = QualType());
   friend class ASTContext;  // ASTContext creates these.
 public:
   Expr *getUnderlyingExpr() const { return TOExpr; }
@@ -1463,7 +1463,7 @@ public:
 /// DecltypeType (C++0x)
 class DecltypeType : public Type {
   Expr *E;
-  DecltypeType(Expr *E, QualType can);
+  DecltypeType(Expr *E, QualType can = QualType());
   friend class ASTContext;  // ASTContext creates these.
 public:
   Expr *getUnderlyingExpr() const { return E; }
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index c59a5d703b..de4816c503 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -1901,8 +1901,13 @@ QualType ASTContext::getObjCQualifiedInterfaceType(ObjCInterfaceDecl *Decl,
 /// DeclRefExpr's. This doesn't effect the type checker, since it operates 
 /// on canonical type's (which are always unique).
 QualType ASTContext::getTypeOfExprType(Expr *tofExpr) {
-  QualType Canonical = getCanonicalType(tofExpr->getType());
-  TypeOfExprType *toe = new (*this,8) TypeOfExprType(tofExpr, Canonical);
+  TypeOfExprType *toe;
+  if (tofExpr->isTypeDependent())
+    toe = new (*this, 8) TypeOfExprType(tofExpr);
+  else {
+    QualType Canonical = getCanonicalType(tofExpr->getType());
+    toe = new (*this,8) TypeOfExprType(tofExpr, Canonical);
+  }
   Types.push_back(toe);
   return QualType(toe, 0);
 }
@@ -1957,8 +1962,13 @@ static QualType getDecltypeForExpr(const Expr *e, ASTContext &Context) {
 /// an issue. This doesn't effect the type checker, since it operates 
 /// on canonical type's (which are always unique).
 QualType ASTContext::getDecltypeType(Expr *e) {
-  QualType T = getDecltypeForExpr(e, *this);
-  DecltypeType *dt = new (*this, 8) DecltypeType(e, getCanonicalType(T));
+  DecltypeType *dt;
+  if (e->isTypeDependent()) // FIXME: canonicalize the expression
+    dt = new (*this, 8) DecltypeType(e);
+  else {
+    QualType T = getDecltypeForExpr(e, *this);
+    dt = new (*this, 8) DecltypeType(e, getCanonicalType(T));    
+  }
   Types.push_back(dt);
   return QualType(dt, 0);
 }
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 2b307c86e3..fa1c9152f4 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -1072,14 +1072,10 @@ QualType TypedefType::LookThroughTypedefs() const {
 
 TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
   : Type(TypeOfExpr, can, E->isTypeDependent()), TOExpr(E) {
-  assert(!isa<TypedefType>(can) && "Invalid canonical type");
 }
 
 DecltypeType::DecltypeType(Expr *E, QualType can)
   : Type(Decltype, can, E->isTypeDependent()), E(E) {
-  assert(can->isDependentType() == E->isTypeDependent() &&
-         "type dependency mismatch!");
-  assert(!isa<TypedefType>(can) && "Invalid canonical type");
 }
 
 TagType::TagType(TypeClass TC, TagDecl *D, QualType can)