Lines Matching full:identifier
97 /// attrib-name '(' identifier ')'
98 /// attrib-name '(' identifier ',' nonempty-expr-list ')'
102 /// identifier
107 /// Whether an attribute takes an 'identifier' is determined by the
110 /// * In C mode, if the attribute argument list starts with an identifier
111 /// followed by a ',' or an ')', and the identifier doesn't resolve to
112 /// a type, it is parsed as an identifier. If the attribute actually
116 /// * In C++ mode, if the attribute argument list starts with an identifier,
117 /// and the attribute *wants* an identifier, it is parsed as an identifier.
118 /// At block scope, any additional tokens between the identifier and the
121 /// We follow the C++ model, but don't allow junk after the identifier.
145 // Expect an identifier or declaration specifier (const, int, etc.)
203 /// \brief Determine whether the given attribute has an identifier argument.
232 assert(Tok.is(tok::identifier) && "expected an identifier");
277 if (Tok.is(tok::identifier)) {
278 // If this attribute wants an 'identifier' argument, make it so.
284 // token in this argument, assume it's meant to be an identifier.
418 if (!Tok.is(tok::identifier)) {
464 // Consume the identifier.
475 if (!Tok.is(tok::identifier)) {
548 // We expect either a well-known identifier or a generic string. Anything
551 if (!IsString && Tok.getKind() != tok::identifier &&
809 /// identifier
841 if (Tok.isNot(tok::identifier)) {
867 if (Tok.isNot(tok::identifier)) {
915 Tok.is(tok::identifier)) {
1002 /// Identifier
1005 /// Identifier: | <empty>
1008 /// Identifier | <empty>
1025 if (Tok.isNot(tok::identifier)) {
1038 if (Tok.is(tok::identifier)) {
1057 if (Tok.is(tok::identifier))
1243 if (Tok.isNot(tok::identifier)) {
1244 Diag(Tok, diag::err_expected) << tok::identifier;
1265 if (Tok.isNot(tok::identifier)) {
1266 Diag(Tok, diag::err_expected) << tok::identifier;
1461 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
1504 case tok::identifier:
1525 // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
1531 case tok::identifier: // Possible virt-specifier.
2113 /// specified token is valid after the identifier in a declarator which
2138 /// identifier in a declspec (which normally terminates the decl spec) when
2150 assert(Tok.is(tok::identifier) && "should have identifier");
2153 // If we see an identifier that is not a type name, we normally would
2156 // parse the typename as the identifier name and fall over misparsing
2162 // an identifier with implicit int, we'd get a parse error because the
2175 // we just avoid eating the identifier, so it will be parsed as the
2176 // identifier in the declarator.
2240 // Determine whether this identifier could plausibly be the name of something
2260 // The identifier is followed by a parenthesized declarator.
2436 (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||
2460 } else if (AfterScope.is(tok::identifier)) {
2466 Next.is(tok::identifier) || Next.is(tok::annot_cxxscope) ||
2686 // is the same as the identifier or the
2742 if (Next.isNot(tok::identifier))
2745 // If we're in a context where the identifier could be a class name,
2770 // If the referenced identifier is not a type, then this declspec is
2775 ConsumeToken(); // Eat the scope spec so the identifier is current.
2830 // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
2836 // then treat __is_signed as an identifier rather than as a keyword.
2848 case tok::identifier: {
2849 // This identifier can only be a typedef name if we haven't already seen
2862 if (!Tok.is(tok::identifier))
2880 // just a simple identifier, create a DependentNameType. This will allow
2903 // If we're in a context where the identifier could be a class name,
2916 ConsumeToken(); // The identifier
3187 Tok.setKind(tok::identifier);
3516 if (!Tok.is(tok::identifier)) {
3517 Diag(Tok, diag::err_expected) << tok::identifier;
3561 /// 'enum' identifier[opt] '{' enumerator-list '}'
3562 ///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
3563 /// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
3565 /// [MS] 'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
3567 /// 'enum' identifier
3568 /// [GNU] 'enum' attributes[opt] identifier
3574 /// enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
3576 /// identifier enum-base[opt]
3587 /// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier
3658 if (Spec.isSet() && Tok.isNot(tok::identifier)) {
3659 Diag(Tok, diag::err_expected) << tok::identifier;
3672 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
3674 Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace;
3681 // If an identifier is present, consume and remember it.
3684 if (Tok.is(tok::identifier)) {
3690 // C++0x 7.2p2: The optional identifier shall not be omitted in the
3920 /// identifier
3942 if (Tok.isNot(tok::identifier)) {
3943 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
3984 if (Tok.is(tok::identifier)) {
4026 // If attributes exist after the identifier list, parse them.
4124 case tok::identifier: // foo::bar
4133 if (Tok.is(tok::identifier))
4237 case tok::identifier: // foo::bar
4250 if (Tok.is(tok::identifier))
4254 // by an identifier and then either ':' or ']', in a place where an
4409 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) {
4457 else if (Tok.is(tok::identifier) ||
4458 (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) {
4712 (Tok.is(tok::identifier) &&
4854 // When correcting from misplaced brackets before the identifier, the location
4869 /// [C99] identifier
4880 /// direct-declarator '(' identifier-list[opt] ')'
4900 /// identifier
4967 if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
4990 // Once we're past the identifier, if the scope was bad, mark the
5010 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
5012 "There's a C++-specific check for tok::identifier above");
5013 assert(Tok.getIdentifierInfo() && "Not an identifier?");
5018 } else if (Tok.is(tok::identifier) && D.diagnoseIdentifier()) {
5019 // A virt-specifier isn't treated as an identifier if it appears after a
5086 << tok::identifier << tok::l_paren;
5094 "Haven't past the location of the identifier yet?");
5136 /// only called before the identifier, so these are most likely just grouping
5144 /// direct-declarator '(' identifier-list[opt] ')'
5152 assert(!D.isPastIdentifier() && "Should be called before passing identifier");
5181 // If we haven't past the identifier yet (or where the identifier would be
5189 // paren, because we haven't seen the identifier yet.
5197 // considered to be a type, not a K&R identifier-list.
5231 // identifier (and remember where it would have been), then call into
5245 /// ParseFunctionDeclarator - We are after the identifier and have parsed the
5254 /// to be present and required to not be an identifier list.
5272 assert(D.isPastIdentifier() && "Should not call before identifier!");
5380 GetLookAheadToken(4).is(tok::identifier) &&
5460 /// identifier list form for a K&R-style function: void foo(a,b,c)
5462 /// Note that identifier-lists are only allowed for normal declarators, not for
5466 && Tok.is(tok::identifier)
5468 // K&R identifier lists can't have typedefs as identifiers, per C99
5471 // Identifier lists follow a really simple grammar: the identifiers can
5472 // be followed *only* by a ", identifier" or ")". However, K&R
5473 // identifier lists are really rare in the brave new modern world, and
5481 // identifier is a "," or ")". Only then do we parse it as an
5482 // identifier list.
5487 /// we found a K&R-style identifier list instead of a typed parameter list.
5491 /// identifier-list: [C99 6.7.5]
5492 /// identifier
5493 /// identifier-list ',' identifier
5498 // If there was no identifier specified for the declarator, either we are in
5500 // to be abstract. In abstract-declarators, identifier lists are not valid:
5509 // If this isn't an identifier, report the error and skip until ')'.
5510 if (Tok.isNot(tok::identifier)) {
5511 Diag(Tok, diag::err_expected) << tok::identifier;
5524 // Verify that the argument identifier has not already been mentioned.
5528 // Remember this identifier in ParamInfo.
5534 // Eat the identifier.
5542 /// identifier list.
5624 // otherwise we have a missing type and identifier.
5858 /// Diagnose brackets before an identifier.
5861 assert(!D.mayOmitIdentifier() && "Declarator cannot omit identifier");
5920 // The missing identifier would have been diagnosed in ParseDirectDeclarator.
6071 case tok::identifier:
6105 case tok::identifier:
