forked from OSchip/llvm-project
[NFC] Modernize enum 'UnqualifiedId::IdKind' into a scoped enum UnqualifiedIdKind.
llvm-svn: 321574
This commit is contained in:
parent
8e1abe4a7d
commit
2ab8c15cf1
|
@ -882,6 +882,30 @@ private:
|
|||
|
||||
};
|
||||
|
||||
/// \brief Describes the kind of unqualified-id parsed.
|
||||
enum class UnqualifiedIdKind {
|
||||
/// \brief An identifier.
|
||||
IK_Identifier,
|
||||
/// \brief An overloaded operator name, e.g., operator+.
|
||||
IK_OperatorFunctionId,
|
||||
/// \brief A conversion function name, e.g., operator int.
|
||||
IK_ConversionFunctionId,
|
||||
/// \brief A user-defined literal name, e.g., operator "" _i.
|
||||
IK_LiteralOperatorId,
|
||||
/// \brief A constructor name.
|
||||
IK_ConstructorName,
|
||||
/// \brief A constructor named via a template-id.
|
||||
IK_ConstructorTemplateId,
|
||||
/// \brief A destructor name.
|
||||
IK_DestructorName,
|
||||
/// \brief A template-id, e.g., f<int>.
|
||||
IK_TemplateId,
|
||||
/// \brief An implicit 'self' parameter
|
||||
IK_ImplicitSelfParam,
|
||||
/// \brief A deduction-guide name (a template-name)
|
||||
IK_DeductionGuideName
|
||||
};
|
||||
|
||||
/// \brief Represents a C++ unqualified-id that has been parsed.
|
||||
class UnqualifiedId {
|
||||
private:
|
||||
|
@ -890,28 +914,7 @@ private:
|
|||
|
||||
public:
|
||||
/// \brief Describes the kind of unqualified-id parsed.
|
||||
enum IdKind {
|
||||
/// \brief An identifier.
|
||||
IK_Identifier,
|
||||
/// \brief An overloaded operator name, e.g., operator+.
|
||||
IK_OperatorFunctionId,
|
||||
/// \brief A conversion function name, e.g., operator int.
|
||||
IK_ConversionFunctionId,
|
||||
/// \brief A user-defined literal name, e.g., operator "" _i.
|
||||
IK_LiteralOperatorId,
|
||||
/// \brief A constructor name.
|
||||
IK_ConstructorName,
|
||||
/// \brief A constructor named via a template-id.
|
||||
IK_ConstructorTemplateId,
|
||||
/// \brief A destructor name.
|
||||
IK_DestructorName,
|
||||
/// \brief A template-id, e.g., f<int>.
|
||||
IK_TemplateId,
|
||||
/// \brief An implicit 'self' parameter
|
||||
IK_ImplicitSelfParam,
|
||||
/// \brief A deduction-guide name (a template-name)
|
||||
IK_DeductionGuideName
|
||||
} Kind;
|
||||
UnqualifiedIdKind Kind;
|
||||
|
||||
struct OFI {
|
||||
/// \brief The kind of overloaded operator.
|
||||
|
@ -966,13 +969,14 @@ public:
|
|||
|
||||
/// \brief The location of the last token that describes this unqualified-id.
|
||||
SourceLocation EndLocation;
|
||||
|
||||
UnqualifiedId() : Kind(IK_Identifier), Identifier(nullptr) { }
|
||||
|
||||
UnqualifiedId()
|
||||
: Kind(UnqualifiedIdKind::IK_Identifier), Identifier(nullptr) {}
|
||||
|
||||
/// \brief Clear out this unqualified-id, setting it to default (invalid)
|
||||
/// state.
|
||||
void clear() {
|
||||
Kind = IK_Identifier;
|
||||
Kind = UnqualifiedIdKind::IK_Identifier;
|
||||
Identifier = nullptr;
|
||||
StartLocation = SourceLocation();
|
||||
EndLocation = SourceLocation();
|
||||
|
@ -985,15 +989,15 @@ public:
|
|||
bool isInvalid() const { return !isValid(); }
|
||||
|
||||
/// \brief Determine what kind of name we have.
|
||||
IdKind getKind() const { return Kind; }
|
||||
void setKind(IdKind kind) { Kind = kind; }
|
||||
UnqualifiedIdKind getKind() const { return Kind; }
|
||||
void setKind(UnqualifiedIdKind kind) { Kind = kind; }
|
||||
|
||||
/// \brief Specify that this unqualified-id was parsed as an identifier.
|
||||
///
|
||||
/// \param Id the parsed identifier.
|
||||
/// \param IdLoc the location of the parsed identifier.
|
||||
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) {
|
||||
Kind = IK_Identifier;
|
||||
Kind = UnqualifiedIdKind::IK_Identifier;
|
||||
Identifier = const_cast<IdentifierInfo *>(Id);
|
||||
StartLocation = EndLocation = IdLoc;
|
||||
}
|
||||
|
@ -1022,7 +1026,7 @@ public:
|
|||
void setConversionFunctionId(SourceLocation OperatorLoc,
|
||||
ParsedType Ty,
|
||||
SourceLocation EndLoc) {
|
||||
Kind = IK_ConversionFunctionId;
|
||||
Kind = UnqualifiedIdKind::IK_ConversionFunctionId;
|
||||
StartLocation = OperatorLoc;
|
||||
EndLocation = EndLoc;
|
||||
ConversionFunctionId = Ty;
|
||||
|
@ -1038,7 +1042,7 @@ public:
|
|||
/// \param IdLoc the location of the identifier.
|
||||
void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc,
|
||||
SourceLocation IdLoc) {
|
||||
Kind = IK_LiteralOperatorId;
|
||||
Kind = UnqualifiedIdKind::IK_LiteralOperatorId;
|
||||
Identifier = const_cast<IdentifierInfo *>(Id);
|
||||
StartLocation = OpLoc;
|
||||
EndLocation = IdLoc;
|
||||
|
@ -1054,7 +1058,7 @@ public:
|
|||
void setConstructorName(ParsedType ClassType,
|
||||
SourceLocation ClassNameLoc,
|
||||
SourceLocation EndLoc) {
|
||||
Kind = IK_ConstructorName;
|
||||
Kind = UnqualifiedIdKind::IK_ConstructorName;
|
||||
StartLocation = ClassNameLoc;
|
||||
EndLocation = EndLoc;
|
||||
ConstructorName = ClassType;
|
||||
|
@ -1077,7 +1081,7 @@ public:
|
|||
void setDestructorName(SourceLocation TildeLoc,
|
||||
ParsedType ClassType,
|
||||
SourceLocation EndLoc) {
|
||||
Kind = IK_DestructorName;
|
||||
Kind = UnqualifiedIdKind::IK_DestructorName;
|
||||
StartLocation = TildeLoc;
|
||||
EndLocation = EndLoc;
|
||||
DestructorName = ClassType;
|
||||
|
@ -1097,7 +1101,7 @@ public:
|
|||
/// \param TemplateLoc The location of the parsed template-name.
|
||||
void setDeductionGuideName(ParsedTemplateTy Template,
|
||||
SourceLocation TemplateLoc) {
|
||||
Kind = IK_DeductionGuideName;
|
||||
Kind = UnqualifiedIdKind::IK_DeductionGuideName;
|
||||
TemplateName = Template;
|
||||
StartLocation = EndLocation = TemplateLoc;
|
||||
}
|
||||
|
@ -2040,7 +2044,7 @@ public:
|
|||
return false;
|
||||
|
||||
// Special names can't have direct initializers.
|
||||
if (Name.getKind() != UnqualifiedId::IK_Identifier)
|
||||
if (Name.getKind() != UnqualifiedIdKind::IK_Identifier)
|
||||
return false;
|
||||
|
||||
switch (Context) {
|
||||
|
@ -2090,8 +2094,8 @@ public:
|
|||
/// special C++ name (constructor, destructor, etc.), or a structured
|
||||
/// binding (which is not exactly a name, but occupies the same position).
|
||||
bool hasName() const {
|
||||
return Name.getKind() != UnqualifiedId::IK_Identifier || Name.Identifier ||
|
||||
isDecompositionDeclarator();
|
||||
return Name.getKind() != UnqualifiedIdKind::IK_Identifier ||
|
||||
Name.Identifier || isDecompositionDeclarator();
|
||||
}
|
||||
|
||||
/// Return whether this declarator is a decomposition declarator.
|
||||
|
@ -2100,7 +2104,7 @@ public:
|
|||
}
|
||||
|
||||
IdentifierInfo *getIdentifier() const {
|
||||
if (Name.getKind() == UnqualifiedId::IK_Identifier)
|
||||
if (Name.getKind() == UnqualifiedIdKind::IK_Identifier)
|
||||
return Name.Identifier;
|
||||
|
||||
return nullptr;
|
||||
|
|
|
@ -2201,7 +2201,7 @@ Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
|
|||
// FIXME: This check should be for a variable template instantiation only.
|
||||
|
||||
// Check that this is a valid instantiation
|
||||
if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
|
||||
if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
|
||||
// If the declarator-id is not a template-id, issue a diagnostic and
|
||||
// recover by ignoring the 'template' keyword.
|
||||
Diag(Tok, diag::err_template_defn_explicit_instantiation)
|
||||
|
|
|
@ -701,7 +701,7 @@ Parser::ParseUsingDeclaration(DeclaratorContext Context,
|
|||
// "typename" keyword is allowed for identifiers only,
|
||||
// because it may be a type definition.
|
||||
if (D.TypenameLoc.isValid() &&
|
||||
D.Name.getKind() != UnqualifiedId::IK_Identifier) {
|
||||
D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {
|
||||
Diag(D.Name.getSourceRange().getBegin(),
|
||||
diag::err_typename_identifiers_only)
|
||||
<< FixItHint::CreateRemoval(SourceRange(D.TypenameLoc));
|
||||
|
@ -755,7 +755,7 @@ Decl *Parser::ParseAliasDeclarationAfterDeclarator(
|
|||
// Type alias templates cannot be specialized.
|
||||
int SpecKind = -1;
|
||||
if (TemplateInfo.Kind == ParsedTemplateInfo::Template &&
|
||||
D.Name.getKind() == UnqualifiedId::IK_TemplateId)
|
||||
D.Name.getKind() == UnqualifiedIdKind::IK_TemplateId)
|
||||
SpecKind = 0;
|
||||
if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization)
|
||||
SpecKind = 1;
|
||||
|
@ -775,7 +775,7 @@ Decl *Parser::ParseAliasDeclarationAfterDeclarator(
|
|||
}
|
||||
|
||||
// Name must be an identifier.
|
||||
if (D.Name.getKind() != UnqualifiedId::IK_Identifier) {
|
||||
if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {
|
||||
Diag(D.Name.StartLocation, diag::err_alias_declaration_not_identifier);
|
||||
// No removal fixit: can't recover from this.
|
||||
SkipUntil(tok::semi);
|
||||
|
|
|
@ -292,8 +292,8 @@ bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
|
|||
break;
|
||||
}
|
||||
|
||||
if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId &&
|
||||
TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) {
|
||||
if (TemplateName.getKind() != UnqualifiedIdKind::IK_OperatorFunctionId &&
|
||||
TemplateName.getKind() != UnqualifiedIdKind::IK_LiteralOperatorId) {
|
||||
Diag(TemplateName.getSourceRange().getBegin(),
|
||||
diag::err_id_after_template_in_nested_name_spec)
|
||||
<< TemplateName.getSourceRange();
|
||||
|
@ -2034,9 +2034,9 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
|
|||
TemplateTy Template;
|
||||
TemplateNameKind TNK = TNK_Non_template;
|
||||
switch (Id.getKind()) {
|
||||
case UnqualifiedId::IK_Identifier:
|
||||
case UnqualifiedId::IK_OperatorFunctionId:
|
||||
case UnqualifiedId::IK_LiteralOperatorId:
|
||||
case UnqualifiedIdKind::IK_Identifier:
|
||||
case UnqualifiedIdKind::IK_OperatorFunctionId:
|
||||
case UnqualifiedIdKind::IK_LiteralOperatorId:
|
||||
if (AssumeTemplateId) {
|
||||
// We defer the injected-class-name checks until we've found whether
|
||||
// this template-id is used to form a nested-name-specifier or not.
|
||||
|
@ -2059,11 +2059,11 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
|
|||
// parse correctly as a template, so suggest the keyword 'template'
|
||||
// before 'getAs' and treat this as a dependent template name.
|
||||
std::string Name;
|
||||
if (Id.getKind() == UnqualifiedId::IK_Identifier)
|
||||
if (Id.getKind() == UnqualifiedIdKind::IK_Identifier)
|
||||
Name = Id.Identifier->getName();
|
||||
else {
|
||||
Name = "operator ";
|
||||
if (Id.getKind() == UnqualifiedId::IK_OperatorFunctionId)
|
||||
if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId)
|
||||
Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
|
||||
else
|
||||
Name += Id.Identifier->getName();
|
||||
|
@ -2080,7 +2080,7 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
|
|||
}
|
||||
break;
|
||||
|
||||
case UnqualifiedId::IK_ConstructorName: {
|
||||
case UnqualifiedIdKind::IK_ConstructorName: {
|
||||
UnqualifiedId TemplateName;
|
||||
bool MemberOfUnknownSpecialization;
|
||||
TemplateName.setIdentifier(Name, NameLoc);
|
||||
|
@ -2091,7 +2091,7 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
|
|||
break;
|
||||
}
|
||||
|
||||
case UnqualifiedId::IK_DestructorName: {
|
||||
case UnqualifiedIdKind::IK_DestructorName: {
|
||||
UnqualifiedId TemplateName;
|
||||
bool MemberOfUnknownSpecialization;
|
||||
TemplateName.setIdentifier(Name, NameLoc);
|
||||
|
@ -2130,18 +2130,20 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
|
|||
true, LAngleLoc, TemplateArgs, RAngleLoc))
|
||||
return true;
|
||||
|
||||
if (Id.getKind() == UnqualifiedId::IK_Identifier ||
|
||||
Id.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
|
||||
Id.getKind() == UnqualifiedId::IK_LiteralOperatorId) {
|
||||
if (Id.getKind() == UnqualifiedIdKind::IK_Identifier ||
|
||||
Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
|
||||
Id.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) {
|
||||
// Form a parsed representation of the template-id to be stored in the
|
||||
// UnqualifiedId.
|
||||
|
||||
// FIXME: Store name for literal operator too.
|
||||
IdentifierInfo *TemplateII =
|
||||
Id.getKind() == UnqualifiedId::IK_Identifier ? Id.Identifier : nullptr;
|
||||
OverloadedOperatorKind OpKind = Id.getKind() == UnqualifiedId::IK_Identifier
|
||||
? OO_None
|
||||
: Id.OperatorFunctionId.Operator;
|
||||
Id.getKind() == UnqualifiedIdKind::IK_Identifier ? Id.Identifier
|
||||
: nullptr;
|
||||
OverloadedOperatorKind OpKind =
|
||||
Id.getKind() == UnqualifiedIdKind::IK_Identifier
|
||||
? OO_None
|
||||
: Id.OperatorFunctionId.Operator;
|
||||
|
||||
TemplateIdAnnotation *TemplateId = TemplateIdAnnotation::Create(
|
||||
SS, TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
|
||||
|
@ -2163,7 +2165,7 @@ bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
|
|||
if (Type.isInvalid())
|
||||
return true;
|
||||
|
||||
if (Id.getKind() == UnqualifiedId::IK_ConstructorName)
|
||||
if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
|
||||
Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
|
||||
else
|
||||
Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
|
||||
|
@ -2557,8 +2559,8 @@ bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
|
|||
//
|
||||
// template-id:
|
||||
// operator-function-id < template-argument-list[opt] >
|
||||
if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
|
||||
Result.getKind() == UnqualifiedId::IK_LiteralOperatorId) &&
|
||||
if ((Result.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId ||
|
||||
Result.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId) &&
|
||||
(TemplateSpecified || Tok.is(tok::less)))
|
||||
return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
|
||||
nullptr, SourceLocation(),
|
||||
|
|
|
@ -271,7 +271,8 @@ Parser::ParseSingleDeclarationAfterTemplate(
|
|||
}
|
||||
|
||||
if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
|
||||
if (DeclaratorInfo.getName().getKind() != UnqualifiedId::IK_TemplateId) {
|
||||
if (DeclaratorInfo.getName().getKind() !=
|
||||
UnqualifiedIdKind::IK_TemplateId) {
|
||||
// If the declarator-id is not a template-id, issue a diagnostic and
|
||||
// recover by ignoring the 'template' keyword.
|
||||
Diag(Tok, diag::err_template_defn_explicit_instantiation) << 0;
|
||||
|
@ -1015,12 +1016,12 @@ bool Parser::AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
|
|||
Tok.setKind(tok::annot_template_id);
|
||||
|
||||
IdentifierInfo *TemplateII =
|
||||
TemplateName.getKind() == UnqualifiedId::IK_Identifier
|
||||
TemplateName.getKind() == UnqualifiedIdKind::IK_Identifier
|
||||
? TemplateName.Identifier
|
||||
: nullptr;
|
||||
|
||||
OverloadedOperatorKind OpKind =
|
||||
TemplateName.getKind() == UnqualifiedId::IK_Identifier
|
||||
TemplateName.getKind() == UnqualifiedIdKind::IK_Identifier
|
||||
? OO_None
|
||||
: TemplateName.OperatorFunctionId.Operator;
|
||||
|
||||
|
|
|
@ -30,7 +30,7 @@ using namespace clang;
|
|||
|
||||
void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
|
||||
assert(TemplateId && "NULL template-id annotation?");
|
||||
Kind = IK_TemplateId;
|
||||
Kind = UnqualifiedIdKind::IK_TemplateId;
|
||||
this->TemplateId = TemplateId;
|
||||
StartLocation = TemplateId->TemplateNameLoc;
|
||||
EndLocation = TemplateId->RAngleLoc;
|
||||
|
@ -38,7 +38,7 @@ void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
|
|||
|
||||
void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
|
||||
assert(TemplateId && "NULL template-id annotation?");
|
||||
Kind = IK_ConstructorTemplateId;
|
||||
Kind = UnqualifiedIdKind::IK_ConstructorTemplateId;
|
||||
this->TemplateId = TemplateId;
|
||||
StartLocation = TemplateId->TemplateNameLoc;
|
||||
EndLocation = TemplateId->RAngleLoc;
|
||||
|
@ -389,14 +389,14 @@ bool Declarator::isDeclarationOfFunction() const {
|
|||
bool Declarator::isStaticMember() {
|
||||
assert(getContext() == DeclaratorContext::MemberContext);
|
||||
return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
|
||||
(getName().Kind == UnqualifiedId::IK_OperatorFunctionId &&
|
||||
(getName().Kind == UnqualifiedIdKind::IK_OperatorFunctionId &&
|
||||
CXXMethodDecl::isStaticOverloadedOperator(
|
||||
getName().OperatorFunctionId.Operator));
|
||||
}
|
||||
|
||||
bool Declarator::isCtorOrDtor() {
|
||||
return (getName().getKind() == UnqualifiedId::IK_ConstructorName) ||
|
||||
(getName().getKind() == UnqualifiedId::IK_DestructorName);
|
||||
return (getName().getKind() == UnqualifiedIdKind::IK_ConstructorName) ||
|
||||
(getName().getKind() == UnqualifiedIdKind::IK_DestructorName);
|
||||
}
|
||||
|
||||
bool DeclSpec::hasTagDefinition() const {
|
||||
|
@ -1281,7 +1281,7 @@ bool DeclSpec::isMissingDeclaratorOk() {
|
|||
void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
|
||||
OverloadedOperatorKind Op,
|
||||
SourceLocation SymbolLocations[3]) {
|
||||
Kind = IK_OperatorFunctionId;
|
||||
Kind = UnqualifiedIdKind::IK_OperatorFunctionId;
|
||||
StartLocation = OperatorLoc;
|
||||
EndLocation = OperatorLoc;
|
||||
OperatorFunctionId.Operator = Op;
|
||||
|
|
|
@ -4897,13 +4897,13 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
|
|||
|
||||
switch (Name.getKind()) {
|
||||
|
||||
case UnqualifiedId::IK_ImplicitSelfParam:
|
||||
case UnqualifiedId::IK_Identifier:
|
||||
case UnqualifiedIdKind::IK_ImplicitSelfParam:
|
||||
case UnqualifiedIdKind::IK_Identifier:
|
||||
NameInfo.setName(Name.Identifier);
|
||||
NameInfo.setLoc(Name.StartLocation);
|
||||
return NameInfo;
|
||||
|
||||
case UnqualifiedId::IK_DeductionGuideName: {
|
||||
case UnqualifiedIdKind::IK_DeductionGuideName: {
|
||||
// C++ [temp.deduct.guide]p3:
|
||||
// The simple-template-id shall name a class template specialization.
|
||||
// The template-name shall be the same identifier as the template-name
|
||||
|
@ -4931,7 +4931,7 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
|
|||
return NameInfo;
|
||||
}
|
||||
|
||||
case UnqualifiedId::IK_OperatorFunctionId:
|
||||
case UnqualifiedIdKind::IK_OperatorFunctionId:
|
||||
NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
|
||||
Name.OperatorFunctionId.Operator));
|
||||
NameInfo.setLoc(Name.StartLocation);
|
||||
|
@ -4941,14 +4941,14 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
|
|||
= Name.EndLocation.getRawEncoding();
|
||||
return NameInfo;
|
||||
|
||||
case UnqualifiedId::IK_LiteralOperatorId:
|
||||
case UnqualifiedIdKind::IK_LiteralOperatorId:
|
||||
NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
|
||||
Name.Identifier));
|
||||
NameInfo.setLoc(Name.StartLocation);
|
||||
NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
|
||||
return NameInfo;
|
||||
|
||||
case UnqualifiedId::IK_ConversionFunctionId: {
|
||||
case UnqualifiedIdKind::IK_ConversionFunctionId: {
|
||||
TypeSourceInfo *TInfo;
|
||||
QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
|
||||
if (Ty.isNull())
|
||||
|
@ -4960,7 +4960,7 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
|
|||
return NameInfo;
|
||||
}
|
||||
|
||||
case UnqualifiedId::IK_ConstructorName: {
|
||||
case UnqualifiedIdKind::IK_ConstructorName: {
|
||||
TypeSourceInfo *TInfo;
|
||||
QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
|
||||
if (Ty.isNull())
|
||||
|
@ -4972,7 +4972,7 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
|
|||
return NameInfo;
|
||||
}
|
||||
|
||||
case UnqualifiedId::IK_ConstructorTemplateId: {
|
||||
case UnqualifiedIdKind::IK_ConstructorTemplateId: {
|
||||
// In well-formed code, we can only have a constructor
|
||||
// template-id that refers to the current context, so go there
|
||||
// to find the actual type being constructed.
|
||||
|
@ -4995,7 +4995,7 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
|
|||
return NameInfo;
|
||||
}
|
||||
|
||||
case UnqualifiedId::IK_DestructorName: {
|
||||
case UnqualifiedIdKind::IK_DestructorName: {
|
||||
TypeSourceInfo *TInfo;
|
||||
QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
|
||||
if (Ty.isNull())
|
||||
|
@ -5007,7 +5007,7 @@ Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
|
|||
return NameInfo;
|
||||
}
|
||||
|
||||
case UnqualifiedId::IK_TemplateId: {
|
||||
case UnqualifiedIdKind::IK_TemplateId: {
|
||||
TemplateName TName = Name.TemplateId->Template.get();
|
||||
SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
|
||||
return Context.getNameForTemplate(TName, TNameLoc);
|
||||
|
@ -5670,8 +5670,8 @@ Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
|
|||
Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
|
||||
<< 1;
|
||||
|
||||
if (D.getName().Kind != UnqualifiedId::IK_Identifier) {
|
||||
if (D.getName().Kind == UnqualifiedId::IK_DeductionGuideName)
|
||||
if (D.getName().Kind != UnqualifiedIdKind::IK_Identifier) {
|
||||
if (D.getName().Kind == UnqualifiedIdKind::IK_DeductionGuideName)
|
||||
Diag(D.getName().StartLocation,
|
||||
diag::err_deduction_guide_invalid_specifier)
|
||||
<< "typedef";
|
||||
|
@ -6425,7 +6425,7 @@ NamedDecl *Sema::ActOnVariableDeclarator(
|
|||
TemplateParams = MatchTemplateParametersToScopeSpecifier(
|
||||
D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
|
||||
D.getCXXScopeSpec(),
|
||||
D.getName().getKind() == UnqualifiedId::IK_TemplateId
|
||||
D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
|
||||
? D.getName().TemplateId
|
||||
: nullptr,
|
||||
TemplateParamLists,
|
||||
|
@ -6433,7 +6433,7 @@ NamedDecl *Sema::ActOnVariableDeclarator(
|
|||
|
||||
if (TemplateParams) {
|
||||
if (!TemplateParams->size() &&
|
||||
D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
|
||||
D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
|
||||
// There is an extraneous 'template<>' for this variable. Complain
|
||||
// about it, but allow the declaration of the variable.
|
||||
Diag(TemplateParams->getTemplateLoc(),
|
||||
|
@ -6443,7 +6443,7 @@ NamedDecl *Sema::ActOnVariableDeclarator(
|
|||
TemplateParams->getRAngleLoc());
|
||||
TemplateParams = nullptr;
|
||||
} else {
|
||||
if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
|
||||
if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
|
||||
// This is an explicit specialization or a partial specialization.
|
||||
// FIXME: Check that we can declare a specialization here.
|
||||
IsVariableTemplateSpecialization = true;
|
||||
|
@ -6464,9 +6464,9 @@ NamedDecl *Sema::ActOnVariableDeclarator(
|
|||
}
|
||||
}
|
||||
} else {
|
||||
assert(
|
||||
(Invalid || D.getName().getKind() != UnqualifiedId::IK_TemplateId) &&
|
||||
"should have a 'template<>' for this decl");
|
||||
assert((Invalid ||
|
||||
D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) &&
|
||||
"should have a 'template<>' for this decl");
|
||||
}
|
||||
|
||||
if (IsVariableTemplateSpecialization) {
|
||||
|
@ -8261,7 +8261,7 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
MatchTemplateParametersToScopeSpecifier(
|
||||
D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
|
||||
D.getCXXScopeSpec(),
|
||||
D.getName().getKind() == UnqualifiedId::IK_TemplateId
|
||||
D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
|
||||
? D.getName().TemplateId
|
||||
: nullptr,
|
||||
TemplateParamLists, isFriend, isMemberSpecialization,
|
||||
|
@ -8318,7 +8318,7 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
// and clearly the user wants a template specialization. So
|
||||
// we need to insert '<>' after the name.
|
||||
SourceLocation InsertLoc;
|
||||
if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
|
||||
if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
|
||||
InsertLoc = D.getName().getSourceRange().getEnd();
|
||||
InsertLoc = getLocForEndOfToken(InsertLoc);
|
||||
}
|
||||
|
@ -8719,7 +8719,7 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
|
||||
// If the declarator is a template-id, translate the parser's template
|
||||
// argument list into our AST format.
|
||||
if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
|
||||
if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
|
||||
TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
|
||||
TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
|
||||
TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
|
||||
|
|
|
@ -8986,15 +8986,15 @@ Decl *Sema::ActOnUsingDeclaration(Scope *S,
|
|||
}
|
||||
|
||||
switch (Name.getKind()) {
|
||||
case UnqualifiedId::IK_ImplicitSelfParam:
|
||||
case UnqualifiedId::IK_Identifier:
|
||||
case UnqualifiedId::IK_OperatorFunctionId:
|
||||
case UnqualifiedId::IK_LiteralOperatorId:
|
||||
case UnqualifiedId::IK_ConversionFunctionId:
|
||||
case UnqualifiedIdKind::IK_ImplicitSelfParam:
|
||||
case UnqualifiedIdKind::IK_Identifier:
|
||||
case UnqualifiedIdKind::IK_OperatorFunctionId:
|
||||
case UnqualifiedIdKind::IK_LiteralOperatorId:
|
||||
case UnqualifiedIdKind::IK_ConversionFunctionId:
|
||||
break;
|
||||
|
||||
case UnqualifiedId::IK_ConstructorName:
|
||||
case UnqualifiedId::IK_ConstructorTemplateId:
|
||||
case UnqualifiedIdKind::IK_ConstructorName:
|
||||
case UnqualifiedIdKind::IK_ConstructorTemplateId:
|
||||
// C++11 inheriting constructors.
|
||||
Diag(Name.getLocStart(),
|
||||
getLangOpts().CPlusPlus11 ?
|
||||
|
@ -9006,17 +9006,17 @@ Decl *Sema::ActOnUsingDeclaration(Scope *S,
|
|||
|
||||
return nullptr;
|
||||
|
||||
case UnqualifiedId::IK_DestructorName:
|
||||
case UnqualifiedIdKind::IK_DestructorName:
|
||||
Diag(Name.getLocStart(), diag::err_using_decl_destructor)
|
||||
<< SS.getRange();
|
||||
return nullptr;
|
||||
|
||||
case UnqualifiedId::IK_TemplateId:
|
||||
case UnqualifiedIdKind::IK_TemplateId:
|
||||
Diag(Name.getLocStart(), diag::err_using_decl_template_id)
|
||||
<< SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
|
||||
return nullptr;
|
||||
|
||||
case UnqualifiedId::IK_DeductionGuideName:
|
||||
case UnqualifiedIdKind::IK_DeductionGuideName:
|
||||
llvm_unreachable("cannot parse qualified deduction guide name");
|
||||
}
|
||||
|
||||
|
@ -10040,7 +10040,7 @@ Decl *Sema::ActOnAliasDeclaration(Scope *S,
|
|||
Previous.clear();
|
||||
}
|
||||
|
||||
assert(Name.Kind == UnqualifiedId::IK_Identifier &&
|
||||
assert(Name.Kind == UnqualifiedIdKind::IK_Identifier &&
|
||||
"name in alias declaration must be an identifier");
|
||||
TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
|
||||
Name.StartLocation,
|
||||
|
@ -13799,7 +13799,8 @@ NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
|
|||
// elaborated-type-specifier, the lookup to determine whether
|
||||
// the entity has been previously declared shall not consider
|
||||
// any scopes outside the innermost enclosing namespace.
|
||||
bool isTemplateId = D.getName().getKind() == UnqualifiedId::IK_TemplateId;
|
||||
bool isTemplateId =
|
||||
D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId;
|
||||
|
||||
// Find the appropriate context according to the above.
|
||||
DC = CurContext;
|
||||
|
@ -13910,24 +13911,24 @@ NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
|
|||
if (!DC->isRecord()) {
|
||||
int DiagArg = -1;
|
||||
switch (D.getName().getKind()) {
|
||||
case UnqualifiedId::IK_ConstructorTemplateId:
|
||||
case UnqualifiedId::IK_ConstructorName:
|
||||
case UnqualifiedIdKind::IK_ConstructorTemplateId:
|
||||
case UnqualifiedIdKind::IK_ConstructorName:
|
||||
DiagArg = 0;
|
||||
break;
|
||||
case UnqualifiedId::IK_DestructorName:
|
||||
case UnqualifiedIdKind::IK_DestructorName:
|
||||
DiagArg = 1;
|
||||
break;
|
||||
case UnqualifiedId::IK_ConversionFunctionId:
|
||||
case UnqualifiedIdKind::IK_ConversionFunctionId:
|
||||
DiagArg = 2;
|
||||
break;
|
||||
case UnqualifiedId::IK_DeductionGuideName:
|
||||
case UnqualifiedIdKind::IK_DeductionGuideName:
|
||||
DiagArg = 3;
|
||||
break;
|
||||
case UnqualifiedId::IK_Identifier:
|
||||
case UnqualifiedId::IK_ImplicitSelfParam:
|
||||
case UnqualifiedId::IK_LiteralOperatorId:
|
||||
case UnqualifiedId::IK_OperatorFunctionId:
|
||||
case UnqualifiedId::IK_TemplateId:
|
||||
case UnqualifiedIdKind::IK_Identifier:
|
||||
case UnqualifiedIdKind::IK_ImplicitSelfParam:
|
||||
case UnqualifiedIdKind::IK_LiteralOperatorId:
|
||||
case UnqualifiedIdKind::IK_OperatorFunctionId:
|
||||
case UnqualifiedIdKind::IK_TemplateId:
|
||||
break;
|
||||
}
|
||||
// This implies that it has to be an operator or function.
|
||||
|
|
|
@ -1711,7 +1711,7 @@ Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id,
|
|||
TemplateArgumentListInfo &Buffer,
|
||||
DeclarationNameInfo &NameInfo,
|
||||
const TemplateArgumentListInfo *&TemplateArgs) {
|
||||
if (Id.getKind() == UnqualifiedId::IK_TemplateId) {
|
||||
if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId) {
|
||||
Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
|
||||
Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);
|
||||
|
||||
|
@ -2070,9 +2070,10 @@ Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
|
|||
IsAddressOfOperand, TemplateArgs);
|
||||
|
||||
// Perform the required lookup.
|
||||
LookupResult R(*this, NameInfo,
|
||||
(Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam)
|
||||
? LookupObjCImplicitSelfParam : LookupOrdinaryName);
|
||||
LookupResult R(*this, NameInfo,
|
||||
(Id.getKind() == UnqualifiedIdKind::IK_ImplicitSelfParam)
|
||||
? LookupObjCImplicitSelfParam
|
||||
: LookupOrdinaryName);
|
||||
if (TemplateArgs) {
|
||||
// Lookup the template name again to correctly establish the context in
|
||||
// which it was found. This is really unfortunate as we already did the
|
||||
|
@ -2243,7 +2244,7 @@ Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
|
|||
// In C++1y, if this is a variable template id, then check it
|
||||
// in BuildTemplateIdExpr().
|
||||
// The single lookup result must be a variable template declaration.
|
||||
if (Id.getKind() == UnqualifiedId::IK_TemplateId && Id.TemplateId &&
|
||||
if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId && Id.TemplateId &&
|
||||
Id.TemplateId->Kind == TNK_Var_template) {
|
||||
assert(R.getAsSingle<VarTemplateDecl>() &&
|
||||
"There should only be one declaration found.");
|
||||
|
@ -2401,7 +2402,7 @@ Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S,
|
|||
IdentifierInfo &II = Context.Idents.get("self");
|
||||
UnqualifiedId SelfName;
|
||||
SelfName.setIdentifier(&II, SourceLocation());
|
||||
SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam);
|
||||
SelfName.setKind(UnqualifiedIdKind::IK_ImplicitSelfParam);
|
||||
CXXScopeSpec SelfScopeSpec;
|
||||
SourceLocation TemplateKWLoc;
|
||||
ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc,
|
||||
|
|
|
@ -356,7 +356,7 @@ ParsedType Sema::getDestructorTypeForDecltype(const DeclSpec &DS,
|
|||
|
||||
bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS,
|
||||
const UnqualifiedId &Name) {
|
||||
assert(Name.getKind() == UnqualifiedId::IK_LiteralOperatorId);
|
||||
assert(Name.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId);
|
||||
|
||||
if (!SS.isValid())
|
||||
return false;
|
||||
|
@ -6716,11 +6716,11 @@ ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
|
|||
SourceLocation CCLoc,
|
||||
SourceLocation TildeLoc,
|
||||
UnqualifiedId &SecondTypeName) {
|
||||
assert((FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
|
||||
FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
|
||||
assert((FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
|
||||
FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&
|
||||
"Invalid first type name in pseudo-destructor");
|
||||
assert((SecondTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
|
||||
SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) &&
|
||||
assert((SecondTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
|
||||
SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&
|
||||
"Invalid second type name in pseudo-destructor");
|
||||
|
||||
QualType ObjectType;
|
||||
|
@ -6742,7 +6742,7 @@ ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
|
|||
QualType DestructedType;
|
||||
TypeSourceInfo *DestructedTypeInfo = nullptr;
|
||||
PseudoDestructorTypeStorage Destructed;
|
||||
if (SecondTypeName.getKind() == UnqualifiedId::IK_Identifier) {
|
||||
if (SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {
|
||||
ParsedType T = getTypeName(*SecondTypeName.Identifier,
|
||||
SecondTypeName.StartLocation,
|
||||
S, &SS, true, false, ObjectTypePtrForLookup,
|
||||
|
@ -6800,9 +6800,9 @@ ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
|
|||
// Convert the name of the scope type (the type prior to '::') into a type.
|
||||
TypeSourceInfo *ScopeTypeInfo = nullptr;
|
||||
QualType ScopeType;
|
||||
if (FirstTypeName.getKind() == UnqualifiedId::IK_TemplateId ||
|
||||
if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||
|
||||
FirstTypeName.Identifier) {
|
||||
if (FirstTypeName.getKind() == UnqualifiedId::IK_Identifier) {
|
||||
if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {
|
||||
ParsedType T = getTypeName(*FirstTypeName.Identifier,
|
||||
FirstTypeName.StartLocation,
|
||||
S, &SS, true, false, ObjectTypePtrForLookup,
|
||||
|
|
|
@ -1707,7 +1707,7 @@ ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base,
|
|||
|
||||
// Warn about the explicit constructor calls Microsoft extension.
|
||||
if (getLangOpts().MicrosoftExt &&
|
||||
Id.getKind() == UnqualifiedId::IK_ConstructorName)
|
||||
Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
|
||||
Diag(Id.getSourceRange().getBegin(),
|
||||
diag::ext_ms_explicit_constructor_call);
|
||||
|
||||
|
|
|
@ -169,16 +169,16 @@ TemplateNameKind Sema::isTemplateName(Scope *S,
|
|||
MemberOfUnknownSpecialization = false;
|
||||
|
||||
switch (Name.getKind()) {
|
||||
case UnqualifiedId::IK_Identifier:
|
||||
case UnqualifiedIdKind::IK_Identifier:
|
||||
TName = DeclarationName(Name.Identifier);
|
||||
break;
|
||||
|
||||
case UnqualifiedId::IK_OperatorFunctionId:
|
||||
case UnqualifiedIdKind::IK_OperatorFunctionId:
|
||||
TName = Context.DeclarationNames.getCXXOperatorName(
|
||||
Name.OperatorFunctionId.Operator);
|
||||
break;
|
||||
|
||||
case UnqualifiedId::IK_LiteralOperatorId:
|
||||
case UnqualifiedIdKind::IK_LiteralOperatorId:
|
||||
TName = Context.DeclarationNames.getCXXLiteralOperatorName(Name.Identifier);
|
||||
break;
|
||||
|
||||
|
@ -3557,7 +3557,7 @@ DeclResult Sema::ActOnVarTemplateSpecialization(
|
|||
TemplateParameterList *TemplateParams, StorageClass SC,
|
||||
bool IsPartialSpecialization) {
|
||||
// D must be variable template id.
|
||||
assert(D.getName().getKind() == UnqualifiedId::IK_TemplateId &&
|
||||
assert(D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&
|
||||
"Variable template specialization is declared with a template it.");
|
||||
|
||||
TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
|
||||
|
@ -4084,8 +4084,8 @@ TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S,
|
|||
// We found something; return it.
|
||||
auto *LookupRD = dyn_cast<CXXRecordDecl>(LookupCtx);
|
||||
if (!AllowInjectedClassName && SS.isSet() && LookupRD &&
|
||||
Name.getKind() == UnqualifiedId::IK_Identifier && Name.Identifier &&
|
||||
LookupRD->getIdentifier() == Name.Identifier) {
|
||||
Name.getKind() == UnqualifiedIdKind::IK_Identifier &&
|
||||
Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
|
||||
// C++14 [class.qual]p2:
|
||||
// In a lookup in which function names are not ignored and the
|
||||
// nested-name-specifier nominates a class C, if the name specified
|
||||
|
@ -4107,17 +4107,17 @@ TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S,
|
|||
NestedNameSpecifier *Qualifier = SS.getScopeRep();
|
||||
|
||||
switch (Name.getKind()) {
|
||||
case UnqualifiedId::IK_Identifier:
|
||||
case UnqualifiedIdKind::IK_Identifier:
|
||||
Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
|
||||
Name.Identifier));
|
||||
return TNK_Dependent_template_name;
|
||||
|
||||
case UnqualifiedId::IK_OperatorFunctionId:
|
||||
case UnqualifiedIdKind::IK_OperatorFunctionId:
|
||||
Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
|
||||
Name.OperatorFunctionId.Operator));
|
||||
return TNK_Function_template;
|
||||
|
||||
case UnqualifiedId::IK_LiteralOperatorId:
|
||||
case UnqualifiedIdKind::IK_LiteralOperatorId:
|
||||
llvm_unreachable("literal operator id cannot have a dependent scope");
|
||||
|
||||
default:
|
||||
|
@ -9044,7 +9044,7 @@ DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
|
|||
return true;
|
||||
}
|
||||
|
||||
if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
|
||||
if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
|
||||
// C++1y [temp.explicit]p3:
|
||||
// If the explicit instantiation is for a variable, the unqualified-id
|
||||
// in the declaration shall be a template-id.
|
||||
|
@ -9126,7 +9126,7 @@ DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
|
|||
// argument list into our AST format.
|
||||
bool HasExplicitTemplateArgs = false;
|
||||
TemplateArgumentListInfo TemplateArgs;
|
||||
if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
|
||||
if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
|
||||
TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
|
||||
HasExplicitTemplateArgs = true;
|
||||
}
|
||||
|
@ -9292,7 +9292,7 @@ DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
|
|||
//
|
||||
// C++98 has the same restriction, just worded differently.
|
||||
FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
|
||||
if (D.getName().getKind() != UnqualifiedId::IK_TemplateId && !FunTmpl &&
|
||||
if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId && !FunTmpl &&
|
||||
D.getCXXScopeSpec().isSet() &&
|
||||
!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
|
||||
Diag(D.getIdentifierLoc(),
|
||||
|
|
|
@ -2703,7 +2703,7 @@ static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy,
|
|||
// If the qualifiers come from a conversion function type, don't diagnose
|
||||
// them -- they're not necessarily redundant, since such a conversion
|
||||
// operator can be explicitly called as "x.operator const int()".
|
||||
if (D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId)
|
||||
if (D.getName().getKind() == UnqualifiedIdKind::IK_ConversionFunctionId)
|
||||
return;
|
||||
|
||||
// Just parens all the way out to the decl specifiers. Diagnose any qualifiers
|
||||
|
@ -2729,11 +2729,11 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
|
|||
TagDecl *OwnedTagDecl = nullptr;
|
||||
|
||||
switch (D.getName().getKind()) {
|
||||
case UnqualifiedId::IK_ImplicitSelfParam:
|
||||
case UnqualifiedId::IK_OperatorFunctionId:
|
||||
case UnqualifiedId::IK_Identifier:
|
||||
case UnqualifiedId::IK_LiteralOperatorId:
|
||||
case UnqualifiedId::IK_TemplateId:
|
||||
case UnqualifiedIdKind::IK_ImplicitSelfParam:
|
||||
case UnqualifiedIdKind::IK_OperatorFunctionId:
|
||||
case UnqualifiedIdKind::IK_Identifier:
|
||||
case UnqualifiedIdKind::IK_LiteralOperatorId:
|
||||
case UnqualifiedIdKind::IK_TemplateId:
|
||||
T = ConvertDeclSpecToType(state);
|
||||
|
||||
if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) {
|
||||
|
@ -2743,9 +2743,9 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
|
|||
}
|
||||
break;
|
||||
|
||||
case UnqualifiedId::IK_ConstructorName:
|
||||
case UnqualifiedId::IK_ConstructorTemplateId:
|
||||
case UnqualifiedId::IK_DestructorName:
|
||||
case UnqualifiedIdKind::IK_ConstructorName:
|
||||
case UnqualifiedIdKind::IK_ConstructorTemplateId:
|
||||
case UnqualifiedIdKind::IK_DestructorName:
|
||||
// Constructors and destructors don't have return types. Use
|
||||
// "void" instead.
|
||||
T = SemaRef.Context.VoidTy;
|
||||
|
@ -2753,13 +2753,13 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
|
|||
D.getDeclSpec().getAttributes().getList());
|
||||
break;
|
||||
|
||||
case UnqualifiedId::IK_DeductionGuideName:
|
||||
case UnqualifiedIdKind::IK_DeductionGuideName:
|
||||
// Deduction guides have a trailing return type and no type in their
|
||||
// decl-specifier sequence. Use a placeholder return type for now.
|
||||
T = SemaRef.Context.DependentTy;
|
||||
break;
|
||||
|
||||
case UnqualifiedId::IK_ConversionFunctionId:
|
||||
case UnqualifiedIdKind::IK_ConversionFunctionId:
|
||||
// The result type of a conversion function is the type that it
|
||||
// converts to.
|
||||
T = SemaRef.GetTypeFromParser(D.getName().ConversionFunctionId,
|
||||
|
@ -2917,7 +2917,7 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
|
|||
}
|
||||
|
||||
SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc();
|
||||
if (D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId)
|
||||
if (D.getName().getKind() == UnqualifiedIdKind::IK_ConversionFunctionId)
|
||||
AutoRange = D.getName().getSourceRange();
|
||||
|
||||
if (Error != -1) {
|
||||
|
@ -4322,7 +4322,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
|
|||
<< T << D.getSourceRange();
|
||||
D.setInvalidType(true);
|
||||
} else if (D.getName().getKind() ==
|
||||
UnqualifiedId::IK_DeductionGuideName) {
|
||||
UnqualifiedIdKind::IK_DeductionGuideName) {
|
||||
if (T != Context.DependentTy) {
|
||||
S.Diag(D.getDeclSpec().getLocStart(),
|
||||
diag::err_deduction_guide_with_complex_decl)
|
||||
|
@ -4350,7 +4350,8 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
|
|||
// C99 6.7.5.3p1: The return type may not be a function or array type.
|
||||
// For conversion functions, we'll diagnose this particular error later.
|
||||
if (!D.isInvalidType() && (T->isArrayType() || T->isFunctionType()) &&
|
||||
(D.getName().getKind() != UnqualifiedId::IK_ConversionFunctionId)) {
|
||||
(D.getName().getKind() !=
|
||||
UnqualifiedIdKind::IK_ConversionFunctionId)) {
|
||||
unsigned diagID = diag::err_func_returning_array_function;
|
||||
// Last processing chunk in block context means this function chunk
|
||||
// represents the block.
|
||||
|
@ -4794,7 +4795,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
|
|||
// Core issue 547 also allows cv-qualifiers on function types that are
|
||||
// top-level template type arguments.
|
||||
enum { NonMember, Member, DeductionGuide } Kind = NonMember;
|
||||
if (D.getName().getKind() == UnqualifiedId::IK_DeductionGuideName)
|
||||
if (D.getName().getKind() == UnqualifiedIdKind::IK_DeductionGuideName)
|
||||
Kind = DeductionGuide;
|
||||
else if (!D.getCXXScopeSpec().isSet()) {
|
||||
if ((D.getContext() == DeclaratorContext::MemberContext ||
|
||||
|
|
Loading…
Reference in New Issue