Template instantiation for "typeof" for both types and expressions.

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

diff --git a/lib/Sema/SemaTemplateInstantiate.cpp b/lib/Sema/SemaTemplateInstantiate.cpp
index 3c32a21073d3607158aed17d4a32f373530994d2..86e69997bcc968ffc406a9729cbcdf5f33b7f704 100644 (file)
--- a/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/lib/Sema/SemaTemplateInstantiate.cpp
@@ -414,17 +414,22 @@ TemplateTypeInstantiator::InstantiateTypedefType(const TypedefType *T,
 QualType 
 TemplateTypeInstantiator::InstantiateTypeOfExprType(const TypeOfExprType *T,
                                                     unsigned Quals) const {
-  // FIXME: Implement this
-  assert(false && "Cannot instantiate TypeOfExprType yet");
-  return QualType();
+  Sema::OwningExprResult E 
+    = SemaRef.InstantiateExpr(T->getUnderlyingExpr(), TemplateArgs);
+  if (E.isInvalid())
+    return QualType();
+
+  return SemaRef.Context.getTypeOfExprType(E.takeAs<Expr>());
 }
 
 QualType 
 TemplateTypeInstantiator::InstantiateTypeOfType(const TypeOfType *T,
                                                 unsigned Quals) const {
-  // FIXME: Implement this
-  assert(false && "Cannot instantiate TypeOfType yet");
-  return QualType();
+  QualType Underlying = Instantiate(T->getUnderlyingType());
+  if (Underlying.isNull())
+    return QualType();
+
+  return SemaRef.Context.getTypeOfType(Underlying);
 }
 
 QualType 

diff --git a/lib/Sema/SemaTemplateInstantiateExpr.cpp b/lib/Sema/SemaTemplateInstantiateExpr.cpp
index 0c298393308c768e817c12a26d06754e562a81fc..9dc14d551bad1d82c548b49542a8aabb060afa4a 100644 (file)
--- a/lib/Sema/SemaTemplateInstantiateExpr.cpp
+++ b/lib/Sema/SemaTemplateInstantiateExpr.cpp
@@ -138,9 +138,15 @@ TemplateExprInstantiator::VisitDeclRefExpr(DeclRefExpr *E) {
     else
       assert(false && 
              "FIXME: instantiation of non-local variable declarations");
-  } else if (isa<FunctionDecl>(D) || isa<OverloadedFunctionDecl>(D)) {
+  } else if (isa<FunctionDecl>(D)) {
     // FIXME: Instantiate decl!
     NewD = cast<ValueDecl>(D);
+  } else if (isa<OverloadedFunctionDecl>(D)) {
+    // FIXME: instantiate decls?
+    return SemaRef.Owned(new (SemaRef.Context) DeclRefExpr(cast<NamedDecl>(D),
+                                                   SemaRef.Context.OverloadTy,
+                                                           E->getLocation(),
+                                                           false, false));
   } else
     assert(false && "FIXME: unhandled declaration reference kind");
 

diff --git a/test/SemaTemplate/instantiate-type.cpp b/test/SemaTemplate/instantiate-type.cpp
new file mode 100644 (file)
index 0000000..48060c4
--- /dev/null
+++ b/test/SemaTemplate/instantiate-type.cpp
@@ -0,0 +1,17 @@
+// RUN: clang-cc -fsyntax-only %s
+
+int* f(int);
+float *f(...);
+
+template<typename T>
+struct X {
+  typedef typeof(T*) typeof_type;
+  typedef typeof(f(T())) typeof_expr;
+};
+
+int *iptr0;
+float *fptr0;
+X<int>::typeof_type &iptr1 = iptr0;
+
+X<int>::typeof_expr &iptr2 = iptr0;
+X<float*>::typeof_expr &fptr1 = fptr0;