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