From: Douglas Gregor Date: Wed, 11 Feb 2009 00:19:33 +0000 (+0000) Subject: Add partial semantic checking of template arguments that are meant for X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=a35284bba5db7a6179d70fcce8fbe66481058698;p=clang 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 c91b507dc8..64c61e17ad 100644 --- 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(E)) { assert(isa(DR->getDecl()) && "Expected overloaded function"); diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index 7aab4a585e..c78d8876da 100644 --- 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 46d92c537b..4b1db5ad68 100644 --- a/test/SemaTemplate/temp_arg_nontype.cpp +++ b/test/SemaTemplate/temp_arg_nontype.cpp @@ -33,8 +33,37 @@ A *a10; // expected-error{{non-type template argument of type 'int' is no class X { public: + X(); X(int, int); operator int() const; }; A *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 struct A2; + +X *X_ptr; +X array_of_Xs[10]; +A2 *a12; +A2 *a13; + +float f(float); + +float g(float); +double g(double); + +int h(int); +float h2(float); + +template struct A3; // expected-note 2{{template parameter is declared here}} +A3 *a14_1; +A3<&h> *a14_2; +A3 *a14_3; +A3<&f> *a14_4; +A3<((&f))> *a14_5; +A3

*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 *a14_7; // expected-error{{non-type template argument of type '' cannot be converted to a value of type 'int (*)(int)'}}\ +// FIXME: expected-error{{expected unqualified-id}} +// FIXME: the first error includes the string , which makes Doug slightly unhappy. diff --git a/test/SemaTemplate/temp_param.cpp b/test/SemaTemplate/temp_param.cpp index e45d45629a..1f10cc49c1 100644 --- a/test/SemaTemplate/temp_param.cpp +++ b/test/SemaTemplate/temp_param.cpp @@ -18,6 +18,7 @@ template struct A10; template struct A11; // expected-error{{a non-type template parameter cannot have type 'float'}} +template struct A12; // expected-error{{a non-type template parameter cannot have type 'void *'}} // C++ [temp.param]p8 template struct A5;