1//===--- SemaDeclSpec.cpp - Declaration Specifier Semantic Analysis -------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for declaration specifiers.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Sema/DeclSpec.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/Expr.h"
18#include "clang/AST/NestedNameSpecifier.h"
19#include "clang/AST/TypeLoc.h"
20#include "clang/Basic/LangOptions.h"
21#include "clang/Basic/TargetInfo.h"
22#include "clang/Lex/Preprocessor.h"
23#include "clang/Parse/ParseDiagnostic.h" // FIXME: remove this back-dependency!
24#include "clang/Sema/LocInfoType.h"
25#include "clang/Sema/ParsedTemplate.h"
26#include "clang/Sema/Sema.h"
27#include "clang/Sema/SemaDiagnostic.h"
28#include "llvm/ADT/STLExtras.h"
29#include "llvm/ADT/SmallString.h"
30#include "llvm/Support/ErrorHandling.h"
31#include <cstring>
32using namespace clang;
33
34
35static DiagnosticBuilder Diag(DiagnosticsEngine &D, SourceLocation Loc,
36 unsigned DiagID) {
37 return D.Report(Loc, DiagID);
38}
39
40
41void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
42 assert(TemplateId && "NULL template-id annotation?");
43 Kind = IK_TemplateId;
44 this->TemplateId = TemplateId;
45 StartLocation = TemplateId->TemplateNameLoc;
46 EndLocation = TemplateId->RAngleLoc;
47}
48
49void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
50 assert(TemplateId && "NULL template-id annotation?");
51 Kind = IK_ConstructorTemplateId;
52 this->TemplateId = TemplateId;
53 StartLocation = TemplateId->TemplateNameLoc;
54 EndLocation = TemplateId->RAngleLoc;
55}
56
57void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc,
58 TypeLoc TL, SourceLocation ColonColonLoc) {
59 Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc);
60 if (Range.getBegin().isInvalid())
61 Range.setBegin(TL.getBeginLoc());
62 Range.setEnd(ColonColonLoc);
63
64 assert(Range == Builder.getSourceRange() &&
65 "NestedNameSpecifierLoc range computation incorrect");
66}
67
68void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier,
69 SourceLocation IdentifierLoc,
70 SourceLocation ColonColonLoc) {
71 Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc);
72
73 if (Range.getBegin().isInvalid())
74 Range.setBegin(IdentifierLoc);
75 Range.setEnd(ColonColonLoc);
76
77 assert(Range == Builder.getSourceRange() &&
78 "NestedNameSpecifierLoc range computation incorrect");
79}
80
81void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace,
82 SourceLocation NamespaceLoc,
83 SourceLocation ColonColonLoc) {
84 Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc);
85
86 if (Range.getBegin().isInvalid())
87 Range.setBegin(NamespaceLoc);
88 Range.setEnd(ColonColonLoc);
89
90 assert(Range == Builder.getSourceRange() &&
91 "NestedNameSpecifierLoc range computation incorrect");
92}
93
94void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
95 SourceLocation AliasLoc,
96 SourceLocation ColonColonLoc) {
97 Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc);
98
99 if (Range.getBegin().isInvalid())
100 Range.setBegin(AliasLoc);
101 Range.setEnd(ColonColonLoc);
102
103 assert(Range == Builder.getSourceRange() &&
104 "NestedNameSpecifierLoc range computation incorrect");
105}
106
107void CXXScopeSpec::MakeGlobal(ASTContext &Context,
108 SourceLocation ColonColonLoc) {
109 Builder.MakeGlobal(Context, ColonColonLoc);
110
111 Range = SourceRange(ColonColonLoc);
112
113 assert(Range == Builder.getSourceRange() &&
114 "NestedNameSpecifierLoc range computation incorrect");
115}
116
117void CXXScopeSpec::MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
118 SourceLocation SuperLoc,
119 SourceLocation ColonColonLoc) {
120 Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
121
122 Range.setBegin(SuperLoc);
123 Range.setEnd(ColonColonLoc);
124
125 assert(Range == Builder.getSourceRange() &&
126 "NestedNameSpecifierLoc range computation incorrect");
127}
128
129void CXXScopeSpec::MakeTrivial(ASTContext &Context,
130 NestedNameSpecifier *Qualifier, SourceRange R) {
131 Builder.MakeTrivial(Context, Qualifier, R);
132 Range = R;
133}
134
135void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) {
136 if (!Other) {
137 Range = SourceRange();
138 Builder.Clear();
139 return;
140 }
141
142 Range = Other.getSourceRange();
143 Builder.Adopt(Other);
144}
145
146SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
147 if (!Builder.getRepresentation())
148 return SourceLocation();
149 return Builder.getTemporary().getLocalBeginLoc();
150}
151
152NestedNameSpecifierLoc
153CXXScopeSpec::getWithLocInContext(ASTContext &Context) const {
154 if (!Builder.getRepresentation())
155 return NestedNameSpecifierLoc();
156
157 return Builder.getWithLocInContext(Context);
158}
159
160/// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
161/// "TheDeclarator" is the declarator that this will be added to.
162DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
163 bool isAmbiguous,
164 SourceLocation LParenLoc,
165 ParamInfo *Params,
166 unsigned NumParams,
167 SourceLocation EllipsisLoc,
168 SourceLocation RParenLoc,
169 unsigned TypeQuals,
170 bool RefQualifierIsLvalueRef,
171 SourceLocation RefQualifierLoc,
172 SourceLocation ConstQualifierLoc,
173 SourceLocation
174 VolatileQualifierLoc,
175 SourceLocation
176 RestrictQualifierLoc,
177 SourceLocation MutableLoc,
178 ExceptionSpecificationType
179 ESpecType,
180 SourceLocation ESpecLoc,
181 ParsedType *Exceptions,
182 SourceRange *ExceptionRanges,
183 unsigned NumExceptions,
184 Expr *NoexceptExpr,
185 CachedTokens *ExceptionSpecTokens,
186 SourceLocation LocalRangeBegin,
187 SourceLocation LocalRangeEnd,
188 Declarator &TheDeclarator,
189 TypeResult TrailingReturnType) {
190 assert(!(TypeQuals & DeclSpec::TQ_atomic) &&
191 "function cannot have _Atomic qualifier");
192
193 DeclaratorChunk I;
194 I.Kind = Function;
195 I.Loc = LocalRangeBegin;
196 I.EndLoc = LocalRangeEnd;
197 I.Fun.AttrList = nullptr;
198 I.Fun.hasPrototype = hasProto;
199 I.Fun.isVariadic = EllipsisLoc.isValid();
200 I.Fun.isAmbiguous = isAmbiguous;
201 I.Fun.LParenLoc = LParenLoc.getRawEncoding();
202 I.Fun.EllipsisLoc = EllipsisLoc.getRawEncoding();
203 I.Fun.RParenLoc = RParenLoc.getRawEncoding();
204 I.Fun.DeleteParams = false;
205 I.Fun.TypeQuals = TypeQuals;
206 I.Fun.NumParams = NumParams;
207 I.Fun.Params = nullptr;
208 I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
209 I.Fun.RefQualifierLoc = RefQualifierLoc.getRawEncoding();
210 I.Fun.ConstQualifierLoc = ConstQualifierLoc.getRawEncoding();
211 I.Fun.VolatileQualifierLoc = VolatileQualifierLoc.getRawEncoding();
212 I.Fun.RestrictQualifierLoc = RestrictQualifierLoc.getRawEncoding();
213 I.Fun.MutableLoc = MutableLoc.getRawEncoding();
214 I.Fun.ExceptionSpecType = ESpecType;
215 I.Fun.ExceptionSpecLoc = ESpecLoc.getRawEncoding();
216 I.Fun.NumExceptions = 0;
217 I.Fun.Exceptions = nullptr;
218 I.Fun.NoexceptExpr = nullptr;
219 I.Fun.HasTrailingReturnType = TrailingReturnType.isUsable() ||
220 TrailingReturnType.isInvalid();
221 I.Fun.TrailingReturnType = TrailingReturnType.get();
222
223 assert(I.Fun.TypeQuals == TypeQuals && "bitfield overflow");
224 assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
225
226 // new[] a parameter array if needed.
227 if (NumParams) {
228 // If the 'InlineParams' in Declarator is unused and big enough, put our
229 // parameter list there (in an effort to avoid new/delete traffic). If it
230 // is already used (consider a function returning a function pointer) or too
231 // small (function with too many parameters), go to the heap.
232 if (!TheDeclarator.InlineParamsUsed &&
233 NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
234 I.Fun.Params = TheDeclarator.InlineParams;
235 I.Fun.DeleteParams = false;
236 TheDeclarator.InlineParamsUsed = true;
237 } else {
238 I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
239 I.Fun.DeleteParams = true;
240 }
241 memcpy(I.Fun.Params, Params, sizeof(Params[0]) * NumParams);
242 }
243
244 // Check what exception specification information we should actually store.
245 switch (ESpecType) {
246 default: break; // By default, save nothing.
247 case EST_Dynamic:
248 // new[] an exception array if needed
249 if (NumExceptions) {
250 I.Fun.NumExceptions = NumExceptions;
251 I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions];
252 for (unsigned i = 0; i != NumExceptions; ++i) {
253 I.Fun.Exceptions[i].Ty = Exceptions[i];
254 I.Fun.Exceptions[i].Range = ExceptionRanges[i];
255 }
256 }
257 break;
258
259 case EST_ComputedNoexcept:
260 I.Fun.NoexceptExpr = NoexceptExpr;
261 break;
262
263 case EST_Unparsed:
264 I.Fun.ExceptionSpecTokens = ExceptionSpecTokens;
265 break;
266 }
267 return I;
268}
269
270bool Declarator::isDeclarationOfFunction() const {
271 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
272 switch (DeclTypeInfo[i].Kind) {
273 case DeclaratorChunk::Function:
274 return true;
275 case DeclaratorChunk::Paren:
276 continue;
277 case DeclaratorChunk::Pointer:
278 case DeclaratorChunk::Reference:
279 case DeclaratorChunk::Array:
280 case DeclaratorChunk::BlockPointer:
281 case DeclaratorChunk::MemberPointer:
282 return false;
283 }
284 llvm_unreachable("Invalid type chunk");
285 }
286
287 switch (DS.getTypeSpecType()) {
288 case TST_atomic:
289 case TST_auto:
290 case TST_bool:
291 case TST_char:
292 case TST_char16:
293 case TST_char32:
294 case TST_class:
295 case TST_decimal128:
296 case TST_decimal32:
297 case TST_decimal64:
298 case TST_double:
299 case TST_enum:
300 case TST_error:
301 case TST_float:
302 case TST_half:
303 case TST_int:
304 case TST_int128:
305 case TST_struct:
306 case TST_interface:
307 case TST_union:
308 case TST_unknown_anytype:
309 case TST_unspecified:
310 case TST_void:
311 case TST_wchar:
312 return false;
313
314 case TST_decltype_auto:
315 // This must have an initializer, so can't be a function declaration,
316 // even if the initializer has function type.
317 return false;
318
319 case TST_decltype:
320 case TST_typeofExpr:
321 if (Expr *E = DS.getRepAsExpr())
322 return E->getType()->isFunctionType();
323 return false;
324
325 case TST_underlyingType:
326 case TST_typename:
327 case TST_typeofType: {
328 QualType QT = DS.getRepAsType().get();
329 if (QT.isNull())
330 return false;
331
332 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
333 QT = LIT->getType();
334
335 if (QT.isNull())
336 return false;
337
338 return QT->isFunctionType();
339 }
340 }
341
342 llvm_unreachable("Invalid TypeSpecType!");
343}
344
345bool Declarator::isStaticMember() {
346 assert(getContext() == MemberContext);
347 return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
| 1//===--- SemaDeclSpec.cpp - Declaration Specifier Semantic Analysis -------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for declaration specifiers.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Sema/DeclSpec.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/Expr.h"
18#include "clang/AST/NestedNameSpecifier.h"
19#include "clang/AST/TypeLoc.h"
20#include "clang/Basic/LangOptions.h"
21#include "clang/Basic/TargetInfo.h"
22#include "clang/Lex/Preprocessor.h"
23#include "clang/Parse/ParseDiagnostic.h" // FIXME: remove this back-dependency!
24#include "clang/Sema/LocInfoType.h"
25#include "clang/Sema/ParsedTemplate.h"
26#include "clang/Sema/Sema.h"
27#include "clang/Sema/SemaDiagnostic.h"
28#include "llvm/ADT/STLExtras.h"
29#include "llvm/ADT/SmallString.h"
30#include "llvm/Support/ErrorHandling.h"
31#include <cstring>
32using namespace clang;
33
34
35static DiagnosticBuilder Diag(DiagnosticsEngine &D, SourceLocation Loc,
36 unsigned DiagID) {
37 return D.Report(Loc, DiagID);
38}
39
40
41void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) {
42 assert(TemplateId && "NULL template-id annotation?");
43 Kind = IK_TemplateId;
44 this->TemplateId = TemplateId;
45 StartLocation = TemplateId->TemplateNameLoc;
46 EndLocation = TemplateId->RAngleLoc;
47}
48
49void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) {
50 assert(TemplateId && "NULL template-id annotation?");
51 Kind = IK_ConstructorTemplateId;
52 this->TemplateId = TemplateId;
53 StartLocation = TemplateId->TemplateNameLoc;
54 EndLocation = TemplateId->RAngleLoc;
55}
56
57void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc,
58 TypeLoc TL, SourceLocation ColonColonLoc) {
59 Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc);
60 if (Range.getBegin().isInvalid())
61 Range.setBegin(TL.getBeginLoc());
62 Range.setEnd(ColonColonLoc);
63
64 assert(Range == Builder.getSourceRange() &&
65 "NestedNameSpecifierLoc range computation incorrect");
66}
67
68void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier,
69 SourceLocation IdentifierLoc,
70 SourceLocation ColonColonLoc) {
71 Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc);
72
73 if (Range.getBegin().isInvalid())
74 Range.setBegin(IdentifierLoc);
75 Range.setEnd(ColonColonLoc);
76
77 assert(Range == Builder.getSourceRange() &&
78 "NestedNameSpecifierLoc range computation incorrect");
79}
80
81void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace,
82 SourceLocation NamespaceLoc,
83 SourceLocation ColonColonLoc) {
84 Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc);
85
86 if (Range.getBegin().isInvalid())
87 Range.setBegin(NamespaceLoc);
88 Range.setEnd(ColonColonLoc);
89
90 assert(Range == Builder.getSourceRange() &&
91 "NestedNameSpecifierLoc range computation incorrect");
92}
93
94void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias,
95 SourceLocation AliasLoc,
96 SourceLocation ColonColonLoc) {
97 Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc);
98
99 if (Range.getBegin().isInvalid())
100 Range.setBegin(AliasLoc);
101 Range.setEnd(ColonColonLoc);
102
103 assert(Range == Builder.getSourceRange() &&
104 "NestedNameSpecifierLoc range computation incorrect");
105}
106
107void CXXScopeSpec::MakeGlobal(ASTContext &Context,
108 SourceLocation ColonColonLoc) {
109 Builder.MakeGlobal(Context, ColonColonLoc);
110
111 Range = SourceRange(ColonColonLoc);
112
113 assert(Range == Builder.getSourceRange() &&
114 "NestedNameSpecifierLoc range computation incorrect");
115}
116
117void CXXScopeSpec::MakeSuper(ASTContext &Context, CXXRecordDecl *RD,
118 SourceLocation SuperLoc,
119 SourceLocation ColonColonLoc) {
120 Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
121
122 Range.setBegin(SuperLoc);
123 Range.setEnd(ColonColonLoc);
124
125 assert(Range == Builder.getSourceRange() &&
126 "NestedNameSpecifierLoc range computation incorrect");
127}
128
129void CXXScopeSpec::MakeTrivial(ASTContext &Context,
130 NestedNameSpecifier *Qualifier, SourceRange R) {
131 Builder.MakeTrivial(Context, Qualifier, R);
132 Range = R;
133}
134
135void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) {
136 if (!Other) {
137 Range = SourceRange();
138 Builder.Clear();
139 return;
140 }
141
142 Range = Other.getSourceRange();
143 Builder.Adopt(Other);
144}
145
146SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const {
147 if (!Builder.getRepresentation())
148 return SourceLocation();
149 return Builder.getTemporary().getLocalBeginLoc();
150}
151
152NestedNameSpecifierLoc
153CXXScopeSpec::getWithLocInContext(ASTContext &Context) const {
154 if (!Builder.getRepresentation())
155 return NestedNameSpecifierLoc();
156
157 return Builder.getWithLocInContext(Context);
158}
159
160/// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
161/// "TheDeclarator" is the declarator that this will be added to.
162DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
163 bool isAmbiguous,
164 SourceLocation LParenLoc,
165 ParamInfo *Params,
166 unsigned NumParams,
167 SourceLocation EllipsisLoc,
168 SourceLocation RParenLoc,
169 unsigned TypeQuals,
170 bool RefQualifierIsLvalueRef,
171 SourceLocation RefQualifierLoc,
172 SourceLocation ConstQualifierLoc,
173 SourceLocation
174 VolatileQualifierLoc,
175 SourceLocation
176 RestrictQualifierLoc,
177 SourceLocation MutableLoc,
178 ExceptionSpecificationType
179 ESpecType,
180 SourceLocation ESpecLoc,
181 ParsedType *Exceptions,
182 SourceRange *ExceptionRanges,
183 unsigned NumExceptions,
184 Expr *NoexceptExpr,
185 CachedTokens *ExceptionSpecTokens,
186 SourceLocation LocalRangeBegin,
187 SourceLocation LocalRangeEnd,
188 Declarator &TheDeclarator,
189 TypeResult TrailingReturnType) {
190 assert(!(TypeQuals & DeclSpec::TQ_atomic) &&
191 "function cannot have _Atomic qualifier");
192
193 DeclaratorChunk I;
194 I.Kind = Function;
195 I.Loc = LocalRangeBegin;
196 I.EndLoc = LocalRangeEnd;
197 I.Fun.AttrList = nullptr;
198 I.Fun.hasPrototype = hasProto;
199 I.Fun.isVariadic = EllipsisLoc.isValid();
200 I.Fun.isAmbiguous = isAmbiguous;
201 I.Fun.LParenLoc = LParenLoc.getRawEncoding();
202 I.Fun.EllipsisLoc = EllipsisLoc.getRawEncoding();
203 I.Fun.RParenLoc = RParenLoc.getRawEncoding();
204 I.Fun.DeleteParams = false;
205 I.Fun.TypeQuals = TypeQuals;
206 I.Fun.NumParams = NumParams;
207 I.Fun.Params = nullptr;
208 I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
209 I.Fun.RefQualifierLoc = RefQualifierLoc.getRawEncoding();
210 I.Fun.ConstQualifierLoc = ConstQualifierLoc.getRawEncoding();
211 I.Fun.VolatileQualifierLoc = VolatileQualifierLoc.getRawEncoding();
212 I.Fun.RestrictQualifierLoc = RestrictQualifierLoc.getRawEncoding();
213 I.Fun.MutableLoc = MutableLoc.getRawEncoding();
214 I.Fun.ExceptionSpecType = ESpecType;
215 I.Fun.ExceptionSpecLoc = ESpecLoc.getRawEncoding();
216 I.Fun.NumExceptions = 0;
217 I.Fun.Exceptions = nullptr;
218 I.Fun.NoexceptExpr = nullptr;
219 I.Fun.HasTrailingReturnType = TrailingReturnType.isUsable() ||
220 TrailingReturnType.isInvalid();
221 I.Fun.TrailingReturnType = TrailingReturnType.get();
222
223 assert(I.Fun.TypeQuals == TypeQuals && "bitfield overflow");
224 assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow");
225
226 // new[] a parameter array if needed.
227 if (NumParams) {
228 // If the 'InlineParams' in Declarator is unused and big enough, put our
229 // parameter list there (in an effort to avoid new/delete traffic). If it
230 // is already used (consider a function returning a function pointer) or too
231 // small (function with too many parameters), go to the heap.
232 if (!TheDeclarator.InlineParamsUsed &&
233 NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
234 I.Fun.Params = TheDeclarator.InlineParams;
235 I.Fun.DeleteParams = false;
236 TheDeclarator.InlineParamsUsed = true;
237 } else {
238 I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
239 I.Fun.DeleteParams = true;
240 }
241 memcpy(I.Fun.Params, Params, sizeof(Params[0]) * NumParams);
242 }
243
244 // Check what exception specification information we should actually store.
245 switch (ESpecType) {
246 default: break; // By default, save nothing.
247 case EST_Dynamic:
248 // new[] an exception array if needed
249 if (NumExceptions) {
250 I.Fun.NumExceptions = NumExceptions;
251 I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions];
252 for (unsigned i = 0; i != NumExceptions; ++i) {
253 I.Fun.Exceptions[i].Ty = Exceptions[i];
254 I.Fun.Exceptions[i].Range = ExceptionRanges[i];
255 }
256 }
257 break;
258
259 case EST_ComputedNoexcept:
260 I.Fun.NoexceptExpr = NoexceptExpr;
261 break;
262
263 case EST_Unparsed:
264 I.Fun.ExceptionSpecTokens = ExceptionSpecTokens;
265 break;
266 }
267 return I;
268}
269
270bool Declarator::isDeclarationOfFunction() const {
271 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) {
272 switch (DeclTypeInfo[i].Kind) {
273 case DeclaratorChunk::Function:
274 return true;
275 case DeclaratorChunk::Paren:
276 continue;
277 case DeclaratorChunk::Pointer:
278 case DeclaratorChunk::Reference:
279 case DeclaratorChunk::Array:
280 case DeclaratorChunk::BlockPointer:
281 case DeclaratorChunk::MemberPointer:
282 return false;
283 }
284 llvm_unreachable("Invalid type chunk");
285 }
286
287 switch (DS.getTypeSpecType()) {
288 case TST_atomic:
289 case TST_auto:
290 case TST_bool:
291 case TST_char:
292 case TST_char16:
293 case TST_char32:
294 case TST_class:
295 case TST_decimal128:
296 case TST_decimal32:
297 case TST_decimal64:
298 case TST_double:
299 case TST_enum:
300 case TST_error:
301 case TST_float:
302 case TST_half:
303 case TST_int:
304 case TST_int128:
305 case TST_struct:
306 case TST_interface:
307 case TST_union:
308 case TST_unknown_anytype:
309 case TST_unspecified:
310 case TST_void:
311 case TST_wchar:
312 return false;
313
314 case TST_decltype_auto:
315 // This must have an initializer, so can't be a function declaration,
316 // even if the initializer has function type.
317 return false;
318
319 case TST_decltype:
320 case TST_typeofExpr:
321 if (Expr *E = DS.getRepAsExpr())
322 return E->getType()->isFunctionType();
323 return false;
324
325 case TST_underlyingType:
326 case TST_typename:
327 case TST_typeofType: {
328 QualType QT = DS.getRepAsType().get();
329 if (QT.isNull())
330 return false;
331
332 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
333 QT = LIT->getType();
334
335 if (QT.isNull())
336 return false;
337
338 return QT->isFunctionType();
339 }
340 }
341
342 llvm_unreachable("Invalid TypeSpecType!");
343}
344
345bool Declarator::isStaticMember() {
346 assert(getContext() == MemberContext);
347 return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
|
350}
351
352bool DeclSpec::hasTagDefinition() const {
353 if (!TypeSpecOwned)
354 return false;
355 return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition();
356}
357
358/// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
359/// declaration specifier includes.
360///
361unsigned DeclSpec::getParsedSpecifiers() const {
362 unsigned Res = 0;
363 if (StorageClassSpec != SCS_unspecified ||
364 ThreadStorageClassSpec != TSCS_unspecified)
365 Res |= PQ_StorageClassSpecifier;
366
367 if (TypeQualifiers != TQ_unspecified)
368 Res |= PQ_TypeQualifier;
369
370 if (hasTypeSpecifier())
371 Res |= PQ_TypeSpecifier;
372
373 if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified ||
374 FS_noreturn_specified || FS_forceinline_specified)
375 Res |= PQ_FunctionSpecifier;
376 return Res;
377}
378
379template <class T> static bool BadSpecifier(T TNew, T TPrev,
380 const char *&PrevSpec,
381 unsigned &DiagID,
382 bool IsExtension = true) {
383 PrevSpec = DeclSpec::getSpecifierName(TPrev);
384 if (TNew != TPrev)
385 DiagID = diag::err_invalid_decl_spec_combination;
386 else
387 DiagID = IsExtension ? diag::ext_duplicate_declspec :
388 diag::warn_duplicate_declspec;
389 return true;
390}
391
392const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) {
393 switch (S) {
394 case DeclSpec::SCS_unspecified: return "unspecified";
395 case DeclSpec::SCS_typedef: return "typedef";
396 case DeclSpec::SCS_extern: return "extern";
397 case DeclSpec::SCS_static: return "static";
398 case DeclSpec::SCS_auto: return "auto";
399 case DeclSpec::SCS_register: return "register";
400 case DeclSpec::SCS_private_extern: return "__private_extern__";
401 case DeclSpec::SCS_mutable: return "mutable";
402 }
403 llvm_unreachable("Unknown typespec!");
404}
405
406const char *DeclSpec::getSpecifierName(DeclSpec::TSCS S) {
407 switch (S) {
408 case DeclSpec::TSCS_unspecified: return "unspecified";
409 case DeclSpec::TSCS___thread: return "__thread";
410 case DeclSpec::TSCS_thread_local: return "thread_local";
411 case DeclSpec::TSCS__Thread_local: return "_Thread_local";
412 }
413 llvm_unreachable("Unknown typespec!");
414}
415
416const char *DeclSpec::getSpecifierName(TSW W) {
417 switch (W) {
418 case TSW_unspecified: return "unspecified";
419 case TSW_short: return "short";
420 case TSW_long: return "long";
421 case TSW_longlong: return "long long";
422 }
423 llvm_unreachable("Unknown typespec!");
424}
425
426const char *DeclSpec::getSpecifierName(TSC C) {
427 switch (C) {
428 case TSC_unspecified: return "unspecified";
429 case TSC_imaginary: return "imaginary";
430 case TSC_complex: return "complex";
431 }
432 llvm_unreachable("Unknown typespec!");
433}
434
435
436const char *DeclSpec::getSpecifierName(TSS S) {
437 switch (S) {
438 case TSS_unspecified: return "unspecified";
439 case TSS_signed: return "signed";
440 case TSS_unsigned: return "unsigned";
441 }
442 llvm_unreachable("Unknown typespec!");
443}
444
445const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
446 const PrintingPolicy &Policy) {
447 switch (T) {
448 case DeclSpec::TST_unspecified: return "unspecified";
449 case DeclSpec::TST_void: return "void";
450 case DeclSpec::TST_char: return "char";
451 case DeclSpec::TST_wchar: return Policy.MSWChar ? "__wchar_t" : "wchar_t";
452 case DeclSpec::TST_char16: return "char16_t";
453 case DeclSpec::TST_char32: return "char32_t";
454 case DeclSpec::TST_int: return "int";
455 case DeclSpec::TST_int128: return "__int128";
456 case DeclSpec::TST_half: return "half";
457 case DeclSpec::TST_float: return "float";
458 case DeclSpec::TST_double: return "double";
459 case DeclSpec::TST_bool: return Policy.Bool ? "bool" : "_Bool";
460 case DeclSpec::TST_decimal32: return "_Decimal32";
461 case DeclSpec::TST_decimal64: return "_Decimal64";
462 case DeclSpec::TST_decimal128: return "_Decimal128";
463 case DeclSpec::TST_enum: return "enum";
464 case DeclSpec::TST_class: return "class";
465 case DeclSpec::TST_union: return "union";
466 case DeclSpec::TST_struct: return "struct";
467 case DeclSpec::TST_interface: return "__interface";
468 case DeclSpec::TST_typename: return "type-name";
469 case DeclSpec::TST_typeofType:
470 case DeclSpec::TST_typeofExpr: return "typeof";
471 case DeclSpec::TST_auto: return "auto";
472 case DeclSpec::TST_decltype: return "(decltype)";
473 case DeclSpec::TST_decltype_auto: return "decltype(auto)";
474 case DeclSpec::TST_underlyingType: return "__underlying_type";
475 case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
476 case DeclSpec::TST_atomic: return "_Atomic";
477 case DeclSpec::TST_error: return "(error)";
478 }
479 llvm_unreachable("Unknown typespec!");
480}
481
482const char *DeclSpec::getSpecifierName(TQ T) {
483 switch (T) {
484 case DeclSpec::TQ_unspecified: return "unspecified";
485 case DeclSpec::TQ_const: return "const";
486 case DeclSpec::TQ_restrict: return "restrict";
487 case DeclSpec::TQ_volatile: return "volatile";
488 case DeclSpec::TQ_atomic: return "_Atomic";
489 }
490 llvm_unreachable("Unknown typespec!");
491}
492
493bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
494 const char *&PrevSpec,
495 unsigned &DiagID,
496 const PrintingPolicy &Policy) {
497 // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
498 // specifiers are not supported.
499 // It seems sensible to prohibit private_extern too
500 // The cl_clang_storage_class_specifiers extension enables support for
501 // these storage-class specifiers.
502 // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
503 // specifiers are not supported."
504 if (S.getLangOpts().OpenCL &&
505 !S.getOpenCLOptions().cl_clang_storage_class_specifiers) {
506 switch (SC) {
507 case SCS_extern:
508 case SCS_private_extern:
509 case SCS_static:
510 if (S.getLangOpts().OpenCLVersion < 120) {
511 DiagID = diag::err_opencl_unknown_type_specifier;
512 PrevSpec = getSpecifierName(SC);
513 return true;
514 }
515 break;
516 case SCS_auto:
517 case SCS_register:
518 DiagID = diag::err_opencl_unknown_type_specifier;
519 PrevSpec = getSpecifierName(SC);
520 return true;
521 default:
522 break;
523 }
524 }
525
526 if (StorageClassSpec != SCS_unspecified) {
527 // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
528 bool isInvalid = true;
529 if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
530 if (SC == SCS_auto)
531 return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
532 if (StorageClassSpec == SCS_auto) {
533 isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
534 PrevSpec, DiagID, Policy);
535 assert(!isInvalid && "auto SCS -> TST recovery failed");
536 }
537 }
538
539 // Changing storage class is allowed only if the previous one
540 // was the 'extern' that is part of a linkage specification and
541 // the new storage class is 'typedef'.
542 if (isInvalid &&
543 !(SCS_extern_in_linkage_spec &&
544 StorageClassSpec == SCS_extern &&
545 SC == SCS_typedef))
546 return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
547 }
548 StorageClassSpec = SC;
549 StorageClassSpecLoc = Loc;
550 assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
551 return false;
552}
553
554bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
555 const char *&PrevSpec,
556 unsigned &DiagID) {
557 if (ThreadStorageClassSpec != TSCS_unspecified)
558 return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
559
560 ThreadStorageClassSpec = TSC;
561 ThreadStorageClassSpecLoc = Loc;
562 return false;
563}
564
565/// These methods set the specified attribute of the DeclSpec, but return true
566/// and ignore the request if invalid (e.g. "extern" then "auto" is
567/// specified).
568bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
569 const char *&PrevSpec,
570 unsigned &DiagID,
571 const PrintingPolicy &Policy) {
572 // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that
573 // for 'long long' we will keep the source location of the first 'long'.
574 if (TypeSpecWidth == TSW_unspecified)
575 TSWLoc = Loc;
576 // Allow turning long -> long long.
577 else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
578 return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
579 TypeSpecWidth = W;
580 return false;
581}
582
583bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
584 const char *&PrevSpec,
585 unsigned &DiagID) {
586 if (TypeSpecComplex != TSC_unspecified)
587 return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
588 TypeSpecComplex = C;
589 TSCLoc = Loc;
590 return false;
591}
592
593bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
594 const char *&PrevSpec,
595 unsigned &DiagID) {
596 if (TypeSpecSign != TSS_unspecified)
597 return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
598 TypeSpecSign = S;
599 TSSLoc = Loc;
600 return false;
601}
602
603bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
604 const char *&PrevSpec,
605 unsigned &DiagID,
606 ParsedType Rep,
607 const PrintingPolicy &Policy) {
608 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
609}
610
611bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
612 SourceLocation TagNameLoc,
613 const char *&PrevSpec,
614 unsigned &DiagID,
615 ParsedType Rep,
616 const PrintingPolicy &Policy) {
617 assert(isTypeRep(T) && "T does not store a type");
618 assert(Rep && "no type provided!");
619 if (TypeSpecType != TST_unspecified) {
620 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
621 DiagID = diag::err_invalid_decl_spec_combination;
622 return true;
623 }
624 TypeSpecType = T;
625 TypeRep = Rep;
626 TSTLoc = TagKwLoc;
627 TSTNameLoc = TagNameLoc;
628 TypeSpecOwned = false;
629 return false;
630}
631
632bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
633 const char *&PrevSpec,
634 unsigned &DiagID,
635 Expr *Rep,
636 const PrintingPolicy &Policy) {
637 assert(isExprRep(T) && "T does not store an expr");
638 assert(Rep && "no expression provided!");
639 if (TypeSpecType != TST_unspecified) {
640 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
641 DiagID = diag::err_invalid_decl_spec_combination;
642 return true;
643 }
644 TypeSpecType = T;
645 ExprRep = Rep;
646 TSTLoc = Loc;
647 TSTNameLoc = Loc;
648 TypeSpecOwned = false;
649 return false;
650}
651
652bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
653 const char *&PrevSpec,
654 unsigned &DiagID,
655 Decl *Rep, bool Owned,
656 const PrintingPolicy &Policy) {
657 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
658}
659
660bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
661 SourceLocation TagNameLoc,
662 const char *&PrevSpec,
663 unsigned &DiagID,
664 Decl *Rep, bool Owned,
665 const PrintingPolicy &Policy) {
666 assert(isDeclRep(T) && "T does not store a decl");
667 // Unlike the other cases, we don't assert that we actually get a decl.
668
669 if (TypeSpecType != TST_unspecified) {
670 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
671 DiagID = diag::err_invalid_decl_spec_combination;
672 return true;
673 }
674 TypeSpecType = T;
675 DeclRep = Rep;
676 TSTLoc = TagKwLoc;
677 TSTNameLoc = TagNameLoc;
678 TypeSpecOwned = Owned && Rep != nullptr;
679 return false;
680}
681
682bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
683 const char *&PrevSpec,
684 unsigned &DiagID,
685 const PrintingPolicy &Policy) {
686 assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
687 "rep required for these type-spec kinds!");
688 if (TypeSpecType != TST_unspecified) {
689 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
690 DiagID = diag::err_invalid_decl_spec_combination;
691 return true;
692 }
693 TSTLoc = Loc;
694 TSTNameLoc = Loc;
695 if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
696 TypeAltiVecBool = true;
697 return false;
698 }
699 TypeSpecType = T;
700 TypeSpecOwned = false;
701 return false;
702}
703
704bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
705 const char *&PrevSpec, unsigned &DiagID,
706 const PrintingPolicy &Policy) {
707 if (TypeSpecType != TST_unspecified) {
708 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
709 DiagID = diag::err_invalid_vector_decl_spec_combination;
710 return true;
711 }
712 TypeAltiVecVector = isAltiVecVector;
713 AltiVecLoc = Loc;
714 return false;
715}
716
717bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
718 const char *&PrevSpec, unsigned &DiagID,
719 const PrintingPolicy &Policy) {
720 if (!TypeAltiVecVector || TypeAltiVecPixel ||
721 (TypeSpecType != TST_unspecified)) {
722 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
723 DiagID = diag::err_invalid_pixel_decl_spec_combination;
724 return true;
725 }
726 TypeAltiVecPixel = isAltiVecPixel;
727 TSTLoc = Loc;
728 TSTNameLoc = Loc;
729 return false;
730}
731
732bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
733 const char *&PrevSpec, unsigned &DiagID,
734 const PrintingPolicy &Policy) {
735 if (!TypeAltiVecVector || TypeAltiVecBool ||
736 (TypeSpecType != TST_unspecified)) {
737 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
738 DiagID = diag::err_invalid_vector_bool_decl_spec;
739 return true;
740 }
741 TypeAltiVecBool = isAltiVecBool;
742 TSTLoc = Loc;
743 TSTNameLoc = Loc;
744 return false;
745}
746
747bool DeclSpec::SetTypeSpecError() {
748 TypeSpecType = TST_error;
749 TypeSpecOwned = false;
750 TSTLoc = SourceLocation();
751 TSTNameLoc = SourceLocation();
752 return false;
753}
754
755bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
756 unsigned &DiagID, const LangOptions &Lang) {
757 // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
758 // C++. However, since this is likely not what the user intended, we will
759 // always warn. We do not need to set the qualifier's location since we
760 // already have it.
761 if (TypeQualifiers & T) {
762 bool IsExtension = true;
763 if (Lang.C99)
764 IsExtension = false;
765 return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
766 }
767 TypeQualifiers |= T;
768
769 switch (T) {
770 case TQ_unspecified: break;
771 case TQ_const: TQ_constLoc = Loc; return false;
772 case TQ_restrict: TQ_restrictLoc = Loc; return false;
773 case TQ_volatile: TQ_volatileLoc = Loc; return false;
774 case TQ_atomic: TQ_atomicLoc = Loc; return false;
775 }
776
777 llvm_unreachable("Unknown type qualifier!");
778}
779
780bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
781 unsigned &DiagID) {
782 // 'inline inline' is ok. However, since this is likely not what the user
783 // intended, we will always warn, similar to duplicates of type qualifiers.
784 if (FS_inline_specified) {
785 DiagID = diag::warn_duplicate_declspec;
786 PrevSpec = "inline";
787 return true;
788 }
789 FS_inline_specified = true;
790 FS_inlineLoc = Loc;
791 return false;
792}
793
794bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
795 unsigned &DiagID) {
796 if (FS_forceinline_specified) {
797 DiagID = diag::warn_duplicate_declspec;
798 PrevSpec = "__forceinline";
799 return true;
800 }
801 FS_forceinline_specified = true;
802 FS_forceinlineLoc = Loc;
803 return false;
804}
805
806bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
807 const char *&PrevSpec,
808 unsigned &DiagID) {
809 // 'virtual virtual' is ok, but warn as this is likely not what the user
810 // intended.
811 if (FS_virtual_specified) {
812 DiagID = diag::warn_duplicate_declspec;
813 PrevSpec = "virtual";
814 return true;
815 }
816 FS_virtual_specified = true;
817 FS_virtualLoc = Loc;
818 return false;
819}
820
821bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
822 const char *&PrevSpec,
823 unsigned &DiagID) {
824 // 'explicit explicit' is ok, but warn as this is likely not what the user
825 // intended.
826 if (FS_explicit_specified) {
827 DiagID = diag::warn_duplicate_declspec;
828 PrevSpec = "explicit";
829 return true;
830 }
831 FS_explicit_specified = true;
832 FS_explicitLoc = Loc;
833 return false;
834}
835
836bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
837 const char *&PrevSpec,
838 unsigned &DiagID) {
839 // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
840 // intended.
841 if (FS_noreturn_specified) {
842 DiagID = diag::warn_duplicate_declspec;
843 PrevSpec = "_Noreturn";
844 return true;
845 }
846 FS_noreturn_specified = true;
847 FS_noreturnLoc = Loc;
848 return false;
849}
850
851bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
852 unsigned &DiagID) {
853 if (Friend_specified) {
854 PrevSpec = "friend";
855 // Keep the later location, so that we can later diagnose ill-formed
856 // declarations like 'friend class X friend;'. Per [class.friend]p3,
857 // 'friend' must be the first token in a friend declaration that is
858 // not a function declaration.
859 FriendLoc = Loc;
860 DiagID = diag::warn_duplicate_declspec;
861 return true;
862 }
863
864 Friend_specified = true;
865 FriendLoc = Loc;
866 return false;
867}
868
869bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
870 unsigned &DiagID) {
871 if (isModulePrivateSpecified()) {
872 PrevSpec = "__module_private__";
873 DiagID = diag::ext_duplicate_declspec;
874 return true;
875 }
876
877 ModulePrivateLoc = Loc;
878 return false;
879}
880
881bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
882 unsigned &DiagID) {
883 // 'constexpr constexpr' is ok, but warn as this is likely not what the user
884 // intended.
885 if (Constexpr_specified) {
886 DiagID = diag::warn_duplicate_declspec;
887 PrevSpec = "constexpr";
888 return true;
889 }
890 Constexpr_specified = true;
891 ConstexprLoc = Loc;
892 return false;
893}
894
895void DeclSpec::setProtocolQualifiers(Decl * const *Protos,
896 unsigned NP,
897 SourceLocation *ProtoLocs,
898 SourceLocation LAngleLoc) {
899 if (NP == 0) return;
900 Decl **ProtoQuals = new Decl*[NP];
901 memcpy(ProtoQuals, Protos, sizeof(Decl*)*NP);
902 ProtocolQualifiers = ProtoQuals;
903 ProtocolLocs = new SourceLocation[NP];
904 memcpy(ProtocolLocs, ProtoLocs, sizeof(SourceLocation)*NP);
905 NumProtocolQualifiers = NP;
906 ProtocolLAngleLoc = LAngleLoc;
907}
908
909void DeclSpec::SaveWrittenBuiltinSpecs() {
910 writtenBS.Sign = getTypeSpecSign();
911 writtenBS.Width = getTypeSpecWidth();
912 writtenBS.Type = getTypeSpecType();
913 // Search the list of attributes for the presence of a mode attribute.
914 writtenBS.ModeAttr = false;
915 AttributeList* attrs = getAttributes().getList();
916 while (attrs) {
917 if (attrs->getKind() == AttributeList::AT_Mode) {
918 writtenBS.ModeAttr = true;
919 break;
920 }
921 attrs = attrs->getNext();
922 }
923}
924
925/// Finish - This does final analysis of the declspec, rejecting things like
926/// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
927/// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
928/// DeclSpec is guaranteed self-consistent, even if an error occurred.
929void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP, const PrintingPolicy &Policy) {
930 // Before possibly changing their values, save specs as written.
931 SaveWrittenBuiltinSpecs();
932
933 // Check the type specifier components first.
934
935 // If decltype(auto) is used, no other type specifiers are permitted.
936 if (TypeSpecType == TST_decltype_auto &&
937 (TypeSpecWidth != TSW_unspecified ||
938 TypeSpecComplex != TSC_unspecified ||
939 TypeSpecSign != TSS_unspecified ||
940 TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
941 TypeQualifiers)) {
942 const unsigned NumLocs = 8;
943 SourceLocation ExtraLocs[NumLocs] = {
944 TSWLoc, TSCLoc, TSSLoc, AltiVecLoc,
945 TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc
946 };
947 FixItHint Hints[NumLocs];
948 SourceLocation FirstLoc;
949 for (unsigned I = 0; I != NumLocs; ++I) {
950 if (!ExtraLocs[I].isInvalid()) {
951 if (FirstLoc.isInvalid() ||
952 PP.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
953 FirstLoc))
954 FirstLoc = ExtraLocs[I];
955 Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
956 }
957 }
958 TypeSpecWidth = TSW_unspecified;
959 TypeSpecComplex = TSC_unspecified;
960 TypeSpecSign = TSS_unspecified;
961 TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
962 TypeQualifiers = 0;
963 Diag(D, TSTLoc, diag::err_decltype_auto_cannot_be_combined)
964 << Hints[0] << Hints[1] << Hints[2] << Hints[3]
965 << Hints[4] << Hints[5] << Hints[6] << Hints[7];
966 }
967
968 // Validate and finalize AltiVec vector declspec.
969 if (TypeAltiVecVector) {
970 if (TypeAltiVecBool) {
971 // Sign specifiers are not allowed with vector bool. (PIM 2.1)
972 if (TypeSpecSign != TSS_unspecified) {
973 Diag(D, TSSLoc, diag::err_invalid_vector_bool_decl_spec)
974 << getSpecifierName((TSS)TypeSpecSign);
975 }
976
977 // Only char/int are valid with vector bool. (PIM 2.1)
978 if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
979 (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
980 Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec)
981 << (TypeAltiVecPixel ? "__pixel" :
982 getSpecifierName((TST)TypeSpecType, Policy));
983 }
984
985 // Only 'short' is valid with vector bool. (PIM 2.1)
986 if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short))
987 Diag(D, TSWLoc, diag::err_invalid_vector_bool_decl_spec)
988 << getSpecifierName((TSW)TypeSpecWidth);
989
990 // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
991 if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
992 (TypeSpecWidth != TSW_unspecified))
993 TypeSpecSign = TSS_unsigned;
994 } else if (TypeSpecType == TST_double) {
995 // vector long double and vector long long double are never allowed.
996 // vector double is OK for Power7 and later.
997 if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
998 Diag(D, TSWLoc, diag::err_invalid_vector_long_double_decl_spec);
999 else if (!PP.getTargetInfo().hasFeature("vsx"))
1000 Diag(D, TSTLoc, diag::err_invalid_vector_double_decl_spec);
1001 } else if (TypeSpecWidth == TSW_long) {
1002 Diag(D, TSWLoc, diag::warn_vector_long_decl_spec_combination)
1003 << getSpecifierName((TST)TypeSpecType, Policy);
1004 }
1005
1006 if (TypeAltiVecPixel) {
1007 //TODO: perform validation
1008 TypeSpecType = TST_int;
1009 TypeSpecSign = TSS_unsigned;
1010 TypeSpecWidth = TSW_short;
1011 TypeSpecOwned = false;
1012 }
1013 }
1014
1015 // signed/unsigned are only valid with int/char/wchar_t.
1016 if (TypeSpecSign != TSS_unspecified) {
1017 if (TypeSpecType == TST_unspecified)
1018 TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1019 else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
1020 TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
1021 Diag(D, TSSLoc, diag::err_invalid_sign_spec)
1022 << getSpecifierName((TST)TypeSpecType, Policy);
1023 // signed double -> double.
1024 TypeSpecSign = TSS_unspecified;
1025 }
1026 }
1027
1028 // Validate the width of the type.
1029 switch (TypeSpecWidth) {
1030 case TSW_unspecified: break;
1031 case TSW_short: // short int
1032 case TSW_longlong: // long long int
1033 if (TypeSpecType == TST_unspecified)
1034 TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1035 else if (TypeSpecType != TST_int) {
1036 Diag(D, TSWLoc,
1037 TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec
1038 : diag::err_invalid_longlong_spec)
1039 << getSpecifierName((TST)TypeSpecType, Policy);
1040 TypeSpecType = TST_int;
1041 TypeSpecOwned = false;
1042 }
1043 break;
1044 case TSW_long: // long double, long int
1045 if (TypeSpecType == TST_unspecified)
1046 TypeSpecType = TST_int; // long -> long int.
1047 else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
1048 Diag(D, TSWLoc, diag::err_invalid_long_spec)
1049 << getSpecifierName((TST)TypeSpecType, Policy);
1050 TypeSpecType = TST_int;
1051 TypeSpecOwned = false;
1052 }
1053 break;
1054 }
1055
1056 // TODO: if the implementation does not implement _Complex or _Imaginary,
1057 // disallow their use. Need information about the backend.
1058 if (TypeSpecComplex != TSC_unspecified) {
1059 if (TypeSpecType == TST_unspecified) {
1060 Diag(D, TSCLoc, diag::ext_plain_complex)
1061 << FixItHint::CreateInsertion(
1062 PP.getLocForEndOfToken(getTypeSpecComplexLoc()),
1063 " double");
1064 TypeSpecType = TST_double; // _Complex -> _Complex double.
1065 } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1066 // Note that this intentionally doesn't include _Complex _Bool.
1067 if (!PP.getLangOpts().CPlusPlus)
1068 Diag(D, TSTLoc, diag::ext_integer_complex);
1069 } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1070 Diag(D, TSCLoc, diag::err_invalid_complex_spec)
1071 << getSpecifierName((TST)TypeSpecType, Policy);
1072 TypeSpecComplex = TSC_unspecified;
1073 }
1074 }
1075
1076 // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1077 // _Thread_local can only appear with the 'static' and 'extern' storage class
1078 // specifiers. We also allow __private_extern__ as an extension.
1079 if (ThreadStorageClassSpec != TSCS_unspecified) {
1080 switch (StorageClassSpec) {
1081 case SCS_unspecified:
1082 case SCS_extern:
1083 case SCS_private_extern:
1084 case SCS_static:
1085 break;
1086 default:
1087 if (PP.getSourceManager().isBeforeInTranslationUnit(
1088 getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1089 Diag(D, getStorageClassSpecLoc(),
1090 diag::err_invalid_decl_spec_combination)
1091 << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1092 << SourceRange(getThreadStorageClassSpecLoc());
1093 else
1094 Diag(D, getThreadStorageClassSpecLoc(),
1095 diag::err_invalid_decl_spec_combination)
1096 << DeclSpec::getSpecifierName(getStorageClassSpec())
1097 << SourceRange(getStorageClassSpecLoc());
1098 // Discard the thread storage class specifier to recover.
1099 ThreadStorageClassSpec = TSCS_unspecified;
1100 ThreadStorageClassSpecLoc = SourceLocation();
1101 }
1102 }
1103
1104 // If no type specifier was provided and we're parsing a language where
1105 // the type specifier is not optional, but we got 'auto' as a storage
1106 // class specifier, then assume this is an attempt to use C++0x's 'auto'
1107 // type specifier.
1108 if (PP.getLangOpts().CPlusPlus &&
1109 TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1110 TypeSpecType = TST_auto;
1111 StorageClassSpec = SCS_unspecified;
1112 TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1113 StorageClassSpecLoc = SourceLocation();
1114 }
1115 // Diagnose if we've recovered from an ill-formed 'auto' storage class
1116 // specifier in a pre-C++11 dialect of C++.
1117 if (!PP.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1118 Diag(D, TSTLoc, diag::ext_auto_type_specifier);
1119 if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().CPlusPlus11 &&
1120 StorageClassSpec == SCS_auto)
1121 Diag(D, StorageClassSpecLoc, diag::warn_auto_storage_class)
1122 << FixItHint::CreateRemoval(StorageClassSpecLoc);
1123 if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1124 Diag(D, TSTLoc, diag::warn_cxx98_compat_unicode_type)
1125 << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1126 if (Constexpr_specified)
1127 Diag(D, ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1128
1129 // C++ [class.friend]p6:
1130 // No storage-class-specifier shall appear in the decl-specifier-seq
1131 // of a friend declaration.
1132 if (isFriendSpecified() &&
1133 (getStorageClassSpec() || getThreadStorageClassSpec())) {
1134 SmallString<32> SpecName;
1135 SourceLocation SCLoc;
1136 FixItHint StorageHint, ThreadHint;
1137
1138 if (DeclSpec::SCS SC = getStorageClassSpec()) {
1139 SpecName = getSpecifierName(SC);
1140 SCLoc = getStorageClassSpecLoc();
1141 StorageHint = FixItHint::CreateRemoval(SCLoc);
1142 }
1143
1144 if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1145 if (!SpecName.empty()) SpecName += " ";
1146 SpecName += getSpecifierName(TSC);
1147 SCLoc = getThreadStorageClassSpecLoc();
1148 ThreadHint = FixItHint::CreateRemoval(SCLoc);
1149 }
1150
1151 Diag(D, SCLoc, diag::err_friend_decl_spec)
1152 << SpecName << StorageHint << ThreadHint;
1153
1154 ClearStorageClassSpecs();
1155 }
1156
1157 // C++11 [dcl.fct.spec]p5:
1158 // The virtual specifier shall be used only in the initial
1159 // declaration of a non-static class member function;
1160 // C++11 [dcl.fct.spec]p6:
1161 // The explicit specifier shall be used only in the declaration of
1162 // a constructor or conversion function within its class
1163 // definition;
1164 if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) {
1165 StringRef Keyword;
1166 SourceLocation SCLoc;
1167
1168 if (isVirtualSpecified()) {
1169 Keyword = "virtual";
1170 SCLoc = getVirtualSpecLoc();
1171 } else {
1172 Keyword = "explicit";
1173 SCLoc = getExplicitSpecLoc();
1174 }
1175
1176 FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
1177 Diag(D, SCLoc, diag::err_friend_decl_spec)
1178 << Keyword << Hint;
1179
1180 FS_virtual_specified = FS_explicit_specified = false;
1181 FS_virtualLoc = FS_explicitLoc = SourceLocation();
1182 }
1183
1184 assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1185
1186 // Okay, now we can infer the real type.
1187
1188 // TODO: return "auto function" and other bad things based on the real type.
1189
1190 // 'data definition has no type or storage class'?
1191}
1192
1193bool DeclSpec::isMissingDeclaratorOk() {
1194 TST tst = getTypeSpecType();
1195 return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1196 StorageClassSpec != DeclSpec::SCS_typedef;
1197}
1198
1199void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1200 OverloadedOperatorKind Op,
1201 SourceLocation SymbolLocations[3]) {
1202 Kind = IK_OperatorFunctionId;
1203 StartLocation = OperatorLoc;
1204 EndLocation = OperatorLoc;
1205 OperatorFunctionId.Operator = Op;
1206 for (unsigned I = 0; I != 3; ++I) {
1207 OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1208
1209 if (SymbolLocations[I].isValid())
1210 EndLocation = SymbolLocations[I];
1211 }
1212}
1213
1214bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1215 const char *&PrevSpec) {
1216 LastLocation = Loc;
1217
1218 if (Specifiers & VS) {
1219 PrevSpec = getSpecifierName(VS);
1220 return true;
1221 }
1222
1223 Specifiers |= VS;
1224
1225 switch (VS) {
1226 default: llvm_unreachable("Unknown specifier!");
1227 case VS_Override: VS_overrideLoc = Loc; break;
1228 case VS_Sealed:
1229 case VS_Final: VS_finalLoc = Loc; break;
1230 }
1231
1232 return false;
1233}
1234
1235const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1236 switch (VS) {
1237 default: llvm_unreachable("Unknown specifier");
1238 case VS_Override: return "override";
1239 case VS_Final: return "final";
1240 case VS_Sealed: return "sealed";
1241 }
1242}
| 351}
352
353bool DeclSpec::hasTagDefinition() const {
354 if (!TypeSpecOwned)
355 return false;
356 return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition();
357}
358
359/// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this
360/// declaration specifier includes.
361///
362unsigned DeclSpec::getParsedSpecifiers() const {
363 unsigned Res = 0;
364 if (StorageClassSpec != SCS_unspecified ||
365 ThreadStorageClassSpec != TSCS_unspecified)
366 Res |= PQ_StorageClassSpecifier;
367
368 if (TypeQualifiers != TQ_unspecified)
369 Res |= PQ_TypeQualifier;
370
371 if (hasTypeSpecifier())
372 Res |= PQ_TypeSpecifier;
373
374 if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified ||
375 FS_noreturn_specified || FS_forceinline_specified)
376 Res |= PQ_FunctionSpecifier;
377 return Res;
378}
379
380template <class T> static bool BadSpecifier(T TNew, T TPrev,
381 const char *&PrevSpec,
382 unsigned &DiagID,
383 bool IsExtension = true) {
384 PrevSpec = DeclSpec::getSpecifierName(TPrev);
385 if (TNew != TPrev)
386 DiagID = diag::err_invalid_decl_spec_combination;
387 else
388 DiagID = IsExtension ? diag::ext_duplicate_declspec :
389 diag::warn_duplicate_declspec;
390 return true;
391}
392
393const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) {
394 switch (S) {
395 case DeclSpec::SCS_unspecified: return "unspecified";
396 case DeclSpec::SCS_typedef: return "typedef";
397 case DeclSpec::SCS_extern: return "extern";
398 case DeclSpec::SCS_static: return "static";
399 case DeclSpec::SCS_auto: return "auto";
400 case DeclSpec::SCS_register: return "register";
401 case DeclSpec::SCS_private_extern: return "__private_extern__";
402 case DeclSpec::SCS_mutable: return "mutable";
403 }
404 llvm_unreachable("Unknown typespec!");
405}
406
407const char *DeclSpec::getSpecifierName(DeclSpec::TSCS S) {
408 switch (S) {
409 case DeclSpec::TSCS_unspecified: return "unspecified";
410 case DeclSpec::TSCS___thread: return "__thread";
411 case DeclSpec::TSCS_thread_local: return "thread_local";
412 case DeclSpec::TSCS__Thread_local: return "_Thread_local";
413 }
414 llvm_unreachable("Unknown typespec!");
415}
416
417const char *DeclSpec::getSpecifierName(TSW W) {
418 switch (W) {
419 case TSW_unspecified: return "unspecified";
420 case TSW_short: return "short";
421 case TSW_long: return "long";
422 case TSW_longlong: return "long long";
423 }
424 llvm_unreachable("Unknown typespec!");
425}
426
427const char *DeclSpec::getSpecifierName(TSC C) {
428 switch (C) {
429 case TSC_unspecified: return "unspecified";
430 case TSC_imaginary: return "imaginary";
431 case TSC_complex: return "complex";
432 }
433 llvm_unreachable("Unknown typespec!");
434}
435
436
437const char *DeclSpec::getSpecifierName(TSS S) {
438 switch (S) {
439 case TSS_unspecified: return "unspecified";
440 case TSS_signed: return "signed";
441 case TSS_unsigned: return "unsigned";
442 }
443 llvm_unreachable("Unknown typespec!");
444}
445
446const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
447 const PrintingPolicy &Policy) {
448 switch (T) {
449 case DeclSpec::TST_unspecified: return "unspecified";
450 case DeclSpec::TST_void: return "void";
451 case DeclSpec::TST_char: return "char";
452 case DeclSpec::TST_wchar: return Policy.MSWChar ? "__wchar_t" : "wchar_t";
453 case DeclSpec::TST_char16: return "char16_t";
454 case DeclSpec::TST_char32: return "char32_t";
455 case DeclSpec::TST_int: return "int";
456 case DeclSpec::TST_int128: return "__int128";
457 case DeclSpec::TST_half: return "half";
458 case DeclSpec::TST_float: return "float";
459 case DeclSpec::TST_double: return "double";
460 case DeclSpec::TST_bool: return Policy.Bool ? "bool" : "_Bool";
461 case DeclSpec::TST_decimal32: return "_Decimal32";
462 case DeclSpec::TST_decimal64: return "_Decimal64";
463 case DeclSpec::TST_decimal128: return "_Decimal128";
464 case DeclSpec::TST_enum: return "enum";
465 case DeclSpec::TST_class: return "class";
466 case DeclSpec::TST_union: return "union";
467 case DeclSpec::TST_struct: return "struct";
468 case DeclSpec::TST_interface: return "__interface";
469 case DeclSpec::TST_typename: return "type-name";
470 case DeclSpec::TST_typeofType:
471 case DeclSpec::TST_typeofExpr: return "typeof";
472 case DeclSpec::TST_auto: return "auto";
473 case DeclSpec::TST_decltype: return "(decltype)";
474 case DeclSpec::TST_decltype_auto: return "decltype(auto)";
475 case DeclSpec::TST_underlyingType: return "__underlying_type";
476 case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
477 case DeclSpec::TST_atomic: return "_Atomic";
478 case DeclSpec::TST_error: return "(error)";
479 }
480 llvm_unreachable("Unknown typespec!");
481}
482
483const char *DeclSpec::getSpecifierName(TQ T) {
484 switch (T) {
485 case DeclSpec::TQ_unspecified: return "unspecified";
486 case DeclSpec::TQ_const: return "const";
487 case DeclSpec::TQ_restrict: return "restrict";
488 case DeclSpec::TQ_volatile: return "volatile";
489 case DeclSpec::TQ_atomic: return "_Atomic";
490 }
491 llvm_unreachable("Unknown typespec!");
492}
493
494bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
495 const char *&PrevSpec,
496 unsigned &DiagID,
497 const PrintingPolicy &Policy) {
498 // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
499 // specifiers are not supported.
500 // It seems sensible to prohibit private_extern too
501 // The cl_clang_storage_class_specifiers extension enables support for
502 // these storage-class specifiers.
503 // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class
504 // specifiers are not supported."
505 if (S.getLangOpts().OpenCL &&
506 !S.getOpenCLOptions().cl_clang_storage_class_specifiers) {
507 switch (SC) {
508 case SCS_extern:
509 case SCS_private_extern:
510 case SCS_static:
511 if (S.getLangOpts().OpenCLVersion < 120) {
512 DiagID = diag::err_opencl_unknown_type_specifier;
513 PrevSpec = getSpecifierName(SC);
514 return true;
515 }
516 break;
517 case SCS_auto:
518 case SCS_register:
519 DiagID = diag::err_opencl_unknown_type_specifier;
520 PrevSpec = getSpecifierName(SC);
521 return true;
522 default:
523 break;
524 }
525 }
526
527 if (StorageClassSpec != SCS_unspecified) {
528 // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode.
529 bool isInvalid = true;
530 if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
531 if (SC == SCS_auto)
532 return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
533 if (StorageClassSpec == SCS_auto) {
534 isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
535 PrevSpec, DiagID, Policy);
536 assert(!isInvalid && "auto SCS -> TST recovery failed");
537 }
538 }
539
540 // Changing storage class is allowed only if the previous one
541 // was the 'extern' that is part of a linkage specification and
542 // the new storage class is 'typedef'.
543 if (isInvalid &&
544 !(SCS_extern_in_linkage_spec &&
545 StorageClassSpec == SCS_extern &&
546 SC == SCS_typedef))
547 return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID);
548 }
549 StorageClassSpec = SC;
550 StorageClassSpecLoc = Loc;
551 assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield");
552 return false;
553}
554
555bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
556 const char *&PrevSpec,
557 unsigned &DiagID) {
558 if (ThreadStorageClassSpec != TSCS_unspecified)
559 return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID);
560
561 ThreadStorageClassSpec = TSC;
562 ThreadStorageClassSpecLoc = Loc;
563 return false;
564}
565
566/// These methods set the specified attribute of the DeclSpec, but return true
567/// and ignore the request if invalid (e.g. "extern" then "auto" is
568/// specified).
569bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
570 const char *&PrevSpec,
571 unsigned &DiagID,
572 const PrintingPolicy &Policy) {
573 // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that
574 // for 'long long' we will keep the source location of the first 'long'.
575 if (TypeSpecWidth == TSW_unspecified)
576 TSWLoc = Loc;
577 // Allow turning long -> long long.
578 else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
579 return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
580 TypeSpecWidth = W;
581 return false;
582}
583
584bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
585 const char *&PrevSpec,
586 unsigned &DiagID) {
587 if (TypeSpecComplex != TSC_unspecified)
588 return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
589 TypeSpecComplex = C;
590 TSCLoc = Loc;
591 return false;
592}
593
594bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
595 const char *&PrevSpec,
596 unsigned &DiagID) {
597 if (TypeSpecSign != TSS_unspecified)
598 return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID);
599 TypeSpecSign = S;
600 TSSLoc = Loc;
601 return false;
602}
603
604bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
605 const char *&PrevSpec,
606 unsigned &DiagID,
607 ParsedType Rep,
608 const PrintingPolicy &Policy) {
609 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
610}
611
612bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
613 SourceLocation TagNameLoc,
614 const char *&PrevSpec,
615 unsigned &DiagID,
616 ParsedType Rep,
617 const PrintingPolicy &Policy) {
618 assert(isTypeRep(T) && "T does not store a type");
619 assert(Rep && "no type provided!");
620 if (TypeSpecType != TST_unspecified) {
621 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
622 DiagID = diag::err_invalid_decl_spec_combination;
623 return true;
624 }
625 TypeSpecType = T;
626 TypeRep = Rep;
627 TSTLoc = TagKwLoc;
628 TSTNameLoc = TagNameLoc;
629 TypeSpecOwned = false;
630 return false;
631}
632
633bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
634 const char *&PrevSpec,
635 unsigned &DiagID,
636 Expr *Rep,
637 const PrintingPolicy &Policy) {
638 assert(isExprRep(T) && "T does not store an expr");
639 assert(Rep && "no expression provided!");
640 if (TypeSpecType != TST_unspecified) {
641 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
642 DiagID = diag::err_invalid_decl_spec_combination;
643 return true;
644 }
645 TypeSpecType = T;
646 ExprRep = Rep;
647 TSTLoc = Loc;
648 TSTNameLoc = Loc;
649 TypeSpecOwned = false;
650 return false;
651}
652
653bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
654 const char *&PrevSpec,
655 unsigned &DiagID,
656 Decl *Rep, bool Owned,
657 const PrintingPolicy &Policy) {
658 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
659}
660
661bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
662 SourceLocation TagNameLoc,
663 const char *&PrevSpec,
664 unsigned &DiagID,
665 Decl *Rep, bool Owned,
666 const PrintingPolicy &Policy) {
667 assert(isDeclRep(T) && "T does not store a decl");
668 // Unlike the other cases, we don't assert that we actually get a decl.
669
670 if (TypeSpecType != TST_unspecified) {
671 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
672 DiagID = diag::err_invalid_decl_spec_combination;
673 return true;
674 }
675 TypeSpecType = T;
676 DeclRep = Rep;
677 TSTLoc = TagKwLoc;
678 TSTNameLoc = TagNameLoc;
679 TypeSpecOwned = Owned && Rep != nullptr;
680 return false;
681}
682
683bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
684 const char *&PrevSpec,
685 unsigned &DiagID,
686 const PrintingPolicy &Policy) {
687 assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
688 "rep required for these type-spec kinds!");
689 if (TypeSpecType != TST_unspecified) {
690 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
691 DiagID = diag::err_invalid_decl_spec_combination;
692 return true;
693 }
694 TSTLoc = Loc;
695 TSTNameLoc = Loc;
696 if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
697 TypeAltiVecBool = true;
698 return false;
699 }
700 TypeSpecType = T;
701 TypeSpecOwned = false;
702 return false;
703}
704
705bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
706 const char *&PrevSpec, unsigned &DiagID,
707 const PrintingPolicy &Policy) {
708 if (TypeSpecType != TST_unspecified) {
709 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
710 DiagID = diag::err_invalid_vector_decl_spec_combination;
711 return true;
712 }
713 TypeAltiVecVector = isAltiVecVector;
714 AltiVecLoc = Loc;
715 return false;
716}
717
718bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
719 const char *&PrevSpec, unsigned &DiagID,
720 const PrintingPolicy &Policy) {
721 if (!TypeAltiVecVector || TypeAltiVecPixel ||
722 (TypeSpecType != TST_unspecified)) {
723 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
724 DiagID = diag::err_invalid_pixel_decl_spec_combination;
725 return true;
726 }
727 TypeAltiVecPixel = isAltiVecPixel;
728 TSTLoc = Loc;
729 TSTNameLoc = Loc;
730 return false;
731}
732
733bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
734 const char *&PrevSpec, unsigned &DiagID,
735 const PrintingPolicy &Policy) {
736 if (!TypeAltiVecVector || TypeAltiVecBool ||
737 (TypeSpecType != TST_unspecified)) {
738 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
739 DiagID = diag::err_invalid_vector_bool_decl_spec;
740 return true;
741 }
742 TypeAltiVecBool = isAltiVecBool;
743 TSTLoc = Loc;
744 TSTNameLoc = Loc;
745 return false;
746}
747
748bool DeclSpec::SetTypeSpecError() {
749 TypeSpecType = TST_error;
750 TypeSpecOwned = false;
751 TSTLoc = SourceLocation();
752 TSTNameLoc = SourceLocation();
753 return false;
754}
755
756bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
757 unsigned &DiagID, const LangOptions &Lang) {
758 // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
759 // C++. However, since this is likely not what the user intended, we will
760 // always warn. We do not need to set the qualifier's location since we
761 // already have it.
762 if (TypeQualifiers & T) {
763 bool IsExtension = true;
764 if (Lang.C99)
765 IsExtension = false;
766 return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension);
767 }
768 TypeQualifiers |= T;
769
770 switch (T) {
771 case TQ_unspecified: break;
772 case TQ_const: TQ_constLoc = Loc; return false;
773 case TQ_restrict: TQ_restrictLoc = Loc; return false;
774 case TQ_volatile: TQ_volatileLoc = Loc; return false;
775 case TQ_atomic: TQ_atomicLoc = Loc; return false;
776 }
777
778 llvm_unreachable("Unknown type qualifier!");
779}
780
781bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
782 unsigned &DiagID) {
783 // 'inline inline' is ok. However, since this is likely not what the user
784 // intended, we will always warn, similar to duplicates of type qualifiers.
785 if (FS_inline_specified) {
786 DiagID = diag::warn_duplicate_declspec;
787 PrevSpec = "inline";
788 return true;
789 }
790 FS_inline_specified = true;
791 FS_inlineLoc = Loc;
792 return false;
793}
794
795bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
796 unsigned &DiagID) {
797 if (FS_forceinline_specified) {
798 DiagID = diag::warn_duplicate_declspec;
799 PrevSpec = "__forceinline";
800 return true;
801 }
802 FS_forceinline_specified = true;
803 FS_forceinlineLoc = Loc;
804 return false;
805}
806
807bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
808 const char *&PrevSpec,
809 unsigned &DiagID) {
810 // 'virtual virtual' is ok, but warn as this is likely not what the user
811 // intended.
812 if (FS_virtual_specified) {
813 DiagID = diag::warn_duplicate_declspec;
814 PrevSpec = "virtual";
815 return true;
816 }
817 FS_virtual_specified = true;
818 FS_virtualLoc = Loc;
819 return false;
820}
821
822bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
823 const char *&PrevSpec,
824 unsigned &DiagID) {
825 // 'explicit explicit' is ok, but warn as this is likely not what the user
826 // intended.
827 if (FS_explicit_specified) {
828 DiagID = diag::warn_duplicate_declspec;
829 PrevSpec = "explicit";
830 return true;
831 }
832 FS_explicit_specified = true;
833 FS_explicitLoc = Loc;
834 return false;
835}
836
837bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
838 const char *&PrevSpec,
839 unsigned &DiagID) {
840 // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
841 // intended.
842 if (FS_noreturn_specified) {
843 DiagID = diag::warn_duplicate_declspec;
844 PrevSpec = "_Noreturn";
845 return true;
846 }
847 FS_noreturn_specified = true;
848 FS_noreturnLoc = Loc;
849 return false;
850}
851
852bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
853 unsigned &DiagID) {
854 if (Friend_specified) {
855 PrevSpec = "friend";
856 // Keep the later location, so that we can later diagnose ill-formed
857 // declarations like 'friend class X friend;'. Per [class.friend]p3,
858 // 'friend' must be the first token in a friend declaration that is
859 // not a function declaration.
860 FriendLoc = Loc;
861 DiagID = diag::warn_duplicate_declspec;
862 return true;
863 }
864
865 Friend_specified = true;
866 FriendLoc = Loc;
867 return false;
868}
869
870bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
871 unsigned &DiagID) {
872 if (isModulePrivateSpecified()) {
873 PrevSpec = "__module_private__";
874 DiagID = diag::ext_duplicate_declspec;
875 return true;
876 }
877
878 ModulePrivateLoc = Loc;
879 return false;
880}
881
882bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
883 unsigned &DiagID) {
884 // 'constexpr constexpr' is ok, but warn as this is likely not what the user
885 // intended.
886 if (Constexpr_specified) {
887 DiagID = diag::warn_duplicate_declspec;
888 PrevSpec = "constexpr";
889 return true;
890 }
891 Constexpr_specified = true;
892 ConstexprLoc = Loc;
893 return false;
894}
895
896void DeclSpec::setProtocolQualifiers(Decl * const *Protos,
897 unsigned NP,
898 SourceLocation *ProtoLocs,
899 SourceLocation LAngleLoc) {
900 if (NP == 0) return;
901 Decl **ProtoQuals = new Decl*[NP];
902 memcpy(ProtoQuals, Protos, sizeof(Decl*)*NP);
903 ProtocolQualifiers = ProtoQuals;
904 ProtocolLocs = new SourceLocation[NP];
905 memcpy(ProtocolLocs, ProtoLocs, sizeof(SourceLocation)*NP);
906 NumProtocolQualifiers = NP;
907 ProtocolLAngleLoc = LAngleLoc;
908}
909
910void DeclSpec::SaveWrittenBuiltinSpecs() {
911 writtenBS.Sign = getTypeSpecSign();
912 writtenBS.Width = getTypeSpecWidth();
913 writtenBS.Type = getTypeSpecType();
914 // Search the list of attributes for the presence of a mode attribute.
915 writtenBS.ModeAttr = false;
916 AttributeList* attrs = getAttributes().getList();
917 while (attrs) {
918 if (attrs->getKind() == AttributeList::AT_Mode) {
919 writtenBS.ModeAttr = true;
920 break;
921 }
922 attrs = attrs->getNext();
923 }
924}
925
926/// Finish - This does final analysis of the declspec, rejecting things like
927/// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
928/// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
929/// DeclSpec is guaranteed self-consistent, even if an error occurred.
930void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP, const PrintingPolicy &Policy) {
931 // Before possibly changing their values, save specs as written.
932 SaveWrittenBuiltinSpecs();
933
934 // Check the type specifier components first.
935
936 // If decltype(auto) is used, no other type specifiers are permitted.
937 if (TypeSpecType == TST_decltype_auto &&
938 (TypeSpecWidth != TSW_unspecified ||
939 TypeSpecComplex != TSC_unspecified ||
940 TypeSpecSign != TSS_unspecified ||
941 TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
942 TypeQualifiers)) {
943 const unsigned NumLocs = 8;
944 SourceLocation ExtraLocs[NumLocs] = {
945 TSWLoc, TSCLoc, TSSLoc, AltiVecLoc,
946 TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc
947 };
948 FixItHint Hints[NumLocs];
949 SourceLocation FirstLoc;
950 for (unsigned I = 0; I != NumLocs; ++I) {
951 if (!ExtraLocs[I].isInvalid()) {
952 if (FirstLoc.isInvalid() ||
953 PP.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
954 FirstLoc))
955 FirstLoc = ExtraLocs[I];
956 Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
957 }
958 }
959 TypeSpecWidth = TSW_unspecified;
960 TypeSpecComplex = TSC_unspecified;
961 TypeSpecSign = TSS_unspecified;
962 TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
963 TypeQualifiers = 0;
964 Diag(D, TSTLoc, diag::err_decltype_auto_cannot_be_combined)
965 << Hints[0] << Hints[1] << Hints[2] << Hints[3]
966 << Hints[4] << Hints[5] << Hints[6] << Hints[7];
967 }
968
969 // Validate and finalize AltiVec vector declspec.
970 if (TypeAltiVecVector) {
971 if (TypeAltiVecBool) {
972 // Sign specifiers are not allowed with vector bool. (PIM 2.1)
973 if (TypeSpecSign != TSS_unspecified) {
974 Diag(D, TSSLoc, diag::err_invalid_vector_bool_decl_spec)
975 << getSpecifierName((TSS)TypeSpecSign);
976 }
977
978 // Only char/int are valid with vector bool. (PIM 2.1)
979 if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) &&
980 (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
981 Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec)
982 << (TypeAltiVecPixel ? "__pixel" :
983 getSpecifierName((TST)TypeSpecType, Policy));
984 }
985
986 // Only 'short' is valid with vector bool. (PIM 2.1)
987 if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short))
988 Diag(D, TSWLoc, diag::err_invalid_vector_bool_decl_spec)
989 << getSpecifierName((TSW)TypeSpecWidth);
990
991 // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
992 if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
993 (TypeSpecWidth != TSW_unspecified))
994 TypeSpecSign = TSS_unsigned;
995 } else if (TypeSpecType == TST_double) {
996 // vector long double and vector long long double are never allowed.
997 // vector double is OK for Power7 and later.
998 if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
999 Diag(D, TSWLoc, diag::err_invalid_vector_long_double_decl_spec);
1000 else if (!PP.getTargetInfo().hasFeature("vsx"))
1001 Diag(D, TSTLoc, diag::err_invalid_vector_double_decl_spec);
1002 } else if (TypeSpecWidth == TSW_long) {
1003 Diag(D, TSWLoc, diag::warn_vector_long_decl_spec_combination)
1004 << getSpecifierName((TST)TypeSpecType, Policy);
1005 }
1006
1007 if (TypeAltiVecPixel) {
1008 //TODO: perform validation
1009 TypeSpecType = TST_int;
1010 TypeSpecSign = TSS_unsigned;
1011 TypeSpecWidth = TSW_short;
1012 TypeSpecOwned = false;
1013 }
1014 }
1015
1016 // signed/unsigned are only valid with int/char/wchar_t.
1017 if (TypeSpecSign != TSS_unspecified) {
1018 if (TypeSpecType == TST_unspecified)
1019 TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
1020 else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
1021 TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
1022 Diag(D, TSSLoc, diag::err_invalid_sign_spec)
1023 << getSpecifierName((TST)TypeSpecType, Policy);
1024 // signed double -> double.
1025 TypeSpecSign = TSS_unspecified;
1026 }
1027 }
1028
1029 // Validate the width of the type.
1030 switch (TypeSpecWidth) {
1031 case TSW_unspecified: break;
1032 case TSW_short: // short int
1033 case TSW_longlong: // long long int
1034 if (TypeSpecType == TST_unspecified)
1035 TypeSpecType = TST_int; // short -> short int, long long -> long long int.
1036 else if (TypeSpecType != TST_int) {
1037 Diag(D, TSWLoc,
1038 TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec
1039 : diag::err_invalid_longlong_spec)
1040 << getSpecifierName((TST)TypeSpecType, Policy);
1041 TypeSpecType = TST_int;
1042 TypeSpecOwned = false;
1043 }
1044 break;
1045 case TSW_long: // long double, long int
1046 if (TypeSpecType == TST_unspecified)
1047 TypeSpecType = TST_int; // long -> long int.
1048 else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
1049 Diag(D, TSWLoc, diag::err_invalid_long_spec)
1050 << getSpecifierName((TST)TypeSpecType, Policy);
1051 TypeSpecType = TST_int;
1052 TypeSpecOwned = false;
1053 }
1054 break;
1055 }
1056
1057 // TODO: if the implementation does not implement _Complex or _Imaginary,
1058 // disallow their use. Need information about the backend.
1059 if (TypeSpecComplex != TSC_unspecified) {
1060 if (TypeSpecType == TST_unspecified) {
1061 Diag(D, TSCLoc, diag::ext_plain_complex)
1062 << FixItHint::CreateInsertion(
1063 PP.getLocForEndOfToken(getTypeSpecComplexLoc()),
1064 " double");
1065 TypeSpecType = TST_double; // _Complex -> _Complex double.
1066 } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) {
1067 // Note that this intentionally doesn't include _Complex _Bool.
1068 if (!PP.getLangOpts().CPlusPlus)
1069 Diag(D, TSTLoc, diag::ext_integer_complex);
1070 } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
1071 Diag(D, TSCLoc, diag::err_invalid_complex_spec)
1072 << getSpecifierName((TST)TypeSpecType, Policy);
1073 TypeSpecComplex = TSC_unspecified;
1074 }
1075 }
1076
1077 // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and
1078 // _Thread_local can only appear with the 'static' and 'extern' storage class
1079 // specifiers. We also allow __private_extern__ as an extension.
1080 if (ThreadStorageClassSpec != TSCS_unspecified) {
1081 switch (StorageClassSpec) {
1082 case SCS_unspecified:
1083 case SCS_extern:
1084 case SCS_private_extern:
1085 case SCS_static:
1086 break;
1087 default:
1088 if (PP.getSourceManager().isBeforeInTranslationUnit(
1089 getThreadStorageClassSpecLoc(), getStorageClassSpecLoc()))
1090 Diag(D, getStorageClassSpecLoc(),
1091 diag::err_invalid_decl_spec_combination)
1092 << DeclSpec::getSpecifierName(getThreadStorageClassSpec())
1093 << SourceRange(getThreadStorageClassSpecLoc());
1094 else
1095 Diag(D, getThreadStorageClassSpecLoc(),
1096 diag::err_invalid_decl_spec_combination)
1097 << DeclSpec::getSpecifierName(getStorageClassSpec())
1098 << SourceRange(getStorageClassSpecLoc());
1099 // Discard the thread storage class specifier to recover.
1100 ThreadStorageClassSpec = TSCS_unspecified;
1101 ThreadStorageClassSpecLoc = SourceLocation();
1102 }
1103 }
1104
1105 // If no type specifier was provided and we're parsing a language where
1106 // the type specifier is not optional, but we got 'auto' as a storage
1107 // class specifier, then assume this is an attempt to use C++0x's 'auto'
1108 // type specifier.
1109 if (PP.getLangOpts().CPlusPlus &&
1110 TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
1111 TypeSpecType = TST_auto;
1112 StorageClassSpec = SCS_unspecified;
1113 TSTLoc = TSTNameLoc = StorageClassSpecLoc;
1114 StorageClassSpecLoc = SourceLocation();
1115 }
1116 // Diagnose if we've recovered from an ill-formed 'auto' storage class
1117 // specifier in a pre-C++11 dialect of C++.
1118 if (!PP.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto)
1119 Diag(D, TSTLoc, diag::ext_auto_type_specifier);
1120 if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().CPlusPlus11 &&
1121 StorageClassSpec == SCS_auto)
1122 Diag(D, StorageClassSpecLoc, diag::warn_auto_storage_class)
1123 << FixItHint::CreateRemoval(StorageClassSpecLoc);
1124 if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
1125 Diag(D, TSTLoc, diag::warn_cxx98_compat_unicode_type)
1126 << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
1127 if (Constexpr_specified)
1128 Diag(D, ConstexprLoc, diag::warn_cxx98_compat_constexpr);
1129
1130 // C++ [class.friend]p6:
1131 // No storage-class-specifier shall appear in the decl-specifier-seq
1132 // of a friend declaration.
1133 if (isFriendSpecified() &&
1134 (getStorageClassSpec() || getThreadStorageClassSpec())) {
1135 SmallString<32> SpecName;
1136 SourceLocation SCLoc;
1137 FixItHint StorageHint, ThreadHint;
1138
1139 if (DeclSpec::SCS SC = getStorageClassSpec()) {
1140 SpecName = getSpecifierName(SC);
1141 SCLoc = getStorageClassSpecLoc();
1142 StorageHint = FixItHint::CreateRemoval(SCLoc);
1143 }
1144
1145 if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) {
1146 if (!SpecName.empty()) SpecName += " ";
1147 SpecName += getSpecifierName(TSC);
1148 SCLoc = getThreadStorageClassSpecLoc();
1149 ThreadHint = FixItHint::CreateRemoval(SCLoc);
1150 }
1151
1152 Diag(D, SCLoc, diag::err_friend_decl_spec)
1153 << SpecName << StorageHint << ThreadHint;
1154
1155 ClearStorageClassSpecs();
1156 }
1157
1158 // C++11 [dcl.fct.spec]p5:
1159 // The virtual specifier shall be used only in the initial
1160 // declaration of a non-static class member function;
1161 // C++11 [dcl.fct.spec]p6:
1162 // The explicit specifier shall be used only in the declaration of
1163 // a constructor or conversion function within its class
1164 // definition;
1165 if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) {
1166 StringRef Keyword;
1167 SourceLocation SCLoc;
1168
1169 if (isVirtualSpecified()) {
1170 Keyword = "virtual";
1171 SCLoc = getVirtualSpecLoc();
1172 } else {
1173 Keyword = "explicit";
1174 SCLoc = getExplicitSpecLoc();
1175 }
1176
1177 FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
1178 Diag(D, SCLoc, diag::err_friend_decl_spec)
1179 << Keyword << Hint;
1180
1181 FS_virtual_specified = FS_explicit_specified = false;
1182 FS_virtualLoc = FS_explicitLoc = SourceLocation();
1183 }
1184
1185 assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
1186
1187 // Okay, now we can infer the real type.
1188
1189 // TODO: return "auto function" and other bad things based on the real type.
1190
1191 // 'data definition has no type or storage class'?
1192}
1193
1194bool DeclSpec::isMissingDeclaratorOk() {
1195 TST tst = getTypeSpecType();
1196 return isDeclRep(tst) && getRepAsDecl() != nullptr &&
1197 StorageClassSpec != DeclSpec::SCS_typedef;
1198}
1199
1200void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
1201 OverloadedOperatorKind Op,
1202 SourceLocation SymbolLocations[3]) {
1203 Kind = IK_OperatorFunctionId;
1204 StartLocation = OperatorLoc;
1205 EndLocation = OperatorLoc;
1206 OperatorFunctionId.Operator = Op;
1207 for (unsigned I = 0; I != 3; ++I) {
1208 OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
1209
1210 if (SymbolLocations[I].isValid())
1211 EndLocation = SymbolLocations[I];
1212 }
1213}
1214
1215bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
1216 const char *&PrevSpec) {
1217 LastLocation = Loc;
1218
1219 if (Specifiers & VS) {
1220 PrevSpec = getSpecifierName(VS);
1221 return true;
1222 }
1223
1224 Specifiers |= VS;
1225
1226 switch (VS) {
1227 default: llvm_unreachable("Unknown specifier!");
1228 case VS_Override: VS_overrideLoc = Loc; break;
1229 case VS_Sealed:
1230 case VS_Final: VS_finalLoc = Loc; break;
1231 }
1232
1233 return false;
1234}
1235
1236const char *VirtSpecifiers::getSpecifierName(Specifier VS) {
1237 switch (VS) {
1238 default: llvm_unreachable("Unknown specifier");
1239 case VS_Override: return "override";
1240 case VS_Final: return "final";
1241 case VS_Sealed: return "sealed";
1242 }
1243}
|