clang  6.0.0svn
SemaType.cpp
Go to the documentation of this file.
1 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements type-related semantic analysis.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "TypeLocBuilder.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/TypeLoc.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/Preprocessor.h"
28 #include "clang/Sema/DeclSpec.h"
30 #include "clang/Sema/Lookup.h"
31 #include "clang/Sema/ScopeInfo.h"
33 #include "clang/Sema/Template.h"
34 #include "llvm/ADT/SmallPtrSet.h"
35 #include "llvm/ADT/SmallString.h"
36 #include "llvm/ADT/StringSwitch.h"
37 #include "llvm/Support/ErrorHandling.h"
38 
39 using namespace clang;
40 
45 };
46 
47 /// isOmittedBlockReturnType - Return true if this declarator is missing a
48 /// return type because this is a omitted return type on a block literal.
49 static bool isOmittedBlockReturnType(const Declarator &D) {
52  return false;
53 
54  if (D.getNumTypeObjects() == 0)
55  return true; // ^{ ... }
56 
57  if (D.getNumTypeObjects() == 1 &&
59  return true; // ^(int X, float Y) { ... }
60 
61  return false;
62 }
63 
64 /// diagnoseBadTypeAttribute - Diagnoses a type attribute which
65 /// doesn't apply to the given type.
66 static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr,
67  QualType type) {
68  TypeDiagSelector WhichType;
69  bool useExpansionLoc = true;
70  switch (attr.getKind()) {
71  case AttributeList::AT_ObjCGC: WhichType = TDS_Pointer; break;
72  case AttributeList::AT_ObjCOwnership: WhichType = TDS_ObjCObjOrBlock; break;
73  default:
74  // Assume everything else was a function attribute.
75  WhichType = TDS_Function;
76  useExpansionLoc = false;
77  break;
78  }
79 
80  SourceLocation loc = attr.getLoc();
81  StringRef name = attr.getName()->getName();
82 
83  // The GC attributes are usually written with macros; special-case them.
84  IdentifierInfo *II = attr.isArgIdent(0) ? attr.getArgAsIdent(0)->Ident
85  : nullptr;
86  if (useExpansionLoc && loc.isMacroID() && II) {
87  if (II->isStr("strong")) {
88  if (S.findMacroSpelling(loc, "__strong")) name = "__strong";
89  } else if (II->isStr("weak")) {
90  if (S.findMacroSpelling(loc, "__weak")) name = "__weak";
91  }
92  }
93 
94  S.Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType
95  << type;
96 }
97 
98 // objc_gc applies to Objective-C pointers or, otherwise, to the
99 // smallest available pointer type (i.e. 'void*' in 'void**').
100 #define OBJC_POINTER_TYPE_ATTRS_CASELIST \
101  case AttributeList::AT_ObjCGC: \
102  case AttributeList::AT_ObjCOwnership
103 
104 // Calling convention attributes.
105 #define CALLING_CONV_ATTRS_CASELIST \
106  case AttributeList::AT_CDecl: \
107  case AttributeList::AT_FastCall: \
108  case AttributeList::AT_StdCall: \
109  case AttributeList::AT_ThisCall: \
110  case AttributeList::AT_RegCall: \
111  case AttributeList::AT_Pascal: \
112  case AttributeList::AT_SwiftCall: \
113  case AttributeList::AT_VectorCall: \
114  case AttributeList::AT_MSABI: \
115  case AttributeList::AT_SysVABI: \
116  case AttributeList::AT_Pcs: \
117  case AttributeList::AT_IntelOclBicc: \
118  case AttributeList::AT_PreserveMost: \
119  case AttributeList::AT_PreserveAll
120 
121 // Function type attributes.
122 #define FUNCTION_TYPE_ATTRS_CASELIST \
123  case AttributeList::AT_NSReturnsRetained: \
124  case AttributeList::AT_NoReturn: \
125  case AttributeList::AT_Regparm: \
126  case AttributeList::AT_AnyX86NoCallerSavedRegisters: \
127  CALLING_CONV_ATTRS_CASELIST
128 
129 // Microsoft-specific type qualifiers.
130 #define MS_TYPE_ATTRS_CASELIST \
131  case AttributeList::AT_Ptr32: \
132  case AttributeList::AT_Ptr64: \
133  case AttributeList::AT_SPtr: \
134  case AttributeList::AT_UPtr
135 
136 // Nullability qualifiers.
137 #define NULLABILITY_TYPE_ATTRS_CASELIST \
138  case AttributeList::AT_TypeNonNull: \
139  case AttributeList::AT_TypeNullable: \
140  case AttributeList::AT_TypeNullUnspecified
141 
142 namespace {
143  /// An object which stores processing state for the entire
144  /// GetTypeForDeclarator process.
145  class TypeProcessingState {
146  Sema &sema;
147 
148  /// The declarator being processed.
149  Declarator &declarator;
150 
151  /// The index of the declarator chunk we're currently processing.
152  /// May be the total number of valid chunks, indicating the
153  /// DeclSpec.
154  unsigned chunkIndex;
155 
156  /// Whether there are non-trivial modifications to the decl spec.
157  bool trivial;
158 
159  /// Whether we saved the attributes in the decl spec.
160  bool hasSavedAttrs;
161 
162  /// The original set of attributes on the DeclSpec.
164 
165  /// A list of attributes to diagnose the uselessness of when the
166  /// processing is complete.
167  SmallVector<AttributeList*, 2> ignoredTypeAttrs;
168 
169  public:
170  TypeProcessingState(Sema &sema, Declarator &declarator)
171  : sema(sema), declarator(declarator),
172  chunkIndex(declarator.getNumTypeObjects()),
173  trivial(true), hasSavedAttrs(false) {}
174 
175  Sema &getSema() const {
176  return sema;
177  }
178 
179  Declarator &getDeclarator() const {
180  return declarator;
181  }
182 
183  bool isProcessingDeclSpec() const {
184  return chunkIndex == declarator.getNumTypeObjects();
185  }
186 
187  unsigned getCurrentChunkIndex() const {
188  return chunkIndex;
189  }
190 
191  void setCurrentChunkIndex(unsigned idx) {
192  assert(idx <= declarator.getNumTypeObjects());
193  chunkIndex = idx;
194  }
195 
196  AttributeList *&getCurrentAttrListRef() const {
197  if (isProcessingDeclSpec())
198  return getMutableDeclSpec().getAttributes().getListRef();
199  return declarator.getTypeObject(chunkIndex).getAttrListRef();
200  }
201 
202  /// Save the current set of attributes on the DeclSpec.
203  void saveDeclSpecAttrs() {
204  // Don't try to save them multiple times.
205  if (hasSavedAttrs) return;
206 
207  DeclSpec &spec = getMutableDeclSpec();
208  for (AttributeList *attr = spec.getAttributes().getList(); attr;
209  attr = attr->getNext())
210  savedAttrs.push_back(attr);
211  trivial &= savedAttrs.empty();
212  hasSavedAttrs = true;
213  }
214 
215  /// Record that we had nowhere to put the given type attribute.
216  /// We will diagnose such attributes later.
217  void addIgnoredTypeAttr(AttributeList &attr) {
218  ignoredTypeAttrs.push_back(&attr);
219  }
220 
221  /// Diagnose all the ignored type attributes, given that the
222  /// declarator worked out to the given type.
223  void diagnoseIgnoredTypeAttrs(QualType type) const {
224  for (auto *Attr : ignoredTypeAttrs)
225  diagnoseBadTypeAttribute(getSema(), *Attr, type);
226  }
227 
228  ~TypeProcessingState() {
229  if (trivial) return;
230 
231  restoreDeclSpecAttrs();
232  }
233 
234  private:
235  DeclSpec &getMutableDeclSpec() const {
236  return const_cast<DeclSpec&>(declarator.getDeclSpec());
237  }
238 
239  void restoreDeclSpecAttrs() {
240  assert(hasSavedAttrs);
241 
242  if (savedAttrs.empty()) {
243  getMutableDeclSpec().getAttributes().set(nullptr);
244  return;
245  }
246 
247  getMutableDeclSpec().getAttributes().set(savedAttrs[0]);
248  for (unsigned i = 0, e = savedAttrs.size() - 1; i != e; ++i)
249  savedAttrs[i]->setNext(savedAttrs[i+1]);
250  savedAttrs.back()->setNext(nullptr);
251  }
252  };
253 } // end anonymous namespace
254 
255 static void spliceAttrIntoList(AttributeList &attr, AttributeList *&head) {
256  attr.setNext(head);
257  head = &attr;
258 }
259 
260 static void spliceAttrOutOfList(AttributeList &attr, AttributeList *&head) {
261  if (head == &attr) {
262  head = attr.getNext();
263  return;
264  }
265 
266  AttributeList *cur = head;
267  while (true) {
268  assert(cur && cur->getNext() && "ran out of attrs?");
269  if (cur->getNext() == &attr) {
270  cur->setNext(attr.getNext());
271  return;
272  }
273  cur = cur->getNext();
274  }
275 }
276 
278  AttributeList *&fromList,
279  AttributeList *&toList) {
280  spliceAttrOutOfList(attr, fromList);
281  spliceAttrIntoList(attr, toList);
282 }
283 
284 /// The location of a type attribute.
286  /// The attribute is in the decl-specifier-seq.
288  /// The attribute is part of a DeclaratorChunk.
290  /// The attribute is immediately after the declaration's name.
292 };
293 
294 static void processTypeAttrs(TypeProcessingState &state,
296  AttributeList *attrs);
297 
298 static bool handleFunctionTypeAttr(TypeProcessingState &state,
299  AttributeList &attr,
300  QualType &type);
301 
302 static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state,
303  AttributeList &attr,
304  QualType &type);
305 
306 static bool handleObjCGCTypeAttr(TypeProcessingState &state,
307  AttributeList &attr, QualType &type);
308 
309 static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state,
310  AttributeList &attr, QualType &type);
311 
312 static bool handleObjCPointerTypeAttr(TypeProcessingState &state,
313  AttributeList &attr, QualType &type) {
314  if (attr.getKind() == AttributeList::AT_ObjCGC)
315  return handleObjCGCTypeAttr(state, attr, type);
316  assert(attr.getKind() == AttributeList::AT_ObjCOwnership);
317  return handleObjCOwnershipTypeAttr(state, attr, type);
318 }
319 
320 /// Given the index of a declarator chunk, check whether that chunk
321 /// directly specifies the return type of a function and, if so, find
322 /// an appropriate place for it.
323 ///
324 /// \param i - a notional index which the search will start
325 /// immediately inside
326 ///
327 /// \param onlyBlockPointers Whether we should only look into block
328 /// pointer types (vs. all pointer types).
330  unsigned i,
331  bool onlyBlockPointers) {
332  assert(i <= declarator.getNumTypeObjects());
333 
334  DeclaratorChunk *result = nullptr;
335 
336  // First, look inwards past parens for a function declarator.
337  for (; i != 0; --i) {
338  DeclaratorChunk &fnChunk = declarator.getTypeObject(i-1);
339  switch (fnChunk.Kind) {
341  continue;
342 
343  // If we find anything except a function, bail out.
350  return result;
351 
352  // If we do find a function declarator, scan inwards from that,
353  // looking for a (block-)pointer declarator.
355  for (--i; i != 0; --i) {
356  DeclaratorChunk &ptrChunk = declarator.getTypeObject(i-1);
357  switch (ptrChunk.Kind) {
363  continue;
364 
367  if (onlyBlockPointers)
368  continue;
369 
370  // fallthrough
371 
373  result = &ptrChunk;
374  goto continue_outer;
375  }
376  llvm_unreachable("bad declarator chunk kind");
377  }
378 
379  // If we run out of declarators doing that, we're done.
380  return result;
381  }
382  llvm_unreachable("bad declarator chunk kind");
383 
384  // Okay, reconsider from our new point.
385  continue_outer: ;
386  }
387 
388  // Ran out of chunks, bail out.
389  return result;
390 }
391 
392 /// Given that an objc_gc attribute was written somewhere on a
393 /// declaration *other* than on the declarator itself (for which, use
394 /// distributeObjCPointerTypeAttrFromDeclarator), and given that it
395 /// didn't apply in whatever position it was written in, try to move
396 /// it to a more appropriate position.
397 static void distributeObjCPointerTypeAttr(TypeProcessingState &state,
398  AttributeList &attr,
399  QualType type) {
400  Declarator &declarator = state.getDeclarator();
401 
402  // Move it to the outermost normal or block pointer declarator.
403  for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
404  DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
405  switch (chunk.Kind) {
408  // But don't move an ARC ownership attribute to the return type
409  // of a block.
410  DeclaratorChunk *destChunk = nullptr;
411  if (state.isProcessingDeclSpec() &&
412  attr.getKind() == AttributeList::AT_ObjCOwnership)
413  destChunk = maybeMovePastReturnType(declarator, i - 1,
414  /*onlyBlockPointers=*/true);
415  if (!destChunk) destChunk = &chunk;
416 
417  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
418  destChunk->getAttrListRef());
419  return;
420  }
421 
424  continue;
425 
426  // We may be starting at the return type of a block.
428  if (state.isProcessingDeclSpec() &&
429  attr.getKind() == AttributeList::AT_ObjCOwnership) {
431  declarator, i,
432  /*onlyBlockPointers=*/true)) {
433  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
434  dest->getAttrListRef());
435  return;
436  }
437  }
438  goto error;
439 
440  // Don't walk through these.
444  goto error;
445  }
446  }
447  error:
448 
449  diagnoseBadTypeAttribute(state.getSema(), attr, type);
450 }
451 
452 /// Distribute an objc_gc type attribute that was written on the
453 /// declarator.
454 static void
456  AttributeList &attr,
457  QualType &declSpecType) {
458  Declarator &declarator = state.getDeclarator();
459 
460  // objc_gc goes on the innermost pointer to something that's not a
461  // pointer.
462  unsigned innermost = -1U;
463  bool considerDeclSpec = true;
464  for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
465  DeclaratorChunk &chunk = declarator.getTypeObject(i);
466  switch (chunk.Kind) {
469  innermost = i;
470  continue;
471 
477  continue;
478 
480  considerDeclSpec = false;
481  goto done;
482  }
483  }
484  done:
485 
486  // That might actually be the decl spec if we weren't blocked by
487  // anything in the declarator.
488  if (considerDeclSpec) {
489  if (handleObjCPointerTypeAttr(state, attr, declSpecType)) {
490  // Splice the attribute into the decl spec. Prevents the
491  // attribute from being applied multiple times and gives
492  // the source-location-filler something to work with.
493  state.saveDeclSpecAttrs();
494  moveAttrFromListToList(attr, declarator.getAttrListRef(),
495  declarator.getMutableDeclSpec().getAttributes().getListRef());
496  return;
497  }
498  }
499 
500  // Otherwise, if we found an appropriate chunk, splice the attribute
501  // into it.
502  if (innermost != -1U) {
503  moveAttrFromListToList(attr, declarator.getAttrListRef(),
504  declarator.getTypeObject(innermost).getAttrListRef());
505  return;
506  }
507 
508  // Otherwise, diagnose when we're done building the type.
509  spliceAttrOutOfList(attr, declarator.getAttrListRef());
510  state.addIgnoredTypeAttr(attr);
511 }
512 
513 /// A function type attribute was written somewhere in a declaration
514 /// *other* than on the declarator itself or in the decl spec. Given
515 /// that it didn't apply in whatever position it was written in, try
516 /// to move it to a more appropriate position.
517 static void distributeFunctionTypeAttr(TypeProcessingState &state,
518  AttributeList &attr,
519  QualType type) {
520  Declarator &declarator = state.getDeclarator();
521 
522  // Try to push the attribute from the return type of a function to
523  // the function itself.
524  for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
525  DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
526  switch (chunk.Kind) {
528  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
529  chunk.getAttrListRef());
530  return;
531 
539  continue;
540  }
541  }
542 
543  diagnoseBadTypeAttribute(state.getSema(), attr, type);
544 }
545 
546 /// Try to distribute a function type attribute to the innermost
547 /// function chunk or type. Returns true if the attribute was
548 /// distributed, false if no location was found.
549 static bool
551  AttributeList &attr,
552  AttributeList *&attrList,
553  QualType &declSpecType) {
554  Declarator &declarator = state.getDeclarator();
555 
556  // Put it on the innermost function chunk, if there is one.
557  for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
558  DeclaratorChunk &chunk = declarator.getTypeObject(i);
559  if (chunk.Kind != DeclaratorChunk::Function) continue;
560 
561  moveAttrFromListToList(attr, attrList, chunk.getAttrListRef());
562  return true;
563  }
564 
565  return handleFunctionTypeAttr(state, attr, declSpecType);
566 }
567 
568 /// A function type attribute was written in the decl spec. Try to
569 /// apply it somewhere.
570 static void
572  AttributeList &attr,
573  QualType &declSpecType) {
574  state.saveDeclSpecAttrs();
575 
576  // C++11 attributes before the decl specifiers actually appertain to
577  // the declarators. Move them straight there. We don't support the
578  // 'put them wherever you like' semantics we allow for GNU attributes.
579  if (attr.isCXX11Attribute()) {
580  moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
581  state.getDeclarator().getAttrListRef());
582  return;
583  }
584 
585  // Try to distribute to the innermost.
587  state.getCurrentAttrListRef(),
588  declSpecType))
589  return;
590 
591  // If that failed, diagnose the bad attribute when the declarator is
592  // fully built.
593  state.addIgnoredTypeAttr(attr);
594 }
595 
596 /// A function type attribute was written on the declarator. Try to
597 /// apply it somewhere.
598 static void
600  AttributeList &attr,
601  QualType &declSpecType) {
602  Declarator &declarator = state.getDeclarator();
603 
604  // Try to distribute to the innermost.
606  declarator.getAttrListRef(),
607  declSpecType))
608  return;
609 
610  // If that failed, diagnose the bad attribute when the declarator is
611  // fully built.
612  spliceAttrOutOfList(attr, declarator.getAttrListRef());
613  state.addIgnoredTypeAttr(attr);
614 }
615 
616 /// \brief Given that there are attributes written on the declarator
617 /// itself, try to distribute any type attributes to the appropriate
618 /// declarator chunk.
619 ///
620 /// These are attributes like the following:
621 /// int f ATTR;
622 /// int (f ATTR)();
623 /// but not necessarily this:
624 /// int f() ATTR;
625 static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state,
626  QualType &declSpecType) {
627  // Collect all the type attributes from the declarator itself.
628  assert(state.getDeclarator().getAttributes() && "declarator has no attrs!");
629  AttributeList *attr = state.getDeclarator().getAttributes();
630  AttributeList *next;
631  do {
632  next = attr->getNext();
633 
634  // Do not distribute C++11 attributes. They have strict rules for what
635  // they appertain to.
636  if (attr->isCXX11Attribute())
637  continue;
638 
639  switch (attr->getKind()) {
641  distributeObjCPointerTypeAttrFromDeclarator(state, *attr, declSpecType);
642  break;
643 
645  distributeFunctionTypeAttrFromDeclarator(state, *attr, declSpecType);
646  break;
647 
649  // Microsoft type attributes cannot go after the declarator-id.
650  continue;
651 
653  // Nullability specifiers cannot go after the declarator-id.
654 
655  // Objective-C __kindof does not get distributed.
656  case AttributeList::AT_ObjCKindOf:
657  continue;
658 
659  default:
660  break;
661  }
662  } while ((attr = next));
663 }
664 
665 /// Add a synthetic '()' to a block-literal declarator if it is
666 /// required, given the return type.
667 static void maybeSynthesizeBlockSignature(TypeProcessingState &state,
668  QualType declSpecType) {
669  Declarator &declarator = state.getDeclarator();
670 
671  // First, check whether the declarator would produce a function,
672  // i.e. whether the innermost semantic chunk is a function.
673  if (declarator.isFunctionDeclarator()) {
674  // If so, make that declarator a prototyped declarator.
675  declarator.getFunctionTypeInfo().hasPrototype = true;
676  return;
677  }
678 
679  // If there are any type objects, the type as written won't name a
680  // function, regardless of the decl spec type. This is because a
681  // block signature declarator is always an abstract-declarator, and
682  // abstract-declarators can't just be parentheses chunks. Therefore
683  // we need to build a function chunk unless there are no type
684  // objects and the decl spec type is a function.
685  if (!declarator.getNumTypeObjects() && declSpecType->isFunctionType())
686  return;
687 
688  // Note that there *are* cases with invalid declarators where
689  // declarators consist solely of parentheses. In general, these
690  // occur only in failed efforts to make function declarators, so
691  // faking up the function chunk is still the right thing to do.
692 
693  // Otherwise, we need to fake up a function declarator.
694  SourceLocation loc = declarator.getLocStart();
695 
696  // ...and *prepend* it to the declarator.
697  SourceLocation NoLoc;
699  /*HasProto=*/true,
700  /*IsAmbiguous=*/false,
701  /*LParenLoc=*/NoLoc,
702  /*ArgInfo=*/nullptr,
703  /*NumArgs=*/0,
704  /*EllipsisLoc=*/NoLoc,
705  /*RParenLoc=*/NoLoc,
706  /*TypeQuals=*/0,
707  /*RefQualifierIsLvalueRef=*/true,
708  /*RefQualifierLoc=*/NoLoc,
709  /*ConstQualifierLoc=*/NoLoc,
710  /*VolatileQualifierLoc=*/NoLoc,
711  /*RestrictQualifierLoc=*/NoLoc,
712  /*MutableLoc=*/NoLoc, EST_None,
713  /*ESpecRange=*/SourceRange(),
714  /*Exceptions=*/nullptr,
715  /*ExceptionRanges=*/nullptr,
716  /*NumExceptions=*/0,
717  /*NoexceptExpr=*/nullptr,
718  /*ExceptionSpecTokens=*/nullptr,
719  /*DeclsInPrototype=*/None,
720  loc, loc, declarator));
721 
722  // For consistency, make sure the state still has us as processing
723  // the decl spec.
724  assert(state.getCurrentChunkIndex() == declarator.getNumTypeObjects() - 1);
725  state.setCurrentChunkIndex(declarator.getNumTypeObjects());
726 }
727 
729  unsigned &TypeQuals,
730  QualType TypeSoFar,
731  unsigned RemoveTQs,
732  unsigned DiagID) {
733  // If this occurs outside a template instantiation, warn the user about
734  // it; they probably didn't mean to specify a redundant qualifier.
735  typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
736  for (QualLoc Qual : {QualLoc(DeclSpec::TQ_const, DS.getConstSpecLoc()),
739  QualLoc(DeclSpec::TQ_atomic, DS.getAtomicSpecLoc())}) {
740  if (!(RemoveTQs & Qual.first))
741  continue;
742 
743  if (!S.inTemplateInstantiation()) {
744  if (TypeQuals & Qual.first)
745  S.Diag(Qual.second, DiagID)
746  << DeclSpec::getSpecifierName(Qual.first) << TypeSoFar
747  << FixItHint::CreateRemoval(Qual.second);
748  }
749 
750  TypeQuals &= ~Qual.first;
751  }
752 }
753 
754 /// Return true if this is omitted block return type. Also check type
755 /// attributes and type qualifiers when returning true.
756 static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator,
757  QualType Result) {
758  if (!isOmittedBlockReturnType(declarator))
759  return false;
760 
761  // Warn if we see type attributes for omitted return type on a block literal.
762  AttributeList *&attrs =
764  AttributeList *prev = nullptr;
765  for (AttributeList *cur = attrs; cur; cur = cur->getNext()) {
766  AttributeList &attr = *cur;
767  // Skip attributes that were marked to be invalid or non-type
768  // attributes.
769  if (attr.isInvalid() || !attr.isTypeAttr()) {
770  prev = cur;
771  continue;
772  }
773  S.Diag(attr.getLoc(),
774  diag::warn_block_literal_attributes_on_omitted_return_type)
775  << attr.getName();
776  // Remove cur from the list.
777  if (prev) {
778  prev->setNext(cur->getNext());
779  prev = cur;
780  } else {
781  attrs = cur->getNext();
782  }
783  }
784 
785  // Warn if we see type qualifiers for omitted return type on a block literal.
786  const DeclSpec &DS = declarator.getDeclSpec();
787  unsigned TypeQuals = DS.getTypeQualifiers();
788  diagnoseAndRemoveTypeQualifiers(S, DS, TypeQuals, Result, (unsigned)-1,
789  diag::warn_block_literal_qualifiers_on_omitted_return_type);
791 
792  return true;
793 }
794 
795 /// Apply Objective-C type arguments to the given type.
798  SourceRange typeArgsRange,
799  bool failOnError = false) {
800  // We can only apply type arguments to an Objective-C class type.
801  const auto *objcObjectType = type->getAs<ObjCObjectType>();
802  if (!objcObjectType || !objcObjectType->getInterface()) {
803  S.Diag(loc, diag::err_objc_type_args_non_class)
804  << type
805  << typeArgsRange;
806 
807  if (failOnError)
808  return QualType();
809  return type;
810  }
811 
812  // The class type must be parameterized.
813  ObjCInterfaceDecl *objcClass = objcObjectType->getInterface();
814  ObjCTypeParamList *typeParams = objcClass->getTypeParamList();
815  if (!typeParams) {
816  S.Diag(loc, diag::err_objc_type_args_non_parameterized_class)
817  << objcClass->getDeclName()
818  << FixItHint::CreateRemoval(typeArgsRange);
819 
820  if (failOnError)
821  return QualType();
822 
823  return type;
824  }
825 
826  // The type must not already be specialized.
827  if (objcObjectType->isSpecialized()) {
828  S.Diag(loc, diag::err_objc_type_args_specialized_class)
829  << type
830  << FixItHint::CreateRemoval(typeArgsRange);
831 
832  if (failOnError)
833  return QualType();
834 
835  return type;
836  }
837 
838  // Check the type arguments.
839  SmallVector<QualType, 4> finalTypeArgs;
840  unsigned numTypeParams = typeParams->size();
841  bool anyPackExpansions = false;
842  for (unsigned i = 0, n = typeArgs.size(); i != n; ++i) {
843  TypeSourceInfo *typeArgInfo = typeArgs[i];
844  QualType typeArg = typeArgInfo->getType();
845 
846  // Type arguments cannot have explicit qualifiers or nullability.
847  // We ignore indirect sources of these, e.g. behind typedefs or
848  // template arguments.
849  if (TypeLoc qual = typeArgInfo->getTypeLoc().findExplicitQualifierLoc()) {
850  bool diagnosed = false;
851  SourceRange rangeToRemove;
852  if (auto attr = qual.getAs<AttributedTypeLoc>()) {
853  rangeToRemove = attr.getLocalSourceRange();
854  if (attr.getTypePtr()->getImmediateNullability()) {
855  typeArg = attr.getTypePtr()->getModifiedType();
856  S.Diag(attr.getLocStart(),
857  diag::err_objc_type_arg_explicit_nullability)
858  << typeArg << FixItHint::CreateRemoval(rangeToRemove);
859  diagnosed = true;
860  }
861  }
862 
863  if (!diagnosed) {
864  S.Diag(qual.getLocStart(), diag::err_objc_type_arg_qualified)
865  << typeArg << typeArg.getQualifiers().getAsString()
866  << FixItHint::CreateRemoval(rangeToRemove);
867  }
868  }
869 
870  // Remove qualifiers even if they're non-local.
871  typeArg = typeArg.getUnqualifiedType();
872 
873  finalTypeArgs.push_back(typeArg);
874 
875  if (typeArg->getAs<PackExpansionType>())
876  anyPackExpansions = true;
877 
878  // Find the corresponding type parameter, if there is one.
879  ObjCTypeParamDecl *typeParam = nullptr;
880  if (!anyPackExpansions) {
881  if (i < numTypeParams) {
882  typeParam = typeParams->begin()[i];
883  } else {
884  // Too many arguments.
885  S.Diag(loc, diag::err_objc_type_args_wrong_arity)
886  << false
887  << objcClass->getDeclName()
888  << (unsigned)typeArgs.size()
889  << numTypeParams;
890  S.Diag(objcClass->getLocation(), diag::note_previous_decl)
891  << objcClass;
892 
893  if (failOnError)
894  return QualType();
895 
896  return type;
897  }
898  }
899 
900  // Objective-C object pointer types must be substitutable for the bounds.
901  if (const auto *typeArgObjC = typeArg->getAs<ObjCObjectPointerType>()) {
902  // If we don't have a type parameter to match against, assume
903  // everything is fine. There was a prior pack expansion that
904  // means we won't be able to match anything.
905  if (!typeParam) {
906  assert(anyPackExpansions && "Too many arguments?");
907  continue;
908  }
909 
910  // Retrieve the bound.
911  QualType bound = typeParam->getUnderlyingType();
912  const auto *boundObjC = bound->getAs<ObjCObjectPointerType>();
913 
914  // Determine whether the type argument is substitutable for the bound.
915  if (typeArgObjC->isObjCIdType()) {
916  // When the type argument is 'id', the only acceptable type
917  // parameter bound is 'id'.
918  if (boundObjC->isObjCIdType())
919  continue;
920  } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC)) {
921  // Otherwise, we follow the assignability rules.
922  continue;
923  }
924 
925  // Diagnose the mismatch.
926  S.Diag(typeArgInfo->getTypeLoc().getLocStart(),
927  diag::err_objc_type_arg_does_not_match_bound)
928  << typeArg << bound << typeParam->getDeclName();
929  S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here)
930  << typeParam->getDeclName();
931 
932  if (failOnError)
933  return QualType();
934 
935  return type;
936  }
937 
938  // Block pointer types are permitted for unqualified 'id' bounds.
939  if (typeArg->isBlockPointerType()) {
940  // If we don't have a type parameter to match against, assume
941  // everything is fine. There was a prior pack expansion that
942  // means we won't be able to match anything.
943  if (!typeParam) {
944  assert(anyPackExpansions && "Too many arguments?");
945  continue;
946  }
947 
948  // Retrieve the bound.
949  QualType bound = typeParam->getUnderlyingType();
951  continue;
952 
953  // Diagnose the mismatch.
954  S.Diag(typeArgInfo->getTypeLoc().getLocStart(),
955  diag::err_objc_type_arg_does_not_match_bound)
956  << typeArg << bound << typeParam->getDeclName();
957  S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here)
958  << typeParam->getDeclName();
959 
960  if (failOnError)
961  return QualType();
962 
963  return type;
964  }
965 
966  // Dependent types will be checked at instantiation time.
967  if (typeArg->isDependentType()) {
968  continue;
969  }
970 
971  // Diagnose non-id-compatible type arguments.
972  S.Diag(typeArgInfo->getTypeLoc().getLocStart(),
973  diag::err_objc_type_arg_not_id_compatible)
974  << typeArg
975  << typeArgInfo->getTypeLoc().getSourceRange();
976 
977  if (failOnError)
978  return QualType();
979 
980  return type;
981  }
982 
983  // Make sure we didn't have the wrong number of arguments.
984  if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) {
985  S.Diag(loc, diag::err_objc_type_args_wrong_arity)
986  << (typeArgs.size() < typeParams->size())
987  << objcClass->getDeclName()
988  << (unsigned)finalTypeArgs.size()
989  << (unsigned)numTypeParams;
990  S.Diag(objcClass->getLocation(), diag::note_previous_decl)
991  << objcClass;
992 
993  if (failOnError)
994  return QualType();
995 
996  return type;
997  }
998 
999  // Success. Form the specialized type.
1000  return S.Context.getObjCObjectType(type, finalTypeArgs, { }, false);
1001 }
1002 
1004  SourceLocation ProtocolLAngleLoc,
1005  ArrayRef<ObjCProtocolDecl *> Protocols,
1006  ArrayRef<SourceLocation> ProtocolLocs,
1007  SourceLocation ProtocolRAngleLoc,
1008  bool FailOnError) {
1009  QualType Result = QualType(Decl->getTypeForDecl(), 0);
1010  if (!Protocols.empty()) {
1011  bool HasError;
1012  Result = Context.applyObjCProtocolQualifiers(Result, Protocols,
1013  HasError);
1014  if (HasError) {
1015  Diag(SourceLocation(), diag::err_invalid_protocol_qualifiers)
1016  << SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1017  if (FailOnError) Result = QualType();
1018  }
1019  if (FailOnError && Result.isNull())
1020  return QualType();
1021  }
1022 
1023  return Result;
1024 }
1025 
1027  SourceLocation Loc,
1028  SourceLocation TypeArgsLAngleLoc,
1029  ArrayRef<TypeSourceInfo *> TypeArgs,
1030  SourceLocation TypeArgsRAngleLoc,
1031  SourceLocation ProtocolLAngleLoc,
1032  ArrayRef<ObjCProtocolDecl *> Protocols,
1033  ArrayRef<SourceLocation> ProtocolLocs,
1034  SourceLocation ProtocolRAngleLoc,
1035  bool FailOnError) {
1036  QualType Result = BaseType;
1037  if (!TypeArgs.empty()) {
1038  Result = applyObjCTypeArgs(*this, Loc, Result, TypeArgs,
1039  SourceRange(TypeArgsLAngleLoc,
1040  TypeArgsRAngleLoc),
1041  FailOnError);
1042  if (FailOnError && Result.isNull())
1043  return QualType();
1044  }
1045 
1046  if (!Protocols.empty()) {
1047  bool HasError;
1048  Result = Context.applyObjCProtocolQualifiers(Result, Protocols,
1049  HasError);
1050  if (HasError) {
1051  Diag(Loc, diag::err_invalid_protocol_qualifiers)
1052  << SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1053  if (FailOnError) Result = QualType();
1054  }
1055  if (FailOnError && Result.isNull())
1056  return QualType();
1057  }
1058 
1059  return Result;
1060 }
1061 
1063  SourceLocation lAngleLoc,
1064  ArrayRef<Decl *> protocols,
1065  ArrayRef<SourceLocation> protocolLocs,
1066  SourceLocation rAngleLoc) {
1067  // Form id<protocol-list>.
1068  QualType Result = Context.getObjCObjectType(
1069  Context.ObjCBuiltinIdTy, { },
1070  llvm::makeArrayRef(
1071  (ObjCProtocolDecl * const *)protocols.data(),
1072  protocols.size()),
1073  false);
1074  Result = Context.getObjCObjectPointerType(Result);
1075 
1076  TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
1077  TypeLoc ResultTL = ResultTInfo->getTypeLoc();
1078 
1079  auto ObjCObjectPointerTL = ResultTL.castAs<ObjCObjectPointerTypeLoc>();
1080  ObjCObjectPointerTL.setStarLoc(SourceLocation()); // implicit
1081 
1082  auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc()
1083  .castAs<ObjCObjectTypeLoc>();
1084  ObjCObjectTL.setHasBaseTypeAsWritten(false);
1085  ObjCObjectTL.getBaseLoc().initialize(Context, SourceLocation());
1086 
1087  // No type arguments.
1088  ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation());
1089  ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation());
1090 
1091  // Fill in protocol qualifiers.
1092  ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc);
1093  ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc);
1094  for (unsigned i = 0, n = protocols.size(); i != n; ++i)
1095  ObjCObjectTL.setProtocolLoc(i, protocolLocs[i]);
1096 
1097  // We're done. Return the completed type to the parser.
1098  return CreateParsedType(Result, ResultTInfo);
1099 }
1100 
1102  Scope *S,
1103  SourceLocation Loc,
1104  ParsedType BaseType,
1105  SourceLocation TypeArgsLAngleLoc,
1106  ArrayRef<ParsedType> TypeArgs,
1107  SourceLocation TypeArgsRAngleLoc,
1108  SourceLocation ProtocolLAngleLoc,
1109  ArrayRef<Decl *> Protocols,
1110  ArrayRef<SourceLocation> ProtocolLocs,
1111  SourceLocation ProtocolRAngleLoc) {
1112  TypeSourceInfo *BaseTypeInfo = nullptr;
1113  QualType T = GetTypeFromParser(BaseType, &BaseTypeInfo);
1114  if (T.isNull())
1115  return true;
1116 
1117  // Handle missing type-source info.
1118  if (!BaseTypeInfo)
1119  BaseTypeInfo = Context.getTrivialTypeSourceInfo(T, Loc);
1120 
1121  // Extract type arguments.
1122  SmallVector<TypeSourceInfo *, 4> ActualTypeArgInfos;
1123  for (unsigned i = 0, n = TypeArgs.size(); i != n; ++i) {
1124  TypeSourceInfo *TypeArgInfo = nullptr;
1125  QualType TypeArg = GetTypeFromParser(TypeArgs[i], &TypeArgInfo);
1126  if (TypeArg.isNull()) {
1127  ActualTypeArgInfos.clear();
1128  break;
1129  }
1130 
1131  assert(TypeArgInfo && "No type source info?");
1132  ActualTypeArgInfos.push_back(TypeArgInfo);
1133  }
1134 
1135  // Build the object type.
1136  QualType Result = BuildObjCObjectType(
1137  T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(),
1138  TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
1139  ProtocolLAngleLoc,
1140  llvm::makeArrayRef((ObjCProtocolDecl * const *)Protocols.data(),
1141  Protocols.size()),
1142  ProtocolLocs, ProtocolRAngleLoc,
1143  /*FailOnError=*/false);
1144 
1145  if (Result == T)
1146  return BaseType;
1147 
1148  // Create source information for this type.
1149  TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
1150  TypeLoc ResultTL = ResultTInfo->getTypeLoc();
1151 
1152  // For id<Proto1, Proto2> or Class<Proto1, Proto2>, we'll have an
1153  // object pointer type. Fill in source information for it.
1154  if (auto ObjCObjectPointerTL = ResultTL.getAs<ObjCObjectPointerTypeLoc>()) {
1155  // The '*' is implicit.
1156  ObjCObjectPointerTL.setStarLoc(SourceLocation());
1157  ResultTL = ObjCObjectPointerTL.getPointeeLoc();
1158  }
1159 
1160  if (auto OTPTL = ResultTL.getAs<ObjCTypeParamTypeLoc>()) {
1161  // Protocol qualifier information.
1162  if (OTPTL.getNumProtocols() > 0) {
1163  assert(OTPTL.getNumProtocols() == Protocols.size());
1164  OTPTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1165  OTPTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1166  for (unsigned i = 0, n = Protocols.size(); i != n; ++i)
1167  OTPTL.setProtocolLoc(i, ProtocolLocs[i]);
1168  }
1169 
1170  // We're done. Return the completed type to the parser.
1171  return CreateParsedType(Result, ResultTInfo);
1172  }
1173 
1174  auto ObjCObjectTL = ResultTL.castAs<ObjCObjectTypeLoc>();
1175 
1176  // Type argument information.
1177  if (ObjCObjectTL.getNumTypeArgs() > 0) {
1178  assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size());
1179  ObjCObjectTL.setTypeArgsLAngleLoc(TypeArgsLAngleLoc);
1180  ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc);
1181  for (unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i)
1182  ObjCObjectTL.setTypeArgTInfo(i, ActualTypeArgInfos[i]);
1183  } else {
1184  ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation());
1185  ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation());
1186  }
1187 
1188  // Protocol qualifier information.
1189  if (ObjCObjectTL.getNumProtocols() > 0) {
1190  assert(ObjCObjectTL.getNumProtocols() == Protocols.size());
1191  ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1192  ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1193  for (unsigned i = 0, n = Protocols.size(); i != n; ++i)
1194  ObjCObjectTL.setProtocolLoc(i, ProtocolLocs[i]);
1195  } else {
1196  ObjCObjectTL.setProtocolLAngleLoc(SourceLocation());
1197  ObjCObjectTL.setProtocolRAngleLoc(SourceLocation());
1198  }
1199 
1200  // Base type.
1201  ObjCObjectTL.setHasBaseTypeAsWritten(true);
1202  if (ObjCObjectTL.getType() == T)
1203  ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->getTypeLoc());
1204  else
1205  ObjCObjectTL.getBaseLoc().initialize(Context, Loc);
1206 
1207  // We're done. Return the completed type to the parser.
1208  return CreateParsedType(Result, ResultTInfo);
1209 }
1210 
1211 static OpenCLAccessAttr::Spelling getImageAccess(const AttributeList *Attrs) {
1212  if (Attrs) {
1213  const AttributeList *Next = Attrs;
1214  do {
1215  const AttributeList &Attr = *Next;
1216  Next = Attr.getNext();
1217  if (Attr.getKind() == AttributeList::AT_OpenCLAccess) {
1218  return static_cast<OpenCLAccessAttr::Spelling>(
1219  Attr.getSemanticSpelling());
1220  }
1221  } while (Next);
1222  }
1223  return OpenCLAccessAttr::Keyword_read_only;
1224 }
1225 
1226 /// \brief Convert the specified declspec to the appropriate type
1227 /// object.
1228 /// \param state Specifies the declarator containing the declaration specifier
1229 /// to be converted, along with other associated processing state.
1230 /// \returns The type described by the declaration specifiers. This function
1231 /// never returns null.
1232 static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
1233  // FIXME: Should move the logic from DeclSpec::Finish to here for validity
1234  // checking.
1235 
1236  Sema &S = state.getSema();
1237  Declarator &declarator = state.getDeclarator();
1238  const DeclSpec &DS = declarator.getDeclSpec();
1239  SourceLocation DeclLoc = declarator.getIdentifierLoc();
1240  if (DeclLoc.isInvalid())
1241  DeclLoc = DS.getLocStart();
1242 
1243  ASTContext &Context = S.Context;
1244 
1245  QualType Result;
1246  switch (DS.getTypeSpecType()) {
1247  case DeclSpec::TST_void:
1248  Result = Context.VoidTy;
1249  break;
1250  case DeclSpec::TST_char:
1252  Result = Context.CharTy;
1253  else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed)
1254  Result = Context.SignedCharTy;
1255  else {
1256  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
1257  "Unknown TSS value");
1258  Result = Context.UnsignedCharTy;
1259  }
1260  break;
1261  case DeclSpec::TST_wchar:
1263  Result = Context.WCharTy;
1264  else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) {
1265  S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
1266  << DS.getSpecifierName(DS.getTypeSpecType(),
1267  Context.getPrintingPolicy());
1268  Result = Context.getSignedWCharType();
1269  } else {
1270  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
1271  "Unknown TSS value");
1272  S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
1273  << DS.getSpecifierName(DS.getTypeSpecType(),
1274  Context.getPrintingPolicy());
1275  Result = Context.getUnsignedWCharType();
1276  }
1277  break;
1278  case DeclSpec::TST_char16:
1279  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
1280  "Unknown TSS value");
1281  Result = Context.Char16Ty;
1282  break;
1283  case DeclSpec::TST_char32:
1284  assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
1285  "Unknown TSS value");
1286  Result = Context.Char32Ty;
1287  break;
1289  // If this is a missing declspec in a block literal return context, then it
1290  // is inferred from the return statements inside the block.
1291  // The declspec is always missing in a lambda expr context; it is either
1292  // specified with a trailing return type or inferred.
1293  if (S.getLangOpts().CPlusPlus14 &&
1294  declarator.getContext() == Declarator::LambdaExprContext) {
1295  // In C++1y, a lambda's implicit return type is 'auto'.
1296  Result = Context.getAutoDeductType();
1297  break;
1298  } else if (declarator.getContext() == Declarator::LambdaExprContext ||
1299  checkOmittedBlockReturnType(S, declarator,
1300  Context.DependentTy)) {
1301  Result = Context.DependentTy;
1302  break;
1303  }
1304 
1305  // Unspecified typespec defaults to int in C90. However, the C90 grammar
1306  // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
1307  // type-qualifier, or storage-class-specifier. If not, emit an extwarn.
1308  // Note that the one exception to this is function definitions, which are
1309  // allowed to be completely missing a declspec. This is handled in the
1310  // parser already though by it pretending to have seen an 'int' in this
1311  // case.
1312  if (S.getLangOpts().ImplicitInt) {
1313  // In C89 mode, we only warn if there is a completely missing declspec
1314  // when one is not allowed.
1315  if (DS.isEmpty()) {
1316  S.Diag(DeclLoc, diag::ext_missing_declspec)
1317  << DS.getSourceRange()
1318  << FixItHint::CreateInsertion(DS.getLocStart(), "int");
1319  }
1320  } else if (!DS.hasTypeSpecifier()) {
1321  // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says:
1322  // "At least one type specifier shall be given in the declaration
1323  // specifiers in each declaration, and in the specifier-qualifier list in
1324  // each struct declaration and type name."
1325  if (S.getLangOpts().CPlusPlus) {
1326  S.Diag(DeclLoc, diag::err_missing_type_specifier)
1327  << DS.getSourceRange();
1328 
1329  // When this occurs in C++ code, often something is very broken with the
1330  // value being declared, poison it as invalid so we don't get chains of
1331  // errors.
1332  declarator.setInvalidType(true);
1333  } else if (S.getLangOpts().OpenCLVersion >= 200 && DS.isTypeSpecPipe()){
1334  S.Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1335  << DS.getSourceRange();
1336  declarator.setInvalidType(true);
1337  } else {
1338  S.Diag(DeclLoc, diag::ext_missing_type_specifier)
1339  << DS.getSourceRange();
1340  }
1341  }
1342 
1343  // FALL THROUGH.
1344  case DeclSpec::TST_int: {
1346  switch (DS.getTypeSpecWidth()) {
1347  case DeclSpec::TSW_unspecified: Result = Context.IntTy; break;
1348  case DeclSpec::TSW_short: Result = Context.ShortTy; break;
1349  case DeclSpec::TSW_long: Result = Context.LongTy; break;
1351  Result = Context.LongLongTy;
1352 
1353  // 'long long' is a C99 or C++11 feature.
1354  if (!S.getLangOpts().C99) {
1355  if (S.getLangOpts().CPlusPlus)
1356  S.Diag(DS.getTypeSpecWidthLoc(),
1357  S.getLangOpts().CPlusPlus11 ?
1358  diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1359  else
1360  S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
1361  }
1362  break;
1363  }
1364  } else {
1365  switch (DS.getTypeSpecWidth()) {
1366  case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
1367  case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break;
1368  case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break;
1370  Result = Context.UnsignedLongLongTy;
1371 
1372  // 'long long' is a C99 or C++11 feature.
1373  if (!S.getLangOpts().C99) {
1374  if (S.getLangOpts().CPlusPlus)
1375  S.Diag(DS.getTypeSpecWidthLoc(),
1376  S.getLangOpts().CPlusPlus11 ?
1377  diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1378  else
1379  S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong);
1380  }
1381  break;
1382  }
1383  }
1384  break;
1385  }
1386  case DeclSpec::TST_int128:
1387  if (!S.Context.getTargetInfo().hasInt128Type())
1388  S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1389  << "__int128";
1391  Result = Context.UnsignedInt128Ty;
1392  else
1393  Result = Context.Int128Ty;
1394  break;
1395  case DeclSpec::TST_float16: Result = Context.Float16Ty; break;
1396  case DeclSpec::TST_half: Result = Context.HalfTy; break;
1397  case DeclSpec::TST_float: Result = Context.FloatTy; break;
1398  case DeclSpec::TST_double:
1400  Result = Context.LongDoubleTy;
1401  else
1402  Result = Context.DoubleTy;
1403  break;
1406  S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
1407  << "__float128";
1408  Result = Context.Float128Ty;
1409  break;
1410  case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
1411  break;
1412  case DeclSpec::TST_decimal32: // _Decimal32
1413  case DeclSpec::TST_decimal64: // _Decimal64
1414  case DeclSpec::TST_decimal128: // _Decimal128
1415  S.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported);
1416  Result = Context.IntTy;
1417  declarator.setInvalidType(true);
1418  break;
1419  case DeclSpec::TST_class:
1420  case DeclSpec::TST_enum:
1421  case DeclSpec::TST_union:
1422  case DeclSpec::TST_struct:
1423  case DeclSpec::TST_interface: {
1424  TypeDecl *D = dyn_cast_or_null<TypeDecl>(DS.getRepAsDecl());
1425  if (!D) {
1426  // This can happen in C++ with ambiguous lookups.
1427  Result = Context.IntTy;
1428  declarator.setInvalidType(true);
1429  break;
1430  }
1431 
1432  // If the type is deprecated or unavailable, diagnose it.
1434 
1435  assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
1436  DS.getTypeSpecSign() == 0 && "No qualifiers on tag names!");
1437 
1438  // TypeQuals handled by caller.
1439  Result = Context.getTypeDeclType(D);
1440 
1441  // In both C and C++, make an ElaboratedType.
1442  ElaboratedTypeKeyword Keyword
1444  Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result);
1445  break;
1446  }
1447  case DeclSpec::TST_typename: {
1448  assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
1449  DS.getTypeSpecSign() == 0 &&
1450  "Can't handle qualifiers on typedef names yet!");
1451  Result = S.GetTypeFromParser(DS.getRepAsType());
1452  if (Result.isNull()) {
1453  declarator.setInvalidType(true);
1454  }
1455 
1456  // TypeQuals handled by caller.
1457  break;
1458  }
1460  // FIXME: Preserve type source info.
1461  Result = S.GetTypeFromParser(DS.getRepAsType());
1462  assert(!Result.isNull() && "Didn't get a type for typeof?");
1463  if (!Result->isDependentType())
1464  if (const TagType *TT = Result->getAs<TagType>())
1465  S.DiagnoseUseOfDecl(TT->getDecl(), DS.getTypeSpecTypeLoc());
1466  // TypeQuals handled by caller.
1467  Result = Context.getTypeOfType(Result);
1468  break;
1469  case DeclSpec::TST_typeofExpr: {
1470  Expr *E = DS.getRepAsExpr();
1471  assert(E && "Didn't get an expression for typeof?");
1472  // TypeQuals handled by caller.
1473  Result = S.BuildTypeofExprType(E, DS.getTypeSpecTypeLoc());
1474  if (Result.isNull()) {
1475  Result = Context.IntTy;
1476  declarator.setInvalidType(true);
1477  }
1478  break;
1479  }
1480  case DeclSpec::TST_decltype: {
1481  Expr *E = DS.getRepAsExpr();
1482  assert(E && "Didn't get an expression for decltype?");
1483  // TypeQuals handled by caller.
1484  Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc());
1485  if (Result.isNull()) {
1486  Result = Context.IntTy;
1487  declarator.setInvalidType(true);
1488  }
1489  break;
1490  }
1492  Result = S.GetTypeFromParser(DS.getRepAsType());
1493  assert(!Result.isNull() && "Didn't get a type for __underlying_type?");
1494  Result = S.BuildUnaryTransformType(Result,
1496  DS.getTypeSpecTypeLoc());
1497  if (Result.isNull()) {
1498  Result = Context.IntTy;
1499  declarator.setInvalidType(true);
1500  }
1501  break;
1502 
1503  case DeclSpec::TST_auto:
1504  Result = Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false);
1505  break;
1506 
1508  Result = Context.getAutoType(QualType(), AutoTypeKeyword::GNUAutoType, false);
1509  break;
1510 
1513  /*IsDependent*/ false);
1514  break;
1515 
1517  Result = Context.UnknownAnyTy;
1518  break;
1519 
1520  case DeclSpec::TST_atomic:
1521  Result = S.GetTypeFromParser(DS.getRepAsType());
1522  assert(!Result.isNull() && "Didn't get a type for _Atomic?");
1523  Result = S.BuildAtomicType(Result, DS.getTypeSpecTypeLoc());
1524  if (Result.isNull()) {
1525  Result = Context.IntTy;
1526  declarator.setInvalidType(true);
1527  }
1528  break;
1529 
1530 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
1531  case DeclSpec::TST_##ImgType##_t: \
1532  switch (getImageAccess(DS.getAttributes().getList())) { \
1533  case OpenCLAccessAttr::Keyword_write_only: \
1534  Result = Context.Id##WOTy; break; \
1535  case OpenCLAccessAttr::Keyword_read_write: \
1536  Result = Context.Id##RWTy; break; \
1537  case OpenCLAccessAttr::Keyword_read_only: \
1538  Result = Context.Id##ROTy; break; \
1539  } \
1540  break;
1541 #include "clang/Basic/OpenCLImageTypes.def"
1542 
1543  case DeclSpec::TST_error:
1544  Result = Context.IntTy;
1545  declarator.setInvalidType(true);
1546  break;
1547  }
1548 
1549  if (S.getLangOpts().OpenCL &&
1551  declarator.setInvalidType(true);
1552 
1553  // Handle complex types.
1554  if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) {
1555  if (S.getLangOpts().Freestanding)
1556  S.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
1557  Result = Context.getComplexType(Result);
1558  } else if (DS.isTypeAltiVecVector()) {
1559  unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(Result));
1560  assert(typeSize > 0 && "type size for vector must be greater than 0 bits");
1562  if (DS.isTypeAltiVecPixel())
1563  VecKind = VectorType::AltiVecPixel;
1564  else if (DS.isTypeAltiVecBool())
1565  VecKind = VectorType::AltiVecBool;
1566  Result = Context.getVectorType(Result, 128/typeSize, VecKind);
1567  }
1568 
1569  // FIXME: Imaginary.
1570  if (DS.getTypeSpecComplex() == DeclSpec::TSC_imaginary)
1571  S.Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported);
1572 
1573  // Before we process any type attributes, synthesize a block literal
1574  // function declarator if necessary.
1575  if (declarator.getContext() == Declarator::BlockLiteralContext)
1577 
1578  // Apply any type attributes from the decl spec. This may cause the
1579  // list of type attributes to be temporarily saved while the type
1580  // attributes are pushed around.
1581  // pipe attributes will be handled later ( at GetFullTypeForDeclarator )
1582  if (!DS.isTypeSpecPipe())
1583  processTypeAttrs(state, Result, TAL_DeclSpec, DS.getAttributes().getList());
1584 
1585  // Apply const/volatile/restrict qualifiers to T.
1586  if (unsigned TypeQuals = DS.getTypeQualifiers()) {
1587  // Warn about CV qualifiers on function types.
1588  // C99 6.7.3p8:
1589  // If the specification of a function type includes any type qualifiers,
1590  // the behavior is undefined.
1591  // C++11 [dcl.fct]p7:
1592  // The effect of a cv-qualifier-seq in a function declarator is not the
1593  // same as adding cv-qualification on top of the function type. In the
1594  // latter case, the cv-qualifiers are ignored.
1595  if (TypeQuals && Result->isFunctionType()) {
1597  S, DS, TypeQuals, Result, DeclSpec::TQ_const | DeclSpec::TQ_volatile,
1598  S.getLangOpts().CPlusPlus
1599  ? diag::warn_typecheck_function_qualifiers_ignored
1600  : diag::warn_typecheck_function_qualifiers_unspecified);
1601  // No diagnostic for 'restrict' or '_Atomic' applied to a
1602  // function type; we'll diagnose those later, in BuildQualifiedType.
1603  }
1604 
1605  // C++11 [dcl.ref]p1:
1606  // Cv-qualified references are ill-formed except when the
1607  // cv-qualifiers are introduced through the use of a typedef-name
1608  // or decltype-specifier, in which case the cv-qualifiers are ignored.
1609  //
1610  // There don't appear to be any other contexts in which a cv-qualified
1611  // reference type could be formed, so the 'ill-formed' clause here appears
1612  // to never happen.
1613  if (TypeQuals && Result->isReferenceType()) {
1615  S, DS, TypeQuals, Result,
1617  diag::warn_typecheck_reference_qualifiers);
1618  }
1619 
1620  // C90 6.5.3 constraints: "The same type qualifier shall not appear more
1621  // than once in the same specifier-list or qualifier-list, either directly
1622  // or via one or more typedefs."
1623  if (!S.getLangOpts().C99 && !S.getLangOpts().CPlusPlus
1624  && TypeQuals & Result.getCVRQualifiers()) {
1625  if (TypeQuals & DeclSpec::TQ_const && Result.isConstQualified()) {
1626  S.Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec)
1627  << "const";
1628  }
1629 
1630  if (TypeQuals & DeclSpec::TQ_volatile && Result.isVolatileQualified()) {
1631  S.Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec)
1632  << "volatile";
1633  }
1634 
1635  // C90 doesn't have restrict nor _Atomic, so it doesn't force us to
1636  // produce a warning in this case.
1637  }
1638 
1639  QualType Qualified = S.BuildQualifiedType(Result, DeclLoc, TypeQuals, &DS);
1640 
1641  // If adding qualifiers fails, just use the unqualified type.
1642  if (Qualified.isNull())
1643  declarator.setInvalidType(true);
1644  else
1645  Result = Qualified;
1646  }
1647 
1648  assert(!Result.isNull() && "This function should not return a null type");
1649  return Result;
1650 }
1651 
1652 static std::string getPrintableNameForEntity(DeclarationName Entity) {
1653  if (Entity)
1654  return Entity.getAsString();
1655 
1656  return "type name";
1657 }
1658 
1660  Qualifiers Qs, const DeclSpec *DS) {
1661  if (T.isNull())
1662  return QualType();
1663 
1664  // Ignore any attempt to form a cv-qualified reference.
1665  if (T->isReferenceType()) {
1666  Qs.removeConst();
1667  Qs.removeVolatile();
1668  }
1669 
1670  // Enforce C99 6.7.3p2: "Types other than pointer types derived from
1671  // object or incomplete types shall not be restrict-qualified."
1672  if (Qs.hasRestrict()) {
1673  unsigned DiagID = 0;
1674  QualType ProblemTy;
1675 
1676  if (T->isAnyPointerType() || T->isReferenceType() ||
1677  T->isMemberPointerType()) {
1678  QualType EltTy;
1679  if (T->isObjCObjectPointerType())
1680  EltTy = T;
1681  else if (const MemberPointerType *PTy = T->getAs<MemberPointerType>())
1682  EltTy = PTy->getPointeeType();
1683  else
1684  EltTy = T->getPointeeType();
1685 
1686  // If we have a pointer or reference, the pointee must have an object
1687  // incomplete type.
1688  if (!EltTy->isIncompleteOrObjectType()) {
1689  DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1690  ProblemTy = EltTy;
1691  }
1692  } else if (!T->isDependentType()) {
1693  DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1694  ProblemTy = T;
1695  }
1696 
1697  if (DiagID) {
1698  Diag(DS ? DS->getRestrictSpecLoc() : Loc, DiagID) << ProblemTy;
1699  Qs.removeRestrict();
1700  }
1701  }
1702 
1703  return Context.getQualifiedType(T, Qs);
1704 }
1705 
1707  unsigned CVRAU, const DeclSpec *DS) {
1708  if (T.isNull())
1709  return QualType();
1710 
1711  // Ignore any attempt to form a cv-qualified reference.
1712  if (T->isReferenceType())
1713  CVRAU &=
1715 
1716  // Convert from DeclSpec::TQ to Qualifiers::TQ by just dropping TQ_atomic and
1717  // TQ_unaligned;
1718  unsigned CVR = CVRAU & ~(DeclSpec::TQ_atomic | DeclSpec::TQ_unaligned);
1719 
1720  // C11 6.7.3/5:
1721  // If the same qualifier appears more than once in the same
1722  // specifier-qualifier-list, either directly or via one or more typedefs,
1723  // the behavior is the same as if it appeared only once.
1724  //
1725  // It's not specified what happens when the _Atomic qualifier is applied to
1726  // a type specified with the _Atomic specifier, but we assume that this
1727  // should be treated as if the _Atomic qualifier appeared multiple times.
1728  if (CVRAU & DeclSpec::TQ_atomic && !T->isAtomicType()) {
1729  // C11 6.7.3/5:
1730  // If other qualifiers appear along with the _Atomic qualifier in a
1731  // specifier-qualifier-list, the resulting type is the so-qualified
1732  // atomic type.
1733  //
1734  // Don't need to worry about array types here, since _Atomic can't be
1735  // applied to such types.
1737  T = BuildAtomicType(QualType(Split.Ty, 0),
1738  DS ? DS->getAtomicSpecLoc() : Loc);
1739  if (T.isNull())
1740  return T;
1741  Split.Quals.addCVRQualifiers(CVR);
1742  return BuildQualifiedType(T, Loc, Split.Quals);
1743  }
1744 
1747  return BuildQualifiedType(T, Loc, Q, DS);
1748 }
1749 
1750 /// \brief Build a paren type including \p T.
1752  return Context.getParenType(T);
1753 }
1754 
1755 /// Given that we're building a pointer or reference to the given
1757  SourceLocation loc,
1758  bool isReference) {
1759  // Bail out if retention is unrequired or already specified.
1760  if (!type->isObjCLifetimeType() ||
1762  return type;
1763 
1765 
1766  // If the object type is const-qualified, we can safely use
1767  // __unsafe_unretained. This is safe (because there are no read
1768  // barriers), and it'll be safe to coerce anything but __weak* to
1769  // the resulting type.
1770  if (type.isConstQualified()) {
1771  implicitLifetime = Qualifiers::OCL_ExplicitNone;
1772 
1773  // Otherwise, check whether the static type does not require
1774  // retaining. This currently only triggers for Class (possibly
1775  // protocol-qualifed, and arrays thereof).
1776  } else if (type->isObjCARCImplicitlyUnretainedType()) {
1777  implicitLifetime = Qualifiers::OCL_ExplicitNone;
1778 
1779  // If we are in an unevaluated context, like sizeof, skip adding a
1780  // qualification.
1781  } else if (S.isUnevaluatedContext()) {
1782  return type;
1783 
1784  // If that failed, give an error and recover using __strong. __strong
1785  // is the option most likely to prevent spurious second-order diagnostics,
1786  // like when binding a reference to a field.
1787  } else {
1788  // These types can show up in private ivars in system headers, so
1789  // we need this to not be an error in those cases. Instead we
1790  // want to delay.
1794  diag::err_arc_indirect_no_ownership, type, isReference));
1795  } else {
1796  S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;
1797  }
1798  implicitLifetime = Qualifiers::OCL_Strong;
1799  }
1800  assert(implicitLifetime && "didn't infer any lifetime!");
1801 
1802  Qualifiers qs;
1803  qs.addObjCLifetime(implicitLifetime);
1804  return S.Context.getQualifiedType(type, qs);
1805 }
1806 
1807 static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy){
1808  std::string Quals =
1810 
1811  switch (FnTy->getRefQualifier()) {
1812  case RQ_None:
1813  break;
1814 
1815  case RQ_LValue:
1816  if (!Quals.empty())
1817  Quals += ' ';
1818  Quals += '&';
1819  break;
1820 
1821  case RQ_RValue:
1822  if (!Quals.empty())
1823  Quals += ' ';
1824  Quals += "&&";
1825  break;
1826  }
1827 
1828  return Quals;
1829 }
1830 
1831 namespace {
1832 /// Kinds of declarator that cannot contain a qualified function type.
1833 ///
1834 /// C++98 [dcl.fct]p4 / C++11 [dcl.fct]p6:
1835 /// a function type with a cv-qualifier or a ref-qualifier can only appear
1836 /// at the topmost level of a type.
1837 ///
1838 /// Parens and member pointers are permitted. We don't diagnose array and
1839 /// function declarators, because they don't allow function types at all.
1840 ///
1841 /// The values of this enum are used in diagnostics.
1842 enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
1843 } // end anonymous namespace
1844 
1845 /// Check whether the type T is a qualified function type, and if it is,
1846 /// diagnose that it cannot be contained within the given kind of declarator.
1848  QualifiedFunctionKind QFK) {
1849  // Does T refer to a function type with a cv-qualifier or a ref-qualifier?
1850  const FunctionProtoType *FPT = T->getAs<FunctionProtoType>();
1851  if (!FPT || (FPT->getTypeQuals() == 0 && FPT->getRefQualifier() == RQ_None))
1852  return false;
1853 
1854  S.Diag(Loc, diag::err_compound_qualified_function_type)
1855  << QFK << isa<FunctionType>(T.IgnoreParens()) << T
1857  return true;
1858 }
1859 
1860 /// \brief Build a pointer type.
1861 ///
1862 /// \param T The type to which we'll be building a pointer.
1863 ///
1864 /// \param Loc The location of the entity whose type involves this
1865 /// pointer type or, if there is no such entity, the location of the
1866 /// type that will have pointer type.
1867 ///
1868 /// \param Entity The name of the entity that involves the pointer
1869 /// type, if known.
1870 ///
1871 /// \returns A suitable pointer type, if there are no
1872 /// errors. Otherwise, returns a NULL type.
1874  SourceLocation Loc, DeclarationName Entity) {
1875  if (T->isReferenceType()) {
1876  // C++ 8.3.2p4: There shall be no ... pointers to references ...
1877  Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
1878  << getPrintableNameForEntity(Entity) << T;
1879  return QualType();
1880  }
1881 
1882  if (T->isFunctionType() && getLangOpts().OpenCL) {
1883  Diag(Loc, diag::err_opencl_function_pointer);
1884  return QualType();
1885  }
1886 
1887  if (checkQualifiedFunction(*this, T, Loc, QFK_Pointer))
1888  return QualType();
1889 
1890  assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType");
1891 
1892  // In ARC, it is forbidden to build pointers to unqualified pointers.
1893  if (getLangOpts().ObjCAutoRefCount)
1894  T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ false);
1895 
1896  // Build the pointer type.
1897  return Context.getPointerType(T);
1898 }
1899 
1900 /// \brief Build a reference type.
1901 ///
1902 /// \param T The type to which we'll be building a reference.
1903 ///
1904 /// \param Loc The location of the entity whose type involves this
1905 /// reference type or, if there is no such entity, the location of the
1906 /// type that will have reference type.
1907 ///
1908 /// \param Entity The name of the entity that involves the reference
1909 /// type, if known.
1910 ///
1911 /// \returns A suitable reference type, if there are no
1912 /// errors. Otherwise, returns a NULL type.
1914  SourceLocation Loc,
1915  DeclarationName Entity) {
1916  assert(Context.getCanonicalType(T) != Context.OverloadTy &&
1917  "Unresolved overloaded function type");
1918 
1919  // C++0x [dcl.ref]p6:
1920  // If a typedef (7.1.3), a type template-parameter (14.3.1), or a
1921  // decltype-specifier (7.1.6.2) denotes a type TR that is a reference to a
1922  // type T, an attempt to create the type "lvalue reference to cv TR" creates
1923  // the type "lvalue reference to T", while an attempt to create the type
1924  // "rvalue reference to cv TR" creates the type TR.
1925  bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>();
1926 
1927  // C++ [dcl.ref]p4: There shall be no references to references.
1928  //
1929  // According to C++ DR 106, references to references are only
1930  // diagnosed when they are written directly (e.g., "int & &"),
1931  // but not when they happen via a typedef:
1932  //
1933  // typedef int& intref;
1934  // typedef intref& intref2;
1935  //
1936  // Parser::ParseDeclaratorInternal diagnoses the case where
1937  // references are written directly; here, we handle the
1938  // collapsing of references-to-references as described in C++0x.
1939  // DR 106 and 540 introduce reference-collapsing into C++98/03.
1940 
1941  // C++ [dcl.ref]p1:
1942  // A declarator that specifies the type "reference to cv void"
1943  // is ill-formed.
1944  if (T->isVoidType()) {
1945  Diag(Loc, diag::err_reference_to_void);
1946  return QualType();
1947  }
1948 
1949  if (checkQualifiedFunction(*this, T, Loc, QFK_Reference))
1950  return QualType();
1951 
1952  // In ARC, it is forbidden to build references to unqualified pointers.
1953  if (getLangOpts().ObjCAutoRefCount)
1954  T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ true);
1955 
1956  // Handle restrict on references.
1957  if (LValueRef)
1958  return Context.getLValueReferenceType(T, SpelledAsLValue);
1959  return Context.getRValueReferenceType(T);
1960 }
1961 
1962 /// \brief Build a Read-only Pipe type.
1963 ///
1964 /// \param T The type to which we'll be building a Pipe.
1965 ///
1966 /// \param Loc We do not use it for now.
1967 ///
1968 /// \returns A suitable pipe type, if there are no errors. Otherwise, returns a
1969 /// NULL type.
1971  return Context.getReadPipeType(T);
1972 }
1973 
1974 /// \brief Build a Write-only Pipe type.
1975 ///
1976 /// \param T The type to which we'll be building a Pipe.
1977 ///
1978 /// \param Loc We do not use it for now.
1979 ///
1980 /// \returns A suitable pipe type, if there are no errors. Otherwise, returns a
1981 /// NULL type.
1983  return Context.getWritePipeType(T);
1984 }
1985 
1986 /// Check whether the specified array size makes the array type a VLA. If so,
1987 /// return true, if not, return the size of the array in SizeVal.
1988 static bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal) {
1989  // If the size is an ICE, it certainly isn't a VLA. If we're in a GNU mode
1990  // (like gnu99, but not c99) accept any evaluatable value as an extension.
1991  class VLADiagnoser : public Sema::VerifyICEDiagnoser {
1992  public:
1993  VLADiagnoser() : Sema::VerifyICEDiagnoser(true) {}
1994 
1995  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
1996  }
1997 
1998  void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR) override {
1999  S.Diag(Loc, diag::ext_vla_folded_to_constant) << SR;
2000  }
2001  } Diagnoser;
2002 
2003  return S.VerifyIntegerConstantExpression(ArraySize, &SizeVal, Diagnoser,
2004  S.LangOpts.GNUMode ||
2005  S.LangOpts.OpenCL).isInvalid();
2006 }
2007 
2008 /// \brief Build an array type.
2009 ///
2010 /// \param T The type of each element in the array.
2011 ///
2012 /// \param ASM C99 array size modifier (e.g., '*', 'static').
2013 ///
2014 /// \param ArraySize Expression describing the size of the array.
2015 ///
2016 /// \param Brackets The range from the opening '[' to the closing ']'.
2017 ///
2018 /// \param Entity The name of the entity that involves the array
2019 /// type, if known.
2020 ///
2021 /// \returns A suitable array type, if there are no errors. Otherwise,
2022 /// returns a NULL type.
2024  Expr *ArraySize, unsigned Quals,
2025  SourceRange Brackets, DeclarationName Entity) {
2026 
2027  SourceLocation Loc = Brackets.getBegin();
2028  if (getLangOpts().CPlusPlus) {
2029  // C++ [dcl.array]p1:
2030  // T is called the array element type; this type shall not be a reference
2031  // type, the (possibly cv-qualified) type void, a function type or an
2032  // abstract class type.
2033  //
2034  // C++ [dcl.array]p3:
2035  // When several "array of" specifications are adjacent, [...] only the
2036  // first of the constant expressions that specify the bounds of the arrays
2037  // may be omitted.
2038  //
2039  // Note: function types are handled in the common path with C.
2040  if (T->isReferenceType()) {
2041  Diag(Loc, diag::err_illegal_decl_array_of_references)
2042  << getPrintableNameForEntity(Entity) << T;
2043  return QualType();
2044  }
2045 
2046  if (T->isVoidType() || T->isIncompleteArrayType()) {
2047  Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T;
2048  return QualType();
2049  }
2050 
2051  if (RequireNonAbstractType(Brackets.getBegin(), T,
2052  diag::err_array_of_abstract_type))
2053  return QualType();
2054 
2055  // Mentioning a member pointer type for an array type causes us to lock in
2056  // an inheritance model, even if it's inside an unused typedef.
2057  if (Context.getTargetInfo().getCXXABI().isMicrosoft())
2058  if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>())
2059  if (!MPTy->getClass()->isDependentType())
2060  (void)isCompleteType(Loc, T);
2061 
2062  } else {
2063  // C99 6.7.5.2p1: If the element type is an incomplete or function type,
2064  // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
2065  if (RequireCompleteType(Loc, T,
2066  diag::err_illegal_decl_array_incomplete_type))
2067  return QualType();
2068  }
2069 
2070  if (T->isFunctionType()) {
2071  Diag(Loc, diag::err_illegal_decl_array_of_functions)
2072  << getPrintableNameForEntity(Entity) << T;
2073  return QualType();
2074  }
2075 
2076  if (const RecordType *EltTy = T->getAs<RecordType>()) {
2077  // If the element type is a struct or union that contains a variadic
2078  // array, accept it as a GNU extension: C99 6.7.2.1p2.
2079  if (EltTy->getDecl()->hasFlexibleArrayMember())
2080  Diag(Loc, diag::ext_flexible_array_in_array) << T;
2081  } else if (T->isObjCObjectType()) {
2082  Diag(Loc, diag::err_objc_array_of_interfaces) << T;
2083  return QualType();
2084  }
2085 
2086  // Do placeholder conversions on the array size expression.
2087  if (ArraySize && ArraySize->hasPlaceholderType()) {
2088  ExprResult Result = CheckPlaceholderExpr(ArraySize);
2089  if (Result.isInvalid()) return QualType();
2090  ArraySize = Result.get();
2091  }
2092 
2093  // Do lvalue-to-rvalue conversions on the array size expression.
2094  if (ArraySize && !ArraySize->isRValue()) {
2095  ExprResult Result = DefaultLvalueConversion(ArraySize);
2096  if (Result.isInvalid())
2097  return QualType();
2098 
2099  ArraySize = Result.get();
2100  }
2101 
2102  // C99 6.7.5.2p1: The size expression shall have integer type.
2103  // C++11 allows contextual conversions to such types.
2104  if (!getLangOpts().CPlusPlus11 &&
2105  ArraySize && !ArraySize->isTypeDependent() &&
2106  !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {
2107  Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
2108  << ArraySize->getType() << ArraySize->getSourceRange();
2109  return QualType();
2110  }
2111 
2112  llvm::APSInt ConstVal(Context.getTypeSize(Context.getSizeType()));
2113  if (!ArraySize) {
2114  if (ASM == ArrayType::Star)
2115  T = Context.getVariableArrayType(T, nullptr, ASM, Quals, Brackets);
2116  else
2117  T = Context.getIncompleteArrayType(T, ASM, Quals);
2118  } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) {
2119  T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets);
2120  } else if ((!T->isDependentType() && !T->isIncompleteType() &&
2121  !T->isConstantSizeType()) ||
2122  isArraySizeVLA(*this, ArraySize, ConstVal)) {
2123  // Even in C++11, don't allow contextual conversions in the array bound
2124  // of a VLA.
2125  if (getLangOpts().CPlusPlus11 &&
2126  !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {
2127  Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
2128  << ArraySize->getType() << ArraySize->getSourceRange();
2129  return QualType();
2130  }
2131 
2132  // C99: an array with an element type that has a non-constant-size is a VLA.
2133  // C99: an array with a non-ICE size is a VLA. We accept any expression
2134  // that we can fold to a non-zero positive value as an extension.
2135  T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets);
2136  } else {
2137  // C99 6.7.5.2p1: If the expression is a constant expression, it shall
2138  // have a value greater than zero.
2139  if (ConstVal.isSigned() && ConstVal.isNegative()) {
2140  if (Entity)
2141  Diag(ArraySize->getLocStart(), diag::err_decl_negative_array_size)
2142  << getPrintableNameForEntity(Entity) << ArraySize->getSourceRange();
2143  else
2144  Diag(ArraySize->getLocStart(), diag::err_typecheck_negative_array_size)
2145  << ArraySize->getSourceRange();
2146  return QualType();
2147  }
2148  if (ConstVal == 0) {
2149  // GCC accepts zero sized static arrays. We allow them when
2150  // we're not in a SFINAE context.
2151  Diag(ArraySize->getLocStart(),
2152  isSFINAEContext()? diag::err_typecheck_zero_array_size
2153  : diag::ext_typecheck_zero_array_size)
2154  << ArraySize->getSourceRange();
2155 
2156  if (ASM == ArrayType::Static) {
2157  Diag(ArraySize->getLocStart(),
2158  diag::warn_typecheck_zero_static_array_size)
2159  << ArraySize->getSourceRange();
2160  ASM = ArrayType::Normal;
2161  }
2162  } else if (!T->isDependentType() && !T->isVariablyModifiedType() &&
2163  !T->isIncompleteType() && !T->isUndeducedType()) {
2164  // Is the array too large?
2165  unsigned ActiveSizeBits
2166  = ConstantArrayType::getNumAddressingBits(Context, T, ConstVal);
2167  if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
2168  Diag(ArraySize->getLocStart(), diag::err_array_too_large)
2169  << ConstVal.toString(10)
2170  << ArraySize->getSourceRange();
2171  return QualType();
2172  }
2173  }
2174 
2175  T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
2176  }
2177 
2178  // OpenCL v1.2 s6.9.d: variable length arrays are not supported.
2179  if (getLangOpts().OpenCL && T->isVariableArrayType()) {
2180  Diag(Loc, diag::err_opencl_vla);
2181  return QualType();
2182  }
2183  // CUDA device code doesn't support VLAs.
2184  if (getLangOpts().CUDA && T->isVariableArrayType())
2185  CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget();
2186 
2187  // If this is not C99, extwarn about VLA's and C99 array size modifiers.
2188  if (!getLangOpts().C99) {
2189  if (T->isVariableArrayType()) {
2190  // Prohibit the use of VLAs during template argument deduction.
2191  if (isSFINAEContext()) {
2192  Diag(Loc, diag::err_vla_in_sfinae);
2193  return QualType();
2194  }
2195  // Just extwarn about VLAs.
2196  else
2197  Diag(Loc, diag::ext_vla);
2198  } else if (ASM != ArrayType::Normal || Quals != 0)
2199  Diag(Loc,
2200  getLangOpts().CPlusPlus? diag::err_c99_array_usage_cxx
2201  : diag::ext_c99_array_usage) << ASM;
2202  }
2203 
2204  if (T->isVariableArrayType()) {
2205  // Warn about VLAs for -Wvla.
2206  Diag(Loc, diag::warn_vla_used);
2207  }
2208 
2209  // OpenCL v2.0 s6.12.5 - Arrays of blocks are not supported.
2210  // OpenCL v2.0 s6.16.13.1 - Arrays of pipe type are not supported.
2211  // OpenCL v2.0 s6.9.b - Arrays of image/sampler type are not supported.
2212  if (getLangOpts().OpenCL) {
2213  const QualType ArrType = Context.getBaseElementType(T);
2214  if (ArrType->isBlockPointerType() || ArrType->isPipeType() ||
2215  ArrType->isSamplerT() || ArrType->isImageType()) {
2216  Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
2217  return QualType();
2218  }
2219  }
2220 
2221  return T;
2222 }
2223 
2224 /// \brief Build an ext-vector type.
2225 ///
2226 /// Run the required checks for the extended vector type.
2228  SourceLocation AttrLoc) {
2229  // Unlike gcc's vector_size attribute, we do not allow vectors to be defined
2230  // in conjunction with complex types (pointers, arrays, functions, etc.).
2231  //
2232  // Additionally, OpenCL prohibits vectors of booleans (they're considered a
2233  // reserved data type under OpenCL v2.0 s6.1.4), we don't support selects
2234  // on bitvectors, and we have no well-defined ABI for bitvectors, so vectors
2235  // of bool aren't allowed.
2236  if ((!T->isDependentType() && !T->isIntegerType() &&
2237  !T->isRealFloatingType()) ||
2238  T->isBooleanType()) {
2239  Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
2240  return QualType();
2241  }
2242 
2243  if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) {
2244  llvm::APSInt vecSize(32);
2245  if (!ArraySize->isIntegerConstantExpr(vecSize, Context)) {
2246  Diag(AttrLoc, diag::err_attribute_argument_type)
2247  << "ext_vector_type" << AANT_ArgumentIntegerConstant
2248  << ArraySize->getSourceRange();
2249  return QualType();
2250  }
2251 
2252  // Unlike gcc's vector_size attribute, the size is specified as the
2253  // number of elements, not the number of bytes.
2254  unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue());
2255 
2256  if (vectorSize == 0) {
2257  Diag(AttrLoc, diag::err_attribute_zero_size)
2258  << ArraySize->getSourceRange();
2259  return QualType();
2260  }
2261 
2262  if (VectorType::isVectorSizeTooLarge(vectorSize)) {
2263  Diag(AttrLoc, diag::err_attribute_size_too_large)
2264  << ArraySize->getSourceRange();
2265  return QualType();
2266  }
2267 
2268  return Context.getExtVectorType(T, vectorSize);
2269  }
2270 
2271  return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc);
2272 }
2273 
2275  if (T->isArrayType() || T->isFunctionType()) {
2276  Diag(Loc, diag::err_func_returning_array_function)
2277  << T->isFunctionType() << T;
2278  return true;
2279  }
2280 
2281  // Functions cannot return half FP.
2282  if (T->isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2283  Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2284  FixItHint::CreateInsertion(Loc, "*");
2285  return true;
2286  }
2287 
2288  // Methods cannot return interface types. All ObjC objects are
2289  // passed by reference.
2290  if (T->isObjCObjectType()) {
2291  Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value)
2292  << 0 << T << FixItHint::CreateInsertion(Loc, "*");
2293  return true;
2294  }
2295 
2296  return false;
2297 }
2298 
2299 /// Check the extended parameter information. Most of the necessary
2300 /// checking should occur when applying the parameter attribute; the
2301 /// only other checks required are positional restrictions.
2304  llvm::function_ref<SourceLocation(unsigned)> getParamLoc) {
2305  assert(EPI.ExtParameterInfos && "shouldn't get here without param infos");
2306 
2307  bool hasCheckedSwiftCall = false;
2308  auto checkForSwiftCC = [&](unsigned paramIndex) {
2309  // Only do this once.
2310  if (hasCheckedSwiftCall) return;
2311  hasCheckedSwiftCall = true;
2312  if (EPI.ExtInfo.getCC() == CC_Swift) return;
2313  S.Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2314  << getParameterABISpelling(EPI.ExtParameterInfos[paramIndex].getABI());
2315  };
2316 
2317  for (size_t paramIndex = 0, numParams = paramTypes.size();
2318  paramIndex != numParams; ++paramIndex) {
2319  switch (EPI.ExtParameterInfos[paramIndex].getABI()) {
2320  // Nothing interesting to check for orindary-ABI parameters.
2322  continue;
2323 
2324  // swift_indirect_result parameters must be a prefix of the function
2325  // arguments.
2327  checkForSwiftCC(paramIndex);
2328  if (paramIndex != 0 &&
2329  EPI.ExtParameterInfos[paramIndex - 1].getABI()
2331  S.Diag(getParamLoc(paramIndex),
2332  diag::err_swift_indirect_result_not_first);
2333  }
2334  continue;
2335 
2337  checkForSwiftCC(paramIndex);
2338  continue;
2339 
2340  // swift_error parameters must be preceded by a swift_context parameter.
2342  checkForSwiftCC(paramIndex);
2343  if (paramIndex == 0 ||
2344  EPI.ExtParameterInfos[paramIndex - 1].getABI() !=
2346  S.Diag(getParamLoc(paramIndex),
2347  diag::err_swift_error_result_not_after_swift_context);
2348  }
2349  continue;
2350  }
2351  llvm_unreachable("bad ABI kind");
2352  }
2353 }
2354 
2356  MutableArrayRef<QualType> ParamTypes,
2357  SourceLocation Loc, DeclarationName Entity,
2358  const FunctionProtoType::ExtProtoInfo &EPI) {
2359  bool Invalid = false;
2360 
2361  Invalid |= CheckFunctionReturnType(T, Loc);
2362 
2363  for (unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2364  // FIXME: Loc is too inprecise here, should use proper locations for args.
2365  QualType ParamType = Context.getAdjustedParameterType(ParamTypes[Idx]);
2366  if (ParamType->isVoidType()) {
2367  Diag(Loc, diag::err_param_with_void_type);
2368  Invalid = true;
2369  } else if (ParamType->isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2370  // Disallow half FP arguments.
2371  Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2372  FixItHint::CreateInsertion(Loc, "*");
2373  Invalid = true;
2374  }
2375 
2376  ParamTypes[Idx] = ParamType;
2377  }
2378 
2379  if (EPI.ExtParameterInfos) {
2380  checkExtParameterInfos(*this, ParamTypes, EPI,
2381  [=](unsigned i) { return Loc; });
2382  }
2383 
2384  if (EPI.ExtInfo.getProducesResult()) {
2385  // This is just a warning, so we can't fail to build if we see it.
2386  checkNSReturnsRetainedReturnType(Loc, T);
2387  }
2388 
2389  if (Invalid)
2390  return QualType();
2391 
2392  return Context.getFunctionType(T, ParamTypes, EPI);
2393 }
2394 
2395 /// \brief Build a member pointer type \c T Class::*.
2396 ///
2397 /// \param T the type to which the member pointer refers.
2398 /// \param Class the class type into which the member pointer points.
2399 /// \param Loc the location where this type begins
2400 /// \param Entity the name of the entity that will have this member pointer type
2401 ///
2402 /// \returns a member pointer type, if successful, or a NULL type if there was
2403 /// an error.
2405  SourceLocation Loc,
2406  DeclarationName Entity) {
2407  // Verify that we're not building a pointer to pointer to function with
2408  // exception specification.
2409  if (CheckDistantExceptionSpec(T)) {
2410  Diag(Loc, diag::err_distant_exception_spec);
2411  return QualType();
2412  }
2413 
2414  // C++ 8.3.3p3: A pointer to member shall not point to ... a member
2415  // with reference type, or "cv void."
2416  if (T->isReferenceType()) {
2417  Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
2418  << getPrintableNameForEntity(Entity) << T;
2419  return QualType();
2420  }
2421 
2422  if (T->isVoidType()) {
2423  Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
2424  << getPrintableNameForEntity(Entity);
2425  return QualType();
2426  }
2427 
2428  if (!Class->isDependentType() && !Class->isRecordType()) {
2429  Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
2430  return QualType();
2431  }
2432 
2433  // Adjust the default free function calling convention to the default method
2434  // calling convention.
2435  bool IsCtorOrDtor =
2438  if (T->isFunctionType())
2439  adjustMemberFunctionCC(T, /*IsStatic=*/false, IsCtorOrDtor, Loc);
2440 
2441  return Context.getMemberPointerType(T, Class.getTypePtr());
2442 }
2443 
2444 /// \brief Build a block pointer type.
2445 ///
2446 /// \param T The type to which we'll be building a block pointer.
2447 ///
2448 /// \param Loc The source location, used for diagnostics.
2449 ///
2450 /// \param Entity The name of the entity that involves the block pointer
2451 /// type, if known.
2452 ///
2453 /// \returns A suitable block pointer type, if there are no
2454 /// errors. Otherwise, returns a NULL type.
2456  SourceLocation Loc,
2457  DeclarationName Entity) {
2458  if (!T->isFunctionType()) {
2459  Diag(Loc, diag::err_nonfunction_block_type);
2460  return QualType();
2461  }
2462 
2463  if (checkQualifiedFunction(*this, T, Loc, QFK_BlockPointer))
2464  return QualType();
2465 
2466  return Context.getBlockPointerType(T);
2467 }
2468 
2470  QualType QT = Ty.get();
2471  if (QT.isNull()) {
2472  if (TInfo) *TInfo = nullptr;
2473  return QualType();
2474  }
2475 
2476  TypeSourceInfo *DI = nullptr;
2477  if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2478  QT = LIT->getType();
2479  DI = LIT->getTypeSourceInfo();
2480  }
2481 
2482  if (TInfo) *TInfo = DI;
2483  return QT;
2484 }
2485 
2486 static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state,
2487  Qualifiers::ObjCLifetime ownership,
2488  unsigned chunkIndex);
2489 
2490 /// Given that this is the declaration of a parameter under ARC,
2491 /// attempt to infer attributes and such for pointer-to-whatever
2492 /// types.
2493 static void inferARCWriteback(TypeProcessingState &state,
2494  QualType &declSpecType) {
2495  Sema &S = state.getSema();
2496  Declarator &declarator = state.getDeclarator();
2497 
2498  // TODO: should we care about decl qualifiers?
2499 
2500  // Check whether the declarator has the expected form. We walk
2501  // from the inside out in order to make the block logic work.
2502  unsigned outermostPointerIndex = 0;
2503  bool isBlockPointer = false;
2504  unsigned numPointers = 0;
2505  for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
2506  unsigned chunkIndex = i;
2507  DeclaratorChunk &chunk = declarator.getTypeObject(chunkIndex);
2508  switch (chunk.Kind) {
2510  // Ignore parens.
2511  break;
2512 
2515  // Count the number of pointers. Treat references
2516  // interchangeably as pointers; if they're mis-ordered, normal
2517  // type building will discover that.
2518  outermostPointerIndex = chunkIndex;
2519  numPointers++;
2520  break;
2521 
2523  // If we have a pointer to block pointer, that's an acceptable
2524  // indirect reference; anything else is not an application of
2525  // the rules.
2526  if (numPointers != 1) return;
2527  numPointers++;
2528  outermostPointerIndex = chunkIndex;
2529  isBlockPointer = true;
2530 
2531  // We don't care about pointer structure in return values here.
2532  goto done;
2533 
2534  case DeclaratorChunk::Array: // suppress if written (id[])?
2537  case DeclaratorChunk::Pipe:
2538  return;
2539  }
2540  }
2541  done:
2542 
2543  // If we have *one* pointer, then we want to throw the qualifier on
2544  // the declaration-specifiers, which means that it needs to be a
2545  // retainable object type.
2546  if (numPointers == 1) {
2547  // If it's not a retainable object type, the rule doesn't apply.
2548  if (!declSpecType->isObjCRetainableType()) return;
2549 
2550  // If it already has lifetime, don't do anything.
2551  if (declSpecType.getObjCLifetime()) return;
2552 
2553  // Otherwise, modify the type in-place.
2554  Qualifiers qs;
2555 
2556  if (declSpecType->isObjCARCImplicitlyUnretainedType())
2558  else
2560  declSpecType = S.Context.getQualifiedType(declSpecType, qs);
2561 
2562  // If we have *two* pointers, then we want to throw the qualifier on
2563  // the outermost pointer.
2564  } else if (numPointers == 2) {
2565  // If we don't have a block pointer, we need to check whether the
2566  // declaration-specifiers gave us something that will turn into a
2567  // retainable object pointer after we slap the first pointer on it.
2568  if (!isBlockPointer && !declSpecType->isObjCObjectType())
2569  return;
2570 
2571  // Look for an explicit lifetime attribute there.
2572  DeclaratorChunk &chunk = declarator.getTypeObject(outermostPointerIndex);
2573  if (chunk.Kind != DeclaratorChunk::Pointer &&
2575  return;
2576  for (const AttributeList *attr = chunk.getAttrs(); attr;
2577  attr = attr->getNext())
2578  if (attr->getKind() == AttributeList::AT_ObjCOwnership)
2579  return;
2580 
2582  outermostPointerIndex);
2583 
2584  // Any other number of pointers/references does not trigger the rule.
2585  } else return;
2586 
2587  // TODO: mark whether we did this inference?
2588 }
2589 
2590 void Sema::diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
2591  SourceLocation FallbackLoc,
2592  SourceLocation ConstQualLoc,
2593  SourceLocation VolatileQualLoc,
2594  SourceLocation RestrictQualLoc,
2595  SourceLocation AtomicQualLoc,
2596  SourceLocation UnalignedQualLoc) {
2597  if (!Quals)
2598  return;
2599 
2600  struct Qual {
2601  const char *Name;
2602  unsigned Mask;
2603  SourceLocation Loc;
2604  } const QualKinds[5] = {
2605  { "const", DeclSpec::TQ_const, ConstQualLoc },
2606  { "volatile", DeclSpec::TQ_volatile, VolatileQualLoc },
2607  { "restrict", DeclSpec::TQ_restrict, RestrictQualLoc },
2608  { "__unaligned", DeclSpec::TQ_unaligned, UnalignedQualLoc },
2609  { "_Atomic", DeclSpec::TQ_atomic, AtomicQualLoc }
2610  };
2611 
2612  SmallString<32> QualStr;
2613  unsigned NumQuals = 0;
2614  SourceLocation Loc;
2615  FixItHint FixIts[5];
2616 
2617  // Build a string naming the redundant qualifiers.
2618  for (auto &E : QualKinds) {
2619  if (Quals & E.Mask) {
2620  if (!QualStr.empty()) QualStr += ' ';
2621  QualStr += E.Name;
2622 
2623  // If we have a location for the qualifier, offer a fixit.
2624  SourceLocation QualLoc = E.Loc;
2625  if (QualLoc.isValid()) {
2626  FixIts[NumQuals] = FixItHint::CreateRemoval(QualLoc);
2627  if (Loc.isInvalid() ||
2628  getSourceManager().isBeforeInTranslationUnit(QualLoc, Loc))
2629  Loc = QualLoc;
2630  }
2631 
2632  ++NumQuals;
2633  }
2634  }
2635 
2636  Diag(Loc.isInvalid() ? FallbackLoc : Loc, DiagID)
2637  << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2638 }
2639 
2640 // Diagnose pointless type qualifiers on the return type of a function.
2642  Declarator &D,
2643  unsigned FunctionChunkIndex) {
2644  if (D.getTypeObject(FunctionChunkIndex).Fun.hasTrailingReturnType()) {
2645  // FIXME: TypeSourceInfo doesn't preserve location information for
2646  // qualifiers.
2647  S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
2648  RetTy.getLocalCVRQualifiers(),
2649  D.getIdentifierLoc());
2650  return;
2651  }
2652 
2653  for (unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2654  End = D.getNumTypeObjects();
2655  OuterChunkIndex != End; ++OuterChunkIndex) {
2656  DeclaratorChunk &OuterChunk = D.getTypeObject(OuterChunkIndex);
2657  switch (OuterChunk.Kind) {
2659  continue;
2660 
2661  case DeclaratorChunk::Pointer: {
2662  DeclaratorChunk::PointerTypeInfo &PTI = OuterChunk.Ptr;
2664  diag::warn_qual_return_type,
2665  PTI.TypeQuals,
2666  SourceLocation(),
2672  return;
2673  }
2674 
2680  case DeclaratorChunk::Pipe:
2681  // FIXME: We can't currently provide an accurate source location and a
2682  // fix-it hint for these.
2683  unsigned AtomicQual = RetTy->isAtomicType() ? DeclSpec::TQ_atomic : 0;
2684  S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
2685  RetTy.getCVRQualifiers() | AtomicQual,
2686  D.getIdentifierLoc());
2687  return;
2688  }
2689 
2690  llvm_unreachable("unknown declarator chunk kind");
2691  }
2692 
2693  // If the qualifiers come from a conversion function type, don't diagnose
2694  // them -- they're not necessarily redundant, since such a conversion
2695  // operator can be explicitly called as "x.operator const int()".
2697  return;
2698 
2699  // Just parens all the way out to the decl specifiers. Diagnose any qualifiers
2700  // which are present there.
2701  S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type,
2703  D.getIdentifierLoc(),
2709 }
2710 
2711 static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
2712  TypeSourceInfo *&ReturnTypeInfo) {
2713  Sema &SemaRef = state.getSema();
2714  Declarator &D = state.getDeclarator();
2715  QualType T;
2716  ReturnTypeInfo = nullptr;
2717 
2718  // The TagDecl owned by the DeclSpec.
2719  TagDecl *OwnedTagDecl = nullptr;
2720 
2721  switch (D.getName().getKind()) {
2727  T = ConvertDeclSpecToType(state);
2728 
2729  if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) {
2730  OwnedTagDecl = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
2731  // Owned declaration is embedded in declarator.
2732  OwnedTagDecl->setEmbeddedInDeclarator(true);
2733  }
2734  break;
2735 
2739  // Constructors and destructors don't have return types. Use
2740  // "void" instead.
2741  T = SemaRef.Context.VoidTy;
2742  processTypeAttrs(state, T, TAL_DeclSpec,
2744  break;
2745 
2747  // Deduction guides have a trailing return type and no type in their
2748  // decl-specifier sequence. Use a placeholder return type for now.
2749  T = SemaRef.Context.DependentTy;
2750  break;
2751 
2753  // The result type of a conversion function is the type that it
2754  // converts to.
2756  &ReturnTypeInfo);
2757  break;
2758  }
2759 
2760  if (D.getAttributes())
2762 
2763  // C++11 [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context.
2764  if (DeducedType *Deduced = T->getContainedDeducedType()) {
2765  AutoType *Auto = dyn_cast<AutoType>(Deduced);
2766  int Error = -1;
2767 
2768  // Is this a 'auto' or 'decltype(auto)' type (as opposed to __auto_type or
2769  // class template argument deduction)?
2770  bool IsCXXAutoType =
2771  (Auto && Auto->getKeyword() != AutoTypeKeyword::GNUAutoType);
2772 
2773  switch (D.getContext()) {
2775  // Declared return type of a lambda-declarator is implicit and is always
2776  // 'auto'.
2777  break;
2781  Error = 0;
2782  break;
2784  // In C++14, generic lambdas allow 'auto' in their parameters.
2785  if (!SemaRef.getLangOpts().CPlusPlus14 ||
2786  !Auto || Auto->getKeyword() != AutoTypeKeyword::Auto)
2787  Error = 16;
2788  else {
2789  // If auto is mentioned in a lambda parameter context, convert it to a
2790  // template parameter type.
2791  sema::LambdaScopeInfo *LSI = SemaRef.getCurLambda();
2792  assert(LSI && "No LambdaScopeInfo on the stack!");
2793  const unsigned TemplateParameterDepth = LSI->AutoTemplateParameterDepth;
2794  const unsigned AutoParameterPosition = LSI->AutoTemplateParams.size();
2795  const bool IsParameterPack = D.hasEllipsis();
2796 
2797  // Create the TemplateTypeParmDecl here to retrieve the corresponding
2798  // template parameter type. Template parameters are temporarily added
2799  // to the TU until the associated TemplateDecl is created.
2800  TemplateTypeParmDecl *CorrespondingTemplateParam =
2802  SemaRef.Context, SemaRef.Context.getTranslationUnitDecl(),
2803  /*KeyLoc*/SourceLocation(), /*NameLoc*/D.getLocStart(),
2804  TemplateParameterDepth, AutoParameterPosition,
2805  /*Identifier*/nullptr, false, IsParameterPack);
2806  LSI->AutoTemplateParams.push_back(CorrespondingTemplateParam);
2807  // Replace the 'auto' in the function parameter with this invented
2808  // template type parameter.
2809  // FIXME: Retain some type sugar to indicate that this was written
2810  // as 'auto'.
2811  T = SemaRef.ReplaceAutoType(
2812  T, QualType(CorrespondingTemplateParam->getTypeForDecl(), 0));
2813  }
2814  break;
2818  break;
2819  bool Cxx = SemaRef.getLangOpts().CPlusPlus;
2820  switch (cast<TagDecl>(SemaRef.CurContext)->getTagKind()) {
2821  case TTK_Enum: llvm_unreachable("unhandled tag kind");
2822  case TTK_Struct: Error = Cxx ? 1 : 2; /* Struct member */ break;
2823  case TTK_Union: Error = Cxx ? 3 : 4; /* Union member */ break;
2824  case TTK_Class: Error = 5; /* Class member */ break;
2825  case TTK_Interface: Error = 6; /* Interface member */ break;
2826  }
2827  if (D.getDeclSpec().isFriendSpecified())
2828  Error = 20; // Friend type
2829  break;
2830  }
2833  Error = 7; // Exception declaration
2834  break;
2836  if (isa<DeducedTemplateSpecializationType>(Deduced))
2837  Error = 19; // Template parameter
2838  else if (!SemaRef.getLangOpts().CPlusPlus1z)
2839  Error = 8; // Template parameter (until C++1z)
2840  break;
2842  Error = 9; // Block literal
2843  break;
2845  Error = 10; // Template type argument
2846  break;
2849  Error = 12; // Type alias
2850  break;
2852  if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
2853  Error = 13; // Function return type
2854  break;
2856  if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
2857  Error = 14; // conversion-type-id
2858  break;
2860  if (isa<DeducedTemplateSpecializationType>(Deduced))
2861  break;
2862  LLVM_FALLTHROUGH;
2864  Error = 15; // Generic
2865  break;
2871  // FIXME: P0091R3 (erroneously) does not permit class template argument
2872  // deduction in conditions, for-init-statements, and other declarations
2873  // that are not simple-declarations.
2874  break;
2876  // FIXME: P0091R3 does not permit class template argument deduction here,
2877  // but we follow GCC and allow it anyway.
2878  if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
2879  Error = 17; // 'new' type
2880  break;
2882  Error = 18; // K&R function parameter
2883  break;
2884  }
2885 
2887  Error = 11;
2888 
2889  // In Objective-C it is an error to use 'auto' on a function declarator
2890  // (and everywhere for '__auto_type').
2891  if (D.isFunctionDeclarator() &&
2892  (!SemaRef.getLangOpts().CPlusPlus11 || !IsCXXAutoType))
2893  Error = 13;
2894 
2895  bool HaveTrailing = false;
2896 
2897  // C++11 [dcl.spec.auto]p2: 'auto' is always fine if the declarator
2898  // contains a trailing return type. That is only legal at the outermost
2899  // level. Check all declarator chunks (outermost first) anyway, to give
2900  // better diagnostics.
2901  // We don't support '__auto_type' with trailing return types.
2902  // FIXME: Should we only do this for 'auto' and not 'decltype(auto)'?
2903  if (SemaRef.getLangOpts().CPlusPlus11 && IsCXXAutoType &&
2904  D.hasTrailingReturnType()) {
2905  HaveTrailing = true;
2906  Error = -1;
2907  }
2908 
2909  SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc();
2911  AutoRange = D.getName().getSourceRange();
2912 
2913  if (Error != -1) {
2914  unsigned Kind;
2915  if (Auto) {
2916  switch (Auto->getKeyword()) {
2917  case AutoTypeKeyword::Auto: Kind = 0; break;
2918  case AutoTypeKeyword::DecltypeAuto: Kind = 1; break;
2919  case AutoTypeKeyword::GNUAutoType: Kind = 2; break;
2920  }
2921  } else {
2922  assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
2923  "unknown auto type");
2924  Kind = 3;
2925  }
2926 
2927  auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
2928  TemplateName TN = DTST ? DTST->getTemplateName() : TemplateName();
2929 
2930  SemaRef.Diag(AutoRange.getBegin(), diag::err_auto_not_allowed)
2931  << Kind << Error << (int)SemaRef.getTemplateNameKindForDiagnostics(TN)
2932  << QualType(Deduced, 0) << AutoRange;
2933  if (auto *TD = TN.getAsTemplateDecl())
2934  SemaRef.Diag(TD->getLocation(), diag::note_template_decl_here);
2935 
2936  T = SemaRef.Context.IntTy;
2937  D.setInvalidType(true);
2938  } else if (!HaveTrailing) {
2939  // If there was a trailing return type, we already got
2940  // warn_cxx98_compat_trailing_return_type in the parser.
2941  SemaRef.Diag(AutoRange.getBegin(),
2942  diag::warn_cxx98_compat_auto_type_specifier)
2943  << AutoRange;
2944  }
2945  }
2946 
2947  if (SemaRef.getLangOpts().CPlusPlus &&
2948  OwnedTagDecl && OwnedTagDecl->isCompleteDefinition()) {
2949  // Check the contexts where C++ forbids the declaration of a new class
2950  // or enumeration in a type-specifier-seq.
2951  unsigned DiagID = 0;
2952  switch (D.getContext()) {
2954  // Class and enumeration definitions are syntactically not allowed in
2955  // trailing return types.
2956  llvm_unreachable("parser should not have allowed this");
2957  break;
2965  // C++11 [dcl.type]p3:
2966  // A type-specifier-seq shall not define a class or enumeration unless
2967  // it appears in the type-id of an alias-declaration (7.1.3) that is not
2968  // the declaration of a template-declaration.
2970  break;
2972  DiagID = diag::err_type_defined_in_alias_template;
2973  break;
2982  DiagID = diag::err_type_defined_in_type_specifier;
2983  break;
2989  // C++ [dcl.fct]p6:
2990  // Types shall not be defined in return or parameter types.
2991  DiagID = diag::err_type_defined_in_param_type;
2992  break;
2994  // C++ 6.4p2:
2995  // The type-specifier-seq shall not contain typedef and shall not declare
2996  // a new class or enumeration.
2997  DiagID = diag::err_type_defined_in_condition;
2998  break;
2999  }
3000 
3001  if (DiagID != 0) {
3002  SemaRef.Diag(OwnedTagDecl->getLocation(), DiagID)
3003  << SemaRef.Context.getTypeDeclType(OwnedTagDecl);
3004  D.setInvalidType(true);
3005  }
3006  }
3007 
3008  assert(!T.isNull() && "This function should not return a null type");
3009  return T;
3010 }
3011 
3012 /// Produce an appropriate diagnostic for an ambiguity between a function
3013 /// declarator and a C++ direct-initializer.
3015  DeclaratorChunk &DeclType, QualType RT) {
3016  const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
3017  assert(FTI.isAmbiguous && "no direct-initializer / function ambiguity");
3018 
3019  // If the return type is void there is no ambiguity.
3020  if (RT->isVoidType())
3021  return;
3022 
3023  // An initializer for a non-class type can have at most one argument.
3024  if (!RT->isRecordType() && FTI.NumParams > 1)
3025  return;
3026 
3027  // An initializer for a reference must have exactly one argument.
3028  if (RT->isReferenceType() && FTI.NumParams != 1)
3029  return;
3030 
3031  // Only warn if this declarator is declaring a function at block scope, and
3032  // doesn't have a storage class (such as 'extern') specified.
3033  if (!D.isFunctionDeclarator() ||
3038  return;
3039 
3040  // Inside a condition, a direct initializer is not permitted. We allow one to
3041  // be parsed in order to give better diagnostics in condition parsing.
3043  return;
3044 
3045  SourceRange ParenRange(DeclType.Loc, DeclType.EndLoc);
3046 
3047  S.Diag(DeclType.Loc,
3048  FTI.NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3049  : diag::warn_empty_parens_are_function_decl)
3050  << ParenRange;
3051 
3052  // If the declaration looks like:
3053  // T var1,
3054  // f();
3055  // and name lookup finds a function named 'f', then the ',' was
3056  // probably intended to be a ';'.
3057  if (!D.isFirstDeclarator() && D.getIdentifier()) {
3060  if (Comma.getFileID() != Name.getFileID() ||
3061  Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3064  if (S.LookupName(Result, S.getCurScope()))
3065  S.Diag(D.getCommaLoc(), diag::note_empty_parens_function_call)
3067  << D.getIdentifier();
3068  Result.suppressDiagnostics();
3069  }
3070  }
3071 
3072  if (FTI.NumParams > 0) {
3073  // For a declaration with parameters, eg. "T var(T());", suggest adding
3074  // parens around the first parameter to turn the declaration into a
3075  // variable declaration.
3076  SourceRange Range = FTI.Params[0].Param->getSourceRange();
3077  SourceLocation B = Range.getBegin();
3078  SourceLocation E = S.getLocForEndOfToken(Range.getEnd());
3079  // FIXME: Maybe we should suggest adding braces instead of parens
3080  // in C++11 for classes that don't have an initializer_list constructor.
3081  S.Diag(B, diag::note_additional_parens_for_variable_declaration)
3082  << FixItHint::CreateInsertion(B, "(")
3083  << FixItHint::CreateInsertion(E, ")");
3084  } else {
3085  // For a declaration without parameters, eg. "T var();", suggest replacing
3086  // the parens with an initializer to turn the declaration into a variable
3087  // declaration.
3088  const CXXRecordDecl *RD = RT->getAsCXXRecordDecl();
3089 
3090  // Empty parens mean value-initialization, and no parens mean
3091  // default initialization. These are equivalent if the default
3092  // constructor is user-provided or if zero-initialization is a
3093  // no-op.
3094  if (RD && RD->hasDefinition() &&
3095  (RD->isEmpty() || RD->hasUserProvidedDefaultConstructor()))
3096  S.Diag(DeclType.Loc, diag::note_empty_parens_default_ctor)
3097  << FixItHint::CreateRemoval(ParenRange);
3098  else {
3099  std::string Init =
3100  S.getFixItZeroInitializerForType(RT, ParenRange.getBegin());
3101  if (Init.empty() && S.LangOpts.CPlusPlus11)
3102  Init = "{}";
3103  if (!Init.empty())
3104  S.Diag(DeclType.Loc, diag::note_empty_parens_zero_initialize)
3105  << FixItHint::CreateReplacement(ParenRange, Init);
3106  }
3107  }
3108 }
3109 
3110 /// Produce an appropriate diagnostic for a declarator with top-level
3111 /// parentheses.
3114  assert(Paren.Kind == DeclaratorChunk::Paren &&
3115  "do not have redundant top-level parentheses");
3116 
3117  // This is a syntactic check; we're not interested in cases that arise
3118  // during template instantiation.
3119  if (S.inTemplateInstantiation())
3120  return;
3121 
3122  // Check whether this could be intended to be a construction of a temporary
3123  // object in C++ via a function-style cast.
3124  bool CouldBeTemporaryObject =
3125  S.getLangOpts().CPlusPlus && D.isExpressionContext() &&
3126  !D.isInvalidType() && D.getIdentifier() &&
3128  (T->isRecordType() || T->isDependentType()) &&
3130 
3131  for (auto &C : D.type_objects()) {
3132  switch (C.Kind) {
3135  continue;
3136 
3138  if (!C.Arr.NumElts)
3139  CouldBeTemporaryObject = false;
3140  continue;
3141 
3143  // FIXME: Suppress the warning here if there is no initializer; we're
3144  // going to give an error anyway.
3145  // We assume that something like 'T (&x) = y;' is highly likely to not
3146  // be intended to be a temporary object.
3147  CouldBeTemporaryObject = false;
3148  continue;
3149 
3151  // In a new-type-id, function chunks require parentheses.
3153  return;
3154  LLVM_FALLTHROUGH;
3157  case DeclaratorChunk::Pipe:
3158  // These cannot appear in expressions.
3159  CouldBeTemporaryObject = false;
3160  continue;
3161  }
3162  }
3163 
3164  // FIXME: If there is an initializer, assume that this is not intended to be
3165  // a construction of a temporary object.
3166 
3167  // Check whether the name has already been declared; if not, this is not a
3168  // function-style cast.
3169  if (CouldBeTemporaryObject) {
3172  if (!S.LookupName(Result, S.getCurScope()))
3173  CouldBeTemporaryObject = false;
3174  Result.suppressDiagnostics();
3175  }
3176 
3177  SourceRange ParenRange(Paren.Loc, Paren.EndLoc);
3178 
3179  if (!CouldBeTemporaryObject) {
3180  S.Diag(Paren.Loc, diag::warn_redundant_parens_around_declarator)
3181  << ParenRange << FixItHint::CreateRemoval(Paren.Loc)
3182  << FixItHint::CreateRemoval(Paren.EndLoc);
3183  return;
3184  }
3185 
3186  S.Diag(Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3187  << ParenRange << D.getIdentifier();
3188  auto *RD = T->getAsCXXRecordDecl();
3189  if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3190  S.Diag(Paren.Loc, diag::note_raii_guard_add_name)
3191  << FixItHint::CreateInsertion(Paren.Loc, " varname") << T
3192  << D.getIdentifier();
3193  // FIXME: A cast to void is probably a better suggestion in cases where it's
3194  // valid (when there is no initializer and we're not in a condition).
3195  S.Diag(D.getLocStart(), diag::note_function_style_cast_add_parentheses)
3198  S.Diag(Paren.Loc, diag::note_remove_parens_for_variable_declaration)
3199  << FixItHint::CreateRemoval(Paren.Loc)
3200  << FixItHint::CreateRemoval(Paren.EndLoc);
3201 }
3202 
3203 /// Helper for figuring out the default CC for a function declarator type. If
3204 /// this is the outermost chunk, then we can determine the CC from the
3205 /// declarator context. If not, then this could be either a member function
3206 /// type or normal function type.
3207 static CallingConv
3210  unsigned ChunkIndex) {
3211  assert(D.getTypeObject(ChunkIndex).Kind == DeclaratorChunk::Function);
3212 
3213  // Check for an explicit CC attribute.
3214  for (auto Attr = FTI.AttrList; Attr; Attr = Attr->getNext()) {
3215  switch (Attr->getKind()) {
3217  // Ignore attributes that don't validate or can't apply to the
3218  // function type. We'll diagnose the failure to apply them in
3219  // handleFunctionTypeAttr.
3220  CallingConv CC;
3221  if (!S.CheckCallingConvAttr(*Attr, CC) &&
3222  (!FTI.isVariadic || supportsVariadicCall(CC))) {
3223  return CC;
3224  }
3225  break;
3226  }
3227 
3228  default:
3229  break;
3230  }
3231  }
3232 
3233  bool IsCXXInstanceMethod = false;
3234 
3235  if (S.getLangOpts().CPlusPlus) {
3236  // Look inwards through parentheses to see if this chunk will form a
3237  // member pointer type or if we're the declarator. Any type attributes
3238  // between here and there will override the CC we choose here.
3239  unsigned I = ChunkIndex;
3240  bool FoundNonParen = false;
3241  while (I && !FoundNonParen) {
3242  --I;
3244  FoundNonParen = true;
3245  }
3246 
3247  if (FoundNonParen) {
3248  // If we're not the declarator, we're a regular function type unless we're
3249  // in a member pointer.
3250  IsCXXInstanceMethod =
3252  } else if (D.getContext() == Declarator::LambdaExprContext) {
3253  // This can only be a call operator for a lambda, which is an instance
3254  // method.
3255  IsCXXInstanceMethod = true;
3256  } else {
3257  // We're the innermost decl chunk, so must be a function declarator.
3258  assert(D.isFunctionDeclarator());
3259 
3260  // If we're inside a record, we're declaring a method, but it could be
3261  // explicitly or implicitly static.
3262  IsCXXInstanceMethod =
3265  !D.isStaticMember();
3266  }
3267  }
3268 
3270  IsCXXInstanceMethod);
3271 
3272  // Attribute AT_OpenCLKernel affects the calling convention for SPIR
3273  // and AMDGPU targets, hence it cannot be treated as a calling
3274  // convention attribute. This is the simplest place to infer
3275  // calling convention for OpenCL kernels.
3276  if (S.getLangOpts().OpenCL) {
3277  for (const AttributeList *Attr = D.getDeclSpec().getAttributes().getList();
3278  Attr; Attr = Attr->getNext()) {
3279  if (Attr->getKind() == AttributeList::AT_OpenCLKernel) {
3280  CC = CC_OpenCLKernel;
3281  break;
3282  }
3283  }
3284  }
3285 
3286  return CC;
3287 }
3288 
3289 namespace {
3290  /// A simple notion of pointer kinds, which matches up with the various
3291  /// pointer declarators.
3292  enum class SimplePointerKind {
3293  Pointer,
3294  BlockPointer,
3295  MemberPointer,
3296  Array,
3297  };
3298 } // end anonymous namespace
3299 
3301  switch (nullability) {
3303  if (!Ident__Nonnull)
3304  Ident__Nonnull = PP.getIdentifierInfo("_Nonnull");
3305  return Ident__Nonnull;
3306 
3308  if (!Ident__Nullable)
3309  Ident__Nullable = PP.getIdentifierInfo("_Nullable");
3310  return Ident__Nullable;
3311 
3313  if (!Ident__Null_unspecified)
3314  Ident__Null_unspecified = PP.getIdentifierInfo("_Null_unspecified");
3315  return Ident__Null_unspecified;
3316  }
3317  llvm_unreachable("Unknown nullability kind.");
3318 }
3319 
3320 /// Retrieve the identifier "NSError".
3322  if (!Ident_NSError)
3323  Ident_NSError = PP.getIdentifierInfo("NSError");
3324 
3325  return Ident_NSError;
3326 }
3327 
3328 /// Check whether there is a nullability attribute of any kind in the given
3329 /// attribute list.
3330 static bool hasNullabilityAttr(const AttributeList *attrs) {
3331  for (const AttributeList *attr = attrs; attr;
3332  attr = attr->getNext()) {
3333  if (attr->getKind() == AttributeList::AT_TypeNonNull ||
3334  attr->getKind() == AttributeList::AT_TypeNullable ||
3335  attr->getKind() == AttributeList::AT_TypeNullUnspecified)
3336  return true;
3337  }
3338 
3339  return false;
3340 }
3341 
3342 namespace {
3343  /// Describes the kind of a pointer a declarator describes.
3345  // Not a pointer.
3346  NonPointer,
3347  // Single-level pointer.
3348  SingleLevelPointer,
3349  // Multi-level pointer (of any pointer kind).
3350  MultiLevelPointer,
3351  // CFFooRef*
3352  MaybePointerToCFRef,
3353  // CFErrorRef*
3354  CFErrorRefPointer,
3355  // NSError**
3356  NSErrorPointerPointer,
3357  };
3358 
3359  /// Describes a declarator chunk wrapping a pointer that marks inference as
3360  /// unexpected.
3361  // These values must be kept in sync with diagnostics.
3363  /// Pointer is top-level.
3364  None = -1,
3365  /// Pointer is an array element.
3366  Array = 0,
3367  /// Pointer is the referent type of a C++ reference.
3368  Reference = 1
3369  };
3370 } // end anonymous namespace
3371 
3372 /// Classify the given declarator, whose type-specified is \c type, based on
3373 /// what kind of pointer it refers to.
3374 ///
3375 /// This is used to determine the default nullability.
3376 static PointerDeclaratorKind
3378  PointerWrappingDeclaratorKind &wrappingKind) {
3379  unsigned numNormalPointers = 0;
3380 
3381  // For any dependent type, we consider it a non-pointer.
3382  if (type->isDependentType())
3383  return PointerDeclaratorKind::NonPointer;
3384 
3385  // Look through the declarator chunks to identify pointers.
3386  for (unsigned i = 0, n = declarator.getNumTypeObjects(); i != n; ++i) {
3387  DeclaratorChunk &chunk = declarator.getTypeObject(i);
3388  switch (chunk.Kind) {
3390  if (numNormalPointers == 0)
3391  wrappingKind = PointerWrappingDeclaratorKind::Array;
3392  break;
3393 
3395  case DeclaratorChunk::Pipe:
3396  break;
3397 
3400  return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3401  : PointerDeclaratorKind::SingleLevelPointer;
3402 
3404  break;
3405 
3407  if (numNormalPointers == 0)
3408  wrappingKind = PointerWrappingDeclaratorKind::Reference;
3409  break;
3410 
3412  ++numNormalPointers;
3413  if (numNormalPointers > 2)
3414  return PointerDeclaratorKind::MultiLevelPointer;
3415  break;
3416  }
3417  }
3418 
3419  // Then, dig into the type specifier itself.
3420  unsigned numTypeSpecifierPointers = 0;
3421  do {
3422  // Decompose normal pointers.
3423  if (auto ptrType = type->getAs<PointerType>()) {
3424  ++numNormalPointers;
3425 
3426  if (numNormalPointers > 2)
3427  return PointerDeclaratorKind::MultiLevelPointer;
3428 
3429  type = ptrType->getPointeeType();
3430  ++numTypeSpecifierPointers;
3431  continue;
3432  }
3433 
3434  // Decompose block pointers.
3435  if (type->getAs<BlockPointerType>()) {
3436  return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3437  : PointerDeclaratorKind::SingleLevelPointer;
3438  }
3439 
3440  // Decompose member pointers.
3441  if (type->getAs<MemberPointerType>()) {
3442  return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3443  : PointerDeclaratorKind::SingleLevelPointer;
3444  }
3445 
3446  // Look at Objective-C object pointers.
3447  if (auto objcObjectPtr = type->getAs<ObjCObjectPointerType>()) {
3448  ++numNormalPointers;
3449  ++numTypeSpecifierPointers;
3450 
3451  // If this is NSError**, report that.
3452  if (auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3453  if (objcClassDecl->getIdentifier() == S.getNSErrorIdent() &&
3454  numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3455  return PointerDeclaratorKind::NSErrorPointerPointer;
3456  }
3457  }
3458 
3459  break;
3460  }
3461 
3462  // Look at Objective-C class types.
3463  if (auto objcClass = type->getAs<ObjCInterfaceType>()) {
3464  if (objcClass->getInterface()->getIdentifier() == S.getNSErrorIdent()) {
3465  if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3466  return PointerDeclaratorKind::NSErrorPointerPointer;
3467  }
3468 
3469  break;
3470  }
3471 
3472  // If at this point we haven't seen a pointer, we won't see one.
3473  if (numNormalPointers == 0)
3474  return PointerDeclaratorKind::NonPointer;
3475 
3476  if (auto recordType = type->getAs<RecordType>()) {
3477  RecordDecl *recordDecl = recordType->getDecl();
3478 
3479  bool isCFError = false;
3480  if (S.CFError) {
3481  // If we already know about CFError, test it directly.
3482  isCFError = (S.CFError == recordDecl);
3483  } else {
3484  // Check whether this is CFError, which we identify based on its bridge
3485  // to NSError.
3486  if (recordDecl->getTagKind() == TTK_Struct && numNormalPointers > 0) {
3487  if (auto bridgeAttr = recordDecl->getAttr<ObjCBridgeAttr>()) {
3488  if (bridgeAttr->getBridgedType() == S.getNSErrorIdent()) {
3489  S.CFError = recordDecl;
3490  isCFError = true;
3491  }
3492  }
3493  }
3494  }
3495 
3496  // If this is CFErrorRef*, report it as such.
3497  if (isCFError && numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3498  return PointerDeclaratorKind::CFErrorRefPointer;
3499  }
3500  break;
3501  }
3502 
3503  break;
3504  } while (true);
3505 
3506  switch (numNormalPointers) {
3507  case 0:
3508  return PointerDeclaratorKind::NonPointer;
3509 
3510  case 1:
3511  return PointerDeclaratorKind::SingleLevelPointer;
3512 
3513  case 2:
3514  return PointerDeclaratorKind::MaybePointerToCFRef;
3515 
3516  default:
3517  return PointerDeclaratorKind::MultiLevelPointer;
3518  }
3519 }
3520 
3522  SourceLocation loc) {
3523  // If we're anywhere in a function, method, or closure context, don't perform
3524  // completeness checks.
3525  for (DeclContext *ctx = S.CurContext; ctx; ctx = ctx->getParent()) {
3526  if (ctx->isFunctionOrMethod())
3527  return FileID();
3528 
3529  if (ctx->isFileContext())
3530  break;
3531  }
3532 
3533  // We only care about the expansion location.
3534  loc = S.SourceMgr.getExpansionLoc(loc);
3535  FileID file = S.SourceMgr.getFileID(loc);
3536  if (file.isInvalid())
3537  return FileID();
3538 
3539  // Retrieve file information.
3540  bool invalid = false;
3541  const SrcMgr::SLocEntry &sloc = S.SourceMgr.getSLocEntry(file, &invalid);
3542  if (invalid || !sloc.isFile())
3543  return FileID();
3544 
3545  // We don't want to perform completeness checks on the main file or in
3546  // system headers.
3547  const SrcMgr::FileInfo &fileInfo = sloc.getFile();
3548  if (fileInfo.getIncludeLoc().isInvalid())
3549  return FileID();
3550  if (fileInfo.getFileCharacteristic() != SrcMgr::C_User &&
3552  return FileID();
3553  }
3554 
3555  return file;
3556 }
3557 
3558 /// Creates a fix-it to insert a C-style nullability keyword at \p pointerLoc,
3559 /// taking into account whitespace before and after.
3561  SourceLocation PointerLoc,
3563  assert(PointerLoc.isValid());
3564  if (PointerLoc.isMacroID())
3565  return;
3566 
3567  SourceLocation FixItLoc = S.getLocForEndOfToken(PointerLoc);
3568  if (!FixItLoc.isValid() || FixItLoc == PointerLoc)
3569  return;
3570 
3571  const char *NextChar = S.SourceMgr.getCharacterData(FixItLoc);
3572  if (!NextChar)
3573  return;
3574 
3575  SmallString<32> InsertionTextBuf{" "};
3576  InsertionTextBuf += getNullabilitySpelling(Nullability);
3577  InsertionTextBuf += " ";
3578  StringRef InsertionText = InsertionTextBuf.str();
3579 
3580  if (isWhitespace(*NextChar)) {
3581  InsertionText = InsertionText.drop_back();
3582  } else if (NextChar[-1] == '[') {
3583  if (NextChar[0] == ']')
3584  InsertionText = InsertionText.drop_back().drop_front();
3585  else
3586  InsertionText = InsertionText.drop_front();
3587  } else if (!isIdentifierBody(NextChar[0], /*allow dollar*/true) &&
3588  !isIdentifierBody(NextChar[-1], /*allow dollar*/true)) {
3589  InsertionText = InsertionText.drop_back().drop_front();
3590  }
3591 
3592  Diag << FixItHint::CreateInsertion(FixItLoc, InsertionText);
3593 }
3594 
3596  SimplePointerKind PointerKind,
3597  SourceLocation PointerLoc,
3598  SourceLocation PointerEndLoc) {
3599  assert(PointerLoc.isValid());
3600 
3601  if (PointerKind == SimplePointerKind::Array) {
3602  S.Diag(PointerLoc, diag::warn_nullability_missing_array);
3603  } else {
3604  S.Diag(PointerLoc, diag::warn_nullability_missing)
3605  << static_cast<unsigned>(PointerKind);
3606  }
3607 
3608  auto FixItLoc = PointerEndLoc.isValid() ? PointerEndLoc : PointerLoc;
3609  if (FixItLoc.isMacroID())
3610  return;
3611 
3612  auto addFixIt = [&](NullabilityKind Nullability) {
3613  auto Diag = S.Diag(FixItLoc, diag::note_nullability_fix_it);
3614  Diag << static_cast<unsigned>(Nullability);
3615  Diag << static_cast<unsigned>(PointerKind);
3616  fixItNullability(S, Diag, FixItLoc, Nullability);
3617  };
3618  addFixIt(NullabilityKind::Nullable);
3619  addFixIt(NullabilityKind::NonNull);
3620 }
3621 
3622 /// Complains about missing nullability if the file containing \p pointerLoc
3623 /// has other uses of nullability (either the keywords or the \c assume_nonnull
3624 /// pragma).
3625 ///
3626 /// If the file has \e not seen other uses of nullability, this particular
3627 /// pointer is saved for possible later diagnosis. See recordNullabilitySeen().
3628 static void
3630  SourceLocation pointerLoc,
3631  SourceLocation pointerEndLoc = SourceLocation()) {
3632  // Determine which file we're performing consistency checking for.
3633  FileID file = getNullabilityCompletenessCheckFileID(S, pointerLoc);
3634  if (file.isInvalid())
3635  return;
3636 
3637  // If we haven't seen any type nullability in this file, we won't warn now
3638  // about anything.
3639  FileNullability &fileNullability = S.NullabilityMap[file];
3640  if (!fileNullability.SawTypeNullability) {
3641  // If this is the first pointer declarator in the file, and the appropriate
3642  // warning is on, record it in case we need to diagnose it retroactively.
3643  diag::kind diagKind;
3644  if (pointerKind == SimplePointerKind::Array)
3645  diagKind = diag::warn_nullability_missing_array;
3646  else
3647  diagKind = diag::warn_nullability_missing;
3648 
3649  if (fileNullability.PointerLoc.isInvalid() &&
3650  !S.Context.getDiagnostics().isIgnored(diagKind, pointerLoc)) {
3651  fileNullability.PointerLoc = pointerLoc;
3652  fileNullability.PointerEndLoc = pointerEndLoc;
3653  fileNullability.PointerKind = static_cast<unsigned>(pointerKind);
3654  }
3655 
3656  return;
3657  }
3658 
3659  // Complain about missing nullability.
3660  emitNullabilityConsistencyWarning(S, pointerKind, pointerLoc, pointerEndLoc);
3661 }
3662 
3663 /// Marks that a nullability feature has been used in the file containing
3664 /// \p loc.
3665 ///
3666 /// If this file already had pointer types in it that were missing nullability,
3667 /// the first such instance is retroactively diagnosed.
3668 ///
3669 /// \sa checkNullabilityConsistency
3672  if (file.isInvalid())
3673  return;
3674 
3675  FileNullability &fileNullability = S.NullabilityMap[file];
3676  if (fileNullability.SawTypeNullability)
3677  return;
3678  fileNullability.SawTypeNullability = true;
3679 
3680  // If we haven't seen any type nullability before, now we have. Retroactively
3681  // diagnose the first unannotated pointer, if there was one.
3682  if (fileNullability.PointerLoc.isInvalid())
3683  return;
3684 
3685  auto kind = static_cast<SimplePointerKind>(fileNullability.PointerKind);
3687  fileNullability.PointerEndLoc);
3688 }
3689 
3690 /// Returns true if any of the declarator chunks before \p endIndex include a
3691 /// level of indirection: array, pointer, reference, or pointer-to-member.
3692 ///
3693 /// Because declarator chunks are stored in outer-to-inner order, testing
3694 /// every chunk before \p endIndex is testing all chunks that embed the current
3695 /// chunk as part of their type.
3696 ///
3697 /// It is legal to pass the result of Declarator::getNumTypeObjects() as the
3698 /// end index, in which case all chunks are tested.
3699 static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex) {
3700  unsigned i = endIndex;
3701  while (i != 0) {
3702  // Walk outwards along the declarator chunks.
3703  --i;
3704  const DeclaratorChunk &DC = D.getTypeObject(i);
3705  switch (DC.Kind) {
3707  break;
3712  return true;
3715  case DeclaratorChunk::Pipe:
3716  // These are invalid anyway, so just ignore.
3717  break;
3718  }
3719  }
3720  return false;
3721 }
3722 
3723 static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
3724  QualType declSpecType,
3725  TypeSourceInfo *TInfo) {
3726  // The TypeSourceInfo that this function returns will not be a null type.
3727  // If there is an error, this function will fill in a dummy type as fallback.
3728  QualType T = declSpecType;
3729  Declarator &D = state.getDeclarator();
3730  Sema &S = state.getSema();
3731  ASTContext &Context = S.Context;
3732  const LangOptions &LangOpts = S.getLangOpts();
3733 
3734  // The name we're declaring, if any.
3735  DeclarationName Name;
3736  if (D.getIdentifier())
3737  Name = D.getIdentifier();
3738 
3739  // Does this declaration declare a typedef-name?
3740  bool IsTypedefName =
3744 
3745  // Does T refer to a function type with a cv-qualifier or a ref-qualifier?
3746  bool IsQualifiedFunction = T->isFunctionProtoType() &&
3747  (T->castAs<FunctionProtoType>()->getTypeQuals() != 0 ||
3748  T->castAs<FunctionProtoType>()->getRefQualifier() != RQ_None);
3749 
3750  // If T is 'decltype(auto)', the only declarators we can have are parens
3751  // and at most one function declarator if this is a function declaration.
3752  // If T is a deduced class template specialization type, we can have no
3753  // declarator chunks at all.
3754  if (auto *DT = T->getAs<DeducedType>()) {
3755  const AutoType *AT = T->getAs<AutoType>();
3756  bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
3757  if ((AT && AT->isDecltypeAuto()) || IsClassTemplateDeduction) {
3758  for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
3759  unsigned Index = E - I - 1;
3760  DeclaratorChunk &DeclChunk = D.getTypeObject(Index);
3761  unsigned DiagId = IsClassTemplateDeduction
3762  ? diag::err_deduced_class_template_compound_type
3763  : diag::err_decltype_auto_compound_type;
3764  unsigned DiagKind = 0;
3765  switch (DeclChunk.Kind) {
3767  // FIXME: Rejecting this is a little silly.
3768  if (IsClassTemplateDeduction) {
3769  DiagKind = 4;
3770  break;
3771  }
3772  continue;
3774  if (IsClassTemplateDeduction) {
3775  DiagKind = 3;
3776  break;
3777  }
3778  unsigned FnIndex;
3779  if (D.isFunctionDeclarationContext() &&
3780  D.isFunctionDeclarator(FnIndex) && FnIndex == Index)
3781  continue;
3782  DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
3783  break;
3784  }
3788  DiagKind = 0;
3789  break;
3791  DiagKind = 1;
3792  break;
3794  DiagKind = 2;
3795  break;
3796  case DeclaratorChunk::Pipe:
3797  break;
3798  }
3799 
3800  S.Diag(DeclChunk.Loc, DiagId) << DiagKind;
3801  D.setInvalidType(true);
3802  break;
3803  }
3804  }
3805  }
3806 
3807  // Determine whether we should infer _Nonnull on pointer types.
3808  Optional<NullabilityKind> inferNullability;
3809  bool inferNullabilityCS = false;
3810  bool inferNullabilityInnerOnly = false;
3811  bool inferNullabilityInnerOnlyComplete = false;
3812 
3813  // Are we in an assume-nonnull region?
3814  bool inAssumeNonNullRegion = false;
3815  SourceLocation assumeNonNullLoc = S.PP.getPragmaAssumeNonNullLoc();
3816  if (assumeNonNullLoc.isValid()) {
3817  inAssumeNonNullRegion = true;
3818  recordNullabilitySeen(S, assumeNonNullLoc);
3819  }
3820 
3821  // Whether to complain about missing nullability specifiers or not.
3822  enum {
3823  /// Never complain.
3824  CAMN_No,
3825  /// Complain on the inner pointers (but not the outermost
3826  /// pointer).
3827  CAMN_InnerPointers,
3828  /// Complain about any pointers that don't have nullability
3829  /// specified or inferred.
3830  CAMN_Yes
3831  } complainAboutMissingNullability = CAMN_No;
3832  unsigned NumPointersRemaining = 0;
3833  auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
3834 
3835  if (IsTypedefName) {
3836  // For typedefs, we do not infer any nullability (the default),
3837  // and we only complain about missing nullability specifiers on
3838  // inner pointers.
3839  complainAboutMissingNullability = CAMN_InnerPointers;
3840 
3841  if (T->canHaveNullability(/*ResultIfUnknown*/false) &&
3842  !T->getNullability(S.Context)) {
3843  // Note that we allow but don't require nullability on dependent types.
3844  ++NumPointersRemaining;
3845  }
3846 
3847  for (unsigned i = 0, n = D.getNumTypeObjects(); i != n; ++i) {
3848  DeclaratorChunk &chunk = D.getTypeObject(i);
3849  switch (chunk.Kind) {
3852  case DeclaratorChunk::Pipe:
3853  break;
3854 
3857  ++NumPointersRemaining;
3858  break;
3859 
3862  continue;
3863 
3865  ++NumPointersRemaining;
3866  continue;
3867  }
3868  }
3869  } else {
3870  bool isFunctionOrMethod = false;
3871  switch (auto context = state.getDeclarator().getContext()) {
3876  isFunctionOrMethod = true;
3877  // fallthrough
3878 
3880  if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) {
3881  complainAboutMissingNullability = CAMN_No;
3882  break;
3883  }
3884 
3885  // Weak properties are inferred to be nullable.
3886  if (state.getDeclarator().isObjCWeakProperty() && inAssumeNonNullRegion) {
3887  inferNullability = NullabilityKind::Nullable;
3888  break;
3889  }
3890 
3891  // fallthrough
3892 
3895  complainAboutMissingNullability = CAMN_Yes;
3896 
3897  // Nullability inference depends on the type and declarator.
3898  auto wrappingKind = PointerWrappingDeclaratorKind::None;
3899  switch (classifyPointerDeclarator(S, T, D, wrappingKind)) {
3900  case PointerDeclaratorKind::NonPointer:
3901  case PointerDeclaratorKind::MultiLevelPointer:
3902  // Cannot infer nullability.
3903  break;
3904 
3905  case PointerDeclaratorKind::SingleLevelPointer:
3906  // Infer _Nonnull if we are in an assumes-nonnull region.
3907  if (inAssumeNonNullRegion) {
3908  complainAboutInferringWithinChunk = wrappingKind;
3909  inferNullability = NullabilityKind::NonNull;
3910  inferNullabilityCS = (context == Declarator::ObjCParameterContext ||
3911  context == Declarator::ObjCResultContext);
3912  }
3913  break;
3914 
3915  case PointerDeclaratorKind::CFErrorRefPointer:
3916  case PointerDeclaratorKind::NSErrorPointerPointer:
3917  // Within a function or method signature, infer _Nullable at both
3918  // levels.
3919  if (isFunctionOrMethod && inAssumeNonNullRegion)
3920  inferNullability = NullabilityKind::Nullable;
3921  break;
3922 
3923  case PointerDeclaratorKind::MaybePointerToCFRef:
3924  if (isFunctionOrMethod) {
3925  // On pointer-to-pointer parameters marked cf_returns_retained or
3926  // cf_returns_not_retained, if the outer pointer is explicit then
3927  // infer the inner pointer as _Nullable.
3928  auto hasCFReturnsAttr = [](const AttributeList *NextAttr) -> bool {
3929  while (NextAttr) {
3930  if (NextAttr->getKind() == AttributeList::AT_CFReturnsRetained ||
3931  NextAttr->getKind() == AttributeList::AT_CFReturnsNotRetained)
3932  return true;
3933  NextAttr = NextAttr->getNext();
3934  }
3935  return false;
3936  };
3937  if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) {
3938  if (hasCFReturnsAttr(D.getAttributes()) ||
3939  hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
3940  hasCFReturnsAttr(D.getDeclSpec().getAttributes().getList())) {
3941  inferNullability = NullabilityKind::Nullable;
3942  inferNullabilityInnerOnly = true;
3943  }
3944  }
3945  }
3946  break;
3947  }
3948  break;
3949  }
3950 
3952  complainAboutMissingNullability = CAMN_Yes;
3953  break;
3954 
3971  // Don't infer in these contexts.
3972  break;
3973  }
3974  }
3975 
3976  // Local function that returns true if its argument looks like a va_list.
3977  auto isVaList = [&S](QualType T) -> bool {
3978  auto *typedefTy = T->getAs<TypedefType>();
3979  if (!typedefTy)
3980  return false;
3981  TypedefDecl *vaListTypedef = S.Context.getBuiltinVaListDecl();
3982  do {
3983  if (typedefTy->getDecl() == vaListTypedef)
3984  return true;
3985  if (auto *name = typedefTy->getDecl()->getIdentifier())
3986  if (name->isStr("va_list"))
3987  return true;
3988  typedefTy = typedefTy->desugar()->getAs<TypedefType>();
3989  } while (typedefTy);
3990  return false;
3991  };
3992 
3993  // Local function that checks the nullability for a given pointer declarator.
3994  // Returns true if _Nonnull was inferred.
3995  auto inferPointerNullability = [&](SimplePointerKind pointerKind,
3996  SourceLocation pointerLoc,
3997  SourceLocation pointerEndLoc,
3998  AttributeList *&attrs) -> AttributeList * {
3999  // We've seen a pointer.
4000  if (NumPointersRemaining > 0)
4001  --NumPointersRemaining;
4002 
4003  // If a nullability attribute is present, there's nothing to do.
4004  if (hasNullabilityAttr(attrs))
4005  return nullptr;
4006 
4007  // If we're supposed to infer nullability, do so now.
4008  if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4009  AttributeList::Syntax syntax
4010  = inferNullabilityCS ? AttributeList::AS_ContextSensitiveKeyword
4012  AttributeList *nullabilityAttr = state.getDeclarator().getAttributePool()
4013  .create(
4015  *inferNullability),
4016  SourceRange(pointerLoc),
4017  nullptr, SourceLocation(),
4018  nullptr, 0, syntax);
4019 
4020  spliceAttrIntoList(*nullabilityAttr, attrs);
4021 
4022  if (inferNullabilityCS) {
4023  state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4024  ->setObjCDeclQualifier(ObjCDeclSpec::DQ_CSNullability);
4025  }
4026 
4027  if (pointerLoc.isValid() &&
4028  complainAboutInferringWithinChunk !=
4030  auto Diag =
4031  S.Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4032  Diag << static_cast<int>(complainAboutInferringWithinChunk);
4034  }
4035 
4036  if (inferNullabilityInnerOnly)
4037  inferNullabilityInnerOnlyComplete = true;
4038  return nullabilityAttr;
4039  }
4040 
4041  // If we're supposed to complain about missing nullability, do so
4042  // now if it's truly missing.
4043  switch (complainAboutMissingNullability) {
4044  case CAMN_No:
4045  break;
4046 
4047  case CAMN_InnerPointers:
4048  if (NumPointersRemaining == 0)
4049  break;
4050  // Fallthrough.
4051 
4052  case CAMN_Yes:
4053  checkNullabilityConsistency(S, pointerKind, pointerLoc, pointerEndLoc);
4054  }
4055  return nullptr;
4056  };
4057 
4058  // If the type itself could have nullability but does not, infer pointer
4059  // nullability and perform consistency checking.
4060  if (S.CodeSynthesisContexts.empty()) {
4061  if (T->canHaveNullability(/*ResultIfUnknown*/false) &&
4062  !T->getNullability(S.Context)) {
4063  if (isVaList(T)) {
4064  // Record that we've seen a pointer, but do nothing else.
4065  if (NumPointersRemaining > 0)
4066  --NumPointersRemaining;
4067  } else {
4068  SimplePointerKind pointerKind = SimplePointerKind::Pointer;
4069  if (T->isBlockPointerType())
4070  pointerKind = SimplePointerKind::BlockPointer;
4071  else if (T->isMemberPointerType())
4072  pointerKind = SimplePointerKind::MemberPointer;
4073 
4074  if (auto *attr = inferPointerNullability(
4075  pointerKind, D.getDeclSpec().getTypeSpecTypeLoc(),
4076  D.getDeclSpec().getLocEnd(),
4078  T = Context.getAttributedType(
4079  AttributedType::getNullabilityAttrKind(*inferNullability),T,T);
4080  attr->setUsedAsTypeAttr();
4081  }
4082  }
4083  }
4084 
4085  if (complainAboutMissingNullability == CAMN_Yes &&
4086  T->isArrayType() && !T->getNullability(S.Context) && !isVaList(T) &&
4087  D.isPrototypeContext() &&
4089  checkNullabilityConsistency(S, SimplePointerKind::Array,
4091  }
4092  }
4093 
4094  // Walk the DeclTypeInfo, building the recursive type as we go.
4095  // DeclTypeInfos are ordered from the identifier out, which is
4096  // opposite of what we want :).
4097  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
4098  unsigned chunkIndex = e - i - 1;
4099  state.setCurrentChunkIndex(chunkIndex);
4100  DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex);
4101  IsQualifiedFunction &= DeclType.Kind == DeclaratorChunk::Paren;
4102  switch (DeclType.Kind) {
4104  if (i == 0)
4105  warnAboutRedundantParens(S, D, T);
4106  T = S.BuildParenType(T);
4107  break;
4109  // If blocks are disabled, emit an error.
4110  if (!LangOpts.Blocks)
4111  S.Diag(DeclType.Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4112 
4113  // Handle pointer nullability.
4114  inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.Loc,
4115  DeclType.EndLoc, DeclType.getAttrListRef());
4116 
4117  T = S.BuildBlockPointerType(T, D.getIdentifierLoc(), Name);
4118  if (DeclType.Cls.TypeQuals || LangOpts.OpenCL) {
4119  // OpenCL v2.0, s6.12.5 - Block variable declarations are implicitly
4120  // qualified with const.
4121  if (LangOpts.OpenCL)
4122  DeclType.Cls.TypeQuals |= DeclSpec::TQ_const;
4123  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Cls.TypeQuals);
4124  }
4125  break;
4127  // Verify that we're not building a pointer to pointer to function with
4128  // exception specification.
4129  if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4130  S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4131  D.setInvalidType(true);
4132  // Build the type anyway.
4133  }
4134 
4135  // Handle pointer nullability
4136  inferPointerNullability(SimplePointerKind::Pointer, DeclType.Loc,
4137  DeclType.EndLoc, DeclType.getAttrListRef());
4138 
4139  if (LangOpts.ObjC1 && T->getAs<ObjCObjectType>()) {
4140  T = Context.getObjCObjectPointerType(T);
4141  if (DeclType.Ptr.TypeQuals)
4142  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
4143  break;
4144  }
4145 
4146  // OpenCL v2.0 s6.9b - Pointer to image/sampler cannot be used.
4147  // OpenCL v2.0 s6.13.16.1 - Pointer to pipe cannot be used.
4148  // OpenCL v2.0 s6.12.5 - Pointers to Blocks are not allowed.
4149  if (LangOpts.OpenCL) {
4150  if (T->isImageType() || T->isSamplerT() || T->isPipeType() ||
4151  T->isBlockPointerType()) {
4152  S.Diag(D.getIdentifierLoc(), diag::err_opencl_pointer_to_type) << T;
4153  D.setInvalidType(true);
4154  }
4155  }
4156 
4157  T = S.BuildPointerType(T, DeclType.Loc, Name);
4158  if (DeclType.Ptr.TypeQuals)
4159  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
4160  break;
4162  // Verify that we're not building a reference to pointer to function with
4163  // exception specification.
4164  if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4165  S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4166  D.setInvalidType(true);
4167  // Build the type anyway.
4168  }
4169  T = S.BuildReferenceType(T, DeclType.Ref.LValueRef, DeclType.Loc, Name);
4170 
4171  if (DeclType.Ref.HasRestrict)
4172  T = S.BuildQualifiedType(T, DeclType.Loc, Qualifiers::Restrict);
4173  break;
4174  }
4175  case DeclaratorChunk::Array: {
4176  // Verify that we're not building an array of pointers to function with
4177  // exception specification.
4178  if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) {
4179  S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
4180  D.setInvalidType(true);
4181  // Build the type anyway.
4182  }
4183  DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
4184  Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
4186  if (ATI.isStar)
4187  ASM = ArrayType::Star;
4188  else if (ATI.hasStatic)
4189  ASM = ArrayType::Static;
4190  else
4191  ASM = ArrayType::Normal;
4192  if (ASM == ArrayType::Star && !D.isPrototypeContext()) {
4193  // FIXME: This check isn't quite right: it allows star in prototypes
4194  // for function definitions, and disallows some edge cases detailed
4195  // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html
4196  S.Diag(DeclType.Loc, diag::err_array_star_outside_prototype);
4197  ASM = ArrayType::Normal;
4198  D.setInvalidType(true);
4199  }
4200 
4201  // C99 6.7.5.2p1: The optional type qualifiers and the keyword static
4202  // shall appear only in a declaration of a function parameter with an
4203  // array type, ...
4204  if (ASM == ArrayType::Static || ATI.TypeQuals) {
4205  if (!(D.isPrototypeContext() ||
4207  S.Diag(DeclType.Loc, diag::err_array_static_outside_prototype) <<
4208  (ASM == ArrayType::Static ? "'static'" : "type qualifier");
4209  // Remove the 'static' and the type qualifiers.
4210  if (ASM == ArrayType::Static)
4211  ASM = ArrayType::Normal;
4212  ATI.TypeQuals = 0;
4213  D.setInvalidType(true);
4214  }
4215 
4216  // C99 6.7.5.2p1: ... and then only in the outermost array type
4217  // derivation.
4218  if (hasOuterPointerLikeChunk(D, chunkIndex)) {
4219  S.Diag(DeclType.Loc, diag::err_array_static_not_outermost) <<
4220  (ASM == ArrayType::Static ? "'static'" : "type qualifier");
4221  if (ASM == ArrayType::Static)
4222  ASM = ArrayType::Normal;
4223  ATI.TypeQuals = 0;
4224  D.setInvalidType(true);
4225  }
4226  }
4227  const AutoType *AT = T->getContainedAutoType();
4228  // Allow arrays of auto if we are a generic lambda parameter.
4229  // i.e. [](auto (&array)[5]) { return array[0]; }; OK
4231  // We've already diagnosed this for decltype(auto).
4232  if (!AT->isDecltypeAuto())
4233  S.Diag(DeclType.Loc, diag::err_illegal_decl_array_of_auto)
4234  << getPrintableNameForEntity(Name) << T;
4235  T = QualType();
4236  break;
4237  }
4238 
4239  // Array parameters can be marked nullable as well, although it's not
4240  // necessary if they're marked 'static'.
4241  if (complainAboutMissingNullability == CAMN_Yes &&
4242  !hasNullabilityAttr(DeclType.getAttrs()) &&
4243  ASM != ArrayType::Static &&
4244  D.isPrototypeContext() &&
4245  !hasOuterPointerLikeChunk(D, chunkIndex)) {
4246  checkNullabilityConsistency(S, SimplePointerKind::Array, DeclType.Loc);
4247  }
4248 
4249  T = S.BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals,
4250  SourceRange(DeclType.Loc, DeclType.EndLoc), Name);
4251  break;
4252  }
4254  // If the function declarator has a prototype (i.e. it is not () and
4255  // does not have a K&R-style identifier list), then the arguments are part
4256  // of the type, otherwise the argument list is ().
4257  const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
4258  IsQualifiedFunction = FTI.TypeQuals || FTI.hasRefQualifier();
4259 
4260  // Check for auto functions and trailing return type and adjust the
4261  // return type accordingly.
4262  if (!D.isInvalidType()) {
4263  // trailing-return-type is only required if we're declaring a function,
4264  // and not, for instance, a pointer to a function.
4265  if (D.getDeclSpec().hasAutoTypeSpec() &&
4266  !FTI.hasTrailingReturnType() && chunkIndex == 0 &&
4267  !S.getLangOpts().CPlusPlus14) {
4270  ? diag::err_auto_missing_trailing_return
4271  : diag::err_deduced_return_type);
4272  T = Context.IntTy;
4273  D.setInvalidType(true);
4274  } else if (FTI.hasTrailingReturnType()) {
4275  // T must be exactly 'auto' at this point. See CWG issue 681.
4276  if (isa<ParenType>(T)) {
4277  S.Diag(D.getLocStart(),
4278  diag::err_trailing_return_in_parens)
4279  << T << D.getSourceRange();
4280  D.setInvalidType(true);
4281  } else if (D.getName().getKind() ==
4283  if (T != Context.DependentTy) {
4284  S.Diag(D.getDeclSpec().getLocStart(),
4285  diag::err_deduction_guide_with_complex_decl)
4286  << D.getSourceRange();
4287  D.setInvalidType(true);
4288  }
4289  } else if (D.getContext() != Declarator::LambdaExprContext &&
4290  (T.hasQualifiers() || !isa<AutoType>(T) ||
4291  cast<AutoType>(T)->getKeyword() !=
4294  diag::err_trailing_return_without_auto)
4295  << T << D.getDeclSpec().getSourceRange();
4296  D.setInvalidType(true);
4297  }
4298  T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo);
4299  if (T.isNull()) {
4300  // An error occurred parsing the trailing return type.
4301  T = Context.IntTy;
4302  D.setInvalidType(true);
4303  }
4304  }
4305  }
4306 
4307  // C99 6.7.5.3p1: The return type may not be a function or array type.
4308  // For conversion functions, we'll diagnose this particular error later.
4309  if (!D.isInvalidType() && (T->isArrayType() || T->isFunctionType()) &&
4311  unsigned diagID = diag::err_func_returning_array_function;
4312  // Last processing chunk in block context means this function chunk
4313  // represents the block.
4314  if (chunkIndex == 0 &&
4316  diagID = diag::err_block_returning_array_function;
4317  S.Diag(DeclType.Loc, diagID) << T->isFunctionType() << T;
4318  T = Context.IntTy;
4319  D.setInvalidType(true);
4320  }
4321 
4322  // Do not allow returning half FP value.
4323  // FIXME: This really should be in BuildFunctionType.
4324  if (T->isHalfType()) {
4325  if (S.getLangOpts().OpenCL) {
4326  if (!S.getOpenCLOptions().isEnabled("cl_khr_fp16")) {
4327  S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4328  << T << 0 /*pointer hint*/;
4329  D.setInvalidType(true);
4330  }
4331  } else if (!S.getLangOpts().HalfArgsAndReturns) {
4332  S.Diag(D.getIdentifierLoc(),
4333  diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4334  D.setInvalidType(true);
4335  }
4336  }
4337 
4338  if (LangOpts.OpenCL) {
4339  // OpenCL v2.0 s6.12.5 - A block cannot be the return value of a
4340  // function.
4341  if (T->isBlockPointerType() || T->isImageType() || T->isSamplerT() ||
4342  T->isPipeType()) {
4343  S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4344  << T << 1 /*hint off*/;
4345  D.setInvalidType(true);
4346  }
4347  // OpenCL doesn't support variadic functions and blocks
4348  // (s6.9.e and s6.12.5 OpenCL v2.0) except for printf.
4349  // We also allow here any toolchain reserved identifiers.
4350  if (FTI.isVariadic &&
4351  !(D.getIdentifier() &&
4352  ((D.getIdentifier()->getName() == "printf" &&
4353  LangOpts.OpenCLVersion >= 120) ||
4354  D.getIdentifier()->getName().startswith("__")))) {
4355  S.Diag(D.getIdentifierLoc(), diag::err_opencl_variadic_function);
4356  D.setInvalidType(true);
4357  }
4358  }
4359 
4360  // Methods cannot return interface types. All ObjC objects are
4361  // passed by reference.
4362  if (T->isObjCObjectType()) {
4363  SourceLocation DiagLoc, FixitLoc;
4364  if (TInfo) {
4365  DiagLoc = TInfo->getTypeLoc().getLocStart();
4366  FixitLoc = S.getLocForEndOfToken(TInfo->getTypeLoc().getLocEnd());
4367  } else {
4368  DiagLoc = D.getDeclSpec().getTypeSpecTypeLoc();
4369  FixitLoc = S.getLocForEndOfToken(D.getDeclSpec().getLocEnd());
4370  }
4371  S.Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
4372  << 0 << T
4373  << FixItHint::CreateInsertion(FixitLoc, "*");
4374 
4375  T = Context.getObjCObjectPointerType(T);
4376  if (TInfo) {
4377  TypeLocBuilder TLB;
4378  TLB.pushFullCopy(TInfo->getTypeLoc());
4380  TLoc.setStarLoc(FixitLoc);
4381  TInfo = TLB.getTypeSourceInfo(Context, T);
4382  }
4383 
4384  D.setInvalidType(true);
4385  }
4386 
4387  // cv-qualifiers on return types are pointless except when the type is a
4388  // class type in C++.
4389  if ((T.getCVRQualifiers() || T->isAtomicType()) &&
4390  !(S.getLangOpts().CPlusPlus &&
4391  (T->isDependentType() || T->isRecordType()))) {
4392  if (T->isVoidType() && !S.getLangOpts().CPlusPlus &&
4394  // [6.9.1/3] qualified void return is invalid on a C
4395  // function definition. Apparently ok on declarations and
4396  // in C++ though (!)
4397  S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T;
4398  } else
4399  diagnoseRedundantReturnTypeQualifiers(S, T, D, chunkIndex);
4400  }
4401 
4402  // Objective-C ARC ownership qualifiers are ignored on the function
4403  // return type (by type canonicalization). Complain if this attribute
4404  // was written here.
4405  if (T.getQualifiers().hasObjCLifetime()) {
4406  SourceLocation AttrLoc;
4407  if (chunkIndex + 1 < D.getNumTypeObjects()) {
4408  DeclaratorChunk ReturnTypeChunk = D.getTypeObject(chunkIndex + 1);
4409  for (const AttributeList *Attr = ReturnTypeChunk.getAttrs();
4410  Attr; Attr = Attr->getNext()) {
4411  if (Attr->getKind() == AttributeList::AT_ObjCOwnership) {
4412  AttrLoc = Attr->getLoc();
4413  break;
4414  }
4415  }
4416  }
4417  if (AttrLoc.isInvalid()) {
4418  for (const AttributeList *Attr
4419  = D.getDeclSpec().getAttributes().getList();
4420  Attr; Attr = Attr->getNext()) {
4421  if (Attr->getKind() == AttributeList::AT_ObjCOwnership) {
4422  AttrLoc = Attr->getLoc();
4423  break;
4424  }
4425  }
4426  }
4427 
4428  if (AttrLoc.isValid()) {
4429  // The ownership attributes are almost always written via
4430  // the predefined
4431  // __strong/__weak/__autoreleasing/__unsafe_unretained.
4432  if (AttrLoc.isMacroID())
4433  AttrLoc = S.SourceMgr.getImmediateExpansionRange(AttrLoc).first;
4434 
4435  S.Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
4436  << T.getQualifiers().getObjCLifetime();
4437  }
4438  }
4439 
4440  if (LangOpts.CPlusPlus && D.getDeclSpec().hasTagDefinition()) {
4441  // C++ [dcl.fct]p6:
4442  // Types shall not be defined in return or parameter types.
4443  TagDecl *Tag = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
4444  S.Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
4445  << Context.getTypeDeclType(Tag);
4446  }
4447 
4448  // Exception specs are not allowed in typedefs. Complain, but add it
4449  // anyway.
4450  if (IsTypedefName && FTI.getExceptionSpecType() && !LangOpts.CPlusPlus1z)
4451  S.Diag(FTI.getExceptionSpecLocBeg(),
4452  diag::err_exception_spec_in_typedef)
4455 
4456  // If we see "T var();" or "T var(T());" at block scope, it is probably
4457  // an attempt to initialize a variable, not a function declaration.
4458  if (FTI.isAmbiguous)
4459  warnAboutAmbiguousFunction(S, D, DeclType, T);
4460 
4461  FunctionType::ExtInfo EI(getCCForDeclaratorChunk(S, D, FTI, chunkIndex));
4462 
4463  if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.CPlusPlus
4464  && !LangOpts.OpenCL) {
4465  // Simple void foo(), where the incoming T is the result type.
4466  T = Context.getFunctionNoProtoType(T, EI);
4467  } else {
4468  // We allow a zero-parameter variadic function in C if the
4469  // function is marked with the "overloadable" attribute. Scan
4470  // for this attribute now.
4471  if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus) {
4472  bool Overloadable = false;
4473  for (const AttributeList *Attrs = D.getAttributes();
4474  Attrs; Attrs = Attrs->getNext()) {
4475  if (Attrs->getKind() == AttributeList::AT_Overloadable) {
4476  Overloadable = true;
4477  break;
4478  }
4479  }
4480 
4481  if (!Overloadable)
4482  S.Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_param);
4483  }
4484 
4485  if (FTI.NumParams && FTI.Params[0].Param == nullptr) {
4486  // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function
4487  // definition.
4488  S.Diag(FTI.Params[0].IdentLoc,
4489  diag::err_ident_list_in_fn_declaration);
4490  D.setInvalidType(true);
4491  // Recover by creating a K&R-style function type.
4492  T = Context.getFunctionNoProtoType(T, EI);
4493  break;
4494  }
4495 
4497  EPI.ExtInfo = EI;
4498  EPI.Variadic = FTI.isVariadic;
4500  EPI.TypeQuals = FTI.TypeQuals;
4501  EPI.RefQualifier = !FTI.hasRefQualifier()? RQ_None
4503  : RQ_RValue;
4504 
4505  // Otherwise, we have a function with a parameter list that is
4506  // potentially variadic.
4507  SmallVector<QualType, 16> ParamTys;
4508  ParamTys.reserve(FTI.NumParams);
4509 
4511  ExtParameterInfos(FTI.NumParams);
4512  bool HasAnyInterestingExtParameterInfos = false;
4513 
4514  for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
4515  ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
4516  QualType ParamTy = Param->getType();
4517  assert(!ParamTy.isNull() && "Couldn't parse type?");
4518 
4519  // Look for 'void'. void is allowed only as a single parameter to a
4520  // function with no other parameters (C99 6.7.5.3p10). We record
4521  // int(void) as a FunctionProtoType with an empty parameter list.
4522  if (ParamTy->isVoidType()) {
4523  // If this is something like 'float(int, void)', reject it. 'void'
4524  // is an incomplete type (C99 6.2.5p19) and function decls cannot
4525  // have parameters of incomplete type.
4526  if (FTI.NumParams != 1 || FTI.isVariadic) {
4527  S.Diag(DeclType.Loc, diag::err_void_only_param);
4528  ParamTy = Context.IntTy;
4529  Param->setType(ParamTy);
4530  } else if (FTI.Params[i].Ident) {
4531  // Reject, but continue to parse 'int(void abc)'.
4532  S.Diag(FTI.Params[i].IdentLoc, diag::err_param_with_void_type);
4533  ParamTy = Context.IntTy;
4534  Param->setType(ParamTy);
4535  } else {
4536  // Reject, but continue to parse 'float(const void)'.
4537  if (ParamTy.hasQualifiers())
4538  S.Diag(DeclType.Loc, diag::err_void_param_qualified);
4539 
4540  // Do not add 'void' to the list.
4541  break;
4542  }
4543  } else if (ParamTy->isHalfType()) {
4544  // Disallow half FP parameters.
4545  // FIXME: This really should be in BuildFunctionType.
4546  if (S.getLangOpts().OpenCL) {
4547  if (!S.getOpenCLOptions().isEnabled("cl_khr_fp16")) {
4548  S.Diag(Param->getLocation(),
4549  diag::err_opencl_half_param) << ParamTy;
4550  D.setInvalidType();
4551  Param->setInvalidDecl();
4552  }
4553  } else if (!S.getLangOpts().HalfArgsAndReturns) {
4554  S.Diag(Param->getLocation(),
4555  diag::err_parameters_retval_cannot_have_fp16_type) << 0;
4556  D.setInvalidType();
4557  }
4558  } else if (!FTI.hasPrototype) {
4559  if (ParamTy->isPromotableIntegerType()) {
4560  ParamTy = Context.getPromotedIntegerType(ParamTy);
4561  Param->setKNRPromoted(true);
4562  } else if (const BuiltinType* BTy = ParamTy->getAs<BuiltinType>()) {
4563  if (BTy->getKind() == BuiltinType::Float) {
4564  ParamTy = Context.DoubleTy;
4565  Param->setKNRPromoted(true);
4566  }
4567  }
4568  }
4569 
4570  if (LangOpts.ObjCAutoRefCount && Param->hasAttr<NSConsumedAttr>()) {
4571  ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(true);
4572  HasAnyInterestingExtParameterInfos = true;
4573  }
4574 
4575  if (auto attr = Param->getAttr<ParameterABIAttr>()) {
4576  ExtParameterInfos[i] =
4577  ExtParameterInfos[i].withABI(attr->getABI());
4578  HasAnyInterestingExtParameterInfos = true;
4579  }
4580 
4581  if (Param->hasAttr<PassObjectSizeAttr>()) {
4582  ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
4583  HasAnyInterestingExtParameterInfos = true;
4584  }
4585 
4586  if (Param->hasAttr<NoEscapeAttr>()) {
4587  ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(true);
4588  HasAnyInterestingExtParameterInfos = true;
4589  }
4590 
4591  ParamTys.push_back(ParamTy);
4592  }
4593 
4594  if (HasAnyInterestingExtParameterInfos) {
4595  EPI.ExtParameterInfos = ExtParameterInfos.data();
4596  checkExtParameterInfos(S, ParamTys, EPI,
4597  [&](unsigned i) { return FTI.Params[i].Param->getLocation(); });
4598  }
4599 
4600  SmallVector<QualType, 4> Exceptions;
4601  SmallVector<ParsedType, 2> DynamicExceptions;
4602  SmallVector<SourceRange, 2> DynamicExceptionRanges;
4603  Expr *NoexceptExpr = nullptr;
4604 
4605  if (FTI.getExceptionSpecType() == EST_Dynamic) {
4606  // FIXME: It's rather inefficient to have to split into two vectors
4607  // here.
4608  unsigned N = FTI.getNumExceptions();
4609  DynamicExceptions.reserve(N);
4610  DynamicExceptionRanges.reserve(N);
4611  for (unsigned I = 0; I != N; ++I) {
4612  DynamicExceptions.push_back(FTI.Exceptions[I].Ty);
4613  DynamicExceptionRanges.push_back(FTI.Exceptions[I].Range);
4614  }
4615  } else if (FTI.getExceptionSpecType() == EST_ComputedNoexcept) {
4616  NoexceptExpr = FTI.NoexceptExpr;
4617  }
4618 
4620  FTI.getExceptionSpecType(),
4621  DynamicExceptions,
4622  DynamicExceptionRanges,
4623  NoexceptExpr,
4624  Exceptions,
4625  EPI.ExceptionSpec);
4626 
4627  T = Context.getFunctionType(T, ParamTys, EPI);
4628  }
4629  break;
4630  }
4632  // The scope spec must refer to a class, or be dependent.
4633  CXXScopeSpec &SS = DeclType.Mem.Scope();
4634  QualType ClsType;
4635 
4636  // Handle pointer nullability.
4637  inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.Loc,
4638  DeclType.EndLoc, DeclType.getAttrListRef());
4639 
4640  if (SS.isInvalid()) {
4641  // Avoid emitting extra errors if we already errored on the scope.
4642  D.setInvalidType(true);
4643  } else if (S.isDependentScopeSpecifier(SS) ||
4644  dyn_cast_or_null<CXXRecordDecl>(S.computeDeclContext(SS))) {
4645  NestedNameSpecifier *NNS = SS.getScopeRep();
4646  NestedNameSpecifier *NNSPrefix = NNS->getPrefix();
4647  switch (NNS->getKind()) {
4649  ClsType = Context.getDependentNameType(ETK_None, NNSPrefix,
4650  NNS->getAsIdentifier());
4651  break;
4652 
4657  llvm_unreachable("Nested-name-specifier must name a type");
4658 
4661  ClsType = QualType(NNS->getAsType(), 0);
4662  // Note: if the NNS has a prefix and ClsType is a nondependent
4663  // TemplateSpecializationType, then the NNS prefix is NOT included
4664  // in ClsType; hence we wrap ClsType into an ElaboratedType.
4665  // NOTE: in particular, no wrap occurs if ClsType already is an
4666  // Elaborated, DependentName, or DependentTemplateSpecialization.
4667  if (NNSPrefix && isa<TemplateSpecializationType>(NNS->getAsType()))
4668  ClsType = Context.getElaboratedType(ETK_None, NNSPrefix, ClsType);
4669  break;
4670  }
4671  } else {
4672  S.Diag(DeclType.Mem.Scope().getBeginLoc(),
4673  diag::err_illegal_decl_mempointer_in_nonclass)
4674  << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
4675  << DeclType.Mem.Scope().getRange();
4676  D.setInvalidType(true);
4677  }
4678 
4679  if (!ClsType.isNull())
4680  T = S.BuildMemberPointerType(T, ClsType, DeclType.Loc,
4681  D.getIdentifier());
4682  if (T.isNull()) {
4683  T = Context.IntTy;
4684  D.setInvalidType(true);
4685  } else if (DeclType.Mem.TypeQuals) {
4686  T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Mem.TypeQuals);
4687  }
4688  break;
4689  }
4690 
4691  case DeclaratorChunk::Pipe: {
4692  T = S.BuildReadPipeType(T, DeclType.Loc);
4693  processTypeAttrs(state, T, TAL_DeclSpec,
4695  break;
4696  }
4697  }
4698 
4699  if (T.isNull()) {
4700  D.setInvalidType(true);
4701  T = Context.IntTy;
4702  }
4703 
4704  // See if there are any attributes on this declarator chunk.
4705  processTypeAttrs(state, T, TAL_DeclChunk,
4706  const_cast<AttributeList *>(DeclType.getAttrs()));
4707  }
4708 
4709  // GNU warning -Wstrict-prototypes
4710  // Warn if a function declaration is without a prototype.
4711  // This warning is issued for all kinds of unprototyped function
4712  // declarations (i.e. function type typedef, function pointer etc.)
4713  // C99 6.7.5.3p14:
4714  // The empty list in a function declarator that is not part of a definition
4715  // of that function specifies that no information about the number or types
4716  // of the parameters is supplied.
4717  if (!LangOpts.CPlusPlus && D.getFunctionDefinitionKind() == FDK_Declaration) {
4718  bool IsBlock = false;
4719  for (const DeclaratorChunk &DeclType : D.type_objects()) {
4720  switch (DeclType.Kind) {
4722  IsBlock = true;
4723  break;
4725  const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
4726  if (FTI.NumParams == 0)
4727  S.Diag(DeclType.Loc, diag::warn_strict_prototypes)
4728  << IsBlock
4729  << FixItHint::CreateInsertion(FTI.getRParenLoc(), "void");
4730  IsBlock = false;
4731  break;
4732  }
4733  default:
4734  break;
4735  }
4736  }
4737  }
4738 
4739  assert(!T.isNull() && "T must not be null after this point");
4740 
4741  if (LangOpts.CPlusPlus && T->isFunctionType()) {
4742  const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>();
4743  assert(FnTy && "Why oh why is there not a FunctionProtoType here?");
4744 
4745  // C++ 8.3.5p4:
4746  // A cv-qualifier-seq shall only be part of the function type
4747  // for a nonstatic member function, the function type to which a pointer
4748  // to member refers, or the top-level function type of a function typedef
4749  // declaration.
4750  //
4751  // Core issue 547 also allows cv-qualifiers on function types that are
4752  // top-level template type arguments.
4753  enum { NonMember, Member, DeductionGuide } Kind = NonMember;
4755  Kind = DeductionGuide;
4756  else if (!D.getCXXScopeSpec().isSet()) {
4757  if ((D.getContext() == Declarator::MemberContext ||
4760  Kind = Member;
4761  } else {
4763  if (!DC || DC->isRecord())
4764  Kind = Member;
4765  }
4766 
4767  // C++11 [dcl.fct]p6 (w/DR1417):
4768  // An attempt to specify a function type with a cv-qualifier-seq or a
4769  // ref-qualifier (including by typedef-name) is ill-formed unless it is:
4770  // - the function type for a non-static member function,
4771  // - the function type to which a pointer to member refers,
4772  // - the top-level function type of a function typedef declaration or
4773  // alias-declaration,
4774  // - the type-id in the default argument of a type-parameter, or
4775  // - the type-id of a template-argument for a type-parameter
4776  //
4777  // FIXME: Checking this here is insufficient. We accept-invalid on:
4778  //
4779  // template<typename T> struct S { void f(T); };
4780  // S<int() const> s;
4781  //
4782  // ... for instance.
4783  if (IsQualifiedFunction &&
4784  !(Kind == Member &&
4786  !IsTypedefName &&
4788  SourceLocation Loc = D.getLocStart();
4789  SourceRange RemovalRange;
4790  unsigned I;
4791  if (D.isFunctionDeclarator(I)) {
4792  SmallVector<SourceLocation, 4> RemovalLocs;
4793  const DeclaratorChunk &Chunk = D.getTypeObject(I);
4794  assert(Chunk.Kind == DeclaratorChunk::Function);
4795  if (Chunk.Fun.hasRefQualifier())
4796  RemovalLocs.push_back(Chunk.Fun.getRefQualifierLoc());
4797  if (Chunk.Fun.TypeQuals & Qualifiers::Const)
4798  RemovalLocs.push_back(Chunk.Fun.getConstQualifierLoc());
4799  if (Chunk.Fun.TypeQuals & Qualifiers::Volatile)
4800  RemovalLocs.push_back(Chunk.Fun.getVolatileQualifierLoc());
4801  if (Chunk.Fun.TypeQuals & Qualifiers::Restrict)
4802  RemovalLocs.push_back(Chunk.Fun.getRestrictQualifierLoc());
4803  if (!RemovalLocs.empty()) {
4804  std::sort(RemovalLocs.begin(), RemovalLocs.end(),
4806  RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back());
4807  Loc = RemovalLocs.front();
4808  }
4809  }
4810 
4811  S.Diag(Loc, diag::err_invalid_qualified_function_type)
4812  << Kind << D.isFunctionDeclarator() << T
4814  << FixItHint::CreateRemoval(RemovalRange);
4815 
4816  // Strip the cv-qualifiers and ref-qualifiers from the type.
4818  EPI.TypeQuals = 0;
4819  EPI.RefQualifier = RQ_None;
4820 
4821  T = Context.getFunctionType(FnTy->getReturnType(), FnTy->getParamTypes(),
4822  EPI);
4823  // Rebuild any parens around the identifier in the function type.
4824  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
4826  break;
4827  T = S.BuildParenType(T);
4828  }
4829  }
4830  }
4831 
4832  // Apply any undistributed attributes from the declarator.
4834 
4835  // Diagnose any ignored type attributes.
4836  state.diagnoseIgnoredTypeAttrs(T);
4837 
4838  // C++0x [dcl.constexpr]p9:
4839  // A constexpr specifier used in an object declaration declares the object
4840  // as const.
4841  if (D.getDeclSpec().isConstexprSpecified() && T->isObjectType()) {
4842  T.addConst();
4843  }
4844 
4845  // If there was an ellipsis in the declarator, the declaration declares a
4846  // parameter pack whose type may be a pack expansion type.
4847  if (D.hasEllipsis()) {
4848  // C++0x [dcl.fct]p13:
4849  // A declarator-id or abstract-declarator containing an ellipsis shall
4850  // only be used in a parameter-declaration. Such a parameter-declaration
4851  // is a parameter pack (14.5.3). [...]
4852  switch (D.getContext()) {
4855  // C++0x [dcl.fct]p13:
4856  // [...] When it is part of a parameter-declaration-clause, the
4857  // parameter pack is a function parameter pack (14.5.3). The type T
4858  // of the declarator-id of the function parameter pack shall contain
4859  // a template parameter pack; each template parameter pack in T is
4860  // expanded by the function parameter pack.
4861  //
4862  // We represent function parameter packs as function parameters whose
4863  // type is a pack expansion.
4864  if (!T->containsUnexpandedParameterPack()) {
4865  S.Diag(D.getEllipsisLoc(),
4866  diag::err_function_parameter_pack_without_parameter_packs)
4867  << T << D.getSourceRange();
4869  } else {
4870  T = Context.getPackExpansionType(T, None);
4871  }
4872  break;
4874  // C++0x [temp.param]p15:
4875  // If a template-parameter is a [...] is a parameter-declaration that
4876  // declares a parameter pack (8.3.5), then the template-parameter is a
4877  // template parameter pack (14.5.3).
4878  //
4879  // Note: core issue 778 clarifies that, if there are any unexpanded
4880  // parameter packs in the type of the non-type template parameter, then
4881  // it expands those parameter packs.
4883  T = Context.getPackExpansionType(T, None);
4884  else
4885  S.Diag(D.getEllipsisLoc(),
4886  LangOpts.CPlusPlus11
4887  ? diag::warn_cxx98_compat_variadic_templates
4888  : diag::ext_variadic_templates);
4889  break;
4890 
4893  case Declarator::ObjCParameterContext: // FIXME: special diagnostic here?
4894  case Declarator::ObjCResultContext: // FIXME: special diagnostic here?
4912  // FIXME: We may want to allow parameter packs in block-literal contexts
4913  // in the future.
4914  S.Diag(D.getEllipsisLoc(),
4915  diag::err_ellipsis_in_declarator_not_parameter);
4917  break;
4918  }
4919  }
4920 
4921  assert(!T.isNull() && "T must not be null at the end of this function");
4922  if (D.isInvalidType())
4923  return Context.getTrivialTypeSourceInfo(T);
4924 
4925  return S.GetTypeSourceInfoForDeclarator(D, T, TInfo);
4926 }
4927 
4928 /// GetTypeForDeclarator - Convert the type for the specified
4929 /// declarator to Type instances.
4930 ///
4931 /// The result of this call will never be null, but the associated
4932 /// type may be a null type if there's an unrecoverable error.
4934  // Determine the type of the declarator. Not all forms of declarator
4935  // have a type.
4936 
4937  TypeProcessingState state(*this, D);
4938 
4939  TypeSourceInfo *ReturnTypeInfo = nullptr;
4940  QualType T = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
4941  if (D.isPrototypeContext() && getLangOpts().ObjCAutoRefCount)
4942  inferARCWriteback(state, T);
4943 
4944  return GetFullTypeForDeclarator(state, T, ReturnTypeInfo);
4945 }
4946 
4948  QualType &declSpecTy,
4949  Qualifiers::ObjCLifetime ownership) {
4950  if (declSpecTy->isObjCRetainableType() &&
4951  declSpecTy.getObjCLifetime() == Qualifiers::OCL_None) {
4952  Qualifiers qs;
4953  qs.addObjCLifetime(ownership);
4954  declSpecTy = S.Context.getQualifiedType(declSpecTy, qs);
4955  }
4956 }
4957 
4958 static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state,
4959  Qualifiers::ObjCLifetime ownership,
4960  unsigned chunkIndex) {
4961  Sema &S = state.getSema();
4962  Declarator &D = state.getDeclarator();
4963 
4964  // Look for an explicit lifetime attribute.
4965  DeclaratorChunk &chunk = D.getTypeObject(chunkIndex);
4966  for (const AttributeList *attr = chunk.getAttrs(); attr;
4967  attr = attr->getNext())
4968  if (attr->getKind() == AttributeList::AT_ObjCOwnership)
4969  return;
4970 
4971  const char *attrStr = nullptr;
4972  switch (ownership) {
4973  case Qualifiers::OCL_None: llvm_unreachable("no ownership!");
4974  case Qualifiers::OCL_ExplicitNone: attrStr = "none"; break;
4975  case Qualifiers::OCL_Strong: attrStr = "strong"; break;
4976  case Qualifiers::OCL_Weak: attrStr = "weak"; break;
4977  case Qualifiers::OCL_Autoreleasing: attrStr = "autoreleasing"; break;
4978  }
4979 
4980  IdentifierLoc *Arg = new (S.Context) IdentifierLoc;
4981  Arg->Ident = &S.Context.Idents.get(attrStr);
4982  Arg->Loc = SourceLocation();
4983 
4984  ArgsUnion Args(Arg);
4985 
4986  // If there wasn't one, add one (with an invalid source location
4987  // so that we don't make an AttributedType for it).
4988  AttributeList *attr = D.getAttributePool()
4989  .create(&S.Context.Idents.get("objc_ownership"), SourceLocation(),
4990  /*scope*/ nullptr, SourceLocation(),
4991  /*args*/ &Args, 1, AttributeList::AS_GNU);
4992  spliceAttrIntoList(*attr, chunk.getAttrListRef());
4993 
4994  // TODO: mark whether we did this inference?
4995 }
4996 
4997 /// \brief Used for transferring ownership in casts resulting in l-values.
4998 static void transferARCOwnership(TypeProcessingState &state,
4999  QualType &declSpecTy,
5000  Qualifiers::ObjCLifetime ownership) {
5001  Sema &S = state.getSema();
5002  Declarator &D = state.getDeclarator();
5003 
5004  int inner = -1;
5005  bool hasIndirection = false;
5006  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
5007  DeclaratorChunk &chunk = D.getTypeObject(i);
5008  switch (chunk.Kind) {
5010  // Ignore parens.
5011  break;
5012 
5016  if (inner != -1)
5017  hasIndirection = true;
5018  inner = i;
5019  break;
5020 
5022  if (inner != -1)
5023  transferARCOwnershipToDeclaratorChunk(state, ownership, i);
5024  return;
5025 
5028  case DeclaratorChunk::Pipe:
5029  return;
5030  }
5031  }
5032 
5033  if (inner == -1)
5034  return;
5035 
5036  DeclaratorChunk &chunk = D.getTypeObject(inner);
5037  if (chunk.Kind == DeclaratorChunk::Pointer) {
5038  if (declSpecTy->isObjCRetainableType())
5039  return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership);
5040  if (declSpecTy->isObjCObjectType() && hasIndirection)
5041  return transferARCOwnershipToDeclaratorChunk(state, ownership, inner);
5042  } else {
5043  assert(chunk.Kind == DeclaratorChunk::Array ||
5044  chunk.Kind == DeclaratorChunk::Reference);
5045  return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership);
5046  }
5047 }
5048 
5050  TypeProcessingState state(*this, D);
5051 
5052  TypeSourceInfo *ReturnTypeInfo = nullptr;
5053  QualType declSpecTy = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
5054 
5055  if (getLangOpts().ObjC1) {
5056  Qualifiers::ObjCLifetime ownership = Context.getInnerObjCOwnership(FromTy);
5057  if (ownership != Qualifiers::OCL_None)
5058  transferARCOwnership(state, declSpecTy, ownership);
5059  }
5060 
5061  return GetFullTypeForDeclarator(state, declSpecTy, ReturnTypeInfo);
5062 }
5063 
5064 /// Map an AttributedType::Kind to an AttributeList::Kind.
5066  switch (kind) {
5068  return AttributeList::AT_AddressSpace;
5070  return AttributeList::AT_Regparm;
5072  return AttributeList::AT_VectorSize;
5074  return AttributeList::AT_NeonVectorType;
5076  return AttributeList::AT_NeonPolyVectorType;
5078  return AttributeList::AT_ObjCGC;
5081  return AttributeList::AT_ObjCOwnership;
5083  return AttributeList::AT_NoReturn;
5085  return AttributeList::AT_CDecl;
5087  return AttributeList::AT_FastCall;
5089  return AttributeList::AT_StdCall;
5091  return AttributeList::AT_ThisCall;
5093  return AttributeList::AT_RegCall;
5095  return AttributeList::AT_Pascal;
5097  return AttributeList::AT_SwiftCall;
5099  return AttributeList::AT_VectorCall;
5102  return AttributeList::AT_Pcs;
5104  return AttributeList::AT_IntelOclBicc;
5106  return AttributeList::AT_MSABI;
5108  return AttributeList::AT_SysVABI;
5110  return AttributeList::AT_PreserveMost;
5112  return AttributeList::AT_PreserveAll;
5114  return AttributeList::AT_Ptr32;
5116  return AttributeList::AT_Ptr64;
5118  return AttributeList::AT_SPtr;
5120  return AttributeList::AT_UPtr;
5122  return AttributeList::AT_TypeNonNull;
5124  return AttributeList::AT_TypeNullable;
5126  return AttributeList::AT_TypeNullUnspecified;
5128  return AttributeList::AT_ObjCKindOf;
5130  return AttributeList::AT_NSReturnsRetained;
5131  }
5132  llvm_unreachable("unexpected attribute kind!");
5133 }
5134 
5136  const AttributeList *attrs,
5137  const AttributeList *DeclAttrs = nullptr) {
5138  // DeclAttrs and attrs cannot be both empty.
5139  assert((attrs || DeclAttrs) &&
5140  "no type attributes in the expected location!");
5141 
5142  AttributeList::Kind parsedKind = getAttrListKind(TL.getAttrKind());
5143  // Try to search for an attribute of matching kind in attrs list.
5144  while (attrs && attrs->getKind() != parsedKind)
5145  attrs = attrs->getNext();
5146  if (!attrs) {
5147  // No matching type attribute in attrs list found.
5148  // Try searching through C++11 attributes in the declarator attribute list.
5149  while (DeclAttrs && (!DeclAttrs->isCXX11Attribute() ||
5150  DeclAttrs->getKind() != parsedKind))
5151  DeclAttrs = DeclAttrs->getNext();
5152  attrs = DeclAttrs;
5153  }
5154 
5155  assert(attrs && "no matching type attribute in expected location!");
5156 
5157  TL.setAttrNameLoc(attrs->getLoc());
5158  if (TL.hasAttrExprOperand()) {
5159  assert(attrs->isArgExpr(0) && "mismatched attribute operand kind");
5160  TL.setAttrExprOperand(attrs->getArgAsExpr(0));
5161  } else if (TL.hasAttrEnumOperand()) {
5162  assert((attrs->isArgIdent(0) || attrs->isArgExpr(0)) &&
5163  "unexpected attribute operand kind");
5164  if (attrs->isArgIdent(0))
5165  TL.setAttrEnumOperandLoc(attrs->getArgAsIdent(0)->Loc);
5166  else
5168  }
5169 
5170  // FIXME: preserve this information to here.
5171  if (TL.hasAttrOperand())
5173 }
5174 
5175 namespace {
5176  class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> {
5177  ASTContext &Context;
5178  const DeclSpec &DS;
5179 
5180  public:
5181  TypeSpecLocFiller(ASTContext &Context, const DeclSpec &DS)
5182  : Context(Context), DS(DS) {}
5183 
5184  void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5186  Visit(TL.getModifiedLoc());
5187  }
5188  void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5189  Visit(TL.getUnqualifiedLoc());
5190  }
5191  void VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5192  TL.setNameLoc(DS.getTypeSpecTypeLoc());
5193  }
5194  void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5195  TL.setNameLoc(DS.getTypeSpecTypeLoc());
5196  // FIXME. We should have DS.getTypeSpecTypeEndLoc(). But, it requires
5197  // addition field. What we have is good enough for dispay of location
5198  // of 'fixit' on interface name.
5199  TL.setNameEndLoc(DS.getLocEnd());
5200  }
5201  void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5202  TypeSourceInfo *RepTInfo = nullptr;
5203  Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo);
5204  TL.copy(RepTInfo->getTypeLoc());
5205  }
5206  void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5207  TypeSourceInfo *RepTInfo = nullptr;
5208  Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo);
5209  TL.copy(RepTInfo->getTypeLoc());
5210  }
5211  void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
5212  TypeSourceInfo *TInfo = nullptr;
5213  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5214 
5215  // If we got no declarator info from previous Sema routines,
5216  // just fill with the typespec loc.
5217  if (!TInfo) {
5218  TL.initialize(Context, DS.getTypeSpecTypeNameLoc());
5219  return;
5220  }
5221 
5222  TypeLoc OldTL = TInfo->getTypeLoc();
5223  if (TInfo->getType()->getAs<ElaboratedType>()) {
5224  ElaboratedTypeLoc ElabTL = OldTL.castAs<ElaboratedTypeLoc>();
5227  TL.copy(NamedTL);
5228  } else {
5230  assert(TL.getRAngleLoc() == OldTL.castAs<TemplateSpecializationTypeLoc>().getRAngleLoc());
5231  }
5232 
5233  }
5234  void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5235  assert(DS.getTypeSpecType() == DeclSpec::TST_typeofExpr);
5238  }
5239  void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5240  assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType);
5243  assert(DS.getRepAsType());
5244  TypeSourceInfo *TInfo = nullptr;
5245  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5246  TL.setUnderlyingTInfo(TInfo);
5247  }
5248  void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5249  // FIXME: This holds only because we only have one unary transform.
5251  TL.setKWLoc(DS.getTypeSpecTypeLoc());
5253  assert(DS.getRepAsType());
5254  TypeSourceInfo *TInfo = nullptr;
5255  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5256  TL.setUnderlyingTInfo(TInfo);
5257  }
5258  void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5259  // By default, use the source location of the type specifier.
5261  if (TL.needsExtraLocalData()) {
5262  // Set info for the written builtin specifiers.
5264  // Try to have a meaningful source location.
5265  if (TL.getWrittenSignSpec() != TSS_unspecified)
5269  }
5270  }
5271  void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5272  ElaboratedTypeKeyword Keyword
5274  if (DS.getTypeSpecType() == TST_typename) {
5275  TypeSourceInfo *TInfo = nullptr;
5276  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5277  if (TInfo) {
5278  TL.copy(TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>());
5279  return;
5280  }
5281  }
5282  TL.setElaboratedKeywordLoc(Keyword != ETK_None
5283  ? DS.getTypeSpecTypeLoc()
5284  : SourceLocation());
5285  const CXXScopeSpec& SS = DS.getTypeSpecScope();
5286  TL.setQualifierLoc(SS.getWithLocInContext(Context));
5287  Visit(TL.getNextTypeLoc().getUnqualifiedLoc());
5288  }
5289  void VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5290  assert(DS.getTypeSpecType() == TST_typename);
5291  TypeSourceInfo *TInfo = nullptr;
5292  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5293  assert(TInfo);
5294  TL.copy(TInfo->getTypeLoc().castAs<DependentNameTypeLoc>());
5295  }
5296  void VisitDependentTemplateSpecializationTypeLoc(
5298  assert(DS.getTypeSpecType() == TST_typename);
5299  TypeSourceInfo *TInfo = nullptr;
5300  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5301  assert(TInfo);
5302  TL.copy(
5303  TInfo->getTypeLoc().castAs<DependentTemplateSpecializationTypeLoc>());
5304  }
5305  void VisitTagTypeLoc(TagTypeLoc TL) {
5307  }
5308  void VisitAtomicTypeLoc(AtomicTypeLoc TL) {
5309  // An AtomicTypeLoc can come from either an _Atomic(...) type specifier
5310  // or an _Atomic qualifier.
5311  if (DS.getTypeSpecType() == DeclSpec::TST_atomic) {
5312  TL.setKWLoc(DS.getTypeSpecTypeLoc());
5314 
5315  TypeSourceInfo *TInfo = nullptr;
5316  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5317  assert(TInfo);
5318  TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc());
5319  } else {
5320  TL.setKWLoc(DS.getAtomicSpecLoc());
5321  // No parens, to indicate this was spelled as an _Atomic qualifier.
5323  Visit(TL.getValueLoc());
5324  }
5325  }
5326 
5327  void VisitPipeTypeLoc(PipeTypeLoc TL) {
5328  TL.setKWLoc(DS.getTypeSpecTypeLoc());
5329 
5330  TypeSourceInfo *TInfo = nullptr;
5331  Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
5332  TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc());
5333  }
5334 
5335  void VisitTypeLoc(TypeLoc TL) {
5