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