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