diff options
Diffstat (limited to 'clang/lib/Sema/SemaTemplate.cpp')
| -rw-r--r-- | clang/lib/Sema/SemaTemplate.cpp | 726 |
1 files changed, 362 insertions, 364 deletions
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index dc455185fec..fceac854ee8 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -27,10 +27,10 @@ using namespace clang; static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) { if (!D) return 0; - + if (isa<TemplateDecl>(D)) return D; - + if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { // C++ [temp.local]p1: // Like normal (non-template) classes, class templates have an @@ -52,14 +52,14 @@ static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) { = dyn_cast<ClassTemplateSpecializationDecl>(Record)) return Spec->getSpecializedTemplate(); } - + return 0; } - + OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D); if (!Ovl) return 0; - + for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(), FEnd = Ovl->function_end(); F != FEnd; ++F) { @@ -71,11 +71,11 @@ static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) { if (isa<FunctionTemplateDecl>(*F)) break; } - + if (F != FEnd) { // Build an overloaded function decl containing only the // function templates in Ovl. - OverloadedFunctionDecl *OvlTemplate + OverloadedFunctionDecl *OvlTemplate = OverloadedFunctionDecl::Create(Context, Ovl->getDeclContext(), Ovl->getDeclName()); @@ -85,19 +85,19 @@ static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) { if (isa<FunctionTemplateDecl>(*F)) OvlTemplate->addOverload(*F); } - + return OvlTemplate; } return FuncTmpl; } } - + return 0; } TemplateNameKind Sema::isTemplateName(Scope *S, - const IdentifierInfo &II, + const IdentifierInfo &II, SourceLocation IdLoc, const CXXScopeSpec *SS, TypeTy *ObjectTypePtr, @@ -109,7 +109,7 @@ TemplateNameKind Sema::isTemplateName(Scope *S, if (ObjectTypePtr) { // This nested-name-specifier occurs in a member access expression, e.g., // x->B::f, and we are looking into the type of the object. - assert((!SS || !SS->isSet()) && + assert((!SS || !SS->isSet()) && "ObjectType and scope specifier cannot coexist"); QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr); LookupCtx = computeDeclContext(ObjectType); @@ -121,29 +121,29 @@ TemplateNameKind Sema::isTemplateName(Scope *S, LookupCtx = computeDeclContext(*SS, EnteringContext); isDependent = isDependentScopeSpecifier(*SS); } - + LookupResult Found; bool ObjectTypeSearchedInScope = false; if (LookupCtx) { // Perform "qualified" name lookup into the declaration context we // computed, which is either the type of the base of a member access - // expression or the declaration context associated with a prior + // expression or the declaration context associated with a prior // nested-name-specifier. // The declaration context must be complete. if (!LookupCtx->isDependentContext() && RequireCompleteDeclContext(*SS)) return TNK_Non_template; - + Found = LookupQualifiedName(LookupCtx, &II, LookupOrdinaryName); - + if (ObjectTypePtr && Found.getKind() == LookupResult::NotFound) { // C++ [basic.lookup.classref]p1: // In a class member access expression (5.2.5), if the . or -> token is - // immediately followed by an identifier followed by a <, the - // identifier must be looked up to determine whether the < is the + // immediately followed by an identifier followed by a <, the + // identifier must be looked up to determine whether the < is the // beginning of a template argument list (14.2) or a less-than operator. - // The identifier is first looked up in the class of the object - // expression. If the identifier is not found, it is then looked up in + // The identifier is first looked up in the class of the object + // expression. If the identifier is not found, it is then looked up in // the context of the entire postfix-expression and shall name a class // or function template. // @@ -153,15 +153,15 @@ TemplateNameKind Sema::isTemplateName(Scope *S, ObjectTypeSearchedInScope = true; } } else if (isDependent) { - // We cannot look into a dependent object type or + // We cannot look into a dependent object type or return TNK_Non_template; } else { // Perform unqualified name lookup in the current scope. Found = LookupName(S, &II, LookupOrdinaryName); } - + // FIXME: Cope with ambiguous name-lookup results. - assert(!Found.isAmbiguous() && + assert(!Found.isAmbiguous() && "Cannot handle template name-lookup ambiguities"); NamedDecl *Template = isAcceptableTemplateName(Context, Found); @@ -170,24 +170,24 @@ TemplateNameKind Sema::isTemplateName(Scope *S, if (ObjectTypePtr && !ObjectTypeSearchedInScope) { // C++ [basic.lookup.classref]p1: - // [...] If the lookup in the class of the object expression finds a + // [...] If the lookup in the class of the object expression finds a // template, the name is also looked up in the context of the entire // postfix-expression and [...] // LookupResult FoundOuter = LookupName(S, &II, LookupOrdinaryName); // FIXME: Handle ambiguities in this lookup better NamedDecl *OuterTemplate = isAcceptableTemplateName(Context, FoundOuter); - + if (!OuterTemplate) { - // - if the name is not found, the name found in the class of the + // - if the name is not found, the name found in the class of the // object expression is used, otherwise } else if (!isa<ClassTemplateDecl>(OuterTemplate)) { - // - if the name is found in the context of the entire - // postfix-expression and does not name a class template, the name + // - if the name is found in the context of the entire + // postfix-expression and does not name a class template, the name // found in the class of the object expression is used, otherwise } else { // - if the name found is a class template, it must refer to the same - // entity as the one found in the class of the object expression, + // entity as the one found in the class of the object expression, // otherwise the program is ill-formed. if (OuterTemplate->getCanonicalDecl() != Template->getCanonicalDecl()) { Diag(IdLoc, diag::err_nested_name_member_ref_lookup_ambiguous) @@ -195,38 +195,38 @@ TemplateNameKind Sema::isTemplateName(Scope *S, Diag(Template->getLocation(), diag::note_ambig_member_ref_object_type) << QualType::getFromOpaquePtr(ObjectTypePtr); Diag(OuterTemplate->getLocation(), diag::note_ambig_member_ref_scope); - - // Recover by taking the template that we found in the object + + // Recover by taking the template that we found in the object // expression's type. } - } + } } - + if (SS && SS->isSet() && !SS->isInvalid()) { - NestedNameSpecifier *Qualifier + NestedNameSpecifier *Qualifier = static_cast<NestedNameSpecifier *>(SS->getScopeRep()); - if (OverloadedFunctionDecl *Ovl + if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(Template)) - TemplateResult + TemplateResult = TemplateTy::make(Context.getQualifiedTemplateName(Qualifier, false, Ovl)); else - TemplateResult + TemplateResult = TemplateTy::make(Context.getQualifiedTemplateName(Qualifier, false, - cast<TemplateDecl>(Template))); - } else if (OverloadedFunctionDecl *Ovl + cast<TemplateDecl>(Template))); + } else if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(Template)) { TemplateResult = TemplateTy::make(TemplateName(Ovl)); } else { TemplateResult = TemplateTy::make( TemplateName(cast<TemplateDecl>(Template))); } - - if (isa<ClassTemplateDecl>(Template) || + + if (isa<ClassTemplateDecl>(Template) || isa<TemplateTemplateParmDecl>(Template)) return TNK_Type_template; - - assert((isa<FunctionTemplateDecl>(Template) || + + assert((isa<FunctionTemplateDecl>(Template) || isa<OverloadedFunctionDecl>(Template)) && "Unhandled template kind in Sema::isTemplateName"); return TNK_Function_template; @@ -246,7 +246,7 @@ bool Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) { // C++ [temp.local]p4: // A template-parameter shall not be redeclared within its // scope (including nested scopes). - Diag(Loc, diag::err_template_param_shadow) + Diag(Loc, diag::err_template_param_shadow) << cast<NamedDecl>(PrevDecl)->getDeclName(); Diag(PrevDecl->getLocation(), diag::note_template_param_here); return true; @@ -269,24 +269,24 @@ TemplateDecl *Sema::AdjustDeclIfTemplate(DeclPtrTy &D) { /// (otherwise, "class" was used), and KeyLoc is the location of the /// "class" or "typename" keyword. ParamName is the name of the /// parameter (NULL indicates an unnamed template parameter) and -/// ParamName is the location of the parameter name (if any). +/// ParamName is the location of the parameter name (if any). /// If the type parameter has a default argument, it will be added /// later via ActOnTypeParameterDefault. -Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis, +Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis, SourceLocation EllipsisLoc, SourceLocation KeyLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position) { - assert(S->isTemplateParamScope() && - "Template type parameter not in template parameter scope!"); + assert(S->isTemplateParamScope() && + "Template type parameter not in template parameter scope!"); bool Invalid = false; if (ParamName) { NamedDecl *PrevDecl = LookupName(S, ParamName, LookupTagName); if (PrevDecl && PrevDecl->isTemplateParameter()) Invalid = Invalid || DiagnoseTemplateParameterShadow(ParamNameLoc, - PrevDecl); + PrevDecl); } SourceLocation Loc = ParamNameLoc; @@ -294,8 +294,8 @@ Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis, Loc = KeyLoc; TemplateTypeParmDecl *Param - = TemplateTypeParmDecl::Create(Context, CurContext, Loc, - Depth, Position, ParamName, Typename, + = TemplateTypeParmDecl::Create(Context, CurContext, Loc, + Depth, Position, ParamName, Typename, Ellipsis); if (Invalid) Param->setInvalidDecl(); @@ -310,28 +310,28 @@ Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis, } /// ActOnTypeParameterDefault - Adds a default argument (the type -/// Default) to the given template type parameter (TypeParam). -void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam, +/// Default) to the given template type parameter (TypeParam). +void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam, SourceLocation EqualLoc, - SourceLocation DefaultLoc, + SourceLocation DefaultLoc, TypeTy *DefaultT) { - TemplateTypeParmDecl *Parm + TemplateTypeParmDecl *Parm = cast<TemplateTypeParmDecl>(TypeParam.getAs<Decl>()); // FIXME: Preserve type source info. QualType Default = GetTypeFromParser(DefaultT); // C++0x [temp.param]p9: // A default template-argument may be specified for any kind of - // template-parameter that is not a template parameter pack. + // template-parameter that is not a template parameter pack. if (Parm->isParameterPack()) { Diag(DefaultLoc, diag::err_template_param_pack_default_arg); return; } - + // C++ [temp.param]p14: // A template-parameter shall not be used in its own default argument. // FIXME: Implement this check! Needs a recursive walk over the types. - + // Check the template argument itself. if (CheckTemplateArgument(Parm, Default, DefaultLoc)) { Parm->setInvalidDecl(); @@ -346,7 +346,7 @@ void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam, /// /// \returns the (possibly-promoted) parameter type if valid; /// otherwise, produces a diagnostic and returns a NULL type. -QualType +QualType Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) { // C++ [temp.param]p4: // @@ -355,11 +355,11 @@ Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) { // // -- integral or enumeration type, if (T->isIntegralType() || T->isEnumeralType() || - // -- pointer to object or pointer to function, - (T->isPointerType() && + // -- pointer to object or pointer to function, + (T->isPointerType() && (T->getAs<PointerType>()->getPointeeType()->isObjectType() || T->getAs<PointerType>()->getPointeeType()->isFunctionType())) || - // -- reference to object or reference to function, + // -- reference to object or reference to function, T->isReferenceType() || // -- pointer to member. T->isMemberPointerType() || @@ -390,7 +390,7 @@ Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) { /// class Array") has been parsed. S is the current scope and D is /// the parsed declarator. Sema::DeclPtrTy Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, - unsigned Depth, + unsigned Depth, unsigned Position) { DeclaratorInfo *DInfo = 0; QualType T = GetTypeForDeclarator(D, S, &DInfo); @@ -432,14 +432,14 @@ Sema::DeclPtrTy Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, void Sema::ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParamD, SourceLocation EqualLoc, ExprArg DefaultE) { - NonTypeTemplateParmDecl *TemplateParm + NonTypeTemplateParmDecl *TemplateParm = cast<NonTypeTemplateParmDecl>(TemplateParamD.getAs<Decl>()); Expr *Default = static_cast<Expr *>(DefaultE.get()); - + // C++ [temp.param]p14: // A template-parameter shall not be used in its own default argument. // FIXME: Implement this check! Needs a recursive walk over the types. - + // Check the well-formedness of the default template argument. TemplateArgument Converted; if (CheckTemplateArgument(TemplateParm, TemplateParm->getType(), Default, @@ -461,8 +461,7 @@ Sema::DeclPtrTy Sema::ActOnTemplateTemplateParameter(Scope* S, IdentifierInfo *Name, SourceLocation NameLoc, unsigned Depth, - unsigned Position) -{ + unsigned Position) { assert(S->isTemplateParamScope() && "Template template parameter not in template parameter scope!"); @@ -496,12 +495,12 @@ Sema::DeclPtrTy Sema::ActOnTemplateTemplateParameter(Scope* S, void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD, SourceLocation EqualLoc, ExprArg DefaultE) { - TemplateTemplateParmDecl *TemplateParm + TemplateTemplateParmDecl *TemplateParm = cast<TemplateTemplateParmDecl>(TemplateParamD.getAs<Decl>()); // Since a template-template parameter's default argument is an // id-expression, it must be a DeclRefExpr. - DeclRefExpr *Default + DeclRefExpr *Default = cast<DeclRefExpr>(static_cast<Expr *>(DefaultE.get())); // C++ [temp.param]p14: @@ -510,12 +509,12 @@ void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD, // Check the well-formedness of the template argument. if (!isa<TemplateDecl>(Default->getDecl())) { - Diag(Default->getSourceRange().getBegin(), + Diag(Default->getSourceRange().getBegin(), diag::err_template_arg_must_be_template) << Default->getSourceRange(); TemplateParm->setInvalidDecl(); return; - } + } if (CheckTemplateArgument(TemplateParm, Default)) { TemplateParm->setInvalidDecl(); return; @@ -530,7 +529,7 @@ void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD, Sema::TemplateParamsTy * Sema::ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, - SourceLocation TemplateLoc, + SourceLocation TemplateLoc, SourceLocation LAngleLoc, DeclPtrTy *Params, unsigned NumParams, SourceLocation RAngleLoc) { @@ -548,7 +547,7 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, AttributeList *Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS) { - assert(TemplateParams && TemplateParams->size() > 0 && + assert(TemplateParams && TemplateParams->size() > 0 && "No template parameters"); assert(TUK != TUK_Reference && "Can only declare or define class templates"); bool Invalid = false; @@ -580,14 +579,14 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, // FIXME: Produce a reasonable diagnostic here return true; } - - Previous = LookupQualifiedName(SemanticContext, Name, LookupOrdinaryName, + + Previous = LookupQualifiedName(SemanticContext, Name, LookupOrdinaryName, true); } else { SemanticContext = CurContext; Previous = LookupName(S, Name, LookupOrdinaryName, true); } - + assert(!Previous.isAmbiguous() && "Ambiguity in class template redecl?"); NamedDecl *PrevDecl = 0; if (Previous.begin() != Previous.end()) @@ -595,10 +594,10 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, if (PrevDecl && !isDeclInScope(PrevDecl, SemanticContext, S)) PrevDecl = 0; - + // If there is a previous declaration with the same name, check // whether this is a valid redeclaration. - ClassTemplateDecl *PrevClassTemplate + ClassTemplateDecl *PrevClassTemplate = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl); if (PrevClassTemplate) { // Ensure that the template parameter lists are compatible. @@ -614,9 +613,9 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, // template declaration (7.1.5.3). RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl(); if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind, KWLoc, *Name)) { - Diag(KWLoc, diag::err_use_with_wrong_tag) + Diag(KWLoc, diag::err_use_with_wrong_tag) << Name - << CodeModificationHint::CreateReplacement(KWLoc, + << CodeModificationHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName()); Diag(PrevRecordDecl->getLocation(), diag::note_previous_use); Kind = PrevRecordDecl->getTagKind(); @@ -654,13 +653,13 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, if (CheckTemplateParameterList(TemplateParams, PrevClassTemplate? PrevClassTemplate->getTemplateParameters() : 0)) Invalid = true; - + // FIXME: If we had a scope specifier, we better have a previous template // declaration! - CXXRecordDecl *NewClass = + CXXRecordDecl *NewClass = CXXRecordDecl::Create(Context, Kind, SemanticContext, NameLoc, Name, KWLoc, - PrevClassTemplate? + PrevClassTemplate? PrevClassTemplate->getTemplatedDecl() : 0, /*DelayTypeCreation=*/true); @@ -671,16 +670,16 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, NewClass->setDescribedClassTemplate(NewTemplate); // Build the type for the class template declaration now. - QualType T = - Context.getTypeDeclType(NewClass, - PrevClassTemplate? - PrevClassTemplate->getTemplatedDecl() : 0); + QualType T = + Context.getTypeDeclType(NewClass, + PrevClassTemplate? + PrevClassTemplate->getTemplatedDecl() : 0); assert(T->isDependentType() && "Class template type is not dependent?"); (void)T; // Set the access specifier. SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS); - + // Set the lexical context of these templates NewClass->setLexicalDeclContext(CurContext); NewTemplate->setLexicalDeclContext(CurContext); @@ -722,7 +721,7 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams) { bool Invalid = false; - + // C++ [temp.param]p10: // The set of default template-arguments available for use with a // template declaration or definition is obtained by merging the @@ -755,7 +754,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, // If a template parameter of a class template is a template parameter pack, // it must be the last template parameter. if (SawParameterPack) { - Diag(ParameterPackLoc, + Diag(ParameterPackLoc, diag::err_template_param_pack_must_be_last_template_parameter); Invalid = true; } @@ -763,15 +762,15 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, // Merge default arguments for template type parameters. if (TemplateTypeParmDecl *NewTypeParm = dyn_cast<TemplateTypeParmDecl>(*NewParam)) { - TemplateTypeParmDecl *OldTypeParm + TemplateTypeParmDecl *OldTypeParm = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : 0; - + if (NewTypeParm->isParameterPack()) { assert(!NewTypeParm->hasDefaultArgument() && "Parameter packs can't have a default argument!"); SawParameterPack = true; ParameterPackLoc = NewTypeParm->getLocation(); - } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() && + } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() && NewTypeParm->hasDefaultArgument()) { OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc(); NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc(); @@ -796,7 +795,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, // Merge default arguments for non-type template parameters NonTypeTemplateParmDecl *OldNonTypeParm = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : 0; - if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() && + if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() && NewNonTypeParm->hasDefaultArgument()) { OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc(); NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc(); @@ -817,14 +816,14 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, SawDefaultArgument = true; PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc(); } else if (SawDefaultArgument) - MissingDefaultArg = true; + MissingDefaultArg = true; } else { // Merge default arguments for template template parameters TemplateTemplateParmDecl *NewTemplateParm = cast<TemplateTemplateParmDecl>(*NewParam); TemplateTemplateParmDecl *OldTemplateParm = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : 0; - if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() && + if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() && NewTemplateParm->hasDefaultArgument()) { OldDefaultLoc = OldTemplateParm->getDefaultArgumentLoc(); NewDefaultLoc = NewTemplateParm->getDefaultArgumentLoc(); @@ -844,7 +843,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, SawDefaultArgument = true; PreviousDefaultArgLoc = NewTemplateParm->getDefaultArgumentLoc(); } else if (SawDefaultArgument) - MissingDefaultArg = true; + MissingDefaultArg = true; } if (RedundantDefaultArg) { @@ -859,7 +858,7 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, // If a template-parameter has a default template-argument, // all subsequent template-parameters shall have a default // template-argument supplied. - Diag((*NewParam)->getLocation(), + Diag((*NewParam)->getLocation(), diag::err_template_param_default_arg_missing); Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg); Invalid = true; @@ -874,13 +873,13 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, return Invalid; } -/// \brief Match the given template parameter lists to the given scope +/// \brief Match the given template parameter lists to the given scope /// specifier, returning the template parameter list that applies to the /// name. /// /// \param DeclStartLoc the start of the declaration that has a scope /// specifier or a template parameter list. -/// +/// /// \param SS the scope specifier that will be matched to the given template /// parameter lists. This scope specifier precedes a qualified name that is /// being declared. @@ -890,10 +889,10 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, /// /// \param NumParamLists the number of template parameter lists in ParamLists. /// -/// \returns the template parameter list, if any, that corresponds to the +/// \returns the template parameter list, if any, that corresponds to the /// name that is preceded by the scope specifier @p SS. This template /// parameter list may be have template parameters (if we're declaring a -/// template) or may have no template parameters (if we're declaring a +/// template) or may have no template parameters (if we're declaring a /// template specialization), or may be NULL (if we were's declaring isn't /// itself a template). TemplateParameterList * @@ -907,35 +906,35 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, TemplateIdsInSpecifier; for (NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); NNS; NNS = NNS->getPrefix()) { - if (const TemplateSpecializationType *SpecType + if (const TemplateSpecializationType *SpecType = dyn_cast_or_null<TemplateSpecializationType>(NNS->getAsType())) { TemplateDecl *Template = SpecType->getTemplateName().getAsTemplateDecl(); if (!Template) continue; // FIXME: should this be an error? probably... - + if (const RecordType *Record = SpecType->getAs<RecordType>()) { ClassTemplateSpecializationDecl *SpecDecl = cast<ClassTemplateSpecializationDecl>(Record->getDecl()); // If the nested name specifier refers to an explicit specialization, // we don't need a template<> header. - // FIXME: revisit this approach once we cope with specialization + // FIXME: revisit this approach once we cope with specialization // properly. if (SpecDecl->getSpecializationKind() == TSK_ExplicitSpecialization) continue; } - + TemplateIdsInSpecifier.push_back(SpecType); } } - + // Reverse the list of template-ids in the scope specifier, so that we can // more easily match up the template-ids and the template parameter lists. std::reverse(TemplateIdsInSpecifier.begin(), TemplateIdsInSpecifier.end()); - + SourceLocation FirstTemplateLoc = DeclStartLoc; if (NumParamLists) FirstTemplateLoc = ParamLists[0]->getTemplateLoc(); - + // Match the template-ids found in the specifier to the template parameter // lists. unsigned Idx = 0; @@ -947,8 +946,8 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, // We have a template-id without a corresponding template parameter // list. if (DependentTemplateId) { - // FIXME: the location information here isn't great. - Diag(SS.getRange().getBegin(), + // FIXME: the location information here isn't great. + Diag(SS.getRange().getBegin(), diag::err_template_spec_needs_template_parameters) << TemplateId << SS.getRange(); @@ -960,13 +959,13 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, } return 0; } - + // Check the template parameter list against its corresponding template-id. if (DependentTemplateId) { - TemplateDecl *Template + TemplateDecl *Template = TemplateIdsInSpecifier[Idx]->getTemplateName().getAsTemplateDecl(); - if (ClassTemplateDecl *ClassTemplate + if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(Template)) { TemplateParameterList *ExpectedTemplateParams = 0; // Is this template-id naming the primary template? @@ -979,34 +978,34 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, ExpectedTemplateParams = PartialSpec->getTemplateParameters(); if (ExpectedTemplateParams) - TemplateParameterListsAreEqual(ParamLists[Idx], + TemplateParameterListsAreEqual(ParamLists[Idx], ExpectedTemplateParams, true); - } + } } else if (ParamLists[Idx]->size() > 0) - Diag(ParamLists[Idx]->getTemplateLoc(), + Diag(ParamLists[Idx]->getTemplateLoc(), diag::err_template_param_list_matches_nontemplate) << TemplateId << ParamLists[Idx]->getSourceRange(); } - + // If there were at least as many template-ids as there were template // parameter lists, then there are no template parameter lists remaining for // the declaration itself. if (Idx >= NumParamLists) return 0; - + // If there were too many template parameter lists, complain about that now. if (Idx != NumParamLists - 1) { while (Idx < NumParamLists - 1) { - Diag(ParamLists[Idx]->getTemplateLoc(), + Diag(ParamLists[Idx]->getTemplateLoc(), diag::err_template_spec_extra_headers) << SourceRange(ParamLists[Idx]->getTemplateLoc(), ParamLists[Idx]->getRAngleLoc()); ++Idx; } } - + // Return the last template parameter list, which corresponds to the // entity being declared. return ParamLists[NumParamLists - 1]; @@ -1014,8 +1013,8 @@ Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, /// \brief Translates template arguments as provided by the parser /// into template arguments used by semantic analysis. -static void -translateTemplateArguments(ASTTemplateArgsPtr &TemplateArgsIn, +static void +translateTemplateArguments(ASTTemplateArgsPtr &TemplateArgsIn, SourceLocation *TemplateArgLocs, llvm::SmallVector<TemplateArgument, 16> &TemplateArgs) { TemplateArgs.reserve(TemplateArgsIn.size()); @@ -1049,12 +1048,12 @@ QualType Sema::CheckTemplateIdType(TemplateName Name, // template. TemplateArgumentListBuilder Converted(Template->getTemplateParameters(), NumTemplateArgs); - if (CheckTemplateArgumentList(Template, TemplateLoc, LAngleLoc, + if (CheckTemplateArgumentList(Template, TemplateLoc, LAngleLoc, TemplateArgs, NumTemplateArgs, RAngleLoc, false, Converted)) return QualType(); - assert((Converted.structuredSize() == + assert((Converted.structuredSize() == Template->getTemplateParameters()->size()) && "Converted template argument list is too short!"); @@ -1071,21 +1070,21 @@ QualType Sema::CheckTemplateIdType(TemplateName Name, // // template<typename T, typename U = T> struct A; TemplateName CanonName = Context.getCanonicalTemplateName(Name); - CanonType = Context.getTemplateSpecializationType(CanonName, + CanonType = Context.getTemplateSpecializationType(CanonName, Converted.getFlatArguments(), Converted.flatSize()); - + // FIXME: CanonType is not actually the canonical type, and unfortunately // it is a TemplateTypeSpecializationType that we will never use again. // In the future, we need to teach getTemplateSpecializationType to only // build the canonical type and return that to us. CanonType = Context.getCanonicalType(CanonType); - } else if (ClassTemplateDecl *ClassTemplate + } else if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(Template)) { // Find the class template specialization declaration that // corresponds to these arguments. llvm::FoldingSetNodeID ID; - ClassTemplateSpecializationDecl::Profile(ID, + ClassTemplateSpecializationDecl::Profile(ID, Converted.getFlatArguments(), Converted.flatSize(), Context); @@ -1096,7 +1095,7 @@ QualType Sema::CheckTemplateIdType(TemplateName Name, // This is the first time we have referenced this class template // specialization. Create the canonical declaration and add it to // the set of specializations. - Decl = ClassTemplateSpecializationDecl::Create(Context, + Decl = ClassTemplateSpecializationDecl::Create(Context, ClassTemplate->getDeclContext(), TemplateLoc, ClassTemplate, @@ -1107,7 +1106,7 @@ QualType Sema::CheckTemplateIdType(TemplateName Name, CanonType = Context.getTypeDeclType(Decl); } - + // Build the fully-sugared type for this class template // specialization, which refers back to the class template // specialization we created or found. @@ -1118,7 +1117,7 @@ QualType Sema::CheckTemplateIdType(TemplateName Name, Action::TypeResult Sema::ActOnTemplateIdType(TemplateTy TemplateD, SourceLocation TemplateLoc, - SourceLocation LAngleLoc, + SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation *TemplateArgLocs, SourceLocation RAngleLoc) { @@ -1151,7 +1150,7 @@ Sema::TypeResult Sema::ActOnTagTemplateIdType(TypeResult TypeResult, // Verify the tag specifier. TagDecl::TagKind TagKind = TagDecl::getTagKindForTypeSpec(TagSpec); - + if (const RecordType *RT = Type->getAs<RecordType>()) { RecordDecl *D = RT->getDecl(); @@ -1179,14 +1178,14 @@ Sema::OwningExprResult Sema::BuildTemplateIdExpr(TemplateName Template, SourceLocation RAngleLoc) { // FIXME: Can we do any checking at this point? I guess we could check the // template arguments that we have against the template name, if the template - // name refers to a single template. That's not a terribly common case, + // name refers to a single template. That's not a terribly common case, // though. - return Owned(TemplateIdRefExpr::Create(Context, + return Owned(TemplateIdRefExpr::Create(Context, /*FIXME: New type?*/Context.OverloadTy, /*FIXME: Necessary?*/0, /*FIXME: Necessary?*/SourceRange(), Template, TemplateNameLoc, LAngleLoc, - TemplateArgs, + TemplateArgs, NumTemplateArgs, RAngleLoc)); } @@ -1197,12 +1196,12 @@ Sema::OwningExprResult Sema::ActOnTemplateIdExpr(TemplateTy TemplateD, SourceLocation *TemplateArgLocs, SourceLocation RAngleLoc) { TemplateName Template = TemplateD.getAsVal<TemplateName>(); - + // Translate the parser's template argument list in our AST format. llvm::SmallVector<TemplateArgument, 16> TemplateArgs; translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); TemplateArgsIn.release(); - + return BuildTemplateIdExpr(Template, TemplateNameLoc, LAngleLoc, TemplateArgs.data(), TemplateArgs.size(), RAngleLoc); @@ -1220,7 +1219,7 @@ Sema::ActOnMemberTemplateIdReferenceExpr(Scope *S, ExprArg Base, SourceLocation *TemplateArgLocs, SourceLocation RAngleLoc) { TemplateName Template = TemplateD.getAsVal<TemplateName>(); - + // FIXME: We're going to end up looking up the template based on its name, // twice! DeclarationName Name; @@ -1230,17 +1229,17 @@ Sema::ActOnMemberTemplateIdReferenceExpr(Scope *S, ExprArg Base, Name = Ovl->getDeclName(); else Name = Template.getAsDependentTemplateName()->getName(); - + // Translate the parser's template argument list in our AST format. llvm::SmallVector<TemplateArgument, 16> TemplateArgs; translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); TemplateArgsIn.release(); - + // Do we have the save the actual template name? We might need it... return BuildMemberReferenceExpr(S, move(Base), OpLoc, OpKind, TemplateNameLoc, Name, true, LAngleLoc, TemplateArgs.data(), TemplateArgs.size(), - RAngleLoc, DeclPtrTy(), &SS); + RAngleLoc, DeclPtrTy(), &SS); } /// \brief Form a dependent template name. @@ -1250,13 +1249,13 @@ Sema::ActOnMemberTemplateIdReferenceExpr(Scope *S, ExprArg Base, /// example, given "MetaFun::template apply", the scope specifier \p /// SS will be "MetaFun::", \p TemplateKWLoc contains the location /// of the "template" keyword, and "apply" is the \p Name. -Sema::TemplateTy +Sema::TemplateTy Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc, const IdentifierInfo &Name, SourceLocation NameLoc, const CXXScopeSpec &SS, TypeTy *ObjectType) { - if ((ObjectType && + if ((ObjectType && computeDeclContext(QualType::getFromOpaquePtr(ObjectType))) || (SS.isSet() && computeDeclContext(SS, false))) { // C++0x [temp.names]p5: @@ -1276,7 +1275,7 @@ Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc, // "template" keyword is now permitted). We follow the C++0x // rules, even in C++03 mode, retroactively applying the DR. TemplateTy Template; - TemplateNameKind TNK = isTemplateName(0, Name, NameLoc, &SS, ObjectType, + TemplateNameKind TNK = isTemplateName(0, Name, NameLoc, &SS, ObjectType, false, Template); if (TNK == TNK_Non_template) { Diag(NameLoc, diag::err_template_kw_refers_to_non_template) @@ -1287,12 +1286,12 @@ Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc, return Template; } - NestedNameSpecifier *Qualifier + NestedNameSpecifier *Qualifier = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); return TemplateTy::make(Context.getDependentTemplateName(Qualifier, &Name)); } -bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, +bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, const TemplateArgument &Arg, TemplateArgumentListBuilder &Converted) { // Check template type parameter. @@ -1305,13 +1304,13 @@ bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, // is not a type. Diag(Arg.getLocation(), diag::err_template_arg_must_be_type); Diag(Param->getLocation(), diag::note_template_param_here); - + return true; - } + } if (CheckTemplateArgument(Param, Arg.getAsType(), Arg.getLocation())) return true; - + // Add the converted template type argument. Converted.Append( TemplateArgument(Arg.getLocation(), @@ -1334,9 +1333,9 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, unsigned NumArgs = NumTemplateArgs; bool Invalid = false; - bool HasParameterPack = + bool HasParameterPack = NumParams > 0 && Params->getParam(NumParams - 1)->isTemplateParameterPack(); - + if ((NumArgs > NumParams && !HasParameterPack) || (NumArgs < Params->getMinRequiredArguments() && !PartialTemplateArgs)) { @@ -1356,8 +1355,8 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, << Params->getSourceRange(); Invalid = true; } - - // C++ [temp.arg]p1: + + // C++ [temp.arg]p1: // [...] The type and form of each template-argument specified in // a template-id shall match the type and form specified for the // corresponding parameter declared by the template in its @@ -1368,7 +1367,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, Param != ParamEnd; ++Param, ++ArgIdx) { if (ArgIdx > NumArgs && PartialTemplateArgs) break; - + // Decode the template argument TemplateArgument Arg; if (ArgIdx >= NumArgs) { @@ -1381,7 +1380,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, Converted.EndPack(); break; } - + if (!TTP->hasDefaultArgument()) break; @@ -1390,14 +1389,14 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, // If the argument type is dependent, instantiate it now based // on the previously-computed template arguments. if (ArgType->isDependentType()) { - InstantiatingTemplate Inst(*this, TemplateLoc, + InstantiatingTemplate Inst(*this, TemplateLoc, Template, Converted.getFlatArguments(), Converted.flatSize(), SourceRange(TemplateLoc, RAngleLoc)); TemplateArgumentList TemplateArgs(Context, Converted, /*TakeArgs=*/false); - ArgType = SubstType(ArgType, + ArgType = SubstType(ArgType, MultiLevelTemplateArgumentList(TemplateArgs), TTP->getDefaultArgumentLoc(), TTP->getDeclName()); @@ -1407,29 +1406,29 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, return true; Arg = TemplateArgument(TTP->getLocation(), ArgType); - } else if (NonTypeTemplateParmDecl *NTTP + } else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { if (!NTTP->hasDefaultArgument()) break; - InstantiatingTemplate Inst(*this, TemplateLoc, + InstantiatingTemplate Inst(*this, TemplateLoc, Template, Converted.getFlatArguments(), Converted.flatSize(), SourceRange(TemplateLoc, RAngleLoc)); - + TemplateArgumentList TemplateArgs(Context, Converted, /*TakeArgs=*/false); - Sema::OwningExprResult E - = SubstExpr(NTTP->getDefaultArgument(), + Sema::OwningExprResult E + = SubstExpr(NTTP->getDefaultArgument(), MultiLevelTemplateArgumentList(TemplateArgs)); if (E.isInvalid()) return true; - + Arg = TemplateArgument(E.takeAs<Expr>()); } else { - TemplateTemplateParmDecl *TempParm - = cast<TemplateTemplateParmDecl>(*Param); + TemplateTemplateParmDecl *TempParm + = cast<TemplateTemplateParmDecl>(*Param); if (!TempParm->hasDefaultArgument()) break; @@ -1451,13 +1450,13 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, if (CheckTemplateTypeArgument(TTP, TemplateArgs[ArgIdx], Converted)) Invalid = true; } - + Converted.EndPack(); } else { if (CheckTemplateTypeArgument(TTP, Arg, Converted)) Invalid = true; } - } else if (NonTypeTemplateParmDecl *NTTP + } else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { // Check non-type template parameters. @@ -1466,21 +1465,21 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, QualType NTTPType = NTTP->getType(); if (NTTPType->isDependentType()) { // Do substitution on the type of the non-type template parameter. - InstantiatingTemplate Inst(*this, TemplateLoc, + InstantiatingTemplate Inst(*this, TemplateLoc, Template, Converted.getFlatArguments(), Converted.flatSize(), SourceRange(TemplateLoc, RAngleLoc)); TemplateArgumentList TemplateArgs(Context, Converted, /*TakeArgs=*/false); - NTTPType = SubstType(NTTPType, + NTTPType = SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs), NTTP->getLocation(), NTTP->getDeclName()); // If that worked, check the non-type template parameter type // for validity. if (!NTTPType.isNull()) - NTTPType = CheckNonTypeTemplateParameterType(NTTPType, + NTTPType = CheckNonTypeTemplateParameterType(NTTPType, NTTP->getLocation()); if (NTTPType.isNull()) { Invalid = true; @@ -1492,7 +1491,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, case TemplateArgument::Null: assert(false && "Should never see a NULL template argument here"); break; - + case TemplateArgument::Expression: { Expr *E = Arg.getAsExpr(); TemplateArgument Result; @@ -1513,7 +1512,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, case TemplateArgument::Type: // We have a non-type template parameter but the template // argument is a type. - + // C++ [temp.arg]p2: // In a template-argument, an ambiguity between a type-id and // an expression is resolved to a type-id, regardless of the @@ -1529,37 +1528,37 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, Diag((*Param)->getLocation(), diag::note_template_param_here); Invalid = true; break; - + case TemplateArgument::Pack: assert(0 && "FIXME: Implement!"); break; } - } else { + } else { // Check template template parameters. - TemplateTemplateParmDecl *TempParm + TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(*Param); - + switch (Arg.getKind()) { case TemplateArgument::Null: assert(false && "Should never see a NULL template argument here"); break; - + case TemplateArgument::Expression: { Expr *ArgExpr = Arg.getAsExpr(); if (ArgExpr && isa<DeclRefExpr>(ArgExpr) && isa<TemplateDecl>(cast<DeclRefExpr>(ArgExpr)->getDecl())) { if (CheckTemplateArgument(TempParm, cast<DeclRefExpr>(ArgExpr))) Invalid = true; - + // Add the converted template argument. - Decl *D + Decl *D = cast<DeclRefExpr>(ArgExpr)->getDecl()->getCanonicalDecl(); Converted.Append(TemplateArgument(Arg.getLocation(), D)); continue; } } // fall through - + case TemplateArgument::Type: { // We have a template template parameter but the template // argument does not refer to a template. @@ -1573,11 +1572,11 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, // it to the list of converted arguments. Converted.Append(Arg); break; - + case TemplateArgument::Integral: assert(false && "Integral argument with template template parameter"); break; - + case TemplateArgument::Pack: assert(0 && "FIXME: Implement!"); break; @@ -1593,7 +1592,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, /// /// This routine implements the semantics of C++ [temp.arg.type]. It /// returns true if an error occurred, and false otherwise. -bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, +bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, QualType Arg, SourceLocation ArgLoc) { // C++ [temp.arg.type]p2: // A local type, a type with no linkage, an unnamed type or a type @@ -1609,7 +1608,7 @@ bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, if (Tag && Tag->getDecl()->getDeclContext()->isFunctionOrMethod()) return Diag(ArgLoc, diag::err_template_arg_local_type) << QualType(Tag, 0); - else if (Tag && !Tag->getDecl()->getDeclName() && + else if (Tag && !Tag->getDecl()->getDeclName() && !Tag->getDecl()->getTypedefForAnonDecl()) { Diag(ArgLoc, diag::err_template_arg_unnamed_type); Diag(Tag->getDecl()->getLocation(), diag::note_template_unnamed_type_here); @@ -1634,7 +1633,7 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, return false; // C++ [temp.arg.nontype]p1: - // + // // A template-argument for a non-type, non-template // template-parameter shall be one of: [...] // @@ -1645,11 +1644,11 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, // the name refers to a function or array, or if the // corresponding template-parameter is a reference; or DeclRefExpr *DRE = 0; - + // Ignore (and complain about) any excess parentheses. while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { if (!Invalid) { - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_extra_parens) << Arg->getSourceRange(); Invalid = true; @@ -1665,7 +1664,7 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, DRE = dyn_cast<DeclRefExpr>(Arg); if (!DRE || !isa<ValueDecl>(DRE->getDecl())) - return Diag(Arg->getSourceRange().getBegin(), + return Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_object_or_func_form) << Arg->getSourceRange(); @@ -1677,14 +1676,14 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, // Cannot refer to non-static member functions if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(DRE->getDecl())) if (!Method->isStatic()) - return Diag(Arg->getSourceRange().getBegin(), + return Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_method) << Method << Arg->getSourceRange(); - + // Functions must have external linkage. if (FunctionDecl *Func = dyn_cast<FunctionDecl>(DRE->getDecl())) { if (Func->getStorageClass() == FunctionDecl::Static) { - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_function_not_extern) << Func << Arg->getSourceRange(); Diag(Func->getLocation(), diag::note_template_arg_internal_object) @@ -1699,7 +1698,7 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { if (!Var->hasGlobalStorage()) { - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_object_not_extern) << Var << Arg->getSourceRange(); Diag(Var->getLocation(), diag::note_template_arg_internal_object) @@ -1711,19 +1710,19 @@ bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, Entity = Var; return Invalid; } - + // We found something else, but we don't know specifically what it is. - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_object_or_func) << Arg->getSourceRange(); - Diag(DRE->getDecl()->getLocation(), + Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here); return true; } /// \brief Checks whether the given template argument is a pointer to /// member constant according to C++ [temp.arg.nontype]p1. -bool +bool Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { bool Invalid = false; @@ -1736,7 +1735,7 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { return false; // C++ [temp.arg.nontype]p1: - // + // // A template-argument for a non-type, non-template // template-parameter shall be one of: [...] // @@ -1746,7 +1745,7 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { // Ignore (and complain about) any excess parentheses. while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { if (!Invalid) { - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_extra_parens) << Arg->getSourceRange(); Invalid = true; @@ -1776,10 +1775,10 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { } // We found something else, but we don't know specifically what it is. - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_pointer_to_member_form) << Arg->getSourceRange(); - Diag(DRE->getDecl()->getLocation(), + Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here); return true; } @@ -1794,7 +1793,7 @@ Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { /// /// If no error was detected, Converted receives the converted template argument. bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, - QualType InstantiatedParamType, Expr *&Arg, + QualType InstantiatedParamType, Expr *&Arg, TemplateArgument &Converted) { SourceLocation StartLoc = Arg->getSourceRange().getBegin(); @@ -1830,7 +1829,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, SourceLocation NonConstantLoc; llvm::APSInt Value; if (!ArgType->isIntegralType() && !ArgType->isEnumeralType()) { - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_integral_or_enumeral) << ArgType << Arg->getSourceRange(); Diag(Param->getLocation(), diag::note_template_param_here); @@ -1859,7 +1858,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, ImpCastExprToType(Arg, ParamType); } else { // We can't perform this conversion. - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_convertible) << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); Diag(Param->getLocation(), diag::note_template_param_here); @@ -1885,7 +1884,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, // Check that we don't overflow the template parameter type. unsigned AllowedBits = Context.getTypeSize(IntegerType); if (Value.getActiveBits() > AllowedBits) { - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_too_large) << Value.toString(10) << Param->getType() << Arg->getSourceRange(); @@ -1909,7 +1908,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, } Converted = TemplateArgument(StartLoc, Value, - ParamType->isEnumeralType() ? ParamType + ParamType->isEnumeralType() ? ParamType : IntegerType); return false; } @@ -1939,7 +1938,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, (ParamType->isMemberPointerType() && ParamType->getAs<MemberPointerType>()->getPointeeType() ->isFunctionType())) { - if (Context.hasSameUnqualifiedType(ArgType, + if (Context.hasSameUnqualifiedType(ArgType, ParamType.getNonReferenceType())) { // We don't have to do anything: the types already match. } else if (ArgType->isNullPtrType() && (ParamType->isPointerType() || @@ -1949,7 +1948,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, } else if (ArgType->isFunctionType() && ParamType->isPointerType()) { ArgType = Context.getPointerType(ArgType); ImpCastExprToType(Arg, ArgType); - } else if (FunctionDecl *Fn + } else if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType, true)) { if (DiagnoseUseOfDecl(Fn, Arg->getSourceRange().getBegin())) return true; @@ -1962,16 +1961,16 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, } } - if (!Context.hasSameUnqualifiedType(ArgType, + if (!Context.hasSameUnqualifiedType(ArgType, ParamType.getNonReferenceType())) { // We can't perform this conversion. - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_convertible) << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); Diag(Param->getLocation(), diag::note_template_param_here); return true; } - + if (ParamType->isMemberPointerType()) { NamedDecl *Member = 0; if (CheckTemplateArgumentPointerToMember(Arg, Member)) @@ -1982,7 +1981,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, Converted = TemplateArgument(StartLoc, Member); return false; } - + NamedDecl *Entity = 0; if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) return true; @@ -2013,16 +2012,16 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, ArgType = ParamType; ImpCastExprToType(Arg, ParamType); } - + if (!Context.hasSameUnqualifiedType(ArgType, ParamType)) { // We can't perform this conversion. - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_convertible) << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); Diag(Param->getLocation(), diag::note_template_param_here); return true; } - + NamedDecl *Entity = 0; if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) return true; @@ -2032,7 +2031,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, Converted = TemplateArgument(StartLoc, Entity); return false; } - + if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) { // -- For a non-type template-parameter of type reference to // object, no conversions apply. The type referred to by the @@ -2044,7 +2043,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, "Only object references allowed here"); if (!Context.hasSameUnqualifiedType(ParamRefType->getPointeeType(), ArgType)) { - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_no_ref_bind) << InstantiatedParamType << Arg->getType() << Arg->getSourceRange(); @@ -2052,10 +2051,10 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, return true; } - unsigned ParamQuals + unsigned ParamQuals = Context.getCanonicalType(ParamType).getCVRQualifiers(); unsigned ArgQuals = Context.getCanonicalType(ArgType).getCVRQualifiers(); - + if ((ParamQuals | ArgQuals) != ParamQuals) { Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_ref_bind_ignores_quals) @@ -2064,7 +2063,7 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, Diag(Param->getLocation(), diag::note_template_param_here); return true; } - + NamedDecl *Entity = 0; if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) return true; @@ -2087,17 +2086,17 @@ bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, ImpCastExprToType(Arg, ParamType); } else { // We can't perform this conversion. - Diag(Arg->getSourceRange().getBegin(), + Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_not_convertible) << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); Diag(Param->getLocation(), diag::note_template_param_here); - return true; + return true; } NamedDecl *Member = 0; if (CheckTemplateArgumentPointerToMember(Arg, Member)) return true; - + if (Member) Member = cast<NamedDecl>(Member->getCanonicalDecl()); Converted = TemplateArgument(StartLoc, Member); @@ -2125,9 +2124,9 @@ bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param, // Note that we also allow template template parameters here, which // will happen when we are dealing with, e.g., class template // partial specializations. - if (!isa<ClassTemplateDecl>(Template) && + if (!isa<ClassTemplateDecl>(Template) && !isa<TemplateTemplateParmDecl>(Template)) { - assert(isa<FunctionTemplateDecl>(Template) && + assert(isa<FunctionTemplateDecl>(Template) && "Only function templates are possible here"); Diag(Arg->getLocStart(), diag::err_template_arg_not_class_template); Diag(Template->getLocation(), diag::note_template_arg_refers_here_func) @@ -2143,7 +2142,7 @@ bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param, /// \brief Determine whether the given template parameter lists are /// equivalent. /// -/// \param New The new template parameter list, typically written in the +/// \param New The new template parameter list, typically written in the /// source code as part of a new template declaration. /// /// \param Old The old template parameter list, typically found via @@ -2165,7 +2164,7 @@ bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param, /// /// \returns True if the template parameter lists are equal, false /// otherwise. -bool +bool Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, TemplateParameterList *Old, bool Complain, @@ -2177,7 +2176,7 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, if (TemplateArgLoc.isValid()) { Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); NextDiag = diag::note_template_param_list_different_arity; - } + } Diag(New->getTemplateLoc(), NextDiag) << (New->size() > Old->size()) << IsTemplateTemplateParm @@ -2218,15 +2217,15 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, // types within the template parameter list of the template template // parameter can be checked, and (2) the template type parameter depths // will match up. - QualType OldParmType + QualType OldParmType = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*OldParm)); - QualType NewParmType + QualType NewParmType = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*NewParm)); - assert(Context.getCanonicalType(OldParmType) == - Context.getCanonicalType(NewParmType) && + assert(Context.getCanonicalType(OldParmType) == + Context.getCanonicalType(NewParmType) && "type parameter mismatch?"); #endif - } else if (NonTypeTemplateParmDecl *OldNTTP + } else if (NonTypeTemplateParmDecl *OldNTTP = dyn_cast<NonTypeTemplateParmDecl>(*OldParm)) { // The types of non-type template parameters must agree. NonTypeTemplateParmDecl *NewNTTP @@ -2236,14 +2235,14 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, if (Complain) { unsigned NextDiag = diag::err_template_nontype_parm_different_type; if (TemplateArgLoc.isValid()) { - Diag(TemplateArgLoc, + Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); NextDiag = diag::note_template_nontype_parm_different_type; } Diag(NewNTTP->getLocation(), NextDiag) << NewNTTP->getType() << IsTemplateTemplateParm; - Diag(OldNTTP->getLocation(), + Diag(OldNTTP->getLocation(), diag::note_template_nontype_parm_prev_declaration) << OldNTTP->getType(); } @@ -2253,9 +2252,9 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, // The template parameter lists of template template // parameters must agree. // FIXME: Could we perform a faster "type" comparison here? - assert(isa<TemplateTemplateParmDecl>(*OldParm) && + assert(isa<TemplateTemplateParmDecl>(*OldParm) && "Only template template parameters handled here"); - TemplateTemplateParmDecl *OldTTP + TemplateTemplateParmDecl *OldTTP = cast<TemplateTemplateParmDecl>(*OldParm); TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(*NewParm); @@ -2275,29 +2274,29 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, /// /// If the template declaration is valid in this scope, returns /// false. Otherwise, issues a diagnostic and returns true. -bool +bool Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) { // Find the nearest enclosing declaration scope. while ((S->getFlags() & Scope::DeclScope) == 0 || (S->getFlags() & Scope::TemplateParamScope) != 0) S = S->getParent(); - + // C++ [temp]p2: // A template-declaration can appear only as a namespace scope or // class scope declaration. DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity()); if (Ctx && isa<LinkageSpecDecl>(Ctx) && cast<LinkageSpecDecl>(Ctx)->getLanguage() != LinkageSpecDecl::lang_cxx) - return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage) + return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage) << TemplateParams->getSourceRange(); - + while (Ctx && isa<LinkageSpecDecl>(Ctx)) Ctx = Ctx->getParent(); if (Ctx && (Ctx->isFileContext() || Ctx->isRecord())) return false; - return Diag(TemplateParams->getTemplateLoc(), + return Diag(TemplateParams->getTemplateLoc(), diag::err_template_outside_namespace_or_class_scope) << TemplateParams->getSourceRange(); } @@ -2306,11 +2305,11 @@ Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) { /// instantiation in the current context is well-formed. /// /// This routine determines whether a class template specialization or -/// explicit instantiation can be declared in the current context -/// (C++ [temp.expl.spec]p2, C++0x [temp.explicit]p2) and emits -/// appropriate diagnostics if there was an error. It returns true if +/// explicit instantiation can be declared in the current context +/// (C++ [temp.expl.spec]p2, C++0x [temp.explicit]p2) and emits +/// appropriate diagnostics if there was an error. It returns true if // there was an error that we cannot recover from, and false otherwise. -bool +bool Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate, ClassTemplateSpecializationDecl *PrevDecl, SourceLocation TemplateNameLoc, @@ -2338,7 +2337,7 @@ Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate, } DeclContext *DC = CurContext->getEnclosingNamespaceContext(); - DeclContext *TemplateContext + DeclContext *TemplateContext = ClassTemplate->getDeclContext()->getEnclosingNamespaceContext(); if ((!PrevDecl || PrevDecl->getSpecializationKind() == TSK_Undeclared) && !ExplicitInstantiation) { @@ -2352,7 +2351,7 @@ Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate, << ClassTemplate << ScopeSpecifierRange; else if (isa<NamespaceDecl>(TemplateContext)) Diag(TemplateNameLoc, diag::err_template_spec_decl_out_of_scope) - << PartialSpecialization << ClassTemplate + << PartialSpecialization << ClassTemplate << cast<NamedDecl>(TemplateContext) << ScopeSpecifierRange; Diag(ClassTemplate->getLocation(), diag::note_template_decl_here); @@ -2379,10 +2378,10 @@ Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate, Diag(TemplateNameLoc, diag::err_template_spec_redecl_out_of_scope) << Kind << ClassTemplate << cast<NamedDecl>(TemplateContext) << ScopeSpecifierRange; - else + else SuppressedDiag = true; } - + if (!SuppressedDiag) Diag(ClassTemplate->getLocation(), diag::note_template_decl_here); } @@ -2413,16 +2412,16 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs( // FIXME: the interface to this function will have to change to // accommodate variadic templates. MirrorsPrimaryTemplate = true; - + const TemplateArgument *ArgList = TemplateArgs.getFlatArguments(); - + for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { // Determine whether the template argument list of the partial // specialization is identical to the implicit argument list of // the primary template. The caller may need to diagnostic this as // an error per C++ [temp.class.spec]p9b3. if (MirrorsPrimaryTemplate) { - if (TemplateTypeParmDecl *TTP + if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(I))) { if (Context.getCanonicalType(Context.getTypeDeclType(TTP)) != Context.getCanonicalType(ArgList[I].getAsType())) @@ -2432,11 +2431,11 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs( TemplateParams->getParam(I))) { // FIXME: We should settle on either Declaration storage or // Expression storage for template template parameters. - TemplateTemplateParmDecl *ArgDecl + TemplateTemplateParmDecl *ArgDecl = dyn_cast_or_null<TemplateTemplateParmDecl>( ArgList[I].getAsDecl()); if (!ArgDecl) - if (DeclRefExpr *DRE + if (DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(ArgList[I].getAsExpr())) ArgDecl = dyn_cast<TemplateTemplateParmDecl>(DRE->getDecl()); @@ -2447,7 +2446,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs( } } - NonTypeTemplateParmDecl *Param + NonTypeTemplateParmDecl *Param = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I)); if (!Param) { continue; @@ -2468,9 +2467,9 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs( // specialized non-type arguments, so skip any non-specialized // arguments. if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr)) - if (NonTypeTemplateParmDecl *NTTP + if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl())) { - if (MirrorsPrimaryTemplate && + if (MirrorsPrimaryTemplate && (Param->getIndex() != NTTP->getIndex() || Param->getDepth() != NTTP->getDepth())) MirrorsPrimaryTemplate = false; @@ -2486,7 +2485,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs( // specialization except when the argument expression is a // simple identifier. if (ArgExpr->isTypeDependent() || ArgExpr->isValueDependent()) { - Diag(ArgExpr->getLocStart(), + Diag(ArgExpr->getLocStart(), diag::err_dependent_non_type_arg_in_partial_spec) << ArgExpr->getSourceRange(); return true; @@ -2496,7 +2495,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs( // specialized non-type argument shall not be dependent on a // parameter of the specialization. if (Param->getType()->isDependentType()) { - Diag(ArgExpr->getLocStart(), + Diag(ArgExpr->getLocStart(), diag::err_dependent_typed_non_type_arg_in_partial_spec) << Param->getType() << ArgExpr->getSourceRange(); @@ -2513,7 +2512,7 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs( Sema::DeclResult Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, - SourceLocation KWLoc, + SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, @@ -2527,7 +2526,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // Find the class template we're specializing TemplateName Name = TemplateD.getAsVal<TemplateName>(); - ClassTemplateDecl *ClassTemplate + ClassTemplateDecl *ClassTemplate = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); bool isPartialSpecialization = false; @@ -2535,8 +2534,8 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // Check the validity of the template headers that introduce this // template. TemplateParameterList *TemplateParams - = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc, SS, - (TemplateParameterList**)TemplateParameterLists.get(), + = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc, SS, + (TemplateParameterList**)TemplateParameterLists.get(), TemplateParameterLists.size()); if (TemplateParams && TemplateParams->size() > 0) { isPartialSpecialization = true; @@ -2548,14 +2547,14 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, Decl *Param = TemplateParams->getParam(I); if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) { if (TTP->hasDefaultArgument()) { - Diag(TTP->getDefaultArgumentLoc(), + Diag(TTP->getDefaultArgumentLoc(), diag::err_default_arg_in_partial_spec); TTP->setDefaultArgument(QualType(), SourceLocation(), false); } } else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) { if (Expr *DefArg = NTTP->getDefaultArgument()) { - Diag(NTTP->getDefaultArgumentLoc(), + Diag(NTTP->getDefaultArgumentLoc(), diag::err_default_arg_in_partial_spec) << DefArg->getSourceRange(); NTTP->setDefaultArgument(0); @@ -2564,7 +2563,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, } else { TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param); if (Expr *DefArg = TTP->getDefaultArgument()) { - Diag(TTP->getDefaultArgumentLoc(), + Diag(TTP->getDefaultArgumentLoc(), diag::err_default_arg_in_partial_spec) << DefArg->getSourceRange(); TTP->setDefaultArgument(0); @@ -2586,13 +2585,13 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; } if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), - Kind, KWLoc, + Kind, KWLoc, *ClassTemplate->getIdentifier())) { - Diag(KWLoc, diag::err_use_with_wrong_tag) + Diag(KWLoc, diag::err_use_with_wrong_tag) << ClassTemplate - << CodeModificationHint::CreateReplacement(KWLoc, + << CodeModificationHint::CreateReplacement(KWLoc, ClassTemplate->getTemplatedDecl()->getKindName()); - Diag(ClassTemplate->getTemplatedDecl()->getLocation(), + Diag(ClassTemplate->getTemplatedDecl()->getLocation(), diag::note_previous_use); Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); } @@ -2605,15 +2604,15 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // template. TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(), TemplateArgs.size()); - if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, + if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, TemplateArgs.data(), TemplateArgs.size(), RAngleLoc, false, Converted)) return true; - assert((Converted.structuredSize() == + assert((Converted.structuredSize() == ClassTemplate->getTemplateParameters()->size()) && "Converted template argument list is too short!"); - + // Find the class template (partial) specialization declaration that // corresponds to these arguments. llvm::FoldingSetNodeID ID; @@ -2627,11 +2626,11 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, if (MirrorsPrimaryTemplate) { // C++ [temp.class.spec]p9b3: // - // -- The argument list of the specialization shall not be identical - // to the implicit argument list of the primary template. + // -- The argument list of the specialization shall not be identical + // to the implicit argument list of the primary template. Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template) << (TUK == TUK_Definition) - << CodeModificationHint::CreateRemoval(SourceRange(LAngleLoc, + << CodeModificationHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc)); return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS, ClassTemplate->getIdentifier(), @@ -2642,7 +2641,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, } // FIXME: Template parameter list matters, too - ClassTemplatePartialSpecializationDecl::Profile(ID, + ClassTemplatePartialSpecializationDecl::Profile(ID, Converted.getFlatArguments(), Converted.flatSize(), Context); @@ -2656,7 +2655,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, if (isPartialSpecialization) PrevDecl - = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, + = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, InsertPos); else PrevDecl @@ -2667,7 +2666,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // Check whether we can declare a class template specialization in // the current scope. if (CheckClassTemplateSpecializationScope(ClassTemplate, PrevDecl, - TemplateNameLoc, + TemplateNameLoc, SS.getRange(), isPartialSpecialization, /*ExplicitInstantiation=*/false)) @@ -2693,12 +2692,12 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, Converted.flatSize()); // Create a new class template partial specialization declaration node. - TemplateParameterList *TemplateParams + TemplateParameterList *TemplateParams = static_cast<TemplateParameterList*>(*TemplateParameterLists.get()); ClassTemplatePartialSpecializationDecl *PrevPartial = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl); - ClassTemplatePartialSpecializationDecl *Partial - = ClassTemplatePartialSpecializationDecl::Create(Context, + ClassTemplatePartialSpecializationDecl *Partial + = ClassTemplatePartialSpecializationDecl::Create(Context, ClassTemplate->getDeclContext(), TemplateNameLoc, TemplateParams, @@ -2734,11 +2733,11 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, if (!DeducibleParams[I]) { NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I)); if (Param->getDeclName()) - Diag(Param->getLocation(), + Diag(Param->getLocation(), diag::note_partial_spec_unused_parameter) << Param->getDeclName(); else - Diag(Param->getLocation(), + Diag(Param->getLocation(), diag::note_partial_spec_unused_parameter) << std::string("<anonymous>"); } @@ -2748,10 +2747,10 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // Create a new class template specialization declaration node for // this explicit specialization. Specialization - = ClassTemplateSpecializationDecl::Create(Context, + = ClassTemplateSpecializationDecl::Create(Context, ClassTemplate->getDeclContext(), TemplateNameLoc, - ClassTemplate, + ClassTemplate, Converted, PrevDecl); @@ -2759,7 +2758,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, ClassTemplate->getSpecializations().RemoveNode(PrevDecl); ClassTemplate->getSpecializations().GetOrInsertNode(Specialization); } else { - ClassTemplate->getSpecializations().InsertNode(Specialization, + ClassTemplate->getSpecializations().InsertNode(Specialization, InsertPos); } @@ -2775,7 +2774,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // FIXME: Should also handle explicit specialization after implicit // instantiation with a special diagnostic. SourceRange Range(TemplateNameLoc, RAngleLoc); - Diag(TemplateNameLoc, diag::err_redefinition) + Diag(TemplateNameLoc, diag::err_redefinition) << Context.getTypeDeclType(Specialization) << Range; Diag(Def->getLocation(), diag::note_previous_definition); Specialization->setInvalidDecl(); @@ -2790,8 +2789,8 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // actually wrote the specialization, rather than formatting the // name based on the "canonical" representation used to store the // template arguments in the specialization. - QualType WrittenTy - = Context.getTemplateSpecializationType(Name, + QualType WrittenTy + = Context.getTemplateSpecializationType(Name, TemplateArgs.data(), TemplateArgs.size(), CanonType); @@ -2807,7 +2806,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, // but we also maintain the lexical context where the actual // definition occurs. Specialization->setLexicalDeclContext(CurContext); - + // We may be starting the definition of this specialization. if (TUK == TUK_Definition) Specialization->startDefinition(); @@ -2819,34 +2818,34 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, return DeclPtrTy::make(Specialization); } -Sema::DeclPtrTy -Sema::ActOnTemplateDeclarator(Scope *S, +Sema::DeclPtrTy +Sema::ActOnTemplateDeclarator(Scope *S, MultiTemplateParamsArg TemplateParameterLists, Declarator &D) { return HandleDeclarator(S, D, move(TemplateParameterLists), false); } -Sema::DeclPtrTy -Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope, +Sema::DeclPtrTy +Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope, MultiTemplateParamsArg TemplateParameterLists, Declarator &D) { assert(getCurFunctionDecl() == 0 && "Function parsing confused"); assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function && "Not a function declarator!"); DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; - + if (FTI.hasPrototype) { - // FIXME: Diagnose arguments without names in C. + // FIXME: Diagnose arguments without names in C. } - + Scope *ParentScope = FnBodyScope->getParent(); - - DeclPtrTy DP = HandleDeclarator(ParentScope, D, + + DeclPtrTy DP = HandleDeclarator(ParentScope, D, move(TemplateParameterLists), /*IsFunctionDefinition=*/true); - if (FunctionTemplateDecl *FunctionTemplate + if (FunctionTemplateDecl *FunctionTemplate = dyn_cast_or_null<FunctionTemplateDecl>(DP.getAs<Decl>())) - return ActOnStartOfFunctionDef(FnBodyScope, + return ActOnStartOfFunctionDef(FnBodyScope, DeclPtrTy::make(FunctionTemplate->getTemplatedDecl())); if (FunctionDecl *Function = dyn_cast_or_null<FunctionDecl>(DP.getAs<Decl>())) return ActOnStartOfFunctionDef(FnBodyScope, DeclPtrTy::make(Function)); @@ -2856,10 +2855,10 @@ Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope, // Explicit instantiation of a class template specialization // FIXME: Implement extern template semantics Sema::DeclResult -Sema::ActOnExplicitInstantiation(Scope *S, +Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, - unsigned TagSpec, + unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, @@ -2871,7 +2870,7 @@ Sema::ActOnExplicitInstantiation(Scope *S, AttributeList *Attr) { // Find the class template we're specializing TemplateName Name = TemplateD.getAsVal<TemplateName>(); - ClassTemplateDecl *ClassTemplate + ClassTemplateDecl *ClassTemplate = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); // Check that the specialization uses the same tag kind as the @@ -2884,13 +2883,13 @@ Sema::ActOnExplicitInstantiation(Scope *S, case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; } if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), - Kind, KWLoc, + Kind, KWLoc, *ClassTemplate->getIdentifier())) { - Diag(KWLoc, diag::err_use_with_wrong_tag) + Diag(KWLoc, diag::err_use_with_wrong_tag) << ClassTemplate - << CodeModificationHint::CreateReplacement(KWLoc, + << CodeModificationHint::CreateReplacement(KWLoc, ClassTemplate->getTemplatedDecl()->getKindName()); - Diag(ClassTemplate->getTemplatedDecl()->getLocation(), + Diag(ClassTemplate->getTemplatedDecl()->getLocation(), diag::note_previous_use); Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); } @@ -2901,7 +2900,7 @@ Sema::ActOnExplicitInstantiation(Scope *S, // // This is C++ DR 275. if (CheckClassTemplateSpecializationScope(ClassTemplate, 0, - TemplateNameLoc, + TemplateNameLoc, SS.getRange(), /*PartialSpecialization=*/false, /*ExplicitInstantiation=*/true)) @@ -2915,19 +2914,19 @@ Sema::ActOnExplicitInstantiation(Scope *S, // template. TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(), TemplateArgs.size()); - if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, + if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, TemplateArgs.data(), TemplateArgs.size(), RAngleLoc, false, Converted)) return true; - assert((Converted.structuredSize() == + assert((Converted.structuredSize() == ClassTemplate->getTemplateParameters()->size()) && "Converted template argument list is too short!"); - + // Find the class template specialization declaration that // corresponds to these arguments. llvm::FoldingSetNodeID ID; - ClassTemplateSpecializationDecl::Profile(ID, + ClassTemplateSpecializationDecl::Profile(ID, Converted.getFlatArguments(), Converted.flatSize(), Context); @@ -2939,13 +2938,13 @@ Sema::ActOnExplicitInstantiation(Scope *S, bool SpecializationRequiresInstantiation = true; if (PrevDecl) { - if (PrevDecl->getSpecializationKind() + if (PrevDecl->getSpecializationKind() == TSK_ExplicitInstantiationDefinition) { // This particular specialization has already been declared or // instantiated. We cannot explicitly instantiate it. Diag(TemplateNameLoc, diag::err_explicit_instantiation_duplicate) << Context.getTypeDeclType(PrevDecl); - Diag(PrevDecl->getLocation(), + Diag(PrevDecl->getLocation(), diag::note_previous_explicit_instantiation); return DeclPtrTy::make(PrevDecl); } @@ -2957,10 +2956,10 @@ Sema::ActOnExplicitInstantiation(Scope *S, // an explicit specialization for that template, the explicit // instantiation has no effect. if (!getLangOptions().CPlusPlus0x) { - Diag(TemplateNameLoc, + Diag(TemplateNameLoc, diag::ext_explicit_instantiation_after_specialization) << Context.getTypeDeclType(PrevDecl); - Diag(PrevDecl->getLocation(), + Diag(PrevDecl->getLocation(), diag::note_previous_template_specialization); } @@ -2970,7 +2969,7 @@ Sema::ActOnExplicitInstantiation(Scope *S, // accurate reproduction of the source code; we don't actually // use it for anything, since it is semantically irrelevant. Specialization - = ClassTemplateSpecializationDecl::Create(Context, + = ClassTemplateSpecializationDecl::Create(Context, ClassTemplate->getDeclContext(), TemplateNameLoc, ClassTemplate, @@ -2996,13 +2995,13 @@ Sema::ActOnExplicitInstantiation(Scope *S, // Create a new class template specialization declaration node for // this explicit specialization. Specialization - = ClassTemplateSpecializationDecl::Create(Context, + = ClassTemplateSpecializationDecl::Create(Context, ClassTemplate->getDeclContext(), TemplateNameLoc, ClassTemplate, Converted, 0); - ClassTemplate->getSpecializations().InsertNode(Specialization, + ClassTemplate->getSpecializations().InsertNode(Specialization, InsertPos); } @@ -3013,8 +3012,8 @@ Sema::ActOnExplicitInstantiation(Scope *S, // the explicit instantiation, rather than formatting the name based // on the "canonical" representation used to store the template // arguments in the specialization. - QualType WrittenTy - = Context.getTemplateSpecializationType(Name, + QualType WrittenTy + = Context.getTemplateSpecializationType(Name, TemplateArgs.data(), TemplateArgs.size(), Context.getTypeDeclType(Specialization)); @@ -3035,7 +3034,7 @@ Sema::ActOnExplicitInstantiation(Scope *S, // This check comes when we actually try to perform the // instantiation. TemplateSpecializationKind TSK - = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition + = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition : TSK_ExplicitInstantiationDeclaration; if (SpecializationRequiresInstantiation) InstantiateClassTemplateSpecialization(Specialization, TSK); @@ -3048,10 +3047,10 @@ Sema::ActOnExplicitInstantiation(Scope *S, // Explicit instantiation of a member class of a class template. Sema::DeclResult -Sema::ActOnExplicitInstantiation(Scope *S, +Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, - unsigned TagSpec, + unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, IdentifierInfo *Name, @@ -3092,7 +3091,7 @@ Sema::ActOnExplicitInstantiation(Scope *S, if (getLangOptions().CPlusPlus0x) { // FIXME: In C++98, we would like to turn these errors into warnings, // dependent on a -Wc++0x flag. - DeclContext *PatternContext + DeclContext *PatternContext = Pattern->getDeclContext()->getEnclosingNamespaceContext(); if (!CurContext->Encloses(PatternContext)) { Diag(TemplateLoc, diag::err_explicit_instantiation_out_of_scope) @@ -3102,19 +3101,19 @@ Sema::ActOnExplicitInstantiation(Scope *S, } TemplateSpecializationKind TSK - = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition + = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition : TSK_ExplicitInstantiationDeclaration; - + if (!Record->getDefinition(Context)) { // If the class has a definition, instantiate it (and all of its // members, recursively). Pattern = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context)); - if (Pattern && InstantiateClass(TemplateLoc, Record, Pattern, + if (Pattern && InstantiateClass(TemplateLoc, Record, Pattern, getTemplateInstantiationArgs(Record), TSK)) return true; } else // Instantiate all of the members of the class. - InstantiateClassMembers(TemplateLoc, Record, + InstantiateClassMembers(TemplateLoc, Record, getTemplateInstantiationArgs(Record), TSK); // FIXME: We don't have any representation for explicit instantiations of @@ -3127,7 +3126,7 @@ Sema::ActOnExplicitInstantiation(Scope *S, Sema::TypeResult Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc) { - NestedNameSpecifier *NNS + NestedNameSpecifier *NNS = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); if (!NNS) return true; @@ -3142,9 +3141,9 @@ Sema::TypeResult Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, SourceLocation TemplateLoc, TypeTy *Ty) { QualType T = GetTypeFromParser(Ty); - NestedNameSpecifier *NNS + NestedNameSpecifier *NNS = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); - const TemplateSpecializationType *TemplateId + const TemplateSpecializationType *TemplateId = T->getAsTemplateSpecializationType(); assert(TemplateId && "Expected a template specialization type"); @@ -3152,11 +3151,11 @@ Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, // If we can compute a declaration context, then the "typename" // keyword was superfluous. Just build a QualifiedNameType to keep // track of the nested-name-specifier. - + // FIXME: Note that the QualifiedNameType had the "typename" keyword! return Context.getQualifiedNameType(NNS, T).getAsOpaquePtr(); } - + return Context.getTypenameType(NNS, TemplateId).getAsOpaquePtr(); } @@ -3173,10 +3172,10 @@ Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II, // instantiation, then build a typename type. if (!CurrentInstantiation) return Context.getTypenameType(NNS, &II); - + // The nested-name-specifier refers to the current instantiation, so the // "typename" keyword itself is superfluous. In C++03, the program is - // actually ill-formed. However, DR 382 (in C++0x CD1) allows such + // actually ill-formed. However, DR 382 (in C++0x CD1) allows such // extraneous "typename" keywords, and we retroactively apply this DR to // C++03 code. } @@ -3197,7 +3196,7 @@ Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II, assert(Ctx && "No declaration context?"); DeclarationName Name(&II); - LookupResult Result = LookupQualifiedName(Ctx, Name, LookupOrdinaryName, + LookupResult Result = LookupQualifiedName(Ctx, Name, LookupOrdinaryName, false); unsigned DiagID = 0; Decl *Referenced = 0; @@ -3247,20 +3246,19 @@ Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II, namespace { // See Sema::RebuildTypeInCurrentInstantiation - class VISIBILITY_HIDDEN CurrentInstantiationRebuilder - : public TreeTransform<CurrentInstantiationRebuilder> - { + class VISIBILITY_HIDDEN CurrentInstantiationRebuilder + : public TreeTransform<CurrentInstantiationRebuilder> { SourceLocation Loc; DeclarationName Entity; - + public: - CurrentInstantiationRebuilder(Sema &SemaRef, + CurrentInstantiationRebuilder(Sema &SemaRef, SourceLocation Loc, - DeclarationName Entity) - : TreeTransform<CurrentInstantiationRebuilder>(SemaRef), + DeclarationName Entity) + : TreeTransform<CurrentInstantiationRebuilder>(SemaRef), Loc(Loc), Entity(Entity) { } - - /// \brief Determine whether the given type \p T has already been + + /// \brief Determine whether the given type \p T has already been /// transformed. /// /// For the purposes of type reconstruction, a type has already been @@ -3268,14 +3266,14 @@ namespace { bool AlreadyTransformed(QualType T) { return T.isNull() || !T->isDependentType(); } - - /// \brief Returns the location of the entity whose type is being + + /// \brief Returns the location of the entity whose type is being /// rebuilt. SourceLocation getBaseLocation() { return Loc; } - + /// \brief Returns the name of the entity whose type is being rebuilt. DeclarationName getBaseEntity() { return Entity; } - + /// \brief Transforms an expression by returning the expression itself /// (an identity function). /// @@ -3284,7 +3282,7 @@ namespace { Sema::OwningExprResult TransformExpr(Expr *E) { return getSema().Owned(E); } - + /// \brief Transforms a typename type by determining whether the type now /// refers to a member of the current instantiation, and then /// type-checking and building a QualifiedNameType (when possible). @@ -3292,7 +3290,7 @@ namespace { }; } -QualType +QualType CurrentInstantiationRebuilder::TransformTypenameType(const TypenameType *T) { NestedNameSpecifier *NNS = TransformNestedNameSpecifier(T->getQualifier(), @@ -3308,30 +3306,30 @@ CurrentInstantiationRebuilder::TransformTypenameType(const TypenameType *T) { SS.setScopeRep(NNS); if (NNS == T->getQualifier() && getSema().computeDeclContext(SS) == 0) return QualType(T, 0); - - // Rebuild the typename type, which will probably turn into a + + // Rebuild the typename type, which will probably turn into a // QualifiedNameType. if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { - QualType NewTemplateId + QualType NewTemplateId = TransformType(QualType(TemplateId, 0)); if (NewTemplateId.isNull()) return QualType(); - + if (NNS == T->getQualifier() && NewTemplateId == QualType(TemplateId, 0)) return QualType(T, 0); - + return getDerived().RebuildTypenameType(NNS, NewTemplateId); } - + return getDerived().RebuildTypenameType(NNS, T->getIdentifier()); } /// \brief Rebuilds a type within the context of the current instantiation. /// -/// The type \p T is part of the type of an out-of-line member definition of +/// The type \p T is part of the type of an out-of-line member definition of /// a class template (or class template partial specialization) that was parsed -/// and constructed before we entered the scope of the class template (or +/// and constructed before we entered the scope of the class template (or /// partial specialization thereof). This routine will rebuild that type now /// that we have entered the declarator's scope, which may produce different /// canonical types, e.g., @@ -3357,7 +3355,7 @@ QualType Sema::RebuildTypeInCurrentInstantiation(QualType T, SourceLocation Loc, DeclarationName Name) { if (T.isNull() || !T->isDependentType()) return T; - + CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name); return Rebuilder.TransformType(T); } |
