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