Index: include/clang/AST/Decl.h =================================================================== --- include/clang/AST/Decl.h (revision 134851) +++ include/clang/AST/Decl.h (working copy) @@ -1847,7 +1847,14 @@ bool isFunctionTemplateSpecialization() const { return getPrimaryTemplate() != 0; } - + + /// \brief Retrieve the class scope template pattern that this function + /// template specialization is instantiated from. + /// + /// If this function declaration is not a class scope template specialization, + /// returns NULL. + FunctionDecl *getClassScopeSpecializationPattern() const; + /// \brief If this function is actually a function template specialization, /// retrieve information about this function template specialization. /// Otherwise, returns NULL. Index: include/clang/AST/DeclTemplate.h =================================================================== --- include/clang/AST/DeclTemplate.h (revision 134851) +++ include/clang/AST/DeclTemplate.h (working copy) @@ -270,7 +270,8 @@ Template(Template, TSK - 1), TemplateArguments(TemplateArgs), TemplateArgumentsAsWritten(TemplateArgsAsWritten), - PointOfInstantiation(POI) { } + PointOfInstantiation(POI), + ClassScopeSpecializationPattern(0) { } public: static FunctionTemplateSpecializationInfo * @@ -295,6 +296,10 @@ /// The two bits are contain the top 4 values of TemplateSpecializationKind. llvm::PointerIntPair Template; + /// \brief For class scope explicit specialization, this represents the + /// pattern to use to instantiate the function. + FunctionDecl *ClassScopeSpecializationPattern; + /// \brief The template arguments used to produce the function template /// specialization from the function template. const TemplateArgumentList *TemplateArguments; @@ -2097,6 +2102,58 @@ friend class ASTDeclWriter; }; +/// Declaration of a function specialization at template class scope. +/// This is a non standard extension needed to support MSVC. +/// For example: +/// template +/// class A { +/// template void foo(U a) { } +/// template<> void foo(int a) { } +/// } +/// +/// "template<> foo(int a)" will be saved in Specialization as a normal +/// CXXMethodDecl. Then during an instantiation of class A, it will be +/// transformed into an actual function specialization. +class ClassScopeFunctionSpecializationDecl : public Decl { +private: + ClassScopeFunctionSpecializationDecl(DeclContext *DC, SourceLocation Loc, + CXXMethodDecl *FD) + : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc), + Specialization(FD) {} + + ClassScopeFunctionSpecializationDecl(EmptyShell Empty) + : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {} + + CXXMethodDecl *Specialization; + +public: + CXXMethodDecl *getSpecialization() const { return Specialization; } + + static ClassScopeFunctionSpecializationDecl *Create(ASTContext &C, + DeclContext *DC, + SourceLocation Loc, + CXXMethodDecl *FD) { + return new (C) ClassScopeFunctionSpecializationDecl(DC , Loc, FD); + } + + static ClassScopeFunctionSpecializationDecl *Create(ASTContext &Context, + EmptyShell Empty) { + return new (Context)ClassScopeFunctionSpecializationDecl(0, + SourceLocation(), 0); + } + // Implement isa/cast/dyncast/etc. + static bool classof(const Decl *D) { return classofKind(D->getKind()); } + static bool classofKind(Kind K) { + return K == Decl::ClassScopeFunctionSpecialization; + } + static bool classof(const ClassScopeFunctionSpecializationDecl *D) { + return true; + } + + friend class ASTDeclReader; + friend class ASTDeclWriter; +}; + /// Implementation of inline functions that require the template declarations inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD) : Function(FTD) { } Index: include/clang/AST/RecursiveASTVisitor.h =================================================================== --- include/clang/AST/RecursiveASTVisitor.h (revision 134851) +++ include/clang/AST/RecursiveASTVisitor.h (working copy) @@ -1114,6 +1114,10 @@ } }) +DEF_TRAVERSE_DECL(ClassScopeFunctionSpecializationDecl, { + TRY_TO(TraverseDecl(D->getSpecialization())); + }) + DEF_TRAVERSE_DECL(LinkageSpecDecl, { }) DEF_TRAVERSE_DECL(ObjCClassDecl, { Index: include/clang/Basic/DeclNodes.td =================================================================== --- include/clang/Basic/DeclNodes.td (revision 134851) +++ include/clang/Basic/DeclNodes.td (working copy) @@ -74,3 +74,4 @@ def FriendTemplate : Decl; def StaticAssert : Decl; def Block : Decl, DeclContext; +def ClassScopeFunctionSpecialization : Decl; Index: include/clang/Basic/DiagnosticSemaKinds.td =================================================================== --- include/clang/Basic/DiagnosticSemaKinds.td (revision 134851) +++ include/clang/Basic/DiagnosticSemaKinds.td (working copy) @@ -1931,6 +1931,9 @@ "parameter}0">; def err_function_specialization_in_class : Error< "cannot specialize a function %0 within class scope">; +def ext_function_specialization_in_class : ExtWarn< + "explicit specialization of %0 within class scope in a Microsoft extension">, + InGroup; def ext_explicit_specialization_storage_class : ExtWarn< "explicit specialization cannot have a storage class">; def err_explicit_specialization_inconsistent_storage_class : Error< Index: include/clang/Sema/Template.h =================================================================== --- include/clang/Sema/Template.h (revision 134851) +++ include/clang/Sema/Template.h (working copy) @@ -350,7 +350,8 @@ TemplateParameterList *TemplateParams = 0); Decl *VisitCXXRecordDecl(CXXRecordDecl *D); Decl *VisitCXXMethodDecl(CXXMethodDecl *D, - TemplateParameterList *TemplateParams = 0); + TemplateParameterList *TemplateParams = 0, + bool IsClassScopeSpecialization = false); Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); Decl *VisitCXXConversionDecl(CXXConversionDecl *D); @@ -367,6 +368,8 @@ Decl *VisitUsingShadowDecl(UsingShadowDecl *D); Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); + Decl *VisitClassScopeFunctionSpecializationDecl( + ClassScopeFunctionSpecializationDecl *D); // Base case. FIXME: Remove once we can instantiate everything. Decl *VisitDecl(Decl *D) { Index: include/clang/Serialization/ASTBitCodes.h =================================================================== --- include/clang/Serialization/ASTBitCodes.h (revision 134851) +++ include/clang/Serialization/ASTBitCodes.h (working copy) @@ -787,7 +787,10 @@ DECL_INDIRECTFIELD, /// \brief A NonTypeTemplateParmDecl record that stores an expanded /// non-type template parameter pack. - DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK + DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK, + /// \brief A ClassScopeFunctionSpecializationDecl record a class scope + /// function specialization. (Microsoft extension). + DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION }; /// \brief Record codes for each kind of statement or expression. Index: lib/AST/Decl.cpp =================================================================== --- lib/AST/Decl.cpp (revision 134851) +++ lib/AST/Decl.cpp (working copy) @@ -1890,13 +1890,17 @@ switch (getTemplateSpecializationKind()) { case TSK_Undeclared: - case TSK_ExplicitSpecialization: case TSK_ExplicitInstantiationDefinition: return false; case TSK_ImplicitInstantiation: return true; + // It is possible to instantiate TSK_ExplicitSpecialization kind + // if the FunctionDecl has a class scope specialization pattern. + case TSK_ExplicitSpecialization: + return getClassScopeSpecializationPattern() != 0; + case TSK_ExplicitInstantiationDeclaration: // Handled below. break; @@ -1919,6 +1923,10 @@ } FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const { + // Handle class scope explicit specialization special case. + if (getTemplateSpecializationKind() == TSK_ExplicitSpecialization) + return getClassScopeSpecializationPattern(); + if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) { while (Primary->getInstantiatedFromMemberTemplate()) { // If we have hit a point where the user provided a specialization of @@ -1944,6 +1952,14 @@ return 0; } +FunctionDecl *FunctionDecl::getClassScopeSpecializationPattern() const { + if (FunctionTemplateSpecializationInfo *Info + = TemplateOrSpecialization. + dyn_cast()) + return Info->ClassScopeSpecializationPattern; + return 0; +} + const TemplateArgumentList * FunctionDecl::getTemplateSpecializationArgs() const { if (FunctionTemplateSpecializationInfo *Info Index: lib/AST/DeclBase.cpp =================================================================== --- lib/AST/DeclBase.cpp (revision 134851) +++ lib/AST/DeclBase.cpp (working copy) @@ -493,6 +493,7 @@ case UsingDirective: case ClassTemplateSpecialization: case ClassTemplatePartialSpecialization: + case ClassScopeFunctionSpecialization: case ObjCImplementation: case ObjCCategory: case ObjCCategoryImpl: Index: lib/CodeGen/CGDecl.cpp =================================================================== --- lib/CodeGen/CGDecl.cpp (revision 134851) +++ lib/CodeGen/CGDecl.cpp (working copy) @@ -70,6 +70,7 @@ case Decl::Friend: case Decl::FriendTemplate: case Decl::Block: + case Decl::ClassScopeFunctionSpecialization: assert(0 && "Declaration should not be in declstmts!"); case Decl::Function: // void X(); case Decl::Record: // struct/union/class X; Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp (revision 134851) +++ lib/Sema/SemaDecl.cpp (working copy) @@ -1707,9 +1707,16 @@ // Preserve triviality. NewMethod->setTrivial(OldMethod->isTrivial()); + // MSVC allows explicit template specialization at class scope: + // 2 CXMethodDecls refering to the same function will be injected. + // We don't want to redeclartion error. + bool IsClassScopeExplicitSpecialization = + OldMethod->isFunctionTemplateSpecialization() && + NewMethod->isFunctionTemplateSpecialization(); bool isFriend = NewMethod->getFriendObjectKind(); - if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord()) { + if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() && + !IsClassScopeExplicitSpecialization) { // -- Member function declarations with the same name and the // same parameter types cannot be overloaded if any of them // is a static member function declaration. @@ -4182,6 +4189,7 @@ FunctionTemplateDecl *FunctionTemplate = 0; bool isExplicitSpecialization = false; bool isFunctionTemplateSpecialization = false; + bool isDependantClassScopeExplicitSpecialization = false; if (!getLangOptions().CPlusPlus) { // Determine whether the function was written with a @@ -4686,10 +4694,11 @@ } else if (isFunctionTemplateSpecialization) { if (CurContext->isDependentContext() && CurContext->isRecord() && !isFriend) { - Diag(NewFD->getLocation(), diag::err_function_specialization_in_class) + isDependantClassScopeExplicitSpecialization = true; + Diag(NewFD->getLocation(), getLangOptions().Microsoft ? + diag::ext_function_specialization_in_class : + diag::err_function_specialization_in_class) << NewFD->getDeclName(); - NewFD->setInvalidDecl(); - return 0; } else if (CheckFunctionTemplateSpecialization(NewFD, (HasExplicitTemplateArgs ? &TemplateArgs : 0), Previous)) @@ -4719,8 +4728,9 @@ } // Perform semantic checking on the function declaration. - CheckFunctionDeclaration(S, NewFD, Previous, isExplicitSpecialization, - Redeclaration); + if (!isDependantClassScopeExplicitSpecialization) + CheckFunctionDeclaration(S, NewFD, Previous, isExplicitSpecialization, + Redeclaration); assert((NewFD->isInvalidDecl() || !Redeclaration || Previous.getResultKind() != LookupResult::FoundOverloaded) && @@ -4901,6 +4911,21 @@ Context.setcudaConfigureCallDecl(NewFD); } } + + // Here we have an function template explicit specialization at class scope. + // The actually specialization will be postponed to template instatiation + // time via the ClassScopeFunctionSpecializationDecl node. + if (isDependantClassScopeExplicitSpecialization) { + ClassScopeFunctionSpecializationDecl *NewSpec = + ClassScopeFunctionSpecializationDecl::Create( + Context, CurContext, SourceLocation(), + cast(NewFD)); + CurContext->addDecl(NewSpec); + // FIXME: This is hackish: set NewFD to invalid and Redeclaration to true, + // to prevent NewFD from been pushed into scope. + NewFD->setInvalidDecl(); + Redeclaration = true; + } return NewFD; } Index: lib/Sema/SemaTemplate.cpp =================================================================== --- lib/Sema/SemaTemplate.cpp (revision 134851) +++ lib/Sema/SemaTemplate.cpp (working copy) @@ -4493,9 +4493,18 @@ } if (S.CurContext->isRecord() && !IsPartialSpecialization) { - S.Diag(Loc, diag::err_template_spec_decl_class_scope) - << Specialized; - return true; + if (S.getLangOptions().Microsoft) { + // Do not warn for class scope explicit specialization during + // instantiation, warning was already emitted during pattern + // semantic analysis. + if (!S.ActiveTemplateInstantiations.size()) + S.Diag(Loc, diag::ext_function_specialization_in_class) + << Specialized; + } else { + S.Diag(Loc, diag::err_template_spec_decl_class_scope) + << Specialized; + return true; + } } // C++ [temp.class.spec]p6: Index: lib/Sema/SemaTemplateInstantiate.cpp =================================================================== --- lib/Sema/SemaTemplateInstantiate.cpp (revision 134851) +++ lib/Sema/SemaTemplateInstantiate.cpp (working copy) @@ -98,8 +98,9 @@ // Add template arguments from a function template specialization. else if (FunctionDecl *Function = dyn_cast(Ctx)) { if (!RelativeToPrimary && - Function->getTemplateSpecializationKind() - == TSK_ExplicitSpecialization) + (Function->getTemplateSpecializationKind() == + TSK_ExplicitSpecialization && + !Function->getClassScopeSpecializationPattern())) break; if (const TemplateArgumentList *TemplateArgs Index: lib/Sema/SemaTemplateInstantiateDecl.cpp =================================================================== --- lib/Sema/SemaTemplateInstantiateDecl.cpp (revision 134851) +++ lib/Sema/SemaTemplateInstantiateDecl.cpp (working copy) @@ -1290,7 +1290,8 @@ Decl * TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, - TemplateParameterList *TemplateParams) { + TemplateParameterList *TemplateParams, + bool IsClassScopeSpecialization) { FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); void *InsertPos = 0; if (FunctionTemplate && !TemplateParams) { @@ -1495,7 +1496,8 @@ } bool Redeclaration = false; - SemaRef.CheckFunctionDeclaration(0, Method, Previous, false, Redeclaration); + if (!IsClassScopeSpecialization) + SemaRef.CheckFunctionDeclaration(0, Method, Previous, false, Redeclaration); if (D->isPure()) SemaRef.CheckPureMethod(Method, SourceRange()); @@ -1514,7 +1516,7 @@ : Method); if (isFriend) Record->makeDeclVisibleInContext(DeclToAdd); - else + else if (!IsClassScopeSpecialization) Owner->addDecl(DeclToAdd); } @@ -1909,6 +1911,29 @@ return UD; } + +Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl( + ClassScopeFunctionSpecializationDecl *Decl) { + CXXMethodDecl *OldFD = Decl->getSpecialization(); + CXXMethodDecl *NewFD = cast(VisitCXXMethodDecl(OldFD, 0, true)); + + LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName, + Sema::ForRedeclaration); + + SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext); + if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, 0, Previous)) { + NewFD->setInvalidDecl(); + return NewFD; + } + + FunctionDecl *Specialization = cast(Previous.getFoundDecl()); + FunctionTemplateSpecializationInfo *SpecInfo + = Specialization->getTemplateSpecializationInfo(); + SpecInfo->ClassScopeSpecializationPattern = OldFD; + + return NewFD; +} + Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs) { TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs); @@ -2337,8 +2362,10 @@ if (Function->isInvalidDecl() || Function->isDefined()) return; - // Never instantiate an explicit specialization. - if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) + // Never instantiate an explicit specialization except if it is a class scope + // explicit specialization. + if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization && + !Function->getClassScopeSpecializationPattern()) return; // Find the function body that we'll be substituting. Index: lib/Serialization/ASTReaderDecl.cpp =================================================================== --- lib/Serialization/ASTReaderDecl.cpp (revision 134851) +++ lib/Serialization/ASTReaderDecl.cpp (working copy) @@ -1576,6 +1576,10 @@ D = ClassTemplatePartialSpecializationDecl::Create(*Context, Decl::EmptyShell()); break; + case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION: + D = ClassScopeFunctionSpecializationDecl::Create(*Context, + Decl::EmptyShell()); + break; case DECL_FUNCTION_TEMPLATE: D = FunctionTemplateDecl::Create(*Context, Decl::EmptyShell()); break; Index: test/SemaTemplate/ms-function-specialization-class-scope.cpp =================================================================== --- test/SemaTemplate/ms-function-specialization-class-scope.cpp (revision 0) +++ test/SemaTemplate/ms-function-specialization-class-scope.cpp (revision 0) @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -fms-extensions -fsyntax-only -verify %s + + +class A { +public: + template + A(U p) { + } + template <> + A(int p) { // expected-warning{{explicit specialization of 'A' within class scope in a Microsoft extension}} + } + + template + void f(U p) { + } + + template <> + void f(int p) { // expected-warning{{explicit specialization of 'f' within class scope in a Microsoft extension}} + } + + void f(int p) { + } +}; + +void test1() +{ + A a(3); + char* b ; + a.f(b); + a.f(99); + a.f(100); +} + + + + +template +class B { +public: + template + B(U p) { + } + template <> + B(int p) { // expected-warning{{explicit specialization of 'B' within class scope in a Microsoft extension}} + } + + template + void f(U p) { + T y = 9; + } + + + template <> + void f(int p) { // expected-warning{{explicit specialization of 'f' within class scope in a Microsoft extension}} + T a = 3; + } + + void f(int p) { + T a = 3; + } +}; + +void test2() +{ + B b(3); + char* ptr; + b.f(ptr); + b.f(99); + b.f(100); +} + Index: tools/libclang/CIndex.cpp =================================================================== --- tools/libclang/CIndex.cpp (revision 134851) +++ tools/libclang/CIndex.cpp (working copy) @@ -3981,6 +3981,7 @@ case Decl::StaticAssert: case Decl::Block: case Decl::Label: // FIXME: Is this right?? + case Decl::ClassScopeFunctionSpecialization: return C; // Declaration kinds that don't make any sense here, but are