clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ParseDeclCXX.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Parse -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Parse -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Parse -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Parse -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Parse/ParseDeclCXX.cpp
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | #include "clang/Parse/Parser.h" |
14 | #include "clang/AST/ASTContext.h" |
15 | #include "clang/AST/DeclTemplate.h" |
16 | #include "clang/AST/PrettyDeclStackTrace.h" |
17 | #include "clang/Basic/Attributes.h" |
18 | #include "clang/Basic/CharInfo.h" |
19 | #include "clang/Basic/OperatorKinds.h" |
20 | #include "clang/Basic/TargetInfo.h" |
21 | #include "clang/Parse/ParseDiagnostic.h" |
22 | #include "clang/Parse/RAIIObjectsForParser.h" |
23 | #include "clang/Sema/DeclSpec.h" |
24 | #include "clang/Sema/ParsedTemplate.h" |
25 | #include "clang/Sema/Scope.h" |
26 | #include "llvm/ADT/SmallString.h" |
27 | #include "llvm/Support/TimeProfiler.h" |
28 | |
29 | using namespace clang; |
30 | |
31 | |
32 | |
33 | |
34 | |
35 | |
36 | |
37 | |
38 | |
39 | |
40 | |
41 | |
42 | |
43 | |
44 | |
45 | |
46 | |
47 | |
48 | |
49 | |
50 | |
51 | |
52 | |
53 | |
54 | |
55 | |
56 | |
57 | |
58 | Parser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, |
59 | SourceLocation &DeclEnd, |
60 | SourceLocation InlineLoc) { |
61 | assert(Tok.is(tok::kw_namespace) && "Not a namespace!"); |
62 | SourceLocation NamespaceLoc = ConsumeToken(); |
63 | ObjCDeclContextSwitch ObjCDC(*this); |
64 | |
65 | if (Tok.is(tok::code_completion)) { |
66 | cutOffParsing(); |
67 | Actions.CodeCompleteNamespaceDecl(getCurScope()); |
68 | return nullptr; |
69 | } |
70 | |
71 | SourceLocation IdentLoc; |
72 | IdentifierInfo *Ident = nullptr; |
73 | InnerNamespaceInfoList ExtraNSs; |
74 | SourceLocation FirstNestedInlineLoc; |
75 | |
76 | ParsedAttributesWithRange attrs(AttrFactory); |
77 | SourceLocation attrLoc; |
78 | if (getLangOpts().CPlusPlus11 && isCXX11AttributeSpecifier()) { |
79 | Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 |
80 | ? diag::warn_cxx14_compat_ns_enum_attribute |
81 | : diag::ext_ns_enum_attribute) |
82 | << 0 ; |
83 | attrLoc = Tok.getLocation(); |
84 | ParseCXX11Attributes(attrs); |
85 | } |
86 | |
87 | if (Tok.is(tok::identifier)) { |
88 | Ident = Tok.getIdentifierInfo(); |
89 | IdentLoc = ConsumeToken(); |
90 | while (Tok.is(tok::coloncolon) && |
91 | (NextToken().is(tok::identifier) || |
92 | (NextToken().is(tok::kw_inline) && |
93 | GetLookAheadToken(2).is(tok::identifier)))) { |
94 | |
95 | InnerNamespaceInfo Info; |
96 | Info.NamespaceLoc = ConsumeToken(); |
97 | |
98 | if (Tok.is(tok::kw_inline)) { |
99 | Info.InlineLoc = ConsumeToken(); |
100 | if (FirstNestedInlineLoc.isInvalid()) |
101 | FirstNestedInlineLoc = Info.InlineLoc; |
102 | } |
103 | |
104 | Info.Ident = Tok.getIdentifierInfo(); |
105 | Info.IdentLoc = ConsumeToken(); |
106 | |
107 | ExtraNSs.push_back(Info); |
108 | } |
109 | } |
110 | |
111 | |
112 | if (!ExtraNSs.empty() && attrLoc.isValid()) |
113 | Diag(attrLoc, diag::err_unexpected_nested_namespace_attribute); |
114 | |
115 | |
116 | if (Tok.is(tok::kw___attribute)) { |
117 | attrLoc = Tok.getLocation(); |
118 | ParseGNUAttributes(attrs); |
119 | } |
120 | |
121 | if (Tok.is(tok::equal)) { |
122 | if (!Ident) { |
123 | Diag(Tok, diag::err_expected) << tok::identifier; |
124 | |
125 | SkipUntil(tok::semi); |
126 | return nullptr; |
127 | } |
128 | if (attrLoc.isValid()) |
129 | Diag(attrLoc, diag::err_unexpected_namespace_attributes_alias); |
130 | if (InlineLoc.isValid()) |
131 | Diag(InlineLoc, diag::err_inline_namespace_alias) |
132 | << FixItHint::CreateRemoval(InlineLoc); |
133 | Decl *NSAlias = ParseNamespaceAlias(NamespaceLoc, IdentLoc, Ident, DeclEnd); |
134 | return Actions.ConvertDeclToDeclGroup(NSAlias); |
135 | } |
136 | |
137 | BalancedDelimiterTracker T(*this, tok::l_brace); |
138 | if (T.consumeOpen()) { |
139 | if (Ident) |
140 | Diag(Tok, diag::err_expected) << tok::l_brace; |
141 | else |
142 | Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace; |
143 | return nullptr; |
144 | } |
145 | |
146 | if (getCurScope()->isClassScope() || getCurScope()->isTemplateParamScope() || |
147 | getCurScope()->isInObjcMethodScope() || getCurScope()->getBlockParent() || |
148 | getCurScope()->getFnParent()) { |
149 | Diag(T.getOpenLocation(), diag::err_namespace_nonnamespace_scope); |
150 | SkipUntil(tok::r_brace); |
151 | return nullptr; |
152 | } |
153 | |
154 | if (ExtraNSs.empty()) { |
155 | |
156 | } else if (InlineLoc.isValid()) { |
157 | Diag(InlineLoc, diag::err_inline_nested_namespace_definition); |
158 | } else if (getLangOpts().CPlusPlus20) { |
159 | Diag(ExtraNSs[0].NamespaceLoc, |
160 | diag::warn_cxx14_compat_nested_namespace_definition); |
161 | if (FirstNestedInlineLoc.isValid()) |
162 | Diag(FirstNestedInlineLoc, |
163 | diag::warn_cxx17_compat_inline_nested_namespace_definition); |
164 | } else if (getLangOpts().CPlusPlus17) { |
165 | Diag(ExtraNSs[0].NamespaceLoc, |
166 | diag::warn_cxx14_compat_nested_namespace_definition); |
167 | if (FirstNestedInlineLoc.isValid()) |
168 | Diag(FirstNestedInlineLoc, diag::ext_inline_nested_namespace_definition); |
169 | } else { |
170 | TentativeParsingAction TPA(*this); |
171 | SkipUntil(tok::r_brace, StopBeforeMatch); |
172 | Token rBraceToken = Tok; |
173 | TPA.Revert(); |
174 | |
175 | if (!rBraceToken.is(tok::r_brace)) { |
176 | Diag(ExtraNSs[0].NamespaceLoc, diag::ext_nested_namespace_definition) |
177 | << SourceRange(ExtraNSs.front().NamespaceLoc, |
178 | ExtraNSs.back().IdentLoc); |
179 | } else { |
180 | std::string NamespaceFix; |
181 | for (const auto &ExtraNS : ExtraNSs) { |
182 | NamespaceFix += " { "; |
183 | if (ExtraNS.InlineLoc.isValid()) |
184 | NamespaceFix += "inline "; |
185 | NamespaceFix += "namespace "; |
186 | NamespaceFix += ExtraNS.Ident->getName(); |
187 | } |
188 | |
189 | std::string RBraces; |
190 | for (unsigned i = 0, e = ExtraNSs.size(); i != e; ++i) |
191 | RBraces += "} "; |
192 | |
193 | Diag(ExtraNSs[0].NamespaceLoc, diag::ext_nested_namespace_definition) |
194 | << FixItHint::CreateReplacement( |
195 | SourceRange(ExtraNSs.front().NamespaceLoc, |
196 | ExtraNSs.back().IdentLoc), |
197 | NamespaceFix) |
198 | << FixItHint::CreateInsertion(rBraceToken.getLocation(), RBraces); |
199 | } |
200 | |
201 | |
202 | if (FirstNestedInlineLoc.isValid()) |
203 | Diag(FirstNestedInlineLoc, diag::ext_inline_nested_namespace_definition); |
204 | } |
205 | |
206 | |
207 | if (InlineLoc.isValid()) |
208 | Diag(InlineLoc, getLangOpts().CPlusPlus11 ? |
209 | diag::warn_cxx98_compat_inline_namespace : diag::ext_inline_namespace); |
210 | |
211 | |
212 | ParseScope NamespaceScope(this, Scope::DeclScope); |
213 | |
214 | UsingDirectiveDecl *ImplicitUsingDirectiveDecl = nullptr; |
215 | Decl *NamespcDecl = Actions.ActOnStartNamespaceDef( |
216 | getCurScope(), InlineLoc, NamespaceLoc, IdentLoc, Ident, |
217 | T.getOpenLocation(), attrs, ImplicitUsingDirectiveDecl); |
218 | |
219 | PrettyDeclStackTraceEntry CrashInfo(Actions.Context, NamespcDecl, |
220 | NamespaceLoc, "parsing namespace"); |
221 | |
222 | |
223 | |
224 | ParseInnerNamespace(ExtraNSs, 0, InlineLoc, attrs, T); |
225 | |
226 | |
227 | NamespaceScope.Exit(); |
228 | |
229 | DeclEnd = T.getCloseLocation(); |
230 | Actions.ActOnFinishNamespaceDef(NamespcDecl, DeclEnd); |
231 | |
232 | return Actions.ConvertDeclToDeclGroup(NamespcDecl, |
233 | ImplicitUsingDirectiveDecl); |
234 | } |
235 | |
236 | |
237 | void Parser::ParseInnerNamespace(const InnerNamespaceInfoList &InnerNSs, |
238 | unsigned int index, SourceLocation &InlineLoc, |
239 | ParsedAttributes &attrs, |
240 | BalancedDelimiterTracker &Tracker) { |
241 | if (index == InnerNSs.size()) { |
242 | while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) && |
243 | Tok.isNot(tok::eof)) { |
244 | ParsedAttributesWithRange attrs(AttrFactory); |
245 | MaybeParseCXX11Attributes(attrs); |
246 | ParseExternalDeclaration(attrs); |
247 | } |
248 | |
249 | |
250 | |
251 | Tracker.consumeClose(); |
252 | |
253 | return; |
254 | } |
255 | |
256 | |
257 | |
258 | |
259 | ParseScope NamespaceScope(this, Scope::DeclScope); |
260 | UsingDirectiveDecl *ImplicitUsingDirectiveDecl = nullptr; |
261 | Decl *NamespcDecl = Actions.ActOnStartNamespaceDef( |
262 | getCurScope(), InnerNSs[index].InlineLoc, InnerNSs[index].NamespaceLoc, |
263 | InnerNSs[index].IdentLoc, InnerNSs[index].Ident, |
264 | Tracker.getOpenLocation(), attrs, ImplicitUsingDirectiveDecl); |
265 | assert(!ImplicitUsingDirectiveDecl && |
266 | "nested namespace definition cannot define anonymous namespace"); |
267 | |
268 | ParseInnerNamespace(InnerNSs, ++index, InlineLoc, attrs, Tracker); |
269 | |
270 | NamespaceScope.Exit(); |
271 | Actions.ActOnFinishNamespaceDef(NamespcDecl, Tracker.getCloseLocation()); |
272 | } |
273 | |
274 | |
275 | |
276 | |
277 | Decl *Parser::ParseNamespaceAlias(SourceLocation NamespaceLoc, |
278 | SourceLocation AliasLoc, |
279 | IdentifierInfo *Alias, |
280 | SourceLocation &DeclEnd) { |
281 | assert(Tok.is(tok::equal) && "Not equal token"); |
282 | |
283 | ConsumeToken(); |
284 | |
285 | if (Tok.is(tok::code_completion)) { |
286 | cutOffParsing(); |
287 | Actions.CodeCompleteNamespaceAliasDecl(getCurScope()); |
288 | return nullptr; |
289 | } |
290 | |
291 | CXXScopeSpec SS; |
292 | |
293 | ParseOptionalCXXScopeSpecifier(SS, nullptr, |
294 | false, |
295 | false, |
296 | nullptr, |
297 | false, |
298 | nullptr, |
299 | true); |
300 | |
301 | if (Tok.isNot(tok::identifier)) { |
302 | Diag(Tok, diag::err_expected_namespace_name); |
303 | |
304 | SkipUntil(tok::semi); |
305 | return nullptr; |
306 | } |
307 | |
308 | if (SS.isInvalid()) { |
309 | |
310 | |
311 | SkipUntil(tok::semi); |
312 | return nullptr; |
313 | } |
314 | |
315 | |
316 | IdentifierInfo *Ident = Tok.getIdentifierInfo(); |
317 | SourceLocation IdentLoc = ConsumeToken(); |
318 | |
319 | |
320 | DeclEnd = Tok.getLocation(); |
321 | if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after_namespace_name)) |
322 | SkipUntil(tok::semi); |
323 | |
324 | return Actions.ActOnNamespaceAliasDef(getCurScope(), NamespaceLoc, AliasLoc, |
325 | Alias, SS, IdentLoc, Ident); |
326 | } |
327 | |
328 | |
329 | |
330 | |
331 | |
332 | |
333 | |
334 | |
335 | Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, DeclaratorContext Context) { |
336 | assert(isTokenStringLiteral() && "Not a string literal!"); |
337 | ExprResult Lang = ParseStringLiteralExpression(false); |
338 | |
339 | ParseScope LinkageScope(this, Scope::DeclScope); |
340 | Decl *LinkageSpec = |
341 | Lang.isInvalid() |
342 | ? nullptr |
343 | : Actions.ActOnStartLinkageSpecification( |
344 | getCurScope(), DS.getSourceRange().getBegin(), Lang.get(), |
345 | Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation()); |
346 | |
347 | ParsedAttributesWithRange attrs(AttrFactory); |
348 | MaybeParseCXX11Attributes(attrs); |
349 | |
350 | if (Tok.isNot(tok::l_brace)) { |
351 | |
352 | |
353 | DS.SetRangeStart(SourceLocation()); |
354 | DS.SetRangeEnd(SourceLocation()); |
355 | |
356 | DS.setExternInLinkageSpec(true); |
357 | ParseExternalDeclaration(attrs, &DS); |
358 | return LinkageSpec ? Actions.ActOnFinishLinkageSpecification( |
359 | getCurScope(), LinkageSpec, SourceLocation()) |
360 | : nullptr; |
361 | } |
362 | |
363 | DS.abort(); |
364 | |
365 | ProhibitAttributes(attrs); |
366 | |
367 | BalancedDelimiterTracker T(*this, tok::l_brace); |
368 | T.consumeOpen(); |
369 | |
370 | unsigned NestedModules = 0; |
371 | while (true) { |
372 | switch (Tok.getKind()) { |
373 | case tok::annot_module_begin: |
374 | ++NestedModules; |
375 | ParseTopLevelDecl(); |
376 | continue; |
377 | |
378 | case tok::annot_module_end: |
379 | if (!NestedModules) |
380 | break; |
381 | --NestedModules; |
382 | ParseTopLevelDecl(); |
383 | continue; |
384 | |
385 | case tok::annot_module_include: |
386 | ParseTopLevelDecl(); |
387 | continue; |
388 | |
389 | case tok::eof: |
390 | break; |
391 | |
392 | case tok::r_brace: |
393 | if (!NestedModules) |
394 | break; |
395 | LLVM_FALLTHROUGH; |
396 | default: |
397 | ParsedAttributesWithRange attrs(AttrFactory); |
398 | MaybeParseCXX11Attributes(attrs); |
399 | ParseExternalDeclaration(attrs); |
400 | continue; |
401 | } |
402 | |
403 | break; |
404 | } |
405 | |
406 | T.consumeClose(); |
407 | return LinkageSpec ? Actions.ActOnFinishLinkageSpecification( |
408 | getCurScope(), LinkageSpec, T.getCloseLocation()) |
409 | : nullptr; |
410 | } |
411 | |
412 | |
413 | |
414 | |
415 | |
416 | |
417 | |
418 | Decl *Parser::ParseExportDeclaration() { |
419 | assert(Tok.is(tok::kw_export)); |
420 | SourceLocation ExportLoc = ConsumeToken(); |
421 | |
422 | ParseScope ExportScope(this, Scope::DeclScope); |
423 | Decl *ExportDecl = Actions.ActOnStartExportDecl( |
424 | getCurScope(), ExportLoc, |
425 | Tok.is(tok::l_brace) ? Tok.getLocation() : SourceLocation()); |
426 | |
427 | if (Tok.isNot(tok::l_brace)) { |
428 | |
429 | ParsedAttributesWithRange Attrs(AttrFactory); |
430 | MaybeParseCXX11Attributes(Attrs); |
431 | MaybeParseMicrosoftAttributes(Attrs); |
432 | ParseExternalDeclaration(Attrs); |
433 | return Actions.ActOnFinishExportDecl(getCurScope(), ExportDecl, |
434 | SourceLocation()); |
435 | } |
436 | |
437 | BalancedDelimiterTracker T(*this, tok::l_brace); |
438 | T.consumeOpen(); |
439 | |
440 | |
441 | |
442 | if (Tok.is(tok::r_brace) && getLangOpts().ModulesTS) { |
443 | Diag(ExportLoc, diag::err_export_empty) |
444 | << SourceRange(ExportLoc, Tok.getLocation()); |
445 | } |
446 | |
447 | while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) && |
448 | Tok.isNot(tok::eof)) { |
449 | ParsedAttributesWithRange Attrs(AttrFactory); |
450 | MaybeParseCXX11Attributes(Attrs); |
451 | MaybeParseMicrosoftAttributes(Attrs); |
452 | ParseExternalDeclaration(Attrs); |
453 | } |
454 | |
455 | T.consumeClose(); |
456 | return Actions.ActOnFinishExportDecl(getCurScope(), ExportDecl, |
457 | T.getCloseLocation()); |
458 | } |
459 | |
460 | |
461 | |
462 | Parser::DeclGroupPtrTy |
463 | Parser::ParseUsingDirectiveOrDeclaration(DeclaratorContext Context, |
464 | const ParsedTemplateInfo &TemplateInfo, |
465 | SourceLocation &DeclEnd, |
466 | ParsedAttributesWithRange &attrs) { |
467 | assert(Tok.is(tok::kw_using) && "Not using token"); |
468 | ObjCDeclContextSwitch ObjCDC(*this); |
469 | |
470 | |
471 | SourceLocation UsingLoc = ConsumeToken(); |
472 | |
473 | if (Tok.is(tok::code_completion)) { |
| |
474 | cutOffParsing(); |
475 | Actions.CodeCompleteUsing(getCurScope()); |
476 | return nullptr; |
477 | } |
478 | |
479 | |
480 | while (Tok.is(tok::kw_template)) { |
| 2 | | Loop condition is false. Execution continues on line 487 | |
|
481 | SourceLocation TemplateLoc = ConsumeToken(); |
482 | Diag(TemplateLoc, diag::err_unexpected_template_after_using) |
483 | << FixItHint::CreateRemoval(TemplateLoc); |
484 | } |
485 | |
486 | |
487 | if (Tok.is(tok::kw_namespace)) { |
| |
488 | |
489 | if (TemplateInfo.Kind) { |
490 | SourceRange R = TemplateInfo.getSourceRange(); |
491 | Diag(UsingLoc, diag::err_templated_using_directive_declaration) |
492 | << 0 << R << FixItHint::CreateRemoval(R); |
493 | } |
494 | |
495 | Decl *UsingDir = ParseUsingDirective(Context, UsingLoc, DeclEnd, attrs); |
496 | return Actions.ConvertDeclToDeclGroup(UsingDir); |
497 | } |
498 | |
499 | |
500 | return ParseUsingDeclaration(Context, TemplateInfo, UsingLoc, DeclEnd, attrs, |
| 4 | | Calling 'Parser::ParseUsingDeclaration' | |
|
501 | AS_none); |
502 | } |
503 | |
504 | |
505 | |
506 | |
507 | |
508 | |
509 | |
510 | |
511 | |
512 | |
513 | |
514 | Decl *Parser::ParseUsingDirective(DeclaratorContext Context, |
515 | SourceLocation UsingLoc, |
516 | SourceLocation &DeclEnd, |
517 | ParsedAttributes &attrs) { |
518 | assert(Tok.is(tok::kw_namespace) && "Not 'namespace' token"); |
519 | |
520 | |
521 | SourceLocation NamespcLoc = ConsumeToken(); |
522 | |
523 | if (Tok.is(tok::code_completion)) { |
524 | cutOffParsing(); |
525 | Actions.CodeCompleteUsingDirective(getCurScope()); |
526 | return nullptr; |
527 | } |
528 | |
529 | CXXScopeSpec SS; |
530 | |
531 | ParseOptionalCXXScopeSpecifier(SS, nullptr, |
532 | false, |
533 | false, |
534 | nullptr, |
535 | false, |
536 | nullptr, |
537 | true); |
538 | |
539 | IdentifierInfo *NamespcName = nullptr; |
540 | SourceLocation IdentLoc = SourceLocation(); |
541 | |
542 | |
543 | if (Tok.isNot(tok::identifier)) { |
544 | Diag(Tok, diag::err_expected_namespace_name); |
545 | |
546 | SkipUntil(tok::semi); |
547 | |
548 | return nullptr; |
549 | } |
550 | |
551 | if (SS.isInvalid()) { |
552 | |
553 | |
554 | SkipUntil(tok::semi); |
555 | return nullptr; |
556 | } |
557 | |
558 | |
559 | NamespcName = Tok.getIdentifierInfo(); |
560 | IdentLoc = ConsumeToken(); |
561 | |
562 | |
563 | bool GNUAttr = false; |
564 | if (Tok.is(tok::kw___attribute)) { |
565 | GNUAttr = true; |
566 | ParseGNUAttributes(attrs); |
567 | } |
568 | |
569 | |
570 | DeclEnd = Tok.getLocation(); |
571 | if (ExpectAndConsume(tok::semi, |
572 | GNUAttr ? diag::err_expected_semi_after_attribute_list |
573 | : diag::err_expected_semi_after_namespace_name)) |
574 | SkipUntil(tok::semi); |
575 | |
576 | return Actions.ActOnUsingDirective(getCurScope(), UsingLoc, NamespcLoc, SS, |
577 | IdentLoc, NamespcName, attrs); |
578 | } |
579 | |
580 | |
581 | |
582 | |
583 | |
584 | |
585 | bool Parser::ParseUsingDeclarator(DeclaratorContext Context, |
586 | UsingDeclarator &D) { |
587 | D.clear(); |
588 | |
589 | |
590 | |
591 | TryConsumeToken(tok::kw_typename, D.TypenameLoc); |
592 | |
593 | if (Tok.is(tok::kw___super)) { |
| |
| 10 | | Returning from 'Token::is' | |
|
| |
594 | Diag(Tok.getLocation(), diag::err_super_in_using_declaration); |
595 | return true; |
596 | } |
597 | |
598 | |
599 | IdentifierInfo *LastII = nullptr; |
600 | if (ParseOptionalCXXScopeSpecifier(D.SS, nullptr, |
| 12 | | Value assigned to 'LastII' | |
|
| 13 | | Assuming the condition is false | |
|
| |
601 | false, |
602 | false, |
603 | nullptr, |
604 | false, |
605 | &LastII, |
606 | false, |
607 | true)) |
608 | |
609 | return true; |
610 | if (D.SS.isInvalid()) |
| 15 | | Calling 'CXXScopeSpec::isInvalid' | |
|
| 17 | | Returning from 'CXXScopeSpec::isInvalid' | |
|
611 | return true; |
612 | |
613 | |
614 | |
615 | |
616 | |
617 | |
618 | |
619 | |
620 | |
621 | |
622 | |
623 | if (getLangOpts().CPlusPlus11 && Context == DeclaratorContext::Member && |
| 18 | | Assuming field 'CPlusPlus11' is not equal to 0 | |
|
| 19 | | Assuming 'Context' is equal to Member | |
|
| |
624 | Tok.is(tok::identifier) && |
| |
| 23 | | Returning from 'Token::is' | |
|
625 | (NextToken().is(tok::semi) || NextToken().is(tok::comma) || |
| |
| 27 | | Returning from 'Token::is' | |
|
626 | NextToken().is(tok::ellipsis) || NextToken().is(tok::l_square) || |
627 | NextToken().is(tok::kw___attribute)) && |
628 | D.SS.isNotEmpty() && LastII == Tok.getIdentifierInfo() && |
| 28 | | Calling 'CXXScopeSpec::isNotEmpty' | |
|
| 34 | | Returning from 'CXXScopeSpec::isNotEmpty' | |
|
| 35 | | Assuming pointer value is null | |
|
629 | !D.SS.getScopeRep()->getAsNamespace() && |
| 36 | | Assuming the condition is true | |
|
630 | !D.SS.getScopeRep()->getAsNamespaceAlias()) { |
| 37 | | Assuming the condition is true | |
|
631 | SourceLocation IdLoc = ConsumeToken(); |
632 | ParsedType Type = |
633 | Actions.getInheritingConstructorName(D.SS, IdLoc, *LastII); |
| 39 | | Forming reference to null pointer |
|
634 | D.Name.setConstructorName(Type, IdLoc, IdLoc); |
635 | } else { |
636 | if (ParseUnqualifiedId( |
637 | D.SS, nullptr, |
638 | false, false, |
639 | true, |
640 | |
641 | !(Tok.is(tok::identifier) && NextToken().is(tok::equal)), |
642 | false, nullptr, D.Name)) |
643 | return true; |
644 | } |
645 | |
646 | if (TryConsumeToken(tok::ellipsis, D.EllipsisLoc)) |
647 | Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? |
648 | diag::warn_cxx17_compat_using_declaration_pack : |
649 | diag::ext_using_declaration_pack); |
650 | |
651 | return false; |
652 | } |
653 | |
654 | |
655 | |
656 | |
657 | |
658 | |
659 | |
660 | |
661 | |
662 | |
663 | |
664 | |
665 | |
666 | |
667 | |
668 | |
669 | |
670 | |
671 | |
672 | |
673 | |
674 | |
675 | Parser::DeclGroupPtrTy |
676 | Parser::ParseUsingDeclaration( |
677 | DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo, |
678 | SourceLocation UsingLoc, SourceLocation &DeclEnd, |
679 | ParsedAttributesWithRange &PrefixAttrs, AccessSpecifier AS) { |
680 | SourceLocation UELoc; |
681 | if (TryConsumeToken(tok::kw_enum, UELoc)) { |
| |
682 | |
683 | Diag(UELoc, getLangOpts().CPlusPlus20 |
684 | ? diag::warn_cxx17_compat_using_enum_declaration |
685 | : diag::ext_using_enum_declaration); |
686 | |
687 | DiagnoseCXX11AttributeExtension(PrefixAttrs); |
688 | |
689 | DeclSpec DS(AttrFactory); |
690 | ParseEnumSpecifier(UELoc, DS, TemplateInfo, AS, |
691 | |
692 | DeclSpecContext::DSC_trailing); |
693 | |
694 | if (TemplateInfo.Kind) { |
695 | SourceRange R = TemplateInfo.getSourceRange(); |
696 | Diag(UsingLoc, diag::err_templated_using_directive_declaration) |
697 | << 1 << R << FixItHint::CreateRemoval(R); |
698 | |
699 | return nullptr; |
700 | } |
701 | |
702 | Decl *UED = Actions.ActOnUsingEnumDeclaration(getCurScope(), AS, UsingLoc, |
703 | UELoc, DS); |
704 | DeclEnd = Tok.getLocation(); |
705 | if (ExpectAndConsume(tok::semi, diag::err_expected_after, |
706 | "using-enum declaration")) |
707 | SkipUntil(tok::semi); |
708 | |
709 | return Actions.ConvertDeclToDeclGroup(UED); |
710 | } |
711 | |
712 | |
713 | |
714 | ParsedAttributesWithRange MisplacedAttrs(AttrFactory); |
715 | MaybeParseCXX11Attributes(MisplacedAttrs); |
716 | |
717 | UsingDeclarator D; |
718 | bool InvalidDeclarator = ParseUsingDeclarator(Context, D); |
| 6 | | Calling 'Parser::ParseUsingDeclarator' | |
|
719 | |
720 | ParsedAttributesWithRange Attrs(AttrFactory); |
721 | MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs); |
722 | |
723 | |
724 | |
725 | if (MisplacedAttrs.Range.isValid()) { |
726 | Diag(MisplacedAttrs.Range.getBegin(), diag::err_attributes_not_allowed) |
727 | << FixItHint::CreateInsertionFromRange( |
728 | Tok.getLocation(), |
729 | CharSourceRange::getTokenRange(MisplacedAttrs.Range)) |
730 | << FixItHint::CreateRemoval(MisplacedAttrs.Range); |
731 | Attrs.takeAllFrom(MisplacedAttrs); |
732 | } |
733 | |
734 | |
735 | if (Tok.is(tok::equal)) { |
736 | if (InvalidDeclarator) { |
737 | SkipUntil(tok::semi); |
738 | return nullptr; |
739 | } |
740 | |
741 | ProhibitAttributes(PrefixAttrs); |
742 | |
743 | Decl *DeclFromDeclSpec = nullptr; |
744 | Decl *AD = ParseAliasDeclarationAfterDeclarator( |
745 | TemplateInfo, UsingLoc, D, DeclEnd, AS, Attrs, &DeclFromDeclSpec); |
746 | return Actions.ConvertDeclToDeclGroup(AD, DeclFromDeclSpec); |
747 | } |
748 | |
749 | DiagnoseCXX11AttributeExtension(PrefixAttrs); |
750 | |
751 | |
752 | |
753 | |
754 | if (TemplateInfo.Kind) { |
755 | SourceRange R = TemplateInfo.getSourceRange(); |
756 | Diag(UsingLoc, diag::err_templated_using_directive_declaration) |
757 | << 1 << R << FixItHint::CreateRemoval(R); |
758 | |
759 | |
760 | |
761 | |
762 | return nullptr; |
763 | } |
764 | |
765 | SmallVector<Decl *, 8> DeclsInGroup; |
766 | while (true) { |
767 | |
768 | MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs); |
769 | DiagnoseCXX11AttributeExtension(Attrs); |
770 | Attrs.addAll(PrefixAttrs.begin(), PrefixAttrs.end()); |
771 | |
772 | if (InvalidDeclarator) |
773 | SkipUntil(tok::comma, tok::semi, StopBeforeMatch); |
774 | else { |
775 | |
776 | |
777 | if (D.TypenameLoc.isValid() && |
778 | D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) { |
779 | Diag(D.Name.getSourceRange().getBegin(), |
780 | diag::err_typename_identifiers_only) |
781 | << FixItHint::CreateRemoval(SourceRange(D.TypenameLoc)); |
782 | |
783 | D.TypenameLoc = SourceLocation(); |
784 | } |
785 | |
786 | Decl *UD = Actions.ActOnUsingDeclaration(getCurScope(), AS, UsingLoc, |
787 | D.TypenameLoc, D.SS, D.Name, |
788 | D.EllipsisLoc, Attrs); |
789 | if (UD) |
790 | DeclsInGroup.push_back(UD); |
791 | } |
792 | |
793 | if (!TryConsumeToken(tok::comma)) |
794 | break; |
795 | |
796 | |
797 | Attrs.clear(); |
798 | InvalidDeclarator = ParseUsingDeclarator(Context, D); |
799 | } |
800 | |
801 | if (DeclsInGroup.size() > 1) |
802 | Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? |
803 | diag::warn_cxx17_compat_multi_using_declaration : |
804 | diag::ext_multi_using_declaration); |
805 | |
806 | |
807 | DeclEnd = Tok.getLocation(); |
808 | if (ExpectAndConsume(tok::semi, diag::err_expected_after, |
809 | !Attrs.empty() ? "attributes list" |
810 | : UELoc.isValid() ? "using-enum declaration" |
811 | : "using declaration")) |
812 | SkipUntil(tok::semi); |
813 | |
814 | return Actions.BuildDeclaratorGroup(DeclsInGroup); |
815 | } |
816 | |
817 | Decl *Parser::ParseAliasDeclarationAfterDeclarator( |
818 | const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, |
819 | UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, |
820 | ParsedAttributes &Attrs, Decl **OwnedType) { |
821 | if (ExpectAndConsume(tok::equal)) { |
822 | SkipUntil(tok::semi); |
823 | return nullptr; |
824 | } |
825 | |
826 | Diag(Tok.getLocation(), getLangOpts().CPlusPlus11 ? |
827 | diag::warn_cxx98_compat_alias_declaration : |
828 | diag::ext_alias_declaration); |
829 | |
830 | |
831 | int SpecKind = -1; |
832 | if (TemplateInfo.Kind == ParsedTemplateInfo::Template && |
833 | D.Name.getKind() == UnqualifiedIdKind::IK_TemplateId) |
834 | SpecKind = 0; |
835 | if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization) |
836 | SpecKind = 1; |
837 | if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) |
838 | SpecKind = 2; |
839 | if (SpecKind != -1) { |
840 | SourceRange Range; |
841 | if (SpecKind == 0) |
842 | Range = SourceRange(D.Name.TemplateId->LAngleLoc, |
843 | D.Name.TemplateId->RAngleLoc); |
844 | else |
845 | Range = TemplateInfo.getSourceRange(); |
846 | Diag(Range.getBegin(), diag::err_alias_declaration_specialization) |
847 | << SpecKind << Range; |
848 | SkipUntil(tok::semi); |
849 | return nullptr; |
850 | } |
851 | |
852 | |
853 | if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) { |
854 | Diag(D.Name.StartLocation, diag::err_alias_declaration_not_identifier); |
855 | |
856 | SkipUntil(tok::semi); |
857 | return nullptr; |
858 | } else if (D.TypenameLoc.isValid()) |
859 | Diag(D.TypenameLoc, diag::err_alias_declaration_not_identifier) |
860 | << FixItHint::CreateRemoval(SourceRange( |
861 | D.TypenameLoc, |
862 | D.SS.isNotEmpty() ? D.SS.getEndLoc() : D.TypenameLoc)); |
863 | else if (D.SS.isNotEmpty()) |
864 | Diag(D.SS.getBeginLoc(), diag::err_alias_declaration_not_identifier) |
865 | << FixItHint::CreateRemoval(D.SS.getRange()); |
866 | if (D.EllipsisLoc.isValid()) |
867 | Diag(D.EllipsisLoc, diag::err_alias_declaration_pack_expansion) |
868 | << FixItHint::CreateRemoval(SourceRange(D.EllipsisLoc)); |
869 | |
870 | Decl *DeclFromDeclSpec = nullptr; |
871 | TypeResult TypeAlias = |
872 | ParseTypeName(nullptr, |
873 | TemplateInfo.Kind ? DeclaratorContext::AliasTemplate |
874 | : DeclaratorContext::AliasDecl, |
875 | AS, &DeclFromDeclSpec, &Attrs); |
876 | if (OwnedType) |
877 | *OwnedType = DeclFromDeclSpec; |
878 | |
879 | |
880 | DeclEnd = Tok.getLocation(); |
881 | if (ExpectAndConsume(tok::semi, diag::err_expected_after, |
882 | !Attrs.empty() ? "attributes list" |
883 | : "alias declaration")) |
884 | SkipUntil(tok::semi); |
885 | |
886 | TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams; |
887 | MultiTemplateParamsArg TemplateParamsArg( |
888 | TemplateParams ? TemplateParams->data() : nullptr, |
889 | TemplateParams ? TemplateParams->size() : 0); |
890 | return Actions.ActOnAliasDeclaration(getCurScope(), AS, TemplateParamsArg, |
891 | UsingLoc, D.Name, Attrs, TypeAlias, |
892 | DeclFromDeclSpec); |
893 | } |
894 | |
895 | static FixItHint getStaticAssertNoMessageFixIt(const Expr *AssertExpr, |
896 | SourceLocation EndExprLoc) { |
897 | if (const auto *BO = dyn_cast_or_null<BinaryOperator>(AssertExpr)) { |
898 | if (BO->getOpcode() == BO_LAnd && |
899 | isa<StringLiteral>(BO->getRHS()->IgnoreImpCasts())) |
900 | return FixItHint::CreateReplacement(BO->getOperatorLoc(), ","); |
901 | } |
902 | return FixItHint::CreateInsertion(EndExprLoc, ", \"\""); |
903 | } |
904 | |
905 | |
906 | |
907 | |
908 | |
909 | |
910 | |
911 | |
912 | |
913 | Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){ |
914 | assert(Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert) && |
915 | "Not a static_assert declaration"); |
916 | |
917 | if (Tok.is(tok::kw__Static_assert) && !getLangOpts().C11) |
918 | Diag(Tok, diag::ext_c11_feature) << Tok.getName(); |
919 | if (Tok.is(tok::kw_static_assert)) { |
920 | if (!getLangOpts().CPlusPlus) |
921 | Diag(Tok, diag::ext_ms_static_assert) |
922 | << FixItHint::CreateReplacement(Tok.getLocation(), "_Static_assert"); |
923 | else |
924 | Diag(Tok, diag::warn_cxx98_compat_static_assert); |
925 | } |
926 | |
927 | SourceLocation StaticAssertLoc = ConsumeToken(); |
928 | |
929 | BalancedDelimiterTracker T(*this, tok::l_paren); |
930 | if (T.consumeOpen()) { |
931 | Diag(Tok, diag::err_expected) << tok::l_paren; |
932 | SkipMalformedDecl(); |
933 | return nullptr; |
934 | } |
935 | |
936 | EnterExpressionEvaluationContext ConstantEvaluated( |
937 | Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
938 | ExprResult AssertExpr(ParseConstantExpressionInExprEvalContext()); |
939 | if (AssertExpr.isInvalid()) { |
940 | SkipMalformedDecl(); |
941 | return nullptr; |
942 | } |
943 | |
944 | ExprResult AssertMessage; |
945 | if (Tok.is(tok::r_paren)) { |
946 | unsigned DiagVal; |
947 | if (getLangOpts().CPlusPlus17) |
948 | DiagVal = diag::warn_cxx14_compat_static_assert_no_message; |
949 | else if (getLangOpts().CPlusPlus) |
950 | DiagVal = diag::ext_cxx_static_assert_no_message; |
951 | else if (getLangOpts().C2x) |
952 | DiagVal = diag::warn_c17_compat_static_assert_no_message; |
953 | else |
954 | DiagVal = diag::ext_c_static_assert_no_message; |
955 | Diag(Tok, DiagVal) << getStaticAssertNoMessageFixIt(AssertExpr.get(), |
956 | Tok.getLocation()); |
957 | } else { |
958 | if (ExpectAndConsume(tok::comma)) { |
959 | SkipUntil(tok::semi); |
960 | return nullptr; |
961 | } |
962 | |
963 | if (!isTokenStringLiteral()) { |
964 | Diag(Tok, diag::err_expected_string_literal) |
965 | << 1; |
966 | SkipMalformedDecl(); |
967 | return nullptr; |
968 | } |
969 | |
970 | AssertMessage = ParseStringLiteralExpression(); |
971 | if (AssertMessage.isInvalid()) { |
972 | SkipMalformedDecl(); |
973 | return nullptr; |
974 | } |
975 | } |
976 | |
977 | T.consumeClose(); |
978 | |
979 | DeclEnd = Tok.getLocation(); |
980 | ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert); |
981 | |
982 | return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc, |
983 | AssertExpr.get(), |
984 | AssertMessage.get(), |
985 | T.getCloseLocation()); |
986 | } |
987 | |
988 | |
989 | |
990 | |
991 | |
992 | |
993 | SourceLocation Parser::ParseDecltypeSpecifier(DeclSpec &DS) { |
994 | assert(Tok.isOneOf(tok::kw_decltype, tok::annot_decltype) |
995 | && "Not a decltype specifier"); |
996 | |
997 | ExprResult Result; |
998 | SourceLocation StartLoc = Tok.getLocation(); |
999 | SourceLocation EndLoc; |
1000 | |
1001 | if (Tok.is(tok::annot_decltype)) { |
1002 | Result = getExprAnnotation(Tok); |
1003 | EndLoc = Tok.getAnnotationEndLoc(); |
1004 | ConsumeAnnotationToken(); |
1005 | if (Result.isInvalid()) { |
1006 | DS.SetTypeSpecError(); |
1007 | return EndLoc; |
1008 | } |
1009 | } else { |
1010 | if (Tok.getIdentifierInfo()->isStr("decltype")) |
1011 | Diag(Tok, diag::warn_cxx98_compat_decltype); |
1012 | |
1013 | ConsumeToken(); |
1014 | |
1015 | BalancedDelimiterTracker T(*this, tok::l_paren); |
1016 | if (T.expectAndConsume(diag::err_expected_lparen_after, |
1017 | "decltype", tok::r_paren)) { |
1018 | DS.SetTypeSpecError(); |
1019 | return T.getOpenLocation() == Tok.getLocation() ? |
1020 | StartLoc : T.getOpenLocation(); |
1021 | } |
1022 | |
1023 | |
1024 | if (Tok.is(tok::kw_auto)) { |
1025 | |
1026 | |
1027 | |
1028 | Diag(Tok.getLocation(), |
1029 | getLangOpts().CPlusPlus14 |
1030 | ? diag::warn_cxx11_compat_decltype_auto_type_specifier |
1031 | : diag::ext_decltype_auto_type_specifier); |
1032 | ConsumeToken(); |
1033 | } else { |
1034 | |
1035 | |
1036 | |
1037 | |
1038 | EnterExpressionEvaluationContext Unevaluated( |
1039 | Actions, Sema::ExpressionEvaluationContext::Unevaluated, nullptr, |
1040 | Sema::ExpressionEvaluationContextRecord::EK_Decltype); |
1041 | Result = Actions.CorrectDelayedTyposInExpr( |
1042 | ParseExpression(), nullptr, |
1043 | false, |
1044 | [](Expr *E) { return E->hasPlaceholderType() ? ExprError() : E; }); |
1045 | if (Result.isInvalid()) { |
1046 | DS.SetTypeSpecError(); |
1047 | if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch)) { |
1048 | EndLoc = ConsumeParen(); |
1049 | } else { |
1050 | if (PP.isBacktrackEnabled() && Tok.is(tok::semi)) { |
1051 | |
1052 | PP.RevertCachedTokens(2); |
1053 | ConsumeToken(); |
1054 | EndLoc = ConsumeAnyToken(); |
1055 | assert(Tok.is(tok::semi)); |
1056 | } else { |
1057 | EndLoc = Tok.getLocation(); |
1058 | } |
1059 | } |
1060 | return EndLoc; |
1061 | } |
1062 | |
1063 | Result = Actions.ActOnDecltypeExpression(Result.get()); |
1064 | } |
1065 | |
1066 | |
1067 | T.consumeClose(); |
1068 | if (T.getCloseLocation().isInvalid()) { |
1069 | DS.SetTypeSpecError(); |
1070 | |
1071 | |
1072 | return T.getCloseLocation(); |
1073 | } |
1074 | |
1075 | if (Result.isInvalid()) { |
1076 | DS.SetTypeSpecError(); |
1077 | return T.getCloseLocation(); |
1078 | } |
1079 | |
1080 | EndLoc = T.getCloseLocation(); |
1081 | } |
1082 | assert(!Result.isInvalid()); |
1083 | |
1084 | const char *PrevSpec = nullptr; |
1085 | unsigned DiagID; |
1086 | const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy(); |
1087 | |
1088 | if (Result.get() |
1089 | ? DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec, |
1090 | DiagID, Result.get(), Policy) |
1091 | : DS.SetTypeSpecType(DeclSpec::TST_decltype_auto, StartLoc, PrevSpec, |
1092 | DiagID, Policy)) { |
1093 | Diag(StartLoc, DiagID) << PrevSpec; |
1094 | DS.SetTypeSpecError(); |
1095 | } |
1096 | return EndLoc; |
1097 | } |
1098 | |
1099 | void Parser::AnnotateExistingDecltypeSpecifier(const DeclSpec& DS, |
1100 | SourceLocation StartLoc, |
1101 | SourceLocation EndLoc) { |
1102 | |
1103 | if (PP.isBacktrackEnabled()) { |
1104 | PP.RevertCachedTokens(1); |
1105 | if (DS.getTypeSpecType() == TST_error) { |
1106 | |
1107 | |
1108 | |
1109 | |
1110 | EndLoc = PP.getLastCachedTokenLocation(); |
1111 | } |
1112 | } |
1113 | else |
1114 | PP.EnterToken(Tok, true); |
1115 | |
1116 | Tok.setKind(tok::annot_decltype); |
1117 | setExprAnnotation(Tok, |
1118 | DS.getTypeSpecType() == TST_decltype ? DS.getRepAsExpr() : |
1119 | DS.getTypeSpecType() == TST_decltype_auto ? ExprResult() : |
1120 | ExprError()); |
1121 | Tok.setAnnotationEndLoc(EndLoc); |
1122 | Tok.setLocation(StartLoc); |
1123 | PP.AnnotateCachedTokens(Tok); |
1124 | } |
1125 | |
1126 | void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) { |
1127 | assert(Tok.is(tok::kw___underlying_type) && |
1128 | "Not an underlying type specifier"); |
1129 | |
1130 | SourceLocation StartLoc = ConsumeToken(); |
1131 | BalancedDelimiterTracker T(*this, tok::l_paren); |
1132 | if (T.expectAndConsume(diag::err_expected_lparen_after, |
1133 | "__underlying_type", tok::r_paren)) { |
1134 | return; |
1135 | } |
1136 | |
1137 | TypeResult Result = ParseTypeName(); |
1138 | if (Result.isInvalid()) { |
1139 | SkipUntil(tok::r_paren, StopAtSemi); |
1140 | return; |
1141 | } |
1142 | |
1143 | |
1144 | T.consumeClose(); |
1145 | if (T.getCloseLocation().isInvalid()) |
1146 | return; |
1147 | |
1148 | const char *PrevSpec = nullptr; |
1149 | unsigned DiagID; |
1150 | if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec, |
1151 | DiagID, Result.get(), |
1152 | Actions.getASTContext().getPrintingPolicy())) |
1153 | Diag(StartLoc, DiagID) << PrevSpec; |
1154 | DS.setTypeofParensRange(T.getRange()); |
1155 | } |
1156 | |
1157 | |
1158 | |
1159 | |
1160 | |
1161 | |
1162 | |
1163 | |
1164 | |
1165 | |
1166 | |
1167 | |
1168 | |
1169 | |
1170 | |
1171 | |
1172 | |
1173 | |
1174 | |
1175 | TypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc, |
1176 | SourceLocation &EndLocation) { |
1177 | |
1178 | if (Tok.is(tok::kw_typename)) { |
1179 | Diag(Tok, diag::err_expected_class_name_not_template) |
1180 | << FixItHint::CreateRemoval(Tok.getLocation()); |
1181 | ConsumeToken(); |
1182 | } |
1183 | |
1184 | |
1185 | CXXScopeSpec SS; |
1186 | if (ParseOptionalCXXScopeSpecifier(SS, nullptr, |
1187 | false, |
1188 | false)) |
1189 | return true; |
1190 | |
1191 | BaseLoc = Tok.getLocation(); |
1192 | |
1193 | |
1194 | |
1195 | |
1196 | if (Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) { |
1197 | if (SS.isNotEmpty()) |
1198 | Diag(SS.getBeginLoc(), diag::err_unexpected_scope_on_base_decltype) |
1199 | << FixItHint::CreateRemoval(SS.getRange()); |
1200 | |
1201 | DeclSpec DS(AttrFactory); |
1202 | |
1203 | EndLocation = ParseDecltypeSpecifier(DS); |
1204 | |
1205 | Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName); |
1206 | return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); |
1207 | } |
1208 | |
1209 | |
1210 | if (Tok.is(tok::annot_template_id)) { |
1211 | TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); |
1212 | if (TemplateId->mightBeType()) { |
1213 | AnnotateTemplateIdTokenAsType(SS, true); |
1214 | |
1215 | assert(Tok.is(tok::annot_typename) && "template-id -> type failed"); |
1216 | TypeResult Type = getTypeAnnotation(Tok); |
1217 | EndLocation = Tok.getAnnotationEndLoc(); |
1218 | ConsumeAnnotationToken(); |
1219 | return Type; |
1220 | } |
1221 | |
1222 | |
1223 | } |
1224 | |
1225 | if (Tok.isNot(tok::identifier)) { |
1226 | Diag(Tok, diag::err_expected_class_name); |
1227 | return true; |
1228 | } |
1229 | |
1230 | IdentifierInfo *Id = Tok.getIdentifierInfo(); |
1231 | SourceLocation IdLoc = ConsumeToken(); |
1232 | |
1233 | if (Tok.is(tok::less)) { |
1234 | |
1235 | |
1236 | |
1237 | |
1238 | TemplateNameKind TNK = TNK_Non_template; |
1239 | TemplateTy Template; |
1240 | if (!Actions.DiagnoseUnknownTemplateName(*Id, IdLoc, getCurScope(), |
1241 | &SS, Template, TNK)) { |
1242 | Diag(IdLoc, diag::err_unknown_template_name) |
1243 | << Id; |
1244 | } |
1245 | |
1246 | |
1247 | UnqualifiedId TemplateName; |
1248 | TemplateName.setIdentifier(Id, IdLoc); |
1249 | |
1250 | |
1251 | if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), |
1252 | TemplateName)) |
1253 | return true; |
1254 | if (Tok.is(tok::annot_template_id) && |
1255 | takeTemplateIdAnnotation(Tok)->mightBeType()) |
1256 | AnnotateTemplateIdTokenAsType(SS, true); |
1257 | |
1258 | |
1259 | |
1260 | if (Tok.isNot(tok::annot_typename)) |
1261 | return true; |
1262 | |
1263 | |
1264 | |
1265 | EndLocation = Tok.getAnnotationEndLoc(); |
1266 | TypeResult Type = getTypeAnnotation(Tok); |
1267 | ConsumeAnnotationToken(); |
1268 | return Type; |
1269 | } |
1270 | |
1271 | |
1272 | IdentifierInfo *CorrectedII = nullptr; |
1273 | ParsedType Type = Actions.getTypeName( |
1274 | *Id, IdLoc, getCurScope(), &SS, true, false, nullptr, |
1275 | false, |
1276 | true, |
1277 | false, &CorrectedII); |
1278 | if (!Type) { |
1279 | Diag(IdLoc, diag::err_expected_class_name); |
1280 | return true; |
1281 | } |
1282 | |
1283 | |
1284 | EndLocation = IdLoc; |
1285 | |
1286 | |
1287 | DeclSpec DS(AttrFactory); |
1288 | DS.SetRangeStart(IdLoc); |
1289 | DS.SetRangeEnd(EndLocation); |
1290 | DS.getTypeSpecScope() = SS; |
1291 | |
1292 | const char *PrevSpec = nullptr; |
1293 | unsigned DiagID; |
1294 | DS.SetTypeSpecType(TST_typename, IdLoc, PrevSpec, DiagID, Type, |
1295 | Actions.getASTContext().getPrintingPolicy()); |
1296 | |
1297 | Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName); |
1298 | return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); |
1299 | } |
1300 | |
1301 | void Parser::ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs) { |
1302 | while (Tok.isOneOf(tok::kw___single_inheritance, |
1303 | tok::kw___multiple_inheritance, |
1304 | tok::kw___virtual_inheritance)) { |
1305 | IdentifierInfo *AttrName = Tok.getIdentifierInfo(); |
1306 | SourceLocation AttrNameLoc = ConsumeToken(); |
1307 | attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, |
1308 | ParsedAttr::AS_Keyword); |
1309 | } |
1310 | } |
1311 | |
1312 | |
1313 | |
1314 | |
1315 | bool Parser::isValidAfterTypeSpecifier(bool CouldBeBitfield) { |
1316 | |
1317 | switch (Tok.getKind()) { |
1318 | default: break; |
1319 | case tok::semi: |
1320 | case tok::star: |
1321 | case tok::amp: |
1322 | case tok::ampamp: |
1323 | case tok::identifier: |
1324 | case tok::r_paren: |
1325 | case tok::coloncolon: |
1326 | case tok::annot_cxxscope: |
1327 | case tok::annot_typename: |
1328 | case tok::annot_template_id: |
1329 | case tok::kw_decltype: |
1330 | case tok::l_paren: |
1331 | case tok::comma: |
1332 | case tok::kw_operator: |
1333 | case tok::kw___declspec: |
1334 | case tok::l_square: |
1335 | case tok::ellipsis: |
1336 | |
1337 | |
1338 | case tok::kw___attribute: |
1339 | case tok::annot_pragma_pack: |
1340 | |
1341 | case tok::annot_pragma_ms_pragma: |
1342 | |
1343 | case tok::annot_pragma_ms_vtordisp: |
1344 | |
1345 | case tok::annot_pragma_ms_pointers_to_members: |
1346 | return true; |
1347 | case tok::colon: |
1348 | return CouldBeBitfield || |
1349 | ColonIsSacred; |
1350 | |
1351 | case tok::kw___cdecl: |
1352 | case tok::kw___fastcall: |
1353 | case tok::kw___stdcall: |
1354 | case tok::kw___thiscall: |
1355 | case tok::kw___vectorcall: |
1356 | |
1357 | |
1358 | return getLangOpts().MicrosoftExt; |
1359 | |
1360 | case tok::kw_const: |
1361 | case tok::kw_volatile: |
1362 | case tok::kw_restrict: |
1363 | case tok::kw__Atomic: |
1364 | case tok::kw___unaligned: |
1365 | |
1366 | |
1367 | |
1368 | case tok::kw_inline: |
1369 | case tok::kw_virtual: |
1370 | case tok::kw_friend: |
1371 | |
1372 | case tok::kw_static: |
1373 | case tok::kw_extern: |
1374 | case tok::kw_typedef: |
1375 | case tok::kw_register: |
1376 | case tok::kw_auto: |
1377 | case tok::kw_mutable: |
1378 | case tok::kw_thread_local: |
1379 | case tok::kw_constexpr: |
1380 | case tok::kw_consteval: |
1381 | case tok::kw_constinit: |
1382 | |
1383 | |
1384 | |
1385 | |
1386 | |
1387 | |
1388 | |
1389 | |
1390 | |
1391 | |
1392 | |
1393 | |
1394 | |
1395 | |
1396 | |
1397 | if (!isKnownToBeTypeSpecifier(NextToken())) |
1398 | return true; |
1399 | break; |
1400 | case tok::r_brace: |
1401 | |
1402 | if (!getLangOpts().CPlusPlus) |
1403 | return true; |
1404 | break; |
1405 | case tok::greater: |
1406 | |
1407 | return getLangOpts().CPlusPlus; |
1408 | } |
1409 | return false; |
1410 | } |
1411 | |
1412 | |
1413 | |
1414 | |
1415 | |
1416 | |
1417 | |
1418 | |
1419 | |
1420 | |
1421 | |
1422 | |
1423 | |
1424 | |
1425 | |
1426 | |
1427 | |
1428 | |
1429 | |
1430 | |
1431 | |
1432 | |
1433 | |
1434 | |
1435 | |
1436 | |
1437 | |
1438 | |
1439 | |
1440 | |
1441 | |
1442 | |
1443 | |
1444 | |
1445 | |
1446 | |
1447 | |
1448 | |
1449 | |
1450 | |
1451 | |
1452 | void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, |
1453 | SourceLocation StartLoc, DeclSpec &DS, |
1454 | const ParsedTemplateInfo &TemplateInfo, |
1455 | AccessSpecifier AS, |
1456 | bool EnteringContext, DeclSpecContext DSC, |
1457 | ParsedAttributesWithRange &Attributes) { |
1458 | DeclSpec::TST TagType; |
1459 | if (TagTokKind == tok::kw_struct) |
1460 | TagType = DeclSpec::TST_struct; |
1461 | else if (TagTokKind == tok::kw___interface) |
1462 | TagType = DeclSpec::TST_interface; |
1463 | else if (TagTokKind == tok::kw_class) |
1464 | TagType = DeclSpec::TST_class; |
1465 | else { |
1466 | assert(TagTokKind == tok::kw_union && "Not a class specifier"); |
1467 | TagType = DeclSpec::TST_union; |
1468 | } |
1469 | |
1470 | if (Tok.is(tok::code_completion)) { |
1471 | |
1472 | cutOffParsing(); |
1473 | Actions.CodeCompleteTag(getCurScope(), TagType); |
1474 | return; |
1475 | } |
1476 | |
1477 | |
1478 | |
1479 | |
1480 | |
1481 | |
1482 | |
1483 | |
1484 | const bool shouldDelayDiagsInTag = |
1485 | (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate); |
1486 | SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag); |
1487 | |
1488 | ParsedAttributesWithRange attrs(AttrFactory); |
1489 | |
1490 | MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs); |
1491 | |
1492 | |
1493 | if (Tok.isOneOf(tok::kw___single_inheritance, |
1494 | tok::kw___multiple_inheritance, |
1495 | tok::kw___virtual_inheritance)) |
1496 | ParseMicrosoftInheritanceClassAttributes(attrs); |
1497 | |
1498 | |
1499 | MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs); |
1500 | |
1501 | |
1502 | |
1503 | SourceLocation AttrFixitLoc = Tok.getLocation(); |
1504 | |
1505 | if (TagType == DeclSpec::TST_struct && |
1506 | Tok.isNot(tok::identifier) && |
1507 | !Tok.isAnnotation() && |
1508 | Tok.getIdentifierInfo() && |
1509 | Tok.isOneOf(tok::kw___is_abstract, |
1510 | tok::kw___is_aggregate, |
1511 | tok::kw___is_arithmetic, |
1512 | tok::kw___is_array, |
1513 | tok::kw___is_assignable, |
1514 | tok::kw___is_base_of, |
1515 | tok::kw___is_class, |
1516 | tok::kw___is_complete_type, |
1517 | tok::kw___is_compound, |
1518 | tok::kw___is_const, |
1519 | tok::kw___is_constructible, |
1520 | tok::kw___is_convertible, |
1521 | tok::kw___is_convertible_to, |
1522 | tok::kw___is_destructible, |
1523 | tok::kw___is_empty, |
1524 | tok::kw___is_enum, |
1525 | tok::kw___is_floating_point, |
1526 | tok::kw___is_final, |
1527 | tok::kw___is_function, |
1528 | tok::kw___is_fundamental, |
1529 | tok::kw___is_integral, |
1530 | tok::kw___is_interface_class, |
1531 | tok::kw___is_literal, |
1532 | tok::kw___is_lvalue_expr, |
1533 | tok::kw___is_lvalue_reference, |
1534 | tok::kw___is_member_function_pointer, |
1535 | tok::kw___is_member_object_pointer, |
1536 | tok::kw___is_member_pointer, |
1537 | tok::kw___is_nothrow_assignable, |
1538 | tok::kw___is_nothrow_constructible, |
1539 | tok::kw___is_nothrow_destructible, |
1540 | tok::kw___is_object, |
1541 | tok::kw___is_pod, |
1542 | tok::kw___is_pointer, |
1543 | tok::kw___is_polymorphic, |
1544 | tok::kw___is_reference, |
1545 | tok::kw___is_rvalue_expr, |
1546 | tok::kw___is_rvalue_reference, |
1547 | tok::kw___is_same, |
1548 | tok::kw___is_scalar, |
1549 | tok::kw___is_sealed, |
1550 | tok::kw___is_signed, |
1551 | tok::kw___is_standard_layout, |
1552 | tok::kw___is_trivial, |
1553 | tok::kw___is_trivially_assignable, |
1554 | tok::kw___is_trivially_constructible, |
1555 | tok::kw___is_trivially_copyable, |
1556 | tok::kw___is_union, |
1557 | tok::kw___is_unsigned, |
1558 | tok::kw___is_void, |
1559 | tok::kw___is_volatile)) |
1560 | |
1561 | |
1562 | |
1563 | |
1564 | |
1565 | TryKeywordIdentFallback(true); |
1566 | |
1567 | struct PreserveAtomicIdentifierInfoRAII { |
1568 | PreserveAtomicIdentifierInfoRAII(Token &Tok, bool Enabled) |
1569 | : AtomicII(nullptr) { |
1570 | if (!Enabled) |
1571 | return; |
1572 | assert(Tok.is(tok::kw__Atomic)); |
1573 | AtomicII = Tok.getIdentifierInfo(); |
1574 | AtomicII->revertTokenIDToIdentifier(); |
1575 | Tok.setKind(tok::identifier); |
1576 | } |
1577 | ~PreserveAtomicIdentifierInfoRAII() { |
1578 | if (!AtomicII) |
1579 | return; |
1580 | AtomicII->revertIdentifierToTokenID(tok::kw__Atomic); |
1581 | } |
1582 | IdentifierInfo *AtomicII; |
1583 | }; |
1584 | |
1585 | |
1586 | |
1587 | |
1588 | |
1589 | |
1590 | bool ShouldChangeAtomicToIdentifier = getLangOpts().MSVCCompat && |
1591 | Tok.is(tok::kw__Atomic) && |
1592 | TagType == DeclSpec::TST_struct; |
1593 | PreserveAtomicIdentifierInfoRAII AtomicTokenGuard( |
1594 | Tok, ShouldChangeAtomicToIdentifier); |
1595 | |
1596 | |
1597 | CXXScopeSpec &SS = DS.getTypeSpecScope(); |
1598 | if (getLangOpts().CPlusPlus) { |
1599 | |
1600 | |
1601 | ColonProtectionRAIIObject X(*this); |
1602 | |
1603 | CXXScopeSpec Spec; |
1604 | bool HasValidSpec = true; |
1605 | if (ParseOptionalCXXScopeSpecifier(Spec, nullptr, |
1606 | false, |
1607 | EnteringContext)) { |
1608 | DS.SetTypeSpecError(); |
1609 | HasValidSpec = false; |
1610 | } |
1611 | if (Spec.isSet()) |
1612 | if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id)) { |
1613 | Diag(Tok, diag::err_expected) << tok::identifier; |
1614 | HasValidSpec = false; |
1615 | } |
1616 | if (HasValidSpec) |
1617 | SS = Spec; |
1618 | } |
1619 | |
1620 | TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams; |
1621 | |
1622 | auto RecoverFromUndeclaredTemplateName = [&](IdentifierInfo *Name, |
1623 | SourceLocation NameLoc, |
1624 | SourceRange TemplateArgRange, |
1625 | bool KnownUndeclared) { |
1626 | Diag(NameLoc, diag::err_explicit_spec_non_template) |
1627 | << (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) |
1628 | << TagTokKind << Name << TemplateArgRange << KnownUndeclared; |
1629 | |
1630 | |
1631 | |
1632 | if (TemplateParams && TemplateInfo.LastParameterListWasEmpty) { |
1633 | if (TemplateParams->size() > 1) { |
1634 | TemplateParams->pop_back(); |
1635 | } else { |
1636 | TemplateParams = nullptr; |
1637 | const_cast<ParsedTemplateInfo &>(TemplateInfo).Kind = |
1638 | ParsedTemplateInfo::NonTemplate; |
1639 | } |
1640 | } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) { |
1641 | |
1642 | TemplateParams = nullptr; |
1643 | const_cast<ParsedTemplateInfo &>(TemplateInfo).Kind = |
1644 | ParsedTemplateInfo::NonTemplate; |
1645 | const_cast<ParsedTemplateInfo &>(TemplateInfo).TemplateLoc = |
1646 | SourceLocation(); |
1647 | const_cast<ParsedTemplateInfo &>(TemplateInfo).ExternLoc = |
1648 | SourceLocation(); |
1649 | } |
1650 | }; |
1651 | |
1652 | |
1653 | IdentifierInfo *Name = nullptr; |
1654 | SourceLocation NameLoc; |
1655 | TemplateIdAnnotation *TemplateId = nullptr; |
1656 | if (Tok.is(tok::identifier)) { |
1657 | Name = Tok.getIdentifierInfo(); |
1658 | NameLoc = ConsumeToken(); |
1659 | |
1660 | if (Tok.is(tok::less) && getLangOpts().CPlusPlus) { |
1661 | |
1662 | |
1663 | |
1664 | TemplateArgList TemplateArgs; |
1665 | SourceLocation LAngleLoc, RAngleLoc; |
1666 | if (ParseTemplateIdAfterTemplateName(true, LAngleLoc, TemplateArgs, |
1667 | RAngleLoc)) { |
1668 | |
1669 | |
1670 | LAngleLoc = RAngleLoc = SourceLocation(); |
1671 | } |
1672 | RecoverFromUndeclaredTemplateName( |
1673 | Name, NameLoc, SourceRange(LAngleLoc, RAngleLoc), false); |
1674 | } |
1675 | } else if (Tok.is(tok::annot_template_id)) { |
1676 | TemplateId = takeTemplateIdAnnotation(Tok); |
1677 | NameLoc = ConsumeAnnotationToken(); |
1678 | |
1679 | if (TemplateId->Kind == TNK_Undeclared_template) { |
1680 | |
1681 | Actions.ActOnUndeclaredTypeTemplateName( |
1682 | getCurScope(), TemplateId->Template, TemplateId->Kind, NameLoc, Name); |
1683 | if (TemplateId->Kind == TNK_Undeclared_template) { |
1684 | RecoverFromUndeclaredTemplateName( |
1685 | Name, NameLoc, |
1686 | SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc), true); |
1687 | TemplateId = nullptr; |
1688 | } |
1689 | } |
1690 | |
1691 | if (TemplateId && !TemplateId->mightBeType()) { |
1692 | |
1693 | |
1694 | |
1695 | SourceRange Range(NameLoc); |
1696 | if (SS.isNotEmpty()) |
1697 | Range.setBegin(SS.getBeginLoc()); |
1698 | |
1699 | |
1700 | Diag(TemplateId->LAngleLoc, diag::err_template_spec_syntax_non_template) |
1701 | << TemplateId->Name << static_cast<int>(TemplateId->Kind) << Range; |
1702 | |
1703 | DS.SetTypeSpecError(); |
1704 | SkipUntil(tok::semi, StopBeforeMatch); |
1705 | return; |
1706 | } |
1707 | } |
1708 | |
1709 | |
1710 | |
1711 | |
1712 | |
1713 | |
1714 | |
1715 | |
1716 | |
1717 | |
1718 | |
1719 | |
1720 | |
1721 | |
1722 | |
1723 | |
1724 | |
1725 | |
1726 | |
1727 | |
1728 | |
1729 | |
1730 | |
1731 | |
1732 | |
1733 | |
1734 | |
1735 | |
1736 | MaybeParseCXX11Attributes(Attributes); |
1737 | |
1738 | const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy(); |
1739 | Sema::TagUseKind TUK; |
1740 | if (isDefiningTypeSpecifierContext(DSC) == AllowDefiningTypeSpec::No || |
1741 | (getLangOpts().OpenMP && OpenMPDirectiveParsing)) |
1742 | TUK = Sema::TUK_Reference; |
1743 | else if (Tok.is(tok::l_brace) || |
1744 | (getLangOpts().CPlusPlus && Tok.is(tok::colon)) || |
1745 | (isClassCompatibleKeyword() && |
1746 | (NextToken().is(tok::l_brace) || NextToken().is(tok::colon)))) { |
1747 | if (DS.isFriendSpecified()) { |
1748 | |
1749 | |
1750 | Diag(Tok.getLocation(), diag::err_friend_decl_defines_type) |
1751 | << SourceRange(DS.getFriendSpecLoc()); |
1752 | |
1753 | |
1754 | |
1755 | SkipUntil(tok::semi, StopBeforeMatch); |
1756 | TUK = Sema::TUK_Friend; |
1757 | } else { |
1758 | |
1759 | TUK = Sema::TUK_Definition; |
1760 | } |
1761 | } else if (isClassCompatibleKeyword() && |
1762 | (NextToken().is(tok::l_square) || |
1763 | NextToken().is(tok::kw_alignas) || |
1764 | isCXX11VirtSpecifier(NextToken()) != VirtSpecifiers::VS_None)) { |
1765 | |
1766 | |
1767 | TentativeParsingAction PA(*this); |
1768 | |
1769 | |
1770 | while (isClassCompatibleKeyword()) { |
1771 | ConsumeToken(); |
1772 | } |
1773 | |
1774 | |
1775 | while (true) { |
1776 | if (Tok.is(tok::l_square) && NextToken().is(tok::l_square)) { |
1777 | ConsumeBracket(); |
1778 | if (!SkipUntil(tok::r_square, StopAtSemi)) |
1779 | break; |
1780 | } else if (Tok.is(tok::kw_alignas) && NextToken().is(tok::l_paren)) { |
1781 | ConsumeToken(); |
1782 | ConsumeParen(); |
1783 | if (!SkipUntil(tok::r_paren, StopAtSemi)) |
1784 | break; |
1785 | } else { |
1786 | break; |
1787 | } |
1788 | } |
1789 | |
1790 | if (Tok.isOneOf(tok::l_brace, tok::colon)) |
1791 | TUK = Sema::TUK_Definition; |
1792 | else |
1793 | TUK = Sema::TUK_Reference; |
1794 | |
1795 | PA.Revert(); |
1796 | } else if (!isTypeSpecifier(DSC) && |
1797 | (Tok.is(tok::semi) || |
1798 | (Tok.isAtStartOfLine() && !isValidAfterTypeSpecifier(false)))) { |
1799 | TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration; |
1800 | if (Tok.isNot(tok::semi)) { |
1801 | const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy(); |
1802 | |
1803 | ExpectAndConsume(tok::semi, diag::err_expected_after, |
1804 | DeclSpec::getSpecifierName(TagType, PPol)); |
1805 | PP.EnterToken(Tok, true); |
1806 | Tok.setKind(tok::semi); |
1807 | } |
1808 | } else |
1809 | TUK = Sema::TUK_Reference; |
1810 | |
1811 | |
1812 | |
1813 | if (TUK != Sema::TUK_Reference) { |
1814 | |
1815 | |
1816 | |
1817 | |
1818 | |
1819 | SourceRange AttrRange = Attributes.Range; |
1820 | if (AttrRange.isValid()) { |
1821 | Diag(AttrRange.getBegin(), diag::err_attributes_not_allowed) |
1822 | << AttrRange |
1823 | << FixItHint::CreateInsertionFromRange(AttrFixitLoc, |
1824 | CharSourceRange(AttrRange, true)) |
1825 | << FixItHint::CreateRemoval(AttrRange); |
1826 | |
1827 | |
1828 | |
1829 | attrs.takeAllFrom(Attributes); |
1830 | } |
1831 | } |
1832 | |
1833 | if (!Name && !TemplateId && (DS.getTypeSpecType() == DeclSpec::TST_error || |
1834 | TUK != Sema::TUK_Definition)) { |
1835 | if (DS.getTypeSpecType() != DeclSpec::TST_error) { |
1836 | |
1837 | Diag(StartLoc, diag::err_anon_type_definition) |
1838 | << DeclSpec::getSpecifierName(TagType, Policy); |
1839 | } |
1840 | |
1841 | |
1842 | |
1843 | |
1844 | if (TUK == Sema::TUK_Definition && Tok.is(tok::colon)) |
1845 | SkipUntil(tok::semi, StopBeforeMatch); |
1846 | else |
1847 | SkipUntil(tok::comma, StopAtSemi); |
1848 | return; |
1849 | } |
1850 | |
1851 | |
1852 | DeclResult TagOrTempResult = true; |
1853 | TypeResult TypeResult = true; |
1854 | |
1855 | bool Owned = false; |
1856 | Sema::SkipBodyInfo SkipBody; |
1857 | if (TemplateId) { |
1858 | |
1859 | |
1860 | ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), |
1861 | TemplateId->NumArgs); |
1862 | if (TemplateId->isInvalid()) { |
1863 | |
1864 | } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation && |
1865 | TUK == Sema::TUK_Declaration) { |
1866 | |
1867 | ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed, |
1868 | true); |
1869 | |
1870 | TagOrTempResult = Actions.ActOnExplicitInstantiation( |
1871 | getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc, |
1872 | TagType, StartLoc, SS, TemplateId->Template, |
1873 | TemplateId->TemplateNameLoc, TemplateId->LAngleLoc, TemplateArgsPtr, |
1874 | TemplateId->RAngleLoc, attrs); |
1875 | |
1876 | |
1877 | |
1878 | |
1879 | |
1880 | } else if (TUK == Sema::TUK_Reference || |
1881 | (TUK == Sema::TUK_Friend && |
1882 | TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) { |
1883 | ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed, |
1884 | true); |
1885 | TypeResult = Actions.ActOnTagTemplateIdType(TUK, TagType, StartLoc, |
1886 | SS, |
1887 | TemplateId->TemplateKWLoc, |
1888 | TemplateId->Template, |
1889 | TemplateId->TemplateNameLoc, |
1890 | TemplateId->LAngleLoc, |
1891 | TemplateArgsPtr, |
1892 | TemplateId->RAngleLoc); |
1893 | } else { |
1894 | |
1895 | |
1896 | TemplateParameterLists FakedParamLists; |
1897 | if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) { |
1898 | |
1899 | |
1900 | |
1901 | |
1902 | |
1903 | |
1904 | |
1905 | |
1906 | |
1907 | |
1908 | |
1909 | assert((TUK == Sema::TUK_Definition || TUK == Sema::TUK_Friend) && |
1910 | "Expected a definition here"); |
1911 | |
1912 | if (TUK == Sema::TUK_Friend) { |
1913 | Diag(DS.getFriendSpecLoc(), diag::err_friend_explicit_instantiation); |
1914 | TemplateParams = nullptr; |
1915 | } else { |
1916 | SourceLocation LAngleLoc = |
1917 | PP.getLocForEndOfToken(TemplateInfo.TemplateLoc); |
1918 | Diag(TemplateId->TemplateNameLoc, |
1919 | diag::err_explicit_instantiation_with_definition) |
1920 | << SourceRange(TemplateInfo.TemplateLoc) |
1921 | << FixItHint::CreateInsertion(LAngleLoc, "<>"); |
1922 | |
1923 | |
1924 | |
1925 | |
1926 | FakedParamLists.push_back(Actions.ActOnTemplateParameterList( |
1927 | 0, SourceLocation(), TemplateInfo.TemplateLoc, LAngleLoc, None, |
1928 | LAngleLoc, nullptr)); |
1929 | TemplateParams = &FakedParamLists; |
1930 | } |
1931 | } |
1932 | |
1933 | |
1934 | TagOrTempResult = Actions.ActOnClassTemplateSpecialization( |
1935 | getCurScope(), TagType, TUK, StartLoc, DS.getModulePrivateSpecLoc(), |
1936 | SS, *TemplateId, attrs, |
1937 | MultiTemplateParamsArg(TemplateParams ? &(*TemplateParams)[0] |
1938 | : nullptr, |
1939 | TemplateParams ? TemplateParams->size() : 0), |
1940 | &SkipBody); |
1941 | } |
1942 | } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation && |
1943 | TUK == Sema::TUK_Declaration) { |
1944 | |
1945 | |
1946 | |
1947 | |
1948 | |
1949 | ProhibitAttributes(attrs); |
1950 | |
1951 | TagOrTempResult = Actions.ActOnExplicitInstantiation( |
1952 | getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc, |
1953 | TagType, StartLoc, SS, Name, NameLoc, attrs); |
1954 | } else if (TUK == Sema::TUK_Friend && |
1955 | TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) { |
1956 | ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed, |
1957 | true); |
1958 | |
1959 | TagOrTempResult = Actions.ActOnTemplatedFriendTag( |
1960 | getCurScope(), DS.getFriendSpecLoc(), TagType, StartLoc, SS, Name, |
1961 | NameLoc, attrs, |
1962 | MultiTemplateParamsArg(TemplateParams ? &(*TemplateParams)[0] : nullptr, |
1963 | TemplateParams ? TemplateParams->size() : 0)); |
1964 | } else { |
1965 | if (TUK != Sema::TUK_Declaration && TUK != Sema::TUK_Definition) |
1966 | ProhibitCXX11Attributes(attrs, diag::err_attributes_not_allowed, |
1967 | true); |
1968 | |
1969 | if (TUK == Sema::TUK_Definition && |
1970 | TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) { |
1971 | |
1972 | |
1973 | Diag(Tok, diag::err_template_defn_explicit_instantiation) |
1974 | << 1 << FixItHint::CreateRemoval(TemplateInfo.TemplateLoc); |
1975 | TemplateParams = nullptr; |
1976 | } |
1977 | |
1978 | bool IsDependent = false; |
1979 | |
1980 | |
1981 | |
1982 | |
1983 | MultiTemplateParamsArg TParams; |
1984 | if (TUK != Sema::TUK_Reference && TemplateParams) |
1985 | TParams = |
1986 | MultiTemplateParamsArg(&(*TemplateParams)[0], TemplateParams->size()); |
1987 | |
1988 | stripTypeAttributesOffDeclSpec(attrs, DS, TUK); |
1989 | |
1990 | |
1991 | TagOrTempResult = Actions.ActOnTag( |
1992 | getCurScope(), TagType, TUK, StartLoc, SS, Name, NameLoc, attrs, AS, |
1993 | DS.getModulePrivateSpecLoc(), TParams, Owned, IsDependent, |
1994 | SourceLocation(), false, clang::TypeResult(), |
1995 | DSC == DeclSpecContext::DSC_type_specifier, |
1996 | DSC == DeclSpecContext::DSC_template_param || |
1997 | DSC == DeclSpecContext::DSC_template_type_arg, |
1998 | &SkipBody); |
1999 | |
2000 | |
2001 | |
2002 | if (IsDependent) { |
2003 | assert(TUK == Sema::TUK_Reference || TUK == Sema::TUK_Friend); |
2004 | TypeResult = Actions.ActOnDependentTag(getCurScope(), TagType, TUK, |
2005 | SS, Name, StartLoc, NameLoc); |
2006 | } |
2007 | } |
2008 | |
2009 | |
2010 | |
2011 | |
2012 | if (shouldDelayDiagsInTag) { |
2013 | diagsFromTag.done(); |
2014 | if (TUK == Sema::TUK_Reference && |
2015 | TemplateInfo.Kind == ParsedTemplateInfo::Template) |
2016 | diagsFromTag.redelay(); |
2017 | } |
2018 | |
2019 | |
2020 | if (TUK == Sema::TUK_Definition) { |
2021 | assert(Tok.is(tok::l_brace) || |
2022 | (getLangOpts().CPlusPlus && Tok.is(tok::colon)) || |
2023 | isClassCompatibleKeyword()); |
2024 | if (SkipBody.ShouldSkip) |
2025 | SkipCXXMemberSpecification(StartLoc, AttrFixitLoc, TagType, |
2026 | TagOrTempResult.get()); |
2027 | else if (getLangOpts().CPlusPlus) |
2028 | ParseCXXMemberSpecification(StartLoc, AttrFixitLoc, attrs, TagType, |
2029 | TagOrTempResult.get()); |
2030 | else { |
2031 | Decl *D = |
2032 | SkipBody.CheckSameAsPrevious ? SkipBody.New : TagOrTempResult.get(); |
2033 | |
2034 | ParseStructUnionBody(StartLoc, TagType, cast<RecordDecl>(D)); |
2035 | if (SkipBody.CheckSameAsPrevious && |
2036 | !Actions.ActOnDuplicateDefinition(DS, TagOrTempResult.get(), |
2037 | SkipBody)) { |
2038 | DS.SetTypeSpecError(); |
2039 | return; |
2040 | } |
2041 | } |
2042 | } |
2043 | |
2044 | if (!TagOrTempResult.isInvalid()) |
2045 | |
2046 | Actions.ProcessDeclAttributeDelayed(TagOrTempResult.get(), attrs); |
2047 | |
2048 | const char *PrevSpec = nullptr; |
2049 | unsigned DiagID; |
2050 | bool Result; |
2051 | if (!TypeResult.isInvalid()) { |
2052 | Result = DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, |
2053 | NameLoc.isValid() ? NameLoc : StartLoc, |
2054 | PrevSpec, DiagID, TypeResult.get(), Policy); |
2055 | } else if (!TagOrTempResult.isInvalid()) { |
2056 | Result = DS.SetTypeSpecType(TagType, StartLoc, |
2057 | NameLoc.isValid() ? NameLoc : StartLoc, |
2058 | PrevSpec, DiagID, TagOrTempResult.get(), Owned, |
2059 | Policy); |
2060 | } else { |
2061 | DS.SetTypeSpecError(); |
2062 | return; |
2063 | } |
2064 | |
2065 | if (Result) |
2066 | Diag(StartLoc, DiagID) << PrevSpec; |
2067 | |
2068 | |
2069 | |
2070 | |
2071 | |
2072 | |
2073 | |
2074 | |
2075 | |
2076 | |
2077 | |
2078 | |
2079 | |
2080 | if (TUK == Sema::TUK_Definition && |
2081 | (getLangOpts().CPlusPlus || !isTypeSpecifier(DSC)) && |
2082 | (TemplateInfo.Kind || !isValidAfterTypeSpecifier(false))) { |
2083 | if (Tok.isNot(tok::semi)) { |
2084 | const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy(); |
2085 | ExpectAndConsume(tok::semi, diag::err_expected_after, |
2086 | DeclSpec::getSpecifierName(TagType, PPol)); |
2087 | |
2088 | |
2089 | |
2090 | PP.EnterToken(Tok, true); |
2091 | Tok.setKind(tok::semi); |
2092 | } |
2093 | } |
2094 | } |
2095 | |
2096 | |
2097 | |
2098 | |
2099 | |
2100 | |
2101 | |
2102 | |
2103 | void Parser::ParseBaseClause(Decl *ClassDecl) { |
2104 | assert(Tok.is(tok::colon) && "Not a base clause"); |
2105 | ConsumeToken(); |
2106 | |
2107 | |
2108 | SmallVector<CXXBaseSpecifier *, 8> BaseInfo; |
2109 | |
2110 | while (true) { |
2111 | |
2112 | BaseResult Result = ParseBaseSpecifier(ClassDecl); |
2113 | if (Result.isInvalid()) { |
2114 | |
2115 | |
2116 | SkipUntil(tok::comma, tok::l_brace, StopAtSemi | StopBeforeMatch); |
2117 | } else { |
2118 | |
2119 | BaseInfo.push_back(Result.get()); |
2120 | } |
2121 | |
2122 | |
2123 | |
2124 | if (!TryConsumeToken(tok::comma)) |
2125 | break; |
2126 | } |
2127 | |
2128 | |
2129 | Actions.ActOnBaseSpecifiers(ClassDecl, BaseInfo); |
2130 | } |
2131 | |
2132 | |
2133 | |
2134 | |
2135 | |
2136 | |
2137 | |
2138 | |
2139 | |
2140 | |
2141 | |
2142 | |
2143 | BaseResult Parser::ParseBaseSpecifier(Decl *ClassDecl) { |
2144 | bool IsVirtual = false; |
2145 | SourceLocation StartLoc = Tok.getLocation(); |
2146 | |
2147 | ParsedAttributesWithRange Attributes(AttrFactory); |
2148 | MaybeParseCXX11Attributes(Attributes); |
2149 | |
2150 | |
2151 | if (TryConsumeToken(tok::kw_virtual)) |
2152 | IsVirtual = true; |
2153 | |
2154 | CheckMisplacedCXX11Attribute(Attributes, StartLoc); |
2155 | |
2156 | |
2157 | AccessSpecifier Access = getAccessSpecifierIfPresent(); |
2158 | if (Access != AS_none) |
2159 | ConsumeToken(); |
2160 | |
2161 | CheckMisplacedCXX11Attribute(Attributes, StartLoc); |
2162 | |
2163 | |
2164 | |
2165 | if (Tok.is(tok::kw_virtual)) { |
2166 | SourceLocation VirtualLoc = ConsumeToken(); |
2167 | if (IsVirtual) { |
2168 | |
2169 | Diag(VirtualLoc, diag::err_dup_virtual) |
2170 | << FixItHint::CreateRemoval(VirtualLoc); |
2171 | } |
2172 | |
2173 | IsVirtual = true; |
2174 | } |
2175 | |
2176 | CheckMisplacedCXX11Attribute(Attributes, StartLoc); |
2177 | |
2178 | |
2179 | |
2180 | |
2181 | |
2182 | |
2183 | |
2184 | if (getLangOpts().MSVCCompat && Tok.is(tok::kw__Atomic) && |
2185 | NextToken().is(tok::less)) |
2186 | Tok.setKind(tok::identifier); |
2187 | |
2188 | SourceLocation EndLocation; |
2189 | SourceLocation BaseLoc; |
2190 | TypeResult BaseType = ParseBaseTypeSpecifier(BaseLoc, EndLocation); |
2191 | if (BaseType.isInvalid()) |
2192 | return true; |
2193 | |
2194 | |
2195 | |
2196 | |
2197 | SourceLocation EllipsisLoc; |
2198 | TryConsumeToken(tok::ellipsis, EllipsisLoc); |
2199 | |
2200 | |
2201 | SourceRange Range(StartLoc, EndLocation); |
2202 | |
2203 | |
2204 | |
2205 | return Actions.ActOnBaseSpecifier(ClassDecl, Range, Attributes, IsVirtual, |
2206 | Access, BaseType.get(), BaseLoc, |
2207 | EllipsisLoc); |
2208 | } |
2209 | |
2210 | |
2211 | |
2212 | |
2213 | |
2214 | |
2215 | |
2216 | |
2217 | AccessSpecifier Parser::getAccessSpecifierIfPresent() const { |
2218 | switch (Tok.getKind()) { |
2219 | default: return AS_none; |
2220 | case tok::kw_private: return AS_private; |
2221 | case tok::kw_protected: return AS_protected; |
2222 | case tok::kw_public: return AS_public; |
2223 | } |
2224 | } |
2225 | |
2226 | |
2227 | |
2228 | |
2229 | |
2230 | void Parser::HandleMemberFunctionDeclDelays(Declarator& DeclaratorInfo, |
2231 | Decl *ThisDecl) { |
2232 | DeclaratorChunk::FunctionTypeInfo &FTI |
2233 | = DeclaratorInfo.getFunctionTypeInfo(); |
2234 | |
2235 | |
2236 | bool NeedLateParse = FTI.getExceptionSpecType() == EST_Unparsed; |
2237 | |
2238 | if (!NeedLateParse) { |
2239 | |
2240 | for (unsigned ParamIdx = 0; ParamIdx < FTI.NumParams; ++ParamIdx) { |
2241 | auto Param = cast<ParmVarDecl>(FTI.Params[ParamIdx].Param); |
2242 | if (Param->hasUnparsedDefaultArg()) { |
2243 | NeedLateParse = true; |
2244 | break; |
2245 | } |
2246 | } |
2247 | } |
2248 | |
2249 | if (NeedLateParse) { |
2250 | |
2251 | |
2252 | auto LateMethod = new LateParsedMethodDeclaration(this, ThisDecl); |
2253 | getCurrentClass().LateParsedDeclarations.push_back(LateMethod); |
2254 | |
2255 | |
2256 | |
2257 | |
2258 | LateMethod->DefaultArgs.reserve(FTI.NumParams); |
2259 | for (unsigned ParamIdx = 0; ParamIdx < FTI.NumParams; ++ParamIdx) |
2260 | LateMethod->DefaultArgs.push_back(LateParsedDefaultArgument( |
2261 | FTI.Params[ParamIdx].Param, |
2262 | std::move(FTI.Params[ParamIdx].DefaultArgTokens))); |
2263 | |
2264 | |
2265 | if (FTI.getExceptionSpecType() == EST_Unparsed) { |
2266 | LateMethod->ExceptionSpecTokens = FTI.ExceptionSpecTokens; |
2267 | FTI.ExceptionSpecTokens = nullptr; |
2268 | } |
2269 | } |
2270 | } |
2271 | |
2272 | |
2273 | |
2274 | |
2275 | |
2276 | |
2277 | |
2278 | |
2279 | VirtSpecifiers::Specifier Parser::isCXX11VirtSpecifier(const Token &Tok) const { |
2280 | if (!getLangOpts().CPlusPlus || Tok.isNot(tok::identifier)) |
2281 | return VirtSpecifiers::VS_None; |
2282 | |
2283 | IdentifierInfo *II = Tok.getIdentifierInfo(); |
2284 | |
2285 | |
2286 | if (!Ident_final) { |
2287 | Ident_final = &PP.getIdentifierTable().get("final"); |
2288 | if (getLangOpts().GNUKeywords) |
2289 | Ident_GNU_final = &PP.getIdentifierTable().get("__final"); |
2290 | if (getLangOpts().MicrosoftExt) { |
2291 | Ident_sealed = &PP.getIdentifierTable().get("sealed"); |
2292 | Ident_abstract = &PP.getIdentifierTable().get("abstract"); |
2293 | } |
2294 | Ident_override = &PP.getIdentifierTable().get("override"); |
2295 | } |
2296 | |
2297 | if (II == Ident_override) |
2298 | return VirtSpecifiers::VS_Override; |
2299 | |
2300 | if (II == Ident_sealed) |
2301 | return VirtSpecifiers::VS_Sealed; |
2302 | |
2303 | if (II == Ident_abstract) |
2304 | return VirtSpecifiers::VS_Abstract; |
2305 | |
2306 | if (II == Ident_final) |
2307 | return VirtSpecifiers::VS_Final; |
2308 | |
2309 | if (II == Ident_GNU_final) |
2310 | return VirtSpecifiers::VS_GNU_Final; |
2311 | |
2312 | return VirtSpecifiers::VS_None; |
2313 | } |
2314 | |
2315 | |
2316 | |
2317 | |
2318 | |
2319 | |
2320 | void Parser::ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS, |
2321 | bool IsInterface, |
2322 | SourceLocation FriendLoc) { |
2323 | while (true) { |
2324 | VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier(); |
2325 | if (Specifier == VirtSpecifiers::VS_None) |
2326 | return; |
2327 | |
2328 | if (FriendLoc.isValid()) { |
2329 | Diag(Tok.getLocation(), diag::err_friend_decl_spec) |
2330 | << VirtSpecifiers::getSpecifierName(Specifier) |
2331 | << FixItHint::CreateRemoval(Tok.getLocation()) |
2332 | << SourceRange(FriendLoc, FriendLoc); |
2333 | ConsumeToken(); |
2334 | continue; |
2335 | } |
2336 | |
2337 | |
2338 | |
2339 | const char *PrevSpec = nullptr; |
2340 | if (VS.SetSpecifier(Specifier, Tok.getLocation(), PrevSpec)) |
2341 | Diag(Tok.getLocation(), diag::err_duplicate_virt_specifier) |
2342 | << PrevSpec |
2343 | << FixItHint::CreateRemoval(Tok.getLocation()); |
2344 | |
2345 | if (IsInterface && (Specifier == VirtSpecifiers::VS_Final || |
2346 | Specifier == VirtSpecifiers::VS_Sealed)) { |
2347 | Diag(Tok.getLocation(), diag::err_override_control_interface) |
2348 | << VirtSpecifiers::getSpecifierName(Specifier); |
2349 | } else if (Specifier == VirtSpecifiers::VS_Sealed) { |
2350 | Diag(Tok.getLocation(), diag::ext_ms_sealed_keyword); |
2351 | } else if (Specifier == VirtSpecifiers::VS_Abstract) { |
2352 | Diag(Tok.getLocation(), diag::ext_ms_abstract_keyword); |
2353 | } else if (Specifier == VirtSpecifiers::VS_GNU_Final) { |
2354 | Diag(Tok.getLocation(), diag::ext_warn_gnu_final); |
2355 | } else { |
2356 | Diag(Tok.getLocation(), |
2357 | getLangOpts().CPlusPlus11 |
2358 | ? diag::warn_cxx98_compat_override_control_keyword |
2359 | : diag::ext_override_control_keyword) |
2360 | << VirtSpecifiers::getSpecifierName(Specifier); |
2361 | } |
2362 | ConsumeToken(); |
2363 | } |
2364 | } |
2365 | |
2366 | |
2367 | |
2368 | bool Parser::isCXX11FinalKeyword() const { |
2369 | VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier(); |
2370 | return Specifier == VirtSpecifiers::VS_Final || |
2371 | Specifier == VirtSpecifiers::VS_GNU_Final || |
2372 | Specifier == VirtSpecifiers::VS_Sealed; |
2373 | } |
2374 | |
2375 | |
2376 | |
2377 | bool Parser::isClassCompatibleKeyword() const { |
2378 | VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier(); |
2379 | return Specifier == VirtSpecifiers::VS_Final || |
2380 | Specifier == VirtSpecifiers::VS_GNU_Final || |
2381 | Specifier == VirtSpecifiers::VS_Sealed || |
2382 | Specifier == VirtSpecifiers::VS_Abstract; |
2383 | } |
2384 | |
2385 | |
2386 | |
2387 | bool Parser::ParseCXXMemberDeclaratorBeforeInitializer( |
2388 | Declarator &DeclaratorInfo, VirtSpecifiers &VS, ExprResult &BitfieldSize, |
2389 | LateParsedAttrList &LateParsedAttrs) { |
2390 | |
2391 | |
2392 | |
2393 | |
2394 | |
2395 | |
2396 | |
2397 | |
2398 | |
2399 | |
2400 | if (Tok.isNot(tok::colon)) |
2401 | ParseDeclarator(DeclaratorInfo); |
2402 | else |
2403 | DeclaratorInfo.SetIdentifier(nullptr, Tok.getLocation()); |
2404 | |
2405 | if (!DeclaratorInfo.isFunctionDeclarator() && TryConsumeToken(tok::colon)) { |
2406 | assert(DeclaratorInfo.isPastIdentifier() && |
2407 | "don't know where identifier would go yet?"); |
2408 | BitfieldSize = ParseConstantExpression(); |
2409 | if (BitfieldSize.isInvalid()) |
2410 | SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); |
2411 | } else if (Tok.is(tok::kw_requires)) { |
2412 | ParseTrailingRequiresClause(DeclaratorInfo); |
2413 | } else { |
2414 | ParseOptionalCXX11VirtSpecifierSeq( |
2415 | VS, getCurrentClass().IsInterface, |
2416 | DeclaratorInfo.getDeclSpec().getFriendSpecLoc()); |
2417 | if (!VS.isUnset()) |
2418 | MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(DeclaratorInfo, VS); |
2419 | } |
2420 | |
2421 | |
2422 | if (Tok.is(tok::kw_asm)) { |
2423 | SourceLocation Loc; |
2424 | ExprResult AsmLabel(ParseSimpleAsm( true, &Loc)); |
2425 | if (AsmLabel.isInvalid()) |
2426 | SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); |
2427 | |
2428 | DeclaratorInfo.setAsmLabel(AsmLabel.get()); |
2429 | DeclaratorInfo.SetRangeEnd(Loc); |
2430 | } |
2431 | |
2432 | |
2433 | |
2434 | |
2435 | DiagnoseAndSkipCXX11Attributes(); |
2436 | MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs); |
2437 | DiagnoseAndSkipCXX11Attributes(); |
2438 | |
2439 | |
2440 | |
2441 | if (BitfieldSize.isUnset() && VS.isUnset()) { |
2442 | ParseOptionalCXX11VirtSpecifierSeq( |
2443 | VS, getCurrentClass().IsInterface, |
2444 | DeclaratorInfo.getDeclSpec().getFriendSpecLoc()); |
2445 | if (!VS.isUnset()) { |
2446 | |
2447 | |
2448 | for (const ParsedAttr &AL : DeclaratorInfo.getAttributes()) |
2449 | if (AL.isKnownToGCC() && !AL.isCXX11Attribute()) |
2450 | Diag(AL.getLoc(), diag::warn_gcc_attribute_location); |
2451 | |
2452 | MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(DeclaratorInfo, VS); |
2453 | } |
2454 | } |
2455 | |
2456 | |
2457 | |
2458 | if (!DeclaratorInfo.hasName() && BitfieldSize.isUnset()) { |
2459 | |
2460 | SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch); |
2461 | return true; |
2462 | } |
2463 | return false; |
2464 | } |
2465 | |
2466 | |
2467 | |
2468 | void Parser::MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq( |
2469 | Declarator &D, |
2470 | VirtSpecifiers &VS) { |
2471 | DeclSpec DS(AttrFactory); |
2472 | |
2473 | |
2474 | |
2475 | ParseTypeQualifierListOpt( |
2476 | DS, AR_NoAttributesParsed, false, |
2477 | false, llvm::function_ref<void()>([&]() { |
2478 | Actions.CodeCompleteFunctionQualifiers(DS, D, &VS); |
2479 | })); |
2480 | D.ExtendWithDeclSpec(DS); |
2481 | |
2482 | if (D.isFunctionDeclarator()) { |
2483 | auto &Function = D.getFunctionTypeInfo(); |
2484 | if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) { |
2485 | auto DeclSpecCheck = [&](DeclSpec::TQ TypeQual, StringRef FixItName, |
2486 | SourceLocation SpecLoc) { |
2487 | FixItHint Insertion; |
2488 | auto &MQ = Function.getOrCreateMethodQualifiers(); |
2489 | if (!(MQ.getTypeQualifiers() & TypeQual)) { |
2490 | std::string Name(FixItName.data()); |
2491 | Name += " "; |
2492 | Insertion = FixItHint::CreateInsertion(VS.getFirstLocation(), Name); |
2493 | MQ.SetTypeQual(TypeQual, SpecLoc); |
2494 | } |
2495 | Diag(SpecLoc, diag::err_declspec_after_virtspec) |
2496 | << FixItName |
2497 | << VirtSpecifiers::getSpecifierName(VS.getLastSpecifier()) |
2498 | << FixItHint::CreateRemoval(SpecLoc) << Insertion; |
2499 | }; |
2500 | DS.forEachQualifier(DeclSpecCheck); |
2501 | } |
2502 | |
2503 | |
2504 | bool RefQualifierIsLValueRef = true; |
2505 | SourceLocation RefQualifierLoc; |
2506 | if (ParseRefQualifier(RefQualifierIsLValueRef, RefQualifierLoc)) { |
2507 | const char *Name = (RefQualifierIsLValueRef ? "& " : "&& "); |
2508 | FixItHint Insertion = FixItHint::CreateInsertion(VS.getFirstLocation(), Name); |
2509 | Function.RefQualifierIsLValueRef = RefQualifierIsLValueRef; |
2510 | Function.RefQualifierLoc = RefQualifierLoc; |
2511 | |
2512 | Diag(RefQualifierLoc, diag::err_declspec_after_virtspec) |
2513 | << (RefQualifierIsLValueRef ? "&" : "&&") |
2514 | << VirtSpecifiers::getSpecifierName(VS.getLastSpecifier()) |
2515 | << FixItHint::CreateRemoval(RefQualifierLoc) |
2516 | << Insertion; |
2517 | D.SetRangeEnd(RefQualifierLoc); |
2518 | } |
2519 | } |
2520 | } |
2521 | |
2522 | |
2523 | |
2524 | |
2525 | |
2526 | |
2527 | |
2528 | |
2529 | |
2530 | |
2531 | |
2532 | |
2533 | |
2534 | |
2535 | |
2536 | |
2537 | |
2538 | |
2539 | |
2540 | |
2541 | |
2542 | |
2543 | |
2544 | |
2545 | |
2546 | |
2547 | |
2548 | |
2549 | |
2550 | |
2551 | |
2552 | |
2553 | |
2554 | |
2555 | |
2556 | |
2557 | |
2558 | |
2559 | Parser::DeclGroupPtrTy |
2560 | Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, |
2561 | ParsedAttributes &AccessAttrs, |
2562 | const ParsedTemplateInfo &TemplateInfo, |
2563 | ParsingDeclRAIIObject *TemplateDiags) { |
2564 | if (Tok.is(tok::at)) { |
2565 | if (getLangOpts().ObjC && NextToken().isObjCAtKeyword(tok::objc_defs)) |
2566 | Diag(Tok, diag::err_at_defs_cxx); |
2567 | else |
2568 | Diag(Tok, diag::err_at_in_class); |
2569 | |
2570 | ConsumeToken(); |
2571 | SkipUntil(tok::r_brace, StopAtSemi); |
2572 | return nullptr; |
2573 | } |
2574 | |
2575 | |
2576 | |
2577 | |
2578 | |
2579 | |
2580 | |
2581 | ColonProtectionRAIIObject X(*this); |
2582 | |
2583 | |
2584 | bool MalformedTypeSpec = false; |
2585 | if (!TemplateInfo.Kind && |
2586 | Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw___super)) { |
2587 | if (TryAnnotateCXXScopeToken()) |
2588 | MalformedTypeSpec = true; |
2589 | |
2590 | bool isAccessDecl; |
2591 | if (Tok.isNot(tok::annot_cxxscope)) |
2592 | isAccessDecl = false; |
2593 | else if (NextToken().is(tok::identifier)) |
2594 | isAccessDecl = GetLookAheadToken(2).is(tok::semi); |
2595 | else |
2596 | isAccessDecl = NextToken().is(tok::kw_operator); |
2597 | |
2598 | if (isAccessDecl) { |
2599 | |
2600 | CXXScopeSpec SS; |
2601 | ParseOptionalCXXScopeSpecifier(SS, nullptr, |
2602 | false, |
2603 | false); |
2604 | |
2605 | if (SS.isInvalid()) { |
2606 | SkipUntil(tok::semi); |
2607 | return nullptr; |
2608 | } |
2609 | |
2610 | |
2611 | SourceLocation TemplateKWLoc; |
2612 | UnqualifiedId Name; |
2613 | if (ParseUnqualifiedId(SS, nullptr, |
2614 | false, false, true, true, |
2615 | false, &TemplateKWLoc, Name)) { |
2616 | SkipUntil(tok::semi); |
2617 | return nullptr; |
2618 | } |
2619 | |
2620 | |
2621 | if (ExpectAndConsume(tok::semi, diag::err_expected_after, |
2622 | "access declaration")) { |
2623 | SkipUntil(tok::semi); |
2624 | return nullptr; |
2625 | } |
2626 | |
2627 | |
2628 | return DeclGroupPtrTy::make(DeclGroupRef(Actions.ActOnUsingDeclaration( |
2629 | getCurScope(), AS, SourceLocation(), |
2630 | SourceLocation(), SS, Name, |
2631 | SourceLocation(), |
2632 | ParsedAttributesView()))); |
2633 | } |
2634 | } |
2635 | |
2636 | |
2637 | |
2638 | if (!TemplateInfo.Kind && |
2639 | Tok.isOneOf(tok::kw_static_assert, tok::kw__Static_assert)) { |
2640 | SourceLocation DeclEnd; |
2641 | return DeclGroupPtrTy::make( |
2642 | DeclGroupRef(ParseStaticAssertDeclaration(DeclEnd))); |
2643 | } |
2644 | |
2645 | if (Tok.is(tok::kw_template)) { |
2646 | assert(!TemplateInfo.TemplateParams && |
2647 | "Nested template improperly parsed?"); |
2648 | ObjCDeclContextSwitch ObjCDC(*this); |
2649 | SourceLocation DeclEnd; |
2650 | return DeclGroupPtrTy::make( |
2651 | DeclGroupRef(ParseTemplateDeclarationOrSpecialization( |
2652 | DeclaratorContext::Member, DeclEnd, AccessAttrs, AS))); |
2653 | } |
2654 | |
2655 | |
2656 | if (Tok.is(tok::kw___extension__)) { |
2657 | |
2658 | ExtensionRAIIObject O(Diags); |
2659 | ConsumeToken(); |
2660 | return ParseCXXClassMemberDeclaration(AS, AccessAttrs, |
2661 | TemplateInfo, TemplateDiags); |
2662 | } |
2663 | |
2664 | ParsedAttributesWithRange attrs(AttrFactory); |
2665 | ParsedAttributesViewWithRange FnAttrs; |
2666 | |
2667 | MaybeParseCXX11Attributes(attrs); |
2668 | |
2669 | |
2670 | |
2671 | |
2672 | if (Tok.is(tok::annot_attr_openmp)) |
2673 | return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, attrs); |
2674 | |
2675 | |
2676 | |
2677 | FnAttrs.addAll(attrs.begin(), attrs.end()); |
2678 | FnAttrs.Range = attrs.Range; |
2679 | |
2680 | MaybeParseMicrosoftAttributes(attrs); |
2681 | |
2682 | if (Tok.is(tok::kw_using)) { |
2683 | |
2684 | SourceLocation UsingLoc = ConsumeToken(); |
2685 | |
2686 | |
2687 | while (Tok.is(tok::kw_template)) { |
2688 | SourceLocation TemplateLoc = ConsumeToken(); |
2689 | Diag(TemplateLoc, diag::err_unexpected_template_after_using) |
2690 | << FixItHint::CreateRemoval(TemplateLoc); |
2691 | } |
2692 | |
2693 | if (Tok.is(tok::kw_namespace)) { |
2694 | Diag(UsingLoc, diag::err_using_namespace_in_class); |
2695 | SkipUntil(tok::semi, StopBeforeMatch); |
2696 | return nullptr; |
2697 | } |
2698 | SourceLocation DeclEnd; |
2699 | |
2700 | return ParseUsingDeclaration(DeclaratorContext::Member, TemplateInfo, |
2701 | UsingLoc, DeclEnd, attrs, AS); |
2702 | } |
2703 | |
2704 | |
2705 | LateParsedAttrList CommonLateParsedAttrs; |
2706 | |
2707 | |
2708 | |
2709 | ParsingDeclSpec DS(*this, TemplateDiags); |
2710 | DS.takeAttributesFrom(attrs); |
2711 | if (MalformedTypeSpec) |
2712 | DS.SetTypeSpecError(); |
2713 | |
2714 | |
2715 | |
2716 | |
2717 | |
2718 | |
2719 | bool IsTemplateSpecOrInst = |
2720 | (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation || |
2721 | TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization); |
2722 | SuppressAccessChecks diagsFromTag(*this, IsTemplateSpecOrInst); |
2723 | |
2724 | ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DeclSpecContext::DSC_class, |
2725 | &CommonLateParsedAttrs); |
2726 | |
2727 | if (IsTemplateSpecOrInst) |
2728 | diagsFromTag.done(); |
2729 | |
2730 | |
2731 | X.restore(); |
2732 | |
2733 | |
2734 | |
2735 | if (DS.hasTagDefinition() && |
2736 | TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate && |
2737 | DiagnoseMissingSemiAfterTagDefinition(DS, AS, DeclSpecContext::DSC_class, |
2738 | &CommonLateParsedAttrs)) |
2739 | return nullptr; |
2740 | |
2741 | MultiTemplateParamsArg TemplateParams( |
2742 | TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->data() |
2743 | : nullptr, |
2744 | TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->size() : 0); |
2745 | |
2746 | if (TryConsumeToken(tok::semi)) { |
2747 | if (DS.isFriendSpecified()) |
2748 | ProhibitAttributes(FnAttrs); |
2749 | |
2750 | RecordDecl *AnonRecord = nullptr; |
2751 | Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec( |
2752 | getCurScope(), AS, DS, TemplateParams, false, AnonRecord); |
2753 | DS.complete(TheDecl); |
2754 | if (AnonRecord) { |
2755 | Decl* decls[] = {AnonRecord, TheDecl}; |
2756 | return Actions.BuildDeclaratorGroup(decls); |
2757 | } |
2758 | return Actions.ConvertDeclToDeclGroup(TheDecl); |
2759 | } |
2760 | |
2761 | ParsingDeclarator DeclaratorInfo(*this, DS, DeclaratorContext::Member); |
2762 | if (TemplateInfo.TemplateParams) |
2763 | DeclaratorInfo.setTemplateParameterLists(TemplateParams); |
2764 | VirtSpecifiers VS; |
2765 | |
2766 | |
2767 | LateParsedAttrList LateParsedAttrs; |
2768 | |
2769 | SourceLocation EqualLoc; |
2770 | SourceLocation PureSpecLoc; |
2771 | |
2772 | auto TryConsumePureSpecifier = [&] (bool AllowDefinition) { |
2773 | if (Tok.isNot(tok::equal)) |
2774 | return false; |
2775 | |
2776 | auto &Zero = NextToken(); |
2777 | SmallString<8> Buffer; |
2778 | if (Zero.isNot(tok::numeric_constant) || |
2779 | PP.getSpelling(Zero, Buffer) != "0") |
2780 | return false; |
2781 | |
2782 | auto &After = GetLookAheadToken(2); |
2783 | if (!After.isOneOf(tok::semi, tok::comma) && |
2784 | !(AllowDefinition && |
2785 | After.isOneOf(tok::l_brace, tok::colon, tok::kw_try))) |
2786 | return false; |
2787 | |
2788 | EqualLoc = ConsumeToken(); |
2789 | PureSpecLoc = ConsumeToken(); |
2790 | return true; |
2791 | }; |
2792 | |
2793 | SmallVector<Decl *, 8> DeclsInGroup; |
2794 | ExprResult BitfieldSize; |
2795 | ExprResult TrailingRequiresClause; |
2796 | bool ExpectSemi = true; |
2797 | |
2798 | |
2799 | |
2800 | |
2801 | SuppressAccessChecks SAC(*this, IsTemplateSpecOrInst); |
2802 | |
2803 | |
2804 | if (ParseCXXMemberDeclaratorBeforeInitializer( |
2805 | DeclaratorInfo, VS, BitfieldSize, LateParsedAttrs)) { |
2806 | TryConsumeToken(tok::semi); |
2807 | return nullptr; |
2808 | } |
2809 | |
2810 | if (IsTemplateSpecOrInst) |
2811 | SAC.done(); |
2812 | |
2813 | |
2814 | if (BitfieldSize.isUnset()) { |
2815 | |
2816 | |
2817 | if (getLangOpts().MicrosoftExt && DeclaratorInfo.isDeclarationOfFunction()) |
2818 | TryConsumePureSpecifier( true); |
2819 | |
2820 | FunctionDefinitionKind DefinitionKind = FunctionDefinitionKind::Declaration; |
2821 | |
2822 | |
2823 | |
2824 | |
2825 | |
2826 | if (Tok.is(tok::l_brace) && !getLangOpts().CPlusPlus11) { |
2827 | DefinitionKind = FunctionDefinitionKind::Definition; |
2828 | } else if (DeclaratorInfo.isFunctionDeclarator()) { |
2829 | if (Tok.isOneOf(tok::l_brace, tok::colon, tok::kw_try)) { |
2830 | DefinitionKind = FunctionDefinitionKind::Definition; |
2831 | } else if (Tok.is(tok::equal)) { |
2832 | const Token &KW = NextToken(); |
2833 | if (KW.is(tok::kw_default)) |
2834 | DefinitionKind = FunctionDefinitionKind::Defaulted; |
2835 | else if (KW.is(tok::kw_delete)) |
2836 | DefinitionKind = FunctionDefinitionKind::Deleted; |
2837 | else if (KW.is(tok::code_completion)) { |
2838 | cutOffParsing(); |
2839 | Actions.CodeCompleteAfterFunctionEquals(DeclaratorInfo); |
2840 | return nullptr; |
2841 | } |
2842 | } |
2843 | } |
2844 | DeclaratorInfo.setFunctionDefinitionKind(DefinitionKind); |
2845 | |
2846 | |
2847 | |
2848 | if (DeclaratorInfo.isFunctionDeclarator() && |
2849 | DefinitionKind == FunctionDefinitionKind::Declaration && |
2850 | DS.isFriendSpecified()) { |
2851 | |
2852 | |
2853 | ProhibitAttributes(FnAttrs); |
2854 | } |
2855 | |
2856 | if (DefinitionKind != FunctionDefinitionKind::Declaration) { |
2857 | if (!DeclaratorInfo.isFunctionDeclarator()) { |
2858 | Diag(DeclaratorInfo.getIdentifierLoc(), diag::err_func_def_no_params); |
2859 | ConsumeBrace(); |
2860 | SkipUntil(tok::r_brace); |
2861 | |
2862 | |
2863 | TryConsumeToken(tok::semi); |
2864 | |
2865 | return nullptr; |
2866 | } |
2867 | |
2868 | if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { |
2869 | Diag(DeclaratorInfo.getIdentifierLoc(), |
2870 | diag::err_function_declared_typedef); |
2871 | |
2872 | |
2873 | DS.ClearStorageClassSpecs(); |
2874 | } |
2875 | |
2876 | Decl *FunDecl = |
2877 | ParseCXXInlineMethodDef(AS, AccessAttrs, DeclaratorInfo, TemplateInfo, |
2878 | VS, PureSpecLoc); |
2879 | |
2880 | if (FunDecl) { |
2881 | for (unsigned i = 0, ni = CommonLateParsedAttrs.size(); i < ni; ++i) { |
2882 | CommonLateParsedAttrs[i]->addDecl(FunDecl); |
2883 | } |
2884 | for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) { |
2885 | LateParsedAttrs[i]->addDecl(FunDecl); |
2886 | } |
2887 | } |
2888 | LateParsedAttrs.clear(); |
2889 | |
2890 | |
2891 | if (Tok.is(tok::semi)) |
2892 | ConsumeExtraSemi(AfterMemberFunctionDefinition); |
2893 | |
2894 | return DeclGroupPtrTy::make(DeclGroupRef(FunDecl)); |
2895 | } |
2896 | } |
2897 | |
2898 | |
2899 | |
2900 | |
2901 | |
2902 | while (1) { |
2903 | InClassInitStyle HasInClassInit = ICIS_NoInit; |
2904 | bool HasStaticInitializer = false; |
2905 | if (Tok.isOneOf(tok::equal, tok::l_brace) && PureSpecLoc.isInvalid()) { |
2906 | |
2907 | if (BitfieldSize.isUsable() && !DeclaratorInfo.hasName()) { |
2908 | |
2909 | Diag(Tok, diag::err_anon_bitfield_member_init); |
2910 | SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); |
2911 | } else if (DeclaratorInfo.isDeclarationOfFunction()) { |
2912 | |
2913 | if (!TryConsumePureSpecifier( false)) |
2914 | |
2915 | HasStaticInitializer = true; |
2916 | } else if (DeclaratorInfo.getDeclSpec().getStorageClassSpec() != |
2917 | DeclSpec::SCS_static && |
2918 | DeclaratorInfo.getDeclSpec().getStorageClassSpec() != |
2919 | DeclSpec::SCS_typedef && |
2920 | !DS.isFriendSpecified()) { |
2921 | |
2922 | if (BitfieldSize.get()) |
2923 | Diag(Tok, getLangOpts().CPlusPlus20 |
2924 | ? diag::warn_cxx17_compat_bitfield_member_init |
2925 | : diag::ext_bitfield_member_init); |
2926 | HasInClassInit = Tok.is(tok::equal) ? ICIS_CopyInit : ICIS_ListInit; |
2927 | } else { |
2928 | HasStaticInitializer = true; |
2929 | } |
2930 | } |
2931 | |
2932 | |
2933 | |
2934 | |
2935 | |
2936 | NamedDecl *ThisDecl = nullptr; |
2937 | if (DS.isFriendSpecified()) { |
2938 | |
2939 | |
2940 | |
2941 | |
2942 | |
2943 | SmallVector<SourceRange, 4> Ranges; |
2944 | DeclaratorInfo.getCXX11AttributeRanges(Ranges); |
2945 | for (SmallVectorImpl<SourceRange>::iterator I = Ranges.begin(), |
2946 | E = Ranges.end(); I != E; ++I) |
2947 | Diag((*I).getBegin(), diag::err_attributes_not_allowed) << *I; |
2948 | |
2949 | ThisDecl = Actions.ActOnFriendFunctionDecl(getCurScope(), DeclaratorInfo, |
2950 | TemplateParams); |
2951 | } else { |
2952 | ThisDecl = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, |
2953 | DeclaratorInfo, |
2954 | TemplateParams, |
2955 | BitfieldSize.get(), |
2956 | VS, HasInClassInit); |
2957 | |
2958 | if (VarTemplateDecl *VT = |
2959 | ThisDecl ? dyn_cast<VarTemplateDecl>(ThisDecl) : nullptr) |
2960 | |
2961 | |
2962 | ThisDecl = VT->getTemplatedDecl(); |
2963 | |
2964 | if (ThisDecl) |
2965 | Actions.ProcessDeclAttributeList(getCurScope(), ThisDecl, AccessAttrs); |
2966 | } |
2967 | |
2968 | |
2969 | |
2970 | if (HasInClassInit != ICIS_NoInit && |
2971 | DeclaratorInfo.getDeclSpec().getStorageClassSpec() == |
2972 | DeclSpec::SCS_static) { |
2973 | HasInClassInit = ICIS_NoInit; |
2974 | HasStaticInitializer = true; |
2975 | } |
2976 | |
2977 | if (PureSpecLoc.isValid() && VS.getAbstractLoc().isValid()) { |
2978 | Diag(PureSpecLoc, diag::err_duplicate_virt_specifier) << "abstract"; |
2979 | } |
2980 | if (ThisDecl && PureSpecLoc.isValid()) |
2981 | Actions.ActOnPureSpecifier(ThisDecl, PureSpecLoc); |
2982 | else if (ThisDecl && VS.getAbstractLoc().isValid()) |
2983 | Actions.ActOnPureSpecifier(ThisDecl, VS.getAbstractLoc()); |
2984 | |
2985 | |
2986 | if (HasInClassInit != ICIS_NoInit) { |
2987 | |
2988 | Diag(Tok, getLangOpts().CPlusPlus11 |
2989 | ? diag::warn_cxx98_compat_nonstatic_member_init |
2990 | : diag::ext_nonstatic_member_init); |
2991 | |
2992 | if (DeclaratorInfo.isArrayOfUnknownBound()) { |
2993 | |
2994 | |
2995 | |
2996 | |
2997 | |
2998 | Diag(Tok, diag::err_incomplete_array_member_init); |
2999 | SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); |
3000 | |
3001 | |
3002 | if (ThisDecl) |
3003 | ThisDecl->setInvalidDecl(); |
3004 | } else |
3005 | ParseCXXNonStaticMemberInitializer(ThisDecl); |
3006 | } else if (HasStaticInitializer) { |
3007 | |
3008 | ExprResult Init = ParseCXXMemberInitializer( |
3009 | ThisDecl, DeclaratorInfo.isDeclarationOfFunction(), EqualLoc); |
3010 | |
3011 | if (Init.isInvalid()) { |
3012 | if (ThisDecl) |
3013 | Actions.ActOnUninitializedDecl(ThisDecl); |
3014 | SkipUntil(tok::comma, StopAtSemi | StopBeforeMatch); |
3015 | } else if (ThisDecl) |
3016 | Actions.AddInitializerToDecl(ThisDecl, Init.get(), EqualLoc.isInvalid()); |
3017 | } else if (ThisDecl && DS.getStorageClassSpec() == DeclSpec::SCS_static) |
3018 | |
3019 | Actions.ActOnUninitializedDecl(ThisDecl); |
3020 | |
3021 | if (ThisDecl) { |
3022 | if (!ThisDecl->isInvalidDecl()) { |
3023 | |
3024 | for (unsigned i = 0, ni = CommonLateParsedAttrs.size(); i < ni; ++i) |
3025 | CommonLateParsedAttrs[i]->addDecl(ThisDecl); |
3026 | |
3027 | for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) |
3028 | LateParsedAttrs[i]->addDecl(ThisDecl); |
3029 | } |
3030 | Actions.FinalizeDeclaration(ThisDecl); |
3031 | DeclsInGroup.push_back(ThisDecl); |
3032 | |
3033 | if (DeclaratorInfo.isFunctionDeclarator() && |
3034 | DeclaratorInfo.getDeclSpec().getStorageClassSpec() != |
3035 | DeclSpec::SCS_typedef) |
3036 | HandleMemberFunctionDeclDelays(DeclaratorInfo, ThisDecl); |
3037 | } |
3038 | LateParsedAttrs.clear(); |
3039 | |
3040 | DeclaratorInfo.complete(ThisDecl); |
3041 | |
3042 | |
3043 | |
3044 | SourceLocation CommaLoc; |
3045 | if (!TryConsumeToken(tok::comma, CommaLoc)) |
3046 | break; |
3047 | |
3048 | if (Tok.isAtStartOfLine() && |
3049 | !MightBeDeclarator(DeclaratorContext::Member)) { |
3050 | |
3051 | |
3052 | |
3053 | Diag(CommaLoc, diag::err_expected_semi_declaration) |
3054 | << FixItHint::CreateReplacement(CommaLoc, ";"); |
3055 | ExpectSemi = false; |
3056 | break; |
3057 | } |
3058 | |
3059 | |
3060 | DeclaratorInfo.clear(); |
3061 | VS.clear(); |
3062 | BitfieldSize = ExprResult(false); |
3063 | EqualLoc = PureSpecLoc = SourceLocation(); |
3064 | DeclaratorInfo.setCommaLoc(CommaLoc); |
3065 | |
3066 | |
3067 | |
3068 | |
3069 | DiagnoseAndSkipCXX11Attributes(); |
3070 | MaybeParseGNUAttributes(DeclaratorInfo); |
3071 | DiagnoseAndSkipCXX11Attributes(); |
3072 | |
3073 | if (ParseCXXMemberDeclaratorBeforeInitializer( |
3074 | DeclaratorInfo, VS, BitfieldSize, LateParsedAttrs)) |
3075 | break; |
3076 | } |
3077 | |
3078 | if (ExpectSemi && |
3079 | ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list)) { |
3080 | |
3081 | SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch); |
3082 | |
3083 | TryConsumeToken(tok::semi); |
3084 | return nullptr; |
3085 | } |
3086 | |
3087 | return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup); |
3088 | } |
3089 | |
3090 | |
3091 | |
3092 | |
3093 | |
3094 | |
3095 | |
3096 | |
3097 | |
3098 | |
3099 | |
3100 | |
3101 | |
3102 | |
3103 | |
3104 | |
3105 | |
3106 | |
3107 | |
3108 | |
3109 | |
3110 | ExprResult Parser::ParseCXXMemberInitializer(Decl *D, bool IsFunction, |
3111 | SourceLocation &EqualLoc) { |
3112 | assert(Tok.isOneOf(tok::equal, tok::l_brace) |
3113 | && "Data member initializer not starting with '=' or '{'"); |
3114 | |
3115 | EnterExpressionEvaluationContext Context( |
3116 | Actions, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, D); |
3117 | if (TryConsumeToken(tok::equal, EqualLoc)) { |
3118 | if (Tok.is(tok::kw_delete)) { |
3119 | |
3120 | |
3121 | |
3122 | |
3123 | |
3124 | const Token &Next = NextToken(); |
3125 | if (IsFunction || Next.isOneOf(tok::semi, tok::comma, tok::eof)) { |
3126 | if (IsFunction) |
3127 | Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration) |
3128 | << 1 ; |
3129 | else |
3130 | Diag(ConsumeToken(), diag::err_deleted_non_function); |
3131 | return ExprError(); |
3132 | } |
3133 | } else if (Tok.is(tok::kw_default)) { |
3134 | if (IsFunction) |
3135 | Diag(Tok, diag::err_default_delete_in_multiple_declaration) |
3136 | << 0 ; |
3137 | else |
3138 | Diag(ConsumeToken(), diag::err_default_special_members) |
3139 | << getLangOpts().CPlusPlus20; |
3140 | return ExprError(); |
3141 | } |
3142 | } |
3143 | if (const auto *PD = dyn_cast_or_null<MSPropertyDecl>(D)) { |
3144 | Diag(Tok, diag::err_ms_property_initializer) << PD; |
3145 | return ExprError(); |
3146 | } |
3147 | return ParseInitializer(); |
3148 | } |
3149 | |
3150 | void Parser::SkipCXXMemberSpecification(SourceLocation RecordLoc, |
3151 | SourceLocation AttrFixitLoc, |
3152 | unsigned TagType, Decl *TagDecl) { |
3153 | |
3154 | if (getLangOpts().CPlusPlus && Tok.is(tok::identifier)) { |
3155 | assert(isCXX11FinalKeyword() && "not a class definition"); |
3156 | ConsumeToken(); |
3157 | |
3158 | |
3159 | |
3160 | ParsedAttributesWithRange Attrs(AttrFactory); |
3161 | CheckMisplacedCXX11Attribute(Attrs, AttrFixitLoc); |
3162 | |
3163 | |
3164 | |
3165 | |
3166 | if (Tok.isNot(tok::colon) && Tok.isNot(tok::l_brace)) |
3167 | return; |
3168 | } |
3169 | |
3170 | |
3171 | |
3172 | |
3173 | if (Tok.is(tok::colon)) { |
3174 | |
3175 | ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope); |
3176 | ParsingClassDefinition ParsingDef(*this, TagDecl, true, |
3177 | TagType == DeclSpec::TST_interface); |
3178 | auto OldContext = |
3179 | Actions.ActOnTagStartSkippedDefinition(getCurScope(), TagDecl); |
3180 | |
3181 | |
3182 | ParseBaseClause(nullptr); |
3183 | |
3184 | Actions.ActOnTagFinishSkippedDefinition(OldContext); |
3185 | |
3186 | if (!Tok.is(tok::l_brace)) { |
3187 | Diag(PP.getLocForEndOfToken(PrevTokLocation), |
3188 | diag::err_expected_lbrace_after_base_specifiers); |
3189 | return; |
3190 | } |
3191 | } |
3192 | |
3193 | |
3194 | assert(Tok.is(tok::l_brace)); |
3195 | BalancedDelimiterTracker T(*this, tok::l_brace); |
3196 | T.consumeOpen(); |
3197 | T.skipToEnd(); |
3198 | |
3199 | |
3200 | ParsedAttributes Attrs(AttrFactory); |
3201 | if (Tok.is(tok::kw___attribute)) |
3202 | MaybeParseGNUAttributes(Attrs); |
3203 | } |
3204 | |
3205 | Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas( |
3206 | AccessSpecifier &AS, ParsedAttributesWithRange &AccessAttrs, |
3207 | DeclSpec::TST TagType, Decl *TagDecl) { |
3208 | ParenBraceBracketBalancer BalancerRAIIObj(*this); |
3209 | |
3210 | switch (Tok.getKind()) { |
3211 | case tok::kw___if_exists: |
3212 | case tok::kw___if_not_exists: |
3213 | ParseMicrosoftIfExistsClassDeclaration(TagType, AccessAttrs, AS); |
3214 | return nullptr; |
3215 | |
3216 | case tok::semi: |
3217 | |
3218 | ConsumeExtraSemi(InsideStruct, TagType); |
3219 | return nullptr; |
3220 | |
3221 | |
3222 | case tok::annot_pragma_vis: |
3223 | HandlePragmaVisibility(); |
3224 | return nullptr; |
3225 | case tok::annot_pragma_pack: |
3226 | HandlePragmaPack(); |
3227 | return nullptr; |
3228 | case tok::annot_pragma_align: |
3229 | HandlePragmaAlign(); |
3230 | return nullptr; |
3231 | case tok::annot_pragma_ms_pointers_to_members: |
3232 | HandlePragmaMSPointersToMembers(); |
3233 | return nullptr; |
3234 | case tok::annot_pragma_ms_pragma: |
3235 | HandlePragmaMSPragma(); |
3236 | return nullptr; |
3237 | case tok::annot_pragma_ms_vtordisp: |
3238 | HandlePragmaMSVtorDisp(); |
3239 | return nullptr; |
3240 | case tok::annot_pragma_dump: |
3241 | HandlePragmaDump(); |
3242 | return nullptr; |
3243 | |
3244 | case tok::kw_namespace: |
3245 | |
3246 | DiagnoseUnexpectedNamespace(cast<NamedDecl>(TagDecl)); |
3247 | return nullptr; |
3248 | |
3249 | case tok::kw_private: |
3250 | |
3251 | |
3252 | if (getLangOpts().OpenCL && !NextToken().is(tok::colon)) |
3253 | return ParseCXXClassMemberDeclaration(AS, AccessAttrs); |
3254 | LLVM_FALLTHROUGH; |
3255 | case tok::kw_public: |
3256 | case tok::kw_protected: { |
3257 | AccessSpecifier NewAS = getAccessSpecifierIfPresent(); |
3258 | assert(NewAS != AS_none); |
3259 | |
3260 | AS = NewAS; |
3261 | SourceLocation ASLoc = Tok.getLocation(); |
3262 | unsigned TokLength = Tok.getLength(); |
3263 | ConsumeToken(); |
3264 | AccessAttrs.clear(); |
3265 | MaybeParseGNUAttributes(AccessAttrs); |
3266 | |
3267 | SourceLocation EndLoc; |
3268 | if (TryConsumeToken(tok::colon, EndLoc)) { |
3269 | } else if (TryConsumeToken(tok::semi, EndLoc)) { |
3270 | Diag(EndLoc, diag::err_expected) |
3271 | << tok::colon << FixItHint::CreateReplacement(EndLoc, ":"); |
3272 | } else { |
3273 | EndLoc = ASLoc.getLocWithOffset(TokLength); |
3274 | Diag(EndLoc, diag::err_expected) |
3275 | << tok::colon << FixItHint::CreateInsertion(EndLoc, ":"); |
3276 | } |
3277 | |
3278 | |
3279 | |
3280 | if (TagType == DeclSpec::TST_interface && AS != AS_public) { |
3281 | Diag(ASLoc, diag::err_access_specifier_interface) << (AS == AS_protected); |
3282 | } |
3283 | |
3284 | if (Actions.ActOnAccessSpecifier(NewAS, ASLoc, EndLoc, AccessAttrs)) { |
3285 | |
3286 | AccessAttrs.clear(); |
3287 | } |
3288 | |
3289 | return nullptr; |
3290 | } |
3291 | |
3292 | case tok::annot_attr_openmp: |
3293 | case tok::annot_pragma_openmp: |
3294 | return ParseOpenMPDeclarativeDirectiveWithExtDecl( |
3295 | AS, AccessAttrs, true, TagType, TagDecl); |
3296 | |
3297 | default: |
3298 | if (tok::isPragmaAnnotation(Tok.getKind())) { |
3299 | Diag(Tok.getLocation(), diag::err_pragma_misplaced_in_decl) |
3300 | << DeclSpec::getSpecifierName(TagType, |
3301 | Actions.getASTContext().getPrintingPolicy()); |
3302 | ConsumeAnnotationToken(); |
3303 | return nullptr; |
3304 | } |
3305 | return ParseCXXClassMemberDeclaration(AS, AccessAttrs); |
3306 | } |
3307 | } |
3308 | |
3309 | |
3310 | |
3311 | |
3312 | |
3313 | |
3314 | |
3315 | void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, |
3316 | SourceLocation AttrFixitLoc, |
3317 | ParsedAttributesWithRange &Attrs, |
3318 | unsigned TagType, Decl *TagDecl) { |
3319 | assert((TagType == DeclSpec::TST_struct || |
3320 | TagType == DeclSpec::TST_interface || |
3321 | TagType == DeclSpec::TST_union || |
3322 | TagType == DeclSpec::TST_class) && "Invalid TagType!"); |
3323 | |
3324 | llvm::TimeTraceScope TimeScope("ParseClass", [&]() { |
3325 | if (auto *TD = dyn_cast_or_null<NamedDecl>(TagDecl)) |
3326 | return TD->getQualifiedNameAsString(); |
3327 | return std::string("<anonymous>"); |
3328 | }); |
3329 | |
3330 | PrettyDeclStackTraceEntry CrashInfo(Actions.Context, TagDecl, RecordLoc, |
3331 | "parsing struct/union/class body"); |
3332 | |
3333 | |
3334 | |
3335 | bool NonNestedClass = true; |
3336 | if (!ClassStack.empty()) { |
3337 | for (const Scope *S = getCurScope(); S; S = S->getParent()) { |
3338 | if (S->isClassScope()) { |
3339 | |
3340 | NonNestedClass = false; |
3341 | |
3342 | |
3343 | if (getCurrentClass().IsInterface) { |
3344 | Diag(RecordLoc, diag::err_invalid_member_in_interface) |
3345 | << 6 |
3346 | << (isa<NamedDecl>(TagDecl) |
3347 | ? cast<NamedDecl>(TagDecl)->getQualifiedNameAsString() |
3348 | : "(anonymous)"); |
3349 | } |
3350 | break; |
3351 | } |
3352 | |
3353 | if ((S->getFlags() & Scope::FnScope)) |
3354 | |
3355 | |
3356 | break; |
3357 | } |
3358 | } |
3359 | |
3360 | |
3361 | ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope); |
3362 | |
3363 | |
3364 | ParsingClassDefinition ParsingDef(*this, TagDecl, NonNestedClass, |
3365 | TagType == DeclSpec::TST_interface); |
3366 | |
3367 | if (TagDecl) |
3368 | Actions.ActOnTagStartDefinition(getCurScope(), TagDecl); |
3369 | |
3370 | SourceLocation FinalLoc; |
3371 | SourceLocation AbstractLoc; |
3372 | bool IsFinalSpelledSealed = false; |
3373 | bool IsAbstract = false; |
3374 | |
3375 | |
3376 | if (getLangOpts().CPlusPlus && Tok.is(tok::identifier)) { |
3377 | while (true) { |
3378 | VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier(Tok); |
3379 | if (Specifier == VirtSpecifiers::VS_None) |
3380 | break; |
3381 | if (isCXX11FinalKeyword()) { |
3382 | if (FinalLoc.isValid()) { |
3383 | auto Skipped = ConsumeToken(); |
3384 | Diag(Skipped, diag::err_duplicate_class_virt_specifier) |
3385 | << VirtSpecifiers::getSpecifierName(Specifier); |
3386 | } else { |
3387 | FinalLoc = ConsumeToken(); |
3388 | if (Specifier == VirtSpecifiers::VS_Sealed) |
3389 | IsFinalSpelledSealed = true; |
3390 | } |
3391 | } else { |
3392 | if (AbstractLoc.isValid()) { |
3393 | auto Skipped = ConsumeToken(); |
3394 | Diag(Skipped, diag::err_duplicate_class_virt_specifier) |
3395 | << VirtSpecifiers::getSpecifierName(Specifier); |
3396 | } else { |
3397 | AbstractLoc = ConsumeToken(); |
3398 | IsAbstract = true; |
3399 | } |
3400 | } |
3401 | if (TagType == DeclSpec::TST_interface) |
3402 | Diag(FinalLoc, diag::err_override_control_interface) |
3403 | << VirtSpecifiers::getSpecifierName(Specifier); |
3404 | else if (Specifier == VirtSpecifiers::VS_Final) |
3405 | Diag(FinalLoc, getLangOpts().CPlusPlus11 |
3406 | ? diag::warn_cxx98_compat_override_control_keyword |
3407 | : diag::ext_override_control_keyword) |
3408 | << VirtSpecifiers::getSpecifierName(Specifier); |
3409 | else if (Specifier == VirtSpecifiers::VS_Sealed) |
3410 | Diag(FinalLoc, diag::ext_ms_sealed_keyword); |
3411 | else if (Specifier == VirtSpecifiers::VS_Abstract) |
3412 | Diag(AbstractLoc, diag::ext_ms_abstract_keyword); |
3413 | else if (Specifier == VirtSpecifiers::VS_GNU_Final) |
3414 | Diag(FinalLoc, diag::ext_warn_gnu_final); |
3415 | } |
3416 | assert((FinalLoc.isValid() || AbstractLoc.isValid()) && |
3417 | "not a class definition"); |
3418 | |
3419 | |
3420 | |
3421 | |
3422 | |
3423 | CheckMisplacedCXX11Attribute(Attrs, AttrFixitLoc); |
3424 | |
3425 | |
3426 | |
3427 | |
3428 | |
3429 | |
3430 | |
3431 | |
3432 | if (!Tok.is(tok::colon) && !Tok.is(tok::l_brace)) { |
3433 | if (TagDecl) |
3434 | Actions.ActOnTagDefinitionError(getCurScope(), TagDecl); |
3435 | return; |
3436 | } |
3437 | } |
3438 | |
3439 | if (Tok.is(tok::colon)) { |
3440 | ParseScope InheritanceScope(this, getCurScope()->getFlags() | |
3441 | Scope::ClassInheritanceScope); |
3442 | |
3443 | ParseBaseClause(TagDecl); |
3444 | if (!Tok.is(tok::l_brace)) { |
3445 | bool SuggestFixIt = false; |
3446 | SourceLocation BraceLoc = PP.getLocForEndOfToken(PrevTokLocation); |
3447 | if (Tok.isAtStartOfLine()) { |
3448 | switch (Tok.getKind()) { |
3449 | case tok::kw_private: |
3450 | case tok::kw_protected: |
3451 | case tok::kw_public: |
3452 | SuggestFixIt = NextToken().getKind() == tok::colon; |
3453 | break; |
3454 | case tok::kw_static_assert: |
3455 | case tok::r_brace: |
3456 | case tok::kw_using: |
3457 | |
3458 | case tok::kw_template: |
3459 | SuggestFixIt = true; |
3460 | break; |
3461 | case tok::identifier: |
3462 | SuggestFixIt = isConstructorDeclarator(true); |
3463 | break; |
3464 | default: |
3465 | SuggestFixIt = isCXXSimpleDeclaration(false); |
3466 | break; |
3467 | } |
3468 | } |
3469 | DiagnosticBuilder LBraceDiag = |
3470 | Diag(BraceLoc, diag::err_expected_lbrace_after_base_specifiers); |
3471 | if (SuggestFixIt) { |
3472 | LBraceDiag << FixItHint::CreateInsertion(BraceLoc, " {"); |
3473 | |
3474 | PP.EnterToken(Tok, true); |
3475 | Tok.setKind(tok::l_brace); |
3476 | } else { |
3477 | if (TagDecl) |
3478 | Actions.ActOnTagDefinitionError(getCurScope(), TagDecl); |
3479 | return; |
3480 | } |
3481 | } |
3482 | } |
3483 | |
3484 | assert(Tok.is(tok::l_brace)); |
3485 | BalancedDelimiterTracker T(*this, tok::l_brace); |
3486 | T.consumeOpen(); |
3487 | |
3488 | if (TagDecl) |
3489 | Actions.ActOnStartCXXMemberDeclarations(getCurScope(), TagDecl, FinalLoc, |
3490 | IsFinalSpelledSealed, IsAbstract, |
3491 | T.getOpenLocation()); |
3492 | |
3493 | |
3494 | |
3495 | |
3496 | AccessSpecifier CurAS; |
3497 | if (TagType == DeclSpec::TST_class) |
3498 | CurAS = AS_private; |
3499 | else |
3500 | CurAS = AS_public; |
3501 | ParsedAttributesWithRange AccessAttrs(AttrFactory); |
3502 | |
3503 | if (TagDecl) { |
3504 | |
3505 | while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) && |
3506 | Tok.isNot(tok::eof)) { |
3507 | |
3508 | ParseCXXClassMemberDeclarationWithPragmas( |
3509 | CurAS, AccessAttrs, static_cast<DeclSpec::TST>(TagType), TagDecl); |
3510 | MaybeDestroyTemplateIds(); |
3511 | } |
3512 | T.consumeClose(); |
3513 | } else { |
3514 | SkipUntil(tok::r_brace); |
3515 | } |
3516 | |
3517 | |
3518 | ParsedAttributes attrs(AttrFactory); |
3519 | MaybeParseGNUAttributes(attrs); |
3520 | |
3521 | if (TagDecl) |
3522 | Actions.ActOnFinishCXXMemberSpecification(getCurScope(), RecordLoc, TagDecl, |
3523 | T.getOpenLocation(), |
3524 | T.getCloseLocation(), attrs); |
3525 | |
3526 | |
3527 | |
3528 | |
3529 | |
3530 | |
3531 | if (TagDecl && NonNestedClass) { |
3532 | |
3533 | |
3534 | |
3535 | |
3536 | |
3537 | SourceLocation SavedPrevTokLocation = PrevTokLocation; |
3538 | ParseLexedPragmas(getCurrentClass()); |
3539 | ParseLexedAttributes(getCurrentClass()); |
3540 | ParseLexedMethodDeclarations(getCurrentClass()); |
3541 | |
3542 | |
3543 | Actions.ActOnFinishCXXMemberDecls(); |
3544 | |
3545 | ParseLexedMemberInitializers(getCurrentClass()); |
3546 | ParseLexedMethodDefs(getCurrentClass()); |
3547 | PrevTokLocation = SavedPrevTokLocation; |
3548 | |
3549 | |
3550 | |
3551 | Actions.ActOnFinishCXXNonNestedClass(); |
3552 | } |
3553 | |
3554 | if (TagDecl) |
3555 | Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, T.getRange()); |
3556 | |
3557 | |
3558 | ParsingDef.Pop(); |
3559 | ClassScope.Exit(); |
3560 | } |
3561 | |
3562 | void Parser::DiagnoseUnexpectedNamespace(NamedDecl *D) { |
3563 | assert(Tok.is(tok::kw_namespace)); |
3564 | |
3565 | |
3566 | |
3567 | Diag(D->getLocation(), |
3568 | diag::err_missing_end_of_definition) << D; |
3569 | Diag(Tok.getLocation(), |
3570 | diag::note_missing_end_of_definition_before) << D; |
3571 | |
3572 | |
3573 | PP.EnterToken(Tok, true); |
3574 | |
3575 | Tok.startToken(); |
3576 | Tok.setLocation(PP.getLocForEndOfToken(PrevTokLocation)); |
3577 | Tok.setKind(tok::semi); |
3578 | PP.EnterToken(Tok, true); |
3579 | |
3580 | Tok.setKind(tok::r_brace); |
3581 | } |
3582 | |
3583 | |
3584 | |
3585 | |
3586 | |
3587 | |
3588 | |
3589 | |
3590 | |
3591 | |
3592 | |
3593 | |
3594 | |
3595 | |
3596 | |
3597 | |
3598 | |
3599 | |
3600 | |
3601 | |
3602 | |
3603 | |
3604 | void Parser::ParseConstructorInitializer(Decl *ConstructorDecl) { |
3605 | assert(Tok.is(tok::colon) && |
3606 | "Constructor initializer always starts with ':'"); |
3607 | |
3608 | |
3609 | |
3610 | PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true); |
3611 | SourceLocation ColonLoc = ConsumeToken(); |
3612 | |
3613 | SmallVector<CXXCtorInitializer*, 4> MemInitializers; |
3614 | bool AnyErrors = false; |
3615 | |
3616 | do { |
3617 | if (Tok.is(tok::code_completion)) { |
3618 | cutOffParsing(); |
3619 | Actions.CodeCompleteConstructorInitializer(ConstructorDecl, |
3620 | MemInitializers); |
3621 | return; |
3622 | } |
3623 | |
3624 | MemInitResult MemInit = ParseMemInitializer(ConstructorDecl); |
3625 | if (!MemInit.isInvalid()) |
3626 | MemInitializers.push_back(MemInit.get()); |
3627 | else |
3628 | AnyErrors = true; |
3629 | |
3630 | if (Tok.is(tok::comma)) |
3631 | ConsumeToken(); |
3632 | else if (Tok.is(tok::l_brace)) |
3633 | break; |
3634 | |
3635 | |
3636 | else if (!MemInit.isInvalid() && |
3637 | Tok.isOneOf(tok::identifier, tok::coloncolon)) { |
3638 | SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation); |
3639 | Diag(Loc, diag::err_ctor_init_missing_comma) |
3640 | << FixItHint::CreateInsertion(Loc, ", "); |
3641 | } else { |
3642 | |
3643 | if (!MemInit.isInvalid()) |
3644 | Diag(Tok.getLocation(), diag::err_expected_either) << tok::l_brace |
3645 | << tok::comma; |
3646 | SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch); |
3647 | break; |
3648 | } |
3649 | } while (true); |
3650 | |
3651 | Actions.ActOnMemInitializers(ConstructorDecl, ColonLoc, MemInitializers, |
3652 | AnyErrors); |
3653 | } |
3654 | |
3655 | |
3656 | |
3657 | |
3658 | |
3659 | |
3660 | |
3661 | |
3662 | |
3663 | |
3664 | |
3665 | |
3666 | |
3667 | MemInitResult Parser::ParseMemInitializer(Decl *ConstructorDecl) { |
3668 | |
3669 | CXXScopeSpec SS; |
3670 | if (ParseOptionalCXXScopeSpecifier(SS, nullptr, |
3671 | false, |
3672 | false)) |
3673 | return true; |
3674 | |
3675 | |
3676 | IdentifierInfo *II = nullptr; |
3677 | SourceLocation IdLoc = Tok.getLocation(); |
3678 | |
3679 | DeclSpec DS(AttrFactory); |
3680 | |
3681 | TypeResult TemplateTypeTy; |
3682 | |
3683 | if (Tok.is(tok::identifier)) { |
3684 | |
3685 | |
3686 | II = Tok.getIdentifierInfo(); |
3687 | ConsumeToken(); |
3688 | } else if (Tok.is(tok::annot_decltype)) { |
3689 | |
3690 | |
3691 | |
3692 | |
3693 | ParseDecltypeSpecifier(DS); |
3694 | } else { |
3695 | TemplateIdAnnotation *TemplateId = Tok.is(tok::annot_template_id) |
3696 | ? takeTemplateIdAnnotation(Tok) |
3697 | : nullptr; |
3698 | if (TemplateId && TemplateId->mightBeType()) { |
3699 | AnnotateTemplateIdTokenAsType(SS, true); |
3700 | assert(Tok.is(tok::annot_typename) && "template-id -> type failed"); |
3701 | TemplateTypeTy = getTypeAnnotation(Tok); |
3702 | ConsumeAnnotationToken(); |
3703 | } else { |
3704 | Diag(Tok, diag::err_expected_member_or_base_name); |
3705 | return true; |
3706 | } |
3707 | } |
3708 | |
3709 | |
3710 | if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { |
3711 | Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); |
3712 | |
3713 | |
3714 | ExprResult InitList = ParseBraceInitializer(); |
3715 | if (InitList.isInvalid()) |
3716 | return true; |
3717 | |
3718 | SourceLocation EllipsisLoc; |
3719 | TryConsumeToken(tok::ellipsis, EllipsisLoc); |
3720 | |
3721 | if (TemplateTypeTy.isInvalid()) |
3722 | return true; |
3723 | return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II, |
3724 | TemplateTypeTy.get(), DS, IdLoc, |
3725 | InitList.get(), EllipsisLoc); |
3726 | } else if(Tok.is(tok::l_paren)) { |
3727 | BalancedDelimiterTracker T(*this, tok::l_paren); |
3728 | T.consumeOpen(); |
3729 | |
3730 | |
3731 | ExprVector ArgExprs; |
3732 | CommaLocsTy CommaLocs; |
3733 | auto RunSignatureHelp = [&] { |
3734 | if (TemplateTypeTy.isInvalid()) |
3735 | return QualType(); |
3736 | QualType PreferredType = Actions.ProduceCtorInitMemberSignatureHelp( |
3737 | getCurScope(), ConstructorDecl, SS, TemplateTypeTy.get(), ArgExprs, II, |
3738 | T.getOpenLocation()); |
3739 | CalledSignatureHelp = true; |
3740 | return PreferredType; |
3741 | }; |
3742 | if (Tok.isNot(tok::r_paren) && |
3743 | ParseExpressionList(ArgExprs, CommaLocs, [&] { |
3744 | PreferredType.enterFunctionArgument(Tok.getLocation(), |
3745 | RunSignatureHelp); |
3746 | })) { |
3747 | if (PP.isCodeCompletionReached() && !CalledSignatureHelp) |
3748 | RunSignatureHelp(); |
3749 | SkipUntil(tok::r_paren, StopAtSemi); |
3750 | return true; |
3751 | } |
3752 | |
3753 | T.consumeClose(); |
3754 | |
3755 | SourceLocation EllipsisLoc; |
3756 | TryConsumeToken(tok::ellipsis, EllipsisLoc); |
3757 | |
3758 | if (TemplateTypeTy.isInvalid()) |
3759 | return true; |
3760 | return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II, |
3761 | TemplateTypeTy.get(), DS, IdLoc, |
3762 | T.getOpenLocation(), ArgExprs, |
3763 | T.getCloseLocation(), EllipsisLoc); |
3764 | } |
3765 | |
3766 | if (TemplateTypeTy.isInvalid()) |
3767 | return true; |
3768 | |
3769 | if (getLangOpts().CPlusPlus11) |
3770 | return Diag(Tok, diag::err_expected_either) << tok::l_paren << tok::l_brace; |
3771 | else |
3772 | return Diag(Tok, diag::err_expected) << tok::l_paren; |
3773 | } |
3774 | |
3775 | |
3776 | |
3777 | |
3778 | |
3779 | |
3780 | |
3781 | |
3782 | |
3783 | |
3784 | ExceptionSpecificationType |
3785 | Parser::tryParseExceptionSpecification(bool Delayed, |
3786 | SourceRange &SpecificationRange, |
3787 | SmallVectorImpl<ParsedType> &DynamicExceptions, |
3788 | SmallVectorImpl<SourceRange> &DynamicExceptionRanges, |
3789 | ExprResult &NoexceptExpr, |
3790 | CachedTokens *&ExceptionSpecTokens) { |
3791 | ExceptionSpecificationType Result = EST_None; |
3792 | ExceptionSpecTokens = nullptr; |
3793 | |
3794 | |
3795 | if (Delayed) { |
3796 | if (Tok.isNot(tok::kw_throw) && Tok.isNot(tok::kw_noexcept)) |
3797 | return EST_None; |
3798 | |
3799 | |
3800 | bool IsNoexcept = Tok.is(tok::kw_noexcept); |
3801 | Token StartTok = Tok; |
3802 | SpecificationRange = SourceRange(ConsumeToken()); |
3803 | |
3804 | |
3805 | if (!Tok.is(tok::l_paren)) { |
3806 | |
3807 | if (IsNoexcept) { |
3808 | Diag(Tok, diag::warn_cxx98_compat_noexcept_decl); |
3809 | NoexceptExpr = nullptr; |
3810 | return EST_BasicNoexcept; |
3811 | } |
3812 | |
3813 | Diag(Tok, diag::err_expected_lparen_after) << "throw"; |
3814 | return EST_DynamicNone; |
3815 | } |
3816 | |
3817 | |
3818 | ExceptionSpecTokens = new CachedTokens; |
3819 | ExceptionSpecTokens->push_back(StartTok); |
3820 | ExceptionSpecTokens->push_back(Tok); |
3821 | SpecificationRange.setEnd(ConsumeParen()); |
3822 | |
3823 | ConsumeAndStoreUntil(tok::r_paren, *ExceptionSpecTokens, |
3824 | true, |
3825 | true); |
3826 | SpecificationRange.setEnd(ExceptionSpecTokens->back().getLocation()); |
3827 | |
3828 | return EST_Unparsed; |
3829 | } |
3830 | |
3831 | |
3832 | if (Tok.is(tok::kw_throw)) { |
3833 | Result = ParseDynamicExceptionSpecification(SpecificationRange, |
3834 | DynamicExceptions, |
3835 | DynamicExceptionRanges); |
3836 | assert(DynamicExceptions.size() == DynamicExceptionRanges.size() && |
3837 | "Produced different number of exception types and ranges."); |
3838 | } |
3839 | |
3840 | |
3841 | if (Tok.isNot(tok::kw_noexcept)) |
3842 | return Result; |
3843 | |
3844 | Diag(Tok, diag::warn_cxx98_compat_noexcept_decl); |
3845 | |
3846 | |
3847 | |
3848 | SourceRange NoexceptRange; |
3849 | ExceptionSpecificationType NoexceptType = EST_None; |
3850 | |
3851 | SourceLocation KeywordLoc = ConsumeToken(); |
3852 | if (Tok.is(tok::l_paren)) { |
3853 | |
3854 | BalancedDelimiterTracker T(*this, tok::l_paren); |
3855 | T.consumeOpen(); |
3856 | NoexceptExpr = ParseConstantExpression(); |
3857 | T.consumeClose(); |
3858 | if (!NoexceptExpr.isInvalid()) { |
3859 | NoexceptExpr = Actions.ActOnNoexceptSpec(NoexceptExpr.get(), |
3860 | NoexceptType); |
3861 | NoexceptRange = SourceRange(KeywordLoc, T.getCloseLocation()); |
3862 | } else { |
3863 | NoexceptType = EST_BasicNoexcept; |
3864 | } |
3865 | } else { |
3866 | |
3867 | NoexceptType = EST_BasicNoexcept; |
3868 | NoexceptRange = SourceRange(KeywordLoc, KeywordLoc); |
3869 | } |
3870 | |
3871 | if (Result == EST_None) { |
3872 | SpecificationRange = NoexceptRange; |
3873 | Result = NoexceptType; |
3874 | |
3875 | |
3876 | |
3877 | if (Tok.is(tok::kw_throw)) { |
3878 | Diag(Tok.getLocation(), diag::err_dynamic_and_noexcept_specification); |
3879 | ParseDynamicExceptionSpecification(NoexceptRange, DynamicExceptions, |
3880 | DynamicExceptionRanges); |
3881 | } |
3882 | } else { |
3883 | Diag(Tok.getLocation(), diag::err_dynamic_and_noexcept_specification); |
3884 | } |
3885 | |
3886 | return Result; |
3887 | } |
3888 | |
3889 | static void diagnoseDynamicExceptionSpecification( |
3890 | Parser &P, SourceRange Range, bool IsNoexcept) { |
3891 | if (P.getLangOpts().CPlusPlus11) { |
3892 | const char *Replacement = IsNoexcept ? "noexcept" : "noexcept(false)"; |
3893 | P.Diag(Range.getBegin(), |
3894 | P.getLangOpts().CPlusPlus17 && !IsNoexcept |
3895 | ? diag::ext_dynamic_exception_spec |
3896 | : diag::warn_exception_spec_deprecated) |
3897 | << Range; |
3898 | P.Diag(Range.getBegin(), diag::note_exception_spec_deprecated) |
3899 | << Replacement << FixItHint::CreateReplacement(Range, Replacement); |
3900 | } |
3901 | } |
3902 | |
3903 | |
3904 | |
3905 | |
3906 | |
3907 | |
3908 | |
3909 | |
3910 | |
3911 | |
3912 | |
3913 | |
3914 | ExceptionSpecificationType Parser::ParseDynamicExceptionSpecification( |
3915 | SourceRange &SpecificationRange, |
3916 | SmallVectorImpl<ParsedType> &Exceptions, |
3917 | SmallVectorImpl<SourceRange> &Ranges) { |
3918 | assert(Tok.is(tok::kw_throw) && "expected throw"); |
3919 | |
3920 | SpecificationRange.setBegin(ConsumeToken()); |
3921 | BalancedDelimiterTracker T(*this, tok::l_paren); |
3922 | if (T.consumeOpen()) { |
3923 | Diag(Tok, diag::err_expected_lparen_after) << "throw"; |
3924 | SpecificationRange.setEnd(SpecificationRange.getBegin()); |
3925 | return EST_DynamicNone; |
3926 | } |
3927 | |
3928 | |
3929 | |
3930 | if (Tok.is(tok::ellipsis)) { |
3931 | SourceLocation EllipsisLoc = ConsumeToken(); |
3932 | if (!getLangOpts().MicrosoftExt) |
3933 | Diag(EllipsisLoc, diag::ext_ellipsis_exception_spec); |
3934 | T.consumeClose(); |
3935 | SpecificationRange.setEnd(T.getCloseLocation()); |
3936 | diagnoseDynamicExceptionSpecification(*this, SpecificationRange, false); |
3937 | return EST_MSAny; |
3938 | } |
3939 | |
3940 | |
3941 | SourceRange Range; |
3942 | while (Tok.isNot(tok::r_paren)) { |
3943 | TypeResult Res(ParseTypeName(&Range)); |
3944 | |
3945 | if (Tok.is(tok::ellipsis)) { |
3946 | |
3947 | |
3948 | |
3949 | SourceLocation Ellipsis = ConsumeToken(); |
3950 | Range.setEnd(Ellipsis); |
3951 | if (!Res.isInvalid()) |
3952 | Res = Actions.ActOnPackExpansion(Res.get(), Ellipsis); |
3953 | } |
3954 | |
3955 | if (!Res.isInvalid()) { |
3956 | Exceptions.push_back(Res.get()); |
3957 | Ranges.push_back(Range); |
3958 | } |
3959 | |
3960 | if (!TryConsumeToken(tok::comma)) |
3961 | break; |
3962 | } |
3963 | |
3964 | T.consumeClose(); |
3965 | SpecificationRange.setEnd(T.getCloseLocation()); |
3966 | diagnoseDynamicExceptionSpecification(*this, SpecificationRange, |
3967 | Exceptions.empty()); |
3968 | return Exceptions.empty() ? EST_DynamicNone : EST_Dynamic; |
3969 | } |
3970 | |
3971 | |
3972 | |
3973 | TypeResult Parser::ParseTrailingReturnType(SourceRange &Range, |
3974 | bool MayBeFollowedByDirectInit) { |
3975 | assert(Tok.is(tok::arrow) && "expected arrow"); |
3976 | |
3977 | ConsumeToken(); |
3978 | |
3979 | return ParseTypeName(&Range, MayBeFollowedByDirectInit |
3980 | ? DeclaratorContext::TrailingReturnVar |
3981 | : DeclaratorContext::TrailingReturn); |
3982 | } |
3983 | |
3984 | |
3985 | void Parser::ParseTrailingRequiresClause(Declarator &D) { |
3986 | assert(Tok.is(tok::kw_requires) && "expected requires"); |
3987 | |
3988 | SourceLocation RequiresKWLoc = ConsumeToken(); |
3989 | |
3990 | ExprResult TrailingRequiresClause; |
3991 | ParseScope ParamScope(this, |
3992 | Scope::DeclScope | |
3993 | Scope::FunctionDeclarationScope | |
3994 | Scope::FunctionPrototypeScope); |
3995 | |
3996 | Actions.ActOnStartTrailingRequiresClause(getCurScope(), D); |
3997 | |
3998 | llvm::Optional<Sema::CXXThisScopeRAII> ThisScope; |
3999 | InitCXXThisScopeForDeclaratorIfRelevant(D, D.getDeclSpec(), ThisScope); |
4000 | |
4001 | TrailingRequiresClause = |
4002 | ParseConstraintLogicalOrExpression(true); |
4003 | |
4004 | TrailingRequiresClause = |
4005 | Actions.ActOnFinishTrailingRequiresClause(TrailingRequiresClause); |
4006 | |
4007 | if (!D.isDeclarationOfFunction()) { |
4008 | Diag(RequiresKWLoc, |
4009 | diag::err_requires_clause_on_declarator_not_declaring_a_function); |
4010 | return; |
4011 | } |
4012 | |
4013 | if (TrailingRequiresClause.isInvalid()) |
4014 | SkipUntil({tok::l_brace, tok::arrow, tok::kw_try, tok::comma, tok::colon}, |
4015 | StopAtSemi | StopBeforeMatch); |
4016 | else |
4017 | D.setTrailingRequiresClause(TrailingRequiresClause.get()); |
4018 | |
4019 | |
4020 | if (D.isFunctionDeclarator() && Tok.is(tok::arrow) && |
4021 | D.getDeclSpec().getTypeSpecType() == TST_auto) { |
4022 | SourceLocation ArrowLoc = Tok.getLocation(); |
4023 | SourceRange Range; |
4024 | TypeResult TrailingReturnType = |
4025 | ParseTrailingReturnType(Range, false); |
4026 | |
4027 | if (!TrailingReturnType.isInvalid()) { |
4028 | Diag(ArrowLoc, |
4029 | diag::err_requires_clause_must_appear_after_trailing_return) |
4030 | << Range; |
4031 | auto &FunctionChunk = D.getFunctionTypeInfo(); |
4032 | FunctionChunk.HasTrailingReturnType = TrailingReturnType.isUsable(); |
4033 | FunctionChunk.TrailingReturnType = TrailingReturnType.get(); |
4034 | FunctionChunk.TrailingReturnTypeLoc = Range.getBegin(); |
4035 | } else |
4036 | SkipUntil({tok::equal, tok::l_brace, tok::arrow, tok::kw_try, tok::comma}, |
4037 | StopAtSemi | StopBeforeMatch); |
4038 | } |
4039 | } |
4040 | |
4041 | |
4042 | |
4043 | |
4044 | Sema::ParsingClassState |
4045 | Parser::PushParsingClass(Decl *ClassDecl, bool NonNestedClass, |
4046 | bool IsInterface) { |
4047 | assert((NonNestedClass || !ClassStack.empty()) && |
4048 | "Nested class without outer class"); |
4049 | ClassStack.push(new ParsingClass(ClassDecl, NonNestedClass, IsInterface)); |
4050 | return Actions.PushParsingClass(); |
4051 | } |
4052 | |
4053 | |
4054 | |
4055 | void Parser::DeallocateParsedClasses(Parser::ParsingClass *Class) { |
4056 | for (unsigned I = 0, N = Class->LateParsedDeclarations.size(); I != N; ++I) |
4057 | delete Class->LateParsedDeclarations[I]; |
4058 | delete Class; |
4059 | } |
4060 | |
4061 | |
4062 | |
4063 | |
4064 | |
4065 | |
4066 | |
4067 | void Parser::PopParsingClass(Sema::ParsingClassState state) { |
4068 | assert(!ClassStack.empty() && "Mismatched push/pop for class parsing"); |
4069 | |
4070 | Actions.PopParsingClass(state); |
4071 | |
4072 | ParsingClass *Victim = ClassStack.top(); |
4073 | ClassStack.pop(); |
4074 | if (Victim->TopLevelClass) { |
4075 | |
4076 | |
4077 | DeallocateParsedClasses(Victim); |
4078 | return; |
4079 | } |
4080 | assert(!ClassStack.empty() && "Missing top-level class?"); |
4081 | |
4082 | if (Victim->LateParsedDeclarations.empty()) { |
4083 | |
4084 | |
4085 | |
4086 | |
4087 | DeallocateParsedClasses(Victim); |
4088 | return; |
4089 | } |
4090 | |
4091 | |
4092 | |
4093 | |
4094 | assert(getCurScope()->isClassScope() && "Nested class outside of class scope?"); |
4095 | ClassStack.top()->LateParsedDeclarations.push_back( |
4096 | new LateParsedClass(this, Victim)); |
4097 | } |
4098 | |
4099 | |
4100 | |
4101 | |
4102 | |
4103 | |
4104 | |
4105 | |
4106 | |
4107 | |
4108 | IdentifierInfo * |
4109 | Parser::TryParseCXX11AttributeIdentifier(SourceLocation &Loc, |
4110 | Sema::AttributeCompletion Completion, |
4111 | const IdentifierInfo *Scope) { |
4112 | switch (Tok.getKind()) { |
4113 | default: |
4114 | |
4115 | if (!Tok.isAnnotation()) { |
4116 | if (IdentifierInfo *II = Tok.getIdentifierInfo()) { |
4117 | Loc = ConsumeToken(); |
4118 | return II; |
4119 | } |
4120 | } |
4121 | return nullptr; |
4122 | |
4123 | case tok::code_completion: |
4124 | cutOffParsing(); |
4125 | Actions.CodeCompleteAttribute(getLangOpts().CPlusPlus ? ParsedAttr::AS_CXX11 |
4126 | : ParsedAttr::AS_C2x, |
4127 | Completion, Scope); |
4128 | return nullptr; |
4129 | |
4130 | case tok::numeric_constant: { |
4131 | |
4132 | |
4133 | |
4134 | if (Tok.getLocation().isMacroID()) { |
4135 | SmallString<8> ExpansionBuf; |
4136 | SourceLocation ExpansionLoc = |
4137 | PP.getSourceManager().getExpansionLoc(Tok.getLocation()); |
4138 | StringRef Spelling = PP.getSpelling(ExpansionLoc, ExpansionBuf); |
4139 | if (Spelling == "__clang__") { |
4140 | SourceRange TokRange( |
4141 | ExpansionLoc, |
4142 | PP.getSourceManager().getExpansionLoc(Tok.getEndLoc())); |
4143 | Diag(Tok, diag::warn_wrong_clang_attr_namespace) |
4144 | << FixItHint::CreateReplacement(TokRange, "_Clang"); |
4145 | Loc = ConsumeToken(); |
4146 | return &PP.getIdentifierTable().get("_Clang"); |
4147 | } |
4148 | } |
4149 | return nullptr; |
4150 | } |
4151 | |
4152 | case tok::ampamp: |
4153 | case tok::pipe: |
4154 | case tok::pipepipe: |
4155 | case tok::caret: |
4156 | case tok::tilde: |
4157 | case tok::amp: |
4158 | case tok::ampequal: |
4159 | case tok::pipeequal: |
4160 | case tok::caretequal: |
4161 | case tok::exclaim: |
4162 | case tok::exclaimequal: |
4163 | |
4164 | |
4165 | SmallString<8> SpellingBuf; |
4166 | SourceLocation SpellingLoc = |
4167 | PP.getSourceManager().getSpellingLoc(Tok.getLocation()); |
4168 | StringRef Spelling = PP.getSpelling(SpellingLoc, SpellingBuf); |
4169 | if (isLetter(Spelling[0])) { |
4170 | Loc = ConsumeToken(); |
4171 | return &PP.getIdentifierTable().get(Spelling); |
4172 | } |
4173 | return nullptr; |
4174 | } |
4175 | } |
4176 | |
4177 | void Parser::ParseOpenMPAttributeArgs(IdentifierInfo *AttrName, |
4178 | CachedTokens &OpenMPTokens) { |
4179 | |
4180 | |
4181 | BalancedDelimiterTracker T(*this, tok::l_paren); |
4182 | if (T.consumeOpen()) { |
4183 | Diag(Tok, diag::err_expected) << tok::l_paren; |
4184 | return; |
4185 | } |
4186 | |
4187 | if (AttrName->isStr("directive")) { |
4188 | |
4189 | |
4190 | |
4191 | Token OMPBeginTok; |
4192 | OMPBeginTok.startToken(); |
4193 | OMPBeginTok.setKind(tok::annot_attr_openmp); |
4194 | OMPBeginTok.setLocation(Tok.getLocation()); |
4195 | OpenMPTokens.push_back(OMPBeginTok); |
4196 | |
4197 | ConsumeAndStoreUntil(tok::r_paren, OpenMPTokens, false, |
4198 | false); |
4199 | Token OMPEndTok; |
4200 | OMPEndTok.startToken(); |
4201 | OMPEndTok.setKind(tok::annot_pragma_openmp_end); |
4202 | OMPEndTok.setLocation(Tok.getLocation()); |
4203 | OpenMPTokens.push_back(OMPEndTok); |
4204 | } else { |
4205 | assert(AttrName->isStr("sequence") && |
4206 | "Expected either 'directive' or 'sequence'"); |
4207 | |
4208 | |
4209 | |
4210 | do { |
4211 | |
4212 | |
4213 | |
4214 | SourceLocation IdentLoc; |
4215 | IdentifierInfo *Ident = TryParseCXX11AttributeIdentifier(IdentLoc); |
4216 | |
4217 | |
4218 | |
4219 | if (Ident && Ident->isStr("omp") && !ExpectAndConsume(tok::coloncolon)) |
4220 | Ident = TryParseCXX11AttributeIdentifier(IdentLoc); |
4221 | |
4222 | |
4223 | |
4224 | if (!Ident || (!Ident->isStr("directive") && !Ident->isStr("sequence"))) { |
4225 | Diag(Tok.getLocation(), diag::err_expected_sequence_or_directive); |
4226 | SkipUntil(tok::r_paren, StopBeforeMatch); |
4227 | continue; |
4228 | } |
4229 | |
4230 | |
4231 | ParseOpenMPAttributeArgs(Ident, OpenMPTokens); |
4232 | |
4233 | |
4234 | |
4235 | } while (TryConsumeToken(tok::comma)); |
4236 | } |
4237 | |
4238 | T.consumeClose(); |
4239 | } |
4240 | |
4241 | static bool IsBuiltInOrStandardCXX11Attribute(IdentifierInfo *AttrName, |
4242 | IdentifierInfo *ScopeName) { |
4243 | switch ( |
4244 | ParsedAttr::getParsedKind(AttrName, ScopeName, ParsedAttr::AS_CXX11)) { |
4245 | case ParsedAttr::AT_CarriesDependency: |
4246 | case ParsedAttr::AT_Deprecated: |
4247 | case ParsedAttr::AT_FallThrough: |
4248 | case ParsedAttr::AT_CXX11NoReturn: |
4249 | case ParsedAttr::AT_NoUniqueAddress: |
4250 | case ParsedAttr::AT_Likely: |
4251 | case ParsedAttr::AT_Unlikely: |
4252 | return true; |
4253 | case ParsedAttr::AT_WarnUnusedResult: |
4254 | return !ScopeName && AttrName->getName().equals("nodiscard"); |
4255 | case ParsedAttr::AT_Unused: |
4256 | return !ScopeName && AttrName->getName().equals("maybe_unused"); |
4257 | default: |
4258 | return false; |
4259 | } |
4260 | } |
4261 | |
4262 | |
4263 | |
4264 | |
4265 | |
4266 | |
4267 | |
4268 | |
4269 | |
4270 | |
4271 | |
4272 | |
4273 | |
4274 | |
4275 | |
4276 | bool Parser::ParseCXX11AttributeArgs(IdentifierInfo *AttrName, |
4277 | SourceLocation AttrNameLoc, |
4278 | ParsedAttributes &Attrs, |
4279 | SourceLocation *EndLoc, |
4280 | IdentifierInfo *ScopeName, |
4281 | SourceLocation ScopeLoc, |
4282 | CachedTokens &OpenMPTokens) { |
4283 | assert(Tok.is(tok::l_paren) && "Not a C++11 attribute argument list"); |
4284 | SourceLocation LParenLoc = Tok.getLocation(); |
4285 | const LangOptions &LO = getLangOpts(); |
4286 | ParsedAttr::Syntax Syntax = |
4287 | LO.CPlusPlus ? ParsedAttr::AS_CXX11 : ParsedAttr::AS_C2x; |
4288 | |
4289 | |
4290 | |
4291 | if (!hasAttribute(LO.CPlusPlus ? AttrSyntax::CXX : AttrSyntax::C, ScopeName, |
4292 | AttrName, getTargetInfo(), getLangOpts())) { |
4293 | |
4294 | ConsumeParen(); |
4295 | SkipUntil(tok::r_paren); |
4296 | return false; |
4297 | } |
4298 | |
4299 | if (ScopeName && (ScopeName->isStr("gnu") || ScopeName->isStr("__gnu__"))) { |
4300 | |
4301 | |
4302 | ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName, |
4303 | ScopeLoc, Syntax, nullptr); |
4304 | return true; |
4305 | } |
4306 | |
4307 | if (ScopeName && ScopeName->isStr("omp")) { |
4308 | Diag(AttrNameLoc, getLangOpts().OpenMP >= 51 |
4309 | ? diag::warn_omp51_compat_attributes |
4310 | : diag::ext_omp_attributes); |
4311 | |
4312 | ParseOpenMPAttributeArgs(AttrName, OpenMPTokens); |
4313 | |
4314 | |
4315 | |
4316 | return true; |
4317 | } |
4318 | |
4319 | unsigned NumArgs; |
4320 | |
4321 | if (ScopeName && (ScopeName->isStr("clang") || ScopeName->isStr("_Clang"))) |
4322 | NumArgs = ParseClangAttributeArgs(AttrName, AttrNameLoc, Attrs, EndLoc, |
4323 | ScopeName, ScopeLoc, Syntax); |
4324 | else |
4325 | NumArgs = |
4326 | ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc, |
4327 | ScopeName, ScopeLoc, Syntax); |
4328 | |
4329 | if (!Attrs.empty() && |
4330 | IsBuiltInOrStandardCXX11Attribute(AttrName, ScopeName)) { |
4331 | ParsedAttr &Attr = Attrs.back(); |
4332 | |
4333 | |
4334 | |
4335 | |
4336 | if (Attr.getMaxArgs() && !NumArgs) { |
4337 | |
4338 | |
4339 | Diag(LParenLoc, diag::err_attribute_requires_arguments) << AttrName; |
4340 | Attr.setInvalid(true); |
4341 | } else if (!Attr.getMaxArgs()) { |
4342 | |
4343 | |
4344 | |
4345 | Diag(LParenLoc, diag::err_cxx11_attribute_forbids_arguments) |
4346 | << AttrName |
4347 | << FixItHint::CreateRemoval(SourceRange(LParenLoc, *EndLoc)); |
4348 | Attr.setInvalid(true); |
4349 | } |
4350 | } |
4351 | return true; |
4352 | } |
4353 | |
4354 | |
4355 | |
4356 | |
4357 | |
4358 | |
4359 | |
4360 | |
4361 | |
4362 | |
4363 | |
4364 | |
4365 | |
4366 | |
4367 | |
4368 | |
4369 | |
4370 | |
4371 | |
4372 | |
4373 | |
4374 | |
4375 | |
4376 | |
4377 | |
4378 | void Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs, |
4379 | CachedTokens &OpenMPTokens, |
4380 | SourceLocation *EndLoc) { |
4381 | if (Tok.is(tok::kw_alignas)) { |
4382 | Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas); |
4383 | ParseAlignmentSpecifier(Attrs, EndLoc); |
4384 | return; |
4385 | } |
4386 | |
4387 | assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square) && |
4388 | "Not a double square bracket attribute list"); |
4389 | |
4390 | SourceLocation OpenLoc = Tok.getLocation(); |
4391 | Diag(OpenLoc, diag::warn_cxx98_compat_attribute); |
4392 | |
4393 | ConsumeBracket(); |
4394 | checkCompoundToken(OpenLoc, tok::l_square, CompoundToken::AttrBegin); |
4395 | ConsumeBracket(); |
4396 | |
4397 | SourceLocation CommonScopeLoc; |
4398 | IdentifierInfo *CommonScopeName = nullptr; |
4399 | if (Tok.is(tok::kw_using)) { |
4400 | Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 |
4401 | ? diag::warn_cxx14_compat_using_attribute_ns |
4402 | : diag::ext_using_attribute_ns); |
4403 | ConsumeToken(); |
4404 | |
4405 | CommonScopeName = TryParseCXX11AttributeIdentifier( |
4406 | CommonScopeLoc, Sema::AttributeCompletion::Scope); |
4407 | if (!CommonScopeName) { |
4408 | Diag(Tok.getLocation(), diag::err_expected) << tok::identifier; |
4409 | SkipUntil(tok::r_square, tok::colon, StopBeforeMatch); |
4410 | } |
4411 | if (!TryConsumeToken(tok::colon) && CommonScopeName) |
4412 | Diag(Tok.getLocation(), diag::err_expected) << tok::colon; |
4413 | } |
4414 | |
4415 | llvm::SmallDenseMap<IdentifierInfo*, SourceLocation, 4> SeenAttrs; |
4416 | |
4417 | bool AttrParsed = false; |
4418 | while (!Tok.isOneOf(tok::r_square, tok::semi, tok::eof)) { |
4419 | if (AttrParsed) { |
4420 | |
4421 | |
4422 | if (ExpectAndConsume(tok::comma)) { |
4423 | SkipUntil(tok::r_square, StopAtSemi | StopBeforeMatch); |
4424 | continue; |
4425 | } |
4426 | AttrParsed = false; |
4427 | } |
4428 | |
4429 | |
4430 | while (TryConsumeToken(tok::comma)) |
4431 | ; |
4432 | |
4433 | SourceLocation ScopeLoc, AttrLoc; |
4434 | IdentifierInfo *ScopeName = nullptr, *AttrName = nullptr; |
4435 | |
4436 | AttrName = TryParseCXX11AttributeIdentifier( |
4437 | AttrLoc, Sema::AttributeCompletion::Attribute, CommonScopeName); |
4438 | if (!AttrName) |
4439 | |
4440 | break; |
4441 | |
4442 | |
4443 | if (TryConsumeToken(tok::coloncolon)) { |
4444 | ScopeName = AttrName; |
4445 | ScopeLoc = AttrLoc; |
4446 | |
4447 | AttrName = TryParseCXX11AttributeIdentifier( |
4448 | AttrLoc, Sema::AttributeCompletion::Attribute, ScopeName); |
4449 | if (!AttrName) { |
4450 | Diag(Tok.getLocation(), diag::err_expected) << tok::identifier; |
4451 | SkipUntil(tok::r_square, tok::comma, StopAtSemi | StopBeforeMatch); |
4452 | continue; |
4453 | } |
4454 | } |
4455 | |
4456 | if (CommonScopeName) { |
4457 | if (ScopeName) { |
4458 | Diag(ScopeLoc, diag::err_using_attribute_ns_conflict) |
4459 | << SourceRange(CommonScopeLoc); |
4460 | } else { |
4461 | ScopeName = CommonScopeName; |
4462 | ScopeLoc = CommonScopeLoc; |
4463 | } |
4464 | } |
4465 | |
4466 | |
4467 | if (Tok.is(tok::l_paren)) |
4468 | AttrParsed = ParseCXX11AttributeArgs(AttrName, AttrLoc, Attrs, EndLoc, |
4469 | ScopeName, ScopeLoc, OpenMPTokens); |
4470 | |
4471 | if (!AttrParsed) { |
4472 | Attrs.addNew( |
4473 | AttrName, |
4474 | SourceRange(ScopeLoc.isValid() ? ScopeLoc : AttrLoc, AttrLoc), |
4475 | ScopeName, ScopeLoc, nullptr, 0, |
4476 | getLangOpts().CPlusPlus ? ParsedAttr::AS_CXX11 : ParsedAttr::AS_C2x); |
4477 | AttrParsed = true; |
4478 | } |
4479 | |
4480 | if (TryConsumeToken(tok::ellipsis)) |
4481 | Diag(Tok, diag::err_cxx11_attribute_forbids_ellipsis) |
4482 | << AttrName; |
4483 | } |
4484 | |
4485 | |
4486 | |
4487 | if (Tok.is(tok::semi)) { |
4488 | ConsumeToken(); |
4489 | return; |
4490 | } |
4491 | |
4492 | SourceLocation CloseLoc = Tok.getLocation(); |
4493 | if (ExpectAndConsume(tok::r_square)) |
4494 | SkipUntil(tok::r_square); |
4495 | else if (Tok.is(tok::r_square)) |
4496 | checkCompoundToken(CloseLoc, tok::r_square, CompoundToken::AttrEnd); |
4497 | if (EndLoc) |
4498 | *EndLoc = Tok.getLocation(); |
4499 | if (ExpectAndConsume(tok::r_square)) |
4500 | SkipUntil(tok::r_square); |
4501 | } |
4502 | |
4503 | |
4504 | |
4505 | |
4506 | |
4507 | void Parser::ParseCXX11Attributes(ParsedAttributesWithRange &attrs, |
4508 | SourceLocation *endLoc) { |
4509 | assert(standardAttributesAllowed()); |
4510 | |
4511 | SourceLocation StartLoc = Tok.getLocation(), Loc; |
4512 | if (!endLoc) |
4513 | endLoc = &Loc; |
4514 | |
4515 | do { |
4516 | ParseCXX11AttributeSpecifier(attrs, endLoc); |
4517 | } while (isCXX11AttributeSpecifier()); |
4518 | |
4519 | attrs.Range = SourceRange(StartLoc, *endLoc); |
4520 | } |
4521 | |
4522 | void Parser::DiagnoseAndSkipCXX11Attributes() { |
4523 | |
4524 | SourceLocation StartLoc = Tok.getLocation(); |
4525 | SourceLocation EndLoc = SkipCXX11Attributes(); |
4526 | |
4527 | if (EndLoc.isValid()) { |
4528 | SourceRange Range(StartLoc, EndLoc); |
4529 | Diag(StartLoc, diag::err_attributes_not_allowed) |
4530 | << Range; |
4531 | } |
4532 | } |
4533 | |
4534 | SourceLocation Parser::SkipCXX11Attributes() { |
4535 | SourceLocation EndLoc; |
4536 | |
4537 | if (!isCXX11AttributeSpecifier()) |
4538 | return EndLoc; |
4539 | |
4540 | do { |
4541 | if (Tok.is(tok::l_square)) { |
4542 | BalancedDelimiterTracker T(*this, tok::l_square); |
4543 | T.consumeOpen(); |
4544 | T.skipToEnd(); |
4545 | EndLoc = T.getCloseLocation(); |
4546 | } else { |
4547 | assert(Tok.is(tok::kw_alignas) && "not an attribute specifier"); |
4548 | ConsumeToken(); |
4549 | BalancedDelimiterTracker T(*this, tok::l_paren); |
4550 | if (!T.consumeOpen()) |
4551 | T.skipToEnd(); |
4552 | EndLoc = T.getCloseLocation(); |
4553 | } |
4554 | } while (isCXX11AttributeSpecifier()); |
4555 | |
4556 | return EndLoc; |
4557 | } |
4558 | |
4559 | |
4560 | void Parser::ParseMicrosoftUuidAttributeArgs(ParsedAttributes &Attrs) { |
4561 | assert(Tok.is(tok::identifier) && "Not a Microsoft attribute list"); |
4562 | IdentifierInfo *UuidIdent = Tok.getIdentifierInfo(); |
4563 | assert(UuidIdent->getName() == "uuid" && "Not a Microsoft attribute list"); |
4564 | |
4565 | SourceLocation UuidLoc = Tok.getLocation(); |
4566 | ConsumeToken(); |
4567 | |
4568 | |
4569 | BalancedDelimiterTracker T(*this, tok::l_paren); |
4570 | if (T.consumeOpen()) { |
4571 | Diag(Tok, diag::err_expected) << tok::l_paren; |
4572 | return; |
4573 | } |
4574 | |
4575 | ArgsVector ArgExprs; |
4576 | if (Tok.is(tok::string_literal)) { |
4577 | |
4578 | ExprResult StringResult = ParseStringLiteralExpression(); |
4579 | if (StringResult.isInvalid()) |
4580 | return; |
4581 | ArgExprs.push_back(StringResult.get()); |
4582 | } else { |
4583 | |
4584 | |
4585 | |
4586 | |
4587 | SmallString<42> StrBuffer; |
4588 | StrBuffer += "\""; |
4589 | |
4590 | |
4591 | |
4592 | |
4593 | |
4594 | |
4595 | |
4596 | |
4597 | SourceLocation StartLoc = Tok.getLocation(); |
4598 | while (Tok.isNot(tok::r_paren)) { |
4599 | if (Tok.hasLeadingSpace() || Tok.isAtStartOfLine()) { |
4600 | Diag(Tok, diag::err_attribute_uuid_malformed_guid); |
4601 | SkipUntil(tok::r_paren, StopAtSemi); |
4602 | return; |
4603 | } |
4604 | SmallString<16> SpellingBuffer; |
4605 | SpellingBuffer.resize(Tok.getLength() + 1); |
4606 | bool Invalid = false; |
4607 | StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid); |
4608 | if (Invalid) { |
4609 | SkipUntil(tok::r_paren, StopAtSemi); |
4610 | return; |
4611 | } |
4612 | StrBuffer += TokSpelling; |
4613 | ConsumeAnyToken(); |
4614 | } |
4615 | StrBuffer += "\""; |
4616 | |
4617 | if (Tok.hasLeadingSpace() || Tok.isAtStartOfLine()) { |
4618 | Diag(Tok, diag::err_attribute_uuid_malformed_guid); |
4619 | ConsumeParen(); |
4620 | return; |
4621 | } |
4622 | |
4623 | |
4624 | |
4625 | |
4626 | Token Toks[1]; |
4627 | Toks[0].startToken(); |
4628 | Toks[0].setKind(tok::string_literal); |
4629 | Toks[0].setLocation(StartLoc); |
4630 | Toks[0].setLiteralData(StrBuffer.data()); |
4631 | Toks[0].setLength(StrBuffer.size()); |
4632 | StringLiteral *UuidString = |
4633 | cast<StringLiteral>(Actions.ActOnStringLiteral(Toks, nullptr).get()); |
4634 | ArgExprs.push_back(UuidString); |
4635 | } |
4636 | |
4637 | if (!T.consumeClose()) { |
4638 | Attrs.addNew(UuidIdent, SourceRange(UuidLoc, T.getCloseLocation()), nullptr, |
4639 | SourceLocation(), ArgExprs.data(), ArgExprs.size(), |
4640 | ParsedAttr::AS_Microsoft); |
4641 | } |
4642 | } |
4643 | |
4644 | |
4645 | |
4646 | |
4647 | |
4648 | |
4649 | |
4650 | |
4651 | |
4652 | void Parser::ParseMicrosoftAttributes(ParsedAttributes &attrs, |
4653 | SourceLocation *endLoc) { |
4654 | assert(Tok.is(tok::l_square) && "Not a Microsoft attribute list"); |
4655 | |
4656 | do { |
4657 | |
4658 | BalancedDelimiterTracker T(*this, tok::l_square); |
4659 | T.consumeOpen(); |
4660 | |
4661 | |
4662 | while (true) { |
4663 | SkipUntil(tok::r_square, tok::identifier, |
4664 | StopAtSemi | StopBeforeMatch | StopAtCodeCompletion); |
4665 | if (Tok.is(tok::code_completion)) { |
4666 | cutOffParsing(); |
4667 | Actions.CodeCompleteAttribute(AttributeCommonInfo::AS_Microsoft, |
4668 | Sema::AttributeCompletion::Attribute, |
4669 | nullptr); |
4670 | break; |
4671 | } |
4672 | if (Tok.isNot(tok::identifier)) |
4673 | break; |
4674 | if (Tok.getIdentifierInfo()->getName() == "uuid") |
4675 | ParseMicrosoftUuidAttributeArgs(attrs); |
4676 | else |
4677 | ConsumeToken(); |
4678 | } |
4679 | |
4680 | T.consumeClose(); |
4681 | if (endLoc) |
4682 | *endLoc = T.getCloseLocation(); |
4683 | } while (Tok.is(tok::l_square)); |
4684 | } |
4685 | |
4686 | void Parser::ParseMicrosoftIfExistsClassDeclaration( |
4687 | DeclSpec::TST TagType, ParsedAttributes &AccessAttrs, |
4688 | AccessSpecifier &CurAS) { |
4689 | IfExistsCondition Result; |
4690 | if (ParseMicrosoftIfExistsCondition(Result)) |
4691 | return; |
4692 | |
4693 | BalancedDelimiterTracker Braces(*this, tok::l_brace); |
4694 | if (Braces.consumeOpen()) { |
4695 | Diag(Tok, diag::err_expected) << tok::l_brace; |
4696 | return; |
4697 | } |
4698 | |
4699 | switch (Result.Behavior) { |
4700 | case IEB_Parse: |
4701 | |
4702 | break; |
4703 | |
4704 | case IEB_Dependent: |
4705 | Diag(Result.KeywordLoc, diag::warn_microsoft_dependent_exists) |
4706 | << Result.IsIfExists; |
4707 | |
4708 | LLVM_FALLTHROUGH; |
4709 | |
4710 | case IEB_Skip: |
4711 | Braces.skipToEnd(); |
4712 | return; |
4713 | } |
4714 | |
4715 | while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { |
4716 | |
4717 | if (Tok.isOneOf(tok::kw___if_exists, tok::kw___if_not_exists)) { |
4718 | ParseMicrosoftIfExistsClassDeclaration(TagType, |
4719 | AccessAttrs, CurAS); |
4720 | continue; |
4721 | } |
4722 | |
4723 | |
4724 | if (Tok.is(tok::semi)) { |
4725 | ConsumeExtraSemi(InsideStruct, TagType); |
4726 | continue; |
4727 | } |
4728 | |
4729 | AccessSpecifier AS = getAccessSpecifierIfPresent(); |
4730 | if (AS != AS_none) { |
4731 | |
4732 | CurAS = AS; |
4733 | SourceLocation ASLoc = Tok.getLocation(); |
4734 | ConsumeToken(); |
4735 | if (Tok.is(tok::colon)) |
4736 | Actions.ActOnAccessSpecifier(AS, ASLoc, Tok.getLocation(), |
4737 | ParsedAttributesView{}); |
4738 | else |
4739 | Diag(Tok, diag::err_expected) << tok::colon; |
4740 | ConsumeToken(); |
4741 | continue; |
4742 | } |
4743 | |
4744 | |
4745 | ParseCXXClassMemberDeclaration(CurAS, AccessAttrs); |
4746 | } |
4747 | |
4748 | Braces.consumeClose(); |
4749 | } |
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | |
15 | |
16 | |
17 | |
18 | |
19 | |
20 | |
21 | |
22 | #ifndef LLVM_CLANG_SEMA_DECLSPEC_H |
23 | #define LLVM_CLANG_SEMA_DECLSPEC_H |
24 | |
25 | #include "clang/AST/DeclCXX.h" |
26 | #include "clang/AST/DeclObjCCommon.h" |
27 | #include "clang/AST/NestedNameSpecifier.h" |
28 | #include "clang/Basic/ExceptionSpecificationType.h" |
29 | #include "clang/Basic/Lambda.h" |
30 | #include "clang/Basic/OperatorKinds.h" |
31 | #include "clang/Basic/Specifiers.h" |
32 | #include "clang/Lex/Token.h" |
33 | #include "clang/Sema/Ownership.h" |
34 | #include "clang/Sema/ParsedAttr.h" |
35 | #include "llvm/ADT/SmallVector.h" |
36 | #include "llvm/Support/Compiler.h" |
37 | #include "llvm/Support/ErrorHandling.h" |
38 | |
39 | namespace clang { |
40 | class ASTContext; |
41 | class CXXRecordDecl; |
42 | class TypeLoc; |
43 | class LangOptions; |
44 | class IdentifierInfo; |
45 | class NamespaceAliasDecl; |
46 | class NamespaceDecl; |
47 | class ObjCDeclSpec; |
48 | class Sema; |
49 | class Declarator; |
50 | struct TemplateIdAnnotation; |
51 | |
52 | |
53 | |
54 | |
55 | |
56 | |
57 | |
58 | |
59 | |
60 | |
61 | |
62 | |
63 | |
64 | class CXXScopeSpec { |
65 | SourceRange Range; |
66 | NestedNameSpecifierLocBuilder Builder; |
67 | |
68 | public: |
69 | SourceRange getRange() const { return Range; } |
70 | void setRange(SourceRange R) { Range = R; } |
71 | void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); } |
72 | void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); } |
73 | SourceLocation getBeginLoc() const { return Range.getBegin(); } |
74 | SourceLocation getEndLoc() const { return Range.getEnd(); } |
75 | |
76 | |
77 | NestedNameSpecifier *getScopeRep() const { |
78 | return Builder.getRepresentation(); |
79 | } |
80 | |
81 | |
82 | |
83 | |
84 | |
85 | |
86 | |
87 | |
88 | |
89 | |
90 | |
91 | |
92 | void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, |
93 | SourceLocation ColonColonLoc); |
94 | |
95 | |
96 | |
97 | |
98 | |
99 | |
100 | |
101 | |
102 | |
103 | |
104 | |
105 | |
106 | void Extend(ASTContext &Context, IdentifierInfo *Identifier, |
107 | SourceLocation IdentifierLoc, SourceLocation ColonColonLoc); |
108 | |
109 | |
110 | |
111 | |
112 | |
113 | |
114 | |
115 | |
116 | |
117 | |
118 | |
119 | |
120 | void Extend(ASTContext &Context, NamespaceDecl *Namespace, |
121 | SourceLocation NamespaceLoc, SourceLocation ColonColonLoc); |
122 | |
123 | |
124 | |
125 | |
126 | |
127 | |
128 | |
129 | |
130 | |
131 | |
132 | |
133 | |
134 | |
135 | void Extend(ASTContext &Context, NamespaceAliasDecl *Alias, |
136 | SourceLocation AliasLoc, SourceLocation ColonColonLoc); |
137 | |
138 | |
139 | |
140 | void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc); |
141 | |
142 | |
143 | |
144 | |
145 | |
146 | |
147 | |
148 | |
149 | |
150 | |
151 | |
152 | |
153 | |
154 | |
155 | void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, |
156 | SourceLocation SuperLoc, SourceLocation ColonColonLoc); |
157 | |
158 | |
159 | |
160 | |
161 | |
162 | |
163 | |
164 | void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, |
165 | SourceRange R); |
166 | |
167 | |
168 | |
169 | void Adopt(NestedNameSpecifierLoc Other); |
170 | |
171 | |
172 | |
173 | |
174 | |
175 | |
176 | NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const; |
177 | |
178 | |
179 | |
180 | |
181 | |
182 | |
183 | |
184 | |
185 | |
186 | |
187 | SourceLocation getLastQualifierNameLoc() const; |
188 | |
189 | |
190 | bool isEmpty() const { return Range.isInvalid() && getScopeRep() == nullptr; } |
| 30 | | Assuming the condition is false | |
|
| 31 | | Returning zero, which participates in a condition later | |
|
191 | |
192 | bool isNotEmpty() const { return !isEmpty(); } |
| 29 | | Calling 'CXXScopeSpec::isEmpty' | |
|
| 32 | | Returning from 'CXXScopeSpec::isEmpty' | |
|
| 33 | | Returning the value 1, which participates in a condition later | |
|
193 | |
194 | |
195 | bool isInvalid() const { return Range.isValid() && getScopeRep() == nullptr; } |
| 16 | | Returning zero, which participates in a condition later | |
|
196 | |
197 | bool isValid() const { return getScopeRep() != nullptr; } |
198 | |
199 | |
200 | void SetInvalid(SourceRange R) { |
201 | assert(R.isValid() && "Must have a valid source range"); |
202 | if (Range.getBegin().isInvalid()) |
203 | Range.setBegin(R.getBegin()); |
204 | Range.setEnd(R.getEnd()); |
205 | Builder.Clear(); |
206 | } |
207 | |
208 | |
209 | |
210 | bool isSet() const { return getScopeRep() != nullptr; } |
211 | |
212 | void clear() { |
213 | Range = SourceRange(); |
214 | Builder.Clear(); |
215 | } |
216 | |
217 | |
218 | char *location_data() const { return Builder.getBuffer().first; } |
219 | |
220 | |
221 | |
222 | unsigned location_size() const { return Builder.getBuffer().second; } |
223 | }; |
224 | |
225 | |
226 | |
227 | |
228 | |
229 | class DeclSpec { |
230 | public: |
231 | |
232 | |
233 | enum SCS { |
234 | SCS_unspecified = 0, |
235 | SCS_typedef, |
236 | SCS_extern, |
237 | SCS_static, |
238 | SCS_auto, |
239 | SCS_register, |
240 | SCS_private_extern, |
241 | SCS_mutable |
242 | }; |
243 | |
244 | |
245 | |
246 | typedef ThreadStorageClassSpecifier TSCS; |
247 | static const TSCS TSCS_unspecified = clang::TSCS_unspecified; |
248 | static const TSCS TSCS___thread = clang::TSCS___thread; |
249 | static const TSCS TSCS_thread_local = clang::TSCS_thread_local; |
250 | static const TSCS TSCS__Thread_local = clang::TSCS__Thread_local; |
251 | |
252 | enum TSC { |
253 | TSC_unspecified, |
254 | TSC_imaginary, |
255 | TSC_complex |
256 | }; |
257 | |
258 | |
259 | typedef TypeSpecifierType TST; |
260 | static const TST TST_unspecified = clang::TST_unspecified; |
261 | static const TST TST_void = clang::TST_void; |
262 | static const TST TST_char = clang::TST_char; |
263 | static const TST TST_wchar = clang::TST_wchar; |
264 | static const TST TST_char8 = clang::TST_char8; |
265 | static const TST TST_char16 = clang::TST_char16; |
266 | static const TST TST_char32 = clang::TST_char32; |
267 | static const TST TST_int = clang::TST_int; |
268 | static const TST TST_int128 = clang::TST_int128; |
269 | static const TST TST_extint = clang::TST_extint; |
270 | static const TST TST_half = clang::TST_half; |
271 | static const TST TST_BFloat16 = clang::TST_BFloat16; |
272 | static const TST TST_float = clang::TST_float; |
273 | static const TST TST_double = clang::TST_double; |
274 | static const TST TST_float16 = clang::TST_Float16; |
275 | static const TST TST_accum = clang::TST_Accum; |
276 | static const TST TST_fract = clang::TST_Fract; |
277 | static const TST TST_float128 = clang::TST_float128; |
278 | static const TST TST_bool = clang::TST_bool; |
279 | static const TST TST_decimal32 = clang::TST_decimal32; |
280 | static const TST TST_decimal64 = clang::TST_decimal64; |
281 | static const TST TST_decimal128 = clang::TST_decimal128; |
282 | static const TST TST_enum = clang::TST_enum; |
283 | static const TST TST_union = clang::TST_union; |
284 | static const TST TST_struct = clang::TST_struct; |
285 | static const TST TST_interface = clang::TST_interface; |
286 | static const TST TST_class = clang::TST_class; |
287 | static const TST TST_typename = clang::TST_typename; |
288 | static const TST TST_typeofType = clang::TST_typeofType; |
289 | static const TST TST_typeofExpr = clang::TST_typeofExpr; |
290 | static const TST TST_decltype = clang::TST_decltype; |
291 | static const TST TST_decltype_auto = clang::TST_decltype_auto; |
292 | static const TST TST_underlyingType = clang::TST_underlyingType; |
293 | static const TST TST_auto = clang::TST_auto; |
294 | static const TST TST_auto_type = clang::TST_auto_type; |
295 | static const TST TST_unknown_anytype = clang::TST_unknown_anytype; |
296 | static const TST TST_atomic = clang::TST_atomic; |
297 | #define GENERIC_IMAGE_TYPE(ImgType, Id) \ |
298 | static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t; |
299 | #include "clang/Basic/OpenCLImageTypes.def" |
300 | static const TST TST_error = clang::TST_error; |
301 | |
302 | |
303 | enum TQ { |
304 | TQ_unspecified = 0, |
305 | TQ_const = 1, |
306 | TQ_restrict = 2, |
307 | TQ_volatile = 4, |
308 | TQ_unaligned = 8, |
309 | |
310 | |
311 | TQ_atomic = 16 |
312 | }; |
313 | |
314 | |
315 | |
316 | enum ParsedSpecifiers { |
317 | PQ_None = 0, |
318 | PQ_StorageClassSpecifier = 1, |
319 | PQ_TypeSpecifier = 2, |
320 | PQ_TypeQualifier = 4, |
321 | PQ_FunctionSpecifier = 8 |
322 | |
323 | }; |
324 | |
325 | private: |
326 | |
327 | unsigned StorageClassSpec : 3; |
328 | unsigned ThreadStorageClassSpec : 2; |
329 | unsigned SCS_extern_in_linkage_spec : 1; |
330 | |
331 | |
332 | unsigned TypeSpecWidth : 2; |
333 | unsigned TypeSpecComplex : 2; |
334 | unsigned TypeSpecSign : 2; |
335 | unsigned TypeSpecType : 6; |
336 | unsigned TypeAltiVecVector : 1; |
337 | unsigned TypeAltiVecPixel : 1; |
338 | unsigned TypeAltiVecBool : 1; |
339 | unsigned TypeSpecOwned : 1; |
340 | unsigned TypeSpecPipe : 1; |
341 | unsigned TypeSpecSat : 1; |
342 | unsigned ConstrainedAuto : 1; |
343 | |
344 | |
345 | unsigned TypeQualifiers : 5; |
346 | |
347 | |
348 | unsigned FS_inline_specified : 1; |
349 | unsigned FS_forceinline_specified: 1; |
350 | unsigned FS_virtual_specified : 1; |
351 | unsigned FS_noreturn_specified : 1; |
352 | |
353 | |
354 | unsigned Friend_specified : 1; |
355 | |
356 | |
357 | unsigned ConstexprSpecifier : 2; |
358 | |
359 | union { |
360 | UnionParsedType TypeRep; |
361 | Decl *DeclRep; |
362 | Expr *ExprRep; |
363 | TemplateIdAnnotation *TemplateIdRep; |
364 | }; |
365 | |
366 | |
367 | ExplicitSpecifier FS_explicit_specifier; |
368 | |
369 | |
370 | ParsedAttributes Attrs; |
371 | |
372 | |
373 | CXXScopeSpec TypeScope; |
374 | |
375 | |
376 | |
377 | SourceRange Range; |
378 | |
379 | SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc; |
380 | SourceRange TSWRange; |
381 | SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc; |
382 | |
383 | |
384 | |
385 | |
386 | SourceLocation TSTNameLoc; |
387 | SourceRange TypeofParensRange; |
388 | SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc, |
389 | TQ_unalignedLoc; |
390 | SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc; |
391 | SourceLocation FS_explicitCloseParenLoc; |
392 | SourceLocation FS_forceinlineLoc; |
393 | SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc; |
394 | SourceLocation TQ_pipeLoc; |
395 | |
396 | WrittenBuiltinSpecs writtenBS; |
397 | void SaveWrittenBuiltinSpecs(); |
398 | |
399 | ObjCDeclSpec *ObjCQualifiers; |
400 | |
401 | static bool isTypeRep(TST T) { |
402 | return (T == TST_typename || T == TST_typeofType || |
403 | T == TST_underlyingType || T == TST_atomic); |
404 | } |
405 | static bool isExprRep(TST T) { |
406 | return (T == TST_typeofExpr || T == TST_decltype || T == TST_extint); |
407 | } |
408 | static bool isTemplateIdRep(TST T) { |
409 | return (T == TST_auto || T == TST_decltype_auto); |
410 | } |
411 | |
412 | DeclSpec(const DeclSpec &) = delete; |
413 | void operator=(const DeclSpec &) = delete; |
414 | public: |
415 | static bool isDeclRep(TST T) { |
416 | return (T == TST_enum || T == TST_struct || |
417 | T == TST_interface || T == TST_union || |
418 | T == TST_class); |
419 | } |
420 | |
421 | DeclSpec(AttributeFactory &attrFactory) |
422 | : StorageClassSpec(SCS_unspecified), |
423 | ThreadStorageClassSpec(TSCS_unspecified), |
424 | SCS_extern_in_linkage_spec(false), |
425 | TypeSpecWidth(static_cast<unsigned>(TypeSpecifierWidth::Unspecified)), |
426 | TypeSpecComplex(TSC_unspecified), |
427 | TypeSpecSign(static_cast<unsigned>(TypeSpecifierSign::Unspecified)), |
428 | TypeSpecType(TST_unspecified), TypeAltiVecVector(false), |
429 | TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false), |
430 | TypeSpecPipe(false), TypeSpecSat(false), ConstrainedAuto(false), |
431 | TypeQualifiers(TQ_unspecified), FS_inline_specified(false), |
432 | FS_forceinline_specified(false), FS_virtual_specified(false), |
433 | FS_noreturn_specified(false), Friend_specified(false), |
434 | ConstexprSpecifier( |
435 | static_cast<unsigned>(ConstexprSpecKind::Unspecified)), |
436 | FS_explicit_specifier(), Attrs(attrFactory), writtenBS(), |
437 | ObjCQualifiers(nullptr) {} |
438 | |
439 | |
440 | SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; } |
441 | TSCS getThreadStorageClassSpec() const { |
442 | return (TSCS)ThreadStorageClassSpec; |
443 | } |
444 | bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; } |
445 | void setExternInLinkageSpec(bool Value) { |
446 | SCS_extern_in_linkage_spec = Value; |
447 | } |
448 | |
449 | SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; } |
450 | SourceLocation getThreadStorageClassSpecLoc() const { |
451 | return ThreadStorageClassSpecLoc; |
452 | } |
453 | |
454 | void ClearStorageClassSpecs() { |
455 | StorageClassSpec = DeclSpec::SCS_unspecified; |
456 | ThreadStorageClassSpec = DeclSpec::TSCS_unspecified; |
457 | SCS_extern_in_linkage_spec = false; |
458 | StorageClassSpecLoc = SourceLocation(); |
459 | ThreadStorageClassSpecLoc = SourceLocation(); |
460 | } |
461 | |
462 | void ClearTypeSpecType() { |
463 | TypeSpecType = DeclSpec::TST_unspecified; |
464 | TypeSpecOwned = false; |
465 | TSTLoc = SourceLocation(); |
466 | } |
467 | |
468 | |
469 | TypeSpecifierWidth getTypeSpecWidth() const { |
470 | return static_cast<TypeSpecifierWidth>(TypeSpecWidth); |
471 | } |
472 | TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; } |
473 | TypeSpecifierSign getTypeSpecSign() const { |
474 | return static_cast<TypeSpecifierSign>(TypeSpecSign); |
475 | } |
476 | TST getTypeSpecType() const { return (TST)TypeSpecType; } |
477 | bool isTypeAltiVecVector() const { return TypeAltiVecVector; } |
478 | bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; } |
479 | bool isTypeAltiVecBool() const { return TypeAltiVecBool; } |
480 | bool isTypeSpecOwned() const { return TypeSpecOwned; } |
481 | bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); } |
482 | bool isTypeSpecPipe() const { return TypeSpecPipe; } |
483 | bool isTypeSpecSat() const { return TypeSpecSat; } |
484 | bool isConstrainedAuto() const { return ConstrainedAuto; } |
485 | |
486 | ParsedType getRepAsType() const { |
487 | assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type"); |
488 | return TypeRep; |
489 | } |
490 | Decl *getRepAsDecl() const { |
491 | assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl"); |
492 | return DeclRep; |
493 | } |
494 | Expr *getRepAsExpr() const { |
495 | assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr"); |
496 | return ExprRep; |
497 | } |
498 | TemplateIdAnnotation *getRepAsTemplateId() const { |
499 | assert(isTemplateIdRep((TST) TypeSpecType) && |
500 | "DeclSpec does not store a template id"); |
501 | return TemplateIdRep; |
502 | } |
503 | CXXScopeSpec &getTypeSpecScope() { return TypeScope; } |
504 | const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; } |
505 | |
506 | SourceRange getSourceRange() const LLVM_READONLY { return Range; } |
507 | SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); } |
508 | SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); } |
509 | |
510 | SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); } |
511 | SourceRange getTypeSpecWidthRange() const { return TSWRange; } |
512 | SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; } |
513 | SourceLocation getTypeSpecSignLoc() const { return TSSLoc; } |
514 | SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; } |
515 | SourceLocation getAltiVecLoc() const { return AltiVecLoc; } |
516 | SourceLocation getTypeSpecSatLoc() const { return TSSatLoc; } |
517 | |
518 | SourceLocation getTypeSpecTypeNameLoc() const { |
519 | assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename); |
520 | return TSTNameLoc; |
521 | } |
522 | |
523 | SourceRange getTypeofParensRange() const { return TypeofParensRange; } |
524 | void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; } |
525 | |
526 | bool hasAutoTypeSpec() const { |
527 | return (TypeSpecType == TST_auto || TypeSpecType == TST_auto_type || |
528 | TypeSpecType == TST_decltype_auto); |
529 | } |
530 | |
531 | bool hasTagDefinition() const; |
532 | |
533 | |
534 | static const char *getSpecifierName(DeclSpec::TST T, |
535 | const PrintingPolicy &Policy); |
536 | static const char *getSpecifierName(DeclSpec::TQ Q); |
537 | static const char *getSpecifierName(TypeSpecifierSign S); |
538 | static const char *getSpecifierName(DeclSpec::TSC C); |
539 | static const char *getSpecifierName(TypeSpecifierWidth W); |
540 | static const char *getSpecifierName(DeclSpec::SCS S); |
541 | static const char *getSpecifierName(DeclSpec::TSCS S); |
542 | static const char *getSpecifierName(ConstexprSpecKind C); |
543 | |
544 | |
545 | |
546 | |
547 | unsigned getTypeQualifiers() const { return TypeQualifiers; } |
548 | SourceLocation getConstSpecLoc() const { return TQ_constLoc; } |
549 | SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; } |
550 | SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; } |
551 | SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; } |
552 | SourceLocation getUnalignedSpecLoc() const { return TQ_unalignedLoc; } |
553 | SourceLocation getPipeLoc() const { return TQ_pipeLoc; } |
554 | |
555 | |
556 | void ClearTypeQualifiers() { |
557 | TypeQualifiers = 0; |
558 | TQ_constLoc = SourceLocation(); |
559 | TQ_restrictLoc = SourceLocation(); |
560 | TQ_volatileLoc = SourceLocation(); |
561 | TQ_atomicLoc = SourceLocation(); |
562 | TQ_unalignedLoc = SourceLocation(); |
563 | TQ_pipeLoc = SourceLocation(); |
564 | } |
565 | |
566 | |
567 | bool isInlineSpecified() const { |
568 | return FS_inline_specified | FS_forceinline_specified; |
569 | } |
570 | SourceLocation getInlineSpecLoc() const { |
571 | return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc; |
572 | } |
573 | |
574 | ExplicitSpecifier getExplicitSpecifier() const { |
575 | return FS_explicit_specifier; |
576 | } |
577 | |
578 | bool isVirtualSpecified() const { return FS_virtual_specified; } |
579 | SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; } |
580 | |
581 | bool hasExplicitSpecifier() const { |
582 | return FS_explicit_specifier.isSpecified(); |
583 | } |
584 | SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; } |
585 | SourceRange getExplicitSpecRange() const { |
586 | return FS_explicit_specifier.getExpr() |
587 | ? SourceRange(FS_explicitLoc, FS_explicitCloseParenLoc) |
588 | : SourceRange(FS_explicitLoc); |
589 | } |
590 | |
591 | bool isNoreturnSpecified() const { return FS_noreturn_specified; } |
592 | SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; } |
593 | |
594 | void ClearFunctionSpecs() { |
595 | FS_inline_specified = false; |
596 | FS_inlineLoc = SourceLocation(); |
597 | FS_forceinline_specified = false; |
598 | FS_forceinlineLoc = SourceLocation(); |
599 | FS_virtual_specified = false; |
600 | FS_virtualLoc = SourceLocation(); |
601 | FS_explicit_specifier = ExplicitSpecifier(); |
602 | FS_explicitLoc = SourceLocation(); |
603 | FS_explicitCloseParenLoc = SourceLocation(); |
604 | FS_noreturn_specified = false; |
605 | FS_noreturnLoc = SourceLocation(); |
606 | } |
607 | |
608 | |
609 | |
610 | |
611 | void forEachCVRUQualifier( |
612 | llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle); |
613 | |
614 | |
615 | |
616 | |
617 | void forEachQualifier( |
618 | llvm::function_ref<void(TQ, StringRef, SourceLocation)> Handle); |
619 | |
620 | |
621 | bool hasTypeSpecifier() const { |
622 | return getTypeSpecType() != DeclSpec::TST_unspecified || |
623 | getTypeSpecWidth() != TypeSpecifierWidth::Unspecified || |
624 | getTypeSpecComplex() != DeclSpec::TSC_unspecified || |
625 | getTypeSpecSign() != TypeSpecifierSign::Unspecified; |
626 | } |
627 | |
628 | |
629 | |
630 | unsigned getParsedSpecifiers() const; |
631 | |
632 | |
633 | |
634 | bool isEmpty() const { |
635 | return getParsedSpecifiers() == DeclSpec::PQ_None; |
636 | } |
637 | |
638 | void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); } |
639 | void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); } |
640 | |
641 | |
642 | |
643 | |
644 | |
645 | |
646 | |
647 | |
648 | |
649 | |
650 | |
651 | bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, |
652 | const char *&PrevSpec, unsigned &DiagID, |
653 | const PrintingPolicy &Policy); |
654 | bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc, |
655 | const char *&PrevSpec, unsigned &DiagID); |
656 | bool SetTypeSpecWidth(TypeSpecifierWidth W, SourceLocation Loc, |
657 | const char *&PrevSpec, unsigned &DiagID, |
658 | const PrintingPolicy &Policy); |
659 | bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec, |
660 | unsigned &DiagID); |
661 | bool SetTypeSpecSign(TypeSpecifierSign S, SourceLocation Loc, |
662 | const char *&PrevSpec, unsigned &DiagID); |
663 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
664 | unsigned &DiagID, const PrintingPolicy &Policy); |
665 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
666 | unsigned &DiagID, ParsedType Rep, |
667 | const PrintingPolicy &Policy); |
668 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
669 | unsigned &DiagID, TypeResult Rep, |
670 | const PrintingPolicy &Policy) { |
671 | if (Rep.isInvalid()) |
672 | return SetTypeSpecError(); |
673 | return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Rep.get(), Policy); |
674 | } |
675 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
676 | unsigned &DiagID, Decl *Rep, bool Owned, |
677 | const PrintingPolicy &Policy); |
678 | bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, |
679 | SourceLocation TagNameLoc, const char *&PrevSpec, |
680 | unsigned &DiagID, ParsedType Rep, |
681 | const PrintingPolicy &Policy); |
682 | bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, |
683 | SourceLocation TagNameLoc, const char *&PrevSpec, |
684 | unsigned &DiagID, Decl *Rep, bool Owned, |
685 | const PrintingPolicy &Policy); |
686 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
687 | unsigned &DiagID, TemplateIdAnnotation *Rep, |
688 | const PrintingPolicy &Policy); |
689 | |
690 | bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, |
691 | unsigned &DiagID, Expr *Rep, |
692 | const PrintingPolicy &policy); |
693 | bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, |
694 | const char *&PrevSpec, unsigned &DiagID, |
695 | const PrintingPolicy &Policy); |
696 | bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, |
697 | const char *&PrevSpec, unsigned &DiagID, |
698 | const PrintingPolicy &Policy); |
699 | bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, |
700 | const char *&PrevSpec, unsigned &DiagID, |
701 | const PrintingPolicy &Policy); |
702 | bool SetTypePipe(bool isPipe, SourceLocation Loc, |
703 | const char *&PrevSpec, unsigned &DiagID, |
704 | const PrintingPolicy &Policy); |
705 | bool SetExtIntType(SourceLocation KWLoc, Expr *BitWidth, |
706 | const char *&PrevSpec, unsigned &DiagID, |
707 | const PrintingPolicy &Policy); |
708 | bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec, |
709 | unsigned &DiagID); |
710 | bool SetTypeSpecError(); |
711 | void UpdateDeclRep(Decl *Rep) { |
712 | assert(isDeclRep((TST) TypeSpecType)); |
713 | DeclRep = Rep; |
714 | } |
715 | void UpdateTypeRep(ParsedType Rep) { |
716 | assert(isTypeRep((TST) TypeSpecType)); |
717 | TypeRep = Rep; |
718 | } |
719 | void UpdateExprRep(Expr *Rep) { |
720 | assert(isExprRep((TST) TypeSpecType)); |
721 | ExprRep = Rep; |
722 | } |
723 | |
724 | bool SetTypeQual(TQ T, SourceLocation Loc); |
725 | |
726 | bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, |
727 | unsigned &DiagID, const LangOptions &Lang); |
728 | |
729 | bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, |
730 | unsigned &DiagID); |
731 | bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec, |
732 | unsigned &DiagID); |
733 | bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec, |
734 | unsigned &DiagID); |
735 | bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec, |
736 | unsigned &DiagID, ExplicitSpecifier ExplicitSpec, |
737 | SourceLocation CloseParenLoc); |
738 | bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec, |
739 | unsigned &DiagID); |
740 | |
741 | bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, |
742 | unsigned &DiagID); |
743 | bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, |
744 | unsigned &DiagID); |
745 | bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc, |
746 | const char *&PrevSpec, unsigned &DiagID); |
747 | |
748 | bool isFriendSpecified() const { return Friend_specified; } |
749 | SourceLocation getFriendSpecLoc() const { return FriendLoc; } |
750 | |
751 | bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); } |
752 | SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; } |
753 | |
754 | ConstexprSpecKind getConstexprSpecifier() const { |
755 | return ConstexprSpecKind(ConstexprSpecifier); |
756 | } |
757 | |
758 | SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; } |
759 | bool hasConstexprSpecifier() const { |
760 | return getConstexprSpecifier() != ConstexprSpecKind::Unspecified; |
761 | } |
762 | |
763 | void ClearConstexprSpec() { |
764 | ConstexprSpecifier = static_cast<unsigned>(ConstexprSpecKind::Unspecified); |
765 | ConstexprLoc = SourceLocation(); |
766 | } |
767 | |
768 | AttributePool &getAttributePool() const { |
769 | return Attrs.getPool(); |
770 | } |
771 | |
772 | |
773 | |
774 | |
775 | |
776 | |
777 | |
778 | |
779 | |
780 | |
781 | |
782 | |
783 | |
784 | |
785 | |
786 | |
787 | |
788 | |
789 | void addAttributes(ParsedAttributesView &AL) { |
790 | Attrs.addAll(AL.begin(), AL.end()); |
791 | } |
792 | |
793 | bool hasAttributes() const { return !Attrs.empty(); } |
794 | |
795 | ParsedAttributes &getAttributes() { return Attrs; } |
796 | const ParsedAttributes &getAttributes() const { return Attrs; } |
797 | |
798 | void takeAttributesFrom(ParsedAttributes &attrs) { |
799 | Attrs.takeAllFrom(attrs); |
800 | } |
801 | |
802 | |
803 | |
804 | |
805 | void Finish(Sema &S, const PrintingPolicy &Policy); |
806 | |
807 | const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const { |
808 | return writtenBS; |
809 | } |
810 | |
811 | ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; } |
812 | void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; } |
813 | |
814 | |
815 | |
816 | |
817 | bool isMissingDeclaratorOk(); |
818 | }; |
819 | |
820 | |
821 | |
822 | class ObjCDeclSpec { |
823 | public: |
824 | |
825 | |
826 | |
827 | |
828 | |
829 | |
830 | enum ObjCDeclQualifier { |
831 | DQ_None = 0x0, |
832 | DQ_In = 0x1, |
833 | DQ_Inout = 0x2, |
834 | DQ_Out = 0x4, |
835 | DQ_Bycopy = 0x8, |
836 | DQ_Byref = 0x10, |
837 | DQ_Oneway = 0x20, |
838 | DQ_CSNullability = 0x40 |
839 | }; |
840 | |
841 | ObjCDeclSpec() |
842 | : objcDeclQualifier(DQ_None), |
843 | PropertyAttributes(ObjCPropertyAttribute::kind_noattr), Nullability(0), |
844 | GetterName(nullptr), SetterName(nullptr) {} |
845 | |
846 | ObjCDeclQualifier getObjCDeclQualifier() const { |
847 | return (ObjCDeclQualifier)objcDeclQualifier; |
848 | } |
849 | void setObjCDeclQualifier(ObjCDeclQualifier DQVal) { |
850 | objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal); |
851 | } |
852 | void clearObjCDeclQualifier(ObjCDeclQualifier DQVal) { |
853 | objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier & ~DQVal); |
854 | } |
855 | |
856 | ObjCPropertyAttribute::Kind getPropertyAttributes() const { |
857 | return ObjCPropertyAttribute::Kind(PropertyAttributes); |
858 | } |
859 | void setPropertyAttributes(ObjCPropertyAttribute::Kind PRVal) { |
860 | PropertyAttributes = |
861 | (ObjCPropertyAttribute::Kind)(PropertyAttributes | PRVal); |
862 | } |
863 | |
864 | NullabilityKind getNullability() const { |
865 | assert( |
866 | ((getObjCDeclQualifier() & DQ_CSNullability) || |
867 | (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) && |
868 | "Objective-C declspec doesn't have nullability"); |
869 | return static_cast<NullabilityKind>(Nullability); |
870 | } |
871 | |
872 | SourceLocation getNullabilityLoc() const { |
873 | assert( |
874 | ((getObjCDeclQualifier() & DQ_CSNullability) || |
875 | (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) && |
876 | "Objective-C declspec doesn't have nullability"); |
877 | return NullabilityLoc; |
878 | } |
879 | |
880 | void setNullability(SourceLocation loc, NullabilityKind kind) { |
881 | assert( |
882 | ((getObjCDeclQualifier() & DQ_CSNullability) || |
883 | (getPropertyAttributes() & ObjCPropertyAttribute::kind_nullability)) && |
884 | "Set the nullability declspec or property attribute first"); |
885 | Nullability = static_cast<unsigned>(kind); |
886 | NullabilityLoc = loc; |
887 | } |
888 | |
889 | const IdentifierInfo *getGetterName() const { return GetterName; } |
890 | IdentifierInfo *getGetterName() { return GetterName; } |
891 | SourceLocation getGetterNameLoc() const { return GetterNameLoc; } |
892 | void setGetterName(IdentifierInfo *name, SourceLocation loc) { |
893 | GetterName = name; |
894 | GetterNameLoc = loc; |
895 | } |
896 | |
897 | const IdentifierInfo *getSetterName() const { return SetterName; } |
898 | IdentifierInfo *getSetterName() { return SetterName; } |
899 | SourceLocation getSetterNameLoc() const { return SetterNameLoc; } |
900 | void setSetterName(IdentifierInfo *name, SourceLocation loc) { |
901 | SetterName = name; |
902 | SetterNameLoc = loc; |
903 | } |
904 | |
905 | private: |
906 | |
907 | |
908 | |
909 | unsigned objcDeclQualifier : 7; |
910 | |
911 | |
912 | unsigned PropertyAttributes : NumObjCPropertyAttrsBits; |
913 | |
914 | unsigned Nullability : 2; |
915 | |
916 | SourceLocation NullabilityLoc; |
917 | |
918 | IdentifierInfo *GetterName; |
919 | IdentifierInfo *SetterName; |
920 | SourceLocation GetterNameLoc; |
921 | SourceLocation SetterNameLoc; |
922 | |
923 | }; |
924 | |
925 | |
926 | enum class UnqualifiedIdKind { |
927 | |
928 | IK_Identifier, |
929 | |
930 | IK_OperatorFunctionId, |
931 | |
932 | IK_ConversionFunctionId, |
933 | |
934 | IK_LiteralOperatorId, |
935 | |
936 | IK_ConstructorName, |
937 | |
938 | IK_ConstructorTemplateId, |
939 | |
940 | IK_DestructorName, |
941 | |
942 | IK_TemplateId, |
943 | |
944 | IK_ImplicitSelfParam, |
945 | |
946 | IK_DeductionGuideName |
947 | }; |
948 | |
949 | |
950 | class UnqualifiedId { |
951 | private: |
952 | UnqualifiedId(const UnqualifiedId &Other) = delete; |
953 | const UnqualifiedId &operator=(const UnqualifiedId &) = delete; |
954 | |
955 | public: |
956 | |
957 | UnqualifiedIdKind Kind; |
958 | |
959 | struct OFI { |
960 | |
961 | OverloadedOperatorKind Operator; |
962 | |
963 | |
964 | |
965 | |
966 | |
967 | |
968 | |
969 | |
970 | SourceLocation SymbolLocations[3]; |
971 | }; |
972 | |
973 | |
974 | |
975 | union { |
976 | |
977 | |
978 | IdentifierInfo *Identifier; |
979 | |
980 | |
981 | |
982 | struct OFI OperatorFunctionId; |
983 | |
984 | |
985 | |
986 | UnionParsedType ConversionFunctionId; |
987 | |
988 | |
989 | |
990 | UnionParsedType ConstructorName; |
991 | |
992 | |
993 | |
994 | UnionParsedType DestructorName; |
995 | |
996 | |
997 | UnionParsedTemplateTy TemplateName; |
998 | |
999 | |
1000 | |
1001 | |
1002 | TemplateIdAnnotation *TemplateId; |
1003 | }; |
1004 | |
1005 | |
1006 | |
1007 | |
1008 | SourceLocation StartLocation; |
1009 | |
1010 | |
1011 | SourceLocation EndLocation; |
1012 | |
1013 | UnqualifiedId() |
1014 | : Kind(UnqualifiedIdKind::IK_Identifier), Identifier(nullptr) {} |
1015 | |
1016 | |
1017 | |
1018 | void clear() { |
1019 | Kind = UnqualifiedIdKind::IK_Identifier; |
1020 | Identifier = nullptr; |
1021 | StartLocation = SourceLocation(); |
1022 | EndLocation = SourceLocation(); |
1023 | } |
1024 | |
1025 | |
1026 | bool isValid() const { return StartLocation.isValid(); } |
1027 | |
1028 | |
1029 | bool isInvalid() const { return !isValid(); } |
1030 | |
1031 | |
1032 | UnqualifiedIdKind getKind() const { return Kind; } |
1033 | |
1034 | |
1035 | |
1036 | |
1037 | |
1038 | void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) { |
1039 | Kind = UnqualifiedIdKind::IK_Identifier; |
1040 | Identifier = const_cast<IdentifierInfo *>(Id); |
1041 | StartLocation = EndLocation = IdLoc; |
1042 | } |
1043 | |
1044 | |
1045 | |
1046 | |
1047 | |
1048 | |
1049 | |
1050 | |
1051 | |
1052 | |
1053 | void setOperatorFunctionId(SourceLocation OperatorLoc, |
1054 | OverloadedOperatorKind Op, |
1055 | SourceLocation SymbolLocations[3]); |
1056 | |
1057 | |
1058 | |
1059 | |
1060 | |
1061 | |
1062 | |
1063 | |
1064 | |
1065 | void setConversionFunctionId(SourceLocation OperatorLoc, |
1066 | ParsedType Ty, |
1067 | SourceLocation EndLoc) { |
1068 | Kind = UnqualifiedIdKind::IK_ConversionFunctionId; |
1069 | StartLocation = OperatorLoc; |
1070 | EndLocation = EndLoc; |
1071 | ConversionFunctionId = Ty; |
1072 | } |
1073 | |
1074 | |
1075 | |
1076 | |
1077 | |
1078 | |
1079 | |
1080 | |
1081 | |
1082 | void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc, |
1083 | SourceLocation IdLoc) { |
1084 | Kind = UnqualifiedIdKind::IK_LiteralOperatorId; |
1085 | Identifier = const_cast<IdentifierInfo *>(Id); |
1086 | StartLocation = OpLoc; |
1087 | EndLocation = IdLoc; |
1088 | } |
1089 | |
1090 | |
1091 | |
1092 | |
1093 | |
1094 | |
1095 | |
1096 | |
1097 | void setConstructorName(ParsedType ClassType, |
1098 | SourceLocation ClassNameLoc, |
1099 | SourceLocation EndLoc) { |
1100 | Kind = UnqualifiedIdKind::IK_ConstructorName; |
1101 | StartLocation = ClassNameLoc; |
1102 | EndLocation = EndLoc; |
1103 | ConstructorName = ClassType; |
1104 | } |
1105 | |
1106 | |
1107 | |
1108 | |
1109 | |
1110 | |
1111 | |
1112 | void setConstructorTemplateId(TemplateIdAnnotation *TemplateId); |
1113 | |
1114 | |
1115 | |
1116 | |
1117 | |
1118 | |
1119 | |
1120 | void setDestructorName(SourceLocation TildeLoc, |
1121 | ParsedType ClassType, |
1122 | SourceLocation EndLoc) { |
1123 | Kind = UnqualifiedIdKind::IK_DestructorName; |
1124 | StartLocation = TildeLoc; |
1125 | EndLocation = EndLoc; |
1126 | DestructorName = ClassType; |
1127 | } |
1128 | |
1129 | |
1130 | |
1131 | |
1132 | |
1133 | |
1134 | void setTemplateId(TemplateIdAnnotation *TemplateId); |
1135 | |
1136 | |
1137 | |
1138 | |
1139 | |
1140 | |
1141 | void setDeductionGuideName(ParsedTemplateTy Template, |
1142 | SourceLocation TemplateLoc) { |
1143 | Kind = UnqualifiedIdKind::IK_DeductionGuideName; |
1144 | TemplateName = Template; |
1145 | StartLocation = EndLocation = TemplateLoc; |
1146 | } |
1147 | |
1148 | |
1149 | |
1150 | |
1151 | |
1152 | void setImplicitSelfParam(const IdentifierInfo *Id) { |
1153 | Kind = UnqualifiedIdKind::IK_ImplicitSelfParam; |
1154 | Identifier = const_cast<IdentifierInfo *>(Id); |
1155 | StartLocation = EndLocation = SourceLocation(); |
1156 | } |
1157 | |
1158 | |
1159 | SourceRange getSourceRange() const LLVM_READONLY { |
1160 | return SourceRange(StartLocation, EndLocation); |
1161 | } |
1162 | SourceLocation getBeginLoc() const LLVM_READONLY { return StartLocation; } |
1163 | SourceLocation getEndLoc() const LLVM_READONLY { return EndLocation; } |
1164 | }; |
1165 | |
1166 | |
1167 | typedef SmallVector<Token, 4> CachedTokens; |
1168 | |
1169 | |
1170 | |
1171 | |
1172 | |
1173 | struct DeclaratorChunk { |
1174 | DeclaratorChunk() {}; |
1175 | |
1176 | enum { |
1177 | Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren, Pipe |
1178 | } Kind; |
1179 | |
1180 | |
1181 | SourceLocation Loc; |
1182 | |
1183 | SourceLocation EndLoc; |
1184 | |
1185 | SourceRange getSourceRange() const { |
1186 | if (EndLoc.isInvalid()) |
1187 | return SourceRange(Loc, Loc); |
1188 | return SourceRange(Loc, EndLoc); |
1189 | } |
1190 | |
1191 | ParsedAttributesView AttrList; |
1192 | |
1193 | struct PointerTypeInfo { |
1194 | |
1195 | unsigned TypeQuals : 5; |
1196 | |
1197 | |
1198 | SourceLocation ConstQualLoc; |
1199 | |
1200 | |
1201 | SourceLocation VolatileQualLoc; |
1202 | |
1203 | |
1204 | SourceLocation RestrictQualLoc; |
1205 | |
1206 | |
1207 | SourceLocation AtomicQualLoc; |
1208 | |
1209 | |
1210 | SourceLocation UnalignedQualLoc; |
1211 | |
1212 | void destroy() { |
1213 | } |
1214 | }; |
1215 | |
1216 | struct ReferenceTypeInfo { |
1217 | |
1218 | bool HasRestrict : 1; |
1219 | |
1220 | bool LValueRef : 1; |
1221 | void destroy() { |
1222 | } |
1223 | }; |
1224 | |
1225 | struct ArrayTypeInfo { |
1226 | |
1227 | |
1228 | unsigned TypeQuals : 5; |
1229 | |
1230 | |
1231 | unsigned hasStatic : 1; |
1232 | |
1233 | |
1234 | unsigned isStar : 1; |
1235 | |
1236 | |
1237 | |
1238 | |
1239 | Expr *NumElts; |
1240 | |
1241 | void destroy() {} |
1242 | }; |
1243 | |
1244 | |
1245 | |
1246 | |
1247 | |
1248 | |
1249 | |
1250 | |
1251 | struct ParamInfo { |
1252 | IdentifierInfo *Ident; |
1253 | SourceLocation IdentLoc; |
1254 | Decl *Param; |
1255 | |
1256 | |
1257 | |
1258 | |
1259 | |
1260 | |
1261 | std::unique_ptr<CachedTokens> DefaultArgTokens; |
1262 | |
1263 | ParamInfo() = default; |
1264 | ParamInfo(IdentifierInfo *ident, SourceLocation iloc, |
1265 | Decl *param, |
1266 | std::unique_ptr<CachedTokens> DefArgTokens = nullptr) |
1267 | : Ident(ident), IdentLoc(iloc), Param(param), |
1268 | DefaultArgTokens(std::move(DefArgTokens)) {} |
1269 | }; |
1270 | |
1271 | struct TypeAndRange { |
1272 | ParsedType Ty; |
1273 | SourceRange Range; |
1274 | }; |
1275 | |
1276 | struct FunctionTypeInfo { |
1277 | |
1278 | |
1279 | |
1280 | unsigned hasPrototype : 1; |
1281 | |
1282 | |
1283 | |
1284 | |
1285 | unsigned isVariadic : 1; |
1286 | |
1287 | |
1288 | unsigned isAmbiguous : 1; |
1289 | |
1290 | |
1291 | |
1292 | unsigned RefQualifierIsLValueRef : 1; |
1293 | |
1294 | |
1295 | unsigned ExceptionSpecType : 4; |
1296 | |
1297 | |
1298 | unsigned DeleteParams : 1; |
1299 | |
1300 | |
1301 | |
1302 | unsigned HasTrailingReturnType : 1; |
1303 | |
1304 | |
1305 | SourceLocation LParenLoc; |
1306 | |
1307 | |
1308 | SourceLocation EllipsisLoc; |
1309 | |
1310 | |
1311 | SourceLocation RParenLoc; |
1312 | |
1313 | |
1314 | |
1315 | unsigned NumParams; |
1316 | |
1317 | |
1318 | |
1319 | |
1320 | unsigned NumExceptionsOrDecls; |
1321 | |
1322 | |
1323 | |
1324 | |
1325 | SourceLocation RefQualifierLoc; |
1326 | |
1327 | |
1328 | |
1329 | SourceLocation MutableLoc; |
1330 | |
1331 | |
1332 | SourceLocation ExceptionSpecLocBeg; |
1333 | |
1334 | |
1335 | SourceLocation ExceptionSpecLocEnd; |
1336 | |
1337 | |
1338 | |
1339 | |
1340 | ParamInfo *Params; |
1341 | |
1342 | |
1343 | DeclSpec *MethodQualifiers; |
1344 | |
1345 | |
1346 | AttributeFactory *QualAttrFactory; |
1347 | |
1348 | union { |
1349 | |
1350 | |
1351 | |
1352 | TypeAndRange *Exceptions; |
1353 | |
1354 | |
1355 | |
1356 | Expr *NoexceptExpr; |
1357 | |
1358 | |
1359 | |
1360 | CachedTokens *ExceptionSpecTokens; |
1361 | |
1362 | |
1363 | |
1364 | |
1365 | NamedDecl **DeclsInPrototype; |
1366 | }; |
1367 | |
1368 | |
1369 | |
1370 | UnionParsedType TrailingReturnType; |
1371 | |
1372 | |
1373 | |
1374 | SourceLocation TrailingReturnTypeLoc; |
1375 | |
1376 | |
1377 | |
1378 | |
1379 | void freeParams() { |
1380 | for (unsigned I = 0; I < NumParams; ++I) |
1381 | Params[I].DefaultArgTokens.reset(); |
1382 | if (DeleteParams) { |
1383 | delete[] Params; |
1384 | DeleteParams = false; |
1385 | } |
1386 | NumParams = 0; |
1387 | } |
1388 | |
1389 | void destroy() { |
1390 | freeParams(); |
1391 | delete QualAttrFactory; |
1392 | delete MethodQualifiers; |
1393 | switch (getExceptionSpecType()) { |
1394 | default: |
1395 | break; |
1396 | case EST_Dynamic: |
1397 | delete[] Exceptions; |
1398 | break; |
1399 | case EST_Unparsed: |
1400 | delete ExceptionSpecTokens; |
1401 | break; |
1402 | case EST_None: |
1403 | if (NumExceptionsOrDecls != 0) |
1404 | delete[] DeclsInPrototype; |
1405 | break; |
1406 | } |
1407 | } |
1408 | |
1409 | DeclSpec &getOrCreateMethodQualifiers() { |
1410 | if (!MethodQualifiers) { |
1411 | QualAttrFactory = new AttributeFactory(); |
1412 | MethodQualifiers = new DeclSpec(*QualAttrFactory); |
1413 | } |
1414 | return *MethodQualifiers; |
1415 | } |
1416 | |
1417 | |
1418 | |
1419 | |
1420 | bool isKNRPrototype() const { return !hasPrototype && NumParams != 0; } |
1421 | |
1422 | SourceLocation getLParenLoc() const { return LParenLoc; } |
1423 | |
1424 | SourceLocation getEllipsisLoc() const { return EllipsisLoc; } |
1425 | |
1426 | SourceLocation getRParenLoc() const { return RParenLoc; } |
1427 | |
1428 | SourceLocation getExceptionSpecLocBeg() const { |
1429 | return ExceptionSpecLocBeg; |
1430 | } |
1431 | |
1432 | SourceLocation getExceptionSpecLocEnd() const { |
1433 | return ExceptionSpecLocEnd; |
1434 | } |
1435 | |
1436 | SourceRange getExceptionSpecRange() const { |
1437 | return SourceRange(getExceptionSpecLocBeg(), getExceptionSpecLocEnd()); |
1438 | } |
1439 | |
1440 | |
1441 | SourceLocation getRefQualifierLoc() const { return RefQualifierLoc; } |
1442 | |
1443 | |
1444 | SourceLocation getConstQualifierLoc() const { |
1445 | assert(MethodQualifiers); |
1446 | return MethodQualifiers->getConstSpecLoc(); |
1447 | } |
1448 | |
1449 | |
1450 | SourceLocation getVolatileQualifierLoc() const { |
1451 | assert(MethodQualifiers); |
1452 | return MethodQualifiers->getVolatileSpecLoc(); |
1453 | } |
1454 | |
1455 | |
1456 | SourceLocation getRestrictQualifierLoc() const { |
1457 | assert(MethodQualifiers); |
1458 | return MethodQualifiers->getRestrictSpecLoc(); |
1459 | } |
1460 | |
1461 | |
1462 | SourceLocation getMutableLoc() const { return MutableLoc; } |
1463 | |
1464 | |
1465 | |
1466 | bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); } |
1467 | |
1468 | |
1469 | |
1470 | bool hasMutableQualifier() const { return getMutableLoc().isValid(); } |
1471 | |
1472 | |
1473 | bool hasMethodTypeQualifiers() const { |
1474 | return MethodQualifiers && (MethodQualifiers->getTypeQualifiers() || |
1475 | MethodQualifiers->getAttributes().size()); |
1476 | } |
1477 | |
1478 | |
1479 | ExceptionSpecificationType getExceptionSpecType() const { |
1480 | return static_cast<ExceptionSpecificationType>(ExceptionSpecType); |
1481 | } |
1482 | |
1483 | |
1484 | unsigned getNumExceptions() const { |
1485 | assert(ExceptionSpecType != EST_None); |
1486 | return NumExceptionsOrDecls; |
1487 | } |
1488 | |
1489 | |
1490 | |
1491 | ArrayRef<NamedDecl *> getDeclsInPrototype() const { |
1492 | assert(ExceptionSpecType == EST_None); |
1493 | return llvm::makeArrayRef(DeclsInPrototype, NumExceptionsOrDecls); |
1494 | } |
1495 | |
1496 | |
1497 | |
1498 | bool hasTrailingReturnType() const { return HasTrailingReturnType; } |
1499 | |
1500 | |
1501 | ParsedType getTrailingReturnType() const { |
1502 | assert(HasTrailingReturnType); |
1503 | return TrailingReturnType; |
1504 | } |
1505 | |
1506 | |
1507 | SourceLocation getTrailingReturnTypeLoc() const { |
1508 | assert(HasTrailingReturnType); |
1509 | return TrailingReturnTypeLoc; |
1510 | } |
1511 | }; |
1512 | |
1513 | struct BlockPointerTypeInfo { |
1514 | |
1515 | |
1516 | unsigned TypeQuals : 5; |
1517 | |
1518 | void destroy() { |
1519 | } |
1520 | }; |
1521 | |
1522 | struct MemberPointerTypeInfo { |
1523 | |
1524 | unsigned TypeQuals : 5; |
1525 | |
1526 | SourceLocation StarLoc; |
1527 | |
1528 | |
1529 | alignas(CXXScopeSpec) char ScopeMem[sizeof(CXXScopeSpec)]; |
1530 | CXXScopeSpec &Scope() { |
1531 | return *reinterpret_cast<CXXScopeSpec *>(ScopeMem); |
1532 | } |
1533 | const CXXScopeSpec &Scope() const { |
1534 | return *reinterpret_cast<const CXXScopeSpec *>(ScopeMem); |
1535 | } |
1536 | void destroy() { |
1537 | Scope().~CXXScopeSpec(); |
1538 | } |
1539 | }; |
1540 | |
1541 | struct PipeTypeInfo { |
1542 | |
1543 | unsigned AccessWrites : 3; |
1544 | |
1545 | void destroy() {} |
1546 | }; |
1547 | |
1548 | union { |
1549 | PointerTypeInfo Ptr; |
1550 | ReferenceTypeInfo Ref; |
1551 | ArrayTypeInfo Arr; |
1552 | FunctionTypeInfo Fun; |
1553 | BlockPointerTypeInfo Cls; |
1554 | MemberPointerTypeInfo Mem; |
1555 | PipeTypeInfo PipeInfo; |
1556 | }; |
1557 | |
1558 | void destroy() { |
1559 | switch (Kind) { |
1560 | case DeclaratorChunk::Function: return Fun.destroy(); |
1561 | case DeclaratorChunk::Pointer: return Ptr.destroy(); |
1562 | case DeclaratorChunk::BlockPointer: return Cls.destroy(); |
1563 | case DeclaratorChunk::Reference: return Ref.destroy(); |
1564 | case DeclaratorChunk::Array: return Arr.destroy(); |
1565 | case DeclaratorChunk::MemberPointer: return Mem.destroy(); |
1566 | case DeclaratorChunk::Paren: return; |
1567 | case DeclaratorChunk::Pipe: return PipeInfo.destroy(); |
1568 | } |
1569 | } |
1570 | |
1571 | |
1572 | |
1573 | const ParsedAttributesView &getAttrs() const { return AttrList; } |
1574 | ParsedAttributesView &getAttrs() { return AttrList; } |
1575 | |
1576 | |
1577 | static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc, |
1578 | SourceLocation ConstQualLoc, |
1579 | SourceLocation VolatileQualLoc, |
1580 | SourceLocation RestrictQualLoc, |
1581 | SourceLocation AtomicQualLoc, |
1582 | SourceLocation UnalignedQualLoc) { |
1583 | DeclaratorChunk I; |
1584 | I.Kind = Pointer; |
1585 | I.Loc = Loc; |
1586 | new (&I.Ptr) PointerTypeInfo; |
1587 | I.Ptr.TypeQuals = TypeQuals; |
1588 | I.Ptr.ConstQualLoc = ConstQualLoc; |
1589 | I.Ptr.VolatileQualLoc = VolatileQualLoc; |
1590 | I.Ptr.RestrictQualLoc = RestrictQualLoc; |
1591 | I.Ptr.AtomicQualLoc = AtomicQualLoc; |
1592 | I.Ptr.UnalignedQualLoc = UnalignedQualLoc; |
1593 | return I; |
1594 | } |
1595 | |
1596 | |
1597 | static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, |
1598 | bool lvalue) { |
1599 | DeclaratorChunk I; |
1600 | I.Kind = Reference; |
1601 | I.Loc = Loc; |
1602 | I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0; |
1603 | I.Ref.LValueRef = lvalue; |
1604 | return I; |
1605 | } |
1606 | |
1607 | |
1608 | static DeclaratorChunk getArray(unsigned TypeQuals, |
1609 | bool isStatic, bool isStar, Expr *NumElts, |
1610 | SourceLocation LBLoc, SourceLocation RBLoc) { |
1611 | DeclaratorChunk I; |
1612 | I.Kind = Array; |
1613 | I.Loc = LBLoc; |
1614 | I.EndLoc = RBLoc; |
1615 | I.Arr.TypeQuals = TypeQuals; |
1616 | I.Arr.hasStatic = isStatic; |
1617 | I.Arr.isStar = isStar; |
1618 | I.Arr.NumElts = NumElts; |
1619 | return I; |
1620 | } |
1621 | |
1622 | |
1623 | |
1624 | static DeclaratorChunk getFunction(bool HasProto, |
1625 | bool IsAmbiguous, |
1626 | SourceLocation LParenLoc, |
1627 | ParamInfo *Params, unsigned NumParams, |
1628 | SourceLocation EllipsisLoc, |
1629 | SourceLocation RParenLoc, |
1630 | bool RefQualifierIsLvalueRef, |
1631 | SourceLocation RefQualifierLoc, |
1632 | SourceLocation MutableLoc, |
1633 | ExceptionSpecificationType ESpecType, |
1634 | SourceRange ESpecRange, |
1635 | ParsedType *Exceptions, |
1636 | SourceRange *ExceptionRanges, |
1637 | unsigned NumExceptions, |
1638 | Expr *NoexceptExpr, |
1639 | CachedTokens *ExceptionSpecTokens, |
1640 | ArrayRef<NamedDecl *> DeclsInPrototype, |
1641 | SourceLocation LocalRangeBegin, |
1642 | SourceLocation LocalRangeEnd, |
1643 | Declarator &TheDeclarator, |
1644 | TypeResult TrailingReturnType = |
1645 | TypeResult(), |
1646 | SourceLocation TrailingReturnTypeLoc = |
1647 | SourceLocation(), |
1648 | DeclSpec *MethodQualifiers = nullptr); |
1649 | |
1650 | |
1651 | static DeclaratorChunk getBlockPointer(unsigned TypeQuals, |
1652 | SourceLocation Loc) { |
1653 | DeclaratorChunk I; |
1654 | I.Kind = BlockPointer; |
1655 | I.Loc = Loc; |
1656 | I.Cls.TypeQuals = TypeQuals; |
1657 | return I; |
1658 | } |
1659 | |
1660 | |
1661 | static DeclaratorChunk getPipe(unsigned TypeQuals, |
1662 | SourceLocation Loc) { |
1663 | DeclaratorChunk I; |
1664 | I.Kind = Pipe; |
1665 | I.Loc = Loc; |
1666 | I.Cls.TypeQuals = TypeQuals; |
1667 | return I; |
1668 | } |
1669 | |
1670 | static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS, |
1671 | unsigned TypeQuals, |
1672 | SourceLocation StarLoc, |
1673 | SourceLocation EndLoc) { |
1674 | DeclaratorChunk I; |
1675 | I.Kind = MemberPointer; |
1676 | I.Loc = SS.getBeginLoc(); |
1677 | I.EndLoc = EndLoc; |
1678 | new (&I.Mem) MemberPointerTypeInfo; |
1679 | I.Mem.StarLoc = StarLoc; |
1680 | I.Mem.TypeQuals = TypeQuals; |
1681 | new (I.Mem.ScopeMem) CXXScopeSpec(SS); |
1682 | return I; |
1683 | } |
1684 | |
1685 | |
1686 | static DeclaratorChunk getParen(SourceLocation LParenLoc, |
1687 | SourceLocation RParenLoc) { |
1688 | DeclaratorChunk I; |
1689 | I.Kind = Paren; |
1690 | I.Loc = LParenLoc; |
1691 | I.EndLoc = RParenLoc; |
1692 | return I; |
1693 | } |
1694 | |
1695 | bool isParen() const { |
1696 | return Kind == Paren; |
1697 | } |
1698 | }; |
1699 | |
1700 | |
1701 | |
1702 | class DecompositionDeclarator { |
1703 | public: |
1704 | struct Binding { |
1705 | IdentifierInfo *Name; |
1706 | SourceLocation NameLoc; |
1707 | }; |
1708 | |
1709 | private: |
1710 | |
1711 | SourceLocation LSquareLoc, RSquareLoc; |
1712 | |
1713 | |
1714 | Binding *Bindings; |
1715 | unsigned NumBindings : 31; |
1716 | unsigned DeleteBindings : 1; |
1717 | |
1718 | friend class Declarator; |
1719 | |
1720 | public: |
1721 | DecompositionDeclarator() |
1722 | : Bindings(nullptr), NumBindings(0), DeleteBindings(false) {} |
1723 | DecompositionDeclarator(const DecompositionDeclarator &G) = delete; |
1724 | DecompositionDeclarator &operator=(const DecompositionDeclarator &G) = delete; |
1725 | ~DecompositionDeclarator() { |
1726 | if (DeleteBindings) |
1727 | delete[] Bindings; |
1728 | } |
1729 | |
1730 | void clear() { |
1731 | LSquareLoc = RSquareLoc = SourceLocation(); |
1732 | if (DeleteBindings) |
1733 | delete[] Bindings; |
1734 | Bindings = nullptr; |
1735 | NumBindings = 0; |
1736 | DeleteBindings = false; |
1737 | } |
1738 | |
1739 | ArrayRef<Binding> bindings() const { |
1740 | return llvm::makeArrayRef(Bindings, NumBindings); |
1741 | } |
1742 | |
1743 | bool isSet() const { return LSquareLoc.isValid(); } |
1744 | |
1745 | SourceLocation getLSquareLoc() const { return LSquareLoc; } |
1746 | SourceLocation getRSquareLoc() const { return RSquareLoc; } |
1747 | SourceRange getSourceRange() const { |
1748 | return SourceRange(LSquareLoc, RSquareLoc); |
1749 | } |
1750 | }; |
1751 | |
1752 | |
1753 | |
1754 | enum class FunctionDefinitionKind { |
1755 | Declaration, |
1756 | Definition, |
1757 | Defaulted, |
1758 | Deleted |
1759 | }; |
1760 | |
1761 | enum class DeclaratorContext { |
1762 | File, |
1763 | Prototype, |
1764 | ObjCResult, |
1765 | ObjCParameter, |
1766 | KNRTypeList, |
1767 | TypeName, |
1768 | FunctionalCast, |
1769 | Member, |
1770 | Block, |
1771 | ForInit, |
1772 | SelectionInit, |
1773 | Condition, |
1774 | TemplateParam, |
1775 | CXXNew, |
1776 | CXXCatch, |
1777 | ObjCCatch, |
1778 | BlockLiteral, |
1779 | LambdaExpr, |
1780 | LambdaExprParameter, |
1781 | ConversionId, |
1782 | TrailingReturn, |
1783 | TrailingReturnVar, |
1784 | TemplateArg, |
1785 | TemplateTypeArg, |
1786 | AliasDecl, |
1787 | AliasTemplate, |
1788 | RequiresExpr |
1789 | }; |
1790 | |
1791 | |
1792 | |
1793 | |
1794 | |
1795 | |
1796 | |
1797 | |
1798 | |
1799 | |
1800 | |
1801 | |
1802 | |
1803 | class Declarator { |
1804 | |
1805 | private: |
1806 | const DeclSpec &DS; |
1807 | CXXScopeSpec SS; |
1808 | UnqualifiedId Name; |
1809 | SourceRange Range; |
1810 | |
1811 | |
1812 | DeclaratorContext Context; |
1813 | |
1814 | |
1815 | DecompositionDeclarator BindingGroup; |
1816 | |
1817 | |
1818 | |
1819 | |
1820 | |
1821 | SmallVector<DeclaratorChunk, 8> DeclTypeInfo; |
1822 | |
1823 | |
1824 | unsigned InvalidType : 1; |
1825 | |
1826 | |
1827 | unsigned GroupingParens : 1; |
1828 | |
1829 | |
1830 | |
1831 | |
1832 | |
1833 | unsigned FunctionDefinition : 2; |
1834 | |
1835 | |
1836 | unsigned Redeclaration : 1; |
1837 | |
1838 | |
1839 | unsigned Extension : 1; |
1840 | |
1841 | |
1842 | unsigned ObjCIvar : 1; |
1843 | |
1844 | |
1845 | unsigned ObjCWeakProperty : 1; |
1846 | |
1847 | |
1848 | unsigned InlineStorageUsed : 1; |
1849 | |
1850 | |
1851 | unsigned HasInitializer : 1; |
1852 | |
1853 | |
1854 | ParsedAttributes Attrs; |
1855 | |
1856 | |
1857 | Expr *AsmLabel; |
1858 | |
1859 | |
1860 | |
1861 | Expr *TrailingRequiresClause; |
1862 | |
1863 | |
1864 | ArrayRef<TemplateParameterList *> TemplateParameterLists; |
1865 | |
1866 | |
1867 | |
1868 | |
1869 | TemplateParameterList *InventedTemplateParameterList; |
1870 | |
1871 | #ifndef _MSC_VER |
1872 | union { |
1873 | #endif |
1874 | |
1875 | |
1876 | |
1877 | DeclaratorChunk::ParamInfo InlineParams[16]; |
1878 | DecompositionDeclarator::Binding InlineBindings[16]; |
1879 | #ifndef _MSC_VER |
1880 | }; |
1881 | #endif |
1882 | |
1883 | |
1884 | |
1885 | SourceLocation CommaLoc; |
1886 | |
1887 | |
1888 | |
1889 | SourceLocation EllipsisLoc; |
1890 | |
1891 | friend struct DeclaratorChunk; |
1892 | |
1893 | public: |
1894 | Declarator(const DeclSpec &ds, DeclaratorContext C) |
1895 | : DS(ds), Range(ds.getSourceRange()), Context(C), |
1896 | InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error), |
1897 | GroupingParens(false), FunctionDefinition(static_cast<unsigned>( |
1898 | FunctionDefinitionKind::Declaration)), |
1899 | Redeclaration(false), Extension(false), ObjCIvar(false), |
1900 | ObjCWeakProperty(false), InlineStorageUsed(false), |
1901 | HasInitializer(false), Attrs(ds.getAttributePool().getFactory()), |
1902 | AsmLabel(nullptr), TrailingRequiresClause(nullptr), |
1903 | InventedTemplateParameterList(nullptr) {} |
1904 | |
1905 | ~Declarator() { |
1906 | clear(); |
1907 | } |
1908 | |
1909 | |
1910 | const DeclSpec &getDeclSpec() const { return DS; } |
1911 | |
1912 | |
1913 | |
1914 | |
1915 | |
1916 | |
1917 | DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); } |
1918 | |
1919 | AttributePool &getAttributePool() const { |
1920 | return Attrs.getPool(); |
1921 | } |
1922 | |
1923 | |
1924 | |
1925 | const CXXScopeSpec &getCXXScopeSpec() const { return SS; } |
1926 | CXXScopeSpec &getCXXScopeSpec() { return SS; } |
1927 | |
1928 | |
1929 | UnqualifiedId &getName() { return Name; } |
1930 | |
1931 | const DecompositionDeclarator &getDecompositionDeclarator() const { |
1932 | return BindingGroup; |
1933 | } |
1934 | |
1935 | DeclaratorContext getContext() const { return Context; } |
1936 | |
1937 | bool isPrototypeContext() const { |
1938 | return (Context == DeclaratorContext::Prototype || |
1939 | Context == DeclaratorContext::ObjCParameter || |
1940 | Context == DeclaratorContext::ObjCResult || |
1941 | Context == DeclaratorContext::LambdaExprParameter); |
1942 | } |
1943 | |
1944 | |
1945 | SourceRange getSourceRange() const LLVM_READONLY { return Range; } |
1946 | SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); } |
1947 | SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); } |
1948 | |
1949 | void SetSourceRange(SourceRange R) { Range = R; } |
1950 | |
1951 | |
1952 | void SetRangeBegin(SourceLocation Loc) { |
1953 | if (!Loc.isInvalid()) |
1954 | Range.setBegin(Loc); |
1955 | } |
1956 | |
1957 | void SetRangeEnd(SourceLocation Loc) { |
1958 | if (!Loc.isInvalid()) |
1959 | Range.setEnd(Loc); |
1960 | } |
1961 | |
1962 | |
1963 | |
1964 | void ExtendWithDeclSpec(const DeclSpec &DS) { |
1965 | SourceRange SR = DS.getSourceRange(); |
1966 | if (Range.getBegin().isInvalid()) |
1967 | Range.setBegin(SR.getBegin()); |
1968 | if (!SR.getEnd().isInvalid()) |
1969 | Range.setEnd(SR.getEnd()); |
1970 | } |
1971 | |
1972 | |
1973 | void clear() { |
1974 | SS.clear(); |
1975 | Name.clear(); |
1976 | Range = DS.getSourceRange(); |
1977 | BindingGroup.clear(); |
1978 | |
1979 | for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i) |
1980 | DeclTypeInfo[i].destroy(); |
1981 | DeclTypeInfo.clear(); |
1982 | Attrs.clear(); |
1983 | AsmLabel = nullptr; |
1984 | InlineStorageUsed = false; |
1985 | HasInitializer = false; |
1986 | ObjCIvar = false; |
1987 | ObjCWeakProperty = false; |
1988 | CommaLoc = SourceLocation(); |
1989 | EllipsisLoc = SourceLocation(); |
1990 | } |
1991 | |
1992 | |
1993 | |
1994 | |
1995 | bool mayOmitIdentifier() const { |
1996 | switch (Context) { |
1997 | case DeclaratorContext::File: |
1998 | case DeclaratorContext::KNRTypeList: |
1999 | case DeclaratorContext::Member: |
2000 | case DeclaratorContext::Block: |
2001 | case DeclaratorContext::ForInit: |
2002 | case DeclaratorContext::SelectionInit: |
2003 | case DeclaratorContext::Condition: |
2004 | return false; |
2005 | |
2006 | case DeclaratorContext::TypeName: |
2007 | case DeclaratorContext::FunctionalCast: |
2008 | case DeclaratorContext::AliasDecl: |
2009 | case DeclaratorContext::AliasTemplate: |
2010 | case DeclaratorContext::Prototype: |
2011 | case DeclaratorContext::LambdaExprParameter: |
2012 | case DeclaratorContext::ObjCParameter: |
2013 | case DeclaratorContext::ObjCResult: |
2014 | case DeclaratorContext::TemplateParam: |
2015 | case DeclaratorContext::CXXNew: |
2016 | case DeclaratorContext::CXXCatch: |
2017 | case DeclaratorContext::ObjCCatch: |
2018 | case DeclaratorContext::BlockLiteral: |
2019 | case DeclaratorContext::LambdaExpr: |
2020 | case DeclaratorContext::ConversionId: |
2021 | case DeclaratorContext::TemplateArg: |
2022 | case DeclaratorContext::TemplateTypeArg: |
2023 | case DeclaratorContext::TrailingReturn: |
2024 | case DeclaratorContext::TrailingReturnVar: |
2025 | case DeclaratorContext::RequiresExpr: |
2026 | return true; |
2027 | } |
2028 | llvm_unreachable("unknown context kind!"); |
2029 | } |
2030 | |
2031 | |
2032 | |
2033 | |
2034 | bool mayHaveIdentifier() const { |
2035 | switch (Context) { |
2036 | case DeclaratorContext::File: |
2037 | case DeclaratorContext::KNRTypeList: |
2038 | case DeclaratorContext::Member: |
2039 | case DeclaratorContext::Block: |
2040 | case DeclaratorContext::ForInit: |
2041 | case DeclaratorContext::SelectionInit: |
2042 | case DeclaratorContext::Condition: |
2043 | case DeclaratorContext::Prototype: |
2044 | case DeclaratorContext::LambdaExprParameter: |
2045 | case DeclaratorContext::TemplateParam: |
2046 | case DeclaratorContext::CXXCatch: |
2047 | case DeclaratorContext::ObjCCatch: |
2048 | case DeclaratorContext::RequiresExpr: |
2049 | return true; |
2050 | |
2051 | case DeclaratorContext::TypeName: |
2052 | case DeclaratorContext::FunctionalCast: |
2053 | case DeclaratorContext::CXXNew: |
2054 | case DeclaratorContext::AliasDecl: |
2055 | case DeclaratorContext::AliasTemplate: |
2056 | case DeclaratorContext::ObjCParameter: |
2057 | case DeclaratorContext::ObjCResult: |
2058 | case DeclaratorContext::BlockLiteral: |
2059 | case DeclaratorContext::LambdaExpr: |
2060 | case DeclaratorContext::ConversionId: |
2061 | case DeclaratorContext::TemplateArg: |
2062 | case DeclaratorContext::TemplateTypeArg: |
2063 | case DeclaratorContext::TrailingReturn: |
2064 | case DeclaratorContext::TrailingReturnVar: |
2065 | return false; |
2066 | } |
2067 | llvm_unreachable("unknown context kind!"); |
2068 | } |
2069 | |
2070 | |
2071 | bool mayHaveDecompositionDeclarator() const { |
2072 | switch (Context) { |
2073 | case DeclaratorContext::File: |
2074 | |
2075 | |
2076 | case DeclaratorContext::Block: |
2077 | case DeclaratorContext::ForInit: |
2078 | case DeclaratorContext::SelectionInit: |
2079 | case DeclaratorContext::Condition: |
2080 | return true; |
2081 | |
2082 | case DeclaratorContext::Member: |
2083 | case DeclaratorContext::Prototype: |
2084 | case DeclaratorContext::TemplateParam: |
2085 | case DeclaratorContext::RequiresExpr: |
2086 | |
2087 | return false; |
2088 | |
2089 | |
2090 | case DeclaratorContext::KNRTypeList: |
2091 | case DeclaratorContext::TypeName: |
2092 | case DeclaratorContext::FunctionalCast: |
2093 | case DeclaratorContext::AliasDecl: |
2094 | case DeclaratorContext::AliasTemplate: |
2095 | case DeclaratorContext::LambdaExprParameter: |
2096 | case DeclaratorContext::ObjCParameter: |
2097 | case DeclaratorContext::ObjCResult: |
2098 | case DeclaratorContext::CXXNew: |
2099 | case DeclaratorContext::CXXCatch: |
2100 | case DeclaratorContext::ObjCCatch: |
2101 | case DeclaratorContext::BlockLiteral: |
2102 | case DeclaratorContext::LambdaExpr: |
2103 | case DeclaratorContext::ConversionId: |
2104 | case DeclaratorContext::TemplateArg: |
2105 | case DeclaratorContext::TemplateTypeArg: |
2106 | case DeclaratorContext::TrailingReturn: |
2107 | case DeclaratorContext::TrailingReturnVar: |
2108 | return false; |
2109 | } |
2110 | llvm_unreachable("unknown context kind!"); |
2111 | } |
2112 | |
2113 | |
2114 | |
2115 | bool mayBeFollowedByCXXDirectInit() const { |
2116 | if (hasGroupingParens()) return false; |
2117 | |
2118 | if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) |
2119 | return false; |
2120 | |
2121 | if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern && |
2122 | Context != DeclaratorContext::File) |
2123 | return false; |
2124 | |
2125 | |
2126 | if (Name.getKind() != UnqualifiedIdKind::IK_Identifier) |
2127 | return false; |
2128 | |
2129 | switch (Context) { |
2130 | case DeclaratorContext::File: |
2131 | case DeclaratorContext::Block: |
2132 | case DeclaratorContext::ForInit: |
2133 | case DeclaratorContext::SelectionInit: |
2134 | case DeclaratorContext::TrailingReturnVar: |
2135 | return true; |
2136 | |
2137 | case DeclaratorContext::Condition: |
2138 | |
2139 | |
2140 | |
2141 | return true; |
2142 | |
2143 | case DeclaratorContext::KNRTypeList: |
2144 | case DeclaratorContext::Member: |
2145 | case DeclaratorContext::Prototype: |
2146 | case DeclaratorContext::LambdaExprParameter: |
2147 | case DeclaratorContext::ObjCParameter: |
2148 | case DeclaratorContext::ObjCResult: |
2149 | case DeclaratorContext::TemplateParam: |
2150 | case DeclaratorContext::CXXCatch: |
2151 | case DeclaratorContext::ObjCCatch: |
2152 | case DeclaratorContext::TypeName: |
2153 | case DeclaratorContext::FunctionalCast: |
2154 | case DeclaratorContext::CXXNew: |
2155 | case DeclaratorContext::AliasDecl: |
2156 | case DeclaratorContext::AliasTemplate: |
2157 | case DeclaratorContext::BlockLiteral: |
2158 | case DeclaratorContext::LambdaExpr: |
2159 | case DeclaratorContext::ConversionId: |
2160 | case DeclaratorContext::TemplateArg: |
2161 | case DeclaratorContext::TemplateTypeArg: |
2162 | case DeclaratorContext::TrailingReturn: |
2163 | case DeclaratorContext::RequiresExpr: |
2164 | return false; |
2165 | } |
2166 | llvm_unreachable("unknown context kind!"); |
2167 | } |
2168 | |
2169 | |
2170 | |
2171 | |
2172 | bool isPastIdentifier() const { return Name.isValid(); } |
2173 | |
2174 | |
2175 | |
2176 | |
2177 | |
2178 | bool hasName() const { |
2179 | return Name.getKind() != UnqualifiedIdKind::IK_Identifier || |
2180 | Name.Identifier || isDecompositionDeclarator(); |
2181 | } |
2182 | |
2183 | |
2184 | bool isDecompositionDeclarator() const { |
2185 | return BindingGroup.isSet(); |
2186 | } |
2187 | |
2188 | IdentifierInfo *getIdentifier() const { |
2189 | if (Name.getKind() == UnqualifiedIdKind::IK_Identifier) |
2190 | return Name.Identifier; |
2191 | |
2192 | return nullptr; |
2193 | } |
2194 | SourceLocation getIdentifierLoc() const { return Name.StartLocation; } |
2195 | |
2196 | |
2197 | void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc) { |
2198 | Name.setIdentifier(Id, IdLoc); |
2199 | } |
2200 | |
2201 | |
2202 | void |
2203 | setDecompositionBindings(SourceLocation LSquareLoc, |
2204 | ArrayRef<DecompositionDeclarator::Binding> Bindings, |
2205 | SourceLocation RSquareLoc); |
2206 | |
2207 | |
2208 | |
2209 | |
2210 | |
2211 | void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, |
2212 | SourceLocation EndLoc) { |
2213 | DeclTypeInfo.push_back(TI); |
2214 | DeclTypeInfo.back().getAttrs().addAll(attrs.begin(), attrs.end()); |
2215 | getAttributePool().takeAllFrom(attrs.getPool()); |
2216 | |
2217 | if (!EndLoc.isInvalid()) |
2218 | SetRangeEnd(EndLoc); |
2219 | } |
2220 | |
2221 | |
2222 | |
2223 | void AddTypeInfo(const DeclaratorChunk &TI, SourceLocation EndLoc) { |
2224 | DeclTypeInfo.push_back(TI); |
2225 | |
2226 | if (!EndLoc.isInvalid()) |
2227 | SetRangeEnd(EndLoc); |
2228 | } |
2229 | |
2230 | |
2231 | void AddInnermostTypeInfo(const DeclaratorChunk &TI) { |
2232 | DeclTypeInfo.insert(DeclTypeInfo.begin(), TI); |
2233 | } |
2234 | |
2235 | |
2236 | unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); } |
2237 | |
2238 | |
2239 | |
2240 | const DeclaratorChunk &getTypeObject(unsigned i) const { |
2241 | assert(i < DeclTypeInfo.size() && "Invalid type chunk"); |
2242 | return DeclTypeInfo[i]; |
2243 | } |
2244 | DeclaratorChunk &getTypeObject(unsigned i) { |
2245 | assert(i < DeclTypeInfo.size() && "Invalid type chunk"); |
2246 | return DeclTypeInfo[i]; |
2247 | } |
2248 | |
2249 | typedef SmallVectorImpl<DeclaratorChunk>::const_iterator type_object_iterator; |
2250 | typedef llvm::iterator_range<type_object_iterator> type_object_range; |
2251 | |
2252 | |
2253 | type_object_range type_objects() const { |
2254 | return type_object_range(DeclTypeInfo.begin(), DeclTypeInfo.end()); |
2255 | } |
2256 | |
2257 | void DropFirstTypeObject() { |
2258 | assert(!DeclTypeInfo.empty() && "No type chunks to drop."); |
2259 | DeclTypeInfo.front().destroy(); |
2260 | DeclTypeInfo.erase(DeclTypeInfo.begin()); |
2261 | } |
2262 | |
2263 | |
2264 | |
2265 | |
2266 | const DeclaratorChunk *getInnermostNonParenChunk() const { |
2267 | for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { |
2268 | if (!DeclTypeInfo[i].isParen()) |
2269 | return &DeclTypeInfo[i]; |
2270 | } |
2271 | return nullptr; |
2272 | } |
2273 | |
2274 | |
2275 | |
2276 | |
2277 | const DeclaratorChunk *getOutermostNonParenChunk() const { |
2278 | for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) { |
2279 | if (!DeclTypeInfo[i-1].isParen()) |
2280 | return &DeclTypeInfo[i-1]; |
2281 | } |
2282 | return nullptr; |
2283 | } |
2284 | |
2285 | |
2286 | |
2287 | |
2288 | bool isArrayOfUnknownBound() const { |
2289 | const DeclaratorChunk *chunk = getInnermostNonParenChunk(); |
2290 | return (chunk && chunk->Kind == DeclaratorChunk::Array && |
2291 | !chunk->Arr.NumElts); |
2292 | } |
2293 | |
2294 | |
2295 | |
2296 | |
2297 | |
2298 | bool isFunctionDeclarator(unsigned& idx) const { |
2299 | for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { |
2300 | switch (DeclTypeInfo[i].Kind) { |
2301 | case DeclaratorChunk::Function: |
2302 | idx = i; |
2303 | return true; |
2304 | case DeclaratorChunk::Paren: |
2305 | continue; |
2306 | case DeclaratorChunk::Pointer: |
2307 | case DeclaratorChunk::Reference: |
2308 | case DeclaratorChunk::Array: |
2309 | case DeclaratorChunk::BlockPointer: |
2310 | case DeclaratorChunk::MemberPointer: |
2311 | case DeclaratorChunk::Pipe: |
2312 | return false; |
2313 | } |
2314 | llvm_unreachable("Invalid type chunk"); |
2315 | } |
2316 | return false; |
2317 | } |
2318 | |
2319 | |
2320 | |
2321 | |
2322 | bool isFunctionDeclarator() const { |
2323 | unsigned index; |
2324 | return isFunctionDeclarator(index); |
2325 | } |
2326 | |
2327 | |
2328 | |
2329 | DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() { |
2330 | assert(isFunctionDeclarator() && "Not a function declarator!"); |
2331 | unsigned index = 0; |
2332 | isFunctionDeclarator(index); |
2333 | return DeclTypeInfo[index].Fun; |
2334 | } |
2335 | |
2336 | |
2337 | |
2338 | const DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() const { |
2339 | return const_cast<Declarator*>(this)->getFunctionTypeInfo(); |
2340 | } |
2341 | |
2342 | |
2343 | |
2344 | |
2345 | |
2346 | |
2347 | |
2348 | bool isDeclarationOfFunction() const; |
2349 | |
2350 | |
2351 | |
2352 | bool isFunctionDeclarationContext() const { |
2353 | if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) |
2354 | return false; |
2355 | |
2356 | switch (Context) { |
2357 | case DeclaratorContext::File: |
2358 | case DeclaratorContext::Member: |
2359 | case DeclaratorContext::Block: |
2360 | case DeclaratorContext::ForInit: |
2361 | case DeclaratorContext::SelectionInit: |
2362 | return true; |
2363 | |
2364 | case DeclaratorContext::Condition: |
2365 | case DeclaratorContext::KNRTypeList: |
2366 | case DeclaratorContext::TypeName: |
2367 | case DeclaratorContext::FunctionalCast: |
2368 | case DeclaratorContext::AliasDecl: |
2369 | case DeclaratorContext::AliasTemplate: |
2370 | case DeclaratorContext::Prototype: |
2371 | case DeclaratorContext::LambdaExprParameter: |
2372 | case DeclaratorContext::ObjCParameter: |
2373 | case DeclaratorContext::ObjCResult: |
2374 | case DeclaratorContext::TemplateParam: |
2375 | case DeclaratorContext::CXXNew: |
2376 | case DeclaratorContext::CXXCatch: |
2377 | case DeclaratorContext::ObjCCatch: |
2378 | case DeclaratorContext::BlockLiteral: |
2379 | case DeclaratorContext::LambdaExpr: |
2380 | case DeclaratorContext::ConversionId: |
2381 | case DeclaratorContext::TemplateArg: |
2382 | case DeclaratorContext::TemplateTypeArg: |
2383 | case DeclaratorContext::TrailingReturn: |
2384 | case DeclaratorContext::TrailingReturnVar: |
2385 | case DeclaratorContext::RequiresExpr: |
2386 | return false; |
2387 | } |
2388 | llvm_unreachable("unknown context kind!"); |
2389 | } |
2390 | |
2391 | |
2392 | |
2393 | bool isExpressionContext() const { |
2394 | switch (Context) { |
2395 | case DeclaratorContext::File: |
2396 | case DeclaratorContext::KNRTypeList: |
2397 | case DeclaratorContext::Member: |
2398 | |
2399 | |
2400 | case DeclaratorContext::TypeName: |
2401 | |
2402 | case DeclaratorContext::FunctionalCast: |
2403 | case DeclaratorContext::AliasDecl: |
2404 | case DeclaratorContext::AliasTemplate: |
2405 | case DeclaratorContext::Prototype: |
2406 | case DeclaratorContext::LambdaExprParameter: |
2407 | case DeclaratorContext::ObjCParameter: |
2408 | case DeclaratorContext::ObjCResult: |
2409 | case DeclaratorContext::TemplateParam: |
2410 | case DeclaratorContext::CXXNew: |
2411 | case DeclaratorContext::CXXCatch: |
2412 | case DeclaratorContext::ObjCCatch: |
2413 | case DeclaratorContext::BlockLiteral: |
2414 | case DeclaratorContext::LambdaExpr: |
2415 | case DeclaratorContext::ConversionId: |
2416 | case DeclaratorContext::TrailingReturn: |
2417 | case DeclaratorContext::TrailingReturnVar: |
2418 | case DeclaratorContext::TemplateTypeArg: |
2419 | case DeclaratorContext::RequiresExpr: |
2420 | return false; |
2421 | |
2422 | case DeclaratorContext::Block: |
2423 | case DeclaratorContext::ForInit: |
2424 | case DeclaratorContext::SelectionInit: |
2425 | case DeclaratorContext::Condition: |
2426 | case DeclaratorContext::TemplateArg: |
2427 | return true; |
2428 | } |
2429 | |
2430 | llvm_unreachable("unknown context kind!"); |
2431 | } |
2432 | |
2433 | |
2434 | |
2435 | bool isFunctionDeclaratorAFunctionDeclaration() const { |
2436 | if (!isFunctionDeclarationContext()) |
2437 | return false; |
2438 | |
2439 | for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I) |
2440 | if (getTypeObject(I).Kind != DeclaratorChunk::Paren) |
2441 | return false; |
2442 | |
2443 | return true; |
2444 | } |
2445 | |
2446 | |
2447 | |
2448 | bool hasTrailingReturnType() const { |
2449 | for (const auto &Chunk : type_objects()) |
2450 | if (Chunk.Kind == DeclaratorChunk::Function && |
2451 | Chunk.Fun.hasTrailingReturnType()) |
2452 | return true; |
2453 | return false; |
2454 | } |
2455 | |
2456 | |
2457 | ParsedType getTrailingReturnType() const { |
2458 | for (const auto &Chunk : type_objects()) |
2459 | if (Chunk.Kind == DeclaratorChunk::Function && |
2460 | Chunk.Fun.hasTrailingReturnType()) |
2461 | return Chunk.Fun.getTrailingReturnType(); |
2462 | return ParsedType(); |
2463 | } |
2464 | |
2465 | |
2466 | void setTrailingRequiresClause(Expr *TRC) { |
2467 | TrailingRequiresClause = TRC; |
2468 | |
2469 | SetRangeEnd(TRC->getEndLoc()); |
2470 | } |
2471 | |
2472 | |
2473 | Expr *getTrailingRequiresClause() { |
2474 | return TrailingRequiresClause; |
2475 | } |
2476 | |
2477 | |
2478 | |
2479 | bool hasTrailingRequiresClause() const { |
2480 | return TrailingRequiresClause != nullptr; |
2481 | } |
2482 | |
2483 | |
2484 | void setTemplateParameterLists(ArrayRef<TemplateParameterList *> TPLs) { |
2485 | TemplateParameterLists = TPLs; |
2486 | } |
2487 | |
2488 | |
2489 | ArrayRef<TemplateParameterList *> getTemplateParameterLists() const { |
2490 | return TemplateParameterLists; |
2491 | } |
2492 | |
2493 | |
2494 | |
2495 | |
2496 | void setInventedTemplateParameterList(TemplateParameterList *Invented) { |
2497 | InventedTemplateParameterList = Invented; |
2498 | } |
2499 | |
2500 | |
2501 | |
2502 | |
2503 | TemplateParameterList * getInventedTemplateParameterList() const { |
2504 | return InventedTemplateParameterList; |
2505 | } |
2506 | |
2507 | |
2508 | |
2509 | |
2510 | |
2511 | |
2512 | |
2513 | |
2514 | |
2515 | |
2516 | void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc) { |
2517 | Attrs.takeAllFrom(attrs); |
2518 | |
2519 | if (!lastLoc.isInvalid()) |
2520 | SetRangeEnd(lastLoc); |
2521 | } |
2522 | |
2523 | const ParsedAttributes &getAttributes() const { return Attrs; } |
2524 | ParsedAttributes &getAttributes() { return Attrs; } |
2525 | |
2526 | |
2527 | bool hasAttributes() const { |
2528 | if (!getAttributes().empty() || getDeclSpec().hasAttributes()) |
2529 | return true; |
2530 | for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i) |
2531 | if (!getTypeObject(i).getAttrs().empty()) |
2532 | return true; |
2533 | return false; |
2534 | } |
2535 | |
2536 | |
2537 | |
2538 | void getCXX11AttributeRanges(SmallVectorImpl<SourceRange> &Ranges) { |
2539 | for (const ParsedAttr &AL : Attrs) |
2540 | if (AL.isCXX11Attribute()) |
2541 | Ranges.push_back(AL.getRange()); |
2542 | } |
2543 | |
2544 | void setAsmLabel(Expr *E) { AsmLabel = E; } |
2545 | Expr *getAsmLabel() const { return AsmLabel; } |
2546 | |
2547 | void setExtension(bool Val = true) { Extension = Val; } |
2548 | bool getExtension() const { return Extension; } |
2549 | |
2550 | void setObjCIvar(bool Val = true) { ObjCIvar = Val; } |
2551 | bool isObjCIvar() const { return ObjCIvar; } |
2552 | |
2553 | void setObjCWeakProperty(bool Val = true) { ObjCWeakProperty = Val; } |
2554 | bool isObjCWeakProperty() const { return ObjCWeakProperty; } |
2555 | |
2556 | void setInvalidType(bool Val = true) { InvalidType = Val; } |
2557 | bool isInvalidType() const { |
2558 | return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error; |
2559 | } |
2560 | |
2561 | void setGroupingParens(bool flag) { GroupingParens = flag; } |
2562 | bool hasGroupingParens() const { return GroupingParens; } |
2563 | |
2564 | bool isFirstDeclarator() const { return !CommaLoc.isValid(); } |
2565 | SourceLocation getCommaLoc() const { return CommaLoc; } |
2566 | void setCommaLoc(SourceLocation CL) { CommaLoc = CL; } |
2567 | |
2568 | bool hasEllipsis() const { return EllipsisLoc.isValid(); } |
2569 | SourceLocation getEllipsisLoc() const { return EllipsisLoc; } |
2570 | void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; } |
2571 | |
2572 | void setFunctionDefinitionKind(FunctionDefinitionKind Val) { |
2573 | FunctionDefinition = static_cast<unsigned>(Val); |
2574 | } |
2575 | |
2576 | bool isFunctionDefinition() const { |
2577 | return getFunctionDefinitionKind() != FunctionDefinitionKind::Declaration; |
2578 | } |
2579 | |
2580 | FunctionDefinitionKind getFunctionDefinitionKind() const { |
2581 | return (FunctionDefinitionKind)FunctionDefinition; |
2582 | } |
2583 | |
2584 | void setHasInitializer(bool Val = true) { HasInitializer = Val; } |
2585 | bool hasInitializer() const { return HasInitializer; } |
2586 | |
2587 | |
2588 | bool isFirstDeclarationOfMember() { |
2589 | return getContext() == DeclaratorContext::Member && |
2590 | !getDeclSpec().isFriendSpecified(); |
2591 | } |
2592 | |
2593 | |
2594 | |
2595 | |
2596 | bool isStaticMember(); |
2597 | |
2598 | |
2599 | bool isCtorOrDtor(); |
2600 | |
2601 | void setRedeclaration(bool Val) { Redeclaration = Val; } |
2602 | bool isRedeclaration() const { return Redeclaration; } |
2603 | }; |
2604 | |
2605 | |
2606 | |
2607 | struct FieldDeclarator { |
2608 | Declarator D; |
2609 | Expr *BitfieldSize; |
2610 | explicit FieldDeclarator(const DeclSpec &DS) |
2611 | : D(DS, DeclaratorContext::Member), BitfieldSize(nullptr) {} |
2612 | }; |
2613 | |
2614 | |
2615 | class VirtSpecifiers { |
2616 | public: |
2617 | enum Specifier { |
2618 | VS_None = 0, |
2619 | VS_Override = 1, |
2620 | VS_Final = 2, |
2621 | VS_Sealed = 4, |
2622 | |
2623 | VS_GNU_Final = 8, |
2624 | VS_Abstract = 16 |
2625 | }; |
2626 | |
2627 | VirtSpecifiers() : Specifiers(0), LastSpecifier(VS_None) { } |
2628 | |
2629 | bool SetSpecifier(Specifier VS, SourceLocation Loc, |
2630 | const char *&PrevSpec); |
2631 | |
2632 | bool isUnset() const { return Specifiers == 0; } |
2633 | |
2634 | bool isOverrideSpecified() const { return Specifiers & VS_Override; } |
2635 | SourceLocation getOverrideLoc() const { return VS_overrideLoc; } |
2636 | |
2637 | bool isFinalSpecified() const { return Specifiers & (VS_Final | VS_Sealed | VS_GNU_Final); } |
2638 | bool isFinalSpelledSealed() const { return Specifiers & VS_Sealed; } |
2639 | SourceLocation getFinalLoc() const { return VS_finalLoc; } |
2640 | SourceLocation getAbstractLoc() const { return VS_abstractLoc; } |
2641 | |
2642 | void clear() { Specifiers = 0; } |
2643 | |
2644 | static const char *getSpecifierName(Specifier VS); |
2645 | |
2646 | SourceLocation getFirstLocation() const { return FirstLocation; } |
2647 | SourceLocation getLastLocation() const { return LastLocation; } |
2648 | Specifier getLastSpecifier() const { return LastSpecifier; } |
2649 | |
2650 | private: |
2651 | unsigned Specifiers; |
2652 | Specifier LastSpecifier; |
2653 | |
2654 | SourceLocation VS_overrideLoc, VS_finalLoc, VS_abstractLoc; |
2655 | SourceLocation FirstLocation; |
2656 | SourceLocation LastLocation; |
2657 | }; |
2658 | |
2659 | enum class LambdaCaptureInitKind { |
2660 | NoInit, |
2661 | CopyInit, |
2662 | DirectInit, |
2663 | ListInit |
2664 | }; |
2665 | |
2666 | |
2667 | struct LambdaIntroducer { |
2668 | |
2669 | struct LambdaCapture { |
2670 | LambdaCaptureKind Kind; |
2671 | SourceLocation Loc; |
2672 | IdentifierInfo *Id; |
2673 | SourceLocation EllipsisLoc; |
2674 | LambdaCaptureInitKind InitKind; |
2675 | ExprResult Init; |
2676 | ParsedType InitCaptureType; |
2677 | SourceRange ExplicitRange; |
2678 | |
2679 | LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc, |
2680 | IdentifierInfo *Id, SourceLocation EllipsisLoc, |
2681 | LambdaCaptureInitKind InitKind, ExprResult Init, |
2682 | ParsedType InitCaptureType, |
2683 | SourceRange ExplicitRange) |
2684 | : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc), |
2685 | InitKind(InitKind), Init(Init), InitCaptureType(InitCaptureType), |
2686 | ExplicitRange(ExplicitRange) {} |
2687 | }; |
2688 | |
2689 | SourceRange Range; |
2690 | SourceLocation DefaultLoc; |
2691 | LambdaCaptureDefault Default; |
2692 | SmallVector<LambdaCapture, 4> Captures; |
2693 | |
2694 | LambdaIntroducer() |
2695 | : Default(LCD_None) {} |
2696 | |
2697 | |
2698 | void addCapture(LambdaCaptureKind Kind, |
2699 | SourceLocation Loc, |
2700 | IdentifierInfo* Id, |
2701 | SourceLocation EllipsisLoc, |
2702 | LambdaCaptureInitKind InitKind, |
2703 | ExprResult Init, |
2704 | ParsedType InitCaptureType, |
2705 | SourceRange ExplicitRange) { |
2706 | Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init, |
2707 | InitCaptureType, ExplicitRange)); |
2708 | } |
2709 | }; |
2710 | |
2711 | struct InventedTemplateParameterInfo { |
2712 | |
2713 | |
2714 | |
2715 | unsigned NumExplicitTemplateParams = 0; |
2716 | |
2717 | |
2718 | |
2719 | unsigned AutoTemplateParameterDepth = 0; |
2720 | |
2721 | |
2722 | |
2723 | |
2724 | |
2725 | |
2726 | |
2727 | |
2728 | SmallVector<NamedDecl*, 4> TemplateParams; |
2729 | }; |
2730 | |
2731 | } |
2732 | |
2733 | #endif // LLVM_CLANG_SEMA_DECLSPEC_H |