clang  5.0.0
SemaType.cpp
Go to the documentation of this file.
1 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
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 type-related semantic analysis.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "TypeLocBuilder.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/TypeLoc.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/Preprocessor.h"
28 #include "clang/Sema/DeclSpec.h"
30 #include "clang/Sema/Lookup.h"
31 #include "clang/Sema/ScopeInfo.h"
33 #include "clang/Sema/Template.h"
34 #include "llvm/ADT/SmallPtrSet.h"
35 #include "llvm/ADT/SmallString.h"
36 #include "llvm/ADT/StringSwitch.h"
37 #include "llvm/Support/ErrorHandling.h"
38 
39 using namespace clang;
40 
45 };
46 
47 /// isOmittedBlockReturnType - Return true if this declarator is missing a
48 /// return type because this is a omitted return type on a block literal.
49 static bool isOmittedBlockReturnType(const Declarator &D) {
52  return false;
53 
54  if (D.getNumTypeObjects() == 0)
55  return true; // ^{ ... }
56 
57  if (D.getNumTypeObjects() == 1 &&
59  return true; // ^(int X, float Y) { ... }
60 
61  return false;
62 }
63 
64 /// diagnoseBadTypeAttribute - Diagnoses a type attribute which
65 /// doesn't apply to the given type.
66 static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr,
67  QualType type) {
68  TypeDiagSelector WhichType;
69  bool useExpansionLoc = true;
70  switch (attr.getKind()) {
71  case AttributeList::AT_ObjCGC: WhichType = TDS_Pointer; break;
72  case AttributeList::AT_ObjCOwnership: WhichType = TDS_ObjCObjOrBlock; break;
73  default:
74  // Assume everything else was a function attribute.
75  WhichType = TDS_Function;
76  useExpansionLoc = false;
77  break;
78  }
79 
80  SourceLocation loc = attr.getLoc();
81  StringRef name = attr.getName()->getName();
82 
83  // The GC attributes are usually written with macros; special-case them.
84  IdentifierInfo *II = attr.isArgIdent(0) ? attr.getArgAsIdent(0)->Ident
85  : nullptr;
86  if (useExpansionLoc && loc.isMacroID() && II) {
87  if (II->isStr("strong")) {
88  if (S.findMacroSpelling(loc, "__strong")) name = "__strong";
89  } else if (II->isStr("weak")) {
90  if (S.findMacroSpelling(loc, "__weak")) name = "__weak";
91  }
92  }
93 
94  S.Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType
95  << type;
96 }
97 
98 // objc_gc applies to Objective-C pointers or, otherwise, to the
99 // smallest available pointer type (i.e. 'void*' in 'void**').
100 #define OBJC_POINTER_TYPE_ATTRS_CASELIST \
101  case AttributeList::AT_ObjCGC: \
102  case AttributeList::AT_ObjCOwnership
103 
104 // Calling convention attributes.
105 #define CALLING_CONV_ATTRS_CASELIST \
106  case AttributeList::AT_CDecl: \
107  case AttributeList::AT_FastCall: \
108  case AttributeList::AT_StdCall: \
109  case AttributeList::AT_ThisCall: \
110  case AttributeList::AT_RegCall: \
111  case AttributeList::AT_Pascal: \
112  case AttributeList::AT_SwiftCall: \
113  case AttributeList::AT_VectorCall: \
114  case AttributeList::AT_MSABI: \
115  case AttributeList::AT_SysVABI: \
116  case AttributeList::AT_Pcs: \
117  case AttributeList::AT_IntelOclBicc: \
118  case AttributeList::AT_PreserveMost: \
119  case AttributeList::AT_PreserveAll
120 
121 // Function type attributes.
122 #define FUNCTION_TYPE_ATTRS_CASELIST \
123  case AttributeList::AT_NSReturnsRetained: \
124  case AttributeList::AT_NoReturn: \
125  case AttributeList::AT_Regparm: \
126  case AttributeList::AT_AnyX86NoCallerSavedRegisters: \
127  CALLING_CONV_ATTRS_CASELIST
128 
129 // Microsoft-specific type qualifiers.
130 #define MS_TYPE_ATTRS_CASELIST \
131  case AttributeList::AT_Ptr32: \
132  case AttributeList::AT_Ptr64: \
133  case AttributeList::AT_SPtr: \
134  case AttributeList::AT_UPtr
135 
136 // Nullability qualifiers.
137 #define NULLABILITY_TYPE_ATTRS_CASELIST \
138  case AttributeList::AT_TypeNonNull: \
139  case AttributeList::AT_TypeNullable: \
140  case AttributeList::AT_TypeNullUnspecified
141 
142 namespace {
143  /// An object which stores processing state for the entire
144  /// GetTypeForDeclarator process.
145  class TypeProcessingState {
146  Sema &sema;
147 
148  /// The declarator being processed.
149  Declarator &declarator;
150 
151  /// The index of the declarator chunk we're currently processing.
152  /// May be the total number of valid chunks, indicating the
153  /// DeclSpec.
154  unsigned chunkIndex;
155 
156  /// Whether there are non-trivial modifications to the decl spec.
157  bool trivial;
158 
159  /// Whether we saved the attributes in the decl spec.
160  bool hasSavedAttrs;
161 
162  /// The original set of attributes on the DeclSpec.
164 
165  /// A list of attributes to diagnose the uselessness of when the
166  /// processing is complete.
167  SmallVector<AttributeList*, 2> ignoredTypeAttrs;
168 
169  public:
170  TypeProcessingState(Sema &sema, Declarator &declarator)
171  : sema(sema), declarator(declarator),
172  chunkIndex(declarator.getNumTypeObjects()),
173  trivial(true), hasSavedAttrs(false) {}
174 
175  Sema &getSema() const {
176  return sema;
177  }
178 
179  Declarator &getDeclarator() const {
180  return declarator;
181  }
182 
183  bool isProcessingDeclSpec() const {
184  return chunkIndex == declarator.getNumTypeObjects();
185  }
186 
187  unsigned getCurrentChunkIndex() const {
188  return chunkIndex;
189  }
190 
191  void setCurrentChunkIndex(unsigned idx) {
192  assert(idx <= declarator.getNumTypeObjects());
193  chunkIndex = idx;
194  }
195 
196  AttributeList *&getCurrentAttrListRef() const {
197  if (isProcessingDeclSpec())
198  return getMutableDeclSpec().getAttributes().getListRef();
199  return declarator.getTypeObject(chunkIndex).getAttrListRef();
200  }
201 
202  /// Save the current set of attributes on the DeclSpec.
203  void saveDeclSpecAttrs() {
204  // Don't try to save them multiple times.
205  if (hasSavedAttrs) return;
206 
207  DeclSpec &spec = getMutableDeclSpec();
208  for (AttributeList *attr = spec.getAttributes().getList(); attr;
209  attr = attr->getNext())
210  savedAttrs.push_back(attr);
211  trivial &= savedAttrs.empty();
212  hasSavedAttrs = true;
213  }
214 
215  /// Record that we had nowhere to put the given type attribute.
216  /// We will diagnose such attributes later.
217  void addIgnoredTypeAttr(AttributeList &attr) {
218  ignoredTypeAttrs.push_back(&attr);
219  }
220 
221  /// Diagnose all the ignored type attributes, given that the
222  /// declarator worked out to the given type.
223  void diagnoseIgnoredTypeAttrs(QualType type) const {
224  for (auto *Attr : ignoredTypeAttrs)
225  diagnoseBadTypeAttribute(getSema(), *Attr, type);
226  }
227 
228  ~TypeProcessingState() {
229  if (trivial) return;
230 
231  restoreDeclSpecAttrs();
232  }
233 
234  private:
235  DeclSpec &getMutableDeclSpec() const {
236  return const_cast<DeclSpec&>(declarator.getDeclSpec());
237  }
238 
239  void restoreDeclSpecAttrs() {
240  assert(hasSavedAttrs);
241 
242  if (savedAttrs.empty()) {
243  getMutableDeclSpec().getAttributes().set(nullptr);
244  return;
245  }
246 
247  getMutableDeclSpec().getAttributes().set(savedAttrs[0]);
248  for (unsigned i = 0, e = savedAttrs.size() - 1; i != e; ++i)
249  savedAttrs[i]->setNext(savedAttrs[i+1]);
250  savedAttrs.back()->setNext(nullptr);
251  }
252  };
253 } // end anonymous namespace
254 
255 static void spliceAttrIntoList(AttributeList &attr, AttributeList *&head) {
256  attr.setNext(head);
257  head = &attr;
258 }
259 
260 static void spliceAttrOutOfList(AttributeList &attr, AttributeList *&head) {
261  if (head == &attr) {
262  head = attr.getNext();
263  return;
264  }
265 
266  AttributeList *cur = head;
267  while (true) {
268  assert(cur && cur->getNext() && "ran out of attrs?");
269  if (cur->getNext() == &attr) {
270  cur->setNext(attr.getNext());
271  return;
272  }
273  cur = cur->getNext();
274  }
275 }
276 
278  AttributeList *&fromList,
279  AttributeList *&toList) {
280  spliceAttrOutOfList(attr, fromList);
281  spliceAttrIntoList(attr, toList);
282 }
283 
284 /// The location of a type attribute.
286  /// The attribute is in the decl-specifier-seq.
288  /// The attribute is part of a DeclaratorChunk.
290  /// The attribute is immediately after the declaration's name.
292 };
293 
294 static void processTypeAttrs(TypeProcessingState &state,
296  AttributeList *attrs);
297 
298 static bool handleFunctionTypeAttr(TypeProcessingState &state,
299  AttributeList &attr,
300  QualType &type);
301 
302 static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state,
303  AttributeList &attr,
304  QualType &type);
305 
306 static bool handleObjCGCTypeAttr(TypeProcessingState &state,
307  AttributeList &attr, QualType &type);
308 
309 static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state,
310  AttributeList &attr, QualType &type);
311 
312 static bool handleObjCPointerTypeAttr(TypeProcessingState &state,
313  AttributeList &attr, QualType &type) {
314  if (attr.getKind() == AttributeList::AT_ObjCGC)
315  return handleObjCGCTypeAttr(state, attr, type);
316  assert(attr.getKind() == AttributeList::AT_ObjCOwnership);
317  return handleObjCOwnershipTypeAttr(state, attr, type);
318 }
319 
320 /// Given the index of a declarator chunk, check whether that chunk
321 /// directly specifies the return type of a function and, if so, find
322 /// an appropriate place for it.
323 ///
324 /// \param i - a notional index which the search will start
325 /// immediately inside
326 ///
327 /// \param onlyBlockPointers Whether we should only look into block
328 /// pointer types (vs. all pointer types).
330  unsigned i,
331  bool onlyBlockPointers) {
332  assert(i <= declarator.getNumTypeObjects());
333 
334  DeclaratorChunk *result = nullptr;
335 
336  // First, look inwards past parens for a function declarator.
337  for (; i != 0; --i) {
338  DeclaratorChunk &fnChunk = declarator.getTypeObject(i-1);
339  switch (fnChunk.Kind) {
341  continue;
342 
343  // If we find anything except a function, bail out.
350  return result;
351 
352  // If we do find a function declarator, scan inwards from that,
353  // looking for a (block-)pointer declarator.
355  for (--i; i != 0; --i) {
356  DeclaratorChunk &ptrChunk = declarator.getTypeObject(i-1);
357  switch (ptrChunk.Kind) {
363  continue;
364 
367  if (onlyBlockPointers)
368  continue;
369 
370  // fallthrough
371 
373  result = &ptrChunk;
374  goto continue_outer;
375  }
376  llvm_unreachable("bad declarator chunk kind");
377  }
378 
379  // If we run out of declarators doing that, we're done.
380  return result;
381  }
382  llvm_unreachable("bad declarator chunk kind");
383 
384  // Okay, reconsider from our new point.
385  continue_outer: ;
386  }
387 
388  // Ran out of chunks, bail out.
389  return result;
390 }
391 
392 /// Given that an objc_gc attribute was written somewhere on a
393 /// declaration *other* than on the declarator itself (for which, use
394 /// distributeObjCPointerTypeAttrFromDeclarator), and given that it
395 /// didn't apply in whatever position it was written in, try to move
396 /// it to a more appropriate position.
397 static void distributeObjCPointerTypeAttr(TypeProcessingState &state,
398  AttributeList &attr,
399  QualType type) {
400  Declarator &declarator = state.getDeclarator();
401 
402  // Move it to the outermost normal or block pointer declarator.
403  for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
404  DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
405  switch (chunk.Kind) {
408  // But don't move an ARC ownership attribute to the return type
409  // of a block.
410  DeclaratorChunk *destChunk = nullptr;
411  if (state.isProcessingDeclSpec() &&
412  attr.getKind() == AttributeList::AT_ObjCOwnership)
413  destChunk = maybeMovePastReturnType(declarator, i - 1,
414  /*onlyBlockPointers=*/true);
415  if (!destChunk) destChunk = &chunk;
416 
417  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
418  destChunk->getAttrListRef());
419  return;
420  }
421 
424  continue;
425 
426  // We may be starting at the return type of a block.
428  if (state.isProcessingDeclSpec() &&
429  attr.getKind() == AttributeList::AT_ObjCOwnership) {
431  declarator, i,
432  /*onlyBlockPointers=*/true)) {
433  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
434  dest->getAttrListRef());
435  return;
436  }
437  }
438  goto error;
439 
440  // Don't walk through these.
444  goto error;
445  }
446  }
447  error:
448 
449  diagnoseBadTypeAttribute(state.getSema(), attr, type);
450 }
451 
452 /// Distribute an objc_gc type attribute that was written on the
453 /// declarator.
454 static void
456  AttributeList &attr,
457  QualType &declSpecType) {
458  Declarator &declarator = state.getDeclarator();
459 
460  // objc_gc goes on the innermost pointer to something that's not a
461  // pointer.
462  unsigned innermost = -1U;
463  bool considerDeclSpec = true;
464  for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
465  DeclaratorChunk &chunk = declarator.getTypeObject(i);
466  switch (chunk.Kind) {
469  innermost = i;
470  continue;
471 
477  continue;
478 
480  considerDeclSpec = false;
481  goto done;
482  }
483  }
484  done:
485 
486  // That might actually be the decl spec if we weren't blocked by
487  // anything in the declarator.
488  if (considerDeclSpec) {
489  if (handleObjCPointerTypeAttr(state, attr, declSpecType)) {
490  // Splice the attribute into the decl spec. Prevents the
491  // attribute from being applied multiple times and gives
492  // the source-location-filler something to work with.
493  state.saveDeclSpecAttrs();
494  moveAttrFromListToList(attr, declarator.getAttrListRef(),
495  declarator.getMutableDeclSpec().getAttributes().getListRef());
496  return;
497  }
498  }
499 
500  // Otherwise, if we found an appropriate chunk, splice the attribute
501  // into it.
502  if (innermost != -1U) {
503  moveAttrFromListToList(attr, declarator.getAttrListRef(),
504  declarator.getTypeObject(innermost).getAttrListRef());
505  return;
506  }
507 
508  // Otherwise, diagnose when we're done building the type.
509  spliceAttrOutOfList(attr, declarator.getAttrListRef());
510  state.addIgnoredTypeAttr(attr);
511 }
512 
513 /// A function type attribute was written somewhere in a declaration
514 /// *other* than on the declarator itself or in the decl spec. Given
515 /// that it didn't apply in whatever position it was written in, try
516 /// to move it to a more appropriate position.
517 static void distributeFunctionTypeAttr(TypeProcessingState &state,
518  AttributeList &attr,
519  QualType type) {
520  Declarator &declarator = state.getDeclarator();
521 
522  // Try to push the attribute from the return type of a function to
523  // the function itself.
524  for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
525  DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
526  switch (chunk.Kind) {
528  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
529  chunk.getAttrListRef());
530  return;
531 
539  continue;
540  }
541  }
542 
543  diagnoseBadTypeAttribute(state.getSema(), attr, type);
544 }
545 
546 /// Try to distribute a function type attribute to the innermost
547 /// function chunk or type. Returns true if the attribute was
548 /// distributed, false if no location was found.
549 static bool
551  AttributeList &attr,
552  AttributeList *&attrList,
553  QualType &declSpecType) {
554  Declarator &declarator = state.getDeclarator();
555 
556  // Put it on the innermost function chunk, if there is one.
557  for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
558  DeclaratorChunk &chunk = declarator.getTypeObject(i);
559  if (chunk.Kind != DeclaratorChunk::Function) continue;
560 
561  moveAttrFromListToList(attr, attrList, chunk.getAttrListRef());
562  return true;
563  }
564 
565  return handleFunctionTypeAttr(state, attr, declSpecType);
566 }
567 
568 /// A function type attribute was written in the decl spec. Try to
569 /// apply it somewhere.
570 static void
572  AttributeList &attr,
573  QualType &declSpecType) {
574  state.saveDeclSpecAttrs();
575 
576  // C++11 attributes before the decl specifiers actually appertain to
577  // the declarators. Move them straight there. We don't support the
578  // 'put them wherever you like' semantics we allow for GNU attributes.
579  if (attr.isCXX11Attribute()) {
580  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
581  state.getDeclarator().getAttrListRef());
582  return;
583  }
584 
585  // Try to distribute to the innermost.
587  state.getCurrentAttrListRef(),
588  declSpecType))
589  return;
590 
591  // If that failed, diagnose the bad attribute when the declarator is
592  // fully built.
593  state.addIgnoredTypeAttr(attr);
594 }
595 
596 /// A function type attribute was written on the declarator. Try to
597 /// apply it somewhere.
598 static void
600  AttributeList &attr,
601  QualType &declSpecType) {
602  Declarator &declarator = state.getDeclarator();
603 
604  // Try to distribute to the innermost.
606  declarator.getAttrListRef(),
607  declSpecType))
608  return;
609 
610  // If that failed, diagnose the bad attribute when the declarator is
611  // fully built.
612  spliceAttrOutOfList(attr, declarator.getAttrListRef());
613  state.addIgnoredTypeAttr(attr);
614 }
615 
616 /// \brief Given that there are attributes written on the declarator
617 /// itself, try to distribute any type attributes to the appropriate
618 /// declarator chunk.
619 ///
620 /// These are attributes like the following:
621 /// int f ATTR;
622 /// int (f ATTR)();
623 /// but not necessarily this:
624 /// int f() ATTR;
625 static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state,
626  QualType &declSpecType) {
627  // Collect all the type attributes from the declarator itself.
628  assert(state.getDeclarator().getAttributes() && "declarator has no attrs!");
629  AttributeList *attr = state.getDeclarator().getAttributes();
630  AttributeList *next;
631  do {
632  next = attr->getNext();
633 
634  // Do not distribute C++11 attributes. They have strict rules for what
635  // they appertain to.
636  if (attr->isCXX11Attribute())
637  continue;
638 
639  switch (attr->getKind()) {
641  distributeObjCPointerTypeAttrFromDeclarator(state, *attr, declSpecType);
642  break;
643 
645  distributeFunctionTypeAttrFromDeclarator(state, *attr, declSpecType);
646  break;
647 
649  // Microsoft type attributes cannot go after the declarator-id.
650  continue;
651 
653  // Nullability specifiers cannot go after the declarator-id.
654 
655  // Objective-C __kindof does not get distributed.
656  case AttributeList::AT_ObjCKindOf:
657  continue;
658 
659  default:
660  break;
661  }
662  } while ((attr = next));
663 }
664 
665 /// Add a synthetic '()' to a block-literal declarator if it is
666 /// required, given the return type.
667 static void maybeSynthesizeBlockSignature(TypeProcessingState &state,
668  QualType declSpecType) {
669  Declarator &declarator = state.getDeclarator();
670 
671  // First, check whether the declarator would produce a function,
672  // i.e. whether the innermost semantic chunk is a function.
673  if (declarator.isFunctionDeclarator()) {
674  // If so, make that declarator a prototyped declarator.
675  declarator.getFunctionTypeInfo().hasPrototype = true;
676  return;
677  }
678 
679  // If there are any type objects, the type as written won't name a
680  // function, regardless of the decl spec type. This is because a
681  // block signature declarator is always an abstract-declarator, and
682  // abstract-declarators can't just be parentheses chunks. Therefore
683  // we need to build a function chunk unless there are no type
684  // objects and the decl spec type is a function.
685  if (!declarator.getNumTypeObjects() && declSpecType->isFunctionType())
686  return;
687 
688  // Note that there *are* cases with invalid declarators where
689  // declarators consist solely of parentheses. In general, these
690  // occur only in failed efforts to make function declarators, so
691  // faking up the function chunk is still the right thing to do.
692 
693  // Otherwise, we need to fake up a function declarator.
694  SourceLocation loc = declarator.getLocStart();
695 
696  // ...and *prepend* it to the declarator.
697  SourceLocation NoLoc;
699  /*HasProto=*/true,
700  /*IsAmbiguous=*/false,
701  /*LParenLoc=*/NoLoc,
702  /*ArgInfo=*/nullptr,
703  /*NumArgs=*/0,
704  /*EllipsisLoc=*/NoLoc,
705  /*RParenLoc=*/NoLoc,
706  /*TypeQuals=*/0,
707  /*RefQualifierIsLvalueRef=*/true,
708  /*RefQualifierLoc=*/NoLoc,
709  /*ConstQualifierLoc=*/NoLoc,
710  /*VolatileQualifierLoc=*/NoLoc,
711  /*RestrictQualifierLoc=*/NoLoc,
712  /*MutableLoc=*/NoLoc, EST_None,
713  /*ESpecRange=*/SourceRange(),
714  /*Exceptions=*/nullptr,
715  /*ExceptionRanges=*/nullptr,
716  /*NumExceptions=*/0,
717  /*NoexceptExpr=*/nullptr,
718  /*ExceptionSpecTokens=*/nullptr,
719  /*DeclsInPrototype=*/None,
720  loc, loc, declarator));
721 
722  // For consistency, make sure the state still has us as processing
723  // the decl spec.
724  assert(state.getCurrentChunkIndex() == declarator.getNumTypeObjects() - 1);
725  state.setCurrentChunkIndex(declarator.getNumTypeObjects());
726 }
727 
729  unsigned &TypeQuals,
730  QualType TypeSoFar,
731  unsigned RemoveTQs,
732  unsigned DiagID) {
733  // If this occurs outside a template instantiation, warn the user about
734  // it; they probably didn't mean to specify a redundant qualifier.
735  typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
736  for (QualLoc Qual : {QualLoc(DeclSpec::TQ_const, DS.getConstSpecLoc()),
739  QualLoc(DeclSpec::TQ_atomic, DS.getAtomicSpecLoc())}) {
740  if (!(RemoveTQs & Qual.first))
741  continue;
742 
743  if (!S.inTemplateInstantiation()) {
744  if (TypeQuals & Qual.first)
745  S.Diag(Qual.second, DiagID)
746  << DeclSpec::getSpecifierName(Qual.first) << TypeSoFar
747  << FixItHint::CreateRemoval(Qual.second);
748  }
749 
750  TypeQuals &= ~Qual.first;
751  }
752 }
753 
754 /// Return true if this is omitted block return type. Also check type
755 /// attributes and type qualifiers when returning true.
756 static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator,
757  QualType Result) {
758  if (!isOmittedBlockReturnType(declarator))
759  return false;
760 
761  // Warn if we see type attributes for omitted return type on a block literal.
762  AttributeList *&attrs =
764  AttributeList *prev = nullptr;
765  for (AttributeList *cur = attrs; cur; cur = cur->getNext()) {
766  AttributeList &attr = *cur;
767  // Skip attributes that were marked to be invalid or non-type
768  // attributes.
769  if (attr.isInvalid() || !attr.isTypeAttr()) {
770  prev = cur;
771  continue;
772  }
773  S.Diag(attr.getLoc(),
774  diag::warn_block_literal_attributes_on_omitted_return_type)
775  << attr.getName();
776  // Remove cur from the list.
777  if (prev) {
778  prev->setNext(cur->getNext());
779  prev = cur;
780  } else {
781  attrs = cur->getNext();
782  }
783  }
784 
785  // Warn if we see type qualifiers for omitted return type on a block literal.
786  const DeclSpec &DS = declarator.getDeclSpec();
787  unsigned TypeQuals = DS.getTypeQualifiers();
788  diagnoseAndRemoveTypeQualifiers(S, DS, TypeQuals, Result, (unsigned)-1,
789  diag::warn_block_literal_qualifiers_on_omitted_return_type);
791 
792  return true;
793 }
794 
795 /// Apply Objective-C type arguments to the given type.
798  SourceRange typeArgsRange,
799  bool failOnError = false) {
800  // We can only apply type arguments to an Objective-C class type.
801  const auto *objcObjectType = type->getAs<ObjCObjectType>();
802  if (!objcObjectType || !objcObjectType->getInterface()) {
803  S.Diag(loc, diag::err_objc_type_args_non_class)
804  << type
805  << typeArgsRange;
806 
807  if (failOnError)
808  return QualType();
809  return type;
810  }
811 
812  // The class type must be parameterized.
813  ObjCInterfaceDecl *objcClass = objcObjectType->getInterface();
814  ObjCTypeParamList *typeParams = objcClass->getTypeParamList();
815  if (!typeParams) {
816  S.Diag(loc, diag::err_objc_type_args_non_parameterized_class)
817  << objcClass->getDeclName()
818  << FixItHint::CreateRemoval(typeArgsRange);
819 
820  if (failOnError)
821  return QualType();
822 
823  return type;
824  }
825 
826  // The type must not already be specialized.
827  if (objcObjectType->isSpecialized()) {
828  S.Diag(loc, diag::err_objc_type_args_specialized_class)
829  << type
830  << FixItHint::CreateRemoval(typeArgsRange);
831 
832  if (failOnError)
833  return QualType();
834 
835  return type;
836  }
837 
838  // Check the type arguments.
839  SmallVector<QualType, 4> finalTypeArgs;
840  unsigned numTypeParams = typeParams->size();
841  bool anyPackExpansions = false;
842  for (unsigned i = 0, n = typeArgs.size(); i != n; ++i) {
843  TypeSourceInfo *typeArgInfo = typeArgs[i];
844  QualType typeArg = typeArgInfo->getType();
845 
846  // Type arguments cannot have explicit qualifiers or nullability.
847  // We ignore indirect sources of these, e.g. behind typedefs or
848  // template arguments.
849  if (TypeLoc qual = typeArgInfo->getTypeLoc().findExplicitQualifierLoc()) {
850  bool diagnosed = false;
851  SourceRange rangeToRemove;
852  if (auto attr = qual.getAs<AttributedTypeLoc>()) {
853  rangeToRemove = attr.getLocalSourceRange();
854  if (attr.getTypePtr()->getImmediateNullability()) {
855  typeArg = attr.getTypePtr()->getModifiedType();
856  S.Diag(attr.getLocStart(),
857  diag::err_objc_type_arg_explicit_nullability)
858  << typeArg << FixItHint::CreateRemoval(rangeToRemove);
859  diagnosed = true;
860  }
861  }
862 
863  if (!diagnosed) {
864  S.Diag(qual.getLocStart(), diag::err_objc_type_arg_qualified)
865  << typeArg << typeArg.getQualifiers().getAsString()
866  << FixItHint::CreateRemoval(rangeToRemove);
867  }
868  }
869 
870  // Remove qualifiers even if they're non-local.
871  typeArg = typeArg.getUnqualifiedType();
872 
873  finalTypeArgs.push_back(typeArg);
874 
875  if (typeArg->getAs<PackExpansionType>())
876  anyPackExpansions = true;
877 
878  // Find the corresponding type parameter, if there is one.
879  ObjCTypeParamDecl *typeParam = nullptr;
880  if (!anyPackExpansions) {
881  if (i < numTypeParams) {
882  typeParam = typeParams->begin()[i];
883  } else {
884  // Too many arguments.
885  S.Diag(loc, diag::err_objc_type_args_wrong_arity)
886  << false
887  << objcClass->getDeclName()
888  << (unsigned)typeArgs.size()
889  << numTypeParams;
890  S.Diag(objcClass->getLocation(), diag::note_previous_decl)
891  << objcClass;
892 
893  if (failOnError)
894  return QualType();
895 
896  return type;
897  }
898  }
899 
900  // Objective-C object pointer types must be substitutable for the bounds.
901  if (const auto *typeArgObjC = typeArg->getAs<ObjCObjectPointerType>()) {
902  // If we don't have a type parameter to match against, assume
903  // everything is fine. There was a prior pack expansion that
904  // means we won't be able to match anything.
905  if (!typeParam) {
906  assert(anyPackExpansions && "Too many arguments?");
907  continue;
908  }
909 
910  // Retrieve the bound.
911  QualType bound = typeParam->getUnderlyingType();
912  const auto *boundObjC = bound->getAs<ObjCObjectPointerType>();
913 
914  // Determine whether the type argument is substitutable for the bound.
915  if (typeArgObjC->isObjCIdType()) {
916  // When the type argument is 'id', the only acceptable type
917  // parameter bound is 'id'.
918  if (boundObjC->isObjCIdType())
919  continue;
920  } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC)) {
921  // Otherwise, we follow the assignability rules.
922  continue;
923  }
924 
925  // Diagnose the mismatch.
926  S.Diag(typeArgInfo->getTypeLoc().getLocStart(),
927  diag::err_objc_type_arg_does_not_match_bound)
928  << typeArg << bound << typeParam->getDeclName();
929  S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here)
930  << typeParam->getDeclName();
931 
932  if (failOnError)
933  return QualType();
934 
935  return type;
936  }
937 
938  // Block pointer types are permitted for unqualified 'id' bounds.
939  if (typeArg->isBlockPointerType()) {
940  // If we don't have a type parameter to match against, assume
941  // everything is fine. There was a prior pack expansion that
942  // means we won't be able to match anything.
943  if (!typeParam) {
944  assert(anyPackExpansions && "Too many arguments?");
945  continue;
946  }
947 
948  // Retrieve the bound.
949  QualType bound = typeParam->getUnderlyingType();
951  continue;
952 
953  // Diagnose the mismatch.
954  S.Diag(typeArgInfo->getTypeLoc().getLocStart(),
955  diag::err_objc_type_arg_does_not_match_bound)
956  << typeArg << bound << typeParam->getDeclName();
957  S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here)
958  << typeParam->getDeclName();
959 
960  if (failOnError)
961  return QualType();
962 
963  return type;
964  }
965 
966  // Dependent types will be checked at instantiation time.
967  if (typeArg->isDependentType()) {
968  continue;
969  }
970 
971  // Diagnose non-id-compatible type arguments.
972  S.Diag(typeArgInfo->getTypeLoc().getLocStart(),
973  diag::err_objc_type_arg_not_id_compatible)
974  << typeArg
975  << typeArgInfo->getTypeLoc().getSourceRange();
976 
977  if (failOnError)
978  return QualType();
979 
980  return type;
981  }
982 
983  // Make sure we didn't have the wrong number of arguments.
984  if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) {
985  S.Diag(loc, diag::err_objc_type_args_wrong_arity)
986  << (typeArgs.size() < typeParams->size())
987  << objcClass->getDeclName()
988  << (unsigned)finalTypeArgs.size()
989  << (unsigned)numTypeParams;
990  S.Diag(objcClass->getLocation(), diag::note_previous_decl)
991  << objcClass;
992 
993  if (failOnError)
994  return QualType();
995 
996  return type;
997  }
998 
999  // Success. Form the specialized type.
1000  return S.Context.getObjCObjectType(type, finalTypeArgs, { }, false);
1001 }
1002 
1004  SourceLocation ProtocolLAngleLoc,
1005  ArrayRef<ObjCProtocolDecl *> Protocols,
1006  ArrayRef<SourceLocation> ProtocolLocs,
1007  SourceLocation ProtocolRAngleLoc,
1008  bool FailOnError) {
1009  QualType Result = QualType(Decl->getTypeForDecl(), 0);
1010  if (!Protocols.empty()) {
1011  bool HasError;
1012  Result = Context.applyObjCProtocolQualifiers(Result, Protocols,
1013  HasError);
1014  if (HasError) {
1015  Diag(SourceLocation(), diag::err_invalid_protocol_qualifiers)
1016  << SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1017  if (FailOnError) Result = QualType();
1018  }
1019  if (FailOnError && Result.isNull())
1020  return QualType();
1021  }
1022 
1023  return Result;
1024 }
1025 
1027  SourceLocation Loc,
1028  SourceLocation TypeArgsLAngleLoc,
1029  ArrayRef<TypeSourceInfo *> TypeArgs,
1030  SourceLocation TypeArgsRAngleLoc,
1031  SourceLocation ProtocolLAngleLoc,
1032  ArrayRef<ObjCProtocolDecl *> Protocols,
1033  ArrayRef<SourceLocation> ProtocolLocs,
1034  SourceLocation ProtocolRAngleLoc,
1035  bool FailOnError) {
1036  QualType Result = BaseType;
1037  if (!TypeArgs.empty()) {
1038  Result = applyObjCTypeArgs(*this, Loc, Result, TypeArgs,
1039  SourceRange(TypeArgsLAngleLoc,
1040  TypeArgsRAngleLoc),
1041  FailOnError);
1042  if (FailOnError && Result.isNull())
1043  return QualType();
1044  }
1045 
1046  if (!Protocols.empty()) {
1047  bool HasError;
1048  Result = Context.applyObjCProtocolQualifiers(Result, Protocols,
1049  HasError);
1050  if (HasError) {
1051  Diag(Loc, diag::err_invalid_protocol_qualifiers)
1052  << SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1053  if (FailOnError) Result = QualType();
1054  }
1055  if (FailOnError && Result.isNull())
1056  return QualType();
1057  }
1058 
1059  return Result;
1060 }
1061 
1063  SourceLocation lAngleLoc,
1064  ArrayRef<Decl *> protocols,
1065  ArrayRef<SourceLocation> protocolLocs,
1066  SourceLocation rAngleLoc) {
1067  // Form id<protocol-list>.
1069  Context.ObjCBuiltinIdTy, { },
1070  llvm::makeArrayRef(
1071  (ObjCProtocolDecl * const *)protocols.data(),
1072  protocols.size()),
1073  false);
1075 
1076  TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
1077  TypeLoc ResultTL = ResultTInfo->getTypeLoc();
1078 
1079  auto ObjCObjectPointerTL = ResultTL.castAs<ObjCObjectPointerTypeLoc>();
1080  ObjCObjectPointerTL.setStarLoc(SourceLocation()); // implicit
1081 
1082  auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc()
1083  .castAs<ObjCObjectTypeLoc>();
1084  ObjCObjectTL.setHasBaseTypeAsWritten(false);
1085  ObjCObjectTL.getBaseLoc().initialize(Context, SourceLocation());
1086 
1087  // No type arguments.
1088  ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation());
1089  ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation());
1090 
1091  // Fill in protocol qualifiers.
1092  ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc);
1093  ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc);
1094  for (unsigned i = 0, n = protocols.size(); i != n; ++i)
1095  ObjCObjectTL.setProtocolLoc(i, protocolLocs[i]);
1096 
1097  // We're done. Return the completed type to the parser.
1098  return CreateParsedType(Result, ResultTInfo);
1099 }
1100 
1102  Scope *S,
1103  SourceLocation Loc,
1104  ParsedType BaseType,
1105  SourceLocation TypeArgsLAngleLoc,
1106  ArrayRef<ParsedType> TypeArgs,
1107  SourceLocation TypeArgsRAngleLoc,
1108  SourceLocation ProtocolLAngleLoc,
1109  ArrayRef<Decl *> Protocols,
1110  ArrayRef<SourceLocation> ProtocolLocs,
1111  SourceLocation ProtocolRAngleLoc) {
1112  TypeSourceInfo *BaseTypeInfo = nullptr;
1113  QualType T = GetTypeFromParser(BaseType, &BaseTypeInfo);
1114  if (T.isNull())
1115  return true;
1116 
1117  // Handle missing type-source info.
1118  if (!BaseTypeInfo)
1119  BaseTypeInfo = Context.getTrivialTypeSourceInfo(T, Loc);
1120 
1121  // Extract type arguments.
1122  SmallVector<TypeSourceInfo *, 4> ActualTypeArgInfos;
1123  for (unsigned i = 0, n = TypeArgs.size(); i != n; ++i) {
1124  TypeSourceInfo *TypeArgInfo = nullptr;
1125  QualType TypeArg = GetTypeFromParser(TypeArgs[i], &TypeArgInfo);
1126  if (TypeArg.isNull()) {
1127  ActualTypeArgInfos.clear();
1128  break;
1129  }
1130 
1131  assert(TypeArgInfo && "No type source info?");
1132  ActualTypeArgInfos.push_back(TypeArgInfo);
1133  }
1134 
1135  // Build the object type.
1137  T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(),
1138  TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
1139  ProtocolLAngleLoc,
1140  llvm::makeArrayRef((ObjCProtocolDecl * const *)Protocols.data(),
1141  Protocols.size()),
1142  ProtocolLocs, ProtocolRAngleLoc,
1143  /*FailOnError=*/false);
1144 
1145  if (Result == T)
1146  return BaseType;
1147 
1148  // Create source information for this type.
1149  TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
1150  TypeLoc ResultTL = ResultTInfo->getTypeLoc();
1151 
1152  // For id<Proto1, Proto2> or Class<Proto1, Proto2>, we'll have an
1153  // object pointer type. Fill in source information for it.
1154  if (auto ObjCObjectPointerTL = ResultTL.getAs<ObjCObjectPointerTypeLoc>()) {
1155  // The '*' is implicit.
1156  ObjCObjectPointerTL.setStarLoc(SourceLocation());
1157  ResultTL = ObjCObjectPointerTL.getPointeeLoc();
1158  }
1159 
1160  if (auto OTPTL = ResultTL.getAs<ObjCTypeParamTypeLoc>()) {
1161  // Protocol qualifier information.
1162  if (OTPTL.getNumProtocols() > 0) {
1163  assert(OTPTL.getNumProtocols() == Protocols.size());
1164  OTPTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1165  OTPTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1166  for (unsigned i = 0, n = Protocols.size(); i != n; ++i)
1167  OTPTL.setProtocolLoc(i, ProtocolLocs[i]);
1168  }
1169 
1170  // We're done. Return the completed type to the parser.
1171  return CreateParsedType(Result, ResultTInfo);
1172  }
1173 
1174  auto ObjCObjectTL = ResultTL.castAs<ObjCObjectTypeLoc>();
1175 
1176  // Type argument information.
1177  if (ObjCObjectTL.getNumTypeArgs() > 0) {
1178  assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size());
1179  ObjCObjectTL.setTypeArgsLAngleLoc(TypeArgsLAngleLoc);
1180  ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc);
1181  for (unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i)
1182  ObjCObjectTL.setTypeArgTInfo(i, ActualTypeArgInfos[i]);
1183  } else {
1184  ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation());
1185  ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation());
1186  }
1187 
1188  // Protocol qualifier information.
1189  if (ObjCObjectTL.getNumProtocols() > 0) {
1190  assert(ObjCObjectTL.getNumProtocols() == Protocols.size());
1191  ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1192  ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1193  for (unsigned i = 0, n = Protocols.size(); i != n; ++i)
1194  ObjCObjectTL.setProtocolLoc(i, ProtocolLocs[i]);
1195  } else {
1196  ObjCObjectTL.setProtocolLAngleLoc(SourceLocation());
1197  ObjCObjectTL.setProtocolRAngleLoc(SourceLocation());
1198  }
1199 
1200  // Base type.
1201  ObjCObjectTL.setHasBaseTypeAsWritten(true);
1202  if (ObjCObjectTL.getType() == T)
1203  ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->getTypeLoc());
1204  else
1205  ObjCObjectTL.getBaseLoc().initialize(Context, Loc);
1206 
1207  // We're done. Return the completed type to the parser.
1208  return CreateParsedType(Result, ResultTInfo);
1209 }
1210 
1211 static OpenCLAccessAttr::Spelling getImageAccess(const AttributeList *Attrs) {
1212  if (Attrs) {
1213  const AttributeList *Next = Attrs;
1214  do {
1215  const AttributeList &Attr = *Next;
1216  Next = Attr.getNext();
1217  if (Attr.getKind() == AttributeList::AT_OpenCLAccess) {
1218  return static_cast<OpenCLAccessAttr::Spelling>(
1219  Attr.getSemanticSpelling());
1220  }
1221  } while (Next);
1222  }
1223  return OpenCLAccessAttr::Keyword_read_only;
1224 }
1225 
1226 /// \brief Convert the specified declspec to the appropriate type
1227 /// object.
1228 /// \param state Specifies the declarator containing the declaration specifier
1229 /// to be converted, along with other associated processing state.
1230 /// \returns The type described by the declaration specifiers. This function
1231 /// never returns null.
1232 static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
1233  // FIXME: Should move the logic from DeclSpec::Finish to here for validity
1234  // checking.
1235 
1236  Sema &S = state.getSema();
1237  Declarator &declarator = state.getDeclarator();
1238  const DeclSpec &DS = declarator.getDeclSpec();
1239  SourceLocation DeclLoc = declarator.getIdentifierLoc();
1240  if (DeclLoc.isInvalid())
1241  DeclLoc = DS.getLocStart();
1242 
1243  ASTContext &Context = S.Context;
1244 
1245  QualType Result;
1246  switch (DS.getTypeSpecType()) {
1247  case DeclSpec::TST_void:
1248  Result = Context.VoidTy;
1249  break;
1250  case DeclSpec::TST_char:
1252  Result = Context.CharTy;
1253  else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed)
1254  Result = Context.SignedCharTy;
1255  else {
1256  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
1257  "Unknown TSS value");
1258  Result = Context.UnsignedCharTy;
1259  }
1260  break;
1261  case DeclSpec::TST_wchar:
1263  Result = Context.WCharTy;
1264  else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) {
1265  S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
1266  << DS.getSpecifierName(DS.getTypeSpecType(),
1267  Context.getPrintingPolicy());
1268  Result = Context.getSignedWCharType();
1269  } else {
1270  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
1271  "Unknown TSS value");
1272  S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
1273  << DS.getSpecifierName(DS.getTypeSpecType(),
1274  Context.getPrintingPolicy());
1275  Result = Context.getUnsignedWCharType();
1276  }
1277  break;
1278  case DeclSpec::TST_char16:
1279  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
1280  "Unknown TSS value");
1281  Result = Context.Char16Ty;
1282  break;
1283  case DeclSpec::TST_char32:
1284  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
1285  "Unknown TSS value");
1286  Result = Context.Char32Ty;
1287  break;
1289  // If this is a missing declspec in a block literal return context, then it
1290  // is inferred from the return statements inside the block.
1291  // The declspec is always missing in a lambda expr context; it is either
1292  // specified with a trailing return type or inferred.
1293  if (S.getLangOpts().CPlusPlus14 &&
1294  declarator.getContext() == Declarator::LambdaExprContext) {
1295  // In C++1y, a lambda's implicit return type is 'auto'.
1296  Result = Context.getAutoDeductType();
1297  break;
1298  } else if (declarator.getContext() == Declarator::LambdaExprContext ||
1299  checkOmittedBlockReturnType(S, declarator,
1300  Context.DependentTy)) {
1301  Result = Context.DependentTy;
1302  break;
1303  }
1304 
1305  // Unspecified typespec defaults to int in C90. However, the C90 grammar
1306  // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
1307  // type-qualifier, or storage-class-specifier. If not, emit an extwarn.
1308  // Note that the one exception to this is function definitions, which are
1309  // allowed to be completely missing a declspec. This is handled in the
1310  // parser already though by it pretending to have seen an 'int' in this
1311  // case.
1312  if (S.getLangOpts().ImplicitInt) {
1313  // In C89 mode, we only warn if there is a completely missing declspec
1314  // when one is not allowed.
1315  if (DS.isEmpty()) {
1316  S.Diag(DeclLoc, diag::ext_missing_declspec)
1317  << DS.getSourceRange()
1318  << FixItHint::CreateInsertion(DS.getLocStart(), "int");
1319  }
1320  } else if (!DS.hasTypeSpecifier()) {
1321  // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says:
1322  // "At least one type specifier shall be given in the declaration
1323  // specifiers in each declaration, and in the specifier-qualifier list in
1324  // each struct declaration and type name."
1325  if (S.getLangOpts().CPlusPlus) {
1326  S.Diag(DeclLoc, diag::err_missing_type_specifier)
1327  << DS.getSourceRange();
1328 
1329  // When this occurs in C++ code, often something is very broken with the
1330  // value being declared, poison it as invalid so we don't get chains of
1331  // errors.
1332  declarator.setInvalidType(true);
1333  } else if (S.getLangOpts().OpenCLVersion >= 200 && DS.isTypeSpecPipe()){
1334  S.Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1335  << DS.getSourceRange();
1336  declarator.setInvalidType(true);
1337  } else {
1338  S.Diag(DeclLoc, diag::ext_missing_type_specifier)
1339  << DS.getSourceRange();
1340  }
1341  }
1342 
1343  // FALL THROUGH.
1344  case DeclSpec::TST_int: {
1346  switch (DS.getTypeSpecWidth()) {
1347  case DeclSpec::TSW_unspecified: Result = Context.IntTy; break;
1348  case DeclSpec::TSW_short: Result = Context.ShortTy; break;
1349  case DeclSpec::TSW_long: Result = Context.LongTy; break;
1351  Result = Context.LongLongTy;
1352 
1353  // 'long long' is a C99 or C++11 feature.
1354  if (!S.getLangOpts().C99) {
1355  if (S.getLangOpts().CPlusPlus)
1356  S.Diag(DS.getTypeSpecWidthLoc(),
1357  S.getLangOpts().CPlusPlus11 ?
1358  diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1359  else
1360  S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
1361  }
1362  break;
1363  }
1364  } else {
1365  switch (DS.getTypeSpecWidth()) {
1366  case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
1367  case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break;
1368  case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break;
1370  Result = Context.UnsignedLongLongTy;
1371 
1372  // 'long long' is a C99 or C++11 feature.
1373  if (!S.getLangOpts().C99) {
1374  if (S.getLangOpts().CPlusPlus)
1375  S.Diag(DS.getTypeSpecWidthLoc(),
1376  S.getLangOpts().CPlusPlus11 ?
1377  diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1378  else
1379  S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
1380  }
1381  break;
1382  }
1383  }
1384  break;
1385  }
1386  case DeclSpec::TST_int128:
1387  if (!S.Context.getTargetInfo().hasInt128Type())
1388  S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1389  << "__int128";
1391  Result = Context.UnsignedInt128Ty;
1392  else
1393  Result = Context.Int128Ty;
1394  break;
1395  case DeclSpec::TST_half: Result = Context.HalfTy; break;
1396  case DeclSpec::TST_float: Result = Context.FloatTy; break;
1397  case DeclSpec::TST_double:
1399  Result = Context.LongDoubleTy;
1400  else
1401  Result = Context.DoubleTy;
1402  break;
1405  S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1406  << "__float128";
1407  Result = Context.Float128Ty;
1408  break;
1409  case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
1410  break;
1411  case DeclSpec::TST_decimal32: // _Decimal32
1412  case DeclSpec::TST_decimal64: // _Decimal64
1413  case DeclSpec::TST_decimal128: // _Decimal128
1414  S.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported);
1415  Result = Context.IntTy;
1416  declarator.setInvalidType(true);
1417  break;
1418  case DeclSpec::TST_class:
1419  case DeclSpec::TST_enum:
1420  case DeclSpec::TST_union:
1421  case DeclSpec::TST_struct:
1422  case DeclSpec::TST_interface: {
1423  TypeDecl *D = dyn_cast_or_null<TypeDecl>(DS.getRepAsDecl());
1424  if (!D) {
1425  // This can happen in C++ with ambiguous lookups.
1426  Result = Context.IntTy;
1427  declarator.setInvalidType(true);
1428  break;
1429  }
1430 
1431  // If the type is deprecated or unavailable, diagnose it.
1433 
1434  assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
1435  DS.getTypeSpecSign() == 0 && "No qualifiers on tag names!");
1436 
1437  // TypeQuals handled by caller.
1438  Result = Context.getTypeDeclType(D);
1439 
1440  // In both C and C++, make an ElaboratedType.
1441  ElaboratedTypeKeyword Keyword
1443  Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result);
1444  break;
1445  }
1446  case DeclSpec::TST_typename: {
1447  assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
1448  DS.getTypeSpecSign() == 0 &&
1449  "Can't handle qualifiers on typedef names yet!");
1450  Result = S.GetTypeFromParser(DS.getRepAsType());
1451  if (Result.isNull()) {
1452  declarator.setInvalidType(true);
1453  }
1454 
1455  // TypeQuals handled by caller.
1456  break;
1457  }
1459  // FIXME: Preserve type source info.
1460  Result = S.GetTypeFromParser(DS.getRepAsType());
1461  assert(!Result.isNull() && "Didn't get a type for typeof?");
1462  if (!Result->isDependentType())
1463  if (const TagType *TT = Result->getAs<TagType>())
1464  S.DiagnoseUseOfDecl(TT->getDecl(), DS.getTypeSpecTypeLoc());
1465  // TypeQuals handled by caller.
1466  Result = Context.getTypeOfType(Result);
1467  break;
1468  case DeclSpec::TST_typeofExpr: {
1469  Expr *E = DS.getRepAsExpr();
1470  assert(E && "Didn't get an expression for typeof?");
1471  // TypeQuals handled by caller.
1472  Result = S.BuildTypeofExprType(E, DS.getTypeSpecTypeLoc());
1473  if (Result.isNull()) {
1474  Result = Context.IntTy;
1475  declarator.setInvalidType(true);
1476  }
1477  break;
1478  }
1479  case DeclSpec::TST_decltype: {
1480  Expr *E = DS.getRepAsExpr();
1481  assert(E && "Didn't get an expression for decltype?");
1482  // TypeQuals handled by caller.
1483  Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc());
1484  if (Result.isNull()) {
1485  Result = Context.IntTy;
1486  declarator.setInvalidType(true);
1487  }
1488  break;
1489  }
1491  Result = S.GetTypeFromParser(DS.getRepAsType());
1492  assert(!Result.isNull() && "Didn't get a type for __underlying_type?");
1493  Result = S.BuildUnaryTransformType(Result,
1495  DS.getTypeSpecTypeLoc());
1496  if (Result.isNull()) {
1497  Result = Context.IntTy;
1498  declarator.setInvalidType(true);
1499  }
1500  break;
1501 
1502  case DeclSpec::TST_auto:
1503  Result = Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false);
1504  break;
1505 
1507  Result = Context.getAutoType(QualType(), AutoTypeKeyword::GNUAutoType, false);
1508  break;
1509 
1512  /*IsDependent*/ false);
1513  break;
1514 
1516  Result = Context.UnknownAnyTy;
1517  break;
1518 
1519  case DeclSpec::TST_atomic:
1520  Result = S.GetTypeFromParser(DS.getRepAsType());
1521  assert(!Result.isNull() && "Didn't get a type for _Atomic?");
1522  Result = S.BuildAtomicType(Result, DS.getTypeSpecTypeLoc());
1523  if (Result.isNull()) {
1524  Result = Context.IntTy;
1525  declarator.setInvalidType(true);
1526  }
1527  break;
1528 
1529 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
1530  case DeclSpec::TST_##ImgType##_t: \
1531  switch (getImageAccess(DS.getAttributes().getList())) { \
1532  case OpenCLAccessAttr::Keyword_write_only: \
1533  Result = Context.Id##WOTy; break; \
1534  case OpenCLAccessAttr::Keyword_read_write: \
1535  Result = Context.Id##RWTy; break; \
1536  case OpenCLAccessAttr::Keyword_read_only: \
1537  Result = Context.Id##ROTy; break; \
1538  } \
1539  break;
1540 #include "clang/Basic/OpenCLImageTypes.def"
1541 
1542  case DeclSpec::TST_error:
1543  Result = Context.IntTy;
1544  declarator.setInvalidType(true);
1545  break;
1546  }
1547 
1548  if (S.getLangOpts().OpenCL &&
1549  S.checkOpenCLDisabledTypeDeclSpec(DS, Result))
1550  declarator.setInvalidType(true);
1551 
1552  // Handle complex types.
1554  if (S.getLangOpts().Freestanding)
1555  S.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
1556  Result = Context.getComplexType(Result);
1557  } else if (DS.isTypeAltiVecVector()) {
1558  unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(Result));
1559  assert(typeSize > 0 && "type size for vector must be greater than 0 bits");
1561  if (DS.isTypeAltiVecPixel())
1562  VecKind = VectorType::AltiVecPixel;
1563  else if (DS.isTypeAltiVecBool())
1564  VecKind = VectorType::AltiVecBool;
1565  Result = Context.getVectorType(Result, 128/typeSize, VecKind);
1566  }
1567 
1568  // FIXME: Imaginary.
1570  S.Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported);
1571 
1572  // Before we process any type attributes, synthesize a block literal
1573  // function declarator if necessary.
1574  if (declarator.getContext() == Declarator::BlockLiteralContext)
1576 
1577  // Apply any type attributes from the decl spec. This may cause the
1578  // list of type attributes to be temporarily saved while the type
1579  // attributes are pushed around.
1580  // pipe attributes will be handled later ( at GetFullTypeForDeclarator )
1581  if (!DS.isTypeSpecPipe())
1583 
1584  // Apply const/volatile/restrict qualifiers to T.
1585  if (unsigned TypeQuals = DS.getTypeQualifiers()) {
1586  // Warn about CV qualifiers on function types.
1587  // C99 6.7.3p8:
1588  // If the specification of a function type includes any type qualifiers,
1589  // the behavior is undefined.
1590  // C++11 [dcl.fct]p7:
1591  // The effect of a cv-qualifier-seq in a function declarator is not the
1592  // same as adding cv-qualification on top of the function type. In the
1593  // latter case, the cv-qualifiers are ignored.
1594  if (TypeQuals && Result->isFunctionType()) {
1596  S, DS, TypeQuals, Result, DeclSpec::TQ_const | DeclSpec::TQ_volatile,
1597  S.getLangOpts().CPlusPlus
1598  ? diag::warn_typecheck_function_qualifiers_ignored
1599  : diag::warn_typecheck_function_qualifiers_unspecified);
1600  // No diagnostic for 'restrict' or '_Atomic' applied to a
1601  // function type; we'll diagnose those later, in BuildQualifiedType.
1602  }
1603 
1604  // C++11 [dcl.ref]p1:
1605  // Cv-qualified references are ill-formed except when the
1606  // cv-qualifiers are introduced through the use of a typedef-name
1607  // or decltype-specifier, in which case the cv-qualifiers are ignored.
1608  //
1609  // There don't appear to be any other contexts in which a cv-qualified
1610  // reference type could be formed, so the 'ill-formed' clause here appears
1611  // to never happen.
1612  if (TypeQuals && Result->isReferenceType()) {
1614  S, DS, TypeQuals, Result,
1616  diag::warn_typecheck_reference_qualifiers);
1617  }
1618 
1619  // C90 6.5.3 constraints: "The same type qualifier shall not appear more
1620  // than once in the same specifier-list or qualifier-list, either directly
1621  // or via one or more typedefs."
1622  if (!S.getLangOpts().C99 && !S.getLangOpts().CPlusPlus
1623  && TypeQuals & Result.getCVRQualifiers()) {
1624  if (TypeQuals & DeclSpec::TQ_const && Result.isConstQualified()) {
1625  S.Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec)
1626  << "const";
1627  }
1628 
1629  if (TypeQuals & DeclSpec::TQ_volatile && Result.isVolatileQualified()) {
1630  S.Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec)
1631  << "volatile";
1632  }
1633 
1634  // C90 doesn't have restrict nor _Atomic, so it doesn't force us to
1635  // produce a warning in this case.
1636  }
1637 
1638  QualType Qualified = S.BuildQualifiedType(Result, DeclLoc, TypeQuals, &DS);
1639 
1640  // If adding qualifiers fails, just use the unqualified type.
1641  if (Qualified.isNull())
1642  declarator.setInvalidType(true);
1643  else
1644  Result = Qualified;
1645  }
1646 
1647  assert(!Result.isNull() && "This function should not return a null type");
1648  return Result;
1649 }
1650 
1651 static std::string getPrintableNameForEntity(DeclarationName Entity) {
1652  if (Entity)
1653  return Entity.getAsString();
1654 
1655  return "type name";
1656 }
1657 
1658 QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc,
1659  Qualifiers Qs, const DeclSpec *DS) {
1660  if (T.isNull())
1661  return QualType();
1662 
1663  // Ignore any attempt to form a cv-qualified reference.
1664  if (T->isReferenceType()) {
1665  Qs.removeConst();
1666  Qs.removeVolatile();
1667  }
1668 
1669  // Enforce C99 6.7.3p2: "Types other than pointer types derived from
1670  // object or incomplete types shall not be restrict-qualified."
1671  if (Qs.hasRestrict()) {
1672  unsigned DiagID = 0;
1673  QualType ProblemTy;
1674 
1675  if (T->isAnyPointerType() || T->isReferenceType() ||
1676  T->isMemberPointerType()) {
1677  QualType EltTy;
1678  if (T->isObjCObjectPointerType())
1679  EltTy = T;
1680  else if (const MemberPointerType *PTy = T->getAs<MemberPointerType>())
1681  EltTy = PTy->getPointeeType();
1682  else
1683  EltTy = T->getPointeeType();
1684 
1685  // If we have a pointer or reference, the pointee must have an object
1686  // incomplete type.
1687  if (!EltTy->isIncompleteOrObjectType()) {
1688  DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1689  ProblemTy = EltTy;
1690  }
1691  } else if (!T->isDependentType()) {
1692  DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1693  ProblemTy = T;
1694  }
1695 
1696  if (DiagID) {
1697  Diag(DS ? DS->getRestrictSpecLoc() : Loc, DiagID) << ProblemTy;
1698  Qs.removeRestrict();
1699  }
1700  }
1701 
1702  return Context.getQualifiedType(T, Qs);
1703 }
1704 
1706  unsigned CVRAU, const DeclSpec *DS) {
1707  if (T.isNull())
1708  return QualType();
1709 
1710  // Ignore any attempt to form a cv-qualified reference.
1711  if (T->isReferenceType())
1712  CVRAU &=
1714 
1715  // Convert from DeclSpec::TQ to Qualifiers::TQ by just dropping TQ_atomic and
1716  // TQ_unaligned;
1717  unsigned CVR = CVRAU & ~(DeclSpec::TQ_atomic | DeclSpec::TQ_unaligned);
1718 
1719  // C11 6.7.3/5:
1720  // If the same qualifier appears more than once in the same
1721  // specifier-qualifier-list, either directly or via one or more typedefs,
1722  // the behavior is the same as if it appeared only once.
1723  //
1724  // It's not specified what happens when the _Atomic qualifier is applied to
1725  // a type specified with the _Atomic specifier, but we assume that this
1726  // should be treated as if the _Atomic qualifier appeared multiple times.
1727  if (CVRAU & DeclSpec::TQ_atomic && !T->isAtomicType()) {
1728  // C11 6.7.3/5:
1729  // If other qualifiers appear along with the _Atomic qualifier in a
1730  // specifier-qualifier-list, the resulting type is the so-qualified
1731  // atomic type.
1732  //
1733  // Don't need to worry about array types here, since _Atomic can't be
1734  // applied to such types.
1736  T = BuildAtomicType(QualType(Split.Ty, 0),
1737  DS ? DS->getAtomicSpecLoc() : Loc);
1738  if (T.isNull())
1739  return T;
1740  Split.Quals.addCVRQualifiers(CVR);
1741  return BuildQualifiedType(T, Loc, Split.Quals);
1742  }
1743 
1746  return BuildQualifiedType(T, Loc, Q, DS);
1747 }
1748 
1749 /// \brief Build a paren type including \p T.
1751  return Context.getParenType(T);
1752 }
1753 
1754 /// Given that we're building a pointer or reference to the given
1756  SourceLocation loc,
1757  bool isReference) {
1758  // Bail out if retention is unrequired or already specified.
1759  if (!type->isObjCLifetimeType() ||
1761  return type;
1762 
1764 
1765  // If the object type is const-qualified, we can safely use
1766  // __unsafe_unretained. This is safe (because there are no read
1767  // barriers), and it'll be safe to coerce anything but __weak* to
1768  // the resulting type.
1769  if (type.isConstQualified()) {
1770  implicitLifetime = Qualifiers::OCL_ExplicitNone;
1771 
1772  // Otherwise, check whether the static type does not require
1773  // retaining. This currently only triggers for Class (possibly
1774  // protocol-qualifed, and arrays thereof).
1775  } else if (type->isObjCARCImplicitlyUnretainedType()) {
1776  implicitLifetime = Qualifiers::OCL_ExplicitNone;
1777 
1778  // If we are in an unevaluated context, like sizeof, skip adding a
1779  // qualification.
1780  } else if (S.isUnevaluatedContext()) {
1781  return type;
1782 
1783  // If that failed, give an error and recover using __strong. __strong
1784  // is the option most likely to prevent spurious second-order diagnostics,
1785  // like when binding a reference to a field.
1786  } else {
1787  // These types can show up in private ivars in system headers, so
1788  // we need this to not be an error in those cases. Instead we
1789  // want to delay.
1793  diag::err_arc_indirect_no_ownership, type, isReference));
1794  } else {
1795  S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;
1796  }
1797  implicitLifetime = Qualifiers::OCL_Strong;
1798  }
1799  assert(implicitLifetime && "didn't infer any lifetime!");
1800 
1801  Qualifiers qs;
1802  qs.addObjCLifetime(implicitLifetime);
1803  return S.Context.getQualifiedType(type, qs);
1804 }
1805 
1806 static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy){
1807  std::string Quals =
1808  Qualifiers::fromCVRMask(FnTy->getTypeQuals()).getAsString();
1809 
1810  switch (FnTy->getRefQualifier()) {
1811  case RQ_None:
1812  break;
1813 
1814  case RQ_LValue:
1815  if (!Quals.empty())
1816  Quals += ' ';
1817  Quals += '&';
1818  break;
1819 
1820  case RQ_RValue:
1821  if (!Quals.empty())
1822  Quals += ' ';
1823  Quals += "&&";
1824  break;
1825  }
1826 
1827  return Quals;
1828 }
1829 
1830 namespace {
1831 /// Kinds of declarator that cannot contain a qualified function type.
1832 ///
1833 /// C++98 [dcl.fct]p4 / C++11 [dcl.fct]p6:
1834 /// a function type with a cv-qualifier or a ref-qualifier can only appear
1835 /// at the topmost level of a type.
1836 ///
1837 /// Parens and member pointers are permitted. We don't diagnose array and
1838 /// function declarators, because they don't allow function types at all.
1839 ///
1840 /// The values of this enum are used in diagnostics.
1841 enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
1842 } // end anonymous namespace
1843 
1844 /// Check whether the type T is a qualified function type, and if it is,
1845 /// diagnose that it cannot be contained within the given kind of declarator.
1847  QualifiedFunctionKind QFK) {
1848  // Does T refer to a function type with a cv-qualifier or a ref-qualifier?
1849  const FunctionProtoType *FPT = T->getAs<FunctionProtoType>();
1850  if (!FPT || (FPT->getTypeQuals() == 0 && FPT->getRefQualifier() == RQ_None))
1851  return false;
1852 
1853  S.Diag(Loc, diag::err_compound_qualified_function_type)
1854  << QFK << isa<FunctionType>(T.IgnoreParens()) << T
1856  return true;
1857 }
1858 
1859 /// \brief Build a pointer type.
1860 ///
1861 /// \param T The type to which we'll be building a pointer.
1862 ///
1863 /// \param Loc The location of the entity whose type involves this
1864 /// pointer type or, if there is no such entity, the location of the
1865 /// type that will have pointer type.
1866 ///
1867 /// \param Entity The name of the entity that involves the pointer
1868 /// type, if known.
1869 ///
1870 /// \returns A suitable pointer type, if there are no
1871 /// errors. Otherwise, returns a NULL type.
1873  SourceLocation Loc, DeclarationName Entity) {
1874  if (T->isReferenceType()) {
1875  // C++ 8.3.2p4: There shall be no ... pointers to references ...
1876  Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
1877  << getPrintableNameForEntity(Entity) << T;
1878  return QualType();
1879  }
1880 
1881  if (T->isFunctionType() && getLangOpts().OpenCL) {
1882  Diag(Loc, diag::err_opencl_function_pointer);
1883  return QualType();
1884  }
1885 
1886  if (checkQualifiedFunction(*this, T, Loc, QFK_Pointer))
1887  return QualType();
1888 
1889  assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType");
1890 
1891  // In ARC, it is forbidden to build pointers to unqualified pointers.
1892  if (getLangOpts().ObjCAutoRefCount)
1893  T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ false);
1894 
1895  // Build the pointer type.
1896  return Context.getPointerType(T);
1897 }
1898 
1899 /// \brief Build a reference type.
1900 ///
1901 /// \param T The type to which we'll be building a reference.
1902 ///
1903 /// \param Loc The location of the entity whose type involves this
1904 /// reference type or, if there is no such entity, the location of the
1905 /// type that will have reference type.
1906 ///
1907 /// \param Entity The name of the entity that involves the reference
1908 /// type, if known.
1909 ///
1910 /// \returns A suitable reference type, if there are no
1911 /// errors. Otherwise, returns a NULL type.
1913  SourceLocation Loc,
1914  DeclarationName Entity) {
1915  assert(Context.getCanonicalType(T) != Context.OverloadTy &&
1916  "Unresolved overloaded function type");
1917 
1918  // C++0x [dcl.ref]p6:
1919  // If a typedef (7.1.3), a type template-parameter (14.3.1), or a
1920  // decltype-specifier (7.1.6.2) denotes a type TR that is a reference to a
1921  // type T, an attempt to create the type "lvalue reference to cv TR" creates
1922  // the type "lvalue reference to T", while an attempt to create the type
1923  // "rvalue reference to cv TR" creates the type TR.
1924  bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>();
1925 
1926  // C++ [dcl.ref]p4: There shall be no references to references.
1927  //
1928  // According to C++ DR 106, references to references are only
1929  // diagnosed when they are written directly (e.g., "int & &"),
1930  // but not when they happen via a typedef:
1931  //
1932  // typedef int& intref;
1933  // typedef intref& intref2;
1934  //
1935  // Parser::ParseDeclaratorInternal diagnoses the case where
1936  // references are written directly; here, we handle the
1937  // collapsing of references-to-references as described in C++0x.
1938  // DR 106 and 540 introduce reference-collapsing into C++98/03.
1939 
1940  // C++ [dcl.ref]p1:
1941  // A declarator that specifies the type "reference to cv void"
1942  // is ill-formed.
1943  if (T->isVoidType()) {
1944  Diag(Loc, diag::err_reference_to_void);
1945  return QualType();
1946  }
1947 
1948  if (checkQualifiedFunction(*this, T, Loc, QFK_Reference))
1949  return QualType();
1950 
1951  // In ARC, it is forbidden to build references to unqualified pointers.
1952  if (getLangOpts().ObjCAutoRefCount)
1953  T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ true);
1954 
1955  // Handle restrict on references.
1956  if (LValueRef)
1957  return Context.getLValueReferenceType(T, SpelledAsLValue);
1958  return Context.getRValueReferenceType(T);
1959 }
1960 
1961 /// \brief Build a Read-only Pipe type.
1962 ///
1963 /// \param T The type to which we'll be building a Pipe.
1964 ///
1965 /// \param Loc We do not use it for now.
1966 ///
1967 /// \returns A suitable pipe type, if there are no errors. Otherwise, returns a
1968 /// NULL type.
1970  return Context.getReadPipeType(T);
1971 }
1972 
1973 /// \brief Build a Write-only Pipe type.
1974 ///
1975 /// \param T The type to which we'll be building a Pipe.
1976 ///
1977 /// \param Loc We do not use it for now.
1978 ///
1979 /// \returns A suitable pipe type, if there are no errors. Otherwise, returns a
1980 /// NULL type.
1982  return Context.getWritePipeType(T);
1983 }
1984 
1985 /// Check whether the specified array size makes the array type a VLA. If so,
1986 /// return true, if not, return the size of the array in SizeVal.
1987 static bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal) {
1988  // If the size is an ICE, it certainly isn't a VLA. If we're in a GNU mode
1989  // (like gnu99, but not c99) accept any evaluatable value as an extension.
1990  class VLADiagnoser : public Sema::VerifyICEDiagnoser {
1991  public:
1992  VLADiagnoser() : Sema::VerifyICEDiagnoser(true) {}
1993 
1994  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
1995  }
1996 
1997  void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR) override {
1998  S.Diag(Loc, diag::ext_vla_folded_to_constant) << SR;
1999  }
2000  } Diagnoser;
2001 
2002  return S.VerifyIntegerConstantExpression(ArraySize, &SizeVal, Diagnoser,
2003  S.LangOpts.GNUMode ||
2004  S.LangOpts.OpenCL).isInvalid();
2005 }
2006 
2007 /// \brief Build an array type.
2008 ///
2009 /// \param T The type of each element in the array.
2010 ///
2011 /// \param ASM C99 array size modifier (e.g., '*', 'static').
2012 ///
2013 /// \param ArraySize Expression describing the size of the array.
2014 ///
2015 /// \param Brackets The range from the opening '[' to the closing ']'.
2016 ///
2017 /// \param Entity The name of the entity that involves the array
2018 /// type, if known.
2019 ///
2020 /// \returns A suitable array type, if there are no errors. Otherwise,
2021 /// returns a NULL type.
2023  Expr *ArraySize, unsigned Quals,
2024  SourceRange Brackets, DeclarationName Entity) {
2025 
2026  SourceLocation Loc = Brackets.getBegin();
2027  if (getLangOpts().CPlusPlus) {
2028  // C++ [dcl.array]p1:
2029  // T is called the array element type; this type shall not be a reference
2030  // type, the (possibly cv-qualified) type void, a function type or an
2031  // abstract class type.
2032  //
2033  // C++ [dcl.array]p3:
2034  // When several "array of" specifications are adjacent, [...] only the
2035  // first of the constant expressions that specify the bounds of the arrays
2036  // may be omitted.
2037  //
2038  // Note: function types are handled in the common path with C.
2039  if (T->isReferenceType()) {
2040  Diag(Loc, diag::err_illegal_decl_array_of_references)
2041  << getPrintableNameForEntity(Entity) << T;
2042  return QualType();
2043  }
2044 
2045  if (T->isVoidType() || T->isIncompleteArrayType()) {
2046  Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T;
2047  return QualType();
2048  }
2049 
2050  if (RequireNonAbstractType(Brackets.getBegin(), T,
2051  diag::err_array_of_abstract_type))
2052  return QualType();
2053 
2054  // Mentioning a member pointer type for an array type causes us to lock in
2055  // an inheritance model, even if it's inside an unused typedef.
2057  if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
2058  if (!MPTy->getClass()->isDependentType())
2059  (void)isCompleteType(Loc, T);
2060 
2061  } else {
2062  // C99 6.7.5.2p1: If the element type is an incomplete or function type,
2063  // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
2064  if (RequireCompleteType(Loc, T,
2065  diag::err_illegal_decl_array_incomplete_type))
2066  return QualType();
2067  }
2068 
2069  if (T->isFunctionType()) {
2070  Diag(Loc, diag::err_illegal_decl_array_of_functions)
2071  << getPrintableNameForEntity(Entity) << T;
2072  return QualType();
2073  }
2074 
2075  if (const RecordType *EltTy = T->getAs<RecordType>()) {
2076  // If the element type is a struct or union that contains a variadic
2077  // array, accept it as a GNU extension: C99 6.7.2.1p2.
2078  if (EltTy->getDecl()->hasFlexibleArrayMember())
2079  Diag(Loc, diag::ext_flexible_array_in_array) << T;
2080  } else if (T->isObjCObjectType()) {
2081  Diag(Loc, diag::err_objc_array_of_interfaces) << T;
2082  return QualType();
2083  }
2084 
2085  // Do placeholder conversions on the array size expression.
2086  if (ArraySize && ArraySize->hasPlaceholderType()) {
2087  ExprResult Result = CheckPlaceholderExpr(ArraySize);
2088  if (Result.isInvalid()) return QualType();
2089  ArraySize = Result.get();
2090  }
2091 
2092  // Do lvalue-to-rvalue conversions on the array size expression.
2093  if (ArraySize && !ArraySize->isRValue()) {
2095  if (Result.isInvalid())
2096  return QualType();
2097 
2098  ArraySize = Result.get();
2099  }
2100 
2101  // C99 6.7.5.2p1: The size expression shall have integer type.
2102  // C++11 allows contextual conversions to such types.
2103  if (!getLangOpts().CPlusPlus11 &&
2104  ArraySize && !ArraySize->isTypeDependent() &&
2105  !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {
2106  Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
2107  << ArraySize->getType() << ArraySize->getSourceRange();
2108  return QualType();
2109  }
2110 
2111  llvm::APSInt ConstVal(Context.getTypeSize(Context.getSizeType()));
2112  if (!ArraySize) {
2113  if (ASM == ArrayType::Star)
2114  T = Context.getVariableArrayType(T, nullptr, ASM, Quals, Brackets);
2115  else
2116  T = Context.getIncompleteArrayType(T, ASM, Quals);
2117  } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) {
2118  T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets);
2119  } else if ((!T->isDependentType() && !T->isIncompleteType() &&
2120  !T->isConstantSizeType()) ||
2121  isArraySizeVLA(*this, ArraySize, ConstVal)) {
2122  // Even in C++11, don't allow contextual conversions in the array bound
2123  // of a VLA.
2124  if (getLangOpts().CPlusPlus11 &&
2125  !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {
2126  Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
2127  << ArraySize->getType() << ArraySize->getSourceRange();
2128  return QualType();
2129  }
2130 
2131  // C99: an array with an element type that has a non-constant-size is a VLA.
2132  // C99: an array with a non-ICE size is a VLA. We accept any expression
2133  // that we can fold to a non-zero positive value as an extension.
2134  T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets);
2135  } else {
2136  // C99 6.7.5.2p1: If the expression is a constant expression, it shall
2137  // have a value greater than zero.
2138  if (ConstVal.isSigned() && ConstVal.isNegative()) {
2139  if (Entity)
2140  Diag(ArraySize->getLocStart(), diag::err_decl_negative_array_size)
2141  << getPrintableNameForEntity(Entity) << ArraySize->getSourceRange();
2142  else
2143  Diag(ArraySize->getLocStart(), diag::err_typecheck_negative_array_size)
2144  << ArraySize->getSourceRange();
2145  return QualType();
2146  }
2147  if (ConstVal == 0) {
2148  // GCC accepts zero sized static arrays. We allow them when
2149  // we're not in a SFINAE context.
2150  Diag(ArraySize->getLocStart(),
2151  isSFINAEContext()? diag::err_typecheck_zero_array_size
2152  : diag::ext_typecheck_zero_array_size)
2153  << ArraySize->getSourceRange();
2154 
2155  if (ASM == ArrayType::Static) {
2156  Diag(ArraySize->getLocStart(),
2157  diag::warn_typecheck_zero_static_array_size)
2158  << ArraySize->getSourceRange();
2159  ASM = ArrayType::Normal;
2160  }
2161  } else if (!T->isDependentType() && !T->isVariablyModifiedType() &&
2162  !T->isIncompleteType() && !T->isUndeducedType()) {
2163  // Is the array too large?
2164  unsigned ActiveSizeBits
2166  if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
2167  Diag(ArraySize->getLocStart(), diag::err_array_too_large)
2168  << ConstVal.toString(10)
2169  << ArraySize->getSourceRange();
2170  return QualType();
2171  }
2172  }
2173 
2174  T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
2175  }
2176 
2177  // OpenCL v1.2 s6.9.d: variable length arrays are not supported.
2178  if (getLangOpts().OpenCL && T->isVariableArrayType()) {
2179  Diag(Loc, diag::err_opencl_vla);
2180  return QualType();
2181  }
2182  // CUDA device code doesn't support VLAs.
2183  if (getLangOpts().CUDA && T->isVariableArrayType())
2184  CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget();
2185 
2186  // If this is not C99, extwarn about VLA's and C99 array size modifiers.
2187  if (!getLangOpts().C99) {
2188  if (T->isVariableArrayType()) {
2189  // Prohibit the use of VLAs during template argument deduction.
2190  if (isSFINAEContext()) {
2191  Diag(Loc, diag::err_vla_in_sfinae);
2192  return QualType();
2193  }
2194  // Just extwarn about VLAs.
2195  else
2196  Diag(Loc, diag::ext_vla);
2197  } else if (ASM != ArrayType::Normal || Quals != 0)
2198  Diag(Loc,
2199  getLangOpts().CPlusPlus? diag::err_c99_array_usage_cxx
2200  : diag::ext_c99_array_usage) << ASM;
2201  }
2202 
2203  if (T->isVariableArrayType()) {
2204  // Warn about VLAs for -Wvla.
2205  Diag(Loc, diag::warn_vla_used);
2206  }
2207 
2208  // OpenCL v2.0 s6.12.5 - Arrays of blocks are not supported.
2209  // OpenCL v2.0 s6.16.13.1 - Arrays of pipe type are not supported.
2210  // OpenCL v2.0 s6.9.b - Arrays of image/sampler type are not supported.
2211  if (getLangOpts().OpenCL) {
2212  const QualType ArrType = Context.getBaseElementType(T);
2213  if (ArrType->isBlockPointerType() || ArrType->isPipeType() ||
2214  ArrType->isSamplerT() || ArrType->isImageType()) {
2215  Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
2216  return QualType();
2217  }
2218  }
2219 
2220  return T;
2221 }
2222 
2223 /// \brief Build an ext-vector type.
2224 ///
2225 /// Run the required checks for the extended vector type.
2227  SourceLocation AttrLoc) {
2228  // Unlike gcc's vector_size attribute, we do not allow vectors to be defined
2229  // in conjunction with complex types (pointers, arrays, functions, etc.).
2230  //
2231  // Additionally, OpenCL prohibits vectors of booleans (they're considered a
2232  // reserved data type under OpenCL v2.0 s6.1.4), we don't support selects
2233  // on bitvectors, and we have no well-defined ABI for bitvectors, so vectors
2234  // of bool aren't allowed.
2235  if ((!T->isDependentType() && !T->isIntegerType() &&
2236  !T->isRealFloatingType()) ||
2237  T->isBooleanType()) {
2238  Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
2239  return QualType();
2240  }
2241 
2242  if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) {
2243  llvm::APSInt vecSize(32);
2244  if (!ArraySize->isIntegerConstantExpr(vecSize, Context)) {
2245  Diag(AttrLoc, diag::err_attribute_argument_type)
2246  << "ext_vector_type" << AANT_ArgumentIntegerConstant
2247  << ArraySize->getSourceRange();
2248  return QualType();
2249  }
2250 
2251  // Unlike gcc's vector_size attribute, the size is specified as the
2252  // number of elements, not the number of bytes.
2253  unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue());
2254 
2255  if (vectorSize == 0) {
2256  Diag(AttrLoc, diag::err_attribute_zero_size)
2257  << ArraySize->getSourceRange();
2258  return QualType();
2259  }
2260 
2261  if (VectorType::isVectorSizeTooLarge(vectorSize)) {
2262  Diag(AttrLoc, diag::err_attribute_size_too_large)
2263  << ArraySize->getSourceRange();
2264  return QualType();
2265  }
2266 
2267  return Context.getExtVectorType(T, vectorSize);
2268  }
2269 
2270  return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc);
2271 }
2272 
2274  if (T->isArrayType() || T->isFunctionType()) {
2275  Diag(Loc, diag::err_func_returning_array_function)
2276  << T->isFunctionType() << T;
2277  return true;
2278  }
2279 
2280  // Functions cannot return half FP.
2281  if (T->isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2282  Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2283  FixItHint::CreateInsertion(Loc, "*");
2284  return true;
2285  }
2286 
2287  // Methods cannot return interface types. All ObjC objects are
2288  // passed by reference.
2289  if (T->isObjCObjectType()) {
2290  Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value)
2291  << 0 << T << FixItHint::CreateInsertion(Loc, "*");
2292  return true;
2293  }
2294 
2295  return false;
2296 }
2297 
2298 /// Check the extended parameter information. Most of the necessary
2299 /// checking should occur when applying the parameter attribute; the
2300 /// only other checks required are positional restrictions.
2303  llvm::function_ref<SourceLocation(unsigned)> getParamLoc) {
2304  assert(EPI.ExtParameterInfos && "shouldn't get here without param infos");
2305 
2306  bool hasCheckedSwiftCall = false;
2307  auto checkForSwiftCC = [&](unsigned paramIndex) {
2308  // Only do this once.
2309  if (hasCheckedSwiftCall) return;
2310  hasCheckedSwiftCall = true;
2311  if (EPI.ExtInfo.getCC() == CC_Swift) return;
2312  S.Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2313  << getParameterABISpelling(EPI.ExtParameterInfos[paramIndex].getABI());
2314  };
2315 
2316  for (size_t paramIndex = 0, numParams = paramTypes.size();
2317  paramIndex != numParams; ++paramIndex) {
2318  switch (EPI.ExtParameterInfos[paramIndex].getABI()) {
2319  // Nothing interesting to check for orindary-ABI parameters.
2321  continue;
2322 
2323  // swift_indirect_result parameters must be a prefix of the function
2324  // arguments.
2326  checkForSwiftCC(paramIndex);
2327  if (paramIndex != 0 &&
2328  EPI.ExtParameterInfos[paramIndex - 1].getABI()
2330  S.Diag(getParamLoc(paramIndex),
2331  diag::err_swift_indirect_result_not_first);
2332  }
2333  continue;
2334 
2336  checkForSwiftCC(paramIndex);
2337  continue;
2338 
2339  // swift_error parameters must be preceded by a swift_context parameter.
2341  checkForSwiftCC(paramIndex);
2342  if (paramIndex == 0 ||
2343  EPI.ExtParameterInfos[paramIndex - 1].getABI() !=
2345  S.Diag(getParamLoc(paramIndex),
2346  diag::err_swift_error_result_not_after_swift_context);
2347  }
2348  continue;
2349  }
2350  llvm_unreachable("bad ABI kind");
2351  }
2352 }
2353 
2355  MutableArrayRef<QualType> ParamTypes,
2356  SourceLocation Loc, DeclarationName Entity,
2357  const FunctionProtoType::ExtProtoInfo &EPI) {
2358  bool Invalid = false;
2359 
2360  Invalid |= CheckFunctionReturnType(T, Loc);
2361 
2362  for (unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2363  // FIXME: Loc is too inprecise here, should use proper locations for args.
2364  QualType ParamType = Context.getAdjustedParameterType(ParamTypes[Idx]);
2365  if (ParamType->isVoidType()) {
2366  Diag(Loc, diag::err_param_with_void_type);
2367  Invalid = true;
2368  } else if (ParamType->isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2369  // Disallow half FP arguments.
2370  Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2371  FixItHint::CreateInsertion(Loc, "*");
2372  Invalid = true;
2373  }
2374 
2375  ParamTypes[Idx] = ParamType;
2376  }
2377 
2378  if (EPI.ExtParameterInfos) {
2379  checkExtParameterInfos(*this, ParamTypes, EPI,
2380  [=](unsigned i) { return Loc; });
2381  }
2382 
2383  if (EPI.ExtInfo.getProducesResult()) {
2384  // This is just a warning, so we can't fail to build if we see it.
2386  }
2387 
2388  if (Invalid)
2389  return QualType();
2390 
2391  return Context.getFunctionType(T, ParamTypes, EPI);
2392 }
2393 
2394 /// \brief Build a member pointer type \c T Class::*.
2395 ///
2396 /// \param T the type to which the member pointer refers.
2397 /// \param Class the class type into which the member pointer points.
2398 /// \param Loc the location where this type begins
2399 /// \param Entity the name of the entity that will have this member pointer type
2400 ///
2401 /// \returns a member pointer type, if successful, or a NULL type if there was
2402 /// an error.
2404  SourceLocation Loc,
2405  DeclarationName Entity) {
2406  // Verify that we're not building a pointer to pointer to function with
2407  // exception specification.
2408  if (CheckDistantExceptionSpec(T)) {
2409  Diag(Loc, diag::err_distant_exception_spec);
2410  return QualType();
2411  }
2412 
2413  // C++ 8.3.3p3: A pointer to member shall not point to ... a member
2414  // with reference type, or "cv void."
2415  if (T->isReferenceType()) {
2416  Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
2417  << getPrintableNameForEntity(Entity) << T;
2418  return QualType();
2419  }
2420 
2421  if (T->isVoidType()) {
2422  Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
2423  << getPrintableNameForEntity(Entity);
2424  return QualType();
2425  }
2426 
2427  if (!Class->isDependentType() && !Class->isRecordType()) {
2428  Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
2429  return QualType();
2430  }
2431 
2432  // Adjust the default free function calling convention to the default method
2433  // calling convention.
2434  bool IsCtorOrDtor =
2437  if (T->isFunctionType())
2438  adjustMemberFunctionCC(T, /*IsStatic=*/false, IsCtorOrDtor, Loc);
2439 
2440  return Context.getMemberPointerType(T, Class.getTypePtr());
2441 }
2442 
2443 /// \brief Build a block pointer type.
2444 ///
2445 /// \param T The type to which we'll be building a block pointer.
2446 ///
2447 /// \param Loc The source location, used for diagnostics.
2448 ///
2449 /// \param Entity The name of the entity that involves the block pointer
2450 /// type, if known.
2451 ///
2452 /// \returns A suitable block pointer type, if there are no
2453 /// errors. Otherwise, returns a NULL type.
2455  SourceLocation Loc,
2456  DeclarationName Entity) {
2457  if (!T->isFunctionType()) {
2458  Diag(Loc, diag::err_nonfunction_block_type);
2459  return QualType();
2460  }
2461 
2462  if (checkQualifiedFunction(*this, T, Loc, QFK_BlockPointer))
2463  return QualType();
2464 
2465  return Context.getBlockPointerType(T);
2466 }
2467 
2469  QualType QT = Ty.get();
2470  if (QT.isNull()) {
2471  if (TInfo) *TInfo = nullptr;
2472  return QualType();
2473  }
2474 
2475  TypeSourceInfo *DI = nullptr;
2476  if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2477  QT = LIT->getType();
2478  DI = LIT->getTypeSourceInfo();
2479  }
2480 
2481  if (TInfo) *TInfo = DI;
2482  return QT;
2483 }
2484 
2485 static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state,
2486  Qualifiers::ObjCLifetime ownership,
2487  unsigned chunkIndex);
2488 
2489 /// Given that this is the declaration of a parameter under ARC,
2490 /// attempt to infer attributes and such for pointer-to-whatever
2491 /// types.
2492 static void inferARCWriteback(TypeProcessingState &state,
2493  QualType &declSpecType) {
2494  Sema &S = state.getSema();
2495  Declarator &declarator = state.getDeclarator();
2496 
2497  // TODO: should we care about decl qualifiers?
2498 
2499  // Check whether the declarator has the expected form. We walk
2500  // from the inside out in order to make the block logic work.
2501  unsigned outermostPointerIndex = 0;
2502  bool isBlockPointer = false;
2503  unsigned numPointers = 0;
2504  for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
2505  unsigned chunkIndex = i;
2506  DeclaratorChunk &chunk = declarator.getTypeObject(chunkIndex);
2507  switch (chunk.Kind) {
2509  // Ignore parens.
2510  break;
2511 
2514  // Count the number of pointers. Treat references
2515  // interchangeably as pointers; if they're mis-ordered, normal
2516  // type building will discover that.
2517  outermostPointerIndex = chunkIndex;
2518  numPointers++;
2519  break;
2520 
2522  // If we have a pointer to block pointer, that's an acceptable
2523  // indirect reference; anything else is not an application of
2524  // the rules.
2525  if (numPointers != 1) return;
2526  numPointers++;
2527  outermostPointerIndex = chunkIndex;
2528  isBlockPointer = true;
2529 
2530  // We don't care about pointer structure in return values here.
2531  goto done;
2532 
2533  case DeclaratorChunk::Array: // suppress if written (id[])?
2536  case DeclaratorChunk::Pipe:
2537  return;
2538  }
2539  }
2540  done:
2541 
2542  // If we have *one* pointer, then we want to throw the qualifier on
2543  // the declaration-specifiers, which means that it needs to be a
2544  // retainable object type.
2545  if (numPointers == 1) {
2546  // If it's not a retainable object type, the rule doesn't apply.
2547  if (!declSpecType->isObjCRetainableType()) return;
2548 
2549  // If it already has lifetime, don't do anything.
2550  if (declSpecType.getObjCLifetime()) return;
2551 
2552  // Otherwise, modify the type in-place.
2553  Qualifiers qs;
2554 
2555  if (declSpecType->isObjCARCImplicitlyUnretainedType())
2557  else
2559  declSpecType = S.Context.getQualifiedType(declSpecType, qs);
2560 
2561  // If we have *two* pointers, then we want to throw the qualifier on
2562  // the outermost pointer.
2563  } else if (numPointers == 2) {
2564  // If we don't have a block pointer, we need to check whether the
2565  // declaration-specifiers gave us something that will turn into a
2566  // retainable object pointer after we slap the first pointer on it.
2567  if (!isBlockPointer && !declSpecType->isObjCObjectType())
2568  return;
2569 
2570  // Look for an explicit lifetime attribute there.
2571  DeclaratorChunk &chunk = declarator.getTypeObject(outermostPointerIndex);
2572  if (chunk.Kind != DeclaratorChunk::Pointer &&
2574  return;
2575  for (const AttributeList *attr = chunk.getAttrs(); attr;
2576  attr = attr->getNext())
2577  if (attr->getKind() == AttributeList::AT_ObjCOwnership)
2578  return;
2579 
2581  outermostPointerIndex);
2582 
2583  // Any other number of pointers/references does not trigger the rule.
2584  } else return;
2585 
2586  // TODO: mark whether we did this inference?
2587 }
2588 
2589 void Sema::diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
2590  SourceLocation FallbackLoc,
2591  SourceLocation ConstQualLoc,
2592  SourceLocation VolatileQualLoc,
2593  SourceLocation RestrictQualLoc,
2594  SourceLocation AtomicQualLoc,
2595  SourceLocation UnalignedQualLoc) {
2596  if (!Quals)
2597  return;
2598 
2599  struct Qual {
2600  const char *Name;
2601  unsigned Mask;
2602  SourceLocation Loc;
2603  } const QualKinds[5] = {
2604  { "const", DeclSpec::TQ_const, ConstQualLoc },
2605  { "volatile", DeclSpec::TQ_volatile, VolatileQualLoc },
2606  { "restrict", DeclSpec::TQ_restrict, RestrictQualLoc },
2607  { "__unaligned", DeclSpec::TQ_unaligned, UnalignedQualLoc },
2608  { "_Atomic", DeclSpec::TQ_atomic, AtomicQualLoc }
2609  };
2610 
2611  SmallString<32> QualStr;
2612  unsigned NumQuals = 0;
2613  SourceLocation Loc;
2614  FixItHint FixIts[5];
2615 
2616  // Build a string naming the redundant qualifiers.
2617  for (auto &E : QualKinds) {
2618  if (Quals & E.Mask) {
2619  if (!QualStr.empty()) QualStr += ' ';
2620  QualStr += E.Name;
2621 
2622  // If we have a location for the qualifier, offer a fixit.
2623  SourceLocation QualLoc = E.Loc;
2624  if (QualLoc.isValid()) {
2625  FixIts[NumQuals] = FixItHint::CreateRemoval(QualLoc);
2626  if (Loc.isInvalid() ||
2628  Loc = QualLoc;
2629  }
2630 
2631  ++NumQuals;
2632  }
2633  }
2634 
2635  Diag(Loc.isInvalid() ? FallbackLoc : Loc, DiagID)
2636  << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2637 }
2638 
2639 // Diagnose pointless type qualifiers on the return type of a function.
2641  Declarator &D,
2642  unsigned FunctionChunkIndex) {
2643  if (D.getTypeObject(FunctionChunkIndex).Fun.hasTrailingReturnType()) {
2644  // FIXME: TypeSourceInfo doesn't preserve location information for
2645  // qualifiers.
2646  S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
2647  RetTy.getLocalCVRQualifiers(),
2648  D.getIdentifierLoc());
2649  return;
2650  }
2651 
2652  for (unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2653  End = D.getNumTypeObjects();
2654  OuterChunkIndex != End; ++OuterChunkIndex) {
2655  DeclaratorChunk &OuterChunk = D.getTypeObject(OuterChunkIndex);
2656  switch (OuterChunk.Kind) {
2658  continue;
2659 
2660  case DeclaratorChunk::Pointer: {
2661  DeclaratorChunk::PointerTypeInfo &PTI = OuterChunk.Ptr;
2663  diag::warn_qual_return_type,
2664  PTI.TypeQuals,
2665  SourceLocation(),
2671  return;
2672  }
2673 
2679  case DeclaratorChunk::Pipe:
2680  // FIXME: We can't currently provide an accurate source location and a
2681  // fix-it hint for these.
2682  unsigned AtomicQual = RetTy->isAtomicType() ? DeclSpec::TQ_atomic : 0;
2683  S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
2684  RetTy.getCVRQualifiers() | AtomicQual,
2685  D.getIdentifierLoc());
2686  return;
2687  }
2688 
2689  llvm_unreachable("unknown declarator chunk kind");
2690  }
2691 
2692  // If the qualifiers come from a conversion function type, don't diagnose
2693  // them -- they're not necessarily redundant, since such a conversion
2694  // operator can be explicitly called as "x.operator const int()".
2696  return;
2697 
2698  // Just parens all the way out to the decl specifiers. Diagnose any qualifiers
2699  // which are present there.
2700  S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
2702  D.getIdentifierLoc(),
2708 }
2709 
2710 static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
2711  TypeSourceInfo *&ReturnTypeInfo) {
2712  Sema &SemaRef = state.getSema();
2713  Declarator &D = state.getDeclarator();
2714  QualType T;
2715  ReturnTypeInfo = nullptr;
2716 
2717  // The TagDecl owned by the DeclSpec.
2718  TagDecl *OwnedTagDecl = nullptr;
2719 
2720  switch (D.getName().getKind()) {
2726  T = ConvertDeclSpecToType(state);
2727 
2728  if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) {
2729  OwnedTagDecl = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
2730  // Owned declaration is embedded in declarator.
2731  OwnedTagDecl->setEmbeddedInDeclarator(true);
2732  }
2733  break;
2734 
2738  // Constructors and destructors don't have return types. Use
2739  // "void" instead.
2740  T = SemaRef.Context.VoidTy;
2741  processTypeAttrs(state, T, TAL_DeclSpec,
2743  break;
2744 
2746  // Deduction guides have a trailing return type and no type in their
2747  // decl-specifier sequence. Use a placeholder return type for now.
2748  T = SemaRef.Context.DependentTy;
2749  break;
2750 
2752  // The result type of a conversion function is the type that it
2753  // converts to.
2755  &ReturnTypeInfo);
2756  break;
2757  }
2758 
2759  if (D.getAttributes())
2761 
2762  // C++11 [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context.
2763  if (DeducedType *Deduced = T->getContainedDeducedType()) {
2764  AutoType *Auto = dyn_cast<AutoType>(Deduced);
2765  int Error = -1;
2766 
2767  // Is this a 'auto' or 'decltype(auto)' type (as opposed to __auto_type or
2768  // class template argument deduction)?
2769  bool IsCXXAutoType =
2770  (Auto && Auto->getKeyword() != AutoTypeKeyword::GNUAutoType);
2771 
2772  switch (D.getContext()) {
2774  // Declared return type of a lambda-declarator is implicit and is always
2775  // 'auto'.
2776  break;
2780  Error = 0;
2781  break;
2783  // In C++14, generic lambdas allow 'auto' in their parameters.
2784  if (!SemaRef.getLangOpts().CPlusPlus14 ||
2785  !Auto || Auto->getKeyword() != AutoTypeKeyword::Auto)
2786  Error = 16;
2787  else {
2788  // If auto is mentioned in a lambda parameter context, convert it to a
2789  // template parameter type.
2790  sema::LambdaScopeInfo *LSI = SemaRef.getCurLambda();
2791  assert(LSI && "No LambdaScopeInfo on the stack!");
2792  const unsigned TemplateParameterDepth = LSI->AutoTemplateParameterDepth;
2793  const unsigned AutoParameterPosition = LSI->AutoTemplateParams.size();
2794  const bool IsParameterPack = D.hasEllipsis();
2795 
2796  // Create the TemplateTypeParmDecl here to retrieve the corresponding
2797  // template parameter type. Template parameters are temporarily added
2798  // to the TU until the associated TemplateDecl is created.
2799  TemplateTypeParmDecl *CorrespondingTemplateParam =
2801  SemaRef.Context, SemaRef.Context.getTranslationUnitDecl(),
2802  /*KeyLoc*/SourceLocation(), /*NameLoc*/D.getLocStart(),
2803  TemplateParameterDepth, AutoParameterPosition,
2804  /*Identifier*/nullptr, false, IsParameterPack);
2805  LSI->AutoTemplateParams.push_back(CorrespondingTemplateParam);
2806  // Replace the 'auto' in the function parameter with this invented
2807  // template type parameter.
2808  // FIXME: Retain some type sugar to indicate that this was written
2809  // as 'auto'.
2810  T = SemaRef.ReplaceAutoType(
2811  T, QualType(CorrespondingTemplateParam->getTypeForDecl(), 0));
2812  }
2813  break;
2817  break;
2818  bool Cxx = SemaRef.getLangOpts().CPlusPlus;
2819  switch (cast<TagDecl>(SemaRef.CurContext)->getTagKind()) {
2820  case TTK_Enum: llvm_unreachable("unhandled tag kind");
2821  case TTK_Struct: Error = Cxx ? 1 : 2; /* Struct member */ break;
2822  case TTK_Union: Error = Cxx ? 3 : 4; /* Union member */ break;
2823  case TTK_Class: Error = 5; /* Class member */ break;
2824  case TTK_Interface: Error = 6; /* Interface member */ break;
2825  }
2826  if (D.getDeclSpec().isFriendSpecified())
2827  Error = 20; // Friend type
2828  break;
2829  }
2832  Error = 7; // Exception declaration
2833  break;
2835  if (isa<DeducedTemplateSpecializationType>(Deduced))
2836  Error = 19; // Template parameter
2837  else if (!SemaRef.getLangOpts().CPlusPlus1z)
2838  Error = 8; // Template parameter (until C++1z)
2839  break;
2841  Error = 9; // Block literal
2842  break;
2844  Error = 10; // Template type argument
2845  break;
2848  Error = 12; // Type alias
2849  break;
2851  if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
2852  Error = 13; // Function return type
2853  break;
2855  if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
2856  Error = 14; // conversion-type-id
2857  break;
2859  if (isa<DeducedTemplateSpecializationType>(Deduced))
2860  break;
2861  LLVM_FALLTHROUGH;
2863  Error = 15; // Generic
2864  break;
2870  // FIXME: P0091R3 (erroneously) does not permit class template argument
2871  // deduction in conditions, for-init-statements, and other declarations
2872  // that are not simple-declarations.
2873  break;
2875  // FIXME: P0091R3 does not permit class template argument deduction here,
2876  // but we follow GCC and allow it anyway.
2877  if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
2878  Error = 17; // 'new' type
2879  break;
2881  Error = 18; // K&R function parameter
2882  break;
2883  }
2884 
2886  Error = 11;
2887 
2888  // In Objective-C it is an error to use 'auto' on a function declarator
2889  // (and everywhere for '__auto_type').
2890  if (D.isFunctionDeclarator() &&
2891  (!SemaRef.getLangOpts().CPlusPlus11 || !IsCXXAutoType))
2892  Error = 13;
2893 
2894  bool HaveTrailing = false;
2895 
2896  // C++11 [dcl.spec.auto]p2: 'auto' is always fine if the declarator
2897  // contains a trailing return type. That is only legal at the outermost
2898  // level. Check all declarator chunks (outermost first) anyway, to give
2899  // better diagnostics.
2900  // We don't support '__auto_type' with trailing return types.
2901  // FIXME: Should we only do this for 'auto' and not 'decltype(auto)'?
2902  if (SemaRef.getLangOpts().CPlusPlus11 && IsCXXAutoType &&
2903  D.hasTrailingReturnType()) {
2904  HaveTrailing = true;
2905  Error = -1;
2906  }
2907 
2908  SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc();
2910  AutoRange = D.getName().getSourceRange();
2911 
2912  if (Error != -1) {
2913  unsigned Kind;
2914  if (Auto) {
2915  switch (Auto->getKeyword()) {
2916  case AutoTypeKeyword::Auto: Kind = 0; break;
2917  case AutoTypeKeyword::DecltypeAuto: Kind = 1; break;
2918  case AutoTypeKeyword::GNUAutoType: Kind = 2; break;
2919  }
2920  } else {
2921  assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
2922  "unknown auto type");
2923  Kind = 3;
2924  }
2925 
2926  auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
2927  TemplateName TN = DTST ? DTST->getTemplateName() : TemplateName();
2928 
2929  SemaRef.Diag(AutoRange.getBegin(), diag::err_auto_not_allowed)
2930  << Kind << Error << (int)SemaRef.getTemplateNameKindForDiagnostics(TN)
2931  << QualType(Deduced, 0) << AutoRange;
2932  if (auto *TD = TN.getAsTemplateDecl())
2933  SemaRef.Diag(TD->getLocation(), diag::note_template_decl_here);
2934 
2935  T = SemaRef.Context.IntTy;
2936  D.setInvalidType(true);
2937  } else if (!HaveTrailing) {
2938  // If there was a trailing return type, we already got
2939  // warn_cxx98_compat_trailing_return_type in the parser.
2940  SemaRef.Diag(AutoRange.getBegin(),
2941  diag::warn_cxx98_compat_auto_type_specifier)
2942  << AutoRange;
2943  }
2944  }
2945 
2946  if (SemaRef.getLangOpts().CPlusPlus &&
2947  OwnedTagDecl && OwnedTagDecl->isCompleteDefinition()) {
2948  // Check the contexts where C++ forbids the declaration of a new class
2949  // or enumeration in a type-specifier-seq.
2950  unsigned DiagID = 0;
2951  switch (D.getContext()) {
2953  // Class and enumeration definitions are syntactically not allowed in
2954  // trailing return types.
2955  llvm_unreachable("parser should not have allowed this");
2956  break;
2964  // C++11 [dcl.type]p3:
2965  // A type-specifier-seq shall not define a class or enumeration unless
2966  // it appears in the type-id of an alias-declaration (7.1.3) that is not
2967  // the declaration of a template-declaration.
2969  break;
2971  DiagID = diag::err_type_defined_in_alias_template;
2972  break;
2981  DiagID = diag::err_type_defined_in_type_specifier;
2982  break;
2988  // C++ [dcl.fct]p6:
2989  // Types shall not be defined in return or parameter types.
2990  DiagID = diag::err_type_defined_in_param_type;
2991  break;
2993  // C++ 6.4p2:
2994  // The type-specifier-seq shall not contain typedef and shall not declare
2995  // a new class or enumeration.
2996  DiagID = diag::err_type_defined_in_condition;
2997  break;
2998  }
2999 
3000  if (DiagID != 0) {
3001  SemaRef.Diag(OwnedTagDecl->getLocation(), DiagID)
3002  << SemaRef.Context.getTypeDeclType(OwnedTagDecl);
3003  D.setInvalidType(true);
3004  }
3005  }
3006 
3007  assert(!T.isNull() && "This function should not return a null type");
3008  return T;
3009 }
3010 
3011 /// Produce an appropriate diagnostic for an ambiguity between a function
3012 /// declarator and a C++ direct-initializer.
3014  DeclaratorChunk &DeclType, QualType RT) {
3015  const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
3016  assert(FTI.isAmbiguous && "no direct-initializer / function ambiguity");
3017 
3018  // If the return type is void there is no ambiguity.
3019  if (RT->isVoidType())
3020  return;
3021 
3022  // An initializer for a non-class type can have at most one argument.
3023  if (!RT->isRecordType() && FTI.NumParams > 1)
3024  return;
3025 
3026  // An initializer for a reference must have exactly one argument.
3027  if (RT->isReferenceType() && FTI.NumParams != 1)
3028  return;
3029 
3030  // Only warn if this declarator is declaring a function at block scope, and
3031  // doesn't have a storage class (such as 'extern') specified.
3032  if (!D.isFunctionDeclarator() ||
3037  return;
3038 
3039  // Inside a condition, a direct initializer is not permitted. We allow one to
3040  // be parsed in order to give better diagnostics in condition parsing.
3042  return;
3043 
3044  SourceRange ParenRange(DeclType.Loc, DeclType.EndLoc);
3045 
3046  S.Diag(DeclType.Loc,
3047  FTI.NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3048  : diag::warn_empty_parens_are_function_decl)
3049  << ParenRange;
3050 
3051  // If the declaration looks like:
3052  // T var1,
3053  // f();
3054  // and name lookup finds a function named 'f', then the ',' was
3055  // probably intended to be a ';'.
3056  if (!D.isFirstDeclarator() && D.getIdentifier()) {
3059  if (Comma.getFileID() != Name.getFileID() ||
3060  Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3063  if (S.LookupName(Result, S.getCurScope()))
3064  S.Diag(D.getCommaLoc(), diag::note_empty_parens_function_call)
3066  << D.getIdentifier();
3067  }
3068  }
3069 
3070  if (FTI.NumParams > 0) {
3071  // For a declaration with parameters, eg. "T var(T());", suggest adding
3072  // parens around the first parameter to turn the declaration into a
3073  // variable declaration.
3074  SourceRange Range = FTI.Params[0].Param->getSourceRange();
3075  SourceLocation B = Range.getBegin();
3077  // FIXME: Maybe we should suggest adding braces instead of parens
3078  // in C++11 for classes that don't have an initializer_list constructor.
3079  S.Diag(B, diag::note_additional_parens_for_variable_declaration)
3080  << FixItHint::CreateInsertion(B, "(")
3081  << FixItHint::CreateInsertion(E, ")");
3082  } else {
3083  // For a declaration without parameters, eg. "T var();", suggest replacing
3084  // the parens with an initializer to turn the declaration into a variable
3085  // declaration.
3086  const CXXRecordDecl *RD = RT->getAsCXXRecordDecl();
3087 
3088  // Empty parens mean value-initialization, and no parens mean
3089  // default initialization. These are equivalent if the default
3090  // constructor is user-provided or if zero-initialization is a
3091  // no-op.
3092  if (RD && RD->hasDefinition() &&
3093  (RD->isEmpty() || RD->hasUserProvidedDefaultConstructor()))
3094  S.Diag(DeclType.Loc, diag::note_empty_parens_default_ctor)
3095  << FixItHint::CreateRemoval(ParenRange);
3096  else {
3097  std::string Init =
3098  S.getFixItZeroInitializerForType(RT, ParenRange.getBegin());
3099  if (Init.empty() && S.LangOpts.CPlusPlus11)
3100  Init = "{}";
3101  if (!Init.empty())
3102  S.Diag(DeclType.Loc, diag::note_empty_parens_zero_initialize)
3103  << FixItHint::CreateReplacement(ParenRange, Init);
3104  }
3105  }
3106 }
3107 
3108 /// Helper for figuring out the default CC for a function declarator type. If
3109 /// this is the outermost chunk, then we can determine the CC from the
3110 /// declarator context. If not, then this could be either a member function
3111 /// type or normal function type.
3112 static CallingConv
3115  unsigned ChunkIndex) {
3116  assert(D.getTypeObject(ChunkIndex).Kind == DeclaratorChunk::Function);
3117 
3118  // Check for an explicit CC attribute.
3119  for (auto Attr = FTI.AttrList; Attr; Attr = Attr->getNext()) {
3120  switch (Attr->getKind()) {
3122  // Ignore attributes that don't validate or can't apply to the
3123  // function type. We'll diagnose the failure to apply them in
3124  // handleFunctionTypeAttr.
3125  CallingConv CC;
3126  if (!S.CheckCallingConvAttr(*Attr, CC) &&
3127  (!FTI.isVariadic || supportsVariadicCall(CC))) {
3128  return CC;
3129  }
3130  break;
3131  }
3132 
3133  default:
3134  break;
3135  }
3136  }
3137 
3138  bool IsCXXInstanceMethod = false;
3139 
3140  if (S.getLangOpts().CPlusPlus) {
3141  // Look inwards through parentheses to see if this chunk will form a
3142  // member pointer type or if we're the declarator. Any type attributes
3143  // between here and there will override the CC we choose here.
3144  unsigned I = ChunkIndex;
3145  bool FoundNonParen = false;
3146  while (I && !FoundNonParen) {
3147  --I;
3149  FoundNonParen = true;
3150  }
3151 
3152  if (FoundNonParen) {
3153  // If we're not the declarator, we're a regular function type unless we're
3154  // in a member pointer.
3155  IsCXXInstanceMethod =
3157  } else if (D.getContext() == Declarator::LambdaExprContext) {
3158  // This can only be a call operator for a lambda, which is an instance
3159  // method.
3160  IsCXXInstanceMethod = true;
3161  } else {
3162  // We're the innermost decl chunk, so must be a function declarator.
3163  assert(D.isFunctionDeclarator());
3164 
3165  // If we're inside a record, we're declaring a method, but it could be
3166  // explicitly or implicitly static.
3167  IsCXXInstanceMethod =
3170  !D.isStaticMember();
3171  }
3172  }
3173 
3175  IsCXXInstanceMethod);
3176 
3177  // Attribute AT_OpenCLKernel affects the calling convention for SPIR
3178  // and AMDGPU targets, hence it cannot be treated as a calling
3179  // convention attribute. This is the simplest place to infer
3180  // calling convention for OpenCL kernels.
3181  if (S.getLangOpts().OpenCL) {
3182  for (const AttributeList *Attr = D.getDeclSpec().getAttributes().getList();
3183  Attr; Attr = Attr->getNext()) {
3184  if (Attr->getKind() == AttributeList::AT_OpenCLKernel) {
3185  CC = CC_OpenCLKernel;
3186  break;
3187  }
3188  }
3189  }
3190 
3191  return CC;
3192 }
3193 
3194 namespace {
3195  /// A simple notion of pointer kinds, which matches up with the various
3196  /// pointer declarators.
3197  enum class SimplePointerKind {
3198  Pointer,
3199  BlockPointer,
3200  MemberPointer,
3201  Array,
3202  };
3203 } // end anonymous namespace
3204 
3206  switch (nullability) {
3208  if (!Ident__Nonnull)
3209  Ident__Nonnull = PP.getIdentifierInfo("_Nonnull");
3210  return Ident__Nonnull;
3211 
3213  if (!Ident__Nullable)
3214  Ident__Nullable = PP.getIdentifierInfo("_Nullable");
3215  return Ident__Nullable;
3216 
3218  if (!Ident__Null_unspecified)
3219  Ident__Null_unspecified = PP.getIdentifierInfo("_Null_unspecified");
3220  return Ident__Null_unspecified;
3221  }
3222  llvm_unreachable("Unknown nullability kind.");
3223 }
3224 
3225 /// Retrieve the identifier "NSError".
3227  if (!Ident_NSError)
3228  Ident_NSError = PP.getIdentifierInfo("NSError");
3229 
3230  return Ident_NSError;
3231 }
3232 
3233 /// Check whether there is a nullability attribute of any kind in the given
3234 /// attribute list.
3235 static bool hasNullabilityAttr(const AttributeList *attrs) {
3236  for (const AttributeList *attr = attrs; attr;
3237  attr = attr->getNext()) {
3238  if (attr->getKind() == AttributeList::AT_TypeNonNull ||
3239  attr->getKind() == AttributeList::AT_TypeNullable ||
3240  attr->getKind() == AttributeList::AT_TypeNullUnspecified)
3241  return true;
3242  }
3243 
3244  return false;
3245 }
3246 
3247 namespace {
3248  /// Describes the kind of a pointer a declarator describes.
3250  // Not a pointer.
3251  NonPointer,
3252  // Single-level pointer.
3253  SingleLevelPointer,
3254  // Multi-level pointer (of any pointer kind).
3255  MultiLevelPointer,
3256  // CFFooRef*
3257  MaybePointerToCFRef,
3258  // CFErrorRef*
3259  CFErrorRefPointer,
3260  // NSError**
3261  NSErrorPointerPointer,
3262  };
3263 
3264  /// Describes a declarator chunk wrapping a pointer that marks inference as
3265  /// unexpected.
3266  // These values must be kept in sync with diagnostics.
3268  /// Pointer is top-level.
3269  None = -1,
3270  /// Pointer is an array element.
3271  Array = 0,
3272  /// Pointer is the referent type of a C++ reference.
3273  Reference = 1
3274  };
3275 } // end anonymous namespace
3276 
3277 /// Classify the given declarator, whose type-specified is \c type, based on
3278 /// what kind of pointer it refers to.
3279 ///
3280 /// This is used to determine the default nullability.
3281 static PointerDeclaratorKind
3283  PointerWrappingDeclaratorKind &wrappingKind) {
3284  unsigned numNormalPointers = 0;
3285 
3286  // For any dependent type, we consider it a non-pointer.
3287  if (type->isDependentType())
3288  return PointerDeclaratorKind::NonPointer;
3289 
3290  // Look through the declarator chunks to identify pointers.
3291  for (unsigned i = 0, n = declarator.getNumTypeObjects(); i != n; ++i) {
3292  DeclaratorChunk &chunk = declarator.getTypeObject(i);
3293  switch (chunk.Kind) {
3295  if (numNormalPointers == 0)
3296  wrappingKind = PointerWrappingDeclaratorKind::Array;
3297  break;
3298 
3300  case DeclaratorChunk::Pipe:
3301  break;
3302 
3305  return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3306  : PointerDeclaratorKind::SingleLevelPointer;
3307 
3309  break;
3310 
3312  if (numNormalPointers == 0)
3313  wrappingKind = PointerWrappingDeclaratorKind::Reference;
3314  break;
3315 
3317  ++numNormalPointers;
3318  if (numNormalPointers > 2)
3319  return PointerDeclaratorKind::MultiLevelPointer;
3320  break;
3321  }
3322  }
3323 
3324  // Then, dig into the type specifier itself.
3325  unsigned numTypeSpecifierPointers = 0;
3326  do {
3327  // Decompose normal pointers.
3328  if (auto ptrType = type->getAs<PointerType>()) {
3329  ++numNormalPointers;
3330 
3331  if (numNormalPointers > 2)
3332  return PointerDeclaratorKind::MultiLevelPointer;
3333 
3334  type = ptrType->getPointeeType();
3335  ++numTypeSpecifierPointers;
3336  continue;
3337  }
3338 
3339  // Decompose block pointers.
3340  if (type->getAs<BlockPointerType>()) {
3341  return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3342  : PointerDeclaratorKind::SingleLevelPointer;
3343  }
3344 
3345  // Decompose member pointers.
3346  if (type->getAs<MemberPointerType>()) {
3347  return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3348  : PointerDeclaratorKind::SingleLevelPointer;
3349  }
3350 
3351  // Look at Objective-C object pointers.
3352  if (auto objcObjectPtr = type->getAs<ObjCObjectPointerType>()) {
3353  ++numNormalPointers;
3354  ++numTypeSpecifierPointers;
3355 
3356  // If this is NSError**, report that.
3357  if (auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3358  if (objcClassDecl->getIdentifier() == S.getNSErrorIdent() &&
3359  numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3360  return PointerDeclaratorKind::NSErrorPointerPointer;
3361  }
3362  }
3363 
3364  break;
3365  }
3366 
3367  // Look at Objective-C class types.
3368  if (auto objcClass = type->getAs<ObjCInterfaceType>()) {
3369  if (objcClass->getInterface()->getIdentifier() == S.getNSErrorIdent()) {
3370  if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3371  return PointerDeclaratorKind::NSErrorPointerPointer;
3372  }
3373 
3374  break;
3375  }
3376 
3377  // If at this point we haven't seen a pointer, we won't see one.
3378  if (numNormalPointers == 0)
3379  return PointerDeclaratorKind::NonPointer;
3380 
3381  if (auto recordType = type->getAs<RecordType>()) {
3382  RecordDecl *recordDecl = recordType->getDecl();
3383 
3384  bool isCFError = false;
3385  if (S.CFError) {
3386  // If we already know about CFError, test it directly.
3387  isCFError = (S.CFError == recordDecl);
3388  } else {
3389  // Check whether this is CFError, which we identify based on its bridge
3390  // to NSError.
3391  if (recordDecl->getTagKind() == TTK_Struct && numNormalPointers > 0) {
3392  if (auto bridgeAttr = recordDecl->getAttr<ObjCBridgeAttr>()) {
3393  if (bridgeAttr->getBridgedType() == S.getNSErrorIdent()) {
3394  S.CFError = recordDecl;
3395  isCFError = true;
3396  }
3397  }
3398  }
3399  }
3400 
3401  // If this is CFErrorRef*, report it as such.
3402  if (isCFError && numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3403  return PointerDeclaratorKind::CFErrorRefPointer;
3404  }
3405  break;
3406  }
3407 
3408  break;
3409  } while (true);
3410 
3411  switch (numNormalPointers) {
3412  case 0:
3413  return PointerDeclaratorKind::NonPointer;
3414 
3415  case 1:
3416  return PointerDeclaratorKind::SingleLevelPointer;
3417 
3418  case 2:
3419  return PointerDeclaratorKind::MaybePointerToCFRef;
3420 
3421  default:
3422  return PointerDeclaratorKind::MultiLevelPointer;
3423  }
3424 }
3425 
3427  SourceLocation loc) {
3428  // If we're anywhere in a function, method, or closure context, don't perform
3429  // completeness checks.
3430  for (DeclContext *ctx = S.CurContext; ctx; ctx = ctx->getParent()) {
3431  if (ctx->isFunctionOrMethod())
3432  return FileID();
3433 
3434  if (ctx->isFileContext())
3435  break;
3436  }
3437 
3438  // We only care about the expansion location.
3439  loc = S.SourceMgr.getExpansionLoc(loc);
3440  FileID file = S.SourceMgr.getFileID(loc);
3441  if (file.isInvalid())
3442  return FileID();
3443 
3444  // Retrieve file information.
3445  bool invalid = false;
3446  const SrcMgr::SLocEntry &sloc = S.SourceMgr.getSLocEntry(file, &invalid);
3447  if (invalid || !sloc.isFile())
3448  return FileID();
3449 
3450  // We don't want to perform completeness checks on the main file or in
3451  // system headers.
3452  const SrcMgr::FileInfo &fileInfo = sloc.getFile();
3453  if (fileInfo.getIncludeLoc().isInvalid())
3454  return FileID();
3455  if (fileInfo.getFileCharacteristic() != SrcMgr::C_User &&
3457  return FileID();
3458  }
3459 
3460  return file;
3461 }
3462 
3463 /// Creates a fix-it to insert a C-style nullability keyword at \p pointerLoc,
3464 /// taking into account whitespace before and after.
3466  SourceLocation PointerLoc,
3468  assert(PointerLoc.isValid());
3469  if (PointerLoc.isMacroID())
3470  return;
3471 
3472  SourceLocation FixItLoc = S.getLocForEndOfToken(PointerLoc);
3473  if (!FixItLoc.isValid() || FixItLoc == PointerLoc)
3474  return;
3475 
3476  const char *NextChar = S.SourceMgr.getCharacterData(FixItLoc);
3477  if (!NextChar)
3478  return;
3479 
3480  SmallString<32> InsertionTextBuf{" "};
3481  InsertionTextBuf += getNullabilitySpelling(Nullability);
3482  InsertionTextBuf += " ";
3483  StringRef InsertionText = InsertionTextBuf.str();
3484 
3485  if (isWhitespace(*NextChar)) {
3486  InsertionText = InsertionText.drop_back();
3487  } else if (NextChar[-1] == '[') {
3488  if (NextChar[0] == ']')
3489  InsertionText = InsertionText.drop_back().drop_front();
3490  else
3491  InsertionText = InsertionText.drop_front();
3492  } else if (!isIdentifierBody(NextChar[0], /*allow dollar*/true) &&
3493  !isIdentifierBody(NextChar[-1], /*allow dollar*/true)) {
3494  InsertionText = InsertionText.drop_back().drop_front();
3495  }
3496 
3497  Diag << FixItHint::CreateInsertion(FixItLoc, InsertionText);
3498 }
3499 
3501  SimplePointerKind PointerKind,
3502  SourceLocation PointerLoc) {
3503  assert(PointerLoc.isValid());
3504 
3505  if (PointerKind == SimplePointerKind::Array) {
3506  S.Diag(PointerLoc, diag::warn_nullability_missing_array);
3507  } else {
3508  S.Diag(PointerLoc, diag::warn_nullability_missing)
3509  << static_cast<unsigned>(PointerKind);
3510  }
3511 
3512  if (PointerLoc.isMacroID())
3513  return;
3514 
3515  auto addFixIt = [&](NullabilityKind Nullability) {
3516  auto Diag = S.Diag(PointerLoc, diag::note_nullability_fix_it);
3517  Diag << static_cast<unsigned>(Nullability);
3518  Diag << static_cast<unsigned>(PointerKind);
3519  fixItNullability(S, Diag, PointerLoc, Nullability);
3520  };
3521  addFixIt(NullabilityKind::Nullable);
3522  addFixIt(NullabilityKind::NonNull);
3523 }
3524 
3525 /// Complains about missing nullability if the file containing \p pointerLoc
3526 /// has other uses of nullability (either the keywords or the \c assume_nonnull
3527 /// pragma).
3528 ///
3529 /// If the file has \e not seen other uses of nullability, this particular
3530 /// pointer is saved for possible later diagnosis. See recordNullabilitySeen().
3532  SimplePointerKind pointerKind,
3533  SourceLocation pointerLoc) {
3534  // Determine which file we're performing consistency checking for.
3535  FileID file = getNullabilityCompletenessCheckFileID(S, pointerLoc);
3536  if (file.isInvalid())
3537  return;
3538 
3539  // If we haven't seen any type nullability in this file, we won't warn now
3540  // about anything.
3541  FileNullability &fileNullability = S.NullabilityMap[file];
3542  if (!fileNullability.SawTypeNullability) {
3543  // If this is the first pointer declarator in the file, and the appropriate
3544  // warning is on, record it in case we need to diagnose it retroactively.
3545  diag::kind diagKind;
3546  if (pointerKind == SimplePointerKind::Array)
3547  diagKind = diag::warn_nullability_missing_array;
3548  else
3549  diagKind = diag::warn_nullability_missing;
3550 
3551  if (fileNullability.PointerLoc.isInvalid() &&
3552  !S.Context.getDiagnostics().isIgnored(diagKind, pointerLoc)) {
3553  fileNullability.PointerLoc = pointerLoc;
3554  fileNullability.PointerKind = static_cast<unsigned>(pointerKind);
3555  }
3556 
3557  return;
3558  }
3559 
3560  // Complain about missing nullability.
3561  emitNullabilityConsistencyWarning(S, pointerKind, pointerLoc);
3562 }
3563 
3564 /// Marks that a nullability feature has been used in the file containing
3565 /// \p loc.
3566 ///
3567 /// If this file already had pointer types in it that were missing nullability,
3568 /// the first such instance is retroactively diagnosed.
3569 ///
3570 /// \sa checkNullabilityConsistency
3573  if (file.isInvalid())
3574  return;
3575 
3576  FileNullability &fileNullability = S.NullabilityMap[file];
3577  if (fileNullability.SawTypeNullability)
3578  return;
3579  fileNullability.SawTypeNullability = true;
3580 
3581  // If we haven't seen any type nullability before, now we have. Retroactively
3582  // diagnose the first unannotated pointer, if there was one.
3583  if (fileNullability.PointerLoc.isInvalid())
3584  return;
3585 
3586  auto kind = static_cast<SimplePointerKind>(fileNullability.PointerKind);
3587  emitNullabilityConsistencyWarning(S, kind, fileNullability.PointerLoc);
3588 }
3589 
3590 /// Returns true if any of the declarator chunks before \p endIndex include a
3591 /// level of indirection: array, pointer, reference, or pointer-to-member.
3592 ///
3593 /// Because declarator chunks are stored in outer-to-inner order, testing
3594 /// every chunk before \p endIndex is testing all chunks that embed the current
3595 /// chunk as part of their type.
3596 ///
3597 /// It is legal to pass the result of Declarator::getNumTypeObjects() as the
3598 /// end index, in which case all chunks are tested.
3599 static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex) {
3600  unsigned i = endIndex;
3601  while (i != 0) {
3602  // Walk outwards along the declarator chunks.
3603  --i;
3604  const DeclaratorChunk &DC = D.getTypeObject(i);
3605  switch (DC.Kind) {
3607  break;
3612  return true;
3615  case DeclaratorChunk::Pipe:
3616  // These are invalid anyway, so just ignore.
3617  break;
3618  }
3619  }
3620  return false;
3621 }
3622 
3623 static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
3624  QualType declSpecType,
3625  TypeSourceInfo *TInfo) {
3626  // The TypeSourceInfo that this function returns will not be a null type.
3627  // If there is an error, this function will fill in a dummy type as fallback.
3628  QualType T = declSpecType;
3629  Declarator &D = state.getDeclarator();
3630  Sema &S = state.getSema();
3631  ASTContext &Context = S.Context;
3632  const LangOptions &LangOpts = S.getLangOpts();
3633 
3634  // The name we're declaring, if any.
3636  if (D.getIdentifier())
3637  Name = D.getIdentifier();
3638 
3639  // Does this declaration declare a typedef-name?
3640  bool IsTypedefName =
3644 
3645  // Does T refer to a function type with a cv-qualifier or a ref-qualifier?
3646  bool IsQualifiedFunction = T->isFunctionProtoType() &&
3647  (T->castAs<FunctionProtoType>()->getTypeQuals() != 0 ||
3648  T->castAs<FunctionProtoType>()->getRefQualifier() != RQ_None);
3649 
3650  // If T is 'decltype(auto)', the only declarators we can have are parens
3651  // and at most one function declarator if this is a function declaration.
3652  // If T is a deduced class template specialization type, we can have no
3653  // declarator chunks at all.
3654  if (auto *DT = T->getAs<DeducedType>()) {
3655  const AutoType *AT = T->getAs<AutoType>();
3656  bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
3657  if ((AT && AT->isDecltypeAuto()) || IsClassTemplateDeduction) {
3658  for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
3659  unsigned Index = E - I - 1;
3660  DeclaratorChunk &DeclChunk = D.getTypeObject(Index);
3661  unsigned DiagId = IsClassTemplateDeduction
3662  ? diag::err_deduced_class_template_compound_type
3663  : diag::err_decltype_auto_compound_type;
3664  unsigned DiagKind = 0;
3665  switch (DeclChunk.Kind) {
3667  // FIXME: Rejecting this is a little silly.
3668  if (IsClassTemplateDeduction) {
3669  DiagKind = 4;
3670  break;
3671  }
3672  continue;
3674  if (IsClassTemplateDeduction) {
3675  DiagKind = 3;
3676  break;
3677  }
3678  unsigned FnIndex;
3679  if (D.isFunctionDeclarationContext() &&
3680  D.isFunctionDeclarator(FnIndex) && FnIndex == Index)
3681  continue;
3682  DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
3683  break;
3684  }
3688  DiagKind = 0;
3689  break;
3691  DiagKind = 1;
3692  break;
3694  DiagKind = 2;
3695  break;
3696  case DeclaratorChunk::Pipe:
3697  break;
3698  }
3699 
3700  S.Diag(DeclChunk.Loc, DiagId) << DiagKind;
3701  D.setInvalidType(true);
3702  break;
3703  }
3704  }
3705  }
3706 
3707  // Determine whether we should infer _Nonnull on pointer types.
3708  Optional<NullabilityKind> inferNullability;
3709  bool inferNullabilityCS = false;
3710  bool inferNullabilityInnerOnly = false;
3711  bool inferNullabilityInnerOnlyComplete = false;
3712 
3713  // Are we in an assume-nonnull region?
3714  bool inAssumeNonNullRegion = false;
3715  SourceLocation assumeNonNullLoc = S.PP.getPragmaAssumeNonNullLoc();
3716  if (assumeNonNullLoc.isValid()) {
3717  inAssumeNonNullRegion = true;
3718  recordNullabilitySeen(S, assumeNonNullLoc);
3719  }
3720 
3721  // Whether to complain about missing nullability specifiers or not.
3722  enum {
3723  /// Never complain.
3724  CAMN_No,
3725  /// Complain on the inner pointers (but not the outermost
3726  /// pointer).
3727  CAMN_InnerPointers,
3728  /// Complain about any pointers that don't have nullability
3729  /// specified or inferred.
3730  CAMN_Yes
3731  } complainAboutMissingNullability = CAMN_No;
3732  unsigned NumPointersRemaining = 0;
3733  auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
3734 
3735  if (IsTypedefName) {
3736  // For typedefs, we do not infer any nullability (the default),
3737  // and we only complain about missing nullability specifiers on
3738  // inner pointers.
3739  complainAboutMissingNullability = CAMN_InnerPointers;
3740 
3741  if (T->canHaveNullability(/*ResultIfUnknown*/false) &&
3742  !T->getNullability(S.Context)) {
3743  // Note that we allow but don't require nullability on dependent types.
3744  ++NumPointersRemaining;
3745  }
3746 
3747  for (unsigned i = 0, n = D.getNumTypeObjects(); i != n; ++i) {
3748  DeclaratorChunk &chunk = D.getTypeObject(i);
3749  switch (chunk.Kind) {
3752  case DeclaratorChunk::Pipe:
3753  break;
3754 
3757  ++NumPointersRemaining;
3758  break;
3759 
3762  continue;
3763 
3765  ++NumPointersRemaining;
3766  continue;
3767  }
3768  }
3769  } else {
3770  bool isFunctionOrMethod = false;
3771  switch (auto context = state.getDeclarator().getContext()) {
3776  isFunctionOrMethod = true;
3777  // fallthrough
3778 
3780  if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) {
3781  complainAboutMissingNullability = CAMN_No;
3782  break;
3783  }
3784 
3785  // Weak properties are inferred to be nullable.
3786  if (state.getDeclarator().isObjCWeakProperty() && inAssumeNonNullRegion) {
3787  inferNullability = NullabilityKind::Nullable;
3788  break;
3789  }
3790 
3791  // fallthrough
3792 
3795  complainAboutMissingNullability = CAMN_Yes;
3796 
3797  // Nullability inference depends on the type and declarator.
3798  auto wrappingKind = PointerWrappingDeclaratorKind::None;
3799  switch (classifyPointerDeclarator(S, T, D, wrappingKind)) {
3800  case PointerDeclaratorKind::NonPointer:
3801  case PointerDeclaratorKind::MultiLevelPointer:
3802  // Cannot infer nullability.
3803  break;
3804 
3805  case PointerDeclaratorKind::SingleLevelPointer:
3806  // Infer _Nonnull if we are in an assumes-nonnull region.
3807  if (inAssumeNonNullRegion) {
3808  complainAboutInferringWithinChunk = wrappingKind;
3809  inferNullability = NullabilityKind::NonNull;
3810  inferNullabilityCS = (context == Declarator::ObjCParameterContext ||
3811  context == Declarator::ObjCResultContext);
3812  }
3813  break;
3814 
3815  case PointerDeclaratorKind::CFErrorRefPointer:
3816  case PointerDeclaratorKind::NSErrorPointerPointer:
3817  // Within a function or method signature, infer _Nullable at both
3818  // levels.
3819  if (isFunctionOrMethod && inAssumeNonNullRegion)
3820  inferNullability = NullabilityKind::Nullable;
3821  break;
3822 
3823  case PointerDeclaratorKind::MaybePointerToCFRef:
3824  if (isFunctionOrMethod) {
3825  // On pointer-to-pointer parameters marked cf_returns_retained or
3826  // cf_returns_not_retained, if the outer pointer is explicit then
3827  // infer the inner pointer as _Nullable.
3828  auto hasCFReturnsAttr = [](const AttributeList *NextAttr) -> bool {
3829  while (NextAttr) {
3830  if (NextAttr->getKind() == AttributeList::AT_CFReturnsRetained ||
3831  NextAttr->getKind() == AttributeList::AT_CFReturnsNotRetained)
3832  return true;
3833  NextAttr = NextAttr->getNext();
3834  }
3835  return false;
3836  };
3837  if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) {
3838  if (hasCFReturnsAttr(D.getAttributes()) ||
3839  hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
3840  hasCFReturnsAttr(D.getDeclSpec().getAttributes().getList())) {
3841  inferNullability = NullabilityKind::Nullable;
3842  inferNullabilityInnerOnly = true;
3843  }
3844  }
3845  }
3846  break;
3847  }
3848  break;
3849  }
3850 
3852  complainAboutMissingNullability = CAMN_Yes;
3853  break;
3854 
3871  // Don't infer in these contexts.
3872  break;
3873  }
3874  }
3875 
3876  // Local function that returns true if its argument looks like a va_list.
3877  auto isVaList = [&S](QualType T) -> bool {
3878  auto *typedefTy = T->getAs<TypedefType>();
3879  if (!typedefTy)
3880  return false;
3881  TypedefDecl *vaListTypedef = S.Context.getBuiltinVaListDecl();
3882  do {
3883  if (typedefTy->getDecl() == vaListTypedef)
3884  return true;
3885  if (auto *name = typedefTy->getDecl()->getIdentifier())
3886  if (name->isStr("va_list"))
3887  return true;
3888  typedefTy = typedefTy->desugar()->getAs<TypedefType>();
3889  } while (typedefTy);
3890  return false;
3891  };
3892 
3893  // Local function that checks the nullability for a given pointer declarator.
3894  // Returns true if _Nonnull was inferred.
3895  auto inferPointerNullability = [&](SimplePointerKind pointerKind,
3896  SourceLocation pointerLoc,
3897  AttributeList *&attrs) -> AttributeList * {
3898  // We've seen a pointer.
3899  if (NumPointersRemaining > 0)
3900  --NumPointersRemaining;
3901 
3902  // If a nullability attribute is present, there's nothing to do.
3903  if (hasNullabilityAttr(attrs))
3904  return nullptr;
3905 
3906  // If we're supposed to infer nullability, do so now.
3907  if (inferNullability && !inferNullabilityInnerOnlyComplete) {
3908  AttributeList::Syntax syntax
3909  = inferNullabilityCS ? AttributeList::AS_ContextSensitiveKeyword
3911  AttributeList *nullabilityAttr = state.getDeclarator().getAttributePool()
3912  .create(
3914  *inferNullability),
3915  SourceRange(pointerLoc),
3916  nullptr, SourceLocation(),
3917  nullptr, 0, syntax);
3918 
3919  spliceAttrIntoList(*nullabilityAttr, attrs);
3920 
3921  if (inferNullabilityCS) {
3922  state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
3923  ->setObjCDeclQualifier(ObjCDeclSpec::DQ_CSNullability);
3924  }
3925 
3926  if (pointerLoc.isValid() &&
3927  complainAboutInferringWithinChunk !=
3929  auto Diag =
3930  S.Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
3931  Diag << static_cast<int>(complainAboutInferringWithinChunk);
3933  }
3934 
3935  if (inferNullabilityInnerOnly)
3936  inferNullabilityInnerOnlyComplete = true;
3937  return nullabilityAttr;
3938  }
3939 
3940  // If we're supposed to complain about missing nullability, do so
3941  // now if it's truly missing.
3942  switch (complainAboutMissingNullability) {
3943  case CAMN_No:
3944  break;
3945 
3946  case CAMN_InnerPointers:
3947  if (NumPointersRemaining == 0)
3948  break;
3949  // Fallthrough.
3950 
3951  case CAMN_Yes:
3952  checkNullabilityConsistency(S, pointerKind, pointerLoc);
3953  }
3954  return nullptr;
3955  };
3956 
3957  // If the type itself could have nullability but does not, infer pointer
3958  // nullability and perform consistency checking.
3959  if (S.CodeSynthesisContexts.empty()) {
3960  if (T->canHaveNullability(/*ResultIfUnknown*/false) &&
3961  !T->getNullability(S.Context)) {
3962  if (isVaList(T)) {
3963  // Record that we've seen a pointer, but do nothing else.
3964  if (NumPointersRemaining > 0)
3965  --NumPointersRemaining;
3966  } else {
3967  SimplePointerKind pointerKind = SimplePointerKind::Pointer;
3968  if (T->isBlockPointerType())
3969  pointerKind = SimplePointerKind::BlockPointer;
3970  else if (T->isMemberPointerType())
3971  pointerKind = SimplePointerKind::MemberPointer;
3972 
3973  if (auto *attr = inferPointerNullability(
3974  pointerKind, D.getDeclSpec().getTypeSpecTypeLoc(),
3976  T = Context.getAttributedType(
3977  AttributedType::getNullabilityAttrKind(*inferNullability),T,T);
3978  attr->setUsedAsTypeAttr();
3979  }
3980  }
3981  }
3982 
3983  if (complainAboutMissingNullability == CAMN_Yes &&
3984  T->isArrayType() && !T->getNullability(S.Context) && !isVaList(T) &&
3985  D.isPrototypeContext() &&
3987  checkNullabilityConsistency(S, SimplePointerKind::Array,
3989  }
3990  }
3991 
3992  // Walk the DeclTypeInfo, building the recursive type as we go.
3993  // DeclTypeInfos are ordered from the identifier out, which is
3994  // opposite of what we want :).
3995  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
3996  unsigned chunkIndex = e - i - 1;
3997  state.setCurrentChunkIndex(chunkIndex);
3998  DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex);
3999  IsQualifiedFunction &= DeclType.Kind == DeclaratorChunk::Paren;
4000  switch (DeclType.Kind) {
4002  T = S.BuildParenType(T);
4003  break;
4005  // If blocks are disabled, emit an error.
4006  if (!LangOpts.Blocks)
4007  S.Diag(DeclType.Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4008 
4009  // Handle pointer nullability.
4010  inferPointerNullability(SimplePointerKind::BlockPointer,
4011  DeclType.Loc, DeclType.getAttrListRef());
4012 
4014  if (DeclType.Cls.TypeQuals || LangOpts.OpenCL) {
4015  // OpenCL v2.0, s6.12.5 - Block variable declarations are implicitly
4016  // qualified with const.
4017  if (LangOpts.OpenCL)
4018  DeclType.Cls.TypeQuals |= DeclSpec::TQ_const;
4019  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Cls.TypeQuals);
4020  }
4021  break;
4023  // Verify that we're not building a pointer to pointer to function with
4024  // exception specification.
4025  if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4026  S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4027  D.setInvalidType(true);
4028  // Build the type anyway.
4029  }
4030 
4031  // Handle pointer nullability
4032  inferPointerNullability(SimplePointerKind::Pointer, DeclType.Loc,
4033  DeclType.getAttrListRef());
4034 
4035  if (LangOpts.ObjC1 && T->getAs<ObjCObjectType>()) {
4036  T = Context.getObjCObjectPointerType(T);
4037  if (DeclType.Ptr.TypeQuals)
4038  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
4039  break;
4040  }
4041 
4042  // OpenCL v2.0 s6.9b - Pointer to image/sampler cannot be used.
4043  // OpenCL v2.0 s6.13.16.1 - Pointer to pipe cannot be used.
4044  // OpenCL v2.0 s6.12.5 - Pointers to Blocks are not allowed.
4045  if (LangOpts.OpenCL) {
4046  if (T->isImageType() || T->isSamplerT() || T->isPipeType() ||
4047  T->isBlockPointerType()) {
4048  S.Diag(D.getIdentifierLoc(), diag::err_opencl_pointer_to_type) << T;
4049  D.setInvalidType(true);
4050  }
4051  }
4052 
4053  T = S.BuildPointerType(T, DeclType.Loc, Name);
4054  if (DeclType.Ptr.TypeQuals)
4055  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
4056  break;
4058  // Verify that we're not building a reference to pointer to function with
4059  // exception specification.
4060  if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4061  S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4062  D.setInvalidType(true);
4063  // Build the type anyway.
4064  }
4065  T = S.BuildReferenceType(T, DeclType.Ref.LValueRef, DeclType.Loc, Name);
4066 
4067  if (DeclType.Ref.HasRestrict)
4068  T = S.BuildQualifiedType(T, DeclType.Loc, Qualifiers::Restrict);
4069  break;
4070  }
4071  case DeclaratorChunk::Array: {
4072  // Verify that we're not building an array of pointers to function with
4073  // exception specification.
4074  if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4075  S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4076  D.setInvalidType(true);
4077  // Build the type anyway.
4078  }
4079  DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
4080  Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
4082  if (ATI.isStar)
4083  ASM = ArrayType::Star;
4084  else if (ATI.hasStatic)
4085  ASM = ArrayType::Static;
4086  else
4087  ASM = ArrayType::Normal;
4088  if (ASM == ArrayType::Star && !D.isPrototypeContext()) {
4089  // FIXME: This check isn't quite right: it allows star in prototypes
4090  // for function definitions, and disallows some edge cases detailed
4091  // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html
4092  S.Diag(DeclType.Loc, diag::err_array_star_outside_prototype);
4093  ASM = ArrayType::Normal;
4094  D.setInvalidType(true);
4095  }
4096 
4097  // C99 6.7.5.2p1: The optional type qualifiers and the keyword static
4098  // shall appear only in a declaration of a function parameter with an
4099  // array type, ...
4100  if (ASM == ArrayType::Static || ATI.TypeQuals) {
4101  if (!(D.isPrototypeContext() ||
4103  S.Diag(DeclType.Loc, diag::err_array_static_outside_prototype) <<
4104  (ASM == ArrayType::Static ? "'static'" : "type qualifier");
4105  // Remove the 'static' and the type qualifiers.
4106  if (ASM == ArrayType::Static)
4107  ASM = ArrayType::Normal;
4108  ATI.TypeQuals = 0;
4109  D.setInvalidType(true);
4110  }
4111 
4112  // C99 6.7.5.2p1: ... and then only in the outermost array type
4113  // derivation.
4114  if (hasOuterPointerLikeChunk(D, chunkIndex)) {
4115  S.Diag(DeclType.Loc, diag::err_array_static_not_outermost) <<
4116  (ASM == ArrayType::Static ? "'static'" : "type qualifier");
4117  if (ASM == ArrayType::Static)
4118  ASM = ArrayType::Normal;
4119  ATI.TypeQuals = 0;
4120  D.setInvalidType(true);
4121  }
4122  }
4123  const AutoType *AT = T->getContainedAutoType();
4124  // Allow arrays of auto if we are a generic lambda parameter.
4125  // i.e. [](auto (&array)[5]) { return array[0]; }; OK
4127  // We've already diagnosed this for decltype(auto).
4128  if (!AT->isDecltypeAuto())
4129  S.Diag(DeclType.Loc, diag::err_illegal_decl_array_of_auto)
4130  << getPrintableNameForEntity(Name) << T;
4131  T = QualType();
4132  break;
4133  }
4134 
4135  // Array parameters can be marked nullable as well, although it's not
4136  // necessary if they're marked 'static'.
4137  if (complainAboutMissingNullability == CAMN_Yes &&
4138  !hasNullabilityAttr(DeclType.getAttrs()) &&
4139  ASM != ArrayType::Static &&
4140  D.isPrototypeContext() &&
4141  !hasOuterPointerLikeChunk(D, chunkIndex)) {
4142  checkNullabilityConsistency(S, SimplePointerKind::Array, DeclType.Loc);
4143  }
4144 
4145  T = S.BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals,
4146  SourceRange(DeclType.Loc, DeclType.EndLoc), Name);
4147  break;
4148  }
4150  // If the function declarator has a prototype (i.e. it is not () and
4151  // does not have a K&R-style identifier list), then the arguments are part
4152  // of the type, otherwise the argument list is ().
4153  const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
4154  IsQualifiedFunction = FTI.TypeQuals || FTI.hasRefQualifier();
4155 
4156  // Check for auto functions and trailing return type and adjust the
4157  // return type accordingly.
4158  if (!D.isInvalidType()) {
4159  // trailing-return-type is only required if we're declaring a function,
4160  // and not, for instance, a pointer to a function.
4161  if (D.getDeclSpec().hasAutoTypeSpec() &&
4162  !FTI.hasTrailingReturnType() && chunkIndex == 0 &&
4163  !S.getLangOpts().CPlusPlus14) {
4166  ? diag::err_auto_missing_trailing_return
4167  : diag::err_deduced_return_type);
4168  T = Context.IntTy;
4169  D.setInvalidType(true);
4170  } else if (FTI.hasTrailingReturnType()) {
4171  // T must be exactly 'auto' at this point. See CWG issue 681.
4172  if (isa<ParenType>(T)) {
4173  S.Diag(D.getLocStart(),
4174  diag::err_trailing_return_in_parens)
4175  << T << D.getSourceRange();
4176  D.setInvalidType(true);
4177  } else if (D.getName().getKind() ==
4179  if (T != Context.DependentTy) {
4180  S.Diag(D.getDeclSpec().getLocStart(),
4181  diag::err_deduction_guide_with_complex_decl)
4182  << D.getSourceRange();
4183  D.setInvalidType(true);
4184  }
4185  } else if (D.getContext() != Declarator::LambdaExprContext &&
4186  (T.hasQualifiers() || !isa<AutoType>(T) ||
4187  cast<AutoType>(T)->getKeyword() !=
4190  diag::err_trailing_return_without_auto)
4191  << T << D.getDeclSpec().getSourceRange();
4192  D.setInvalidType(true);
4193  }
4194  T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo);
4195  if (T.isNull()) {
4196  // An error occurred parsing the trailing return type.
4197  T = Context.IntTy;
4198  D.setInvalidType(true);
4199  }
4200  }
4201  }
4202 
4203  // C99 6.7.5.3p1: The return type may not be a function or array type.
4204  // For conversion functions, we'll diagnose this particular error later.
4205  if (!D.isInvalidType() && (T->isArrayType() || T->isFunctionType()) &&
4207  unsigned diagID = diag::err_func_returning_array_function;
4208  // Last processing chunk in block context means this function chunk
4209  // represents the block.
4210  if (chunkIndex == 0 &&
4212  diagID = diag::err_block_returning_array_function;
4213  S.Diag(DeclType.Loc, diagID) << T->isFunctionType() << T;
4214  T = Context.IntTy;
4215  D.setInvalidType(true);
4216  }
4217 
4218  // Do not allow returning half FP value.
4219  // FIXME: This really should be in BuildFunctionType.
4220  if (T->isHalfType()) {
4221  if (S.getLangOpts().OpenCL) {
4222  if (!S.getOpenCLOptions().isEnabled("cl_khr_fp16")) {
4223  S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4224  << T << 0 /*pointer hint*/;
4225  D.setInvalidType(true);
4226  }
4227  } else if (!S.getLangOpts().HalfArgsAndReturns) {
4228  S.Diag(D.getIdentifierLoc(),
4229  diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4230  D.setInvalidType(true);
4231  }
4232  }
4233 
4234  if (LangOpts.OpenCL) {
4235  // OpenCL v2.0 s6.12.5 - A block cannot be the return value of a
4236  // function.
4237  if (T->isBlockPointerType() || T->isImageType() || T->isSamplerT() ||
4238  T->isPipeType()) {
4239  S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4240  << T << 1 /*hint off*/;
4241  D.setInvalidType(true);
4242  }
4243  // OpenCL doesn't support variadic functions and blocks
4244  // (s6.9.e and s6.12.5 OpenCL v2.0) except for printf.
4245  // We also allow here any toolchain reserved identifiers.
4246  if (FTI.isVariadic &&
4247  !(D.getIdentifier() &&
4248  ((D.getIdentifier()->getName() == "printf" &&
4249  LangOpts.OpenCLVersion >= 120) ||
4250  D.getIdentifier()->getName().startswith("__")))) {
4251  S.Diag(D.getIdentifierLoc(), diag::err_opencl_variadic_function);
4252  D.setInvalidType(true);
4253  }
4254  }
4255 
4256  // Methods cannot return interface types. All ObjC objects are
4257  // passed by reference.
4258  if (T->isObjCObjectType()) {
4259  SourceLocation DiagLoc, FixitLoc;
4260  if (TInfo) {
4261  DiagLoc = TInfo->getTypeLoc().getLocStart();
4262  FixitLoc = S.getLocForEndOfToken(TInfo->getTypeLoc().getLocEnd());
4263  } else {
4264  DiagLoc = D.getDeclSpec().getTypeSpecTypeLoc();
4265  FixitLoc = S.getLocForEndOfToken(D.getDeclSpec().getLocEnd());
4266  }
4267  S.Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
4268  << 0 << T
4269  << FixItHint::CreateInsertion(FixitLoc, "*");
4270 
4271  T = Context.getObjCObjectPointerType(T);
4272  if (TInfo) {
4273  TypeLocBuilder TLB;
4274  TLB.pushFullCopy(TInfo->getTypeLoc());
4276  TLoc.setStarLoc(FixitLoc);
4277  TInfo = TLB.getTypeSourceInfo(Context, T);
4278  }
4279 
4280  D.setInvalidType(true);
4281  }
4282 
4283  // cv-qualifiers on return types are pointless except when the type is a
4284  // class type in C++.
4285  if ((T.getCVRQualifiers() || T->isAtomicType()) &&
4286  !(S.getLangOpts().CPlusPlus &&
4287  (T->isDependentType() || T->isRecordType()))) {
4288  if (T->isVoidType() && !S.getLangOpts().CPlusPlus &&
4290  // [6.9.1/3] qualified void return is invalid on a C
4291  // function definition. Apparently ok on declarations and
4292  // in C++ though (!)
4293  S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T;
4294  } else
4295  diagnoseRedundantReturnTypeQualifiers(S, T, D, chunkIndex);
4296  }
4297 
4298  // Objective-C ARC ownership qualifiers are ignored on the function
4299  // return type (by type canonicalization). Complain if this attribute
4300  // was written here.
4301  if (T.getQualifiers().hasObjCLifetime()) {
4302  SourceLocation AttrLoc;
4303  if (chunkIndex + 1 < D.getNumTypeObjects()) {
4304  DeclaratorChunk ReturnTypeChunk = D.getTypeObject(chunkIndex + 1);
4305  for (const AttributeList *Attr = ReturnTypeChunk.getAttrs();
4306  Attr; Attr = Attr->getNext()) {
4307  if (Attr->getKind() == AttributeList::AT_ObjCOwnership) {
4308  AttrLoc = Attr->getLoc();
4309  break;
4310  }
4311  }
4312  }
4313  if (AttrLoc.isInvalid()) {
4314  for (const AttributeList *Attr
4315  = D.getDeclSpec().getAttributes().getList();
4316  Attr; Attr = Attr->getNext()) {
4317  if (Attr->getKind() == AttributeList::AT_ObjCOwnership) {
4318  AttrLoc = Attr->getLoc();
4319  break;
4320  }
4321  }
4322  }
4323 
4324  if (AttrLoc.isValid()) {
4325  // The ownership attributes are almost always written via
4326  // the predefined
4327  // __strong/__weak/__autoreleasing/__unsafe_unretained.
4328  if (AttrLoc.isMacroID())
4329  AttrLoc = S.SourceMgr.getImmediateExpansionRange(AttrLoc).first;
4330 
4331  S.Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
4332  << T.getQualifiers().getObjCLifetime();
4333  }
4334  }
4335 
4336  if (LangOpts.CPlusPlus && D.getDeclSpec().hasTagDefinition()) {
4337  // C++ [dcl.fct]p6:
4338  // Types shall not be defined in return or parameter types.
4339  TagDecl *Tag = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
4340  S.Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
4341  << Context.getTypeDeclType(Tag);
4342  }
4343 
4344  // Exception specs are not allowed in typedefs. Complain, but add it
4345  // anyway.
4346  if (IsTypedefName && FTI.getExceptionSpecType() && !LangOpts.CPlusPlus1z)
4347  S.Diag(FTI.getExceptionSpecLocBeg(),
4348  diag::err_exception_spec_in_typedef)
4351 
4352  // If we see "T var();" or "T var(T());" at block scope, it is probably
4353  // an attempt to initialize a variable, not a function declaration.
4354  if (FTI.isAmbiguous)
4355  warnAboutAmbiguousFunction(S, D, DeclType, T);
4356 
4357  FunctionType::ExtInfo EI(getCCForDeclaratorChunk(S, D, FTI, chunkIndex));
4358 
4359  if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.CPlusPlus) {
4360  // Simple void foo(), where the incoming T is the result type.
4361  T = Context.getFunctionNoProtoType(T, EI);
4362  } else {
4363  // We allow a zero-parameter variadic function in C if the
4364  // function is marked with the "overloadable" attribute. Scan
4365  // for this attribute now.
4366  if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus) {
4367  bool Overloadable = false;
4368  for (const AttributeList *Attrs = D.getAttributes();
4369  Attrs; Attrs = Attrs->getNext()) {
4370  if (Attrs->getKind() == AttributeList::AT_Overloadable) {
4371  Overloadable = true;
4372  break;
4373  }
4374  }
4375 
4376  if (!Overloadable)
4377  S.Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_param);
4378  }
4379 
4380  if (FTI.NumParams && FTI.Params[0].Param == nullptr) {
4381  // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function
4382  // definition.
4383  S.Diag(FTI.Params[0].IdentLoc,
4384  diag::err_ident_list_in_fn_declaration);
4385  D.setInvalidType(true);
4386  // Recover by creating a K&R-style function type.
4387  T = Context.getFunctionNoProtoType(T, EI);
4388  break;
4389  }
4390 
4392  EPI.ExtInfo = EI;
4393  EPI.Variadic = FTI.isVariadic;
4395  EPI.TypeQuals = FTI.TypeQuals;
4396  EPI.RefQualifier = !FTI.hasRefQualifier()? RQ_None
4398  : RQ_RValue;
4399 
4400  // Otherwise, we have a function with a parameter list that is
4401  // potentially variadic.
4402  SmallVector<QualType, 16> ParamTys;
4403  ParamTys.reserve(FTI.NumParams);
4404 
4406  ExtParameterInfos(FTI.NumParams);
4407  bool HasAnyInterestingExtParameterInfos = false;
4408 
4409  for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
4410  ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
4411  QualType ParamTy = Param->getType();
4412  assert(!ParamTy.isNull() && "Couldn't parse type?");
4413 
4414  // Look for 'void'. void is allowed only as a single parameter to a
4415  // function with no other parameters (C99 6.7.5.3p10). We record
4416  // int(void) as a FunctionProtoType with an empty parameter list.
4417  if (ParamTy->isVoidType()) {
4418  // If this is something like 'float(int, void)', reject it. 'void'
4419  // is an incomplete type (C99 6.2.5p19) and function decls cannot
4420  // have parameters of incomplete type.
4421  if (FTI.NumParams != 1 || FTI.isVariadic) {
4422  S.Diag(DeclType.Loc, diag::err_void_only_param);
4423  ParamTy = Context.IntTy;
4424  Param->setType(ParamTy);
4425  } else if (FTI.Params[i].Ident) {
4426  // Reject, but continue to parse 'int(void abc)'.
4427  S.Diag(FTI.Params[i].IdentLoc, diag::err_param_with_void_type);
4428  ParamTy = Context.IntTy;
4429  Param->setType(ParamTy);
4430  } else {
4431  // Reject, but continue to parse 'float(const void)'.
4432  if (ParamTy.hasQualifiers())
4433  S.Diag(DeclType.Loc, diag::err_void_param_qualified);
4434 
4435  // Do not add 'void' to the list.
4436  break;
4437  }
4438  } else if (ParamTy->isHalfType()) {
4439  // Disallow half FP parameters.
4440  // FIXME: This really should be in BuildFunctionType.
4441  if (S.getLangOpts().OpenCL) {
4442  if (!S.getOpenCLOptions().isEnabled("cl_khr_fp16")) {
4443  S.Diag(Param->getLocation(),
4444  diag::err_opencl_half_param) << ParamTy;
4445  D.setInvalidType();
4446  Param->setInvalidDecl();
4447  }
4448  } else if (!S.getLangOpts().HalfArgsAndReturns) {
4449  S.Diag(Param->getLocation(),
4450  diag::err_parameters_retval_cannot_have_fp16_type) << 0;
4451  D.setInvalidType();
4452  }
4453  } else if (!FTI.hasPrototype) {
4454  if (ParamTy->isPromotableIntegerType()) {
4455  ParamTy = Context.getPromotedIntegerType(ParamTy);
4456  Param->setKNRPromoted(true);
4457  } else if (const BuiltinType* BTy = ParamTy->getAs<BuiltinType>()) {
4458  if (BTy->getKind() == BuiltinType::Float) {
4459  ParamTy = Context.DoubleTy;
4460  Param->setKNRPromoted(true);
4461  }
4462  }
4463  }
4464 
4465  if (LangOpts.ObjCAutoRefCount && Param->hasAttr<NSConsumedAttr>()) {
4466  ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(true);
4467  HasAnyInterestingExtParameterInfos = true;
4468  }
4469 
4470  if (auto attr = Param->getAttr<ParameterABIAttr>()) {
4471  ExtParameterInfos[i] =
4472  ExtParameterInfos[i].withABI(attr->getABI());
4473  HasAnyInterestingExtParameterInfos = true;
4474  }
4475 
4476  if (Param->hasAttr<PassObjectSizeAttr>()) {
4477  ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
4478  HasAnyInterestingExtParameterInfos = true;
4479  }
4480 
4481  ParamTys.push_back(ParamTy);
4482  }
4483 
4484  if (HasAnyInterestingExtParameterInfos) {
4485  EPI.ExtParameterInfos = ExtParameterInfos.data();
4486  checkExtParameterInfos(S, ParamTys, EPI,
4487  [&](unsigned i) { return FTI.Params[i].Param->getLocation(); });
4488  }
4489 
4490  SmallVector<QualType, 4> Exceptions;
4491  SmallVector<ParsedType, 2> DynamicExceptions;
4492  SmallVector<SourceRange, 2> DynamicExceptionRanges;
4493  Expr *NoexceptExpr = nullptr;
4494 
4495  if (FTI.getExceptionSpecType() == EST_Dynamic) {
4496  // FIXME: It's rather inefficient to have to split into two vectors
4497  // here.
4498  unsigned N = FTI.getNumExceptions();
4499  DynamicExceptions.reserve(N);
4500  DynamicExceptionRanges.reserve(N);
4501  for (unsigned I = 0; I != N; ++I) {
4502  DynamicExceptions.push_back(FTI.Exceptions[I].Ty);
4503  DynamicExceptionRanges.push_back(FTI.Exceptions[I].Range);
4504  }
4505  } else if (FTI.getExceptionSpecType() == EST_ComputedNoexcept) {
4506  NoexceptExpr = FTI.NoexceptExpr;
4507  }
4508 
4510  FTI.getExceptionSpecType(),
4511  DynamicExceptions,
4512  DynamicExceptionRanges,
4513  NoexceptExpr,
4514  Exceptions,
4515  EPI.ExceptionSpec);
4516 
4517  T = Context.getFunctionType(T, ParamTys, EPI);
4518  }
4519  break;
4520  }
4522  // The scope spec must refer to a class, or be dependent.
4523  CXXScopeSpec &SS = DeclType.Mem.Scope();
4524  QualType ClsType;
4525 
4526  // Handle pointer nullability.
4527  inferPointerNullability(SimplePointerKind::MemberPointer,
4528  DeclType.Loc, DeclType.getAttrListRef());
4529 
4530  if (SS.isInvalid()) {
4531  // Avoid emitting extra errors if we already errored on the scope.
4532  D.setInvalidType(true);
4533  } else if (S.isDependentScopeSpecifier(SS) ||
4534  dyn_cast_or_null<CXXRecordDecl>(S.computeDeclContext(SS))) {
4535  NestedNameSpecifier *NNS = SS.getScopeRep();
4536  NestedNameSpecifier *NNSPrefix = NNS->getPrefix();
4537  switch (NNS->getKind()) {
4539  ClsType = Context.getDependentNameType(ETK_None, NNSPrefix,
4540  NNS->getAsIdentifier());
4541  break;
4542 
4547  llvm_unreachable("Nested-name-specifier must name a type");
4548 
4551  ClsType = QualType(NNS->getAsType(), 0);
4552  // Note: if the NNS has a prefix and ClsType is a nondependent
4553  // TemplateSpecializationType, then the NNS prefix is NOT included
4554  // in ClsType; hence we wrap ClsType into an ElaboratedType.
4555  // NOTE: in particular, no wrap occurs if ClsType already is an
4556  // Elaborated, DependentName, or DependentTemplateSpecialization.
4557  if (NNSPrefix && isa<TemplateSpecializationType>(NNS->getAsType()))
4558  ClsType = Context.getElaboratedType(ETK_None, NNSPrefix, ClsType);
4559  break;
4560  }
4561  } else {
4562  S.Diag(DeclType.Mem.Scope().getBeginLoc(),
4563  diag::err_illegal_decl_mempointer_in_nonclass)
4564  << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
4565  << DeclType.Mem.Scope().getRange();
4566  D.setInvalidType(true);
4567  }
4568 
4569  if (!ClsType.isNull())
4570  T = S.BuildMemberPointerType(T, ClsType, DeclType.Loc,
4571  D.getIdentifier());
4572  if (T.isNull()) {
4573  T = Context.IntTy;
4574  D.setInvalidType(true);
4575  } else if (DeclType.Mem.TypeQuals) {
4576  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Mem.TypeQuals);
4577  }
4578  break;
4579  }
4580 
4581  case DeclaratorChunk::Pipe: {
4582  T = S.BuildReadPipeType(T, DeclType.Loc);
4583  processTypeAttrs(state, T, TAL_DeclSpec,
4585  break;
4586  }
4587  }
4588 
4589  if (T.isNull()) {
4590  D.setInvalidType(true);
4591  T = Context.IntTy;
4592  }
4593 
4594  // See if there are any attributes on this declarator chunk.
4595  processTypeAttrs(state, T, TAL_DeclChunk,
4596  const_cast<AttributeList *>(DeclType.getAttrs()));
4597  }
4598 
4599  // GNU warning -Wstrict-prototypes
4600  // Warn if a function declaration is without a prototype.
4601  // This warning is issued for all kinds of unprototyped function
4602  // declarations (i.e. function type typedef, function pointer etc.)
4603  // C99 6.7.5.3p14:
4604  // The empty list in a function declarator that is not part of a definition
4605  // of that function specifies that no information about the number or types
4606  // of the parameters is supplied.
4607  if (!LangOpts.CPlusPlus && D.getFunctionDefinitionKind() == FDK_Declaration) {
4608  bool IsBlock = false;
4609  for (const DeclaratorChunk &DeclType : D.type_objects()) {
4610  switch (DeclType.Kind) {
4612  IsBlock = true;
4613  break;
4615  const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
4616  if (FTI.NumParams == 0)
4617  S.Diag(DeclType.Loc, diag::warn_strict_prototypes)
4618  << IsBlock
4619  << FixItHint::CreateInsertion(FTI.getRParenLoc(), "void");
4620  IsBlock = false;
4621  break;
4622  }
4623  default:
4624  break;
4625  }
4626  }
4627  }
4628 
4629  assert(!T.isNull() && "T must not be null after this point");
4630 
4631  if (LangOpts.CPlusPlus && T->isFunctionType()) {
4632  const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>();
4633  assert(FnTy && "Why oh why is there not a FunctionProtoType here?");
4634 
4635  // C++ 8.3.5p4:
4636  // A cv-qualifier-seq shall only be part of the function type
4637  // for a nonstatic member function, the function type to which a pointer
4638  // to member refers, or the top-level function type of a function typedef
4639  // declaration.
4640  //
4641  // Core issue 547 also allows cv-qualifiers on function types that are
4642  // top-level template type arguments.
4643  enum { NonMember, Member, DeductionGuide } Kind = NonMember;
4645  Kind = DeductionGuide;
4646  else if (!D.getCXXScopeSpec().isSet()) {
4647  if ((D.getContext() == Declarator::MemberContext ||
4650  Kind = Member;
4651  } else {
4653  if (!DC || DC->isRecord())
4654  Kind = Member;
4655  }
4656 
4657  // C++11 [dcl.fct]p6 (w/DR1417):
4658  // An attempt to specify a function type with a cv-qualifier-seq or a
4659  // ref-qualifier (including by typedef-name) is ill-formed unless it is:
4660  // - the function type for a non-static member function,
4661  // - the function type to which a pointer to member refers,
4662  // - the top-level function type of a function typedef declaration or
4663  // alias-declaration,
4664  // - the type-id in the default argument of a type-parameter, or
4665  // - the type-id of a template-argument for a type-parameter
4666  //
4667  // FIXME: Checking this here is insufficient. We accept-invalid on:
4668  //
4669  // template<typename T> struct S { void f(T); };
4670  // S<int() const> s;
4671  //
4672  // ... for instance.
4673  if (IsQualifiedFunction &&
4674  !(Kind == Member &&
4676  !IsTypedefName &&
4678  SourceLocation Loc = D.getLocStart();
4679  SourceRange RemovalRange;
4680  unsigned I;
4681  if (D.isFunctionDeclarator(I)) {
4682  SmallVector<SourceLocation, 4> RemovalLocs;
4683  const DeclaratorChunk &Chunk = D.getTypeObject(I);
4684  assert(Chunk.Kind == DeclaratorChunk::Function);
4685  if (Chunk.Fun.hasRefQualifier())
4686  RemovalLocs.push_back(Chunk.Fun.getRefQualifierLoc());
4687  if (Chunk.Fun.TypeQuals & Qualifiers::Const)
4688  RemovalLocs.push_back(Chunk.Fun.getConstQualifierLoc());
4689  if (Chunk.Fun.TypeQuals & Qualifiers::Volatile)
4690  RemovalLocs.push_back(Chunk.Fun.getVolatileQualifierLoc());
4691  if (Chunk.Fun.TypeQuals & Qualifiers::Restrict)
4692  RemovalLocs.push_back(Chunk.Fun.getRestrictQualifierLoc());
4693  if (!RemovalLocs.empty()) {
4694  std::sort(RemovalLocs.begin(), RemovalLocs.end(),
4696  RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back());
4697  Loc = RemovalLocs.front();
4698  }
4699  }
4700 
4701  S.Diag(Loc, diag::err_invalid_qualified_function_type)
4702  << Kind << D.isFunctionDeclarator() << T
4704  << FixItHint::CreateRemoval(RemovalRange);
4705 
4706  // Strip the cv-qualifiers and ref-qualifiers from the type.
4708  EPI.TypeQuals = 0;
4709  EPI.RefQualifier = RQ_None;
4710 
4711  T = Context.getFunctionType(FnTy->getReturnType(), FnTy->getParamTypes(),
4712  EPI);
4713  // Rebuild any parens around the identifier in the function type.
4714  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
4716  break;
4717  T = S.BuildParenType(T);
4718  }
4719  }
4720  }
4721 
4722  // Apply any undistributed attributes from the declarator.
4724 
4725  // Diagnose any ignored type attributes.
4726  state.diagnoseIgnoredTypeAttrs(T);
4727 
4728  // C++0x [dcl.constexpr]p9:
4729  // A constexpr specifier used in an object declaration declares the object
4730  // as const.
4731  if (D.getDeclSpec().isConstexprSpecified() && T->isObjectType()) {
4732  T.addConst();
4733  }
4734 
4735  // If there was an ellipsis in the declarator, the declaration declares a
4736  // parameter pack whose type may be a pack expansion type.
4737  if (D.hasEllipsis()) {
4738  // C++0x [dcl.fct]p13:
4739  // A declarator-id or abstract-declarator containing an ellipsis shall
4740  // only be used in a parameter-declaration. Such a parameter-declaration
4741  // is a parameter pack (14.5.3). [...]
4742  switch (D.getContext()) {
4745  // C++0x [dcl.fct]p13:
4746  // [...] When it is part of a parameter-declaration-clause, the
4747  // parameter pack is a function parameter pack (14.5.3). The type T
4748  // of the declarator-id of the function parameter pack shall contain
4749  // a template parameter pack; each template parameter pack in T is
4750  // expanded by the function parameter pack.
4751  //
4752  // We represent function parameter packs as function parameters whose
4753  // type is a pack expansion.
4754  if (!T->containsUnexpandedParameterPack()) {
4755  S.Diag(D.getEllipsisLoc(),
4756  diag::err_function_parameter_pack_without_parameter_packs)
4757  << T << D.getSourceRange();
4759  } else {
4760  T = Context.getPackExpansionType(T, None);
4761  }
4762  break;
4764  // C++0x [temp.param]p15:
4765  // If a template-parameter is a [...] is a parameter-declaration that
4766  // declares a parameter pack (8.3.5), then the template-parameter is a
4767  // template parameter pack (14.5.3).
4768  //
4769  // Note: core issue 778 clarifies that, if there are any unexpanded
4770  // parameter packs in the type of the non-type template parameter, then
4771  // it expands those parameter packs.
4773  T = Context.getPackExpansionType(T, None);
4774  else
4775  S.Diag(D.getEllipsisLoc(),
4776  LangOpts.CPlusPlus11
4777  ? diag::warn_cxx98_compat_variadic_templates
4778  : diag::ext_variadic_templates);
4779  break;
4780 
4783  case Declarator::ObjCParameterContext: // FIXME: special diagnostic here?
4784  case Declarator::ObjCResultContext: // FIXME: special diagnostic here?
4802  // FIXME: We may want to allow parameter packs in block-literal contexts
4803  // in the future.
4804  S.Diag(D.getEllipsisLoc(),
4805  diag::err_ellipsis_in_declarator_not_parameter);
4807  break;
4808  }
4809  }
4810 
4811  assert(!T.isNull() && "T must not be null at the end of this function");
4812  if (D.isInvalidType())
4813  return Context.getTrivialTypeSourceInfo(T);
4814 
4815  return S.GetTypeSourceInfoForDeclarator(D, T, TInfo);
4816 }
4817 
4818 /// GetTypeForDeclarator - Convert the type for the specified
4819 /// declarator to Type instances.
4820 ///
4821 /// The result of this call will never be null, but the associated
4822 /// type may be a null type if there's an unrecoverable error.
4824  // Determine the type of the declarator. Not all forms of declarator
4825  // have a type.
4826 
4827  TypeProcessingState state(*this, D);
4828 
4829  TypeSourceInfo *ReturnTypeInfo = nullptr;
4830  QualType T = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
4831 
4832  if (D.isPrototypeContext() && getLangOpts().ObjCAutoRefCount)
4833  inferARCWriteback(state, T);
4834 
4835  return GetFullTypeForDeclarator(state, T, ReturnTypeInfo);
4836 }
4837 
4839  QualType &declSpecTy,
4840  Qualifiers::ObjCLifetime ownership) {
4841  if (declSpecTy->isObjCRetainableType() &&
4842  declSpecTy.getObjCLifetime() == Qualifiers::OCL_None) {
4843  Qualifiers qs;
4844  qs.addObjCLifetime(ownership);
4845  declSpecTy = S.Context.getQualifiedType(declSpecTy, qs);
4846  }
4847 }
4848 
4849 static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state,
4850  Qualifiers::ObjCLifetime ownership,
4851  unsigned chunkIndex) {
4852  Sema &S = state.getSema();
4853  Declarator &D = state.getDeclarator();
4854 
4855  // Look for an explicit lifetime attribute.
4856  DeclaratorChunk &chunk = D.getTypeObject(chunkIndex);
4857  for (const AttributeList *attr = chunk.getAttrs(); attr;
4858  attr = attr->getNext())
4859  if (attr->getKind() == AttributeList::AT_ObjCOwnership)
4860  return;
4861 
4862  const char *attrStr = nullptr;
4863  switch (ownership) {
4864  case Qualifiers::OCL_None: llvm_unreachable("no ownership!");
4865  case Qualifiers::OCL_ExplicitNone: attrStr = "none"; break;
4866  case Qualifiers::OCL_Strong: attrStr = "strong"; break;
4867  case Qualifiers::OCL_Weak: attrStr = "weak"; break;
4868  case Qualifiers::OCL_Autoreleasing: attrStr = "autoreleasing"; break;
4869  }
4870 
4871  IdentifierLoc *Arg = new (S.Context) IdentifierLoc;
4872  Arg->Ident = &S.Context.Idents.get(attrStr);
4873  Arg->Loc = SourceLocation();
4874 
4875  ArgsUnion Args(Arg);
4876 
4877  // If there wasn't one, add one (with an invalid source location
4878  // so that we don't make an AttributedType for it).
4879  AttributeList *attr = D.getAttributePool()
4880  .create(&S.Context.Idents.get("objc_ownership"), SourceLocation(),
4881  /*scope*/ nullptr, SourceLocation(),
4882  /*args*/ &Args, 1, AttributeList::AS_GNU);
4883  spliceAttrIntoList(*attr, chunk.getAttrListRef());
4884 
4885  // TODO: mark whether we did this inference?
4886 }
4887 
4888 /// \brief Used for transferring ownership in casts resulting in l-values.
4889 static void transferARCOwnership(TypeProcessingState &state,
4890  QualType &declSpecTy,
4891  Qualifiers::ObjCLifetime ownership) {
4892  Sema &S = state.getSema();
4893  Declarator &D = state.getDeclarator();
4894 
4895  int inner = -1;
4896  bool hasIndirection = false;
4897  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
4898  DeclaratorChunk &chunk = D.getTypeObject(i);
4899  switch (chunk.Kind) {
4901  // Ignore parens.
4902  break;
4903 
4907  if (inner != -1)
4908  hasIndirection = true;
4909  inner = i;
4910  break;
4911 
4913  if (inner != -1)
4914  transferARCOwnershipToDeclaratorChunk(state, ownership, i);
4915  return;
4916 
4919  case DeclaratorChunk::Pipe:
4920  return;
4921  }
4922  }
4923 
4924  if (inner == -1)
4925  return;
4926 
4927  DeclaratorChunk &chunk = D.getTypeObject(inner);
4928  if (chunk.Kind == DeclaratorChunk::Pointer) {
4929  if (declSpecTy->isObjCRetainableType())
4930  return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership);
4931  if (declSpecTy->isObjCObjectType() && hasIndirection)
4932  return transferARCOwnershipToDeclaratorChunk(state, ownership, inner);
4933  } else {
4934  assert(chunk.Kind == DeclaratorChunk::Array ||
4935  chunk.Kind == DeclaratorChunk::Reference);
4936  return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership);
4937  }
4938 }
4939 
4941  TypeProcessingState state(*this, D);
4942 
4943  TypeSourceInfo *ReturnTypeInfo = nullptr;
4944  QualType declSpecTy = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
4945 
4946  if (getLangOpts().ObjC1) {
4948  if (ownership != Qualifiers::OCL_None)
4949  transferARCOwnership(state, declSpecTy, ownership);
4950  }
4951 
4952  return GetFullTypeForDeclarator(state, declSpecTy, ReturnTypeInfo);
4953 }
4954 
4955 /// Map an AttributedType::Kind to an AttributeList::Kind.
4957  switch (kind) {
4959  return AttributeList::AT_AddressSpace;
4961  return AttributeList::AT_Regparm;
4963  return AttributeList::AT_VectorSize;
4965  return AttributeList::AT_NeonVectorType;
4967  return AttributeList::AT_NeonPolyVectorType;
4969  return AttributeList::AT_ObjCGC;
4972  return AttributeList::AT_ObjCOwnership;
4974  return AttributeList::AT_NoReturn;
4976  return AttributeList::AT_CDecl;
4978  return AttributeList::AT_FastCall;
4980  return AttributeList::AT_StdCall;
4982  return AttributeList::AT_ThisCall;
4984  return AttributeList::AT_RegCall;
4986  return AttributeList::AT_Pascal;
4988  return AttributeList::AT_SwiftCall;
4990  return AttributeList::AT_VectorCall;
4993  return AttributeList::AT_Pcs;
4995  return AttributeList::AT_IntelOclBicc;
4997  return AttributeList::AT_MSABI;
4999  return AttributeList::AT_SysVABI;
5001  return AttributeList::AT_PreserveMost;
5003  return AttributeList::AT_PreserveAll;
5005  return AttributeList::AT_Ptr32;
5007  return AttributeList::AT_Ptr64;
5009  return AttributeList::AT_SPtr;
5011  return AttributeList::AT_UPtr;
5013  return AttributeList::AT_TypeNonNull;
5015  return AttributeList::AT_TypeNullable;
5017  return AttributeList::AT_TypeNullUnspecified;
5019  return AttributeList::AT_ObjCKindOf;
5021  return AttributeList::AT_NSReturnsRetained;
5022  }
5023  llvm_unreachable("unexpected attribute kind!");
5024 }
5025 
5027  const AttributeList *attrs,
5028  const AttributeList *DeclAttrs = nullptr) {
5029  // DeclAttrs and attrs cannot be both empty.
5030  assert((attrs || DeclAttrs) &&
5031  "no type attributes in the expected location!");
5032 
5033  AttributeList::Kind parsedKind = getAttrListKind(TL.getAttrKind());
5034  // Try to search for an attribute of matching kind in attrs list.
5035  while (attrs && attrs->getKind() != parsedKind)
5036  attrs = attrs->getNext();
5037  if (!attrs) {
5038  // No matching type attribute in attrs list found.
5039  // Try searching through C++11 attributes in the declarator attribute list.
5040  while (DeclAttrs && (!DeclAttrs->isCXX11Attribute() ||
5041  DeclAttrs->getKind() != parsedKind))
5042  DeclAttrs = DeclAttrs->getNext();
5043  attrs = DeclAttrs;
5044  }
5045 
5046  assert(attrs && "no matching type attribute in expected location!");
5047 
5048  TL.setAttrNameLoc(attrs->getLoc());
5049  if (TL.hasAttrExprOperand()) {
5050  assert(attrs->isArgExpr(0) && "mismatched attribute operand kind");
5051  TL.setAttrExprOperand(attrs->getArgAsExpr(0));
5052  } else if (TL.hasAttrEnumOperand()) {
5053  assert((attrs->isArgIdent(0) || attrs->isArgExpr(0)) &&
5054  "unexpected attribute operand kind");
5055  if (attrs->isArgIdent(0))
5056  TL.setAttrEnumOperandLoc(attrs->getArgAsIdent(0)->Loc);
5057  else
5059  }
5060 
5061  // FIXME: preserve this information to here.
5062  if (TL.hasAttrOperand())
5064 }
5065 
5066 namespace {
5067  class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> {
5069  const DeclSpec &DS;
5070 
5071  public:
5072  TypeSpecLocFiller(ASTContext &Context, const DeclSpec &DS)
5073  : Context(Context), DS(DS) {}
5074 
5075  void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5077  Visit(TL.getModifiedLoc());
5078  }
5079  void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5080  Visit(TL.getUnqualifiedLoc());
5081  }
5082  void VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5083  TL.setNameLoc(DS.getTypeSpecTypeLoc());
5084  }
5085  void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5086  TL.setNameLoc(DS.getTypeSpecTypeLoc());
5087  // FIXME. We should have DS.getTypeSpecTypeEndLoc(). But, it requires
5088  // addition field. What we have is good enough for dispay of location
5089  // of 'fixit' on interface name.
5090  TL.setNameEndLoc(DS.getLocEnd());
5091  }
5092  void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5093  TypeSourceInfo *RepTInfo = nullptr;
5094  Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo);
5095  TL.copy(RepTInfo->getTypeLoc());
5096  }
5097  void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5098  TypeSourceInfo *RepTInfo = nullptr;
5099  Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo);
5100  TL.copy(RepTInfo->getTypeLoc());
5101  }
5102  void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
5103  TypeSourceInfo *TInfo = nullptr;
5104  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5105 
5106  // If we got no declarator info from previous Sema routines,
5107  // just fill with the typespec loc.
5108  if (!TInfo) {
5110  return;
5111  }
5112 
5113  TypeLoc OldTL = TInfo->getTypeLoc();
5114  if (TInfo->getType()->getAs<ElaboratedType>()) {
5115  ElaboratedTypeLoc ElabTL = OldTL.castAs<ElaboratedTypeLoc>();
5118  TL.copy(NamedTL);
5119  } else {
5121  assert(TL.getRAngleLoc() == OldTL.castAs<TemplateSpecializationTypeLoc>().getRAngleLoc());
5122  }
5123 
5124  }
5125  void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5126  assert(DS.getTypeSpecType() == DeclSpec::TST_typeofExpr);
5129  }
5130  void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5131  assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType);
5134  assert(DS.getRepAsType());
5135  TypeSourceInfo *TInfo = nullptr;
5136  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5137  TL.setUnderlyingTInfo(TInfo);
5138  }
5139  void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5140  // FIXME: This holds only because we only have one unary transform.
5142  TL.setKWLoc(DS.getTypeSpecTypeLoc());
5144  assert(DS.getRepAsType());
5145  TypeSourceInfo *TInfo = nullptr;
5146  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5147  TL.setUnderlyingTInfo(TInfo);
5148  }
5149  void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5150  // By default, use the source location of the type specifier.
5152  if (TL.needsExtraLocalData()) {
5153  // Set info for the written builtin specifiers.
5155  // Try to have a meaningful source location.
5156  if (TL.getWrittenSignSpec() != TSS_unspecified)
5160  }
5161  }
5162  void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5163  ElaboratedTypeKeyword Keyword
5165  if (DS.getTypeSpecType() == TST_typename) {
5166  TypeSourceInfo *TInfo = nullptr;
5167  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5168  if (TInfo) {
5169  TL.copy(TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>());
5170  return;
5171  }
5172  }
5173  TL.setElaboratedKeywordLoc(Keyword != ETK_None
5174  ? DS.getTypeSpecTypeLoc()
5175  : SourceLocation());
5176  const CXXScopeSpec& SS = DS.getTypeSpecScope();
5178  Visit(TL.getNextTypeLoc().getUnqualifiedLoc());
5179  }
5180  void VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5181  assert(DS.getTypeSpecType() == TST_typename);
5182  TypeSourceInfo *TInfo = nullptr;
5183  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5184  assert(TInfo);
5185  TL.copy(TInfo->getTypeLoc().castAs<DependentNameTypeLoc>());
5186  }
5187  void VisitDependentTemplateSpecializationTypeLoc(
5189  assert(DS.getTypeSpecType() == TST_typename);
5190  TypeSourceInfo *TInfo = nullptr;
5191  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5192  assert(TInfo);
5193  TL.copy(
5194  TInfo->getTypeLoc().castAs<DependentTemplateSpecializationTypeLoc>());
5195  }
5196  void VisitTagTypeLoc(TagTypeLoc TL) {
5198  }
5199  void VisitAtomicTypeLoc(AtomicTypeLoc TL) {
5200  // An AtomicTypeLoc can come from either an _Atomic(...) type specifier
5201  // or an _Atomic qualifier.
5202  if (DS.getTypeSpecType() == DeclSpec::TST_atomic) {
5203  TL.setKWLoc(DS.getTypeSpecTypeLoc());
5205 
5206  TypeSourceInfo *TInfo = nullptr;
5207  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5208  assert(TInfo);
5209  TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc());
5210  } else {
5211  TL.setKWLoc(DS.getAtomicSpecLoc());
5212  // No parens, to indicate this was spelled as an _Atomic qualifier.
5214  Visit(TL.getValueLoc());
5215  }
5216  }
5217 
5218  void VisitPipeTypeLoc(PipeTypeLoc TL) {
5219  TL.setKWLoc(DS.getTypeSpecTypeLoc());
5220 
5221  TypeSourceInfo *TInfo = nullptr;
5222  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5223  TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc());
5224  }
5225 
5226  void VisitTypeLoc(TypeLoc TL) {
5227  // FIXME: add other typespec types and change this to an assert.
5229  }
5230  };
5231 
5232  class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> {
5234  const DeclaratorChunk &Chunk;
5235 
5236  public:
5237  DeclaratorLocFiller(ASTContext &Context, const DeclaratorChunk &Chunk)
5238  : Context(Context), Chunk(Chunk) {}
5239 
5240  void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5241  llvm_unreachable("qualified type locs not expected here!");
5242  }
5243  void VisitDecayedTypeLoc(DecayedTypeLoc TL) {
5244  llvm_unreachable("decayed type locs not expected here!");
5245  }
5246 
5247  void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5248  fillAttributedTypeLoc(TL, Chunk.getAttrs());
5249  }
5250  void VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
5251  // nothing
5252  }
5253  void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
5254  assert(Chunk.Kind == DeclaratorChunk::BlockPointer);
5255  TL.setCaretLoc(Chunk.Loc);
5256  }
5257  void VisitPointerTypeLoc(PointerTypeLoc TL) {
5258  assert(Chunk.Kind == DeclaratorChunk::Pointer);
5259  TL.setStarLoc(Chunk.Loc);
5260  }
5261  void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5262  assert(Chunk.Kind == DeclaratorChunk::Pointer);
5263  TL.setStarLoc(Chunk.Loc);
5264  }
5265  void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
5266  assert(Chunk.Kind == DeclaratorChunk::MemberPointer);
5267  const CXXScopeSpec& SS = Chunk.Mem.Scope();
5269 
5270  const Type* ClsTy = TL.getClass();
5271  QualType ClsQT = QualType(ClsTy, 0);
5272  TypeSourceInfo *ClsTInfo = Context.CreateTypeSourceInfo(ClsQT, 0);
5273  // Now copy source location info into the type loc component.
5274  TypeLoc ClsTL = ClsTInfo->getTypeLoc();
5275  switch (NNSLoc.getNestedNameSpecifier()->getKind()) {
5277  assert(isa<DependentNameType>(ClsTy) && "Unexpected TypeLoc");
5278  {
5281  DNTLoc.setQualifierLoc(NNSLoc.getPrefix());
5282  DNTLoc.setNameLoc(NNSLoc.getLocalBeginLoc());
5283  }
5284  break;
5285 
5288  if (isa<ElaboratedType>(ClsTy)) {
5289  ElaboratedTypeLoc ETLoc = ClsTL.castAs<ElaboratedTypeLoc>();
5291  ETLoc.setQualifierLoc(NNSLoc.getPrefix());
5292  TypeLoc NamedTL = ETLoc.getNamedTypeLoc();
5293  NamedTL.initializeFullCopy(NNSLoc.getTypeLoc());
5294  } else {
5295  ClsTL.initializeFullCopy(NNSLoc.getTypeLoc());
5296  }
5297  break;
5298 
5303  llvm_unreachable("Nested-name-specifier must name a type");
5304  }
5305 
5306  // Finally fill in MemberPointerLocInfo fields.
5307  TL.setStarLoc(Chunk.Loc);
5308  TL.setClassTInfo(ClsTInfo);
5309  }
5310  void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
5311  assert(Chunk.Kind == DeclaratorChunk::Reference);
5312  // 'Amp' is misleading: this might have been originally
5313  /// spelled with AmpAmp.
5314  TL.setAmpLoc(Chunk.Loc);
5315  }
5316  void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
5317  assert(Chunk.Kind == DeclaratorChunk::Reference);
5318  assert(!Chunk.Ref.LValueRef);
5319  TL.setAmpAmpLoc(Chunk.Loc);
5320  }
5321  void VisitArrayTypeLoc(ArrayTypeLoc TL) {
5322  assert(Chunk.Kind == DeclaratorChunk::Array);
5323  TL.setLBracketLoc(Chunk.Loc);
5324  TL.setRBracketLoc(Chunk.EndLoc);
5325  TL.setSizeExpr(static_cast<Expr*>(Chunk.Arr.NumElts));
5326  }
5327  void VisitFunctionTypeLoc(FunctionTypeLoc TL) {
5328  assert(Chunk.Kind == DeclaratorChunk::Function);
5329  TL.setLocalRangeBegin(Chunk.Loc);
5330  TL.setLocalRangeEnd(Chunk.EndLoc);
5331 
5332  const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.Fun;
5333  TL.setLParenLoc(FTI.getLParenLoc());
5334  TL.setRParenLoc(FTI.getRParenLoc());
5335  for (unsigned i = 0, e = TL.getNumParams(), tpi = 0; i != e; ++i) {
5336  ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
5337  TL.setParam(tpi++, Param);
5338  }
5340  }
5341  void VisitParenTypeLoc(ParenTypeLoc TL) {
5342  assert(Chunk.Kind == DeclaratorChunk::Paren);
5343  TL.setLParenLoc(Chunk.Loc);
5344  TL.setRParenLoc(Chunk.EndLoc);
5345  }
5346  void VisitPipeTypeLoc(PipeTypeLoc TL) {
5347  assert(Chunk.Kind == DeclaratorChunk::Pipe);
5348  TL.setKWLoc(Chunk.Loc);
5349  }
5350 
5351  void VisitTypeLoc(TypeLoc TL) {
5352  llvm_unreachable("unsupported TypeLoc kind in declarator!");
5353  }
5354  };
5355 } // end anonymous namespace
5356 
5357 static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk) {
5358  SourceLocation Loc;
5359  switch (Chunk.Kind) {
5363  case DeclaratorChunk::Pipe:
5364  llvm_unreachable("cannot be _Atomic qualified");
5365 
5368  break;
5369 
5373  // FIXME: Provide a source location for the _Atomic keyword.
5374  break;
5375  }
5376 
5377  ATL.setKWLoc(Loc);
5378  ATL.setParensRange(SourceRange());
5379 }
5380 
5381 /// \brief Create and instantiate a TypeSourceInfo with type source information.
5382 ///
5383 /// \param T QualType referring to the type as written in source code.
5384 ///
5385 /// \param ReturnTypeInfo For declarators whose return type does not show
5386 /// up in the normal place in the declaration specifiers (such as a C++
5387 /// conversion function), this pointer will refer to a type source information
5388 /// for that return type.
5391  TypeSourceInfo *ReturnTypeInfo) {
5393  UnqualTypeLoc CurrTL = TInfo->getTypeLoc().getUnqualifiedLoc();
5394  const AttributeList *DeclAttrs = D.getAttributes();
5395 
5396  // Handle parameter packs whose type is a pack expansion.
5397  if (isa<PackExpansionType>(T)) {
5398  CurrTL.castAs<PackExpansionTypeLoc>().setEllipsisLoc(D.getEllipsisLoc());
5399  CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc();
5400  }
5401 
5402  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
5403  // An AtomicTypeLoc might be produced by an atomic qualifier in this
5404  // declarator chunk.
5405  if (AtomicTypeLoc ATL = CurrTL.getAs<AtomicTypeLoc>()) {
5406  fillAtomicQualLoc(ATL, D.getTypeObject(i));
5407  CurrTL = ATL.getValueLoc().getUnqualifiedLoc();
5408  }
5409 
5410  while (AttributedTypeLoc TL = CurrTL.getAs<AttributedTypeLoc>()) {
5411  fillAttributedTypeLoc(TL, D.getTypeObject(i).getAttrs(), DeclAttrs);
5412  CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc();
5413  }
5414 
5415  // FIXME: Ordering here?
5416  while (AdjustedTypeLoc TL = CurrTL.getAs<AdjustedTypeLoc>())
5417  CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc();
5418 
5419  DeclaratorLocFiller(Context, D.getTypeObject(i)).Visit(CurrTL);
5420  CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc();
5421  }
5422 
5423  // If we have different source information for the return type, use
5424  // that. This really only applies to C++ conversion functions.
5425  if (ReturnTypeInfo) {
5426  TypeLoc TL = ReturnTypeInfo->getTypeLoc();
5427  assert(TL.getFullDataSize() == CurrTL.getFullDataSize());
5428  memcpy(CurrTL.getOpaqueData(), TL.getOpaqueData(), TL.getFullDataSize());
5429  } else {
5430  TypeSpecLocFiller(Context, D.getDeclSpec()).Visit(CurrTL);
5431  }
5432 
5433  return TInfo;
5434 }
5435 
5436 /// \brief Create a LocInfoType to hold the given QualType and TypeSourceInfo.
5438  // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser
5439  // and Sema during declaration parsing. Try deallocating/caching them when
5440  // it's appropriate, instead of allocating them and keeping them around.
5441  LocInfoType *LocT = (LocInfoType*)BumpAlloc.Allocate(sizeof(LocInfoType),
5442  TypeAlignment);
5443  new (LocT) LocInfoType(T, TInfo);
5444  assert(LocT->getTypeClass() != T->getTypeClass() &&
5445  "LocInfoType's TypeClass conflicts with an existing Type class");
5446  return ParsedType::make(QualType(LocT, 0));
5447 }
5448 
5449 void LocInfoType::getAsStringInternal(std::string &Str,
5450  const PrintingPolicy &Policy) const {
5451  llvm_unreachable("LocInfoType leaked into the type system; an opaque TypeTy*"
5452  " was used directly instead of getting the QualType through"
5453  " GetTypeFromParser");
5454 }
5455 
5457  // C99 6.7.6: Type names have no identifier. This is already validated by
5458  // the parser.
5459  assert(D.getIdentifier() == nullptr &&
5460  "Type name should have no identifier!");
5461 
5462  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
5463  QualType T = TInfo->getType();
5464  if (D.isInvalidType())
5465  return true;
5466 
5467  // Make sure there are no unused decl attributes on the declarator.
5468  // We don't want to do this for ObjC parameters because we're going
5469  // to apply them to the actual parameter declaration.
5470  // Likewise, we don't want to do this for alias declarations, because
5471  // we are actually going to build a declaration from this eventually.
5476 
5477  if (getLangOpts().CPlusPlus) {
5478  // Check that there are no default arguments (C++ only).
5480  }
5481 
5482  return CreateParsedType(T, TInfo);
5483 }
5484 
5488  return CreateParsedType(T, TInfo);
5489 }
5490 
5491 //===----------------------------------------------------------------------===//
5492 // Type Attribute Processing
5493 //===----------------------------------------------------------------------===//
5494 
5495 /// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
5496 /// specified type. The attribute contains 1 argument, the id of the address
5497 /// space for the type.
5499  const AttributeList &Attr, Sema &S){
5500 
5501  // If this type is already address space qualified, reject it.
5502  // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "No type shall be qualified by
5503  // qualifiers for two or more different address spaces."
5504  if (Type.getAddressSpace()) {
5505  S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers);
5506  Attr.setInvalid();
5507  return;
5508  }
5509 
5510  // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "A function type shall not be
5511  // qualified by an address-space qualifier."
5512  if (Type->isFunctionType()) {
5513  S.Diag(Attr.getLoc(), diag::err_attribute_address_function_type);
5514  Attr.setInvalid();
5515  return;
5516  }
5517 
5518  unsigned ASIdx;
5519  if (Attr.getKind() == AttributeList::AT_AddressSpace) {
5520  // Check the attribute arguments.
5521  if (Attr.getNumArgs() != 1) {
5522  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
5523  << Attr.getName() << 1;
5524  Attr.setInvalid();
5525  return;
5526  }
5527  Expr *ASArgExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
5528  llvm::APSInt addrSpace(32);
5529  if (ASArgExpr->isTypeDependent() || ASArgExpr->isValueDependent() ||
5530  !ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) {
5531  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
5533  << ASArgExpr->getSourceRange();
5534  Attr.setInvalid();
5535  return;
5536  }
5537 
5538  // Bounds checking.
5539  if (addrSpace.isSigned()) {
5540  if (addrSpace.isNegative()) {
5541  S.Diag(Attr.getLoc(), diag::err_attribute_address_space_negative)
5542  << ASArgExpr->getSourceRange();
5543  Attr.setInvalid();
5544  return;
5545  }
5546  addrSpace.setIsSigned(false);
5547  }
5548  llvm::APSInt max(addrSpace.getBitWidth());
5550  if (addrSpace > max) {
5551  S.Diag(Attr.getLoc(), diag::err_attribute_address_space_too_high)
5552  << (unsigned)max.getZExtValue() << ASArgExpr->getSourceRange();
5553  Attr.setInvalid();
5554  return;
5555  }
5556  ASIdx = static_cast<unsigned>(addrSpace.getZExtValue()) +
5557  LangAS::FirstTargetAddressSpace;
5558  } else {
5559  // The keyword-based type attributes imply which address space to use.
5560  switch (Attr.getKind()) {
5561  case AttributeList::AT_OpenCLGlobalAddressSpace:
5562  ASIdx = LangAS::opencl_global; break;
5563  case AttributeList::AT_OpenCLLocalAddressSpace:
5564  ASIdx = LangAS::opencl_local; break;
5565  case AttributeList::AT_OpenCLConstantAddressSpace:
5566  ASIdx = LangAS::opencl_constant; break;
5567  case AttributeList::AT_OpenCLGenericAddressSpace:
5568  ASIdx = LangAS::opencl_generic; break;
5569  default:
5570  assert(Attr.getKind() == AttributeList::AT_OpenCLPrivateAddressSpace);
5571  ASIdx = 0; break;
5572  }
5573  }
5574 
5575  Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
5576 }
5577 
5578 /// Does this type have a "direct" ownership qualifier? That is,
5579 /// is it written like "__strong id", as opposed to something like
5580 /// "typeof(foo)", where that happens to be strong?
5582  // Fast path: no qualifier at all.
5583  assert(type.getQualifiers().hasObjCLifetime());
5584 
5585  while (true) {
5586  // __strong id
5587  if (const AttributedType *attr = dyn_cast<AttributedType>(type)) {
5588  if (attr->getAttrKind() == AttributedType::attr_objc_ownership)
5589  return true;
5590 
5591  type = attr->getModifiedType();
5592 
5593  // X *__strong (...)
5594  } else if (const ParenType *paren = dyn_cast<ParenType>(type)) {
5595  type = paren->getInnerType();
5596 
5597  // That's it for things we want to complain about. In particular,
5598  // we do not want to look through typedefs, typeof(expr),
5599  // typeof(type), or any other way that the type is somehow
5600  // abstracted.
5601  } else {
5602 
5603  return false;
5604  }
5605  }
5606 }
5607 
5608 /// handleObjCOwnershipTypeAttr - Process an objc_ownership
5609 /// attribute on the specified type.
5610 ///
5611 /// Returns 'true' if the attribute was handled.
5612 static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state,
5613  AttributeList &attr,
5614  QualType &type) {
5615  bool NonObjCPointer = false;
5616 
5617  if (!type->isDependentType() && !type->isUndeducedType()) {
5618  if (const PointerType *ptr = type->getAs<PointerType>()) {
5619  QualType pointee = ptr->getPointeeType();
5620  if (pointee->isObjCRetainableType() || pointee->isPointerType())
5621  return false;
5622  // It is important not to lose the source info that there was an attribute
5623  // applied to non-objc pointer. We will create an attributed type but
5624  // its type will be the same as the original type.
5625  NonObjCPointer = true;
5626  } else if (!type->isObjCRetainableType()) {
5627  return false;
5628  }
5629 
5630  // Don't accept an ownership attribute in the declspec if it would
5631  // just be the return type of a block pointer.
5632  if (state.isProcessingDeclSpec()) {
5633  Declarator &D = state.getDeclarator();
5635  /*onlyBlockPointers=*/true))
5636  return false;
5637  }
5638  }
5639 
5640  Sema &S = state.getSema();
5641  SourceLocation AttrLoc = attr.getLoc();
5642  if (AttrLoc.isMacroID())
5643  AttrLoc = S.getSourceManager().getImmediateExpansionRange(AttrLoc).first;
5644 
5645  if (!attr.isArgIdent(0)) {
5646  S.Diag(AttrLoc, diag::err_attribute_argument_type)
5647  << attr.getName() << AANT_ArgumentString;
5648  attr.setInvalid();
5649  return true;
5650  }
5651 
5652  IdentifierInfo *II = attr.getArgAsIdent(0)->Ident;
5653  Qualifiers::ObjCLifetime lifetime;
5654  if (II->isStr("none"))
5655  lifetime = Qualifiers::OCL_ExplicitNone;
5656  else if (II->isStr("strong"))
5657  lifetime = Qualifiers::OCL_Strong;
5658  else if (II->isStr("weak"))
5659  lifetime = Qualifiers::OCL_Weak;
5660  else if (II->isStr("autoreleasing"))
5661  lifetime = Qualifiers::OCL_Autoreleasing;
5662  else {
5663  S.Diag(AttrLoc, diag::warn_attribute_type_not_supported)
5664  << attr.getName() << II;
5665  attr.setInvalid();
5666  return true;
5667  }
5668 
5669  // Just ignore lifetime attributes other than __weak and __unsafe_unretained
5670  // outside of ARC mode.
5671  if (!S.getLangOpts().ObjCAutoRefCount &&
5672  lifetime != Qualifiers::OCL_Weak &&
5673  lifetime != Qualifiers::OCL_ExplicitNone) {
5674  return true;
5675  }
5676 
5677  SplitQualType underlyingType = type.split();
5678 
5679  // Check for redundant/conflicting ownership qualifiers.
5680  if (Qualifiers::ObjCLifetime previousLifetime
5681  = type.getQualifiers().getObjCLifetime()) {
5682  // If it's written directly, that's an error.
5683  if (hasDirectOwnershipQualifier(type)) {
5684  S.Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
5685  << type;
5686  return true;
5687  }
5688 
5689  // Otherwise, if the qualifiers actually conflict, pull sugar off
5690  // and remove the ObjCLifetime qualifiers.
5691  if (previousLifetime != lifetime) {
5692  // It's possible to have multiple local ObjCLifetime qualifiers. We
5693  // can't stop after we reach a type that is directly qualified.
5694  const Type *prevTy = nullptr;
5695  while (!prevTy || prevTy != underlyingType.Ty) {
5696  prevTy = underlyingType.Ty;
5697  underlyingType = underlyingType.getSingleStepDesugaredType();
5698  }
5699  underlyingType.Quals.removeObjCLifetime();
5700  }
5701  }
5702 
5703  underlyingType.Quals.addObjCLifetime(lifetime);
5704 
5705  if (NonObjCPointer) {
5706  StringRef name = attr.getName()->getName();
5707  switch (lifetime) {
5708  case Qualifiers::OCL_None:
5710  break;
5711  case Qualifiers::OCL_Strong: name = "__strong"; break;
5712  case Qualifiers::OCL_Weak: name = "__weak"; break;
5713  case Qualifiers::OCL_Autoreleasing: name = "__autoreleasing"; break;
5714  }
5715  S.Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
5716  << TDS_ObjCObjOrBlock << type;
5717  }
5718 
5719  // Don't actually add the __unsafe_unretained qualifier in non-ARC files,
5720  // because having both 'T' and '__unsafe_unretained T' exist in the type
5721  // system causes unfortunate widespread consistency problems. (For example,
5722  // they're not considered compatible types, and we mangle them identicially
5723  // as template arguments.) These problems are all individually fixable,
5724  // but it's easier to just not add the qualifier and instead sniff it out
5725  // in specific places using isObjCInertUnsafeUnretainedType().
5726  //
5727  // Doing this does means we miss some trivial consistency checks that
5728  // would've triggered in ARC, but that's better than trying to solve all
5729  // the coexistence problems with __unsafe_unretained.
5730  if (!S.getLangOpts().ObjCAutoRefCount &&
5731  lifetime == Qualifiers::OCL_ExplicitNone) {
5732  type = S.Context.getAttributedType(
5734  type, type);
5735  return true;
5736  }
5737 
5738  QualType origType = type;
5739  if (!NonObjCPointer)
5740  type = S.Context.getQualifiedType(underlyingType);
5741 
5742  // If we have a valid source location for the attribute, use an
5743  // AttributedType instead.
5744  if (AttrLoc.isValid())
5746  origType, type);
5747 
5748  auto diagnoseOrDelay = [](Sema &S, SourceLocation loc,
5749  unsigned diagnostic, QualType type) {
5754  diagnostic, type, /*ignored*/ 0));
5755  } else {
5756  S.Diag(loc, diagnostic);
5757  }
5758  };
5759 
5760  // Sometimes, __weak isn't allowed.
5761  if (lifetime == Qualifiers::OCL_Weak &&
5762  !S.getLangOpts().ObjCWeak && !NonObjCPointer) {
5763 
5764  // Use a specialized diagnostic if the runtime just doesn't support them.
5765  unsigned diagnostic =
5766  (S.getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
5767  : diag::err_arc_weak_no_runtime);
5768 
5769  // In any case, delay the diagnostic until we know what we're parsing.
5770  diagnoseOrDelay(S, AttrLoc, diagnostic, type);
5771 
5772  attr.setInvalid();
5773  return true;
5774  }
5775 
5776  // Forbid __weak for class objects marked as
5777  // objc_arc_weak_reference_unavailable
5778  if (lifetime == Qualifiers::OCL_Weak) {
5779  if (const ObjCObjectPointerType *ObjT =
5780  type->getAs<ObjCObjectPointerType>()) {
5781  if (ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl()) {
5782  if (Class->isArcWeakrefUnavailable()) {
5783  S.Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
5784  S.Diag(ObjT->getInterfaceDecl()->getLocation(),
5785  diag::note_class_declared);
5786  }
5787  }
5788  }
5789  }
5790 
5791  return true;
5792 }
5793 
5794 /// handleObjCGCTypeAttr - Process the __attribute__((objc_gc)) type
5795 /// attribute on the specified type. Returns true to indicate that
5796 /// the attribute was handled, false to indicate that the type does
5797 /// not permit the attribute.
5798 static bool handleObjCGCTypeAttr(TypeProcessingState &state,
5799  AttributeList &attr,
5800  QualType &type) {
5801  Sema &S = state.getSema();
5802 
5803  // Delay if this isn't some kind of pointer.
5804  if (!type->isPointerType() &&
5805  !type->isObjCObjectPointerType() &&
5806  !type->isBlockPointerType())
5807  return false;
5808 
5809  if (type.getObjCGCAttr() != Qualifiers::GCNone) {
5810  S.Diag(attr.getLoc(), diag::err_attribute_multiple_objc_gc);
5811  attr.setInvalid();
5812  return true;
5813  }
5814 
5815  // Check the attribute arguments.
5816  if (!attr.isArgIdent(0)) {
5817  S.Diag(attr.getLoc(), diag::err_attribute_argument_type)
5818  << attr.getName() << AANT_ArgumentString;
5819  attr.setInvalid();
5820  return true;
5821  }
5822  Qualifiers::GC GCAttr;
5823  if (attr.getNumArgs() > 1) {
5824  S.Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments)
5825  << attr.getName() << 1;
5826  attr.setInvalid();
5827  return true;
5828  }
5829 
5830  IdentifierInfo *II = attr.getArgAsIdent(0)->Ident;
5831  if (II->isStr("weak"))
5832  GCAttr = Qualifiers::Weak;
5833  else if (II->isStr("strong"))
5834  GCAttr = Qualifiers::Strong;
5835  else {
5836  S.Diag(attr.getLoc(), diag::warn_attribute_type_not_supported)
5837  << attr.getName() << II;
5838  attr.setInvalid();
5839  return true;
5840  }
5841 
5842  QualType origType = type;
5843  type = S.Context.getObjCGCQualType(origType, GCAttr);
5844 
5845  // Make an attributed type to preserve the source information.
5846  if (attr.getLoc().isValid())
5848  origType, type);
5849 
5850  return true;
5851 }
5852 
5853 namespace {
5854  /// A helper class to unwrap a type down to a function for the
5855  /// purposes of applying attributes there.
5856  ///
5857  /// Use:
5858  /// FunctionTypeUnwrapper unwrapped(SemaRef, T);
5859  /// if (unwrapped.isFunctionType()) {
5860  /// const FunctionType *fn = unwrapped.get();
5861  /// // change fn somehow
5862  /// T = unwrapped.wrap(fn);
5863  /// }
5864  struct FunctionTypeUnwrapper {
5865  enum WrapKind {
5866  Desugar,
5867  Attributed,
5868  Parens,
5869  Pointer,
5870  BlockPointer,
5871  Reference,
5872  MemberPointer
5873  };
5874 
5875  QualType Original;
5876  const FunctionType *Fn;
5877  SmallVector<unsigned char /*WrapKind*/, 8> Stack;
5878 
5879  FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) {
5880  while (true) {
5881  const Type *Ty = T.getTypePtr();
5882  if (isa<FunctionType>(Ty)) {
5883  Fn = cast<FunctionType>(Ty);
5884  return;
5885  } else if (isa<ParenType>(Ty)) {
5886  T = cast<ParenType>(Ty)->getInnerType();
5887  Stack.push_back(Parens);
5888  } else if (isa<PointerType>(Ty)) {
5889  T = cast<PointerType>(Ty)->getPointeeType();
5890  Stack.push_back(Pointer);
5891  } else if (isa<BlockPointerType>(Ty)) {
5892  T = cast<BlockPointerType>(Ty)->getPointeeType();
5893  Stack.push_back(BlockPointer);
5894  } else if (isa<MemberPointerType>(Ty)) {
5895  T = cast<MemberPointerType>(Ty)->getPointeeType();
5896  Stack.push_back(MemberPointer);
5897  } else if (isa<ReferenceType>(Ty)) {
5898  T = cast<ReferenceType>(Ty)->getPointeeType();
5899  Stack.push_back(Reference);
5900  } else if (isa<AttributedType>(Ty)) {
5901  T = cast<AttributedType>(Ty)->getEquivalentType();
5902  Stack.push_back(Attributed);
5903  } else {
5904  const Type *DTy = Ty->getUnqualifiedDesugaredType();
5905  if (Ty == DTy) {
5906  Fn = nullptr;
5907  return;
5908  }
5909 
5910  T = QualType(DTy, 0);
5911  Stack.push_back(Desugar);
5912  }
5913  }
5914  }
5915 
5916  bool isFunctionType() const { return (Fn != nullptr); }
5917  const FunctionType *get() const { return Fn; }
5918 
5919  QualType wrap(Sema &S, const FunctionType *New) {
5920  // If T wasn't modified from the unwrapped type, do nothing.
5921  if (New == get()) return Original;
5922 
5923  Fn = New;
5924  return wrap(S.Context, Original, 0);
5925  }
5926 
5927  private:
5928  QualType wrap(ASTContext &C, QualType Old, unsigned I) {
5929  if (I == Stack.size())
5930  return C.getQualifiedType(Fn, Old.getQualifiers());
5931 
5932  // Build up the inner type, applying the qualifiers from the old
5933  // type to the new type.
5934  SplitQualType SplitOld = Old.split();
5935 
5936  // As a special case, tail-recurse if there are no qualifiers.
5937  if (SplitOld.Quals.empty())
5938  return wrap(C, SplitOld.Ty, I);
5939  return C.getQualifiedType(wrap(C, SplitOld.Ty, I), SplitOld.Quals);
5940  }
5941 
5942  QualType wrap(ASTContext &C, const Type *Old, unsigned I) {
5943  if (I == Stack.size()) return QualType(Fn, 0);
5944 
5945  switch (static_cast<WrapKind>(Stack[I++])) {
5946  case Desugar:
5947  // This is the point at which we potentially lose source
5948  // information.
5949  return wrap(C, Old->getUnqualifiedDesugaredType(), I);
5950 
5951  case Attributed:
5952  return wrap(C, cast<AttributedType>(Old)->getEquivalentType(), I);
5953 
5954  case Parens: {
5955  QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
5956  return C.getParenType(New);
5957  }
5958 
5959  case Pointer: {
5960  QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I);
5961  return C.getPointerType(New);
5962  }
5963 
5964  case BlockPointer: {
5965  QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I);
5966  return C.getBlockPointerType(New);
5967  }
5968 
5969  case MemberPointer: {
5970  const MemberPointerType *OldMPT = cast<MemberPointerType>(Old);
5971  QualType New = wrap(C, OldMPT->getPointeeType(), I);
5972  return C.getMemberPointerType(New, OldMPT->getClass());
5973  }
5974 
5975  case Reference: {
5976  const ReferenceType *OldRef = cast<ReferenceType>(Old);
5977  QualType New = wrap(C, OldRef->getPointeeType(), I);
5978  if (isa<LValueReferenceType>(OldRef))
5979  return C.getLValueReferenceType(New, OldRef->isSpelledAsLValue());
5980  else
5981  return C.getRValueReferenceType(New);
5982  }
5983  }
5984 
5985  llvm_unreachable("unknown wrapping kind");
5986  }
5987  };
5988 } // end anonymous namespace
5989 
5990 static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State,
5992  QualType &Type) {
5993  Sema &S = State.getSema();
5994 
5995  AttributeList::Kind Kind = Attr.getKind();
5996  QualType Desugared = Type;
5997  const AttributedType *AT = dyn_cast<AttributedType>(Type);
5998  while (AT) {
5999  AttributedType::Kind CurAttrKind = AT->getAttrKind();
6000 
6001  // You cannot specify duplicate type attributes, so if the attribute has
6002  // already been applied, flag it.
6003  if (getAttrListKind(CurAttrKind) == Kind) {
6004  S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute_exact)
6005  << Attr.getName();
6006  return true;
6007  }
6008 
6009  // You cannot have both __sptr and __uptr on the same type, nor can you
6010  // have __ptr32 and __ptr64.
6011  if ((CurAttrKind == AttributedType::attr_ptr32 &&
6012  Kind == AttributeList::AT_Ptr64) ||
6013  (CurAttrKind == AttributedType::attr_ptr64 &&
6014  Kind == AttributeList::AT_Ptr32)) {
6015  S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
6016  << "'__ptr32'" << "'__ptr64'";
6017  return true;
6018  } else if ((CurAttrKind == AttributedType::attr_sptr &&
6019  Kind == AttributeList::AT_UPtr) ||
6020  (CurAttrKind == AttributedType::attr_uptr &&
6021  Kind == AttributeList::AT_SPtr)) {
6022  S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
6023  << "'__sptr'" << "'__uptr'";
6024  return true;
6025  }
6026 
6027  Desugared = AT->getEquivalentType();
6028  AT = dyn_cast<AttributedType>(Desugared);
6029  }
6030 
6031  // Pointer type qualifiers can only operate on pointer types, but not
6032  // pointer-to-member types.
6033  if (!isa<PointerType>(Desugared)) {
6034  if (Type->isMemberPointerType())
6035  S.Diag(Attr.getLoc(), diag::err_attribute_no_member_pointers)
6036  << Attr.getName();
6037  else
6038  S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
6039  << Attr.getName() << 0;
6040  return true;
6041  }
6042 
6044  switch (Kind) {
6045  default: llvm_unreachable("Unknown attribute kind");
6046  case AttributeList::AT_Ptr32: TAK = AttributedType::attr_ptr32; break;
6047  case AttributeList::AT_Ptr64: TAK = AttributedType::attr_ptr64; break;
6048  case AttributeList::AT_SPtr: TAK = AttributedType::attr_sptr; break;
6049  case AttributeList::AT_UPtr: TAK = AttributedType::attr_uptr; break;
6050  }
6051 
6052  Type = S.Context.getAttributedType(TAK, Type, Type);
6053  return false;
6054 }
6055 
6057  NullabilityKind nullability,
6058  SourceLocation nullabilityLoc,
6059  bool isContextSensitive,
6060  bool allowOnArrayType) {
6061  recordNullabilitySeen(*this, nullabilityLoc);
6062 
6063  // Check for existing nullability attributes on the type.
6064  QualType desugared = type;
6065  while (auto attributed = dyn_cast<AttributedType>(desugared.getTypePtr())) {
6066  // Check whether there is already a null
6067  if (auto existingNullability = attributed->getImmediateNullability()) {
6068  // Duplicated nullability.
6069  if (nullability == *existingNullability) {
6070  Diag(nullabilityLoc, diag::warn_nullability_duplicate)
6071  << DiagNullabilityKind(nullability, isContextSensitive)
6072  << FixItHint::CreateRemoval(nullabilityLoc);
6073 
6074  break;
6075  }
6076 
6077  // Conflicting nullability.
6078  Diag(nullabilityLoc, diag::err_nullability_conflicting)
6079  << DiagNullabilityKind(nullability, isContextSensitive)
6080  << DiagNullabilityKind(*existingNullability, false);
6081  return true;
6082  }
6083 
6084  desugared = attributed->getModifiedType();
6085  }
6086 
6087  // If there is already a different nullability specifier, complain.
6088  // This (unlike the code above) looks through typedefs that might
6089  // have nullability specifiers on them, which means we cannot
6090  // provide a useful Fix-It.
6091  if (auto existingNullability = desugared->getNullability(Context)) {
6092  if (nullability != *existingNullability) {
6093  Diag(nullabilityLoc, diag::err_nullability_conflicting)
6094  << DiagNullabilityKind(nullability, isContextSensitive)
6095  << DiagNullabilityKind(*existingNullability, false);
6096 
6097  // Try to find the typedef with the existing nullability specifier.
6098  if (auto typedefType = desugared->getAs<TypedefType>()) {
6099  TypedefNameDecl *typedefDecl = typedefType->getDecl();
6100  QualType underlyingType = typedefDecl->getUnderlyingType();
6101  if (auto typedefNullability
6102  = AttributedType::stripOuterNullability(underlyingType)) {
6103  if (*typedefNullability == *existingNullability) {
6104  Diag(typedefDecl->getLocation(), diag::note_nullability_here)
6105  << DiagNullabilityKind(*existingNullability, false);
6106  }
6107  }
6108  }
6109 
6110  return true;
6111  }
6112  }
6113 
6114  // If this definitely isn't a pointer type, reject the specifier.
6115  if (!desugared->canHaveNullability() &&
6116  !(allowOnArrayType && desugared->isArrayType())) {
6117  Diag(nullabilityLoc, diag::err_nullability_nonpointer)
6118  << DiagNullabilityKind(nullability, isContextSensitive) << type;
6119  return true;
6120  }
6121 
6122  // For the context-sensitive keywords/Objective-C property
6123  // attributes, require that the type be a single-level pointer.
6124  if (isContextSensitive) {
6125  // Make sure that the pointee isn't itself a pointer type.
6126  const Type *pointeeType;
6127  if (desugared->isArrayType())
6128  pointeeType = desugared->getArrayElementTypeNoTypeQual();
6129  else
6130  pointeeType = desugared->getPointeeType().getTypePtr();
6131 
6132  if (pointeeType->isAnyPointerType() ||
6133  pointeeType->isObjCObjectPointerType() ||
6134  pointeeType->isMemberPointerType()) {
6135  Diag(nullabilityLoc, diag::err_nullability_cs_multilevel)
6136  << DiagNullabilityKind(nullability, true)
6137  << type;
6138  Diag(nullabilityLoc, diag::note_nullability_type_specifier)
6139  << DiagNullabilityKind(nullability, false)
6140  << type
6141  << FixItHint::CreateReplacement(nullabilityLoc,
6142  getNullabilitySpelling(nullability));
6143  return true;
6144  }
6145  }
6146 
6147  // Form the attributed type.
6148  type = Context.getAttributedType(
6149  AttributedType::getNullabilityAttrKind(nullability), type, type);
6150  return false;
6151 }
6152 
6154  if (isa<ObjCTypeParamType>(type)) {
6155  // Build the attributed type to record where __kindof occurred.
6157  type, type);
6158  return false;
6159  }
6160 
6161  // Find out if it's an Objective-C object or object pointer type;
6162  const ObjCObjectPointerType *ptrType = type->getAs<ObjCObjectPointerType>();
6163  const ObjCObjectType *objType = ptrType ? ptrType->getObjectType()
6164  : type->getAs<ObjCObjectType>();
6165 
6166  // If not, we can't apply __kindof.
6167  if (!objType) {
6168  // FIXME: Handle dependent types that aren't yet object types.
6169  Diag(loc, diag::err_objc_kindof_nonobject)
6170  << type;
6171  return true;
6172  }
6173 
6174  // Rebuild the "equivalent" type, which pushes __kindof down into
6175  // the object type.
6176  // There is no need to apply kindof on an unqualified id type.
6177  QualType equivType = Context.getObjCObjectType(
6178  objType->getBaseType(), objType->getTypeArgsAsWritten(),
6179  objType->getProtocols(),
6180  /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true);
6181 
6182  // If we started with an object pointer type, rebuild it.
6183  if (ptrType) {
6184  equivType = Context.getObjCObjectPointerType(equivType);
6185  if (auto nullability = type->getNullability(Context)) {
6186  auto attrKind = AttributedType::getNullabilityAttrKind(*nullability);
6187  equivType = Context.getAttributedType(attrKind, equivType, equivType);
6188  }
6189  }
6190 
6191  // Build the attributed type to record where __kindof occurred.
6193  type,
6194  equivType);
6195 
6196  return false;
6197 }
6198 
6199 /// Map a nullability attribute kind to a nullability kind.
6201  switch (kind) {
6202  case AttributeList::AT_TypeNonNull:
6203  return NullabilityKind::NonNull;
6204 
6205  case AttributeList::AT_TypeNullable:
6207 
6208  case AttributeList::AT_TypeNullUnspecified:
6210 
6211  default:
6212  llvm_unreachable("not a nullability attribute kind");
6213  }
6214 }
6215 
6216 /// Distribute a nullability type attribute that cannot be applied to
6217 /// the type specifier to a pointer, block pointer, or member pointer
6218 /// declarator, complaining if necessary.
6219 ///
6220 /// \returns true if the nullability annotation was distributed, false
6221 /// otherwise.
6222 static bool distributeNullabilityTypeAttr(TypeProcessingState &state,
6223  QualType type,
6224  AttributeList &attr) {
6225  Declarator &declarator = state.getDeclarator();
6226 
6227  /// Attempt to move the attribute to the specified chunk.
6228  auto moveToChunk = [&](DeclaratorChunk &chunk, bool inFunction) -> bool {
6229  // If there is already a nullability attribute there, don't add
6230  // one.
6231  if (hasNullabilityAttr(chunk.getAttrListRef()))
6232  return false;
6233 
6234  // Complain about the nullability qualifier being in the wrong
6235  // place.
6236  enum {
6237  PK_Pointer,
6238  PK_BlockPointer,
6239  PK_MemberPointer,
6240  PK_FunctionPointer,
6241  PK_MemberFunctionPointer,
6242  } pointerKind
6243  = chunk.Kind == DeclaratorChunk::Pointer ? (inFunction ? PK_FunctionPointer
6244  : PK_Pointer)
6245  : chunk.Kind == DeclaratorChunk::BlockPointer ? PK_BlockPointer
6246  : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
6247 
6248  auto diag = state.getSema().Diag(attr.getLoc(),
6249  diag::warn_nullability_declspec)
6252  << type
6253  << static_cast<unsigned>(pointerKind);
6254 
6255  // FIXME: MemberPointer chunks don't carry the location of the *.
6256  if (chunk.Kind != DeclaratorChunk::MemberPointer) {
6257  diag << FixItHint::CreateRemoval(attr.getLoc())
6259  state.getSema().getPreprocessor()
6260  .getLocForEndOfToken(chunk.Loc),
6261  " " + attr.getName()->getName().str() + " ");
6262  }
6263 
6264  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
6265  chunk.getAttrListRef());
6266  return true;
6267  };
6268 
6269  // Move it to the outermost pointer, member pointer, or block
6270  // pointer declarator.
6271  for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
6272  DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
6273  switch (chunk.Kind) {
6277  return moveToChunk(chunk, false);
6278 
6281  continue;
6282 
6284  // Try to move past the return type to a function/block/member
6285  // function pointer.
6287  declarator, i,
6288  /*onlyBlockPointers=*/false)) {
6289  return moveToChunk(*dest, true);
6290  }
6291 
6292  return false;
6293 
6294  // Don't walk through these.
6296  case DeclaratorChunk::Pipe:
6297  return false;
6298  }
6299  }
6300 
6301  return false;
6302 }
6303 
6305  assert(!Attr.isInvalid());
6306  switch (Attr.getKind()) {
6307  default:
6308  llvm_unreachable("not a calling convention attribute");
6309  case AttributeList::AT_CDecl:
6311  case AttributeList::AT_FastCall:
6313  case AttributeList::AT_StdCall:
6315  case AttributeList::AT_ThisCall:
6317  case AttributeList::AT_RegCall:
6319  case AttributeList::AT_Pascal:
6321  case AttributeList::AT_SwiftCall:
6323  case AttributeList::AT_VectorCall:
6325  case AttributeList::AT_Pcs: {
6326  // The attribute may have had a fixit applied where we treated an
6327  // identifier as a string literal. The contents of the string are valid,
6328  // but the form may not be.
6329  StringRef Str;
6330  if (Attr.isArgExpr(0))
6331  Str = cast<StringLiteral>(Attr.getArgAsExpr(0))->getString();
6332  else
6333  Str = Attr.getArgAsIdent(0)->Ident->getName();
6334  return llvm::StringSwitch<AttributedType::Kind>(Str)
6335  .Case("aapcs", AttributedType::attr_pcs)
6336  .Case("aapcs-vfp", AttributedType::attr_pcs_vfp);
6337  }
6338  case AttributeList::AT_IntelOclBicc:
6340  case AttributeList::AT_MSABI:
6342  case AttributeList::AT_SysVABI:
6344  case AttributeList::AT_PreserveMost:
6346  case AttributeList::AT_PreserveAll:
6348  }
6349  llvm_unreachable("unexpected attribute kind!");
6350 }
6351 
6352 /// Process an individual function attribute. Returns true to
6353 /// indicate that the attribute was handled, false if it wasn't.
6354 static bool handleFunctionTypeAttr(TypeProcessingState &state,
6355  AttributeList &attr,
6356  QualType &type) {
6357  Sema &S = state.getSema();
6358 
6359  FunctionTypeUnwrapper unwrapped(S, type);
6360 
6361  if (attr.getKind() == AttributeList::AT_NoReturn) {
6362  if (S.CheckNoReturnAttr(attr))
6363  return true;
6364 
6365  // Delay if this is not a function type.
6366  if (!unwrapped.isFunctionType())
6367  return false;
6368 
6369  // Otherwise we can process right away.
6370  FunctionType::ExtInfo EI = unwrapped.get()->getExtInfo().withNoReturn(true);
6371  type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
6372  return true;
6373  }
6374 
6375  // ns_returns_retained is not always a type attribute, but if we got
6376  // here, we're treating it as one right now.
6377  if (attr.getKind() == AttributeList::AT_NSReturnsRetained) {
6378  if (attr.getNumArgs()) return true;
6379 
6380  // Delay if this is not a function type.
6381  if (!unwrapped.isFunctionType())
6382  return false;
6383 
6384  // Check whether the return type is reasonable.
6386  unwrapped.get()->getReturnType()))
6387  return true;
6388 
6389  // Only actually change the underlying type in ARC builds.
6390  QualType origType = type;
6391  if (state.getSema().getLangOpts().ObjCAutoRefCount) {
6393  = unwrapped.get()->getExtInfo().withProducesResult(true);
6394  type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
6395  }
6397  origType, type);
6398  return true;
6399  }
6400 
6401  if (attr.getKind() == AttributeList::AT_AnyX86NoCallerSavedRegisters) {
6402  if (S.CheckNoCallerSavedRegsAttr(attr))
6403  return true;
6404 
6405  // Delay if this is not a function type.
6406  if (!unwrapped.isFunctionType())
6407  return false;
6408 
6410  unwrapped.get()->getExtInfo().withNoCallerSavedRegs(true);
6411  type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
6412  return true;
6413  }
6414 
6415  if (attr.getKind() == AttributeList::AT_Regparm) {
6416  unsigned value;
6417  if (S.CheckRegparmAttr(attr, value))
6418  return true;
6419 
6420  // Delay if this is not a function type.
6421  if (!unwrapped.isFunctionType())
6422  return false;
6423 
6424  // Diagnose regparm with fastcall.
6425  const FunctionType *fn = unwrapped.get();
6426  CallingConv CC = fn->getCallConv();
6427  if (CC == CC_X86FastCall) {
6428  S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
6430  << "regparm";
6431  attr.setInvalid();
6432  return true;
6433  }
6434 
6436  unwrapped.get()->getExtInfo().withRegParm(value);
6437  type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
6438  return true;
6439  }
6440 
6441  // Delay if the type didn't work out to a function.
6442  if (!unwrapped.isFunctionType()) return false;
6443 
6444  // Otherwise, a calling convention.
6445  CallingConv CC;
6446  if (S.CheckCallingConvAttr(attr, CC))
6447  return true;
6448 
6449  const FunctionType *fn = unwrapped.get();
6450  CallingConv CCOld = fn->getCallConv();
6451  AttributedType::Kind CCAttrKind = getCCTypeAttrKind(attr);
6452 
6453  if (CCOld != CC) {
6454  // Error out on when there's already an attribute on the type
6455  // and the CCs don't match.
6456  const AttributedType *AT = S.getCallingConvAttributedType(type);
6457  if (AT && AT->getAttrKind() != CCAttrKind) {
6458  S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
6461  attr.setInvalid();
6462  return true;
6463  }
6464  }
6465 
6466  // Diagnose use of variadic functions with calling conventions that
6467  // don't support them (e.g. because they're callee-cleanup).
6468  // We delay warning about this on unprototyped function declarations
6469  // until after redeclaration checking, just in case we pick up a
6470  // prototype that way. And apparently we also "delay" warning about
6471  // unprototyped function types in general, despite not necessarily having
6472  // much ability to diagnose it later.
6473  if (!supportsVariadicCall(CC)) {
6474  const FunctionProtoType *FnP = dyn_cast<FunctionProtoType>(fn);
6475  if (FnP && FnP->isVariadic()) {
6476  unsigned DiagID = diag::err_cconv_varargs;
6477 
6478  // stdcall and fastcall are ignored with a warning for GCC and MS
6479  // compatibility.
6480  bool IsInvalid = true;
6481  if (CC == CC_X86StdCall || CC == CC_X86FastCall) {
6482  DiagID = diag::warn_cconv_varargs;
6483  IsInvalid = false;
6484  }
6485 
6486  S.Diag(attr.getLoc(), DiagID) << FunctionType::getNameForCallConv(CC);
6487  if (IsInvalid) attr.setInvalid();
6488  return true;
6489  }
6490  }
6491 
6492  // Also diagnose fastcall with regparm.
6493  if (CC == CC_X86FastCall && fn->getHasRegParm()) {
6494  S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
6496  attr.setInvalid();
6497  return true;
6498  }
6499 
6500  // Modify the CC from the wrapped function type, wrap it all back, and then
6501  // wrap the whole thing in an AttributedType as written. The modified type
6502  // might have a different CC if we ignored the attribute.
6503  QualType Equivalent;
6504  if (CCOld == CC) {
6505  Equivalent = type;
6506  } else {
6507  auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
6508  Equivalent =
6509  unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
6510  }
6511  type = S.Context.getAttributedType(CCAttrKind, type, Equivalent);
6512  return true;
6513 }
6514 
6516  QualType R = T.IgnoreParens();
6517  while (const AttributedType *AT = dyn_cast<AttributedType>(R)) {
6518  if (AT->isCallingConv())
6519  return true;
6520  R = AT->getModifiedType().IgnoreParens();
6521  }
6522  return false;
6523 }
6524 
6525 void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
6526  SourceLocation Loc) {
6527  FunctionTypeUnwrapper Unwrapped(*this, T);
6528  const FunctionType *FT = Unwrapped.get();
6529  bool IsVariadic = (isa<FunctionProtoType>(FT) &&
6530  cast<FunctionProtoType>(FT)->isVariadic());
6531  CallingConv CurCC = FT->getCallConv();
6532  CallingConv ToCC = Context.getDefaultCallingConvention(IsVariadic, !IsStatic);
6533 
6534  if (CurCC == ToCC)
6535  return;
6536 
6537  // MS compiler ignores explicit calling convention attributes on structors. We
6538  // should do the same.
6539  if (Context.getTargetInfo().getCXXABI().isMicrosoft() && IsCtorOrDtor) {
6540  // Issue a warning on ignored calling convention -- except of __stdcall.
6541  // Again, this is what MS compiler does.
6542  if (CurCC != CC_X86StdCall)
6543  Diag(Loc, diag::warn_cconv_structors)
6545  // Default adjustment.
6546  } else {
6547  // Only adjust types with the default convention. For example, on Windows
6548  // we should adjust a __cdecl type to __thiscall for instance methods, and a
6549  // __thiscall type to __cdecl for static methods.
6550  CallingConv DefaultCC =
6551  Context.getDefaultCallingConvention(IsVariadic, IsStatic);
6552 
6553  if (CurCC != DefaultCC || DefaultCC == ToCC)
6554  return;
6555 
6556  if (hasExplicitCallingConv(T))
6557  return;
6558  }
6559 
6560  FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(ToCC));
6561  QualType Wrapped = Unwrapped.wrap(*this, FT);
6562  T = Context.getAdjustedType(T, Wrapped);
6563 }
6564 
6565 /// HandleVectorSizeAttribute - this attribute is only applicable to integral
6566 /// and float scalars, although arrays, pointers, and function return values are
6567 /// allowed in conjunction with this construct. Aggregates with this attribute
6568 /// are invalid, even if they are of the same size as a corresponding scalar.
6569 /// The raw attribute should contain precisely 1 argument, the vector size for
6570 /// the variable, measured in bytes. If curType and rawAttr are well formed,
6571 /// this routine will return a new vector type.
6572 static void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr,
6573  Sema &S) {
6574  // Check the attribute arguments.
6575  if (Attr.getNumArgs() != 1) {
6576  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
6577  << Attr.getName() << 1;
6578  Attr.setInvalid();
6579  return;
6580  }
6581  Expr *sizeExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
6582  llvm::APSInt vecSize(32);
6583  if (sizeExpr->isTypeDependent() || sizeExpr->isValueDependent() ||
6584  !sizeExpr->isIntegerConstantExpr(vecSize, S.Context)) {
6585  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
6587  << sizeExpr->getSourceRange();
6588  Attr.setInvalid();
6589  return;
6590  }
6591  // The base type must be integer (not Boolean or enumeration) or float, and
6592  // can't already be a vector.
6593  if (!CurType->isBuiltinType() || CurType->isBooleanType() ||
6594  (!CurType->isIntegerType() && !CurType->isRealFloatingType())) {
6595  S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
6596  Attr.setInvalid();
6597  return;
6598  }
6599  unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType));
6600  // vecSize is specified in bytes - convert to bits.
6601  unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8);
6602 
6603  // the vector size needs to be an integral multiple of the type size.
6604  if (vectorSize % typeSize) {
6605  S.Diag(Attr.getLoc(), diag::err_attribute_invalid_size)
6606  << sizeExpr->getSourceRange();
6607  Attr.setInvalid();
6608  return;
6609  }
6610  if (VectorType::isVectorSizeTooLarge(vectorSize / typeSize)) {
6611  S.Diag(Attr.getLoc(), diag::err_attribute_size_too_large)
6612  << sizeExpr->getSourceRange();
6613  Attr.setInvalid();
6614  return;
6615  }
6616  if (vectorSize == 0) {
6617  S.Diag(Attr.getLoc(), diag::err_attribute_zero_size)
6618  << sizeExpr->getSourceRange();
6619  Attr.setInvalid();
6620  return;
6621  }
6622 
6623  // Success! Instantiate the vector type, the number of elements is > 0, and
6624  // not required to be a power of 2, unlike GCC.
6625  CurType = S.Context.getVectorType(CurType, vectorSize/typeSize,
6627 }
6628 
6629 /// \brief Process the OpenCL-like ext_vector_type attribute when it occurs on
6630 /// a type.
6631 static void HandleExtVectorTypeAttr(QualType &CurType,
6632  const AttributeList &Attr,
6633  Sema &S) {
6634  // check the attribute arguments.
6635  if (Attr.getNumArgs() != 1) {
6636  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
6637  << Attr.getName() << 1;
6638  return;
6639  }
6640 
6641  Expr *sizeExpr;
6642 
6643  // Special case where the argument is a template id.
6644  if (Attr.isArgIdent(0)) {
6645  CXXScopeSpec SS;
6646  SourceLocation TemplateKWLoc;
6647  UnqualifiedId id;
6648  id.setIdentifier(Attr.getArgAsIdent(0)->Ident, Attr.getLoc());
6649 
6650  ExprResult Size = S.ActOnIdExpression(S.getCurScope(), SS, TemplateKWLoc,
6651  id, false, false);
6652  if (Size.isInvalid())
6653  return;
6654 
6655  sizeExpr = Size.get();
6656  } else {
6657  sizeExpr = Attr.getArgAsExpr(0);
6658  }
6659 
6660  // Create the vector type.
6661  QualType T = S.BuildExtVectorType(CurType, sizeExpr, Attr.getLoc());
6662  if (!T.isNull())
6663  CurType = T;
6664 }
6665 
6667  VectorType::VectorKind VecKind, Sema &S) {
6668  const BuiltinType *BTy = Ty->getAs<BuiltinType>();
6669  if (!BTy)
6670  return false;
6671 
6672  llvm::Triple Triple = S.Context.getTargetInfo().getTriple();
6673 
6674  // Signed poly is mathematically wrong, but has been baked into some ABIs by
6675  // now.
6676  bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
6677  Triple.getArch() == llvm::Triple::aarch64_be;
6678  if (VecKind == VectorType::NeonPolyVector) {
6679  if (IsPolyUnsigned) {
6680  // AArch64 polynomial vectors are unsigned and support poly64.
6681  return BTy->getKind() == BuiltinType::UChar ||
6682  BTy->getKind() == BuiltinType::UShort ||
6683  BTy->getKind() == BuiltinType::ULong ||
6684  BTy->getKind() == BuiltinType::ULongLong;
6685  } else {
6686  // AArch32 polynomial vector are signed.
6687  return BTy->getKind() == BuiltinType::SChar ||
6688  BTy->getKind() == BuiltinType::Short;
6689  }
6690  }
6691 
6692  // Non-polynomial vector types: the usual suspects are allowed, as well as
6693  // float64_t on AArch64.
6694  bool Is64Bit = Triple.getArch() == llvm::Triple::aarch64 ||
6695  Triple.getArch() == llvm::Triple::aarch64_be;
6696 
6697  if (Is64Bit && BTy->getKind() == BuiltinType::Double)
6698  return true;
6699 
6700  return BTy->getKind() == BuiltinType::SChar ||
6701  BTy->getKind() == BuiltinType::UChar ||
6702  BTy->getKind() == BuiltinType::Short ||
6703  BTy->getKind() == BuiltinType::UShort ||
6704  BTy->getKind() == BuiltinType::Int ||
6705  BTy->getKind() == BuiltinType::UInt ||
6706  BTy->getKind() == BuiltinType::Long ||
6707  BTy->getKind() == BuiltinType::ULong ||
6708  BTy->getKind() == BuiltinType::LongLong ||
6709  BTy->getKind() == BuiltinType::ULongLong ||
6710  BTy->getKind() == BuiltinType::Float ||
6711  BTy->getKind() == BuiltinType::Half;
6712 }
6713 
6714 /// HandleNeonVectorTypeAttr - The "neon_vector_type" and
6715 /// "neon_polyvector_type" attributes are used to create vector types that
6716 /// are mangled according to ARM's ABI. Otherwise, these types are identical
6717 /// to those created with the "vector_size" attribute. Unlike "vector_size"
6718 /// the argument to these Neon attributes is the number of vector elements,
6719 /// not the vector size in bytes. The vector width and element type must
6720 /// match one of the standard Neon vector types.
6721 static void HandleNeonVectorTypeAttr(QualType& CurType,
6722  const AttributeList &Attr, Sema &S,
6723  VectorType::VectorKind VecKind) {
6724  // Target must have NEON
6725  if (!S.Context.getTargetInfo().hasFeature("neon")) {
6726  S.Diag(Attr.getLoc(), diag::err_attribute_unsupported) << Attr.getName();
6727  Attr.setInvalid();
6728  return;
6729  }
6730  // Check the attribute arguments.
6731  if (Attr.getNumArgs() != 1) {
6732  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
6733  << Attr.getName() << 1;
6734  Attr.setInvalid();
6735  return;
6736  }
6737  // The number of elements must be an ICE.
6738  Expr *numEltsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
6739  llvm::APSInt numEltsInt(32);
6740  if (numEltsExpr->isTypeDependent() || numEltsExpr->isValueDependent() ||
6741  !numEltsExpr->isIntegerConstantExpr(numEltsInt, S.Context)) {
6742  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
6744  << numEltsExpr->getSourceRange();
6745  Attr.setInvalid();
6746  return;
6747  }
6748  // Only certain element types are supported for Neon vectors.
6749  if (!isPermittedNeonBaseType(CurType, VecKind, S)) {
6750  S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
6751  Attr.setInvalid();
6752  return;
6753  }
6754 
6755  // The total size of the vector must be 64 or 128 bits.
6756  unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType));
6757  unsigned numElts = static_cast<unsigned>(numEltsInt.getZExtValue());
6758  unsigned vecSize = typeSize * numElts;
6759  if (vecSize != 64 && vecSize != 128) {
6760  S.Diag(Attr.getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
6761  Attr.setInvalid();
6762  return;
6763  }
6764 
6765  CurType = S.Context.getVectorType(CurType, numElts, VecKind);
6766 }
6767 
6768 /// Handle OpenCL Access Qualifier Attribute.
6769 static void HandleOpenCLAccessAttr(QualType &CurType, const AttributeList &Attr,
6770  Sema &S) {
6771  // OpenCL v2.0 s6.6 - Access qualifier can be used only for image and pipe type.
6772  if (!(CurType->isImageType() || CurType->isPipeType())) {
6773  S.Diag(Attr.getLoc(), diag::err_opencl_invalid_access_qualifier);
6774  Attr.setInvalid();
6775  return;
6776  }
6777 
6778  if (const TypedefType* TypedefTy = CurType->getAs<TypedefType>()) {
6779  QualType PointeeTy = TypedefTy->desugar();
6780  S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers);
6781 
6782  std::string PrevAccessQual;
6783  switch (cast<BuiltinType>(PointeeTy.getTypePtr())->getKind()) {
6784  #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6785  case BuiltinType::Id: \
6786  PrevAccessQual = #Access; \
6787  break;
6788  #include "clang/Basic/OpenCLImageTypes.def"
6789  default:
6790  assert(0 && "Unable to find corresponding image type.");
6791  }
6792 
6793  S.Diag(TypedefTy->getDecl()->getLocStart(),
6794  diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
6795  } else if (CurType->isPipeType()) {
6796  if (Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
6797  QualType ElemType = CurType->getAs<PipeType>()->getElementType();
6798  CurType = S.Context.getWritePipeType(ElemType);
6799  }
6800  }
6801 }
6802 
6803 static void processTypeAttrs(TypeProcessingState &state, QualType &type,
6804  TypeAttrLocation TAL, AttributeList *attrs) {
6805  // Scan through and apply attributes to this type where it makes sense. Some
6806  // attributes (such as __address_space__, __vector_size__, etc) apply to the
6807  // type, but others can be present in the type specifiers even though they
6808  // apply to the decl. Here we apply type attributes and ignore the rest.
6809 
6810  bool hasOpenCLAddressSpace = false;
6811  while (attrs) {
6812  AttributeList &attr = *attrs;
6813  attrs = attr.getNext(); // reset to the next here due to early loop continue
6814  // stmts
6815 
6816  // Skip attributes that were marked to be invalid.
6817  if (attr.isInvalid())
6818  continue;
6819 
6820  if (attr.isCXX11Attribute()) {
6821  // [[gnu::...]] attributes are treated as declaration attributes, so may
6822  // not appertain to a DeclaratorChunk, even if we handle them as type
6823  // attributes.
6824  if (attr.getScopeName() && attr.getScopeName()->isStr("gnu")) {
6825  if (TAL == TAL_DeclChunk) {
6826  state.getSema().Diag(attr.getLoc(),
6827  diag::warn_cxx11_gnu_attribute_on_type)
6828  << attr.getName();
6829  continue;
6830  }
6831  } else if (TAL != TAL_DeclChunk) {
6832  // Otherwise, only consider type processing for a C++11 attribute if
6833  // it's actually been applied to a type.
6834  continue;
6835  }
6836  }
6837 
6838  // If this is an attribute we can handle, do so now,
6839  // otherwise, add it to the FnAttrs list for rechaining.
6840  switch (attr.getKind()) {
6841  default:
6842  // A C++11 attribute on a declarator chunk must appertain to a type.
6843  if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk) {
6844  state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr)
6845  << attr.getName();
6846  attr.setUsedAsTypeAttr();
6847  }
6848  break;
6849 
6851  if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk)
6852  state.getSema().Diag(attr.getLoc(),
6853  diag::warn_unknown_attribute_ignored)
6854  << attr.getName();
6855  break;
6856 
6858  break;
6859 
6860  case AttributeList::AT_MayAlias:
6861  // FIXME: This attribute needs to actually be handled, but if we ignore
6862  // it it breaks large amounts of Linux software.
6863  attr.setUsedAsTypeAttr();
6864  break;
6865  case AttributeList::AT_OpenCLPrivateAddressSpace:
6866  case AttributeList::AT_OpenCLGlobalAddressSpace:
6867  case AttributeList::AT_OpenCLLocalAddressSpace:
6868  case AttributeList::AT_OpenCLConstantAddressSpace:
6869  case AttributeList::AT_OpenCLGenericAddressSpace:
6870  case AttributeList::AT_AddressSpace:
6871  HandleAddressSpaceTypeAttribute(type, attr, state.getSema());
6872  attr.setUsedAsTypeAttr();
6873  hasOpenCLAddressSpace = true;
6874  break;
6876  if (!handleObjCPointerTypeAttr(state, attr, type))
6877  distributeObjCPointerTypeAttr(state, attr, type);
6878  attr.setUsedAsTypeAttr();
6879  break;
6880  case AttributeList::AT_VectorSize:
6881  HandleVectorSizeAttr(type, attr, state.getSema());
6882  attr.setUsedAsTypeAttr();
6883  break;
6884  case AttributeList::AT_ExtVectorType:
6885  HandleExtVectorTypeAttr(type, attr, state.getSema());
6886  attr.setUsedAsTypeAttr();
6887  break;
6888  case AttributeList::AT_NeonVectorType:
6889  HandleNeonVectorTypeAttr(type, attr, state.getSema(),
6891  attr.setUsedAsTypeAttr();
6892  break;
6893  case AttributeList::AT_NeonPolyVectorType:
6894  HandleNeonVectorTypeAttr(type, attr, state.getSema(),
6896  attr.setUsedAsTypeAttr();
6897  break;
6898  case AttributeList::AT_OpenCLAccess:
6899  HandleOpenCLAccessAttr(type, attr, state.getSema());
6900  attr.setUsedAsTypeAttr();
6901  break;
6902 
6904  if (!handleMSPointerTypeQualifierAttr(state, attr, type))
6905  attr.setUsedAsTypeAttr();
6906  break;
6907 
6908 
6910  // Either add nullability here or try to distribute it. We
6911  // don't want to distribute the nullability specifier past any
6912  // dependent type, because that complicates the user model.
6913  if (type->canHaveNullability() || type->isDependentType() ||
6914  type->isArrayType() ||
6915  !distributeNullabilityTypeAttr(state, type, attr)) {
6916  unsigned endIndex;
6917  if (TAL == TAL_DeclChunk)
6918  endIndex = state.getCurrentChunkIndex();
6919  else
6920  endIndex = state.getDeclarator().getNumTypeObjects();
6921  bool allowOnArrayType =
6922  state.getDeclarator().isPrototypeContext() &&
6923  !hasOuterPointerLikeChunk(state.getDeclarator(), endIndex);
6924  if (state.getSema().checkNullabilityTypeSpecifier(
6925  type,
6927  attr.getLoc(),
6929  allowOnArrayType)) {
6930  attr.setInvalid();
6931  }
6932 
6933  attr.setUsedAsTypeAttr();
6934  }
6935  break;
6936 
6937  case AttributeList::AT_ObjCKindOf:
6938  // '__kindof' must be part of the decl-specifiers.
6939  switch (TAL) {
6940  case TAL_DeclSpec:
6941  break;
6942 
6943  case TAL_DeclChunk:
6944  case TAL_DeclName:
6945  state.getSema().Diag(attr.getLoc(),
6946  diag::err_objc_kindof_wrong_position)
6947  << FixItHint::CreateRemoval(attr.getLoc())
6949  state.getDeclarator().getDeclSpec().getLocStart(), "__kindof ");
6950  break;
6951  }
6952 
6953  // Apply it regardless.
6954  if (state.getSema().checkObjCKindOfType(type, attr.getLoc()))
6955  attr.setInvalid();
6956  attr.setUsedAsTypeAttr();
6957  break;
6958 
6960  attr.setUsedAsTypeAttr();
6961 
6962  // Never process function type attributes as part of the
6963  // declaration-specifiers.
6964  if (TAL == TAL_DeclSpec)
6965  distributeFunctionTypeAttrFromDeclSpec(state, attr, type);
6966 
6967  // Otherwise, handle the possible delays.
6968  else if (!handleFunctionTypeAttr(state, attr, type))
6969  distributeFunctionTypeAttr(state, attr, type);
6970  break;
6971  }
6972  }
6973 
6974  // If address space is not set, OpenCL 2.0 defines non private default
6975  // address spaces for some cases:
6976  // OpenCL 2.0, section 6.5:
6977  // The address space for a variable at program scope or a static variable
6978  // inside a function can either be __global or __constant, but defaults to
6979  // __global if not specified.
6980  // (...)
6981  // Pointers that are declared without pointing to a named address space point
6982  // to the generic address space.
6983  if (state.getSema().getLangOpts().OpenCLVersion >= 200 &&
6984  !hasOpenCLAddressSpace && type.getAddressSpace() == 0 &&
6985  (TAL == TAL_DeclSpec || TAL == TAL_DeclChunk)) {
6986  Declarator &D = state.getDeclarator();
6987  if (state.getCurrentChunkIndex() > 0 &&
6988  (D.getTypeObject(state.getCurrentChunkIndex() - 1).Kind ==
6990  D.getTypeObject(state.getCurrentChunkIndex() - 1).Kind ==
6992  type = state.getSema().Context.getAddrSpaceQualType(
6993  type, LangAS::opencl_generic);
6994  } else if (state.getCurrentChunkIndex() == 0 &&
6998  !type->isSamplerT())
6999  type = state.getSema().Context.getAddrSpaceQualType(
7000  type, LangAS::opencl_global);
7001  else if (state.getCurrentChunkIndex() == 0 &&
7004  type = state.getSema().Context.getAddrSpaceQualType(
7005  type, LangAS::opencl_global);
7006  }
7007 }
7008 
7010  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
7011  if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
7012  if (isTemplateInstantiation(Var->getTemplateSpecializationKind())) {
7013  SourceLocation PointOfInstantiation = E->getExprLoc();
7014 
7015  if (MemberSpecializationInfo *MSInfo =
7016  Var->getMemberSpecializationInfo()) {
7017  // If we don't already have a point of instantiation, this is it.
7018  if (MSInfo->getPointOfInstantiation().isInvalid()) {
7019  MSInfo->setPointOfInstantiation(PointOfInstantiation);
7020 
7021  // This is a modification of an existing AST node. Notify
7022  // listeners.
7024  L->StaticDataMemberInstantiated(Var);
7025  }
7026  } else {
7028  cast<VarTemplateSpecializationDecl>(Var);
7029  if (VarSpec->getPointOfInstantiation().isInvalid())
7030  VarSpec->setPointOfInstantiation(PointOfInstantiation);
7031  }
7032 
7033  InstantiateVariableDefinition(PointOfInstantiation, Var);
7034 
7035  // Update the type to the newly instantiated definition's type both
7036  // here and within the expression.
7037  if (VarDecl *Def = Var->getDefinition()) {
7038  DRE->setDecl(Def);
7039  QualType T = Def->getType();
7040  DRE->setType(T);
7041  // FIXME: Update the type on all intervening expressions.
7042  E->setType(T);
7043  }
7044 
7045  // We still go on to try to complete the type independently, as it
7046  // may also require instantiations or diagnostics if it remains
7047  // incomplete.
7048  }
7049  }
7050  }
7051 }
7052 
7053 /// \brief Ensure that the type of the given expression is complete.
7054 ///
7055 /// This routine checks whether the expression \p E has a complete type. If the
7056 /// expression refers to an instantiable construct, that instantiation is
7057 /// performed as needed to complete its type. Furthermore
7058 /// Sema::RequireCompleteType is called for the expression's type (or in the
7059 /// case of a reference type, the referred-to type).
7060 ///
7061 /// \param E The expression whose type is required to be complete.
7062 /// \param Diagnoser The object that will emit a diagnostic if the type is
7063 /// incomplete.
7064 ///
7065 /// \returns \c true if the type of \p E is incomplete and diagnosed, \c false
7066 /// otherwise.
7068  QualType T = E->getType();
7069 
7070  // Incomplete array types may be completed by the initializer attached to
7071  // their definitions. For static data members of class templates and for
7072  // variable templates, we need to instantiate the definition to get this
7073  // initializer and complete the type.
7074  if (T->isIncompleteArrayType()) {
7076  T = E->getType();
7077  }
7078 
7079  // FIXME: Are there other cases which require instantiating something other
7080  // than the type to complete the type of an expression?
7081 
7082  return RequireCompleteType(E->getExprLoc(), T, Diagnoser);
7083 }
7084 
7085 bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) {
7086  BoundTypeDiagnoser<> Diagnoser(DiagID);
7087  return RequireCompleteExprType(E, Diagnoser);
7088 }
7089 
7090 /// @brief Ensure that the type T is a complete type.
7091 ///
7092 /// This routine checks whether the type @p T is complete in any
7093 /// context where a complete type is required. If @p T is a complete
7094 /// type, returns false. If @p T is a class template specialization,
7095 /// this routine then attempts to perform class template
7096 /// instantiation. If instantiation fails, or if @p T is incomplete
7097 /// and cannot be completed, issues the diagnostic @p diag (giving it
7098 /// the type @p T) and returns true.
7099 ///
7100 /// @param Loc The location in the source that the incomplete type
7101 /// diagnostic should refer to.
7102 ///
7103 /// @param T The type that this routine is examining for completeness.
7104 ///
7105 /// @returns @c true if @p T is incomplete and a diagnostic was emitted,
7106 /// @c false otherwise.
7108  TypeDiagnoser &Diagnoser) {
7109  if (RequireCompleteTypeImpl(Loc, T, &Diagnoser))
7110  return true;
7111  if (const TagType *Tag = T->getAs<TagType>()) {
7112  if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
7113  Tag->getDecl()->setCompleteDefinitionRequired();
7114  Consumer.HandleTagDeclRequiredDefinition(Tag->getDecl());
7115  }
7116  }
7117  return false;
7118 }
7119 
7121  llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls;
7122  if (!Suggested)
7123  return false;
7124 
7125  // FIXME: Add a specific mode for C11 6.2.7/1 in StructuralEquivalenceContext
7126  // and isolate from other C++ specific checks.
7128  D->getASTContext(), Suggested->getASTContext(), NonEquivalentDecls,
7129  false /*StrictTypeSpelling*/, true /*Complain*/,
7130  true /*ErrorOnTagTypeMismatch*/);
7131  return Ctx.IsStructurallyEquivalent(D, Suggested);
7132 }
7133 
7134 /// \brief Determine whether there is any declaration of \p D that was ever a
7135 /// definition (perhaps before module merging) and is currently visible.
7136 /// \param D The definition of the entity.
7137 /// \param Suggested Filled in with the declaration that should be made visible
7138 /// in order to provide a definition of this entity.
7139 /// \param OnlyNeedComplete If \c true, we only need the type to be complete,
7140 /// not defined. This only matters for enums with a fixed underlying
7141 /// type, since in all other cases, a type is complete if and only if it
7142 /// is defined.
7144  bool OnlyNeedComplete) {
7145  // Easy case: if we don't have modules, all declarations are visible.
7146  if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility)
7147  return true;
7148 
7149  // If this definition was instantiated from a template, map back to the
7150  // pattern from which it was instantiated.
7151  if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
7152  // We're in the middle of defining it; this definition should be treated
7153  // as visible.
7154  return true;
7155  } else if (auto *RD = dyn_cast<CXXRecordDecl>(D)) {
7156  if (auto *Pattern = RD->getTemplateInstantiationPattern())
7157  RD = Pattern;
7158  D = RD->getDefinition();
7159  } else if (auto *ED = dyn_cast<EnumDecl>(D)) {
7160  if (auto *Pattern = ED->getTemplateInstantiationPattern())
7161  ED = Pattern;
7162  if (OnlyNeedComplete && ED->isFixed()) {
7163  // If the enum has a fixed underlying type, and we're only looking for a
7164  // complete type (not a definition), any visible declaration of it will
7165  // do.
7166  *Suggested = nullptr;
7167  for (auto *Redecl : ED->redecls()) {
7168  if (isVisible(Redecl))
7169  return true;
7170  if (Redecl->isThisDeclarationADefinition() ||
7171  (Redecl->isCanonicalDecl() && !*Suggested))
7172  *Suggested = Redecl;
7173  }
7174  return false;
7175  }
7176  D = ED->getDefinition();
7177  } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7178  if (auto *Pattern = FD->getTemplateInstantiationPattern())
7179  FD = Pattern;
7180  D = FD->getDefinition();
7181  } else if (auto *VD = dyn_cast<VarDecl>(D)) {
7182  if (auto *Pattern = VD->getTemplateInstantiationPattern())
7183  VD = Pattern;
7184  D = VD->getDefinition();
7185  }
7186  assert(D && "missing definition for pattern of instantiated definition");
7187 
7188  *Suggested = D;
7189  if (isVisible(D))
7190  return true;
7191 
7192  // The external source may have additional definitions of this entity that are
7193  // visible, so complete the redeclaration chain now and ask again.
7194  if (auto *Source = Context.getExternalSource()) {
7195  Source->CompleteRedeclChain(D);
7196  return isVisible(D);
7197  }
7198 
7199  return false;
7200 }
7201 
7202 /// Locks in the inheritance model for the given class and all of its bases.
7204  RD = RD->getMostRecentDecl();
7205  if (!RD->hasAttr<MSInheritanceAttr>()) {
7206  MSInheritanceAttr::Spelling IM;
7207 
7210  IM = RD->calculateInheritanceModel();
7211  break;
7213  IM = MSInheritanceAttr::Keyword_single_inheritance;
7214  break;
7216  IM = MSInheritanceAttr::Keyword_multiple_inheritance;
7217  break;
7219  IM = MSInheritanceAttr::Keyword_unspecified_inheritance;
7220  break;
7221  }
7222 
7223  RD->addAttr(MSInheritanceAttr::CreateImplicit(
7224  S.getASTContext(), IM,
7225  /*BestCase=*/S.MSPointerToMemberRepresentationMethod ==
7229  : RD->getSourceRange()));
7231  }
7232 }
7233 
7234 /// \brief The implementation of RequireCompleteType
7235 bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
7236  TypeDiagnoser *Diagnoser) {
7237  // FIXME: Add this assertion to make sure we always get instantiation points.
7238  // assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType");
7239  // FIXME: Add this assertion to help us flush out problems with
7240  // checking for dependent types and type-dependent expressions.
7241  //
7242  // assert(!T->isDependentType() &&
7243  // "Can't ask whether a dependent type is complete");
7244 
7245  // We lock in the inheritance model once somebody has asked us to ensure
7246  // that a pointer-to-member type is complete.
7248  if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) {
7249  if (!MPTy->getClass()->isDependentType()) {
7250  (void)isCompleteType(Loc, QualType(MPTy->getClass(), 0));
7251  assignInheritanceModel(*this, MPTy->getMostRecentCXXRecordDecl());
7252  }
7253  }
7254  }
7255 
7256  NamedDecl *Def = nullptr;
7257  bool Incomplete = T->isIncompleteType(&Def);
7258 
7259  // Check that any necessary explicit specializations are visible. For an
7260  // enum, we just need the declaration, so don't check this.
7261  if (Def && !isa<EnumDecl>(Def))
7263 
7264  // If we have a complete type, we're done.
7265  if (!Incomplete) {
7266  // If we know about the definition but it is not visible, complain.
7267  NamedDecl *SuggestedDef = nullptr;
7268  if (Def &&
7269  !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) {
7270  // If the user is going to see an error here, recover by making the
7271  // definition visible.
7272  bool TreatAsComplete = Diagnoser && !isSFINAEContext();
7273  if (Diagnoser)
7275  /*Recover*/TreatAsComplete);
7276  return !TreatAsComplete;
7277  }
7278 
7279  return false;
7280  }
7281 
7282  const TagType *Tag = T->getAs<TagType>();
7283  const ObjCInterfaceType *IFace = T->getAs<ObjCInterfaceType>();
7284 
7285  // If there's an unimported definition of this type in a module (for
7286  // instance, because we forward declared it, then imported the definition),
7287  // import that definition now.
7288  //
7289  // FIXME: What about other cases where an import extends a redeclaration
7290  // chain for a declaration that can be accessed through a mechanism other
7291  // than name lookup (eg, referenced in a template, or a variable whose type
7292  // could be completed by the module)?
7293  //
7294  // FIXME: Should we map through to the base array element type before
7295  // checking for a tag type?
7296  if (Tag || IFace) {
7297  NamedDecl *D =
7298  Tag ? static_cast<NamedDecl *>(Tag->getDecl()) : IFace->getDecl();
7299 
7300  // Avoid diagnosing invalid decls as incomplete.
7301  if (D->isInvalidDecl())
7302  return true;
7303 
7304  // Give the external AST source a chance to complete the type.
7305  if (auto *Source = Context.getExternalSource()) {
7306  if (Tag)
7307  Source->CompleteType(Tag->getDecl());
7308  else
7309  Source->CompleteType(IFace->getDecl());
7310 
7311  // If the external source completed the type, go through the motions
7312  // again to ensure we're allowed to use the completed type.
7313  if (!T->isIncompleteType())
7314  return RequireCompleteTypeImpl(Loc, T, Diagnoser);
7315  }
7316  }
7317 
7318  // If we have a class template specialization or a class member of a
7319  // class template specialization, or an array with known size of such,
7320  // try to instantiate it.
7321  QualType MaybeTemplate = T;
7322  while (const ConstantArrayType *Array
7323  = Context.getAsConstantArrayType(MaybeTemplate))
7324  MaybeTemplate = Array->getElementType();
7325  if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) {
7326  bool Instantiated = false;
7327  bool Diagnosed = false;
7328  if (ClassTemplateSpecializationDecl *ClassTemplateSpec
7329  = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
7330  if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) {
7332  Loc, ClassTemplateSpec, TSK_ImplicitInstantiation,
7333  /*Complain=*/Diagnoser);
7334  Instantiated = true;
7335  }
7336  } else if (CXXRecordDecl *Rec
7337  = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
7339  if (!Rec->isBeingDefined() && Pattern) {
7340  MemberSpecializationInfo *MSI = Rec->getMemberSpecializationInfo();
7341  assert(MSI && "Missing member specialization information?");
7342  // This record was instantiated from a class within a template.
7343  if (MSI->getTemplateSpecializationKind() !=
7345  Diagnosed = InstantiateClass(Loc, Rec, Pattern,
7348  /*Complain=*/Diagnoser);
7349  Instantiated = true;
7350  }
7351  }
7352  }
7353 
7354  if (Instantiated) {
7355  // Instantiate* might have already complained that the template is not
7356  // defined, if we asked it to.
7357  if (Diagnoser && Diagnosed)
7358  return true;
7359  // If we instantiated a definition, check that it's usable, even if
7360  // instantiation produced an error, so that repeated calls to this
7361  // function give consistent answers.
7362  if (!T->isIncompleteType())
7363  return RequireCompleteTypeImpl(Loc, T, Diagnoser);
7364  }
7365  }
7366 
7367  // FIXME: If we didn't instantiate a definition because of an explicit
7368  // specialization declaration, check that it's visible.
7369 
7370  if (!Diagnoser)
7371  return true;
7372 
7373  Diagnoser->diagnose(*this, Loc, T);
7374 
7375  // If the type was a forward declaration of a class/struct/union
7376  // type, produce a note.
7377  if (Tag && !Tag->getDecl()->isInvalidDecl())
7378  Diag(Tag->getDecl()->getLocation(),
7379  Tag->isBeingDefined() ? diag::note_type_being_defined
7380  : diag::note_forward_declaration)
7381  << QualType(Tag, 0);
7382 
7383  // If the Objective-C class was a forward declaration, produce a note.
7384  if (IFace && !IFace->getDecl()->isInvalidDecl())
7385  Diag(IFace->getDecl()->getLocation(), diag::note_forward_class);
7386 
7387  // If we have external information that we can use to suggest a fix,
7388  // produce a note.
7389  if (ExternalSource)
7390  ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T);
7391 
7392  return true;
7393 }
7394 
7396  unsigned DiagID) {
7397  BoundTypeDiagnoser<> Diagnoser(DiagID);
7398  return RequireCompleteType(Loc, T, Diagnoser);
7399 }
7400 
7401 /// \brief Get diagnostic %select index for tag kind for
7402 /// literal type diagnostic message.
7403 /// WARNING: Indexes apply to particular diagnostics only!
7404 ///
7405 /// \returns diagnostic %select index.
7407  switch (Tag) {
7408  case TTK_Struct: return 0;
7409  case TTK_Interface: return 1;
7410  case TTK_Class: return 2;
7411  default: llvm_unreachable("Invalid tag kind for literal type diagnostic!");
7412  }
7413 }
7414 
7415 /// @brief Ensure that the type T is a literal type.
7416 ///
7417 /// This routine checks whether the type @p T is a literal type. If @p T is an
7418 /// incomplete type, an attempt is made to complete it. If @p T is a literal
7419 /// type, or @p AllowIncompleteType is true and @p T is an incomplete type,
7420 /// returns false. Otherwise, this routine issues the diagnostic @p PD (giving
7421 /// it the type @p T), along with notes explaining why the type is not a
7422 /// literal type, and returns true.
7423 ///
7424 /// @param Loc The location in the source that the non-literal type
7425 /// diagnostic should refer to.
7426 ///
7427 /// @param T The type that this routine is examining for literalness.
7428 ///
7429 /// @param Diagnoser Emits a diagnostic if T is not a literal type.
7430 ///
7431 /// @returns @c true if @p T is not a literal type and a diagnostic was emitted,
7432 /// @c false otherwise.
7434  TypeDiagnoser &Diagnoser) {
7435  assert(!T->isDependentType() && "type should not be dependent");
7436 
7437  QualType ElemType = Context.getBaseElementType(T);
7438  if ((isCompleteType(Loc, ElemType) || ElemType->isVoidType()) &&
7439  T->isLiteralType(Context))
7440  return false;
7441 
7442  Diagnoser.diagnose(*this, Loc, T);
7443 
7444  if (T->isVariableArrayType())
7445  return true;
7446 
7447  const RecordType *RT = ElemType->getAs<RecordType>();
7448  if (!RT)
7449  return true;
7450 
7451  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
7452 
7453  // A partially-defined class type can't be a literal type, because a literal
7454  // class type must have a trivial destructor (which can't be checked until
7455  // the class definition is complete).
7456  if (RequireCompleteType(Loc, ElemType, diag::note_non_literal_incomplete, T))
7457  return true;
7458 
7459  // If the class has virtual base classes, then it's not an aggregate, and
7460  // cannot have any constexpr constructors or a trivial default constructor,
7461  // so is non-literal. This is better to diagnose than the resulting absence
7462  // of constexpr constructors.
7463  if (RD->getNumVBases()) {
7464  Diag(RD->getLocation(), diag::note_non_literal_virtual_base)
7466  for (const auto &I : RD->vbases())
7467  Diag(I.getLocStart(), diag::note_constexpr_virtual_base_here)
7468  << I.getSourceRange();
7469  } else if (!RD->isAggregate() && !RD->hasConstexprNonCopyMoveConstructor() &&
7471  Diag(RD->getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
7472  } else if (RD->hasNonLiteralTypeFieldsOrBases()) {
7473  for (const auto &I : RD->bases()) {
7474  if (!I.getType()->isLiteralType(Context)) {
7475  Diag(I.getLocStart(),
7476  diag::note_non_literal_base_class)
7477  << RD << I.getType() << I.getSourceRange();
7478  return true;
7479  }
7480  }
7481  for (const auto *I : RD->fields()) {
7482  if (!I->getType()->isLiteralType(Context) ||
7483  I->getType().isVolatileQualified()) {
7484  Diag(I->getLocation(), diag::note_non_literal_field)
7485  << RD << I << I->getType()
7486  << I->getType().isVolatileQualified();
7487  return true;
7488  }
7489  }
7490  } else if (!RD->hasTrivialDestructor()) {
7491  // All fields and bases are of literal types, so have trivial destructors.
7492  // If this class's destructor is non-trivial it must be user-declared.
7493  CXXDestructorDecl *Dtor = RD->getDestructor();
7494  assert(Dtor && "class has literal fields and bases but no dtor?");
7495  if (!Dtor)
7496  return true;
7497 
7498  Diag(Dtor->getLocation(), Dtor->isUserProvided() ?
7499  diag::note_non_literal_user_provided_dtor :
7500  diag::note_non_literal_nontrivial_dtor) << RD;
7501  if (!Dtor->isUserProvided())
7502  SpecialMemberIsTrivial(Dtor, CXXDestructor, /*Diagnose*/true);
7503  }
7504 
7505  return true;
7506 }
7507 
7508 bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID) {
7509  BoundTypeDiagnoser<> Diagnoser(DiagID);
7510  return RequireLiteralType(Loc, T, Diagnoser);
7511 }
7512 
7513 /// \brief Retrieve a version of the type 'T' that is elaborated by Keyword
7514 /// and qualified by the nested-name-specifier contained in SS.
7516  const CXXScopeSpec &SS, QualType T) {
7517  if (T.isNull())
7518  return T;
7519  NestedNameSpecifier *NNS;
7520  if (SS.isValid())
7521  NNS = SS.getScopeRep();
7522  else {
7523  if (Keyword == ETK_None)
7524  return T;
7525  NNS = nullptr;
7526  }
7527  return Context.getElaboratedType(Keyword, NNS, T);
7528 }
7529 
7532  if (ER.isInvalid()) return QualType();
7533  E = ER.get();
7534 
7535  if (!getLangOpts().CPlusPlus && E->refersToBitField())
7536  Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 2;
7537 
7538  if (!E->isTypeDependent()) {
7539  QualType T = E->getType();
7540  if (const TagType *TT = T->getAs<TagType>())
7541  DiagnoseUseOfDecl(TT->getDecl(), E->getExprLoc());
7542  }
7543  return Context.getTypeOfExprType(E);
7544 }
7545 
7546 /// getDecltypeForExpr - Given an expr, will return the decltype for
7547 /// that expression, according to the rules in C++11
7548 /// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18.
7550  if (E->isTypeDependent())
7551  return S.Context.DependentTy;
7552 
7553  // C++11 [dcl.type.simple]p4:
7554  // The type denoted by decltype(e) is defined as follows:
7555  //
7556  // - if e is an unparenthesized id-expression or an unparenthesized class
7557  // member access (5.2.5), decltype(e) is the type of the entity named
7558  // by e. If there is no such entity, or if e names a set of overloaded
7559  // functions, the program is ill-formed;
7560  //
7561  // We apply the same rules for Objective-C ivar and property references.
7562  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
7563  if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl()))
7564  return VD->getType();
7565  } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
7566  if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
7567  return FD->getType();
7568  } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) {
7569  return IR->getDecl()->getType();
7570  } else if (const ObjCPropertyRefExpr *PR = dyn_cast<ObjCPropertyRefExpr>(E)) {
7571  if (PR->isExplicitProperty())
7572  return PR->getExplicitProperty()->getType();
7573  } else if (auto *PE = dyn_cast<PredefinedExpr>(E)) {
7574  return PE->getType();
7575  }
7576 
7577  // C++11 [expr.lambda.prim]p18:
7578  // Every occurrence of decltype((x)) where x is a possibly
7579  // parenthesized id-expression that names an entity of automatic
7580  // storage duration is treated as if x were transformed into an
7581  // access to a corresponding data member of the closure type that
7582  // would have been declared if x were an odr-use of the denoted
7583  // entity.
7584  using namespace sema;
7585  if (S.getCurLambda()) {
7586  if (isa<ParenExpr>(E)) {
7587  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
7588  if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
7589  QualType T = S.getCapturedDeclRefType(Var, DRE->getLocation());
7590  if (!T.isNull())
7591  return S.Context.getLValueReferenceType(T);
7592  }
7593  }
7594  }
7595  }
7596 
7597 
7598  // C++11 [dcl.type.simple]p4:
7599  // [...]
7600  QualType T = E->getType();
7601  switch (E->getValueKind()) {
7602  // - otherwise, if e is an xvalue, decltype(e) is T&&, where T is the
7603  // type of e;
7604  case VK_XValue: T = S.Context.getRValueReferenceType(T); break;
7605  // - otherwise, if e is an lvalue, decltype(e) is T&, where T is the
7606  // type of e;
7607  case VK_LValue: T = S.Context.getLValueReferenceType(T); break;
7608  // - otherwise, decltype(e) is the type of e.
7609  case VK_RValue: break;
7610  }
7611 
7612  return T;
7613 }
7614 
7616  bool AsUnevaluated) {
7618  if (ER.isInvalid()) return QualType();
7619  E = ER.get();
7620 
7621  if (AsUnevaluated && CodeSynthesisContexts.empty() &&
7622  E->HasSideEffects(Context, false)) {
7623  // The expression operand for decltype is in an unevaluated expression
7624  // context, so side effects could result in unintended consequences.
7625  Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
7626  }
7627 
7628  return Context.getDecltypeType(E, getDecltypeForExpr(*this, E));
7629 }
7630 
7633  SourceLocation Loc) {
7634  switch (UKind) {
7636  if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) {
7637  Diag(Loc, diag::err_only_enums_have_underlying_types);
7638  return QualType();
7639  } else {
7640  QualType Underlying = BaseType;
7641  if (!BaseType->isDependentType()) {
7642  // The enum could be incomplete if we're parsing its definition or
7643  // recovering from an error.
7644  NamedDecl *FwdDecl = nullptr;
7645  if (BaseType->isIncompleteType(&FwdDecl)) {
7646  Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
7647  Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl;
7648  return QualType();
7649  }
7650 
7651  EnumDecl *ED = BaseType->getAs<EnumType>()->getDecl();
7652  assert(ED && "EnumType has no EnumDecl");
7653 
7654  DiagnoseUseOfDecl(ED, Loc);
7655 
7656  Underlying = ED->getIntegerType();
7657  assert(!Underlying.isNull());
7658  }
7659  return Context.getUnaryTransformType(BaseType, Underlying,
7661  }
7662  }
7663  llvm_unreachable("unknown unary transform type");
7664 }
7665 
7667  if (!T->isDependentType()) {
7668  // FIXME: It isn't entirely clear whether incomplete atomic types
7669  // are allowed or not; for simplicity, ban them for the moment.
7670  if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
7671  return QualType();
7672 
7673  int DisallowedKind = -1;
7674  if (T->isArrayType())
7675  DisallowedKind = 1;
7676  else if (T->isFunctionType())
7677  DisallowedKind = 2;
7678  else if (T->isReferenceType())
7679  DisallowedKind = 3;
7680  else if (T->isAtomicType())
7681  DisallowedKind = 4;
7682  else if (T.hasQualifiers())
7683  DisallowedKind = 5;
7684  else if (!T.isTriviallyCopyableType(Context))
7685  // Some other non-trivially-copyable type (probably a C++ class)
7686  DisallowedKind = 6;
7687 
7688  if (DisallowedKind != -1) {
7689  Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind << T;
7690  return QualType();
7691  }
7692 
7693  // FIXME: Do we need any handling for ARC here?
7694  }
7695 
7696  // Build the pointer type.
7697  return Context.getAtomicType(T);
7698 }
FileNullabilityMap NullabilityMap
A mapping that describes the nullability we've seen in each header file.
Definition: Sema.h:460
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1454
bool CheckNoCallerSavedRegsAttr(const AttributeList &attr)
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:539
static CallingConv getCCForDeclaratorChunk(Sema &S, Declarator &D, const DeclaratorChunk::FunctionTypeInfo &FTI, unsigned ChunkIndex)
Helper for figuring out the default CC for a function declarator type.
Definition: SemaType.cpp:3113
Kind getKind() const
Definition: Type.h:2105
bool CheckNoReturnAttr(const AttributeList &attr)
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5605
static void HandleExtVectorTypeAttr(QualType &CurType, const AttributeList &Attr, Sema &S)
Process the OpenCL-like ext_vector_type attribute when it occurs on a type.
Definition: SemaType.cpp:6631
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType) const
Defines the clang::ASTContext interface.
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
Definition: SemaDecl.cpp:2785
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:4576
SourceLocation getEnd() const
static bool handleObjCPointerTypeAttr(TypeProcessingState &state, AttributeList &attr, QualType &type)
Definition: SemaType.cpp:312
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
unsigned UnalignedQualLoc
The location of the __unaligned-qualifier, if any.
Definition: DeclSpec.h:1170
const Type * Ty
The locally-unqualified type.
Definition: Type.h:561
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1001
CanQualType LongLongTy
Definition: ASTContext.h:971
static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for literal type diagnostic message.
Definition: SemaType.cpp:7406
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:5437
bool isVariadic() const
Definition: Type.h:3442
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2245
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
Definition: DeclSpec.h:1252
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:10411
static bool isOmittedBlockReturnType(const Declarator &D)
isOmittedBlockReturnType - Return true if this declarator is missing a return type because this is a ...
Definition: SemaType.cpp:49
no exception specification
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
Definition: SemaType.cpp:2354
This is a discriminated union of FileInfo and ExpansionInfo.
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
Definition: TargetInfo.h:363
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2224
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:544
QualType BuildWritePipeType(QualType T, SourceLocation Loc)
Build a Write-only Pipe type.
Definition: SemaType.cpp:1981
A (possibly-)qualified type.
Definition: Type.h:616
ASTConsumer & Consumer
Definition: Sema.h:306
base_class_range bases()
Definition: DeclCXX.h:737
bool isInvalid() const
Definition: Ownership.h:159
const AttributeList * getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1524
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1308
bool isMacroID() const
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:543
TypeResult actOnObjCTypeArgsAndProtocolQualifiers(Scope *S, SourceLocation Loc, ParsedType BaseType, SourceLocation TypeArgsLAngleLoc, ArrayRef< ParsedType > TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< Decl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc)
Build a specialized and/or protocol-qualified Objective-C type.
Definition: SemaType.cpp:1101
Wrapper for source info for tag types.
Definition: TypeLoc.h:675
ExtInfo withCallingConv(CallingConv cc) const
Definition: Type.h:3042
TSW getTypeSpecWidth() const
Definition: DeclSpec.h:477
static void distributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state, AttributeList &attr, QualType &declSpecType)
Distribute an objc_gc type attribute that was written on the declarator.
Definition: SemaType.cpp:455
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1119
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1350
static const TSS TSS_unsigned
Definition: DeclSpec.h:268
bool isMemberPointerType() const
Definition: Type.h:5736
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
TheContext getContext() const
Definition: DeclSpec.h:1874
QualType BuildUnaryTransformType(QualType BaseType, UnaryTransformType::UTTKind UKind, SourceLocation Loc)
Definition: SemaType.cpp:7631
__auto_type (GNU extension)
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2954
void setNameEndLoc(SourceLocation Loc)
Definition: TypeLoc.h:1108
static const TST TST_wchar
Definition: DeclSpec.h:275
static LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t', '\f', '\v', '\n', '\r'.
Definition: CharInfo.h:88
Decl * getRepAsDecl() const
Definition: DeclSpec.h:492
CanQualType Char32Ty
Definition: ASTContext.h:970
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1804
const LangOptions & getLangOpts() const
Definition: Sema.h:1166
#define CALLING_CONV_ATTRS_CASELIST
Definition: SemaType.cpp:105
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:2194
The attribute is immediately after the declaration's name.
Definition: SemaType.cpp:291
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1399
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration...
Definition: DeclCXX.h:2001
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1242
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:281
void setExceptionSpecRange(SourceRange R)
Definition: TypeLoc.h:1412
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2923
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:1905
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
unsigned getSemanticSpelling() const
If the parsed attribute has a semantic equivalent, and it would have a semantic Spelling enumeration ...
void setEmbeddedInDeclarator(bool isInDeclarator)
Definition: Decl.h:2978
TypedefDecl - Represents the declaration of a typedef-name via the 'typedef' type specifier...
Definition: Decl.h:2770
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Definition: Preprocessor.h:974
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:779
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
Qualifiers::GC getObjCGCAttr() const
Returns gc attribute of this type.
Definition: Type.h:5610
A conversion function name, e.g., operator int.
Definition: DeclSpec.h:912
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:469
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
bool isRecordType() const
Definition: Type.h:5769
static const TST TST_typeofExpr
Definition: DeclSpec.h:295
QualType getUnderlyingType() const
Definition: Decl.h:2727
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1243
static const TST TST_char16
Definition: DeclSpec.h:276
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
static NullabilityKind mapNullabilityAttrKind(AttributeList::Kind kind)
Map a nullability attribute kind to a nullability kind.
Definition: SemaType.cpp:6200
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer...
bool isTypeAltiVecBool() const
Definition: DeclSpec.h:483
WrittenBuiltinSpecs & getWrittenBuiltinSpecs()
Definition: TypeLoc.h:549
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2069
void setType(QualType t)
Definition: Expr.h:128
AttributePool & getAttributePool() const
Definition: DeclSpec.h:1858
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2154
Defines the C++ template declaration subclasses.
static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, AttributeList *attrs)
Definition: SemaType.cpp:6803
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4206
IdentifierInfo * Ident
Definition: AttributeList.h:75
bool hasAutoTypeSpec() const
Definition: DeclSpec.h:522
bool isEnumeralType() const
Definition: Type.h:5772
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7102
QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity)
Build an array type.
Definition: SemaType.cpp:2022
SCS getStorageClassSpec() const
Definition: DeclSpec.h:448
bool hasDefinition() const
Definition: DeclCXX.h:702
FunctionDefinitionKind getFunctionDefinitionKind() const
Definition: DeclSpec.h:2404
PtrTy get() const
Definition: Ownership.h:163
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
QualType getPointeeType() const
Definition: Type.h:2461
The base class of the type hierarchy.
Definition: Type.h:1303
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
CanQualType LongTy
Definition: ASTContext.h:971
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5522
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1133
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5260
SourceLocation EndLoc
EndLoc - If valid, the place where this chunck ends.
Definition: DeclSpec.h:1141
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:45
Wrapper for source info for typedefs.
Definition: TypeLoc.h:638
static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk)
Definition: SemaType.cpp:5357
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:494
bool isDecltypeAuto() const
Definition: Type.h:4217
The attribute is part of a DeclaratorChunk.
Definition: SemaType.cpp:289
bool isBooleanType() const
Definition: Type.h:5969
A container of type source information.
Definition: Decl.h:62
static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, unsigned &TypeQuals, QualType TypeSoFar, unsigned RemoveTQs, unsigned DiagID)
Definition: SemaType.cpp:728
static void transferARCOwnership(TypeProcessingState &state, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
Used for transferring ownership in casts resulting in l-values.
Definition: SemaType.cpp:4889
bool getHasRegParm() const
Definition: Type.h:3067
AttributeList *& getAttrListRef()
Definition: DeclSpec.h:2346
bool isBlockPointerType() const
Definition: Type.h:5718
Wrapper for source info for pointers decayed from arrays and functions.
Definition: TypeLoc.h:1197
bool hasAttrEnumOperand() const
Definition: TypeLoc.h:841
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:9697
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:2876
TypeLoc getNextTypeLoc() const
Definition: TypeLoc.h:382
bool isSpelledAsLValue() const
Definition: Type.h:2377
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
#define NULLABILITY_TYPE_ATTRS_CASELIST
Definition: SemaType.cpp:137
CanQualType HalfTy
Definition: ASTContext.h:975
unsigned RestrictQualLoc
The location of the restrict-qualifier, if any.
Definition: DeclSpec.h:1164
static AttributedType::Kind getCCTypeAttrKind(AttributeList &Attr)
Definition: SemaType.cpp:6304
bool checkObjCKindOfType(QualType &type, SourceLocation loc)
Check the application of the Objective-C '__kindof' qualifier to the given type.
Definition: SemaType.cpp:6153
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
Definition: DeclSpec.h:1462
void setParensRange(SourceRange range)
Definition: TypeLoc.h:1741
SourceLocation getIncludeLoc() const
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
An identifier, stored as an IdentifierInfo*.
SourceLocation getCommaLoc() const
Definition: DeclSpec.h:2389
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:758
unsigned isStar
True if this dimension was [*]. In this case, NumElts is null.
Definition: DeclSpec.h:1194
static DeclaratorChunk * maybeMovePastReturnType(Declarator &declarator, unsigned i, bool onlyBlockPointers)
Given the index of a declarator chunk, check whether that chunk directly specifies the return type of...
Definition: SemaType.cpp:329
static const TST TST_underlyingType
Definition: DeclSpec.h:298
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type...
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1733
void removeObjCLifetime()
Definition: Type.h:315
DiagnosticsEngine & Diags
Definition: Sema.h:307
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1265
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
Definition: TypeLoc.h:254
ObjCLifetime getObjCLifetime() const
Definition: Type.h:309
bool hasAttrExprOperand() const
Definition: TypeLoc.h:836
CanQualType Float128Ty
Definition: ASTContext.h:974
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:1386
The "union" keyword.
Definition: Type.h:4494
Extra information about a function prototype.
Definition: Type.h:3234
CallingConv getCallConv() const
Definition: Type.h:3073
std::string getAsString() const
AutoTypeKeyword getKeyword() const
Definition: Type.h:4220
Represents a C++17 deduced template specialization type.
Definition: Type.h:4241
The "__interface" keyword.
Definition: Type.h:4492
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1924
Represents a variable template specialization, which refers to a variable template with a given set o...
static const TST TST_interface
Definition: DeclSpec.h:291
static const TST TST_char
Definition: DeclSpec.h:274
A namespace, stored as a NamespaceDecl*.
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
bool isImageType() const
Definition: Type.h:5853
bool hasAttrOperand() const
Definition: TypeLoc.h:846
bool canHaveNullability(bool ResultIfUnknown=true) const
Determine whether the given type can have a nullability specifier applied to it, i.e., if it is any kind of pointer type.
Definition: Type.cpp:3545
unsigned size() const
Determine the number of type parameters in this list.
Definition: DeclObjC.h:653
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1575
bool isArgIdent(unsigned Arg) const
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1434
bool isObjCRetainableType() const
Definition: Type.cpp:3751
static bool handleFunctionTypeAttr(TypeProcessingState &state, AttributeList &attr, QualType &type)
Process an individual function attribute.
Definition: SemaType.cpp:6354
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
Definition: DeclSpec.h:2169
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1167
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs, typeofs, etc., as well as any qualifiers.
Definition: Type.cpp:340
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1885
SourceLocation Loc
Definition: AttributeList.h:74
bool isVoidType() const
Definition: Type.h:5906
The collection of all-type qualifiers we support.
Definition: Type.h:118
PipeType - OpenCL20.
Definition: Type.h:5419
void setParensRange(SourceRange Range)
Definition: TypeLoc.h:2166
static const TST TST_unknown_anytype
Definition: DeclSpec.h:301
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
QualType BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity)
Build a member pointer type T Class::*.
Definition: SemaType.cpp:2403
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3354
__ptr16, alignas(...), etc.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.h:1894
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
Definition: DeclSpec.h:1329
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3249
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
void setLocalRangeEnd(SourceLocation L)
Definition: TypeLoc.h:1385
static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, QualifiedFunctionKind QFK)
Check whether the type T is a qualified function type, and if it is, diagnose that it cannot be conta...
Definition: SemaType.cpp:1846
static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex)
Returns true if any of the declarator chunks before endIndex include a level of indirection: array...
Definition: SemaType.cpp:3599
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1225
ParameterABI getABI() const
Return the ABI treatment of this parameter.
Definition: Type.h:3162
static void distributeFunctionTypeAttr(TypeProcessingState &state, AttributeList &attr, QualType type)
A function type attribute was written somewhere in a declaration other than on the declarator itself ...
Definition: SemaType.cpp:517
static const TST TST_decimal32
Definition: DeclSpec.h:285
bool hasAttr() const
Definition: DeclBase.h:521
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Definition: DeclSpec.h:956
void removeRestrict()
Definition: Type.h:255
Represents a class type in Objective C.
Definition: Type.h:4969
AttributeList * getList() const
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1813
llvm::PointerUnion< Expr *, IdentifierLoc * > ArgsUnion
A union of the various pointer types that can be passed to an AttributeList as an argument...
Definition: AttributeList.h:83
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
A C++ nested-name-specifier augmented with source location information.
is ARM Neon vector
Definition: Type.h:2804
SourceLocation getRestrictQualifierLoc() const
Retrieve the location of the 'restrict' qualifier, if any.
Definition: DeclSpec.h:1422
bool isTypeSpecPipe() const
Definition: DeclSpec.h:486
LineState State
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3343
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
Definition: Type.cpp:3713
QualType BuildParenType(QualType T)
Build a paren type including T.
Definition: SemaType.cpp:1750
void setBuiltinLoc(SourceLocation Loc)
Definition: TypeLoc.h:534
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1864
SourceLocation getTypeSpecSignLoc() const
Definition: DeclSpec.h:510
QualType getAddrSpaceQualType(QualType T, unsigned AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
TSS getTypeSpecSign() const
Definition: DeclSpec.h:479
void setRBracketLoc(SourceLocation Loc)
Definition: TypeLoc.h:1499
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
bool isReferenceType() const
Definition: Type.h:5721
static bool distributeNullabilityTypeAttr(TypeProcessingState &state, QualType type, AttributeList &attr)
Distribute a nullability type attribute that cannot be applied to the type specifier to a pointer...
Definition: SemaType.cpp:6222
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
static const TST TST_class
Definition: DeclSpec.h:292
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2366
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2960
bool isAnyPointerType() const
Definition: Type.h:5715
static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, AttributeList &attr, QualType &type)
handleObjCOwnershipTypeAttr - Process an objc_ownership attribute on the specified type...
Definition: SemaType.cpp:5612
void removeConst()
Definition: Type.h:241
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned The qualifier bitmask values are the same as...
Definition: DeclSpec.h:1256
bool isEmpty() const
isEmpty - Return true if this declaration specifier is completely empty: no tokens were parsed in the...
Definition: DeclSpec.h:605
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:2990
static const TST TST_double
Definition: DeclSpec.h:282
static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr, QualType type)
diagnoseBadTypeAttribute - Diagnoses a type attribute which doesn't apply to the given type...
Definition: SemaType.cpp:66
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1934
static std::string getPrintableNameForEntity(DeclarationName Entity)
Definition: SemaType.cpp:1651
TagKind getTagKind() const
Definition: Decl.h:3019
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:397
ParsedType ActOnObjCInstanceType(SourceLocation Loc)
The parser has parsed the context-sensitive type 'instancetype' in an Objective-C message declaration...
Definition: SemaType.cpp:5485
static const TST TST_error
Definition: DeclSpec.h:306
TypeLoc getValueLoc() const
Definition: TypeLoc.h:2189
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6...
Definition: SemaType.cpp:7120
virtual bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc, QualType T)
Produces a diagnostic note if the external source contains a complete definition for T...
static const TST TST_enum
Definition: DeclSpec.h:288
QualType getTypeOfType(QualType t) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes...
static void maybeSynthesizeBlockSignature(TypeProcessingState &state, QualType declSpecType)
Add a synthetic '()' to a block-literal declarator if it is required, given the return type...
Definition: SemaType.cpp:667
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:511
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1885
static const TSW TSW_unspecified
Definition: DeclSpec.h:253
void copy(DependentTemplateSpecializationTypeLoc Loc)
Definition: TypeLoc.h:2071
void setUnderlyingTInfo(TypeSourceInfo *TInfo)
Definition: TypeLoc.h:1818
Wrapper of type source information for a type with no direct qualifiers.
Definition: TypeLoc.h:229
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final * state
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1295
virtual void HandleTagDeclRequiredDefinition(const TagDecl *D)
This callback is invoked the first time each TagDecl is required to be complete.
Definition: ASTConsumer.h:77
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator, which is not a function declaration or definition and therefore is not permitted to have default arguments.
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
Definition: Diagnostic.h:1200
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1053
IdentifierTable & Idents
Definition: ASTContext.h:513
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:106
Values of this type can be null.
static void inferARCWriteback(TypeProcessingState &state, QualType &declSpecType)
Given that this is the declaration of a parameter under ARC, attempt to infer attributes and such for...
Definition: SemaType.cpp:2492
static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc)
Definition: SemaType.cpp:3500
T * getAttr() const
Definition: DeclBase.h:518
PointerTypeInfo Ptr
Definition: DeclSpec.h:1500
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1677
void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly...
Definition: SemaType.cpp:6525
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment...
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:899
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1585
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
Definition: Sema.cpp:1165
QualType getParenType(QualType NamedType) const
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:505
static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo)
Definition: SemaType.cpp:2710
Represents the results of name lookup.
Definition: Lookup.h:32
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
Definition: ASTMatchers.h:158
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:643
static void HandleVectorSizeAttr(QualType &CurType, const AttributeList &Attr, Sema &S)
HandleVectorSizeAttribute - this attribute is only applicable to integral and float scalars...
Definition: SemaType.cpp:6572
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1262
unsigned ConstQualLoc
The location of the const-qualifier, if any.
Definition: DeclSpec.h:1158
static void fixItNullability(Sema &S, DiagnosticBuilder &Diag, SourceLocation PointerLoc, NullabilityKind Nullability)
Creates a fix-it to insert a C-style nullability keyword at pointerLoc, taking into account whitespac...
Definition: SemaType.cpp:3465
void setCaretLoc(SourceLocation Loc)
Definition: TypeLoc.h:1255
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2152
static void spliceAttrOutOfList(AttributeList &attr, AttributeList *&head)
Definition: SemaType.cpp:260
static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator, PointerWrappingDeclaratorKind &wrappingKind)
Classify the given declarator, whose type-specified is type, based on what kind of pointer it refers ...
Definition: SemaType.cpp:3282
SourceLocation getRAngleLoc() const
Definition: TypeLoc.h:1592
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
Definition: DeclSpec.h:2268
bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T)
Check if type T corresponding to declaration specifier DS is disabled due to required OpenCL extensio...
Definition: Sema.cpp:1691
bool hasTrailingReturnType() const
Determine whether a trailing return type was written (at any level) within this declarator.
Definition: DeclSpec.h:2319
QualType getReturnType() const
Definition: Type.h:3065
Wrapper for source info for functions.
Definition: TypeLoc.h:1357
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
Definition: Type.cpp:2383
ArrayTypeInfo Arr
Definition: DeclSpec.h:1502
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, AttributeList &attr, QualType &type)
Definition: SemaType.cpp:5990
static bool hasDirectOwnershipQualifier(QualType type)
Does this type have a "direct" ownership qualifier? That is, is it written like "__strong id"...
Definition: SemaType.cpp:5581
Whether values of this type can be null is (explicitly) unspecified.
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:115
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, QualType &declSpecType)
Given that there are attributes written on the declarator itself, try to distribute any type attribut...
Definition: SemaType.cpp:625
field_range fields() const
Definition: Decl.h:3483
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5576
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3770
bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC, const FunctionDecl *FD=nullptr)
bool hasNonLiteralTypeFieldsOrBases() const
Determine whether this class has a non-literal or/ volatile type non-static data member or base class...
Definition: DeclCXX.h:1391
void addCVRQualifiers(unsigned mask)
Definition: Type.h:271
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2642
An implicit 'self' parameter.
Definition: DeclSpec.h:924
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:148
bool needsExtraLocalData() const
Definition: TypeLoc.h:556
RecordDecl * getDecl() const
Definition: Type.h:3793
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
Definition: DeclSpec.h:2147
void expandBuiltinRange(SourceRange Range)
Definition: TypeLoc.h:537
CanQualType LongDoubleTy
Definition: ASTContext.h:974
Values of this type can never be null.
QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope...
Definition: SemaExpr.cpp:14348
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
Wrapper for source info for ObjC interfaces.
Definition: TypeLoc.h:1083
QualType BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc)
Build an ext-vector type.
Definition: SemaType.cpp:2226
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Definition: Type.cpp:76
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
TypeClass getTypeClass() const
Definition: Type.h:1555
enum clang::DeclaratorChunk::@196 Kind
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1985
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1930
#define MS_TYPE_ATTRS_CASELIST
Definition: SemaType.cpp:130
void setUnaligned(bool flag)
Definition: Type.h:281
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
static FileID getNullabilityCompletenessCheckFileID(Sema &S, SourceLocation loc)
Definition: SemaType.cpp:3426
Preprocessor & PP
Definition: Sema.h:304
bool isInvalid() const
static void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc)
Complains about missing nullability if the file containing pointerLoc has other uses of nullability (...
Definition: SemaType.cpp:3531
void setLocalRangeBegin(SourceLocation L)
Definition: TypeLoc.h:1378
static void transferARCOwnershipToDeclSpec(Sema &S, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
Definition: SemaType.cpp:4838
SourceRange getTypeSpecWidthRange() const
Definition: DeclSpec.h:508
Represents an ObjC class declaration.
Definition: DeclObjC.h:1108
void copy(ElaboratedTypeLoc Loc)
Definition: TypeLoc.h:1913
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:504
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:503
bool empty() const
Definition: Type.h:395
void setInvalid(bool b=true) const
detail::InMemoryDirectory::const_iterator I
is ARM Neon polynomial vector
Definition: Type.h:2805
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
unsigned getNumParams() const
Definition: TypeLoc.h:1426
SmallVector< TemplateTypeParmDecl *, 4 > AutoTemplateParams
Store the list of the auto parameters for a generic lambda.
Definition: ScopeInfo.h:778
void removeVolatile()
Definition: Type.h:248
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2110
CanQualType UnsignedCharTy
Definition: ASTContext.h:972
QualType getType() const
Definition: Decl.h:589
bool isInvalid() const
const LangOptions & LangOpts
Definition: Sema.h:303
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:53
static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy)
Definition: SemaType.cpp:1806
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:1807
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
uint8_t PointerKind
Which kind of pointer declarator we saw.
Definition: Sema.h:232
This object can be modified without requiring retains or releases.
Definition: Type.h:139
SourceRange getRange() const
Definition: DeclSpec.h:68
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:7357
DiagnosticsEngine & getDiagnostics() const
static const TST TST_float
Definition: DeclSpec.h:281
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void setUnderlyingTInfo(TypeSourceInfo *TI) const
Definition: TypeLoc.h:1779
bool IsStructurallyEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: SemaType.cpp:5449
AttributedType::Kind getAttrKind() const
Definition: TypeLoc.h:832
QualType BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a block pointer type.
Definition: SemaType.cpp:2454
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
Definition: TypeLoc.h:152
static OpenCLAccessAttr::Spelling getImageAccess(const AttributeList *Attrs)
Definition: SemaType.cpp:1211
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1856
SourceRange getTypeofParensRange() const
Definition: DeclSpec.h:519
bool hasConstexprNonCopyMoveConstructor() const
Determine whether this class has at least one constexpr constructor other than the copy or move const...
Definition: DeclCXX.h:1272
ExtInfo getExtInfo() const
Definition: Type.h:3074
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:269
static const TSW TSW_long
Definition: DeclSpec.h:255
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
CXXRecordDecl * getMostRecentDecl()
Definition: DeclCXX.h:686
static bool handleObjCGCTypeAttr(TypeProcessingState &state, AttributeList &attr, QualType &type)
handleObjCGCTypeAttr - Process the attribute((objc_gc)) type attribute on the specified type...
Definition: SemaType.cpp:5798
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition: DeclSpec.h:2214
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:953
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
TST getTypeSpecType() const
Definition: DeclSpec.h:480
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3129
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
Definition: DeclCXX.cpp:1336
Kind getKind() const
void setParensRange(SourceRange Range)
Definition: TypeLoc.h:1829
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
Definition: LocInfoType.h:29
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
static void checkExtParameterInfos(Sema &S, ArrayRef< QualType > paramTypes, const FunctionProtoType::ExtProtoInfo &EPI, llvm::function_ref< SourceLocation(unsigned)> getParamLoc)
Check the extended parameter information.
Definition: SemaType.cpp:2301
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1028
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1279
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2503
ASTContext * Context
std::vector< bool > & Stack
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/unaligned/atomic.
Definition: DeclSpec.h:1155
void addObjCLifetime(ObjCLifetime type)
Definition: Type.h:316
static QualType ConvertDeclSpecToType(TypeProcessingState &state)
Convert the specified declspec to the appropriate type object.
Definition: SemaType.cpp:1232
void setSizeExpr(Expr *Size)
Definition: TypeLoc.h:1510
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
void initialize(ASTContext &Context, SourceLocation Loc) const
Initializes this to state that every location in this type is the given location. ...
Definition: TypeLoc.h:174
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:414
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:542
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1837
const WrittenBuiltinSpecs & getWrittenBuiltinSpecs() const
Definition: DeclSpec.h:763
QualType BuildObjCObjectType(QualType BaseType, SourceLocation Loc, SourceLocation TypeArgsLAngleLoc, ArrayRef< TypeSourceInfo * > TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError=false)
Build an Objective-C object pointer type.
Definition: SemaType.cpp:1026
SourceLocation getLParenLoc() const
Definition: DeclSpec.h:1382
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
unsigned hasStatic
True if this dimension included the 'static' keyword.
Definition: DeclSpec.h:1191
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:5497
SourceLocation getVolatileQualifierLoc() const
Retrieve the location of the 'volatile' qualifier, if any.
Definition: DeclSpec.h:1417
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
Type source information for an attributed type.
Definition: TypeLoc.h:827
const Type * getTypeForDecl() const
Definition: Decl.h:2663
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D, const TemplateArgumentList *Innermost=nullptr, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:580
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:5975
Expr - This represents one expression.
Definition: Expr.h:105
MSInheritanceAttr::Spelling calculateInheritanceModel() const
Calculate what the inheritance model would be for this class.
StringRef getName() const
Return the actual identifier string.
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:546
void * getOpaqueData() const
Get the pointer where source information is stored.
Definition: TypeLoc.h:123
SourceLocation getTypeSpecComplexLoc() const
Definition: DeclSpec.h:509
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Definition: Type.h:3941
Declaration of a template type parameter.
TypeSpecifierWidth getWrittenWidthSpec() const
Definition: TypeLoc.h:590
bool isFunctionDefinition() const
Definition: DeclSpec.h:2400
static void HandleOpenCLAccessAttr(QualType &CurType, const AttributeList &Attr, Sema &S)
Handle OpenCL Access Qualifier Attribute.
Definition: SemaType.cpp:6769
unsigned VolatileQualLoc
The location of the volatile-qualifier, if any.
Definition: DeclSpec.h:1161
This file defines the classes used to store parsed information about declaration-specifiers and decla...
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4503
TypeResult ActOnTypeName(Scope *S, Declarator &D)
Definition: SemaType.cpp:5456
bool isAtomicType() const
Definition: Type.h:5794
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2551
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:111
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:956
QualType BuildAtomicType(QualType T, SourceLocation Loc)
Definition: SemaType.cpp:7666
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
Definition: DeclSpec.h:551
bool isVariableArrayType() const
Definition: Type.h:5760
Defines the clang::Preprocessor interface.
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:13138
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3347
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static void HandleNeonVectorTypeAttr(QualType &CurType, const AttributeList &Attr, Sema &S, VectorType::VectorKind VecKind)
HandleNeonVectorTypeAttr - The "neon_vector_type" and "neon_polyvector_type" attributes are used ...
Definition: SemaType.cpp:6721
void completeExprArrayBound(Expr *E)
Definition: SemaType.cpp:7009
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:545
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
Definition: Specifiers.h:254
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
Definition: ASTMatchers.h:352
CanQualType ShortTy
Definition: ASTContext.h:971
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
internal::Matcher< T > id(StringRef ID, const internal::BindableMatcher< T > &InnerMatcher)
If the provided matcher matches a node, binds the node to ID.
Definition: ASTMatchers.h:102
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Definition: ASTConsumer.h:108
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:15541
Represents a C++ template name within the type system.
Definition: TemplateName.h:176
static const TST TST_decimal64
Definition: DeclSpec.h:286
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7107
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition: Sema.h:1531
static QualType getDecltypeForExpr(Sema &S, Expr *E)
getDecltypeForExpr - Given an expr, will return the decltype for that expression, according to the ru...
Definition: SemaType.cpp:7549
bool isConstexprSpecified() const
Definition: DeclSpec.h:708
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:973
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:559
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1096
Kind getAttrKind() const
Definition: Type.h:3906
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:337
TypeDiagSelector
Definition: SemaType.cpp:41
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
Definition: Type.cpp:3663
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
bool LValueRef
True if this is an lvalue reference, false if it's an rvalue reference.
Definition: DeclSpec.h:1180
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:592
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1797
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
SourceLocation Loc
Loc - The place where this type was defined.
Definition: DeclSpec.h:1139
bool isFunctionOrMethod() const
Definition: DeclBase.h:1343
Qualifiers Quals
The local qualifiers.
Definition: Type.h:564
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1294
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
Definition: TypeLoc.h:720
SourceLocation getConstQualifierLoc() const
Retrieve the location of the 'const' qualifier, if any.
Definition: DeclSpec.h:1412
static const TST TST_int
Definition: DeclSpec.h:278
void setHasBaseTypeAsWritten(bool HasBaseType)
Definition: TypeLoc.h:1040
void setEllipsisLoc(SourceLocation EL)
Definition: DeclSpec.h:2394
static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, AttributeList &attr, QualType &declSpecType)
A function type attribute was written in the decl spec.
Definition: SemaType.cpp:571
void setPointOfInstantiation(SourceLocation Loc)
static QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference)
Given that we're building a pointer or reference to the given.
Definition: SemaType.cpp:1755
TypeSourceInfo * GetTypeSourceInfoForDeclarator(Declarator &D, QualType T, TypeSourceInfo *ReturnTypeInfo)
Create and instantiate a TypeSourceInfo with type source information.
Definition: SemaType.cpp:5390
void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
Compare two source locations.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
Definition: SemaType.cpp:7433
static const TST TST_half
Definition: DeclSpec.h:280
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2407
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Definition: DeclSpec.h:1440
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4166
Wraps an identifier and optional source location for the identifier.
Definition: AttributeList.h:73
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
Definition: DeclSpec.h:1459
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA)
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:148
SourceLocation getLocEnd() const LLVM_READONLY
Definition: TypeLoc.h:138
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1943
bool RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
Definition: SemaType.cpp:7067
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition: Type.h:745
static const TSW TSW_short
Definition: DeclSpec.h:254
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:166
AttributeList * create(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, ArgsUnion *args, unsigned numArgs, AttributeList::Syntax syntax, SourceLocation ellipsisLoc=SourceLocation())
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:232
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
SourceLocation PointerLoc
The first pointer declarator (of any pointer kind) in the file that does not have a corresponding nul...
Definition: Sema.h:229
CanQualType SignedCharTy
Definition: ASTContext.h:971
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:608
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
Definition: SemaType.cpp:4940
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:1610
bool hasObjCLifetime() const
Definition: Type.h:308
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
Definition: DeclSpec.h:1325
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:541
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result)
Return true if this is omitted block return type.
Definition: SemaType.cpp:756
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1272
static const TST TST_char32
Definition: DeclSpec.h:277
void addAttr(Attr *A)
Definition: DeclBase.h:472
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
void setTypeofLoc(SourceLocation Loc)
Definition: TypeLoc.h:1720
Context-sensitive version of a keyword attribute.
bool SawTypeNullability
Whether we saw any type nullability annotations in the given file.
Definition: Sema.h:235
bool isPrototypeContext() const
Definition: DeclSpec.h:1876
static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, Declarator &D, unsigned FunctionChunkIndex)
Definition: SemaType.cpp:2640
A parameter attribute which changes the argument-passing ABI rule for the parameter.
Definition: Attr.h:165
Wrapper for source info for arrays.
Definition: TypeLoc.h:1484
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
CanQualType OverloadTy
Definition: ASTContext.h:979
There is no lifetime qualification on this type.
Definition: Type.h:135
Information about a FileID, basically just the logical file that it represents and include stack info...
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:222
void setAttrOperandParensRange(SourceRange range)
Definition: TypeLoc.h:904
is AltiVec 'vector Pixel'
Definition: Type.h:2802
The "struct" keyword.
Definition: Type.h:4490
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:146
Kind
TypeLoc getValueLoc() const
Definition: TypeLoc.h:2134
not a target-specific vector type
Definition: Type.h:2800
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:145
The attribute is in the decl-specifier-seq.
Definition: SemaType.cpp:287
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
void setKNRPromoted(bool promoted)
Definition: Decl.h:1511
static bool distributeFunctionTypeAttrToInnermost(TypeProcessingState &state, AttributeList &attr, AttributeList *&attrList, QualType &declSpecType)
Try to distribute a function type attribute to the innermost function chunk or type.
Definition: SemaType.cpp:550
static bool isPermittedNeonBaseType(QualType &Ty, VectorType::VectorKind VecKind, Sema &S)
Definition: SemaType.cpp:6666
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3255
Encodes a location in the source.
Sugar for parentheses used when specifying types.
Definition: Type.h:2193
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static const TST TST_auto_type
Definition: DeclSpec.h:300
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1014
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3810
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5489
bool CheckDistantExceptionSpec(QualType T)
CheckDistantExceptionSpec - Check if the given type is a pointer or pointer to member to a function w...
ReferenceTypeInfo Ref
Definition: DeclSpec.h:1501
PointerDeclaratorKind
Describes the kind of a pointer a declarator describes.
Definition: SemaType.cpp:3249
CanQualType Int128Ty
Definition: ASTContext.h:971
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:3458
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5165
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:910
Expr * getRepAsExpr() const
Definition: DeclSpec.h:496
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1868
A deduction-guide name (a template-name)
Definition: DeclSpec.h:926
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition: Type.h:5766
bool isValid() const
Return true if this is a valid SourceLocation object.
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2816
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex)
Definition: SemaType.cpp:4849
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
Definition: Type.cpp:1920
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:346
FunctionTypeInfo Fun
Definition: DeclSpec.h:1503
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ASTContext & getASTContext() const
Definition: Sema.h:1173
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
static const TST TST_union
Definition: DeclSpec.h:289
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, unsigned TypeQuals, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation ConstQualifierLoc, SourceLocation VolatileQualifierLoc, SourceLocation RestrictQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult())
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition: DeclSpec.cpp:152
ParsedType getRepAsType() const
Definition: DeclSpec.h:488
static void moveAttrFromListToList(AttributeList &attr, AttributeList *&fromList, AttributeList *&toList)
Definition: SemaType.cpp:277
TSC getTypeSpecComplex() const
Definition: DeclSpec.h:478
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
static const TSS TSS_signed
Definition: DeclSpec.h:267
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
Definition: Sema.h:644
RecordDecl * CFError
The struct behind the CFErrorRef pointer.
Definition: Sema.h:10398
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
Definition: SemaType.cpp:7143
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:537
No ref-qualifier was provided.
Definition: Type.h:1260
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T)
Retrieve a version of the type 'T' that is elaborated by Keyword and qualified by the nested-name-spe...
Definition: SemaType.cpp:7515
CanQualType FloatTy
Definition: ASTContext.h:974
SourceRange getExceptionSpecRange() const
Definition: DeclSpec.h:1402
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
Definition: DeclCXX.h:901
QualType getIncompleteArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type...
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3658
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2235
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
Definition: Type.cpp:190
MemberPointerTypeInfo Mem
Definition: DeclSpec.h:1505
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
static QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type, ArrayRef< TypeSourceInfo * > typeArgs, SourceRange typeArgsRange, bool failOnError=false)
Apply Objective-C type arguments to the given type.
Definition: SemaType.cpp:796
SimplePointerKind
A simple notion of pointer kinds, which matches up with the various pointer declarators.
Definition: SemaType.cpp:3197
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
CanQualType VoidTy
Definition: ASTContext.h:963
const DeclaratorChunk * getInnermostNonParenChunk() const
Return the innermost (closest to the declarator) chunk of this declarator that is not a parens chunk...
Definition: DeclSpec.h:2182
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
Definition: SemaType.cpp:1658
static bool isBlockPointer(Expr *Arg)
const FileInfo & getFile() const
is AltiVec 'vector bool ...'
Definition: Type.h:2803
QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError=false)
Build an Objective-C type parameter type.
Definition: SemaType.cpp:1003
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:547
bool isRValue() const
Definition: Expr.h:249
static const TST TST_typeofType
Definition: DeclSpec.h:294
is AltiVec vector
Definition: Type.h:2801
SourceLocation getBegin() const
void setAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1330
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6105
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:166
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
bool isArgExpr(unsigned Arg) const
void setLBracketLoc(SourceLocation Loc)
Definition: TypeLoc.h:1492
AttributeList *& getAttrListRef()
Definition: DeclSpec.h:1528
IdentifierInfo * getScopeName() const
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:145
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent) const
C++11 deduced auto type.
PtrTy get() const
Definition: Ownership.h:74
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
Definition: SemaType.cpp:1912
bool HasRestrict
The type qualifier: restrict. [GNU] C++ extension.
Definition: DeclSpec.h:1178
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
Definition: DeclSpec.h:1476
static bool isVectorSizeTooLarge(unsigned NumElements)
Definition: Type.h:2823
IdentifierLoc * getArgAsIdent(unsigned Arg) const
bool isStaticMember()
Returns true if this declares a static member.
Definition: DeclSpec.cpp:388
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1264
Assigning into this object requires a lifetime extension.
Definition: Type.h:152
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:732
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Definition: Expr.h:434
SourceLocation getExceptionSpecLocBeg() const
Definition: DeclSpec.h:1394
CUDAFunctionTarget CurrentCUDATarget()
Gets the CUDA target for the current context.
Definition: Sema.h:9894
static void recordNullabilitySeen(Sema &S, SourceLocation loc)
Marks that a nullability feature has been used in the file containing loc.
Definition: SemaType.cpp:3571
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1627
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Definition: ASTContext.h:1605
bool isFunctionProtoType() const
Definition: Type.h:1684
A constructor named via a template-id.
Definition: DeclSpec.h:918
Represents a pack expansion of types.
Definition: Type.h:4787
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1392
void setTypeArgsLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:974
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1884
CanQualType UnsignedShortTy
Definition: ASTContext.h:972
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Definition: Type.cpp:111
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
TypeLoc findExplicitQualifierLoc() const
Find a type with the location of an explicit type qualifier.
Definition: TypeLoc.cpp:369
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2682
attr::Kind getKind() const
Definition: Attr.h:84
QualType getType() const
Definition: Expr.h:127
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
CanQualType CharTy
Definition: ASTContext.h:965
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
static const TST TST_decltype_auto
Definition: DeclSpec.h:297
void setClassTInfo(TypeSourceInfo *TI)
Definition: TypeLoc.h:1282
TagTypeKind
The kind of a tag type.
Definition: Type.h:4488
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:982
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration...
unsigned TypeQuals
The type qualifiers for the array: const/volatile/restrict/__unaligned/_Atomic.
Definition: DeclSpec.h:1188
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
Definition: Sema.h:337
static const TSS TSS_unspecified
Definition: DeclSpec.h:266
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1215
void setAmpAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1343
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
Definition: SemaType.cpp:2273
StringRef Name
Definition: USRFinder.cpp:123
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation(), SourceLocation UnalignedQualLoc=SourceLocation())
Definition: SemaType.cpp:2589
static const TST TST_decltype
Definition: DeclSpec.h:296
static const TST TST_auto
Definition: DeclSpec.h:299
bool isFriendSpecified() const
Definition: DeclSpec.h:702
static const TST TST_void
Definition: DeclSpec.h:273
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1437
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:2126
SourceLocation getLocStart() const LLVM_READONLY
Definition: TypeLoc.h:137
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)', this is true.
Definition: DeclSpec.h:1245
SourceLocation getTypeSpecTypeNameLoc() const
Definition: DeclSpec.h:514
static const TST TST_int128
Definition: DeclSpec.h:279
bool isInvalidDecl() const
Definition: DeclBase.h:532
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
Definition: Type.h:929
bool getProducesResult() const
Definition: Type.h:2994
QualType getEquivalentType() const
Definition: Type.h:3911
bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:203
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:973
bool hasTagDefinition() const
Definition: DeclSpec.cpp:401
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:116
QualType BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a pointer type.
Definition: SemaType.cpp:1872
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
std::pair< SourceLocation, SourceLocation > getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:617
Expr * getArgAsExpr(unsigned Arg) const
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
Definition: DeclCXX.h:1257
DeclarationName - The name of a declaration.
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:537
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
CallingConv getCC() const
Definition: Type.h:3003
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:505
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:792
QualType BuildReadPipeType(QualType T, SourceLocation Loc)
Build a Read-only Pipe type.
Definition: SemaType.cpp:1969
EnumDecl - Represents an enum.
Definition: Decl.h:3102
#define FUNCTION_TYPE_ATTRS_CASELIST
Definition: SemaType.cpp:122
static bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal)
Check whether the specified array size makes the array type a VLA.
Definition: SemaType.cpp:1987
detail::InMemoryDirectory::const_iterator E
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7328
The maximum supported address space number.
Definition: Type.h:158
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2442
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
bool isHalfType() const
Definition: Type.h:5912
bool isSamplerT() const
Definition: Type.h:5833
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:358
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2087
A type that was preceded by the 'template' keyword, stored as a Type*.
static const TST TST_unspecified
Definition: DeclSpec.h:272
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
Definition: SemaDecl.cpp:1155
bool isFirstDeclarator() const
Definition: DeclSpec.h:2388
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1953
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
Represents a pointer to an Objective C object.
Definition: Type.h:5220
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:134
Pointer to a block type.
Definition: Type.h:2327
IdentifierInfo * getNSErrorIdent()
Retrieve the identifier "NSError".
Definition: SemaType.cpp:3226
TypeResult actOnObjCProtocolQualifierType(SourceLocation lAngleLoc, ArrayRef< Decl * > protocols, ArrayRef< SourceLocation > protocolLocs, SourceLocation rAngleLoc)
Build a an Objective-C protocol-qualified 'id' type where no base type was specified.
Definition: SemaType.cpp:1062
Syntax
The style used to specify an attribute.
Definition: AttributeList.h:98
bool isObjCObjectType() const
Definition: Type.h:5787
void setAttrEnumOperandLoc(SourceLocation loc)
Definition: TypeLoc.h:891
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3784
TypeSpecifierSign getWrittenSignSpec() const
Definition: TypeLoc.h:576
unsigned getNumExceptions() const
Get the number of dynamic exception specifications.
Definition: DeclSpec.h:1445
IdentifierInfo * getName() const
static const TST TST_decimal128
Definition: DeclSpec.h:287
SourceManager & getSourceManager() const
Definition: Sema.h:1171
CanQualType UnknownAnyTy
Definition: ASTContext.h:979
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:6042
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
unsigned getTypeQuals() const
Definition: Type.h:3454
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Definition: DeclObjC.cpp:285
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
Definition: DeclSpec.h:1240
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:152
#define OBJC_POINTER_TYPE_ATTRS_CASELIST
Definition: SemaType.cpp:100
CanQualType UnsignedLongTy
Definition: ASTContext.h:972
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
bool isInvalid() const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1281
CanQualType DependentTy
Definition: ASTContext.h:979
void setNext(AttributeList *N)
UnqualTypeLoc getUnqualifiedLoc() const
Definition: TypeLoc.h:260
CanQualType WCharTy
Definition: ASTContext.h:966
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
Definition: Decl.h:3226
bool isFunctionType() const
Definition: Type.h:5709
static const TST TST_typename
Definition: DeclSpec.h:293
QualType BuildDecltypeType(Expr *E, SourceLocation Loc, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
Definition: SemaType.cpp:7615
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2360
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1548
llvm::StringRef getParameterABISpelling(ParameterABI kind)
void copy(TemplateSpecializationTypeLoc Loc)
Copy the location information from the given info.
Definition: TypeLoc.h:1621
Wraps an ObjCPointerType with source location information.
Definition: TypeLoc.h:1300
unsigned AtomicQualLoc
The location of the _Atomic-qualifier, if any.
Definition: DeclSpec.h:1167
SourceLocation getLoc() const
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:90
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
The "class" keyword.
Definition: Type.h:4496
A template-id, e.g., f<int>.
Definition: DeclSpec.h:922
CXXScopeSpec & getTypeSpecScope()
Definition: DeclSpec.h:500
BlockPointerTypeInfo Cls
Definition: DeclSpec.h:1504
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2468
bool isTypeAttr() const
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
QualType getPointeeType() const
Definition: Type.h:2381
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:479
static void warnAboutAmbiguousFunction(Sema &S, Declarator &D, DeclaratorChunk &DeclType, QualType RT)
Produce an appropriate diagnostic for an ambiguity between a function declarator and a C++ direct-ini...
Definition: SemaType.cpp:3013
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2114
static bool hasNullabilityAttr(const AttributeList *attrs)
Check whether there is a nullability attribute of any kind in the given attribute list...
Definition: SemaType.cpp:3235
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
Definition: SemaExpr.cpp:2019
Describes whether we've seen any nullability information for the given file.
Definition: Sema.h:226
bool CheckRegparmAttr(const AttributeList &attr, unsigned &value)
Checks a regparm attribute, returning true if it is ill-formed and otherwise setting numParams to the...
static LLVM_READONLY bool isIdentifierBody(unsigned char c, bool AllowDollar=false)
Returns true if this is a body character of a C identifier, which is [a-zA-Z0-9_].
Definition: CharInfo.h:59
bool isCXX11Attribute() const
const Type * getClass() const
Definition: Type.h:2475
PointerWrappingDeclaratorKind
Describes a declarator chunk wrapping a pointer that marks inference as unexpected.
Definition: SemaType.cpp:3267
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2380
Reading or writing from this object requires a barrier call.
Definition: Type.h:149
bool isContextSensitiveKeywordAttribute() const
unsigned AutoTemplateParameterDepth
If this is a generic lambda, use this as the depth of each 'auto' parameter, during initial AST const...
Definition: ScopeInfo.h:771
QualType getTypeOfExprType(Expr *e) const
GCC extension.
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:3838
unsigned getFullDataSize() const
Returns the size of the type source info data block.
Definition: TypeLoc.h:146
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:2145
unsigned TypeQuals
For now, sema will catch these as invalid.
Definition: DeclSpec.h:1468
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
Definition: Type.cpp:3674
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2378
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type...
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
bool isAggregate() const
Determine whether this class is an aggregate (C++ [dcl.init.aggr]), which is a class with no user-dec...
Definition: DeclCXX.h:1182
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2120
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5569
Represents a C++ struct/union/class.
Definition: DeclCXX.h:267
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:861
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:914
bool isObjCObjectPointerType() const
Definition: Type.h:5784
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
Definition: DeclSpec.h:1199
bool checkNullabilityTypeSpecifier(QualType &type, NullabilityKind nullability, SourceLocation nullabilityLoc, bool isContextSensitive, bool allowArrayTypes)
Check whether a nullability type specifier can be added to the given type.
Definition: SemaType.cpp:6056
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1432
CallingConv getDefaultCallingConvention(bool isVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:595
CanQualType Char16Ty
Definition: ASTContext.h:969
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
Definition: Sema.h:331
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
static const TST TST_float128
Definition: DeclSpec.h:283
bool isPipeType() const
Definition: Type.h:5860
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1133
static const TST TST_bool
Definition: DeclSpec.h:284
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:317
The "enum" keyword.
Definition: Type.h:4498
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:615
static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD)
Locks in the inheritance model for the given class and all of its bases.
Definition: SemaType.cpp:7203
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:44
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:127
This class is used for builtin types like 'int'.
Definition: Type.h:2084
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the keyword associated.
Definition: SemaType.cpp:3205
SourceLocation getRParenLoc() const
Definition: DeclSpec.h:1390
static void HandleAddressSpaceTypeAttribute(QualType &Type, const AttributeList &Attr, Sema &S)
HandleAddressSpaceTypeAttribute - Process an address_space attribute on the specified type...
Definition: SemaType.cpp:5498
bool isTypeSpecOwned() const
Definition: DeclSpec.h:484
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:245
bool isArrayType() const
Definition: Type.h:5751
Defines the clang::TargetInfo interface.
SourceLocation getTypeSpecWidthLoc() const
Definition: DeclSpec.h:507
A SourceLocation and its associated SourceManager.
QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement)
Completely replace the auto in TypeWithAuto by Replacement.
static Qualifiers fromCVRMask(unsigned CVR)
Definition: Type.h:213
static const TSW TSW_longlong
Definition: DeclSpec.h:256
TagDecl * getDecl() const
Definition: Type.cpp:2986
bool isIncompleteArrayType() const
Definition: Type.h:5757
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:897
CanQualType IntTy
Definition: ASTContext.h:971
bool isRecord() const
Definition: DeclBase.h:1368
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl * > protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
static OpaquePtr make(QualTypeP)
Definition: Ownership.h:54
bool isTypeAltiVecVector() const
Definition: DeclSpec.h:481
bool hasEllipsis() const
Definition: DeclSpec.h:2392
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:953
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:402
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
Definition: TargetInfo.h:911
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
bool hasRestrict() const
Definition: Type.h:251
void copy(TypeLoc other)
Copies the other type loc into this one.
Definition: TypeLoc.cpp:145
static const TST TST_atomic
Definition: DeclSpec.h:302
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5564
SourceManager & SourceMgr
Definition: Sema.h:308
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Definition: DeclSpec.h:1433
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
Definition: DeclSpec.h:1407
static const TST TST_struct
Definition: DeclSpec.h:290
SplitQualType getSingleStepDesugaredType() const
Definition: Type.h:5482
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:64
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
Definition: TypeLoc.h:180
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2156
AttributeList * getNext() const
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2634
Wrapper for source info for builtin types.
Definition: TypeLoc.h:526
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:110
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1136
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:407
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:752
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
Definition: TypeLoc.h:304
ASTContext & Context
Definition: Sema.h:305
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
bool isInvalidType() const
Definition: DeclSpec.h:2381
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
void copy(DependentNameTypeLoc Loc)
Definition: TypeLoc.h:1964
QualifiedFunctionKind
Kinds of declarator that cannot contain a qualified function type.
Definition: SemaType.cpp:1841
bool hasExplicitCallingConv(QualType &T)
Definition: SemaType.cpp:6515
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
CanQualType BoolTy
Definition: ASTContext.h:964
No keyword precedes the qualified type name.
Definition: Type.h:4518
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1299
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5548
TypeAttrLocation
The location of a type attribute.
Definition: SemaType.cpp:285
static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, AttributeList &attr, QualType &declSpecType)
A function type attribute was written on the declarator.
Definition: SemaType.cpp:599
CanQualType DoubleTy
Definition: ASTContext.h:974
const Type * getClass() const
Definition: TypeLoc.h:1276
static void spliceAttrIntoList(AttributeList &attr, AttributeList *&head)
Definition: SemaType.cpp:255
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:683
static TypeSourceInfo * GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo)
Definition: SemaType.cpp:3623
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
Definition: DeclSpec.h:2409
llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)
Retrieve the spelling of the given nullability kind.
The global specifier '::'. There is no stored value.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:257
void setType(QualType newType)
Definition: Decl.h:590
Wrapper for source info for pointers.
Definition: TypeLoc.h:1236
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3526
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1249
bool isTypeAltiVecPixel() const
Definition: DeclSpec.h:482
base_class_range vbases()
Definition: DeclCXX.h:754
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2553
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3254
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
static AttributeList::Kind getAttrListKind(AttributedType::Kind kind)
Map an AttributedType::Kind to an AttributeList::Kind.
Definition: SemaType.cpp:4956
CUDADiagBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a CUDADiagBuilder that emits the diagnostic if the current context is "used as device code"...
Definition: SemaCUDA.cpp:641
A class which abstracts out some details necessary for making a call.
Definition: Type.h:2948
AttributeList *& getListRef()
Returns a reference to the attribute list.
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1319
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1876
const NamedDecl * Result
Definition: USRFinder.cpp:70
Attr - This represents one attribute.
Definition: Attr.h:43
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:751
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
Definition: SemaType.cpp:4823
static void distributeObjCPointerTypeAttr(TypeProcessingState &state, AttributeList &attr, QualType type)
Given that an objc_gc attribute was written somewhere on a declaration other than on the declarator i...
Definition: SemaType.cpp:397
This parameter (which must have pointer type) is a Swift indirect result parameter.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5928
QualType BuildTypeofExprType(Expr *E, SourceLocation Loc)
Definition: SemaType.cpp:7530
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2368
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1849
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:95
CanQualType UnsignedIntTy
Definition: ASTContext.h:972
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5516
static void fillAttributedTypeLoc(AttributedTypeLoc TL, const AttributeList *attrs, const AttributeList *DeclAttrs=nullptr)
Definition: SemaType.cpp:5026
bool isPointerType() const
Definition: Type.h:5712
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:2393
const AttributeList * getAttributes() const
Definition: DeclSpec.h:2343
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1605
unsigned isAmbiguous
Can this declaration be a constructor-style initializer?
Definition: DeclSpec.h:1248