Add partial semantic checking of template arguments that are meant for

non-type template parameters of pointer-to-object and
pointer-to-function type. The most fun part of this is the use of
overload resolution to pick a function from the set of overloaded
functions that comes in as a template argument.

Also, fixed two minor bugs in this area:
  - We were allowing non-type template parameters of type pointer to
  void.
  - We weren't patching up an expression that refers to an overloaded
  function set via "&f" properly.

We're still not performing complete checking of the expression to be
sure that it is referring to an object or function with external
linkage (C++ [temp.arg.nontype]p1).

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

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index c91b507dc83134a46f058df83e36db973afdb7e1..64c61e17ad18f876104d7a5e3755345772450925 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -3953,7 +3953,7 @@ void Sema::FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn) {
     assert(UnOp->getOpcode() == UnaryOperator::AddrOf && 
            "Can only take the address of an overloaded function");
     FixOverloadedFunctionReference(UnOp->getSubExpr(), Fn);
-    E->setType(Context.getPointerType(E->getType()));
+    E->setType(Context.getPointerType(UnOp->getSubExpr()->getType()));
   } else if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E)) {
     assert(isa<OverloadedFunctionDecl>(DR->getDecl()) && 
            "Expected overloaded function");

diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 7aab4a585e099e08d05437898833ca6d832e73eb..c78d8876dae1f50dac0a7dd351066d40dd3cc36b 100644 (file)
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -192,7 +192,9 @@ Sema::DeclTy *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
   //       -- integral or enumeration type,
   if (T->isIntegralType() || T->isEnumeralType() ||
       //   -- pointer to object or pointer to function, 
-      T->isPointerType() ||
+      (T->isPointerType() && 
+       (T->getAsPointerType()->getPointeeType()->isObjectType() ||
+        T->getAsPointerType()->getPointeeType()->isFunctionType())) ||
       //   -- reference to object or reference to function, 
       T->isReferenceType() ||
       //   -- pointer to member.
@@ -844,9 +846,8 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
   //        enumeration type, integral promotions (4.5) and integral
   //        conversions (4.7) are applied.
   QualType ParamType = Param->getType();
+  QualType ArgType = Arg->getType();
   if (ParamType->isIntegralType() || ParamType->isEnumeralType()) {
-    QualType ArgType = Arg->getType();
-
     // C++ [temp.arg.nontype]p1:
     //   A template-argument for a non-type, non-template
     //   template-parameter shall be one of:
@@ -894,6 +895,71 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
 
     return false;
   }
+
+  if (const PointerType *ParamPtrType = ParamType->getAsPointerType()) {
+    //   -- for a non-type template-parameter of type pointer to
+    //      object, qualification conversions (4.4) and the
+    //      array-to-pointer conversion (4.2) are applied.
+    if (ParamPtrType->getPointeeType()->isObjectType()) {
+      if (ArgType->isArrayType()) {
+        ArgType = Context.getArrayDecayedType(ArgType);
+        ImpCastExprToType(Arg, ArgType);
+      }
+
+      if (IsQualificationConversion(ArgType, ParamType)) {
+        ArgType = ParamType;
+        ImpCastExprToType(Arg, ParamType);
+      }
+
+      if (!hasSameUnqualifiedType(ArgType, ParamType)) {
+        // We can't perform this conversion.
+        Diag(Arg->getSourceRange().getBegin(), 
+             diag::err_template_arg_not_convertible)
+          << Arg->getType() << Param->getType() << Arg->getSourceRange();
+        Diag(Param->getLocation(), diag::note_template_param_here);
+        return true;
+      }
+
+      // FIXME: Check the restrictions in p1!
+      return false;
+    }
+    
+    assert(ParamPtrType->getPointeeType()->isFunctionType() &&
+           "Only function pointers remain");
+    //   -- For a non-type template-parameter of type pointer to
+    //      function, only the function-to-pointer conversion (4.3) is
+    //      applied. If the template-argument represents a set of
+    //      overloaded functions (or a pointer to such), the matching
+    //      function is selected from the set (13.4).
+    if (hasSameUnqualifiedType(ArgType, ParamType)) {
+      // We don't have to do anything: the types already match.
+    }
+    else if (ArgType->isFunctionType()) {
+      ArgType = Context.getPointerType(ArgType);
+      ImpCastExprToType(Arg, ArgType);
+    } else if (FunctionDecl *Fn 
+                 = ResolveAddressOfOverloadedFunction(Arg, ParamType, true)) {
+      FixOverloadedFunctionReference(Arg, Fn);
+      ArgType = Arg->getType();
+      if (ArgType->isFunctionType()) {
+        ArgType = Context.getPointerType(Arg->getType());
+        ImpCastExprToType(Arg, ArgType);
+      }
+    }
+
+    if (!hasSameUnqualifiedType(ArgType, ParamType)) {
+      // We can't perform this conversion.
+      Diag(Arg->getSourceRange().getBegin(), 
+           diag::err_template_arg_not_convertible)
+        << Arg->getType() << Param->getType() << Arg->getSourceRange();
+      Diag(Param->getLocation(), diag::note_template_param_here);
+      return true;
+    }
+
+    // FIXME: Check the restrictions in p1!
+    return false;
+  }
+
   // FIXME: p5 has a lot more checks to perform!
 
   return false;

diff --git a/test/SemaTemplate/temp_arg_nontype.cpp b/test/SemaTemplate/temp_arg_nontype.cpp
index 46d92c537b106ac1a493c5cbafd74e76aa5e61f9..4b1db5ad687b2f5ec483a73bff20004e0442ac74 100644 (file)
--- a/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/test/SemaTemplate/temp_arg_nontype.cpp
@@ -33,8 +33,37 @@ A<f(17)> *a10; // expected-error{{non-type template argument of type 'int' is no
 
 class X {
 public:
+  X();
   X(int, int);
   operator int() const;
 };
 A<X(17, 42)> *a11; // expected-error{{non-type template argument of type 'class X' must have an integral or enumeration type}} \
                    // FIXME:expected-error{{expected unqualified-id}}
+
+template<X const *Ptr> struct A2;
+
+X *X_ptr;
+X array_of_Xs[10];
+A2<X_ptr> *a12;
+A2<array_of_Xs> *a13;
+
+float f(float);
+
+float g(float);
+double g(double);
+
+int h(int);
+float h2(float);
+
+template<int fp(int)> struct A3; // expected-note 2{{template parameter is declared here}}
+A3<h> *a14_1;
+A3<&h> *a14_2;
+A3<f> *a14_3;
+A3<&f> *a14_4;
+A3<((&f))> *a14_5;
+A3<h2> *a14_6;  // expected-error{{non-type template argument of type 'float (*)(float)' cannot be converted to a value of type 'int (*)(int)'}} \
+// FIXME: expected-error{{expected unqualified-id}}
+A3<g> *a14_7; // expected-error{{non-type template argument of type '<overloaded function type>' cannot be converted to a value of type 'int (*)(int)'}}\
+// FIXME: expected-error{{expected unqualified-id}}
+// FIXME: the first error includes the string <overloaded function
+// type>, which makes Doug slightly unhappy.

diff --git a/test/SemaTemplate/temp_param.cpp b/test/SemaTemplate/temp_param.cpp
index e45d45629a5768fb1129a4951e9217800ce91890..1f10cc49c10281cc03e9349f39583695dc7ab4c5 100644 (file)
--- a/test/SemaTemplate/temp_param.cpp
+++ b/test/SemaTemplate/temp_param.cpp
@@ -18,6 +18,7 @@ template<typename T, T x> struct A10;
 
 template<float f> struct A11; // expected-error{{a non-type template parameter cannot have type 'float'}}
 
+template<void *Ptr> struct A12; // expected-error{{a non-type template parameter cannot have type 'void *'}}
 
 // C++ [temp.param]p8
 template<int X[10]> struct A5;