[clang] e7f3e21 - Suppress printing template arguments that match default template
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 11 15:08:00 PST 2020
Author: Richard Smith
Date: 2020-11-11T15:05:51-08:00
New Revision: e7f3e2103cdb567dda4fd52f81bf4bc07179f5a8
URL: https://github.com/llvm/llvm-project/commit/e7f3e2103cdb567dda4fd52f81bf4bc07179f5a8
DIFF: https://github.com/llvm/llvm-project/commit/e7f3e2103cdb567dda4fd52f81bf4bc07179f5a8.diff
LOG: Suppress printing template arguments that match default template
arguments of types by default.
This somewhat improves the worst-case printing of types like
std::string, std::vector, etc., where many irrelevant default arguments
can be included in the type as printed if we've lost the type sugar.
Added:
clang/test/Misc/diag-template.cpp
Modified:
clang/include/clang/AST/PrettyPrinter.h
clang/include/clang/AST/Type.h
clang/lib/AST/DeclTemplate.cpp
clang/lib/AST/TypePrinter.cpp
clang/lib/Frontend/FrontendActions.cpp
clang/test/SemaCXX/cxx14-compat.cpp
clang/test/SemaCXX/generic-selection.cpp
clang/test/SemaTemplate/class-template-id.cpp
clang/test/SemaTemplate/class-template-spec.cpp
clang/test/SemaTemplate/instantiation-default-1.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/PrettyPrinter.h b/clang/include/clang/AST/PrettyPrinter.h
index dfd5851bb30d..50e2142e2ef0 100644
--- a/clang/include/clang/AST/PrettyPrinter.h
+++ b/clang/include/clang/AST/PrettyPrinter.h
@@ -55,7 +55,8 @@ struct PrintingPolicy {
SuppressInitializers(false), ConstantArraySizeAsWritten(false),
AnonymousTagLocations(true), SuppressStrongLifetime(false),
SuppressLifetimeQualifiers(false),
- SuppressTemplateArgsInCXXConstructors(false), Bool(LO.Bool),
+ SuppressTemplateArgsInCXXConstructors(false),
+ SuppressDefaultTemplateArgs(true), Bool(LO.Bool),
Nullptr(LO.CPlusPlus11), Restrict(LO.C99), Alignof(LO.CPlusPlus11),
UnderscoreAlignof(LO.C11), UseVoidForZeroParams(!LO.CPlusPlus),
SplitTemplateClosers(!LO.CPlusPlus11), TerseOutput(false),
@@ -167,6 +168,10 @@ struct PrintingPolicy {
/// constructors.
unsigned SuppressTemplateArgsInCXXConstructors : 1;
+ /// When true, attempt to suppress template arguments that match the default
+ /// argument for the parameter.
+ unsigned SuppressDefaultTemplateArgs : 1;
+
/// Whether we can use 'bool' rather than '_Bool' (even if the language
/// doesn't actually have 'bool', because, e.g., it is defined as a macro).
unsigned Bool : 1;
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index 1442bc740620..6dedd097ff89 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -61,6 +61,7 @@ class ExtQuals;
class QualType;
class ConceptDecl;
class TagDecl;
+class TemplateParameterList;
class Type;
enum {
@@ -5196,15 +5197,18 @@ class alignas(8) TemplateSpecializationType
/// enclosing the template arguments.
void printTemplateArgumentList(raw_ostream &OS,
ArrayRef<TemplateArgument> Args,
- const PrintingPolicy &Policy);
+ const PrintingPolicy &Policy,
+ const TemplateParameterList *TPL = nullptr);
void printTemplateArgumentList(raw_ostream &OS,
ArrayRef<TemplateArgumentLoc> Args,
- const PrintingPolicy &Policy);
+ const PrintingPolicy &Policy,
+ const TemplateParameterList *TPL = nullptr);
void printTemplateArgumentList(raw_ostream &OS,
const TemplateArgumentListInfo &Args,
- const PrintingPolicy &Policy);
+ const PrintingPolicy &Policy,
+ const TemplateParameterList *TPL = nullptr);
/// The injected class name of a C++ class template or class
/// template partial specialization. Used to record that a type was
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index 9918377070c3..328ceaa63df3 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -914,10 +914,14 @@ void ClassTemplateSpecializationDecl::getNameForDiagnostic(
const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
PS ? PS->getTemplateArgsAsWritten() : nullptr) {
- printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
+ printTemplateArgumentList(
+ OS, ArgsAsWritten->arguments(), Policy,
+ getSpecializedTemplate()->getTemplateParameters());
} else {
const TemplateArgumentList &TemplateArgs = getTemplateArgs();
- printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
+ printTemplateArgumentList(
+ OS, TemplateArgs.asArray(), Policy,
+ getSpecializedTemplate()->getTemplateParameters());
}
}
@@ -1261,10 +1265,14 @@ void VarTemplateSpecializationDecl::getNameForDiagnostic(
const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
PS ? PS->getTemplateArgsAsWritten() : nullptr) {
- printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
+ printTemplateArgumentList(
+ OS, ArgsAsWritten->arguments(), Policy,
+ getSpecializedTemplate()->getTemplateParameters());
} else {
const TemplateArgumentList &TemplateArgs = getTemplateArgs();
- printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
+ printTemplateArgumentList(
+ OS, TemplateArgs.asArray(), Policy,
+ getSpecializedTemplate()->getTemplateParameters());
}
}
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
index 5e9b22664185..3368905007a4 100644
--- a/clang/lib/AST/TypePrinter.cpp
+++ b/clang/lib/AST/TypePrinter.cpp
@@ -1124,7 +1124,9 @@ void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
OS << T->getTypeConstraintConcept()->getName();
auto Args = T->getTypeConstraintArguments();
if (!Args.empty())
- printTemplateArgumentList(OS, Args, Policy);
+ printTemplateArgumentList(
+ OS, Args, Policy,
+ T->getTypeConstraintConcept()->getTemplateParameters());
OS << ' ';
}
switch (T->getKeyword()) {
@@ -1226,7 +1228,9 @@ void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
OS << Spec->getIdentifier()->getName();
const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
- printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
+ printTemplateArgumentList(
+ OS, TemplateArgs.asArray(), Policy,
+ Spec->getSpecializedTemplate()->getTemplateParameters());
OS << "::";
} else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
@@ -1317,7 +1321,9 @@ void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
Args = TemplateArgs.asArray();
}
IncludeStrongLifetimeRAII Strong(Policy);
- printTemplateArgumentList(OS, Args, Policy);
+ printTemplateArgumentList(
+ OS, Args, Policy,
+ Spec->getSpecializedTemplate()->getTemplateParameters());
}
spaceBeforePlaceHolder(OS);
@@ -1389,7 +1395,11 @@ void TypePrinter::printTemplateSpecializationBefore(
IncludeStrongLifetimeRAII Strong(Policy);
T->getTemplateName().print(OS, Policy);
- printTemplateArgumentList(OS, T->template_arguments(), Policy);
+ const TemplateParameterList *TPL = nullptr;
+ if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl())
+ TPL = TD->getTemplateParameters();
+
+ printTemplateArgumentList(OS, T->template_arguments(), Policy, TPL);
spaceBeforePlaceHolder(OS);
}
@@ -1789,9 +1799,159 @@ static void printArgument(const TemplateArgumentLoc &A,
return A.getArgument().print(PP, OS);
}
+static bool isSubstitutedTemplateArgument(ASTContext &Ctx, TemplateArgument Arg,
+ TemplateArgument Pattern,
+ ArrayRef<TemplateArgument> Args,
+ unsigned Depth);
+
+static bool isSubstitutedType(ASTContext &Ctx, QualType T, QualType Pattern,
+ ArrayRef<TemplateArgument> Args, unsigned Depth) {
+ if (Ctx.hasSameType(T, Pattern))
+ return true;
+
+ // A type parameter matches its argument.
+ if (auto *TTPT = Pattern->getAs<TemplateTypeParmType>()) {
+ if (TTPT->getDepth() == Depth && TTPT->getIndex() < Args.size() &&
+ Args[TTPT->getIndex()].getKind() == TemplateArgument::Type) {
+ QualType SubstArg = Ctx.getQualifiedType(
+ Args[TTPT->getIndex()].getAsType(), Pattern.getQualifiers());
+ return Ctx.hasSameType(SubstArg, T);
+ }
+ return false;
+ }
+
+ // FIXME: Recurse into array types.
+
+ // All other cases will need the types to be identically qualified.
+ Qualifiers TQual, PatQual;
+ T = Ctx.getUnqualifiedArrayType(T, TQual);
+ Pattern = Ctx.getUnqualifiedArrayType(Pattern, PatQual);
+ if (TQual != PatQual)
+ return false;
+
+ // Recurse into pointer-like types.
+ {
+ QualType TPointee = T->getPointeeType();
+ QualType PPointee = Pattern->getPointeeType();
+ if (!TPointee.isNull() && !PPointee.isNull())
+ return T->getTypeClass() == Pattern->getTypeClass() &&
+ isSubstitutedType(Ctx, TPointee, PPointee, Args, Depth);
+ }
+
+ // Recurse into template specialization types.
+ if (auto *PTST =
+ Pattern.getCanonicalType()->getAs<TemplateSpecializationType>()) {
+ TemplateName Template;
+ ArrayRef<TemplateArgument> TemplateArgs;
+ if (auto *TTST = T->getAs<TemplateSpecializationType>()) {
+ Template = TTST->getTemplateName();
+ TemplateArgs = TTST->template_arguments();
+ } else if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
+ T->getAsCXXRecordDecl())) {
+ Template = TemplateName(CTSD->getSpecializedTemplate());
+ TemplateArgs = CTSD->getTemplateArgs().asArray();
+ } else {
+ return false;
+ }
+
+ if (!isSubstitutedTemplateArgument(Ctx, Template, PTST->getTemplateName(),
+ Args, Depth))
+ return false;
+ if (TemplateArgs.size() != PTST->getNumArgs())
+ return false;
+ for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
+ if (!isSubstitutedTemplateArgument(Ctx, TemplateArgs[I], PTST->getArg(I),
+ Args, Depth))
+ return false;
+ return true;
+ }
+
+ // FIXME: Handle more cases.
+ return false;
+}
+
+static bool isSubstitutedTemplateArgument(ASTContext &Ctx, TemplateArgument Arg,
+ TemplateArgument Pattern,
+ ArrayRef<TemplateArgument> Args,
+ unsigned Depth) {
+ Arg = Ctx.getCanonicalTemplateArgument(Arg);
+ Pattern = Ctx.getCanonicalTemplateArgument(Pattern);
+ if (Arg.structurallyEquals(Pattern))
+ return true;
+
+ if (Pattern.getKind() == TemplateArgument::Expression) {
+ if (auto *DRE =
+ dyn_cast<DeclRefExpr>(Pattern.getAsExpr()->IgnoreParenImpCasts())) {
+ if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
+ return NTTP->getDepth() == Depth && Args.size() > NTTP->getIndex() &&
+ Args[NTTP->getIndex()].structurallyEquals(Arg);
+ }
+ }
+
+ if (Arg.getKind() != Pattern.getKind())
+ return false;
+
+ if (Arg.getKind() == TemplateArgument::Type)
+ return isSubstitutedType(Ctx, Arg.getAsType(), Pattern.getAsType(), Args,
+ Depth);
+
+ if (Arg.getKind() == TemplateArgument::Template) {
+ TemplateDecl *PatTD = Pattern.getAsTemplate().getAsTemplateDecl();
+ if (auto *TTPD = dyn_cast_or_null<TemplateTemplateParmDecl>(PatTD))
+ return TTPD->getDepth() == Depth && Args.size() > TTPD->getIndex() &&
+ Ctx.getCanonicalTemplateArgument(Args[TTPD->getIndex()])
+ .structurallyEquals(Arg);
+ }
+
+ // FIXME: Handle more cases.
+ return false;
+}
+
+/// Make a best-effort determination of whether the type T can be produced by
+/// substituting Args into the default argument of Param.
+static bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
+ const NamedDecl *Param,
+ ArrayRef<TemplateArgument> Args,
+ unsigned Depth) {
+ // An empty pack is equivalent to not providing a pack argument.
+ if (Arg.getKind() == TemplateArgument::Pack && Arg.pack_size() == 0)
+ return true;
+
+ if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Param)) {
+ return TTPD->hasDefaultArgument() &&
+ isSubstitutedTemplateArgument(Ctx, Arg, TTPD->getDefaultArgument(),
+ Args, Depth);
+ } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) {
+ return TTPD->hasDefaultArgument() &&
+ isSubstitutedTemplateArgument(
+ Ctx, Arg, TTPD->getDefaultArgument().getArgument(), Args, Depth);
+ } else if (auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+ return NTTPD->hasDefaultArgument() &&
+ isSubstitutedTemplateArgument(Ctx, Arg, NTTPD->getDefaultArgument(),
+ Args, Depth);
+ }
+ return false;
+}
+
template<typename TA>
static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
- const PrintingPolicy &Policy, bool SkipBrackets) {
+ const PrintingPolicy &Policy, bool SkipBrackets,
+ const TemplateParameterList *TPL) {
+ // Drop trailing template arguments that match default arguments.
+ if (TPL && Policy.SuppressDefaultTemplateArgs &&
+ !Policy.PrintCanonicalTypes && !Args.empty() &&
+ Args.size() <= TPL->size()) {
+ ASTContext &Ctx = TPL->getParam(0)->getASTContext();
+ llvm::SmallVector<TemplateArgument, 8> OrigArgs;
+ for (const TA &A : Args)
+ OrigArgs.push_back(getArgument(A));
+ while (!Args.empty() &&
+ isSubstitutedDefaultArgument(Ctx, getArgument(Args.back()),
+ TPL->getParam(Args.size() - 1),
+ OrigArgs, TPL->getDepth()))
+ Args = Args.drop_back();
+ }
+
const char *Comma = Policy.MSVCFormatting ? "," : ", ";
if (!SkipBrackets)
OS << '<';
@@ -1806,7 +1966,7 @@ static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
if (Argument.getKind() == TemplateArgument::Pack) {
if (Argument.pack_size() && !FirstArg)
OS << Comma;
- printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
+ printTo(ArgOS, Argument.getPackAsArray(), Policy, true, nullptr);
} else {
if (!FirstArg)
OS << Comma;
@@ -1839,20 +1999,23 @@ static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
void clang::printTemplateArgumentList(raw_ostream &OS,
const TemplateArgumentListInfo &Args,
- const PrintingPolicy &Policy) {
- return printTo(OS, Args.arguments(), Policy, false);
+ const PrintingPolicy &Policy,
+ const TemplateParameterList *TPL) {
+ printTemplateArgumentList(OS, Args.arguments(), Policy, TPL);
}
void clang::printTemplateArgumentList(raw_ostream &OS,
ArrayRef<TemplateArgument> Args,
- const PrintingPolicy &Policy) {
- printTo(OS, Args, Policy, false);
+ const PrintingPolicy &Policy,
+ const TemplateParameterList *TPL) {
+ printTo(OS, Args, Policy, false, TPL);
}
void clang::printTemplateArgumentList(raw_ostream &OS,
ArrayRef<TemplateArgumentLoc> Args,
- const PrintingPolicy &Policy) {
- printTo(OS, Args, Policy, false);
+ const PrintingPolicy &Policy,
+ const TemplateParameterList *TPL) {
+ printTo(OS, Args, Policy, false, TPL);
}
std::string Qualifiers::getAsString() const {
diff --git a/clang/lib/Frontend/FrontendActions.cpp b/clang/lib/Frontend/FrontendActions.cpp
index 0993e5eb033f..f38da54cebcc 100644
--- a/clang/lib/Frontend/FrontendActions.cpp
+++ b/clang/lib/Frontend/FrontendActions.cpp
@@ -467,7 +467,10 @@ class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
Entry.Event = BeginInstantiation ? "Begin" : "End";
if (auto *NamedTemplate = dyn_cast_or_null<NamedDecl>(Inst.Entity)) {
llvm::raw_string_ostream OS(Entry.Name);
- NamedTemplate->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
+ PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
+ // FIXME: Also ask for FullyQualifiedNames?
+ Policy.SuppressDefaultTemplateArgs = false;
+ NamedTemplate->getNameForDiagnostic(OS, Policy, true);
const PresumedLoc DefLoc =
TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
if(!DefLoc.isInvalid())
diff --git a/clang/test/Misc/diag-template.cpp b/clang/test/Misc/diag-template.cpp
new file mode 100644
index 000000000000..30d4829409bb
--- /dev/null
+++ b/clang/test/Misc/diag-template.cpp
@@ -0,0 +1,37 @@
+// RUN: %clang_cc1 -verify %s
+
+namespace default_args {
+ template<typename T> struct char_traits;
+ template<typename T> struct allocator;
+ template<typename T, typename = char_traits<T>, typename = allocator<T>> struct basic_string {};
+
+ typedef basic_string<char> string;
+
+ template<typename T> T f(T);
+
+ void test1() {
+ string s;
+ f(s).size(); // expected-error {{no member named 'size' in 'default_args::basic_string<char>'}}
+ }
+
+ template<typename T> struct default_delete {};
+ template<class T, class Deleter = default_delete<T>> class unique_ptr {};
+ template<class T, class Deleter> class unique_ptr<T[], Deleter> {};
+ void test2() {
+ unique_ptr<string> ups;
+ f(ups).reset(); // expected-error {{no member named 'reset' in 'default_args::unique_ptr<default_args::basic_string<char>>'}}
+ }
+
+ template<int A, int B = A> struct Z { int error[B]; }; // expected-error {{negative size}}
+ Z<-1> z; // expected-note {{in instantiation of template class 'default_args::Z<-1>' requested here}}
+
+ template<template<typename> class A = allocator, template<typename> class B = A> struct Q {};
+ void test3() {
+ f(Q<>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<>'}}
+ f(Q<allocator>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<>'}}
+ f(Q<allocator, allocator>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<>'}}
+ f(Q<char_traits>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<char_traits>'}}
+ f(Q<char_traits, char_traits>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<char_traits>'}}
+ f(Q<char_traits, allocator>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<char_traits, allocator>'}}
+ }
+}
diff --git a/clang/test/SemaCXX/cxx14-compat.cpp b/clang/test/SemaCXX/cxx14-compat.cpp
index d70f477cd09a..d6396a7de4df 100644
--- a/clang/test/SemaCXX/cxx14-compat.cpp
+++ b/clang/test/SemaCXX/cxx14-compat.cpp
@@ -16,7 +16,7 @@ namespace [[]] NS_with_attr {} // expected-warning {{incompatible with C++ stand
enum { e [[]] }; // expected-warning {{incompatible with C++ standards before C++17}}
template<typename T = int> struct X {};
-X x; // expected-warning {{class template argument deduction is incompatible with C++ standards before C++17; for compatibility, use explicit type name 'X<int>'}}
+X x; // expected-warning {{class template argument deduction is incompatible with C++ standards before C++17; for compatibility, use explicit type name 'X<>'}}
template<template<typename> class> struct Y {};
Y<X> yx; // ok, not class template argument deduction
diff --git a/clang/test/SemaCXX/generic-selection.cpp b/clang/test/SemaCXX/generic-selection.cpp
index c0a5d89fff67..8bf4a784f9bf 100644
--- a/clang/test/SemaCXX/generic-selection.cpp
+++ b/clang/test/SemaCXX/generic-selection.cpp
@@ -14,7 +14,7 @@ static_assert(A<int>::id == 1, "fail");
static_assert(A<float>::id == 2, "fail");
static_assert(A<double, double>::id == 3, "fail");
-A<char> a1; // expected-note {{in instantiation of template class 'A<char, void *>' requested here}}
+A<char> a1; // expected-note {{in instantiation of template class 'A<char>' requested here}}
A<short, int> a2; // expected-note {{in instantiation of template class 'A<short, int>' requested here}}
template <typename T, typename U>
diff --git a/clang/test/SemaTemplate/class-template-id.cpp b/clang/test/SemaTemplate/class-template-id.cpp
index 50cb3ef59ea4..b32a03e478d9 100644
--- a/clang/test/SemaTemplate/class-template-id.cpp
+++ b/clang/test/SemaTemplate/class-template-id.cpp
@@ -9,9 +9,9 @@ A<int, FLOAT> *foo(A<int> *ptr, A<int> const *ptr2, A<int, double> *ptr3) {
if (ptr)
return ptr; // okay
else if (ptr2)
- return ptr2; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'const A<int> *'}}
+ return ptr2; // expected-error{{cannot initialize return object of type 'A<int> *' with an lvalue of type 'const A<int> *'}}
else {
- return ptr3; // expected-error{{cannot initialize return object of type 'A<int, FLOAT> *' (aka 'A<int, float> *') with an lvalue of type 'A<int, double> *'}}
+ return ptr3; // expected-error{{cannot initialize return object of type 'A<int> *' with an lvalue of type 'A<int, double> *'}}
}
}
diff --git a/clang/test/SemaTemplate/class-template-spec.cpp b/clang/test/SemaTemplate/class-template-spec.cpp
index d763944371cc..e96ef44b7a25 100644
--- a/clang/test/SemaTemplate/class-template-spec.cpp
+++ b/clang/test/SemaTemplate/class-template-spec.cpp
@@ -22,7 +22,7 @@ int test_incomplete_specs(A<double, double> *a1,
A<double> *a2)
{
(void)a1->x; // expected-error{{member access into incomplete type}}
- (void)a2->x; // expected-error{{implicit instantiation of undefined template 'A<double, int>'}}
+ (void)a2->x; // expected-error{{implicit instantiation of undefined template 'A<double>'}}
}
typedef float FLOAT;
diff --git a/clang/test/SemaTemplate/instantiation-default-1.cpp b/clang/test/SemaTemplate/instantiation-default-1.cpp
index ab9eca75e239..33e01b6b8aa5 100644
--- a/clang/test/SemaTemplate/instantiation-default-1.cpp
+++ b/clang/test/SemaTemplate/instantiation-default-1.cpp
@@ -36,7 +36,7 @@ typedef int& int_ref_t;
Def2<int_ref_t> *d2; // expected-note{{in instantiation of default argument for 'Def2<int &>' required here}}
-template<> struct Def1<const int> { }; // expected-error{{redefinition of 'Def1<const int, const int>'}}
+template<> struct Def1<const int> { }; // expected-error{{redefinition of 'Def1<const int>'}}
template<typename T, typename T2 = T&> struct Def3;
More information about the cfe-commits
mailing list