/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp

Bug Summary

File:	tools/clang/lib/AST/ASTContext.cpp
Warning:	line 8203, column 7 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTContext.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn373517/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn373517=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-02-234743-9763-1 -x c++ /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp

/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp

→

1//===- ASTContext.cpp - Context to hold long-lived AST nodes --------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file implements the ASTContext interface.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/AST/ASTContext.h"
14#include "CXXABI.h"
15#include "Interp/Context.h"
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTMutationListener.h"
18#include "clang/AST/ASTTypeTraits.h"
19#include "clang/AST/Attr.h"
20#include "clang/AST/AttrIterator.h"
21#include "clang/AST/CharUnits.h"
22#include "clang/AST/Comment.h"
23#include "clang/AST/Decl.h"
24#include "clang/AST/DeclBase.h"
25#include "clang/AST/DeclCXX.h"
26#include "clang/AST/DeclContextInternals.h"
27#include "clang/AST/DeclObjC.h"
28#include "clang/AST/DeclOpenMP.h"
29#include "clang/AST/DeclTemplate.h"
30#include "clang/AST/DeclarationName.h"
31#include "clang/AST/Expr.h"
32#include "clang/AST/ExprCXX.h"
33#include "clang/AST/ExternalASTSource.h"
34#include "clang/AST/Mangle.h"
35#include "clang/AST/MangleNumberingContext.h"
36#include "clang/AST/NestedNameSpecifier.h"
37#include "clang/AST/RawCommentList.h"
38#include "clang/AST/RecordLayout.h"
39#include "clang/AST/RecursiveASTVisitor.h"
40#include "clang/AST/Stmt.h"
41#include "clang/AST/TemplateBase.h"
42#include "clang/AST/TemplateName.h"
43#include "clang/AST/Type.h"
44#include "clang/AST/TypeLoc.h"
45#include "clang/AST/UnresolvedSet.h"
46#include "clang/AST/VTableBuilder.h"
47#include "clang/Basic/AddressSpaces.h"
48#include "clang/Basic/Builtins.h"
49#include "clang/Basic/CommentOptions.h"
50#include "clang/Basic/ExceptionSpecificationType.h"
51#include "clang/Basic/FixedPoint.h"
52#include "clang/Basic/IdentifierTable.h"
53#include "clang/Basic/LLVM.h"
54#include "clang/Basic/LangOptions.h"
55#include "clang/Basic/Linkage.h"
56#include "clang/Basic/ObjCRuntime.h"
57#include "clang/Basic/SanitizerBlacklist.h"
58#include "clang/Basic/SourceLocation.h"
59#include "clang/Basic/SourceManager.h"
60#include "clang/Basic/Specifiers.h"
61#include "clang/Basic/TargetCXXABI.h"
62#include "clang/Basic/TargetInfo.h"
63#include "clang/Basic/XRayLists.h"
64#include "llvm/ADT/APInt.h"
65#include "llvm/ADT/APSInt.h"
66#include "llvm/ADT/ArrayRef.h"
67#include "llvm/ADT/DenseMap.h"
68#include "llvm/ADT/DenseSet.h"
69#include "llvm/ADT/FoldingSet.h"
70#include "llvm/ADT/None.h"
71#include "llvm/ADT/Optional.h"
72#include "llvm/ADT/PointerUnion.h"
73#include "llvm/ADT/STLExtras.h"
74#include "llvm/ADT/SmallPtrSet.h"
75#include "llvm/ADT/SmallVector.h"
76#include "llvm/ADT/StringExtras.h"
77#include "llvm/ADT/StringRef.h"
78#include "llvm/ADT/Triple.h"
79#include "llvm/Support/Capacity.h"
80#include "llvm/Support/Casting.h"
81#include "llvm/Support/Compiler.h"
82#include "llvm/Support/ErrorHandling.h"
83#include "llvm/Support/MathExtras.h"
84#include "llvm/Support/raw_ostream.h"
85#include <algorithm>
86#include <cassert>
87#include <cstddef>
88#include <cstdint>
89#include <cstdlib>
90#include <map>
91#include <memory>
92#include <string>
93#include <tuple>
94#include <utility>

96using namespace clang;

98enum FloatingRank {
Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
100};

102/// \returns location that is relevant when searching for Doc comments related
103/// to \p D.
104static SourceLocation getDeclLocForCommentSearch(const Decl *D,
                                               SourceManager &SourceMgr) {
assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 106, __PRETTY_FUNCTION__));

// User can not attach documentation to implicit declarations.
if (D->isImplicit())
  return {};

// User can not attach documentation to implicit instantiations.
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
    return {};
}

if (const auto *VD = dyn_cast<VarDecl>(D)) {
  if (VD->isStaticDataMember() &&
      VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
    return {};
}

if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
  if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
    return {};
}

if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
  TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
  if (TSK == TSK_ImplicitInstantiation ||
      TSK == TSK_Undeclared)
    return {};
}

if (const auto *ED = dyn_cast<EnumDecl>(D)) {
  if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
    return {};
}
if (const auto *TD = dyn_cast<TagDecl>(D)) {
  // When tag declaration (but not definition!) is part of the
  // decl-specifier-seq of some other declaration, it doesn't get comment
  if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
    return {};
}
// TODO: handle comments for function parameters properly.
if (isa<ParmVarDecl>(D))
  return {};

// TODO: we could look up template parameter documentation in the template
// documentation.
if (isa<TemplateTypeParmDecl>(D) ||
    isa<NonTypeTemplateParmDecl>(D) ||
    isa<TemplateTemplateParmDecl>(D))
  return {};

// Find declaration location.
// For Objective-C declarations we generally don't expect to have multiple
// declarators, thus use declaration starting location as the "declaration
// location".
// For all other declarations multiple declarators are used quite frequently,
// so we use the location of the identifier as the "declaration location".
if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
    isa<ObjCPropertyDecl>(D) ||
    isa<RedeclarableTemplateDecl>(D) ||
    isa<ClassTemplateSpecializationDecl>(D))
  return D->getBeginLoc();
else {
  const SourceLocation DeclLoc = D->getLocation();
  if (DeclLoc.isMacroID()) {
    if (isa<TypedefDecl>(D)) {
      // If location of the typedef name is in a macro, it is because being
      // declared via a macro. Try using declaration's starting location as
      // the "declaration location".
      return D->getBeginLoc();
    } else if (const auto *TD = dyn_cast<TagDecl>(D)) {
      // If location of the tag decl is inside a macro, but the spelling of
      // the tag name comes from a macro argument, it looks like a special
      // macro like NS_ENUM is being used to define the tag decl.  In that
      // case, adjust the source location to the expansion loc so that we can
      // attach the comment to the tag decl.
      if (SourceMgr.isMacroArgExpansion(DeclLoc) &&
          TD->isCompleteDefinition())
        return SourceMgr.getExpansionLoc(DeclLoc);
    }
  }
  return DeclLoc;
}

return {};
191}

193RawComment *ASTContext::getRawCommentForDeclNoCacheImpl(
  const Decl *D, const SourceLocation RepresentativeLocForDecl,
  const std::map<unsigned, RawComment *> &CommentsInTheFile) const {
// If the declaration doesn't map directly to a location in a file, we
// can't find the comment.
if (RepresentativeLocForDecl.isInvalid() ||
    !RepresentativeLocForDecl.isFileID())
  return nullptr;

// If there are no comments anywhere, we won't find anything.
if (CommentsInTheFile.empty())
  return nullptr;

// Decompose the location for the declaration and find the beginning of the
// file buffer.
const std::pair<FileID, unsigned> DeclLocDecomp =
    SourceMgr.getDecomposedLoc(RepresentativeLocForDecl);

// Slow path.
auto OffsetCommentBehindDecl =
    CommentsInTheFile.lower_bound(DeclLocDecomp.second);

// First check whether we have a trailing comment.
if (OffsetCommentBehindDecl != CommentsInTheFile.end()) {
  RawComment *CommentBehindDecl = OffsetCommentBehindDecl->second;
  if ((CommentBehindDecl->isDocumentation() ||
       LangOpts.CommentOpts.ParseAllComments) &&
      CommentBehindDecl->isTrailingComment() &&
      (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) ||
       isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) {

    // Check that Doxygen trailing comment comes after the declaration, starts
    // on the same line and in the same file as the declaration.
    if (SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) ==
        Comments.getCommentBeginLine(CommentBehindDecl, DeclLocDecomp.first,
                                     OffsetCommentBehindDecl->first)) {
      return CommentBehindDecl;
    }
  }
}

// The comment just after the declaration was not a trailing comment.
// Let's look at the previous comment.
if (OffsetCommentBehindDecl == CommentsInTheFile.begin())
  return nullptr;

auto OffsetCommentBeforeDecl = --OffsetCommentBehindDecl;
RawComment *CommentBeforeDecl = OffsetCommentBeforeDecl->second;

// Check that we actually have a non-member Doxygen comment.
if (!(CommentBeforeDecl->isDocumentation() ||
      LangOpts.CommentOpts.ParseAllComments) ||
    CommentBeforeDecl->isTrailingComment())
  return nullptr;

// Decompose the end of the comment.
const unsigned CommentEndOffset =
    Comments.getCommentEndOffset(CommentBeforeDecl);

// Get the corresponding buffer.
bool Invalid = false;
const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
                                             &Invalid).data();
if (Invalid)
  return nullptr;

// Extract text between the comment and declaration.
StringRef Text(Buffer + CommentEndOffset,
               DeclLocDecomp.second - CommentEndOffset);

// There should be no other declarations or preprocessor directives between
// comment and declaration.
if (Text.find_first_of(";{}#@") != StringRef::npos)
  return nullptr;

return CommentBeforeDecl;
269}

271RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
const SourceLocation DeclLoc = getDeclLocForCommentSearch(D, SourceMgr);

// If the declaration doesn't map directly to a location in a file, we
// can't find the comment.
if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
  return nullptr;

if (ExternalSource && !CommentsLoaded) {
  ExternalSource->ReadComments();
  CommentsLoaded = true;
}

if (Comments.empty())
  return nullptr;

const FileID File = SourceMgr.getDecomposedLoc(DeclLoc).first;
const auto CommentsInThisFile = Comments.getCommentsInFile(File);
if (!CommentsInThisFile || CommentsInThisFile->empty())
  return nullptr;

return getRawCommentForDeclNoCacheImpl(D, DeclLoc, *CommentsInThisFile);
293}

295/// If we have a 'templated' declaration for a template, adjust 'D' to
296/// refer to the actual template.
297/// If we have an implicit instantiation, adjust 'D' to refer to template.
298static const Decl &adjustDeclToTemplate(const Decl &D) {
if (const auto *FD = dyn_cast<FunctionDecl>(&D)) {
  // Is this function declaration part of a function template?
  if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
    return *FTD;

  // Nothing to do if function is not an implicit instantiation.
  if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
    return D;

  // Function is an implicit instantiation of a function template?
  if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
    return *FTD;

  // Function is instantiated from a member definition of a class template?
  if (const FunctionDecl *MemberDecl =
          FD->getInstantiatedFromMemberFunction())
    return *MemberDecl;

  return D;
}
if (const auto *VD = dyn_cast<VarDecl>(&D)) {
  // Static data member is instantiated from a member definition of a class
  // template?
  if (VD->isStaticDataMember())
    if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
      return *MemberDecl;

  return D;
}
if (const auto *CRD = dyn_cast<CXXRecordDecl>(&D)) {
  // Is this class declaration part of a class template?
  if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
    return *CTD;

  // Class is an implicit instantiation of a class template or partial
  // specialization?
  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
    if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
      return D;
    llvm::PointerUnion<ClassTemplateDecl *,
                       ClassTemplatePartialSpecializationDecl *>
        PU = CTSD->getSpecializedTemplateOrPartial();
    return PU.is<ClassTemplateDecl *>()
               ? *static_cast<const Decl *>(PU.get<ClassTemplateDecl *>())
               : *static_cast<const Decl *>(
                     PU.get<ClassTemplatePartialSpecializationDecl *>());
  }

  // Class is instantiated from a member definition of a class template?
  if (const MemberSpecializationInfo *Info =
          CRD->getMemberSpecializationInfo())
    return *Info->getInstantiatedFrom();

  return D;
}
if (const auto *ED = dyn_cast<EnumDecl>(&D)) {
  // Enum is instantiated from a member definition of a class template?
  if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
    return *MemberDecl;

  return D;
}
// FIXME: Adjust alias templates?
return D;
363}

365const RawComment *ASTContext::getRawCommentForAnyRedecl(
                                              const Decl *D,
                                              const Decl **OriginalDecl) const {
if (!D) {
  if (OriginalDecl)
    OriginalDecl = nullptr;
  return nullptr;
}

D = &adjustDeclToTemplate(*D);

// Any comment directly attached to D?
{
  auto DeclComment = DeclRawComments.find(D);
  if (DeclComment != DeclRawComments.end()) {
    if (OriginalDecl)
      *OriginalDecl = D;
    return DeclComment->second;
  }
}

// Any comment attached to any redeclaration of D?
const Decl *CanonicalD = D->getCanonicalDecl();
if (!CanonicalD)
  return nullptr;

{
  auto RedeclComment = RedeclChainComments.find(CanonicalD);
  if (RedeclComment != RedeclChainComments.end()) {
    if (OriginalDecl)
      *OriginalDecl = RedeclComment->second;
    auto CommentAtRedecl = DeclRawComments.find(RedeclComment->second);
    assert(CommentAtRedecl != DeclRawComments.end() &&((CommentAtRedecl != DeclRawComments.end() && "This decl is supposed to have comment attached."
) ? static_cast<void> (0) : __assert_fail ("CommentAtRedecl != DeclRawComments.end() && \"This decl is supposed to have comment attached.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 398, __PRETTY_FUNCTION__))
           "This decl is supposed to have comment attached.")((CommentAtRedecl != DeclRawComments.end() && "This decl is supposed to have comment attached."
) ? static_cast<void> (0) : __assert_fail ("CommentAtRedecl != DeclRawComments.end() && \"This decl is supposed to have comment attached.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 398, __PRETTY_FUNCTION__));
    return CommentAtRedecl->second;
  }
}

// Any redeclarations of D that we haven't checked for comments yet?
// We can't use DenseMap::iterator directly since it'd get invalid.
auto LastCheckedRedecl = [this, CanonicalD]() -> const Decl * {
  auto LookupRes = CommentlessRedeclChains.find(CanonicalD);
  if (LookupRes != CommentlessRedeclChains.end())
    return LookupRes->second;
  return nullptr;
}();

for (const auto Redecl : D->redecls()) {
  assert(Redecl)((Redecl) ? static_cast<void> (0) : __assert_fail ("Redecl"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 413, __PRETTY_FUNCTION__));
  // Skip all redeclarations that have been checked previously.
  if (LastCheckedRedecl) {
    if (LastCheckedRedecl == Redecl) {
      LastCheckedRedecl = nullptr;
    }
    continue;
  }
  const RawComment *RedeclComment = getRawCommentForDeclNoCache(Redecl);
  if (RedeclComment) {
    cacheRawCommentForDecl(*Redecl, *RedeclComment);
    if (OriginalDecl)
      *OriginalDecl = Redecl;
    return RedeclComment;
  }
  CommentlessRedeclChains[CanonicalD] = Redecl;
}

if (OriginalDecl)
  *OriginalDecl = nullptr;
return nullptr;
434}

436void ASTContext::cacheRawCommentForDecl(const Decl &OriginalD,
                                      const RawComment &Comment) const {
assert(Comment.isDocumentation() || LangOpts.CommentOpts.ParseAllComments)((Comment.isDocumentation() || LangOpts.CommentOpts.ParseAllComments
) ? static_cast<void> (0) : __assert_fail ("Comment.isDocumentation() || LangOpts.CommentOpts.ParseAllComments"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 438, __PRETTY_FUNCTION__));
DeclRawComments.try_emplace(&OriginalD, &Comment);
const Decl *const CanonicalDecl = OriginalD.getCanonicalDecl();
RedeclChainComments.try_emplace(CanonicalDecl, &OriginalD);
CommentlessRedeclChains.erase(CanonicalDecl);
443}

445static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
                 SmallVectorImpl<const NamedDecl *> &Redeclared) {
const DeclContext *DC = ObjCMethod->getDeclContext();
if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
  const ObjCInterfaceDecl *ID = IMD->getClassInterface();
  if (!ID)
    return;
  // Add redeclared method here.
  for (const auto *Ext : ID->known_extensions()) {
    if (ObjCMethodDecl *RedeclaredMethod =
          Ext->getMethod(ObjCMethod->getSelector(),
                                ObjCMethod->isInstanceMethod()))
      Redeclared.push_back(RedeclaredMethod);
  }
}
460}

462void ASTContext::attachCommentsToJustParsedDecls(ArrayRef<Decl *> Decls,
                                               const Preprocessor *PP) {
if (Comments.empty() || Decls.empty())
  return;

// See if there are any new comments that are not attached to a decl.
// The location doesn't have to be precise - we care only about the file.
const FileID File =
    SourceMgr.getDecomposedLoc((*Decls.begin())->getLocation()).first;
auto CommentsInThisFile = Comments.getCommentsInFile(File);
if (!CommentsInThisFile || CommentsInThisFile->empty() ||
    CommentsInThisFile->rbegin()->second->isAttached())
  return;

// There is at least one comment not attached to a decl.
// Maybe it should be attached to one of Decls?
//
// Note that this way we pick up not only comments that precede the
// declaration, but also comments that *follow* the declaration -- thanks to
// the lookahead in the lexer: we've consumed the semicolon and looked
// ahead through comments.

for (const Decl *D : Decls) {
  assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 485, __PRETTY_FUNCTION__));
  if (D->isInvalidDecl())
    continue;

  D = &adjustDeclToTemplate(*D);

  const SourceLocation DeclLoc = getDeclLocForCommentSearch(D, SourceMgr);

  if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
    continue;

  if (DeclRawComments.count(D) > 0)
    continue;

  if (RawComment *const DocComment =
          getRawCommentForDeclNoCacheImpl(D, DeclLoc, *CommentsInThisFile)) {
    cacheRawCommentForDecl(*D, *DocComment);
    comments::FullComment *FC = DocComment->parse(*this, PP, D);
    ParsedComments[D->getCanonicalDecl()] = FC;
  }
}
506}

508comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
                                                  const Decl *D) const {
auto *ThisDeclInfo = new (*this) comments::DeclInfo;
ThisDeclInfo->CommentDecl = D;
ThisDeclInfo->IsFilled = false;
ThisDeclInfo->fill();
ThisDeclInfo->CommentDecl = FC->getDecl();
if (!ThisDeclInfo->TemplateParameters)
  ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
comments::FullComment *CFC =
  new (*this) comments::FullComment(FC->getBlocks(),
                                    ThisDeclInfo);
return CFC;
521}

523comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const {
const RawComment *RC = getRawCommentForDeclNoCache(D);
return RC ? RC->parse(*this, nullptr, D) : nullptr;
526}

528comments::FullComment *ASTContext::getCommentForDecl(
                                            const Decl *D,
                                            const Preprocessor *PP) const {
if (!D || D->isInvalidDecl())
  return nullptr;
D = &adjustDeclToTemplate(*D);

const Decl *Canonical = D->getCanonicalDecl();
llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
    ParsedComments.find(Canonical);

if (Pos != ParsedComments.end()) {
  if (Canonical != D) {
    comments::FullComment *FC = Pos->second;
    comments::FullComment *CFC = cloneFullComment(FC, D);
    return CFC;
  }
  return Pos->second;
}

const Decl *OriginalDecl = nullptr;

const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
if (!RC) {
  if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
    SmallVector<const NamedDecl*, 8> Overridden;
    const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
    if (OMD && OMD->isPropertyAccessor())
      if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
        if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
          return cloneFullComment(FC, D);
    if (OMD)
      addRedeclaredMethods(OMD, Overridden);
    getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);
    for (unsigned i = 0, e = Overridden.size(); i < e; i++)
      if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
        return cloneFullComment(FC, D);
  }
  else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
    // Attach any tag type's documentation to its typedef if latter
    // does not have one of its own.
    QualType QT = TD->getUnderlyingType();
    if (const auto *TT = QT->getAs<TagType>())
      if (const Decl *TD = TT->getDecl())
        if (comments::FullComment *FC = getCommentForDecl(TD, PP))
          return cloneFullComment(FC, D);
  }
  else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
    while (IC->getSuperClass()) {
      IC = IC->getSuperClass();
      if (comments::FullComment *FC = getCommentForDecl(IC, PP))
        return cloneFullComment(FC, D);
    }
  }
  else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
    if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
      if (comments::FullComment *FC = getCommentForDecl(IC, PP))
        return cloneFullComment(FC, D);
  }
  else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
    if (!(RD = RD->getDefinition()))
      return nullptr;
    // Check non-virtual bases.
    for (const auto &I : RD->bases()) {
      if (I.isVirtual() || (I.getAccessSpecifier() != AS_public))
        continue;
      QualType Ty = I.getType();
      if (Ty.isNull())
        continue;
      if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
        if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
          continue;

        if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
          return cloneFullComment(FC, D);
      }
    }
    // Check virtual bases.
    for (const auto &I : RD->vbases()) {
      if (I.getAccessSpecifier() != AS_public)
        continue;
      QualType Ty = I.getType();
      if (Ty.isNull())
        continue;
      if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
        if (!(VirtualBase= VirtualBase->getDefinition()))
          continue;
        if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
          return cloneFullComment(FC, D);
      }
    }
  }
  return nullptr;
}

// If the RawComment was attached to other redeclaration of this Decl, we
// should parse the comment in context of that other Decl.  This is important
// because comments can contain references to parameter names which can be
// different across redeclarations.
if (D != OriginalDecl && OriginalDecl)
  return getCommentForDecl(OriginalDecl, PP);

comments::FullComment *FC = RC->parse(*this, PP, D);
ParsedComments[Canonical] = FC;
return FC;
633}

635void
636ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
                                             TemplateTemplateParmDecl *Parm) {
ID.AddInteger(Parm->getDepth());
ID.AddInteger(Parm->getPosition());
ID.AddBoolean(Parm->isParameterPack());

TemplateParameterList *Params = Parm->getTemplateParameters();
ID.AddInteger(Params->size());
for (TemplateParameterList::const_iterator P = Params->begin(),
                                        PEnd = Params->end();
     P != PEnd; ++P) {
  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
    ID.AddInteger(0);
    ID.AddBoolean(TTP->isParameterPack());
    continue;
  }

  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
    ID.AddInteger(1);
    ID.AddBoolean(NTTP->isParameterPack());
    ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
    if (NTTP->isExpandedParameterPack()) {
      ID.AddBoolean(true);
      ID.AddInteger(NTTP->getNumExpansionTypes());
      for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
        QualType T = NTTP->getExpansionType(I);
        ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
      }
    } else
      ID.AddBoolean(false);
    continue;
  }

  auto *TTP = cast<TemplateTemplateParmDecl>(*P);
  ID.AddInteger(2);
  Profile(ID, TTP);
}
673}

675TemplateTemplateParmDecl *
676ASTContext::getCanonicalTemplateTemplateParmDecl(
                                        TemplateTemplateParmDecl *TTP) const {
// Check if we already have a canonical template template parameter.
llvm::FoldingSetNodeID ID;
CanonicalTemplateTemplateParm::Profile(ID, TTP);
void *InsertPos = nullptr;
CanonicalTemplateTemplateParm *Canonical
  = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
if (Canonical)
  return Canonical->getParam();

// Build a canonical template parameter list.
TemplateParameterList *Params = TTP->getTemplateParameters();
SmallVector<NamedDecl *, 4> CanonParams;
CanonParams.reserve(Params->size());
for (TemplateParameterList::const_iterator P = Params->begin(),
                                        PEnd = Params->end();
     P != PEnd; ++P) {
  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
    CanonParams.push_back(
                TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(),
                                             SourceLocation(),
                                             SourceLocation(),
                                             TTP->getDepth(),
                                             TTP->getIndex(), nullptr, false,
                                             TTP->isParameterPack()));
  else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
    QualType T = getCanonicalType(NTTP->getType());
    TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
    NonTypeTemplateParmDecl *Param;
    if (NTTP->isExpandedParameterPack()) {
      SmallVector<QualType, 2> ExpandedTypes;
      SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;
      for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
        ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
        ExpandedTInfos.push_back(
                              getTrivialTypeSourceInfo(ExpandedTypes.back()));
      }

      Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
                                              SourceLocation(),
                                              SourceLocation(),
                                              NTTP->getDepth(),
                                              NTTP->getPosition(), nullptr,
                                              T,
                                              TInfo,
                                              ExpandedTypes,
                                              ExpandedTInfos);
    } else {
      Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
                                              SourceLocation(),
                                              SourceLocation(),
                                              NTTP->getDepth(),
                                              NTTP->getPosition(), nullptr,
                                              T,
                                              NTTP->isParameterPack(),
                                              TInfo);
    }
    CanonParams.push_back(Param);

  } else
    CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
                                         cast<TemplateTemplateParmDecl>(*P)));
}

assert(!TTP->getRequiresClause() &&((!TTP->getRequiresClause() && "Unexpected requires-clause on template template-parameter"
) ? static_cast<void> (0) : __assert_fail ("!TTP->getRequiresClause() && \"Unexpected requires-clause on template template-parameter\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 742, __PRETTY_FUNCTION__))
       "Unexpected requires-clause on template template-parameter")((!TTP->getRequiresClause() && "Unexpected requires-clause on template template-parameter"
) ? static_cast<void> (0) : __assert_fail ("!TTP->getRequiresClause() && \"Unexpected requires-clause on template template-parameter\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 742, __PRETTY_FUNCTION__));
Expr *const CanonRequiresClause = nullptr;

TemplateTemplateParmDecl *CanonTTP
  = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
                                     SourceLocation(), TTP->getDepth(),
                                     TTP->getPosition(),
                                     TTP->isParameterPack(),
                                     nullptr,
                       TemplateParameterList::Create(*this, SourceLocation(),
                                                     SourceLocation(),
                                                     CanonParams,
                                                     SourceLocation(),
                                                     CanonRequiresClause));

// Get the new insert position for the node we care about.
Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
assert(!Canonical && "Shouldn't be in the map!")((!Canonical && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!Canonical && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 759, __PRETTY_FUNCTION__));
(void)Canonical;

// Create the canonical template template parameter entry.
Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
return CanonTTP;
766}

768CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
if (!LangOpts.CPlusPlus) return nullptr;

switch (T.getCXXABI().getKind()) {
case TargetCXXABI::GenericARM: // Same as Itanium at this level
case TargetCXXABI::iOS:
case TargetCXXABI::iOS64:
case TargetCXXABI::WatchOS:
case TargetCXXABI::GenericAArch64:
case TargetCXXABI::GenericMIPS:
case TargetCXXABI::GenericItanium:
case TargetCXXABI::WebAssembly:
  return CreateItaniumCXXABI(*this);
case TargetCXXABI::Microsoft:
  return CreateMicrosoftCXXABI(*this);
}
llvm_unreachable("Invalid CXXABI type!")::llvm::llvm_unreachable_internal("Invalid CXXABI type!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 784);
785}

787interp::Context &ASTContext::getInterpContext() {
if (!InterpContext) {
  InterpContext.reset(new interp::Context(*this));
}
return *InterpContext.get();
792}

794static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
                                         const LangOptions &LOpts) {
if (LOpts.FakeAddressSpaceMap) {
  // The fake address space map must have a distinct entry for each
  // language-specific address space.
  static const unsigned FakeAddrSpaceMap[] = {
    0, // Default
    1, // opencl_global
    3, // opencl_local
    2, // opencl_constant
    0, // opencl_private
    4, // opencl_generic
    5, // cuda_device
    6, // cuda_constant
    7  // cuda_shared
  };
  return &FakeAddrSpaceMap;
} else {
  return &T.getAddressSpaceMap();
}
814}

816static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI,
                                        const LangOptions &LangOpts) {
switch (LangOpts.getAddressSpaceMapMangling()) {
case LangOptions::ASMM_Target:
  return TI.useAddressSpaceMapMangling();
case LangOptions::ASMM_On:
  return true;
case LangOptions::ASMM_Off:
  return false;
}
llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything.")::llvm::llvm_unreachable_internal("getAddressSpaceMapMangling() doesn't cover anything."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 826);
827}

829ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
                     IdentifierTable &idents, SelectorTable &sels,
                     Builtin::Context &builtins)
  : FunctionProtoTypes(this_()), TemplateSpecializationTypes(this_()),
    DependentTemplateSpecializationTypes(this_()),
    SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
    SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
    XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
                                      LangOpts.XRayNeverInstrumentFiles,
                                      LangOpts.XRayAttrListFiles, SM)),
    PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
    BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
    CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
    CompCategories(this_()), LastSDM(nullptr, 0) {
TUDecl = TranslationUnitDecl::Create(*this);
TraversalScope = {TUDecl};
845}

847ASTContext::~ASTContext() {
// Release the DenseMaps associated with DeclContext objects.
// FIXME: Is this the ideal solution?
ReleaseDeclContextMaps();

// Call all of the deallocation functions on all of their targets.
for (auto &Pair : Deallocations)
  (Pair.first)(Pair.second);

// ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
// because they can contain DenseMaps.
for (llvm::DenseMap<const ObjCContainerDecl*,
     const ASTRecordLayout*>::iterator
     I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
  // Increment in loop to prevent using deallocated memory.
  if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
    R->Destroy(*this);

for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
     I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
  // Increment in loop to prevent using deallocated memory.
  if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
    R->Destroy(*this);
}

for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
                                                  AEnd = DeclAttrs.end();
     A != AEnd; ++A)
  A->second->~AttrVec();

for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
     MaterializedTemporaryValues)
  MTVPair.second->~APValue();

for (const auto &Value : ModuleInitializers)
  Value.second->~PerModuleInitializers();

for (APValue *Value : APValueCleanups)
  Value->~APValue();
886}

888class ASTContext::ParentMap {
/// Contains parents of a node.
using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;

/// Maps from a node to its parents. This is used for nodes that have
/// pointer identity only, which are more common and we can save space by
/// only storing a unique pointer to them.
using ParentMapPointers = llvm::DenseMap<
    const void *,
    llvm::PointerUnion4<const Decl *, const Stmt *,
                        ast_type_traits::DynTypedNode *, ParentVector *>>;

/// Parent map for nodes without pointer identity. We store a full
/// DynTypedNode for all keys.
using ParentMapOtherNodes = llvm::DenseMap<
    ast_type_traits::DynTypedNode,
    llvm::PointerUnion4<const Decl *, const Stmt *,
                        ast_type_traits::DynTypedNode *, ParentVector *>>;

ParentMapPointers PointerParents;
ParentMapOtherNodes OtherParents;
class ASTVisitor;

static ast_type_traits::DynTypedNode
getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) {
  if (const auto *D = U.dyn_cast<const Decl *>())
    return ast_type_traits::DynTypedNode::create(*D);
  if (const auto *S = U.dyn_cast<const Stmt *>())
    return ast_type_traits::DynTypedNode::create(*S);
  return *U.get<ast_type_traits::DynTypedNode *>();
}

template <typename NodeTy, typename MapTy>
static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
                                                      const MapTy &Map) {
  auto I = Map.find(Node);
  if (I == Map.end()) {
    return llvm::ArrayRef<ast_type_traits::DynTypedNode>();
  }
  if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
    return llvm::makeArrayRef(*V);
  }
  return getSingleDynTypedNodeFromParentMap(I->second);
}

933public:
ParentMap(ASTContext &Ctx);
~ParentMap() {
  for (const auto &Entry : PointerParents) {
    if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
      delete Entry.second.get<ast_type_traits::DynTypedNode *>();
    } else if (Entry.second.is<ParentVector *>()) {
      delete Entry.second.get<ParentVector *>();
    }
  }
  for (const auto &Entry : OtherParents) {
    if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
      delete Entry.second.get<ast_type_traits::DynTypedNode *>();
    } else if (Entry.second.is<ParentVector *>()) {
      delete Entry.second.get<ParentVector *>();
    }
  }
}

DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node) {
  if (Node.getNodeKind().hasPointerIdentity())
    return getDynNodeFromMap(Node.getMemoizationData(), PointerParents);
  return getDynNodeFromMap(Node, OtherParents);
}
957};

959void ASTContext::setTraversalScope(const std::vector<Decl *> &TopLevelDecls) {
TraversalScope = TopLevelDecls;
Parents.reset();
962}

964void ASTContext::AddDeallocation(void (*Callback)(void *), void *Data) const {
Deallocations.push_back({Callback, Data});
966}

968void
969ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {
ExternalSource = std::move(Source);
971}

973void ASTContext::PrintStats() const {
llvm::errs() << "\n*** AST Context Stats:\n";
llvm::errs() << "  " << Types.size() << " types total.\n";

unsigned counts[] = {
978#define TYPE(Name, Parent) 0,
979#define ABSTRACT_TYPE(Name, Parent)
980#include "clang/AST/TypeNodes.inc"
  0 // Extra
};

for (unsigned i = 0, e = Types.size(); i != e; ++i) {
  Type *T = Types[i];
  counts[(unsigned)T->getTypeClass()]++;
}

unsigned Idx = 0;
unsigned TotalBytes = 0;
991#define TYPE(Name, Parent)                                              \
if (counts[Idx])                                                      \
  llvm::errs() << "    " << counts[Idx] << " " << #Name               \
               << " types, " << sizeof(Name##Type) << " each "        \
               << "(" << counts[Idx] * sizeof(Name##Type)             \
               << " bytes)\n";                                        \
TotalBytes += counts[Idx] * sizeof(Name##Type);                       \
++Idx;
999#define ABSTRACT_TYPE(Name, Parent)
1000#include "clang/AST/TypeNodes.inc"

llvm::errs() << "Total bytes = " << TotalBytes << "\n";

// Implicit special member functions.
llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/"
             << NumImplicitDefaultConstructors
             << " implicit default constructors created\n";
llvm::errs() << NumImplicitCopyConstructorsDeclared << "/"
             << NumImplicitCopyConstructors
             << " implicit copy constructors created\n";
if (getLangOpts().CPlusPlus)
  llvm::errs() << NumImplicitMoveConstructorsDeclared << "/"
               << NumImplicitMoveConstructors
               << " implicit move constructors created\n";
llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/"
             << NumImplicitCopyAssignmentOperators
             << " implicit copy assignment operators created\n";
if (getLangOpts().CPlusPlus)
  llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/"
               << NumImplicitMoveAssignmentOperators
               << " implicit move assignment operators created\n";
llvm::errs() << NumImplicitDestructorsDeclared << "/"
             << NumImplicitDestructors
             << " implicit destructors created\n";

if (ExternalSource) {
  llvm::errs() << "\n";
  ExternalSource->PrintStats();
}

BumpAlloc.PrintStats();
1032}

1034void ASTContext::mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
                                         bool NotifyListeners) {
if (NotifyListeners)
  if (auto *Listener = getASTMutationListener())
    Listener->RedefinedHiddenDefinition(ND, M);

MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M);
1041}

1043void ASTContext::deduplicateMergedDefinitonsFor(NamedDecl *ND) {
auto It = MergedDefModules.find(cast<NamedDecl>(ND->getCanonicalDecl()));
if (It == MergedDefModules.end())
  return;

auto &Merged = It->second;
llvm::DenseSet<Module*> Found;
for (Module *&M : Merged)
  if (!Found.insert(M).second)
    M = nullptr;
Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr), Merged.end());
1054}

1056void ASTContext::PerModuleInitializers::resolve(ASTContext &Ctx) {
if (LazyInitializers.empty())
  return;

auto *Source = Ctx.getExternalSource();
assert(Source && "lazy initializers but no external source")((Source && "lazy initializers but no external source"
) ? static_cast<void> (0) : __assert_fail ("Source && \"lazy initializers but no external source\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1061, __PRETTY_FUNCTION__));

auto LazyInits = std::move(LazyInitializers);
LazyInitializers.clear();

for (auto ID : LazyInits)
  Initializers.push_back(Source->GetExternalDecl(ID));

assert(LazyInitializers.empty() &&((LazyInitializers.empty() && "GetExternalDecl for lazy module initializer added more inits"
) ? static_cast<void> (0) : __assert_fail ("LazyInitializers.empty() && \"GetExternalDecl for lazy module initializer added more inits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1070, __PRETTY_FUNCTION__))
       "GetExternalDecl for lazy module initializer added more inits")((LazyInitializers.empty() && "GetExternalDecl for lazy module initializer added more inits"
) ? static_cast<void> (0) : __assert_fail ("LazyInitializers.empty() && \"GetExternalDecl for lazy module initializer added more inits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1070, __PRETTY_FUNCTION__));
1071}

1073void ASTContext::addModuleInitializer(Module *M, Decl *D) {
// One special case: if we add a module initializer that imports another
// module, and that module's only initializer is an ImportDecl, simplify.
if (const auto *ID = dyn_cast<ImportDecl>(D)) {
  auto It = ModuleInitializers.find(ID->getImportedModule());

  // Maybe the ImportDecl does nothing at all. (Common case.)
  if (It == ModuleInitializers.end())
    return;

  // Maybe the ImportDecl only imports another ImportDecl.
  auto &Imported = *It->second;
  if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
    Imported.resolve(*this);
    auto *OnlyDecl = Imported.Initializers.front();
    if (isa<ImportDecl>(OnlyDecl))
      D = OnlyDecl;
  }
}

auto *&Inits = ModuleInitializers[M];
if (!Inits)
  Inits = new (*this) PerModuleInitializers;
Inits->Initializers.push_back(D);
1097}

1099void ASTContext::addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs) {
auto *&Inits = ModuleInitializers[M];
if (!Inits)
  Inits = new (*this) PerModuleInitializers;
Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
                               IDs.begin(), IDs.end());
1105}

1107ArrayRef<Decl *> ASTContext::getModuleInitializers(Module *M) {
auto It = ModuleInitializers.find(M);
if (It == ModuleInitializers.end())
  return None;

auto *Inits = It->second;
Inits->resolve(*this);
return Inits->Initializers;
1115}

1117ExternCContextDecl *ASTContext::getExternCContextDecl() const {
if (!ExternCContext)
  ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl());

return ExternCContext;
1122}

1124BuiltinTemplateDecl *
1125ASTContext::buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,
                                   const IdentifierInfo *II) const {
auto *BuiltinTemplate = BuiltinTemplateDecl::Create(*this, TUDecl, II, BTK);
BuiltinTemplate->setImplicit();
TUDecl->addDecl(BuiltinTemplate);

return BuiltinTemplate;
1132}

1134BuiltinTemplateDecl *
1135ASTContext::getMakeIntegerSeqDecl() const {
if (!MakeIntegerSeqDecl)
  MakeIntegerSeqDecl = buildBuiltinTemplateDecl(BTK__make_integer_seq,
                                                getMakeIntegerSeqName());
return MakeIntegerSeqDecl;
1140}

1142BuiltinTemplateDecl *
1143ASTContext::getTypePackElementDecl() const {
if (!TypePackElementDecl)
  TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element,
                                                 getTypePackElementName());
return TypePackElementDecl;
1148}

1150RecordDecl *ASTContext::buildImplicitRecord(StringRef Name,
                                          RecordDecl::TagKind TK) const {
SourceLocation Loc;
RecordDecl *NewDecl;
if (getLangOpts().CPlusPlus)
  NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc,
                                  Loc, &Idents.get(Name));
else
  NewDecl = RecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, Loc,
                               &Idents.get(Name));
NewDecl->setImplicit();
NewDecl->addAttr(TypeVisibilityAttr::CreateImplicit(
    const_cast<ASTContext &>(*this), TypeVisibilityAttr::Default));
return NewDecl;
1164}

1166TypedefDecl *ASTContext::buildImplicitTypedef(QualType T,
                                            StringRef Name) const {
TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
TypedefDecl *NewDecl = TypedefDecl::Create(
    const_cast<ASTContext &>(*this), getTranslationUnitDecl(),
    SourceLocation(), SourceLocation(), &Idents.get(Name), TInfo);
NewDecl->setImplicit();
return NewDecl;
1174}

1176TypedefDecl *ASTContext::getInt128Decl() const {
if (!Int128Decl)
  Int128Decl = buildImplicitTypedef(Int128Ty, "__int128_t");
return Int128Decl;
1180}

1182TypedefDecl *ASTContext::getUInt128Decl() const {
if (!UInt128Decl)
  UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t");
return UInt128Decl;
1186}

1188void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
auto *Ty = new (*this, TypeAlignment) BuiltinType(K);
R = CanQualType::CreateUnsafe(QualType(Ty, 0));
Types.push_back(Ty);
1192}

1194void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
                                const TargetInfo *AuxTarget) {
assert((!this->Target || this->Target == &Target) &&(((!this->Target || this->Target == &Target) &&
 "Incorrect target reinitialization") ? static_cast<void>
 (0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Incorrect target reinitialization\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1197, __PRETTY_FUNCTION__))
       "Incorrect target reinitialization")(((!this->Target || this->Target == &Target) &&
 "Incorrect target reinitialization") ? static_cast<void>
 (0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Incorrect target reinitialization\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1197, __PRETTY_FUNCTION__));
assert(VoidTy.isNull() && "Context reinitialized?")((VoidTy.isNull() && "Context reinitialized?") ? static_cast
<void> (0) : __assert_fail ("VoidTy.isNull() && \"Context reinitialized?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1198, __PRETTY_FUNCTION__));

this->Target = &Target;
this->AuxTarget = AuxTarget;

ABI.reset(createCXXABI(Target));
AddrSpaceMap = getAddressSpaceMap(Target, LangOpts);
AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts);

// C99 6.2.5p19.
InitBuiltinType(VoidTy,              BuiltinType::Void);

// C99 6.2.5p2.
InitBuiltinType(BoolTy,              BuiltinType::Bool);
// C99 6.2.5p3.
if (LangOpts.CharIsSigned)
  InitBuiltinType(CharTy,            BuiltinType::Char_S);
else
  InitBuiltinType(CharTy,            BuiltinType::Char_U);
// C99 6.2.5p4.
InitBuiltinType(SignedCharTy,        BuiltinType::SChar);
InitBuiltinType(ShortTy,             BuiltinType::Short);
InitBuiltinType(IntTy,               BuiltinType::Int);
InitBuiltinType(LongTy,              BuiltinType::Long);
InitBuiltinType(LongLongTy,          BuiltinType::LongLong);

// C99 6.2.5p6.
InitBuiltinType(UnsignedCharTy,      BuiltinType::UChar);
InitBuiltinType(UnsignedShortTy,     BuiltinType::UShort);
InitBuiltinType(UnsignedIntTy,       BuiltinType::UInt);
InitBuiltinType(UnsignedLongTy,      BuiltinType::ULong);
InitBuiltinType(UnsignedLongLongTy,  BuiltinType::ULongLong);

// C99 6.2.5p10.
InitBuiltinType(FloatTy,             BuiltinType::Float);
InitBuiltinType(DoubleTy,            BuiltinType::Double);
InitBuiltinType(LongDoubleTy,        BuiltinType::LongDouble);

// GNU extension, __float128 for IEEE quadruple precision
InitBuiltinType(Float128Ty,          BuiltinType::Float128);

// C11 extension ISO/IEC TS 18661-3
InitBuiltinType(Float16Ty,           BuiltinType::Float16);

// ISO/IEC JTC1 SC22 WG14 N1169 Extension
InitBuiltinType(ShortAccumTy,            BuiltinType::ShortAccum);
InitBuiltinType(AccumTy,                 BuiltinType::Accum);
InitBuiltinType(LongAccumTy,             BuiltinType::LongAccum);
InitBuiltinType(UnsignedShortAccumTy,    BuiltinType::UShortAccum);
InitBuiltinType(UnsignedAccumTy,         BuiltinType::UAccum);
InitBuiltinType(UnsignedLongAccumTy,     BuiltinType::ULongAccum);
InitBuiltinType(ShortFractTy,            BuiltinType::ShortFract);
InitBuiltinType(FractTy,                 BuiltinType::Fract);
InitBuiltinType(LongFractTy,             BuiltinType::LongFract);
InitBuiltinType(UnsignedShortFractTy,    BuiltinType::UShortFract);
InitBuiltinType(UnsignedFractTy,         BuiltinType::UFract);
InitBuiltinType(UnsignedLongFractTy,     BuiltinType::ULongFract);
InitBuiltinType(SatShortAccumTy,         BuiltinType::SatShortAccum);
InitBuiltinType(SatAccumTy,              BuiltinType::SatAccum);
InitBuiltinType(SatLongAccumTy,          BuiltinType::SatLongAccum);
InitBuiltinType(SatUnsignedShortAccumTy, BuiltinType::SatUShortAccum);
InitBuiltinType(SatUnsignedAccumTy,      BuiltinType::SatUAccum);
InitBuiltinType(SatUnsignedLongAccumTy,  BuiltinType::SatULongAccum);
InitBuiltinType(SatShortFractTy,         BuiltinType::SatShortFract);
InitBuiltinType(SatFractTy,              BuiltinType::SatFract);
InitBuiltinType(SatLongFractTy,          BuiltinType::SatLongFract);
InitBuiltinType(SatUnsignedShortFractTy, BuiltinType::SatUShortFract);
InitBuiltinType(SatUnsignedFractTy,      BuiltinType::SatUFract);
InitBuiltinType(SatUnsignedLongFractTy,  BuiltinType::SatULongFract);

// GNU extension, 128-bit integers.
InitBuiltinType(Int128Ty,            BuiltinType::Int128);
InitBuiltinType(UnsignedInt128Ty,    BuiltinType::UInt128);

// C++ 3.9.1p5
if (TargetInfo::isTypeSigned(Target.getWCharType()))
  InitBuiltinType(WCharTy,           BuiltinType::WChar_S);
else  // -fshort-wchar makes wchar_t be unsigned.
  InitBuiltinType(WCharTy,           BuiltinType::WChar_U);
if (LangOpts.CPlusPlus && LangOpts.WChar)
  WideCharTy = WCharTy;
else {
  // C99 (or C++ using -fno-wchar).
  WideCharTy = getFromTargetType(Target.getWCharType());
}

WIntTy = getFromTargetType(Target.getWIntType());

// C++20 (proposed)
InitBuiltinType(Char8Ty,              BuiltinType::Char8);

if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
  InitBuiltinType(Char16Ty,           BuiltinType::Char16);
else // C99
  Char16Ty = getFromTargetType(Target.getChar16Type());

if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
  InitBuiltinType(Char32Ty,           BuiltinType::Char32);
else // C99
  Char32Ty = getFromTargetType(Target.getChar32Type());

// Placeholder type for type-dependent expressions whose type is
// completely unknown. No code should ever check a type against
// DependentTy and users should never see it; however, it is here to
// help diagnose failures to properly check for type-dependent
// expressions.
InitBuiltinType(DependentTy,         BuiltinType::Dependent);

// Placeholder type for functions.
InitBuiltinType(OverloadTy,          BuiltinType::Overload);

// Placeholder type for bound members.
InitBuiltinType(BoundMemberTy,       BuiltinType::BoundMember);

// Placeholder type for pseudo-objects.
InitBuiltinType(PseudoObjectTy,      BuiltinType::PseudoObject);

// "any" type; useful for debugger-like clients.
InitBuiltinType(UnknownAnyTy,        BuiltinType::UnknownAny);

// Placeholder type for unbridged ARC casts.
InitBuiltinType(ARCUnbridgedCastTy,  BuiltinType::ARCUnbridgedCast);

// Placeholder type for builtin functions.
InitBuiltinType(BuiltinFnTy,  BuiltinType::BuiltinFn);

// Placeholder type for OMP array sections.
if (LangOpts.OpenMP)
  InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection);

// C99 6.2.5p11.
FloatComplexTy      = getComplexType(FloatTy);
DoubleComplexTy     = getComplexType(DoubleTy);
LongDoubleComplexTy = getComplexType(LongDoubleTy);
Float128ComplexTy   = getComplexType(Float128Ty);

// Builtin types for 'id', 'Class', and 'SEL'.
InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);

if (LangOpts.OpenCL) {
1340#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
  InitBuiltinType(SingletonId, BuiltinType::Id);
1342#include "clang/Basic/OpenCLImageTypes.def"

  InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler);
  InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent);
  InitBuiltinType(OCLClkEventTy, BuiltinType::OCLClkEvent);
  InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue);
  InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID);

1350#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
  InitBuiltinType(Id##Ty, BuiltinType::Id);
1352#include "clang/Basic/OpenCLExtensionTypes.def"
}

if (Target.hasAArch64SVETypes()) {
1356#define SVE_TYPE(Name, Id, SingletonId) \
  InitBuiltinType(SingletonId, BuiltinType::Id);
1358#include "clang/Basic/AArch64SVEACLETypes.def"
}

// Builtin type for __objc_yes and __objc_no
ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
                     SignedCharTy : BoolTy);

ObjCConstantStringType = QualType();

ObjCSuperType = QualType();

// void * type
if (LangOpts.OpenCLVersion >= 200) {
  auto Q = VoidTy.getQualifiers();
  Q.setAddressSpace(LangAS::opencl_generic);
  VoidPtrTy = getPointerType(getCanonicalType(
      getQualifiedType(VoidTy.getUnqualifiedType(), Q)));
} else {
  VoidPtrTy = getPointerType(VoidTy);
}

// nullptr type (C++0x 2.14.7)
InitBuiltinType(NullPtrTy,           BuiltinType::NullPtr);

// half type (OpenCL 6.1.1.1) / ARM NEON __fp16
InitBuiltinType(HalfTy, BuiltinType::Half);

// Builtin type used to help define __builtin_va_list.
VaListTagDecl = nullptr;
1387}

1389DiagnosticsEngine &ASTContext::getDiagnostics() const {
return SourceMgr.getDiagnostics();
1391}

1393AttrVec& ASTContext::getDeclAttrs(const Decl *D) {
AttrVec *&Result = DeclAttrs[D];
if (!Result) {
  void *Mem = Allocate(sizeof(AttrVec));
  Result = new (Mem) AttrVec;
}

return *Result;
1401}

1403/// Erase the attributes corresponding to the given declaration.
1404void ASTContext::eraseDeclAttrs(const Decl *D) {
llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
if (Pos != DeclAttrs.end()) {
  Pos->second->~AttrVec();
  DeclAttrs.erase(Pos);
}
1410}

1412// FIXME: Remove ?
1413MemberSpecializationInfo *
1414ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) {
assert(Var->isStaticDataMember() && "Not a static data member")((Var->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Var->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1415, __PRETTY_FUNCTION__));
return getTemplateOrSpecializationInfo(Var)
    .dyn_cast<MemberSpecializationInfo *>();
1418}

1420ASTContext::TemplateOrSpecializationInfo
1421ASTContext::getTemplateOrSpecializationInfo(const VarDecl *Var) {
llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
    TemplateOrInstantiation.find(Var);
if (Pos == TemplateOrInstantiation.end())
  return {};

return Pos->second;
1428}

1430void
1431ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
                                              TemplateSpecializationKind TSK,
                                        SourceLocation PointOfInstantiation) {
assert(Inst->isStaticDataMember() && "Not a static data member")((Inst->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Inst->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1434, __PRETTY_FUNCTION__));
assert(Tmpl->isStaticDataMember() && "Not a static data member")((Tmpl->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Tmpl->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1435, __PRETTY_FUNCTION__));
setTemplateOrSpecializationInfo(Inst, new (*this) MemberSpecializationInfo(
                                          Tmpl, TSK, PointOfInstantiation));
1438}

1440void
1441ASTContext::setTemplateOrSpecializationInfo(VarDecl *Inst,
                                          TemplateOrSpecializationInfo TSI) {
assert(!TemplateOrInstantiation[Inst] &&((!TemplateOrInstantiation[Inst] && "Already noted what the variable was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!TemplateOrInstantiation[Inst] && \"Already noted what the variable was instantiated from\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1444, __PRETTY_FUNCTION__))
       "Already noted what the variable was instantiated from")((!TemplateOrInstantiation[Inst] && "Already noted what the variable was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!TemplateOrInstantiation[Inst] && \"Already noted what the variable was instantiated from\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1444, __PRETTY_FUNCTION__));
TemplateOrInstantiation[Inst] = TSI;
1446}

1448NamedDecl *
1449ASTContext::getInstantiatedFromUsingDecl(NamedDecl *UUD) {
auto Pos = InstantiatedFromUsingDecl.find(UUD);
if (Pos == InstantiatedFromUsingDecl.end())
  return nullptr;

return Pos->second;
1455}

1457void
1458ASTContext::setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern) {
assert((isa<UsingDecl>(Pattern) ||(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1462, __PRETTY_FUNCTION__))
        isa<UnresolvedUsingValueDecl>(Pattern) ||(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1462, __PRETTY_FUNCTION__))
        isa<UnresolvedUsingTypenameDecl>(Pattern)) &&(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1462, __PRETTY_FUNCTION__))
       "pattern decl is not a using decl")(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1462, __PRETTY_FUNCTION__));
assert((isa<UsingDecl>(Inst) ||(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
 "instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1466, __PRETTY_FUNCTION__))
        isa<UnresolvedUsingValueDecl>(Inst) ||(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
 "instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1466, __PRETTY_FUNCTION__))
        isa<UnresolvedUsingTypenameDecl>(Inst)) &&(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
 "instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1466, __PRETTY_FUNCTION__))
       "instantiation did not produce a using decl")(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
 "instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1466, __PRETTY_FUNCTION__));
assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists")((!InstantiatedFromUsingDecl[Inst] && "pattern already exists"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUsingDecl[Inst] && \"pattern already exists\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1467, __PRETTY_FUNCTION__));
InstantiatedFromUsingDecl[Inst] = Pattern;
1469}

1471UsingShadowDecl *
1472ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
  = InstantiatedFromUsingShadowDecl.find(Inst);
if (Pos == InstantiatedFromUsingShadowDecl.end())
  return nullptr;

return Pos->second;
1479}

1481void
1482ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
                                             UsingShadowDecl *Pattern) {
assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists")((!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUsingShadowDecl[Inst] && \"pattern already exists\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1484, __PRETTY_FUNCTION__));
InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1486}

1488FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) {
llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
  = InstantiatedFromUnnamedFieldDecl.find(Field);
if (Pos == InstantiatedFromUnnamedFieldDecl.end())
  return nullptr;

return Pos->second;
1495}

1497void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst,
                                                   FieldDecl *Tmpl) {
assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed")((!Inst->getDeclName() && "Instantiated field decl is not unnamed"
) ? static_cast<void> (0) : __assert_fail ("!Inst->getDeclName() && \"Instantiated field decl is not unnamed\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1499, __PRETTY_FUNCTION__));
assert(!Tmpl->getDeclName() && "Template field decl is not unnamed")((!Tmpl->getDeclName() && "Template field decl is not unnamed"
) ? static_cast<void> (0) : __assert_fail ("!Tmpl->getDeclName() && \"Template field decl is not unnamed\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1500, __PRETTY_FUNCTION__));
assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&((!InstantiatedFromUnnamedFieldDecl[Inst] && "Already noted what unnamed field was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUnnamedFieldDecl[Inst] && \"Already noted what unnamed field was instantiated from\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1502, __PRETTY_FUNCTION__))
       "Already noted what unnamed field was instantiated from")((!InstantiatedFromUnnamedFieldDecl[Inst] && "Already noted what unnamed field was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUnnamedFieldDecl[Inst] && \"Already noted what unnamed field was instantiated from\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1502, __PRETTY_FUNCTION__));

InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1505}

1507ASTContext::overridden_cxx_method_iterator
1508ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const {
return overridden_methods(Method).begin();
1510}

1512ASTContext::overridden_cxx_method_iterator
1513ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const {
return overridden_methods(Method).end();
1515}

1517unsigned
1518ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const {
auto Range = overridden_methods(Method);
return Range.end() - Range.begin();
1521}

1523ASTContext::overridden_method_range
1524ASTContext::overridden_methods(const CXXMethodDecl *Method) const {
llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
    OverriddenMethods.find(Method->getCanonicalDecl());
if (Pos == OverriddenMethods.end())
  return overridden_method_range(nullptr, nullptr);
return overridden_method_range(Pos->second.begin(), Pos->second.end());
1530}

1532void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method,
                                   const CXXMethodDecl *Overridden) {
assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl())((Method->isCanonicalDecl() && Overridden->isCanonicalDecl
()) ? static_cast<void> (0) : __assert_fail ("Method->isCanonicalDecl() && Overridden->isCanonicalDecl()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1534, __PRETTY_FUNCTION__));
OverriddenMethods[Method].push_back(Overridden);
1536}

1538void ASTContext::getOverriddenMethods(
                    const NamedDecl *D,
                    SmallVectorImpl<const NamedDecl *> &Overridden) const {
assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1541, __PRETTY_FUNCTION__));

if (const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
  Overridden.append(overridden_methods_begin(CXXMethod),
                    overridden_methods_end(CXXMethod));
  return;
}

const auto *Method = dyn_cast<ObjCMethodDecl>(D);
if (!Method)
  return;

SmallVector<const ObjCMethodDecl *, 8> OverDecls;
Method->getOverriddenMethods(OverDecls);
Overridden.append(OverDecls.begin(), OverDecls.end());
1556}

1558void ASTContext::addedLocalImportDecl(ImportDecl *Import) {
assert(!Import->NextLocalImport && "Import declaration already in the chain")((!Import->NextLocalImport && "Import declaration already in the chain"
) ? static_cast<void> (0) : __assert_fail ("!Import->NextLocalImport && \"Import declaration already in the chain\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1559, __PRETTY_FUNCTION__));
assert(!Import->isFromASTFile() && "Non-local import declaration")((!Import->isFromASTFile() && "Non-local import declaration"
) ? static_cast<void> (0) : __assert_fail ("!Import->isFromASTFile() && \"Non-local import declaration\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1560, __PRETTY_FUNCTION__));
if (!FirstLocalImport) {
  FirstLocalImport = Import;
  LastLocalImport = Import;
  return;
}

LastLocalImport->NextLocalImport = Import;
LastLocalImport = Import;
1569}

1571//===----------------------------------------------------------------------===//
1572//                         Type Sizing and Analysis
1573//===----------------------------------------------------------------------===//

1575/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
1576/// scalar floating point type.
1577const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
const auto *BT = T->getAs<BuiltinType>();
assert(BT && "Not a floating point type!")((BT && "Not a floating point type!") ? static_cast<
void> (0) : __assert_fail ("BT && \"Not a floating point type!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1579, __PRETTY_FUNCTION__));
switch (BT->getKind()) {
default: llvm_unreachable("Not a floating point type!")::llvm::llvm_unreachable_internal("Not a floating point type!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1581);
case BuiltinType::Float16:
case BuiltinType::Half:
  return Target->getHalfFormat();
case BuiltinType::Float:      return Target->getFloatFormat();
case BuiltinType::Double:     return Target->getDoubleFormat();
case BuiltinType::LongDouble:
  if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)
    return AuxTarget->getLongDoubleFormat();
  return Target->getLongDoubleFormat();
case BuiltinType::Float128:
  if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)
    return AuxTarget->getFloat128Format();
  return Target->getFloat128Format();
}
1596}

1598CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
unsigned Align = Target->getCharWidth();

bool UseAlignAttrOnly = false;
if (unsigned AlignFromAttr = D->getMaxAlignment()) {
  Align = AlignFromAttr;

  // __attribute__((aligned)) can increase or decrease alignment
  // *except* on a struct or struct member, where it only increases
  // alignment unless 'packed' is also specified.
  //
  // It is an error for alignas to decrease alignment, so we can
  // ignore that possibility;  Sema should diagnose it.
  if (isa<FieldDecl>(D)) {
    UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
      cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
  } else {
    UseAlignAttrOnly = true;
  }
}
else if (isa<FieldDecl>(D))
    UseAlignAttrOnly =
      D->hasAttr<PackedAttr>() ||
      cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();

// If we're using the align attribute only, just ignore everything
// else about the declaration and its type.
if (UseAlignAttrOnly) {
  // do nothing
} else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
  QualType T = VD->getType();
  if (const auto *RT = T->getAs<ReferenceType>()) {
    if (ForAlignof)
      T = RT->getPointeeType();
    else
      T = getPointerType(RT->getPointeeType());
  }
  QualType BaseT = getBaseElementType(T);
  if (T->isFunctionType())
    Align = getTypeInfoImpl(T.getTypePtr()).Align;
  else if (!BaseT->isIncompleteType()) {
    // Adjust alignments of declarations with array type by the
    // large-array alignment on the target.
    if (const ArrayType *arrayType = getAsArrayType(T)) {
      unsigned MinWidth = Target->getLargeArrayMinWidth();
      if (!ForAlignof && MinWidth) {
        if (isa<VariableArrayType>(arrayType))
          Align = std::max(Align, Target->getLargeArrayAlign());
        else if (isa<ConstantArrayType>(arrayType) &&
                 MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType)))
          Align = std::max(Align, Target->getLargeArrayAlign());
      }
    }
    Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
    if (BaseT.getQualifiers().hasUnaligned())
      Align = Target->getCharWidth();
    if (const auto *VD = dyn_cast<VarDecl>(D)) {
      if (VD->hasGlobalStorage() && !ForAlignof) {
        uint64_t TypeSize = getTypeSize(T.getTypePtr());
        Align = std::max(Align, getTargetInfo().getMinGlobalAlign(TypeSize));
      }
    }
  }

  // Fields can be subject to extra alignment constraints, like if
  // the field is packed, the struct is packed, or the struct has a
  // a max-field-alignment constraint (#pragma pack).  So calculate
  // the actual alignment of the field within the struct, and then
  // (as we're expected to) constrain that by the alignment of the type.
  if (const auto *Field = dyn_cast<FieldDecl>(VD)) {
    const RecordDecl *Parent = Field->getParent();
    // We can only produce a sensible answer if the record is valid.
    if (!Parent->isInvalidDecl()) {
      const ASTRecordLayout &Layout = getASTRecordLayout(Parent);

      // Start with the record's overall alignment.
      unsigned FieldAlign = toBits(Layout.getAlignment());

      // Use the GCD of that and the offset within the record.
      uint64_t Offset = Layout.getFieldOffset(Field->getFieldIndex());
      if (Offset > 0) {
        // Alignment is always a power of 2, so the GCD will be a power of 2,
        // which means we get to do this crazy thing instead of Euclid's.
        uint64_t LowBitOfOffset = Offset & (~Offset + 1);
        if (LowBitOfOffset < FieldAlign)
          FieldAlign = static_cast<unsigned>(LowBitOfOffset);
      }

      Align = std::min(Align, FieldAlign);
    }
  }
}

return toCharUnitsFromBits(Align);
1692}

1694// getTypeInfoDataSizeInChars - Return the size of a type, in
1695// chars. If the type is a record, its data size is returned.  This is
1696// the size of the memcpy that's performed when assigning this type
1697// using a trivial copy/move assignment operator.
1698std::pair<CharUnits, CharUnits>
1699ASTContext::getTypeInfoDataSizeInChars(QualType T) const {
std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);

// In C++, objects can sometimes be allocated into the tail padding
// of a base-class subobject.  We decide whether that's possible
// during class layout, so here we can just trust the layout results.
if (getLangOpts().CPlusPlus) {
  if (const auto *RT = T->getAs<RecordType>()) {
    const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl());
    sizeAndAlign.first = layout.getDataSize();
  }
}

return sizeAndAlign;
1713}

1715/// getConstantArrayInfoInChars - Performing the computation in CharUnits
1716/// instead of in bits prevents overflowing the uint64_t for some large arrays.
1717std::pair<CharUnits, CharUnits>
1718static getConstantArrayInfoInChars(const ASTContext &Context,
                                 const ConstantArrayType *CAT) {
std::pair<CharUnits, CharUnits> EltInfo =
    Context.getTypeInfoInChars(CAT->getElementType());
uint64_t Size = CAT->getSize().getZExtValue();
assert((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <=(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<void> (0) : __assert_fail ("(Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= (uint64_t)(-1)/Size) && \"Overflow in array type char size evaluation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1725, __PRETTY_FUNCTION__))
            (uint64_t)(-1)/Size) &&(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<void> (0) : __assert_fail ("(Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= (uint64_t)(-1)/Size) && \"Overflow in array type char size evaluation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1725, __PRETTY_FUNCTION__))
       "Overflow in array type char size evaluation")(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<void> (0) : __assert_fail ("(Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= (uint64_t)(-1)/Size) && \"Overflow in array type char size evaluation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1725, __PRETTY_FUNCTION__));
uint64_t Width = EltInfo.first.getQuantity() * Size;
unsigned Align = EltInfo.second.getQuantity();
if (!Context.getTargetInfo().getCXXABI().isMicrosoft() ||
    Context.getTargetInfo().getPointerWidth(0) == 64)
  Width = llvm::alignTo(Width, Align);
return std::make_pair(CharUnits::fromQuantity(Width),
                      CharUnits::fromQuantity(Align));
1733}

1735std::pair<CharUnits, CharUnits>
1736ASTContext::getTypeInfoInChars(const Type *T) const {
if (const auto *CAT = dyn_cast<ConstantArrayType>(T))
  return getConstantArrayInfoInChars(*this, CAT);
TypeInfo Info = getTypeInfo(T);
return std::make_pair(toCharUnitsFromBits(Info.Width),
                      toCharUnitsFromBits(Info.Align));
1742}

1744std::pair<CharUnits, CharUnits>
1745ASTContext::getTypeInfoInChars(QualType T) const {
return getTypeInfoInChars(T.getTypePtr());
1747}

1749bool ASTContext::isAlignmentRequired(const Type *T) const {
return getTypeInfo(T).AlignIsRequired;
1751}

1753bool ASTContext::isAlignmentRequired(QualType T) const {
return isAlignmentRequired(T.getTypePtr());
1755}

1757unsigned ASTContext::getTypeAlignIfKnown(QualType T) const {
// An alignment on a typedef overrides anything else.
if (const auto *TT = T->getAs<TypedefType>())
  if (unsigned Align = TT->getDecl()->getMaxAlignment())
    return Align;

// If we have an (array of) complete type, we're done.
T = getBaseElementType(T);
if (!T->isIncompleteType())
  return getTypeAlign(T);

// If we had an array type, its element type might be a typedef
// type with an alignment attribute.
if (const auto *TT = T->getAs<TypedefType>())
  if (unsigned Align = TT->getDecl()->getMaxAlignment())
    return Align;

// Otherwise, see if the declaration of the type had an attribute.
if (const auto *TT = T->getAs<TagType>())
  return TT->getDecl()->getMaxAlignment();

return 0;
1779}

1781TypeInfo ASTContext::getTypeInfo(const Type *T) const {
TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
if (I != MemoizedTypeInfo.end())
  return I->second;

// This call can invalidate MemoizedTypeInfo[T], so we need a second lookup.
TypeInfo TI = getTypeInfoImpl(T);
MemoizedTypeInfo[T] = TI;
return TI;
1790}

1792/// getTypeInfoImpl - Return the size of the specified type, in bits.  This
1793/// method does not work on incomplete types.
1794///
1795/// FIXME: Pointers into different addr spaces could have different sizes and
1796/// alignment requirements: getPointerInfo should take an AddrSpace, this
1797/// should take a QualType, &c.
1798TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
uint64_t Width = 0;
unsigned Align = 8;
bool AlignIsRequired = false;
unsigned AS = 0;
switch (T->getTypeClass()) {
1804#define TYPE(Class, Base)
1805#define ABSTRACT_TYPE(Class, Base)
1806#define NON_CANONICAL_TYPE(Class, Base)
1807#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1808#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)                       \
case Type::Class:                                                            \
assert(!T->isDependentType() && "should not see dependent types here")((!T->isDependentType() && "should not see dependent types here"
) ? static_cast<void> (0) : __assert_fail ("!T->isDependentType() && \"should not see dependent types here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1810, __PRETTY_FUNCTION__));      \
return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1812#include "clang/AST/TypeNodes.inc"
  llvm_unreachable("Should not see dependent types")::llvm::llvm_unreachable_internal("Should not see dependent types"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1813);

case Type::FunctionNoProto:
case Type::FunctionProto:
  // GCC extension: alignof(function) = 32 bits
  Width = 0;
  Align = 32;
  break;

case Type::IncompleteArray:
case Type::VariableArray:
  Width = 0;
  Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
  break;

case Type::ConstantArray: {
  const auto *CAT = cast<ConstantArrayType>(T);

  TypeInfo EltInfo = getTypeInfo(CAT->getElementType());
  uint64_t Size = CAT->getSize().getZExtValue();
  assert((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&(((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
 "Overflow in array type bit size evaluation") ? static_cast<
void> (0) : __assert_fail ("(Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && \"Overflow in array type bit size evaluation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1834, __PRETTY_FUNCTION__))
         "Overflow in array type bit size evaluation")(((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
 "Overflow in array type bit size evaluation") ? static_cast<
void> (0) : __assert_fail ("(Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && \"Overflow in array type bit size evaluation\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1834, __PRETTY_FUNCTION__));
  Width = EltInfo.Width * Size;
  Align = EltInfo.Align;
  if (!getTargetInfo().getCXXABI().isMicrosoft() ||
      getTargetInfo().getPointerWidth(0) == 64)
    Width = llvm::alignTo(Width, Align);
  break;
}
case Type::ExtVector:
case Type::Vector: {
  const auto *VT = cast<VectorType>(T);
  TypeInfo EltInfo = getTypeInfo(VT->getElementType());
  Width = EltInfo.Width * VT->getNumElements();
  Align = Width;
  // If the alignment is not a power of 2, round up to the next power of 2.
  // This happens for non-power-of-2 length vectors.
  if (Align & (Align-1)) {
    Align = llvm::NextPowerOf2(Align);
    Width = llvm::alignTo(Width, Align);
  }
  // Adjust the alignment based on the target max.
  uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
  if (TargetVectorAlign && TargetVectorAlign < Align)
    Align = TargetVectorAlign;
  break;
}

case Type::Builtin:
  switch (cast<BuiltinType>(T)->getKind()) {
  default: llvm_unreachable("Unknown builtin type!")::llvm::llvm_unreachable_internal("Unknown builtin type!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1863);
  case BuiltinType::Void:
    // GCC extension: alignof(void) = 8 bits.
    Width = 0;
    Align = 8;
    break;
  case BuiltinType::Bool:
    Width = Target->getBoolWidth();
    Align = Target->getBoolAlign();
    break;
  case BuiltinType::Char_S:
  case BuiltinType::Char_U:
  case BuiltinType::UChar:
  case BuiltinType::SChar:
  case BuiltinType::Char8:
    Width = Target->getCharWidth();
    Align = Target->getCharAlign();
    break;
  case BuiltinType::WChar_S:
  case BuiltinType::WChar_U:
    Width = Target->getWCharWidth();
    Align = Target->getWCharAlign();
    break;
  case BuiltinType::Char16:
    Width = Target->getChar16Width();
    Align = Target->getChar16Align();
    break;
  case BuiltinType::Char32:
    Width = Target->getChar32Width();
    Align = Target->getChar32Align();
    break;
  case BuiltinType::UShort:
  case BuiltinType::Short:
    Width = Target->getShortWidth();
    Align = Target->getShortAlign();
    break;
  case BuiltinType::UInt:
  case BuiltinType::Int:
    Width = Target->getIntWidth();
    Align = Target->getIntAlign();
    break;
  case BuiltinType::ULong:
  case BuiltinType::Long:
    Width = Target->getLongWidth();
    Align = Target->getLongAlign();
    break;
  case BuiltinType::ULongLong:
  case BuiltinType::LongLong:
    Width = Target->getLongLongWidth();
    Align = Target->getLongLongAlign();
    break;
  case BuiltinType::Int128:
  case BuiltinType::UInt128:
    Width = 128;
    Align = 128; // int128_t is 128-bit aligned on all targets.
    break;
  case BuiltinType::ShortAccum:
  case BuiltinType::UShortAccum:
  case BuiltinType::SatShortAccum:
  case BuiltinType::SatUShortAccum:
    Width = Target->getShortAccumWidth();
    Align = Target->getShortAccumAlign();
    break;
  case BuiltinType::Accum:
  case BuiltinType::UAccum:
  case BuiltinType::SatAccum:
  case BuiltinType::SatUAccum:
    Width = Target->getAccumWidth();
    Align = Target->getAccumAlign();
    break;
  case BuiltinType::LongAccum:
  case BuiltinType::ULongAccum:
  case BuiltinType::SatLongAccum:
  case BuiltinType::SatULongAccum:
    Width = Target->getLongAccumWidth();
    Align = Target->getLongAccumAlign();
    break;
  case BuiltinType::ShortFract:
  case BuiltinType::UShortFract:
  case BuiltinType::SatShortFract:
  case BuiltinType::SatUShortFract:
    Width = Target->getShortFractWidth();
    Align = Target->getShortFractAlign();
    break;
  case BuiltinType::Fract:
  case BuiltinType::UFract:
  case BuiltinType::SatFract:
  case BuiltinType::SatUFract:
    Width = Target->getFractWidth();
    Align = Target->getFractAlign();
    break;
  case BuiltinType::LongFract:
  case BuiltinType::ULongFract:
  case BuiltinType::SatLongFract:
  case BuiltinType::SatULongFract:
    Width = Target->getLongFractWidth();
    Align = Target->getLongFractAlign();
    break;
  case BuiltinType::Float16:
  case BuiltinType::Half:
    if (Target->hasFloat16Type() || !getLangOpts().OpenMP ||
        !getLangOpts().OpenMPIsDevice) {
      Width = Target->getHalfWidth();
      Align = Target->getHalfAlign();
    } else {
      assert(getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice &&((getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice
 && "Expected OpenMP device compilation.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice && \"Expected OpenMP device compilation.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1969, __PRETTY_FUNCTION__))
             "Expected OpenMP device compilation.")((getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice
 && "Expected OpenMP device compilation.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice && \"Expected OpenMP device compilation.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 1969, __PRETTY_FUNCTION__));
      Width = AuxTarget->getHalfWidth();
      Align = AuxTarget->getHalfAlign();
    }
    break;
  case BuiltinType::Float:
    Width = Target->getFloatWidth();
    Align = Target->getFloatAlign();
    break;
  case BuiltinType::Double:
    Width = Target->getDoubleWidth();
    Align = Target->getDoubleAlign();
    break;
  case BuiltinType::LongDouble:
    if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice &&
        (Target->getLongDoubleWidth() != AuxTarget->getLongDoubleWidth() ||
         Target->getLongDoubleAlign() != AuxTarget->getLongDoubleAlign())) {
      Width = AuxTarget->getLongDoubleWidth();
      Align = AuxTarget->getLongDoubleAlign();
    } else {
      Width = Target->getLongDoubleWidth();
      Align = Target->getLongDoubleAlign();
    }
    break;
  case BuiltinType::Float128:
    if (Target->hasFloat128Type() || !getLangOpts().OpenMP ||
        !getLangOpts().OpenMPIsDevice) {
      Width = Target->getFloat128Width();
      Align = Target->getFloat128Align();
    } else {
      assert(getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice &&((getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice
 && "Expected OpenMP device compilation.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice && \"Expected OpenMP device compilation.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2000, __PRETTY_FUNCTION__))
             "Expected OpenMP device compilation.")((getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice
 && "Expected OpenMP device compilation.") ? static_cast
<void> (0) : __assert_fail ("getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice && \"Expected OpenMP device compilation.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2000, __PRETTY_FUNCTION__));
      Width = AuxTarget->getFloat128Width();
      Align = AuxTarget->getFloat128Align();
    }
    break;
  case BuiltinType::NullPtr:
    Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
    Align = Target->getPointerAlign(0); //   == sizeof(void*)
    break;
  case BuiltinType::ObjCId:
  case BuiltinType::ObjCClass:
  case BuiltinType::ObjCSel:
    Width = Target->getPointerWidth(0);
    Align = Target->getPointerAlign(0);
    break;
  case BuiltinType::OCLSampler:
  case BuiltinType::OCLEvent:
  case BuiltinType::OCLClkEvent:
  case BuiltinType::OCLQueue:
  case BuiltinType::OCLReserveID:
2020#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
  case BuiltinType::Id:
2022#include "clang/Basic/OpenCLImageTypes.def"
2023#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
2025#include "clang/Basic/OpenCLExtensionTypes.def"
    AS = getTargetAddressSpace(
        Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T)));
    Width = Target->getPointerWidth(AS);
    Align = Target->getPointerAlign(AS);
    break;
  // The SVE types are effectively target-specific.  The length of an
  // SVE_VECTOR_TYPE is only known at runtime, but it is always a multiple
  // of 128 bits.  There is one predicate bit for each vector byte, so the
  // length of an SVE_PREDICATE_TYPE is always a multiple of 16 bits.
  //
  // Because the length is only known at runtime, we use a dummy value
  // of 0 for the static length.  The alignment values are those defined
  // by the Procedure Call Standard for the Arm Architecture.
2039#define SVE_VECTOR_TYPE(Name, Id, SingletonId, ElKind, ElBits, IsSigned, IsFP)\
  case BuiltinType::Id: \
    Width = 0; \
    Align = 128; \
    break;
2044#define SVE_PREDICATE_TYPE(Name, Id, SingletonId, ElKind) \
  case BuiltinType::Id: \
    Width = 0; \
    Align = 16; \
    break;
2049#include "clang/Basic/AArch64SVEACLETypes.def"
  }
  break;
case Type::ObjCObjectPointer:
  Width = Target->getPointerWidth(0);
  Align = Target->getPointerAlign(0);
  break;
case Type::BlockPointer:
  AS = getTargetAddressSpace(cast<BlockPointerType>(T)->getPointeeType());
  Width = Target->getPointerWidth(AS);
  Align = Target->getPointerAlign(AS);
  break;
case Type::LValueReference:
case Type::RValueReference:
  // alignof and sizeof should never enter this code path here, so we go
  // the pointer route.
  AS = getTargetAddressSpace(cast<ReferenceType>(T)->getPointeeType());
  Width = Target->getPointerWidth(AS);
  Align = Target->getPointerAlign(AS);
  break;
case Type::Pointer:
  AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType());
  Width = Target->getPointerWidth(AS);
  Align = Target->getPointerAlign(AS);
  break;
case Type::MemberPointer: {
  const auto *MPT = cast<MemberPointerType>(T);
  CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
  Width = MPI.Width;
  Align = MPI.Align;
  break;
}
case Type::Complex: {
  // Complex types have the same alignment as their elements, but twice the
  // size.
  TypeInfo EltInfo = getTypeInfo(cast<ComplexType>(T)->getElementType());
  Width = EltInfo.Width * 2;
  Align = EltInfo.Align;
  break;
}
case Type::ObjCObject:
  return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
case Type::Adjusted:
case Type::Decayed:
  return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr());
case Type::ObjCInterface: {
  const auto *ObjCI = cast<ObjCInterfaceType>(T);
  const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
  Width = toBits(Layout.getSize());
  Align = toBits(Layout.getAlignment());
  break;
}
case Type::Record:
case Type::Enum: {
  const auto *TT = cast<TagType>(T);

  if (TT->getDecl()->isInvalidDecl()) {
    Width = 8;
    Align = 8;
    break;
  }

  if (const auto *ET = dyn_cast<EnumType>(TT)) {
    const EnumDecl *ED = ET->getDecl();
    TypeInfo Info =
        getTypeInfo(ED->getIntegerType()->getUnqualifiedDesugaredType());
    if (unsigned AttrAlign = ED->getMaxAlignment()) {
      Info.Align = AttrAlign;
      Info.AlignIsRequired = true;
    }
    return Info;
  }

  const auto *RT = cast<RecordType>(TT);
  const RecordDecl *RD = RT->getDecl();
  const ASTRecordLayout &Layout = getASTRecordLayout(RD);
  Width = toBits(Layout.getSize());
  Align = toBits(Layout.getAlignment());
  AlignIsRequired = RD->hasAttr<AlignedAttr>();
  break;
}

case Type::SubstTemplateTypeParm:
  return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
                     getReplacementType().getTypePtr());

case Type::Auto:
case Type::DeducedTemplateSpecialization: {
  const auto *A = cast<DeducedType>(T);
  assert(!A->getDeducedType().isNull() &&((!A->getDeducedType().isNull() && "cannot request the size of an undeduced or dependent auto type"
) ? static_cast<void> (0) : __assert_fail ("!A->getDeducedType().isNull() && \"cannot request the size of an undeduced or dependent auto type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2139, __PRETTY_FUNCTION__))
         "cannot request the size of an undeduced or dependent auto type")((!A->getDeducedType().isNull() && "cannot request the size of an undeduced or dependent auto type"
) ? static_cast<void> (0) : __assert_fail ("!A->getDeducedType().isNull() && \"cannot request the size of an undeduced or dependent auto type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2139, __PRETTY_FUNCTION__));
  return getTypeInfo(A->getDeducedType().getTypePtr());
}

case Type::Paren:
  return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());

case Type::MacroQualified:
  return getTypeInfo(
      cast<MacroQualifiedType>(T)->getUnderlyingType().getTypePtr());

case Type::ObjCTypeParam:
  return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());

case Type::Typedef: {
  const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
  TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
  // If the typedef has an aligned attribute on it, it overrides any computed
  // alignment we have.  This violates the GCC documentation (which says that
  // attribute(aligned) can only round up) but matches its implementation.
  if (unsigned AttrAlign = Typedef->getMaxAlignment()) {
    Align = AttrAlign;
    AlignIsRequired = true;
  } else {
    Align = Info.Align;
    AlignIsRequired = Info.AlignIsRequired;
  }
  Width = Info.Width;
  break;
}

case Type::Elaborated:
  return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());

case Type::Attributed:
  return getTypeInfo(
                cast<AttributedType>(T)->getEquivalentType().getTypePtr());

case Type::Atomic: {
  // Start with the base type information.
  TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType());
  Width = Info.Width;
  Align = Info.Align;

  if (!Width) {
    // An otherwise zero-sized type should still generate an
    // atomic operation.
    Width = Target->getCharWidth();
    assert(Align)((Align) ? static_cast<void> (0) : __assert_fail ("Align"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2187, __PRETTY_FUNCTION__));
  } else if (Width <= Target->getMaxAtomicPromoteWidth()) {
    // If the size of the type doesn't exceed the platform's max
    // atomic promotion width, make the size and alignment more
    // favorable to atomic operations:

    // Round the size up to a power of 2.
    if (!llvm::isPowerOf2_64(Width))
      Width = llvm::NextPowerOf2(Width);

    // Set the alignment equal to the size.
    Align = static_cast<unsigned>(Width);
  }
}
break;

case Type::Pipe:
  Width = Target->getPointerWidth(getTargetAddressSpace(LangAS::opencl_global));
  Align = Target->getPointerAlign(getTargetAddressSpace(LangAS::opencl_global));
  break;
}

assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2")((llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"
) ? static_cast<void> (0) : __assert_fail ("llvm::isPowerOf2_32(Align) && \"Alignment must be power of 2\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2209, __PRETTY_FUNCTION__));
return TypeInfo(Width, Align, AlignIsRequired);
2211}

2213unsigned ASTContext::getTypeUnadjustedAlign(const Type *T) const {
UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(T);
if (I != MemoizedUnadjustedAlign.end())
  return I->second;

unsigned UnadjustedAlign;
if (const auto *RT = T->getAs<RecordType>()) {
  const RecordDecl *RD = RT->getDecl();
  const ASTRecordLayout &Layout = getASTRecordLayout(RD);
  UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
} else if (const auto *ObjCI = T->getAs<ObjCInterfaceType>()) {
  const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
  UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
} else {
  UnadjustedAlign = getTypeAlign(T->getUnqualifiedDesugaredType());
}

MemoizedUnadjustedAlign[T] = UnadjustedAlign;
return UnadjustedAlign;
2232}

2234unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const {
unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign();
// Target ppc64 with QPX: simd default alignment for pointer to double is 32.
if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 ||
     getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) &&
    getTargetInfo().getABI() == "elfv1-qpx" &&
    T->isSpecificBuiltinType(BuiltinType::Double))
  SimdAlign = 256;
return SimdAlign;
2243}

2245/// toCharUnitsFromBits - Convert a size in bits to a size in characters.
2246CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
return CharUnits::fromQuantity(BitSize / getCharWidth());
2248}

2250/// toBits - Convert a size in characters to a size in characters.
2251int64_t ASTContext::toBits(CharUnits CharSize) const {
return CharSize.getQuantity() * getCharWidth();
2253}

2255/// getTypeSizeInChars - Return the size of the specified type, in characters.
2256/// This method does not work on incomplete types.
2257CharUnits ASTContext::getTypeSizeInChars(QualType T) const {
return getTypeInfoInChars(T).first;
2259}
2260CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
return getTypeInfoInChars(T).first;
2262}

2264/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
2265/// characters. This method does not work on incomplete types.
2266CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
return toCharUnitsFromBits(getTypeAlign(T));
2268}
2269CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
return toCharUnitsFromBits(getTypeAlign(T));
2271}

2273/// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a
2274/// type, in characters, before alignment adustments. This method does
2275/// not work on incomplete types.
2276CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const {
return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
2278}
2279CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
2281}

2283/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
2284/// type for the current target in bits.  This can be different than the ABI
2285/// alignment in cases where it is beneficial for performance to overalign
2286/// a data type.
2287unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
TypeInfo TI = getTypeInfo(T);
unsigned ABIAlign = TI.Align;

T = T->getBaseElementTypeUnsafe();

// The preferred alignment of member pointers is that of a pointer.
if (T->isMemberPointerType())
  return getPreferredTypeAlign(getPointerDiffType().getTypePtr());

if (!Target->allowsLargerPreferedTypeAlignment())
  return ABIAlign;

// Double and long long should be naturally aligned if possible.
if (const auto *CT = T->getAs<ComplexType>())
  T = CT->getElementType().getTypePtr();
if (const auto *ET = T->getAs<EnumType>())
  T = ET->getDecl()->getIntegerType().getTypePtr();
if (T->isSpecificBuiltinType(BuiltinType::Double) ||
    T->isSpecificBuiltinType(BuiltinType::LongLong) ||
    T->isSpecificBuiltinType(BuiltinType::ULongLong))
  // Don't increase the alignment if an alignment attribute was specified on a
  // typedef declaration.
  if (!TI.AlignIsRequired)
    return std::max(ABIAlign, (unsigned)getTypeSize(T));

return ABIAlign;
2314}

2316/// getTargetDefaultAlignForAttributeAligned - Return the default alignment
2317/// for __attribute__((aligned)) on this target, to be used if no alignment
2318/// value is specified.
2319unsigned ASTContext::getTargetDefaultAlignForAttributeAligned() const {
return getTargetInfo().getDefaultAlignForAttributeAligned();
2321}

2323/// getAlignOfGlobalVar - Return the alignment in bits that should be given
2324/// to a global variable of the specified type.
2325unsigned ASTContext::getAlignOfGlobalVar(QualType T) const {
uint64_t TypeSize = getTypeSize(T.getTypePtr());
return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign(TypeSize));
2328}

2330/// getAlignOfGlobalVarInChars - Return the alignment in characters that
2331/// should be given to a global variable of the specified type.
2332CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const {
return toCharUnitsFromBits(getAlignOfGlobalVar(T));
2334}

2336CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const {
CharUnits Offset = CharUnits::Zero();
const ASTRecordLayout *Layout = &getASTRecordLayout(RD);
while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) {
  Offset += Layout->getBaseClassOffset(Base);
  Layout = &getASTRecordLayout(Base);
}
return Offset;
2344}

2346/// DeepCollectObjCIvars -
2347/// This routine first collects all declared, but not synthesized, ivars in
2348/// super class and then collects all ivars, including those synthesized for
2349/// current class. This routine is used for implementation of current class
2350/// when all ivars, declared and synthesized are known.
2351void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
                                    bool leafClass,
                          SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
  DeepCollectObjCIvars(SuperClass, false, Ivars);
if (!leafClass) {
  for (const auto *I : OI->ivars())
    Ivars.push_back(I);
} else {
  auto *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
  for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
       Iv= Iv->getNextIvar())
    Ivars.push_back(Iv);
}
2365}

2367/// CollectInheritedProtocols - Collect all protocols in current class and
2368/// those inherited by it.
2369void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
                        llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
if (const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
  // We can use protocol_iterator here instead of
  // all_referenced_protocol_iterator since we are walking all categories.
  for (auto *Proto : OI->all_referenced_protocols()) {
    CollectInheritedProtocols(Proto, Protocols);
  }

  // Categories of this Interface.
  for (const auto *Cat : OI->visible_categories())
    CollectInheritedProtocols(Cat, Protocols);

  if (ObjCInterfaceDecl *SD = OI->getSuperClass())
    while (SD) {
      CollectInheritedProtocols(SD, Protocols);
      SD = SD->getSuperClass();
    }
} else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
  for (auto *Proto : OC->protocols()) {
    CollectInheritedProtocols(Proto, Protocols);
  }
} else if (const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
  // Insert the protocol.
  if (!Protocols.insert(
        const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second)
    return;

  for (auto *Proto : OP->protocols())
    CollectInheritedProtocols(Proto, Protocols);
}
2400}

2402static bool unionHasUniqueObjectRepresentations(const ASTContext &Context,
                                              const RecordDecl *RD) {
assert(RD->isUnion() && "Must be union type")((RD->isUnion() && "Must be union type") ? static_cast
<void> (0) : __assert_fail ("RD->isUnion() && \"Must be union type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2404, __PRETTY_FUNCTION__));
CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());

for (const auto *Field : RD->fields()) {
  if (!Context.hasUniqueObjectRepresentations(Field->getType()))
    return false;
  CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
  if (FieldSize != UnionSize)
    return false;
}
return !RD->field_empty();
2415}

2417static bool isStructEmpty(QualType Ty) {
const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();

if (!RD->field_empty())
  return false;

if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
  return ClassDecl->isEmpty();

return true;
2427}

2429static llvm::Optional<int64_t>
2430structHasUniqueObjectRepresentations(const ASTContext &Context,
                                   const RecordDecl *RD) {
assert(!RD->isUnion() && "Must be struct/class type")((!RD->isUnion() && "Must be struct/class type") ?
 static_cast<void> (0) : __assert_fail ("!RD->isUnion() && \"Must be struct/class type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2432, __PRETTY_FUNCTION__));
const auto &Layout = Context.getASTRecordLayout(RD);

int64_t CurOffsetInBits = 0;
if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
  if (ClassDecl->isDynamicClass())
    return llvm::None;

  SmallVector<std::pair<QualType, int64_t>, 4> Bases;
  for (const auto Base : ClassDecl->bases()) {
    // Empty types can be inherited from, and non-empty types can potentially
    // have tail padding, so just make sure there isn't an error.
    if (!isStructEmpty(Base.getType())) {
      llvm::Optional<int64_t> Size = structHasUniqueObjectRepresentations(
          Context, Base.getType()->castAs<RecordType>()->getDecl());
      if (!Size)
        return llvm::None;
      Bases.emplace_back(Base.getType(), Size.getValue());
    }
  }

  llvm::sort(Bases, [&](const std::pair<QualType, int64_t> &L,
                        const std::pair<QualType, int64_t> &R) {
    return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) <
           Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl());
  });

  for (const auto Base : Bases) {
    int64_t BaseOffset = Context.toBits(
        Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl()));
    int64_t BaseSize = Base.second;
    if (BaseOffset != CurOffsetInBits)
      return llvm::None;
    CurOffsetInBits = BaseOffset + BaseSize;
  }
}

for (const auto *Field : RD->fields()) {
  if (!Field->getType()->isReferenceType() &&
      !Context.hasUniqueObjectRepresentations(Field->getType()))
    return llvm::None;

  int64_t FieldSizeInBits =
      Context.toBits(Context.getTypeSizeInChars(Field->getType()));
  if (Field->isBitField()) {
    int64_t BitfieldSize = Field->getBitWidthValue(Context);

    if (BitfieldSize > FieldSizeInBits)
      return llvm::None;
    FieldSizeInBits = BitfieldSize;
  }

  int64_t FieldOffsetInBits = Context.getFieldOffset(Field);

  if (FieldOffsetInBits != CurOffsetInBits)
    return llvm::None;

  CurOffsetInBits = FieldSizeInBits + FieldOffsetInBits;
}

return CurOffsetInBits;
2493}

2495bool ASTContext::hasUniqueObjectRepresentations(QualType Ty) const {
// C++17 [meta.unary.prop]:
//   The predicate condition for a template specialization
//   has_unique_object_representations<T> shall be
//   satisfied if and only if:
//     (9.1) - T is trivially copyable, and
//     (9.2) - any two objects of type T with the same value have the same
//     object representation, where two objects
//   of array or non-union class type are considered to have the same value
//   if their respective sequences of
//   direct subobjects have the same values, and two objects of union type
//   are considered to have the same
//   value if they have the same active member and the corresponding members
//   have the same value.
//   The set of scalar types for which this condition holds is
//   implementation-defined. [ Note: If a type has padding
//   bits, the condition does not hold; otherwise, the condition holds true
//   for unsigned integral types. -- end note ]
assert(!Ty.isNull() && "Null QualType sent to unique object rep check")((!Ty.isNull() && "Null QualType sent to unique object rep check"
) ? static_cast<void> (0) : __assert_fail ("!Ty.isNull() && \"Null QualType sent to unique object rep check\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2513, __PRETTY_FUNCTION__));

// Arrays are unique only if their element type is unique.
if (Ty->isArrayType())
  return hasUniqueObjectRepresentations(getBaseElementType(Ty));

// (9.1) - T is trivially copyable...
if (!Ty.isTriviallyCopyableType(*this))
  return false;

// All integrals and enums are unique.
if (Ty->isIntegralOrEnumerationType())
  return true;

// All other pointers are unique.
if (Ty->isPointerType())
  return true;

if (Ty->isMemberPointerType()) {
  const auto *MPT = Ty->getAs<MemberPointerType>();
  return !ABI->getMemberPointerInfo(MPT).HasPadding;
}

if (Ty->isRecordType()) {
  const RecordDecl *Record = Ty->castAs<RecordType>()->getDecl();

  if (Record->isInvalidDecl())
    return false;

  if (Record->isUnion())
    return unionHasUniqueObjectRepresentations(*this, Record);

  Optional<int64_t> StructSize =
      structHasUniqueObjectRepresentations(*this, Record);

  return StructSize &&
         StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty));
}

// FIXME: More cases to handle here (list by rsmith):
// vectors (careful about, eg, vector of 3 foo)
// _Complex int and friends
// _Atomic T
// Obj-C block pointers
// Obj-C object pointers
// and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t,
// clk_event_t, queue_t, reserve_id_t)
// There're also Obj-C class types and the Obj-C selector type, but I think it
// makes sense for those to return false here.

return false;
2564}

2566unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const {
unsigned count = 0;
// Count ivars declared in class extension.
for (const auto *Ext : OI->known_extensions())
  count += Ext->ivar_size();

// Count ivar defined in this class's implementation.  This
// includes synthesized ivars.
if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
  count += ImplDecl->ivar_size();

return count;
2578}

2580bool ASTContext::isSentinelNullExpr(const Expr *E) {
if (!E)
  return false;

// nullptr_t is always treated as null.
if (E->getType()->isNullPtrType()) return true;

if (E->getType()->isAnyPointerType() &&
    E->IgnoreParenCasts()->isNullPointerConstant(*this,
                                              Expr::NPC_ValueDependentIsNull))
  return true;

// Unfortunately, __null has type 'int'.
if (isa<GNUNullExpr>(E)) return true;

return false;
2596}

2598/// Get the implementation of ObjCInterfaceDecl, or nullptr if none
2599/// exists.
2600ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
  I = ObjCImpls.find(D);
if (I != ObjCImpls.end())
  return cast<ObjCImplementationDecl>(I->second);
return nullptr;
2606}

2608/// Get the implementation of ObjCCategoryDecl, or nullptr if none
2609/// exists.
2610ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
  I = ObjCImpls.find(D);
if (I != ObjCImpls.end())
  return cast<ObjCCategoryImplDecl>(I->second);
return nullptr;
2616}

2618/// Set the implementation of ObjCInterfaceDecl.
2619void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
                         ObjCImplementationDecl *ImplD) {
assert(IFaceD && ImplD && "Passed null params")((IFaceD && ImplD && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("IFaceD && ImplD && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2621, __PRETTY_FUNCTION__));
ObjCImpls[IFaceD] = ImplD;
2623}

2625/// Set the implementation of ObjCCategoryDecl.
2626void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
                         ObjCCategoryImplDecl *ImplD) {
assert(CatD && ImplD && "Passed null params")((CatD && ImplD && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("CatD && ImplD && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2628, __PRETTY_FUNCTION__));
ObjCImpls[CatD] = ImplD;
2630}

2632const ObjCMethodDecl *
2633ASTContext::getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const {
return ObjCMethodRedecls.lookup(MD);
2635}

2637void ASTContext::setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
                                          const ObjCMethodDecl *Redecl) {
assert(!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration")((!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration"
) ? static_cast<void> (0) : __assert_fail ("!getObjCMethodRedeclaration(MD) && \"MD already has a redeclaration\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2639, __PRETTY_FUNCTION__));
ObjCMethodRedecls[MD] = Redecl;
2641}

2643const ObjCInterfaceDecl *ASTContext::getObjContainingInterface(
                                            const NamedDecl *ND) const {
if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
  return ID;
if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
  return CD->getClassInterface();
if (const auto *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
  return IMD->getClassInterface();

return nullptr;
2653}

2655/// Get the copy initialization expression of VarDecl, or nullptr if
2656/// none exists.
2657ASTContext::BlockVarCopyInit
2658ASTContext::getBlockVarCopyInit(const VarDecl*VD) const {
assert(VD && "Passed null params")((VD && "Passed null params") ? static_cast<void>
 (0) : __assert_fail ("VD && \"Passed null params\"",
 "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2659, __PRETTY_FUNCTION__));
assert(VD->hasAttr<BlocksAttr>() &&((VD->hasAttr<BlocksAttr>() && "getBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"getBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2661, __PRETTY_FUNCTION__))
       "getBlockVarCopyInits - not __block var")((VD->hasAttr<BlocksAttr>() && "getBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"getBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2661, __PRETTY_FUNCTION__));
auto I = BlockVarCopyInits.find(VD);
if (I != BlockVarCopyInits.end())
  return I->second;
return {nullptr, false};
2666}

2668/// Set the copy initialization expression of a block var decl.
2669void ASTContext::setBlockVarCopyInit(const VarDecl*VD, Expr *CopyExpr,
                                   bool CanThrow) {
assert(VD && CopyExpr && "Passed null params")((VD && CopyExpr && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("VD && CopyExpr && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2671, __PRETTY_FUNCTION__));
assert(VD->hasAttr<BlocksAttr>() &&((VD->hasAttr<BlocksAttr>() && "setBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"setBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2673, __PRETTY_FUNCTION__))
       "setBlockVarCopyInits - not __block var")((VD->hasAttr<BlocksAttr>() && "setBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"setBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2673, __PRETTY_FUNCTION__));
BlockVarCopyInits[VD].setExprAndFlag(CopyExpr, CanThrow);
2675}

2677TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
                                               unsigned DataSize) const {
if (!DataSize)
  DataSize = TypeLoc::getFullDataSizeForType(T);
else
  assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&((DataSize == TypeLoc::getFullDataSizeForType(T) && "incorrect data size provided to CreateTypeSourceInfo!"
) ? static_cast<void> (0) : __assert_fail ("DataSize == TypeLoc::getFullDataSizeForType(T) && \"incorrect data size provided to CreateTypeSourceInfo!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2683, __PRETTY_FUNCTION__))
         "incorrect data size provided to CreateTypeSourceInfo!")((DataSize == TypeLoc::getFullDataSizeForType(T) && "incorrect data size provided to CreateTypeSourceInfo!"
) ? static_cast<void> (0) : __assert_fail ("DataSize == TypeLoc::getFullDataSizeForType(T) && \"incorrect data size provided to CreateTypeSourceInfo!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2683, __PRETTY_FUNCTION__));

auto *TInfo =
  (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
new (TInfo) TypeSourceInfo(T);
return TInfo;
2689}

2691TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
                                                   SourceLocation L) const {
TypeSourceInfo *DI = CreateTypeSourceInfo(T);
DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
return DI;
2696}

2698const ASTRecordLayout &
2699ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const {
return getObjCLayout(D, nullptr);
2701}

2703const ASTRecordLayout &
2704ASTContext::getASTObjCImplementationLayout(
                                      const ObjCImplementationDecl *D) const {
return getObjCLayout(D->getClassInterface(), D);
2707}

2709//===----------------------------------------------------------------------===//
2710//                   Type creation/memoization methods
2711//===----------------------------------------------------------------------===//

2713QualType
2714ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
unsigned fastQuals = quals.getFastQualifiers();
quals.removeFastQualifiers();

// Check if we've already instantiated this type.
llvm::FoldingSetNodeID ID;
ExtQuals::Profile(ID, baseType, quals);
void *insertPos = nullptr;
if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
  assert(eq->getQualifiers() == quals)((eq->getQualifiers() == quals) ? static_cast<void> (
0) : __assert_fail ("eq->getQualifiers() == quals", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2723, __PRETTY_FUNCTION__));
  return QualType(eq, fastQuals);
}

// If the base type is not canonical, make the appropriate canonical type.
QualType canon;
if (!baseType->isCanonicalUnqualified()) {
  SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split();
  canonSplit.Quals.addConsistentQualifiers(quals);
  canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);

  // Re-find the insert position.
  (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
}

auto *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
ExtQualNodes.InsertNode(eq, insertPos);
return QualType(eq, fastQuals);
2741}

2743QualType ASTContext::getAddrSpaceQualType(QualType T,
                                        LangAS AddressSpace) const {
QualType CanT = getCanonicalType(T);
if (CanT.getAddressSpace() == AddressSpace)
  return T;

// If we are composing extended qualifiers together, merge together
// into one ExtQuals node.
QualifierCollector Quals;
const Type *TypeNode = Quals.strip(T);

// If this type already has an address space specified, it cannot get
// another one.
assert(!Quals.hasAddressSpace() &&((!Quals.hasAddressSpace() && "Type cannot be in multiple addr spaces!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasAddressSpace() && \"Type cannot be in multiple addr spaces!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2757, __PRETTY_FUNCTION__))
       "Type cannot be in multiple addr spaces!")((!Quals.hasAddressSpace() && "Type cannot be in multiple addr spaces!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasAddressSpace() && \"Type cannot be in multiple addr spaces!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2757, __PRETTY_FUNCTION__));
Quals.addAddressSpace(AddressSpace);

return getExtQualType(TypeNode, Quals);
2761}

2763QualType ASTContext::removeAddrSpaceQualType(QualType T) const {
// If we are composing extended qualifiers together, merge together
// into one ExtQuals node.
QualifierCollector Quals;
const Type *TypeNode = Quals.strip(T);

// If the qualifier doesn't have an address space just return it.
if (!Quals.hasAddressSpace())
  return T;

Quals.removeAddressSpace();

// Removal of the address space can mean there are no longer any
// non-fast qualifiers, so creating an ExtQualType isn't possible (asserts)
// or required.
if (Quals.hasNonFastQualifiers())
  return getExtQualType(TypeNode, Quals);
else
  return QualType(TypeNode, Quals.getFastQualifiers());
2782}

2784QualType ASTContext::getObjCGCQualType(QualType T,
                                     Qualifiers::GC GCAttr) const {
QualType CanT = getCanonicalType(T);
if (CanT.getObjCGCAttr() == GCAttr)
  return T;

if (const auto *ptr = T->getAs<PointerType>()) {
  QualType Pointee = ptr->getPointeeType();
  if (Pointee->isAnyPointerType()) {
    QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
    return getPointerType(ResultType);
  }
}

// If we are composing extended qualifiers together, merge together
// into one ExtQuals node.
QualifierCollector Quals;
const Type *TypeNode = Quals.strip(T);

// If this type already has an ObjCGC specified, it cannot get
// another one.
assert(!Quals.hasObjCGCAttr() &&((!Quals.hasObjCGCAttr() && "Type cannot have multiple ObjCGCs!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasObjCGCAttr() && \"Type cannot have multiple ObjCGCs!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2806, __PRETTY_FUNCTION__))
       "Type cannot have multiple ObjCGCs!")((!Quals.hasObjCGCAttr() && "Type cannot have multiple ObjCGCs!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasObjCGCAttr() && \"Type cannot have multiple ObjCGCs!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2806, __PRETTY_FUNCTION__));
Quals.addObjCGCAttr(GCAttr);

return getExtQualType(TypeNode, Quals);
2810}

2812const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T,
                                                 FunctionType::ExtInfo Info) {
if (T->getExtInfo() == Info)
  return T;

QualType Result;
if (const auto *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
  Result = getFunctionNoProtoType(FNPT->getReturnType(), Info);
} else {
  const auto *FPT = cast<FunctionProtoType>(T);
  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
  EPI.ExtInfo = Info;
  Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
}

return cast<FunctionType>(Result.getTypePtr());
2828}

2830void ASTContext::adjustDeducedFunctionResultType(FunctionDecl *FD,
                                               QualType ResultType) {
FD = FD->getMostRecentDecl();
while (true) {
  const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
  FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI));
  if (FunctionDecl *Next = FD->getPreviousDecl())
    FD = Next;
  else
    break;
}
if (ASTMutationListener *L = getASTMutationListener())
  L->DeducedReturnType(FD, ResultType);
2844}

2846/// Get a function type and produce the equivalent function type with the
2847/// specified exception specification. Type sugar that can be present on a
2848/// declaration of a function with an exception specification is permitted
2849/// and preserved. Other type sugar (for instance, typedefs) is not.
2850QualType ASTContext::getFunctionTypeWithExceptionSpec(
  QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) {
// Might have some parens.
if (const auto *PT = dyn_cast<ParenType>(Orig))
  return getParenType(
      getFunctionTypeWithExceptionSpec(PT->getInnerType(), ESI));

// Might be wrapped in a macro qualified type.
if (const auto *MQT = dyn_cast<MacroQualifiedType>(Orig))
  return getMacroQualifiedType(
      getFunctionTypeWithExceptionSpec(MQT->getUnderlyingType(), ESI),
      MQT->getMacroIdentifier());

// Might have a calling-convention attribute.
if (const auto *AT = dyn_cast<AttributedType>(Orig))
  return getAttributedType(
      AT->getAttrKind(),
      getFunctionTypeWithExceptionSpec(AT->getModifiedType(), ESI),
      getFunctionTypeWithExceptionSpec(AT->getEquivalentType(), ESI));

// Anything else must be a function type. Rebuild it with the new exception
// specification.
const auto *Proto = Orig->getAs<FunctionProtoType>();
return getFunctionType(
    Proto->getReturnType(), Proto->getParamTypes(),
    Proto->getExtProtoInfo().withExceptionSpec(ESI));
2876}

2878bool ASTContext::hasSameFunctionTypeIgnoringExceptionSpec(QualType T,
                                                        QualType U) {
return hasSameType(T, U) ||
       (getLangOpts().CPlusPlus17 &&
        hasSameType(getFunctionTypeWithExceptionSpec(T, EST_None),
                    getFunctionTypeWithExceptionSpec(U, EST_None)));
2884}

2886void ASTContext::adjustExceptionSpec(
  FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI,
  bool AsWritten) {
// Update the type.
QualType Updated =
    getFunctionTypeWithExceptionSpec(FD->getType(), ESI);
FD->setType(Updated);

if (!AsWritten)
  return;

// Update the type in the type source information too.
if (TypeSourceInfo *TSInfo = FD->getTypeSourceInfo()) {
  // If the type and the type-as-written differ, we may need to update
  // the type-as-written too.
  if (TSInfo->getType() != FD->getType())
    Updated = getFunctionTypeWithExceptionSpec(TSInfo->getType(), ESI);

  // FIXME: When we get proper type location information for exceptions,
  // we'll also have to rebuild the TypeSourceInfo. For now, we just patch
  // up the TypeSourceInfo;
  assert(TypeLoc::getFullDataSizeForType(Updated) ==((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2909, __PRETTY_FUNCTION__))
             TypeLoc::getFullDataSizeForType(TSInfo->getType()) &&((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2909, __PRETTY_FUNCTION__))
         "TypeLoc size mismatch from updating exception specification")((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2909, __PRETTY_FUNCTION__));
  TSInfo->overrideType(Updated);
}
2912}

2914/// getComplexType - Return the uniqued reference to the type for a complex
2915/// number with the specified element type.
2916QualType ASTContext::getComplexType(QualType T) const {
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
ComplexType::Profile(ID, T);

void *InsertPos = nullptr;
if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(CT, 0);

// If the pointee type isn't canonical, this won't be a canonical type either,
// so fill in the canonical type field.
QualType Canonical;
if (!T.isCanonical()) {
  Canonical = getComplexType(getCanonicalType(T));

  // Get the new insert position for the node we care about.
  ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2934, __PRETTY_FUNCTION__)); (void)NewIP;
}
auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
Types.push_back(New);
ComplexTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
2940}

2942/// getPointerType - Return the uniqued reference to the type for a pointer to
2943/// the specified type.
2944QualType ASTContext::getPointerType(QualType T) const {
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
PointerType::Profile(ID, T);

void *InsertPos = nullptr;
if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(PT, 0);

// If the pointee type isn't canonical, this won't be a canonical type either,
// so fill in the canonical type field.
QualType Canonical;
if (!T.isCanonical()) {
  Canonical = getPointerType(getCanonicalType(T));

  // Get the new insert position for the node we care about.
  PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2962, __PRETTY_FUNCTION__)); (void)NewIP;
}
auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
Types.push_back(New);
PointerTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
2968}

2970QualType ASTContext::getAdjustedType(QualType Orig, QualType New) const {
llvm::FoldingSetNodeID ID;
AdjustedType::Profile(ID, Orig, New);
void *InsertPos = nullptr;
AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
if (AT)
  return QualType(AT, 0);

QualType Canonical = getCanonicalType(New);

// Get the new insert position for the node we care about.
AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(!AT && "Shouldn't be in the map!")((!AT && "Shouldn't be in the map!") ? static_cast<
void> (0) : __assert_fail ("!AT && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2982, __PRETTY_FUNCTION__));

AT = new (*this, TypeAlignment)
    AdjustedType(Type::Adjusted, Orig, New, Canonical);
Types.push_back(AT);
AdjustedTypes.InsertNode(AT, InsertPos);
return QualType(AT, 0);
2989}

2991QualType ASTContext::getDecayedType(QualType T) const {
assert((T->isArrayType() || T->isFunctionType()) && "T does not decay")(((T->isArrayType() || T->isFunctionType()) && "T does not decay"
) ? static_cast<void> (0) : __assert_fail ("(T->isArrayType() || T->isFunctionType()) && \"T does not decay\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 2992, __PRETTY_FUNCTION__));

QualType Decayed;

// C99 6.7.5.3p7:
//   A declaration of a parameter as "array of type" shall be
//   adjusted to "qualified pointer to type", where the type
//   qualifiers (if any) are those specified within the [ and ] of
//   the array type derivation.
if (T->isArrayType())
  Decayed = getArrayDecayedType(T);

// C99 6.7.5.3p8:
//   A declaration of a parameter as "function returning type"
//   shall be adjusted to "pointer to function returning type", as
//   in 6.3.2.1.
if (T->isFunctionType())
  Decayed = getPointerType(T);

llvm::FoldingSetNodeID ID;
AdjustedType::Profile(ID, T, Decayed);
void *InsertPos = nullptr;
AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
if (AT)
  return QualType(AT, 0);

QualType Canonical = getCanonicalType(Decayed);

// Get the new insert position for the node we care about.
AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(!AT && "Shouldn't be in the map!")((!AT && "Shouldn't be in the map!") ? static_cast<
void> (0) : __assert_fail ("!AT && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3022, __PRETTY_FUNCTION__));

AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical);
Types.push_back(AT);
AdjustedTypes.InsertNode(AT, InsertPos);
return QualType(AT, 0);
3028}

3030/// getBlockPointerType - Return the uniqued reference to the type for
3031/// a pointer to the specified block.
3032QualType ASTContext::getBlockPointerType(QualType T) const {
assert(T->isFunctionType() && "block of function types only")((T->isFunctionType() && "block of function types only"
) ? static_cast<void> (0) : __assert_fail ("T->isFunctionType() && \"block of function types only\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3033, __PRETTY_FUNCTION__));
// Unique pointers, to guarantee there is only one block of a particular
// structure.
llvm::FoldingSetNodeID ID;
BlockPointerType::Profile(ID, T);

void *InsertPos = nullptr;
if (BlockPointerType *PT =
      BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(PT, 0);

// If the block pointee type isn't canonical, this won't be a canonical
// type either so fill in the canonical type field.
QualType Canonical;
if (!T.isCanonical()) {
  Canonical = getBlockPointerType(getCanonicalType(T));

  // Get the new insert position for the node we care about.
  BlockPointerType *NewIP =
    BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3053, __PRETTY_FUNCTION__)); (void)NewIP;
}
auto *New = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
Types.push_back(New);
BlockPointerTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
3059}

3061/// getLValueReferenceType - Return the uniqued reference to the type for an
3062/// lvalue reference to the specified type.
3063QualType
3064ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
assert(getCanonicalType(T) != OverloadTy &&((getCanonicalType(T) != OverloadTy && "Unresolved overloaded function type"
) ? static_cast<void> (0) : __assert_fail ("getCanonicalType(T) != OverloadTy && \"Unresolved overloaded function type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3066, __PRETTY_FUNCTION__))
       "Unresolved overloaded function type")((getCanonicalType(T) != OverloadTy && "Unresolved overloaded function type"
) ? static_cast<void> (0) : __assert_fail ("getCanonicalType(T) != OverloadTy && \"Unresolved overloaded function type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3066, __PRETTY_FUNCTION__));

// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
ReferenceType::Profile(ID, T, SpelledAsLValue);

void *InsertPos = nullptr;
if (LValueReferenceType *RT =
      LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(RT, 0);

const auto *InnerRef = T->getAs<ReferenceType>();

// If the referencee type isn't canonical, this won't be a canonical type
// either, so fill in the canonical type field.
QualType Canonical;
if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
  QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
  Canonical = getLValueReferenceType(getCanonicalType(PointeeType));

  // Get the new insert position for the node we care about.
  LValueReferenceType *NewIP =
    LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3090, __PRETTY_FUNCTION__)); (void)NewIP;
}

auto *New = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
                                                           SpelledAsLValue);
Types.push_back(New);
LValueReferenceTypes.InsertNode(New, InsertPos);

return QualType(New, 0);
3099}

3101/// getRValueReferenceType - Return the uniqued reference to the type for an
3102/// rvalue reference to the specified type.
3103QualType ASTContext::getRValueReferenceType(QualType T) const {
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
ReferenceType::Profile(ID, T, false);

void *InsertPos = nullptr;
if (RValueReferenceType *RT =
      RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(RT, 0);

const auto *InnerRef = T->getAs<ReferenceType>();

// If the referencee type isn't canonical, this won't be a canonical type
// either, so fill in the canonical type field.
QualType Canonical;
if (InnerRef || !T.isCanonical()) {
  QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
  Canonical = getRValueReferenceType(getCanonicalType(PointeeType));

  // Get the new insert position for the node we care about.
  RValueReferenceType *NewIP =
    RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3126, __PRETTY_FUNCTION__)); (void)NewIP;
}

auto *New = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
Types.push_back(New);
RValueReferenceTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
3133}

3135/// getMemberPointerType - Return the uniqued reference to the type for a
3136/// member pointer to the specified type, in the specified class.
3137QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
MemberPointerType::Profile(ID, T, Cls);

void *InsertPos = nullptr;
if (MemberPointerType *PT =
    MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(PT, 0);

// If the pointee or class type isn't canonical, this won't be a canonical
// type either, so fill in the canonical type field.
QualType Canonical;
if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
  Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));

  // Get the new insert position for the node we care about.
  MemberPointerType *NewIP =
    MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3157, __PRETTY_FUNCTION__)); (void)NewIP;
}
auto *New = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
Types.push_back(New);
MemberPointerTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
3163}

3165/// getConstantArrayType - Return the unique reference to the type for an
3166/// array of the specified element type.
3167QualType ASTContext::getConstantArrayType(QualType EltTy,
                                        const llvm::APInt &ArySizeIn,
                                        ArrayType::ArraySizeModifier ASM,
                                        unsigned IndexTypeQuals) const {
assert((EltTy->isDependentType() ||(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3173, __PRETTY_FUNCTION__))
        EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3173, __PRETTY_FUNCTION__))
       "Constant array of VLAs is illegal!")(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3173, __PRETTY_FUNCTION__));

// Convert the array size into a canonical width matching the pointer size for
// the target.
llvm::APInt ArySize(ArySizeIn);
ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());

llvm::FoldingSetNodeID ID;
ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals);

void *InsertPos = nullptr;
if (ConstantArrayType *ATP =
    ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(ATP, 0);

// If the element type isn't canonical or has qualifiers, this won't
// be a canonical type either, so fill in the canonical type field.
QualType Canon;
if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
  SplitQualType canonSplit = getCanonicalType(EltTy).split();
  Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize,
                               ASM, IndexTypeQuals);
  Canon = getQualifiedType(Canon, canonSplit.Quals);

  // Get the new insert position for the node we care about.
  ConstantArrayType *NewIP =
    ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3200, __PRETTY_FUNCTION__)); (void)NewIP;
}

auto *New = new (*this,TypeAlignment)
  ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
ConstantArrayTypes.InsertNode(New, InsertPos);
Types.push_back(New);
return QualType(New, 0);
3208}

3210/// getVariableArrayDecayedType - Turns the given type, which may be
3211/// variably-modified, into the corresponding type with all the known
3212/// sizes replaced with [*].
3213QualType ASTContext::getVariableArrayDecayedType(QualType type) const {
// Vastly most common case.
if (!type->isVariablyModifiedType()) return type;

QualType result;

SplitQualType split = type.getSplitDesugaredType();
const Type *ty = split.Ty;
switch (ty->getTypeClass()) {
3222#define TYPE(Class, Base)
3223#define ABSTRACT_TYPE(Class, Base)
3224#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3225#include "clang/AST/TypeNodes.inc"
  llvm_unreachable("didn't desugar past all non-canonical types?")::llvm::llvm_unreachable_internal("didn't desugar past all non-canonical types?"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3226);

// These types should never be variably-modified.
case Type::Builtin:
case Type::Complex:
case Type::Vector:
case Type::DependentVector:
case Type::ExtVector:
case Type::DependentSizedExtVector:
case Type::DependentAddressSpace:
case Type::ObjCObject:
case Type::ObjCInterface:
case Type::ObjCObjectPointer:
case Type::Record:
case Type::Enum:
case Type::UnresolvedUsing:
case Type::TypeOfExpr:
case Type::TypeOf:
case Type::Decltype:
case Type::UnaryTransform:
case Type::DependentName:
case Type::InjectedClassName:
case Type::TemplateSpecialization:
case Type::DependentTemplateSpecialization:
case Type::TemplateTypeParm:
case Type::SubstTemplateTypeParmPack:
case Type::Auto:
case Type::DeducedTemplateSpecialization:
case Type::PackExpansion:
  llvm_unreachable("type should never be variably-modified")::llvm::llvm_unreachable_internal("type should never be variably-modified"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3255);

// These types can be variably-modified but should never need to
// further decay.
case Type::FunctionNoProto:
case Type::FunctionProto:
case Type::BlockPointer:
case Type::MemberPointer:
case Type::Pipe:
  return type;

// These types can be variably-modified.  All these modifications
// preserve structure except as noted by comments.
// TODO: if we ever care about optimizing VLAs, there are no-op
// optimizations available here.
case Type::Pointer:
  result = getPointerType(getVariableArrayDecayedType(
                            cast<PointerType>(ty)->getPointeeType()));
  break;

case Type::LValueReference: {
  const auto *lv = cast<LValueReferenceType>(ty);
  result = getLValueReferenceType(
               getVariableArrayDecayedType(lv->getPointeeType()),
                                  lv->isSpelledAsLValue());
  break;
}

case Type::RValueReference: {
  const auto *lv = cast<RValueReferenceType>(ty);
  result = getRValueReferenceType(
               getVariableArrayDecayedType(lv->getPointeeType()));
  break;
}

case Type::Atomic: {
  const auto *at = cast<AtomicType>(ty);
  result = getAtomicType(getVariableArrayDecayedType(at->getValueType()));
  break;
}

case Type::ConstantArray: {
  const auto *cat = cast<ConstantArrayType>(ty);
  result = getConstantArrayType(
               getVariableArrayDecayedType(cat->getElementType()),
                                cat->getSize(),
                                cat->getSizeModifier(),
                                cat->getIndexTypeCVRQualifiers());
  break;
}

case Type::DependentSizedArray: {
  const auto *dat = cast<DependentSizedArrayType>(ty);
  result = getDependentSizedArrayType(
               getVariableArrayDecayedType(dat->getElementType()),
                                      dat->getSizeExpr(),
                                      dat->getSizeModifier(),
                                      dat->getIndexTypeCVRQualifiers(),
                                      dat->getBracketsRange());
  break;
}

// Turn incomplete types into [*] types.
case Type::IncompleteArray: {
  const auto *iat = cast<IncompleteArrayType>(ty);
  result = getVariableArrayType(
               getVariableArrayDecayedType(iat->getElementType()),
                                /*size*/ nullptr,
                                ArrayType::Normal,
                                iat->getIndexTypeCVRQualifiers(),
                                SourceRange());
  break;
}

// Turn VLA types into [*] types.
case Type::VariableArray: {
  const auto *vat = cast<VariableArrayType>(ty);
  result = getVariableArrayType(
               getVariableArrayDecayedType(vat->getElementType()),
                                /*size*/ nullptr,
                                ArrayType::Star,
                                vat->getIndexTypeCVRQualifiers(),
                                vat->getBracketsRange());
  break;
}
}

// Apply the top-level qualifiers from the original.
return getQualifiedType(result, split.Quals);
3344}

3346/// getVariableArrayType - Returns a non-unique reference to the type for a
3347/// variable array of the specified element type.
3348QualType ASTContext::getVariableArrayType(QualType EltTy,
                                        Expr *NumElts,
                                        ArrayType::ArraySizeModifier ASM,
                                        unsigned IndexTypeQuals,
                                        SourceRange Brackets) const {
// Since we don't unique expressions, it isn't possible to unique VLA's
// that have an expression provided for their size.
QualType Canon;

// Be sure to pull qualifiers off the element type.
if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
  SplitQualType canonSplit = getCanonicalType(EltTy).split();
  Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM,
                               IndexTypeQuals, Brackets);
  Canon = getQualifiedType(Canon, canonSplit.Quals);
}

auto *New = new (*this, TypeAlignment)
  VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);

VariableArrayTypes.push_back(New);
Types.push_back(New);
return QualType(New, 0);
3371}

3373/// getDependentSizedArrayType - Returns a non-unique reference to
3374/// the type for a dependently-sized array of the specified element
3375/// type.
3376QualType ASTContext::getDependentSizedArrayType(QualType elementType,
                                              Expr *numElements,
                                              ArrayType::ArraySizeModifier ASM,
                                              unsigned elementTypeQuals,
                                              SourceRange brackets) const {
assert((!numElements || numElements->isTypeDependent() ||(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3383, __PRETTY_FUNCTION__))
        numElements->isValueDependent()) &&(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3383, __PRETTY_FUNCTION__))
       "Size must be type- or value-dependent!")(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3383, __PRETTY_FUNCTION__));

// Dependently-sized array types that do not have a specified number
// of elements will have their sizes deduced from a dependent
// initializer.  We do no canonicalization here at all, which is okay
// because they can't be used in most locations.
if (!numElements) {
  auto *newType
    = new (*this, TypeAlignment)
        DependentSizedArrayType(*this, elementType, QualType(),
                                numElements, ASM, elementTypeQuals,
                                brackets);
  Types.push_back(newType);
  return QualType(newType, 0);
}

// Otherwise, we actually build a new type every time, but we
// also build a canonical type.

SplitQualType canonElementType = getCanonicalType(elementType).split();

void *insertPos = nullptr;
llvm::FoldingSetNodeID ID;
DependentSizedArrayType::Profile(ID, *this,
                                 QualType(canonElementType.Ty, 0),
                                 ASM, elementTypeQuals, numElements);

// Look for an existing type with these properties.
DependentSizedArrayType *canonTy =
  DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);

// If we don't have one, build one.
if (!canonTy) {
  canonTy = new (*this, TypeAlignment)
    DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
                            QualType(), numElements, ASM, elementTypeQuals,
                            brackets);
  DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
  Types.push_back(canonTy);
}

// Apply qualifiers from the element type to the array.
QualType canon = getQualifiedType(QualType(canonTy,0),
                                  canonElementType.Quals);

// If we didn't need extra canonicalization for the element type or the size
// expression, then just use that as our result.
if (QualType(canonElementType.Ty, 0) == elementType &&
    canonTy->getSizeExpr() == numElements)
  return canon;

// Otherwise, we need to build a type which follows the spelling
// of the element type.
auto *sugaredType
  = new (*this, TypeAlignment)
      DependentSizedArrayType(*this, elementType, canon, numElements,
                              ASM, elementTypeQuals, brackets);
Types.push_back(sugaredType);
return QualType(sugaredType, 0);
3442}

3444QualType ASTContext::getIncompleteArrayType(QualType elementType,
                                          ArrayType::ArraySizeModifier ASM,
                                          unsigned elementTypeQuals) const {
llvm::FoldingSetNodeID ID;
IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals);

void *insertPos = nullptr;
if (IncompleteArrayType *iat =
     IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
  return QualType(iat, 0);

// If the element type isn't canonical, this won't be a canonical type
// either, so fill in the canonical type field.  We also have to pull
// qualifiers off the element type.
QualType canon;

if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
  SplitQualType canonSplit = getCanonicalType(elementType).split();
  canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
                                 ASM, elementTypeQuals);
  canon = getQualifiedType(canon, canonSplit.Quals);

  // Get the new insert position for the node we care about.
  IncompleteArrayType *existing =
    IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
  assert(!existing && "Shouldn't be in the map!")((!existing && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!existing && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3469, __PRETTY_FUNCTION__)); (void) existing;
}

auto *newType = new (*this, TypeAlignment)
  IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);

IncompleteArrayTypes.InsertNode(newType, insertPos);
Types.push_back(newType);
return QualType(newType, 0);
3478}

3480/// getVectorType - Return the unique reference to a vector type of
3481/// the specified element type and size. VectorType must be a built-in type.
3482QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
                                 VectorType::VectorKind VecKind) const {
assert(vecType->isBuiltinType())((vecType->isBuiltinType()) ? static_cast<void> (0) :
 __assert_fail ("vecType->isBuiltinType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3484, __PRETTY_FUNCTION__));

// Check if we've already instantiated a vector of this type.
llvm::FoldingSetNodeID ID;
VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);

void *InsertPos = nullptr;
if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(VTP, 0);

// If the element type isn't canonical, this won't be a canonical type either,
// so fill in the canonical type field.
QualType Canonical;
if (!vecType.isCanonical()) {
  Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);

  // Get the new insert position for the node we care about.
  VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3502, __PRETTY_FUNCTION__)); (void)NewIP;
}
auto *New = new (*this, TypeAlignment)
  VectorType(vecType, NumElts, Canonical, VecKind);
VectorTypes.InsertNode(New, InsertPos);
Types.push_back(New);
return QualType(New, 0);
3509}

3511QualType
3512ASTContext::getDependentVectorType(QualType VecType, Expr *SizeExpr,
                                 SourceLocation AttrLoc,
                                 VectorType::VectorKind VecKind) const {
llvm::FoldingSetNodeID ID;
DependentVectorType::Profile(ID, *this, getCanonicalType(VecType), SizeExpr,
                             VecKind);
void *InsertPos = nullptr;
DependentVectorType *Canon =
    DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
DependentVectorType *New;

if (Canon) {
  New = new (*this, TypeAlignment) DependentVectorType(
      *this, VecType, QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
} else {
  QualType CanonVecTy = getCanonicalType(VecType);
  if (CanonVecTy == VecType) {
    New = new (*this, TypeAlignment) DependentVectorType(
        *this, VecType, QualType(), SizeExpr, AttrLoc, VecKind);

    DependentVectorType *CanonCheck =
        DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
    assert(!CanonCheck &&((!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3535, __PRETTY_FUNCTION__))
           "Dependent-sized vector_size canonical type broken")((!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3535, __PRETTY_FUNCTION__));
    (void)CanonCheck;
    DependentVectorTypes.InsertNode(New, InsertPos);
  } else {
    QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
                                                    SourceLocation());
    New = new (*this, TypeAlignment) DependentVectorType(
        *this, VecType, Canon, SizeExpr, AttrLoc, VecKind);
  }
}

Types.push_back(New);
return QualType(New, 0);
3548}

3550/// getExtVectorType - Return the unique reference to an extended vector type of
3551/// the specified element type and size. VectorType must be a built-in type.
3552QualType
3553ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
assert(vecType->isBuiltinType() || vecType->isDependentType())((vecType->isBuiltinType() || vecType->isDependentType(
)) ? static_cast<void> (0) : __assert_fail ("vecType->isBuiltinType() || vecType->isDependentType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3554, __PRETTY_FUNCTION__));

// Check if we've already instantiated a vector of this type.
llvm::FoldingSetNodeID ID;
VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
                    VectorType::GenericVector);
void *InsertPos = nullptr;
if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(VTP, 0);

// If the element type isn't canonical, this won't be a canonical type either,
// so fill in the canonical type field.
QualType Canonical;
if (!vecType.isCanonical()) {
  Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);

  // Get the new insert position for the node we care about.
  VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3572, __PRETTY_FUNCTION__)); (void)NewIP;
}
auto *New = new (*this, TypeAlignment)
  ExtVectorType(vecType, NumElts, Canonical);
VectorTypes.InsertNode(New, InsertPos);
Types.push_back(New);
return QualType(New, 0);
3579}

3581QualType
3582ASTContext::getDependentSizedExtVectorType(QualType vecType,
                                         Expr *SizeExpr,
                                         SourceLocation AttrLoc) const {
llvm::FoldingSetNodeID ID;
DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
                                     SizeExpr);

void *InsertPos = nullptr;
DependentSizedExtVectorType *Canon
  = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
DependentSizedExtVectorType *New;
if (Canon) {
  // We already have a canonical version of this array type; use it as
  // the canonical type for a newly-built type.
  New = new (*this, TypeAlignment)
    DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
                                SizeExpr, AttrLoc);
} else {
  QualType CanonVecTy = getCanonicalType(vecType);
  if (CanonVecTy == vecType) {
    New = new (*this, TypeAlignment)
      DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
                                  AttrLoc);

    DependentSizedExtVectorType *CanonCheck
      = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
    assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken")((!CanonCheck && "Dependent-sized ext_vector canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized ext_vector canonical type broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3608, __PRETTY_FUNCTION__));
    (void)CanonCheck;
    DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
  } else {
    QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
                                                    SourceLocation());
    New = new (*this, TypeAlignment)
      DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
  }
}

Types.push_back(New);
return QualType(New, 0);
3621}

3623QualType ASTContext::getDependentAddressSpaceType(QualType PointeeType,
                                                Expr *AddrSpaceExpr,
                                                SourceLocation AttrLoc) const {
assert(AddrSpaceExpr->isInstantiationDependent())((AddrSpaceExpr->isInstantiationDependent()) ? static_cast
<void> (0) : __assert_fail ("AddrSpaceExpr->isInstantiationDependent()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3626, __PRETTY_FUNCTION__));

QualType canonPointeeType = getCanonicalType(PointeeType);

void *insertPos = nullptr;
llvm::FoldingSetNodeID ID;
DependentAddressSpaceType::Profile(ID, *this, canonPointeeType,
                                   AddrSpaceExpr);

DependentAddressSpaceType *canonTy =
  DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);

if (!canonTy) {
  canonTy = new (*this, TypeAlignment)
    DependentAddressSpaceType(*this, canonPointeeType,
                              QualType(), AddrSpaceExpr, AttrLoc);
  DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
  Types.push_back(canonTy);
}

if (canonPointeeType == PointeeType &&
    canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
  return QualType(canonTy, 0);

auto *sugaredType
  = new (*this, TypeAlignment)
      DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0),
                                AddrSpaceExpr, AttrLoc);
Types.push_back(sugaredType);
return QualType(sugaredType, 0);
3656}

3658/// Determine whether \p T is canonical as the result type of a function.
3659static bool isCanonicalResultType(QualType T) {
return T.isCanonical() &&
       (T.getObjCLifetime() == Qualifiers::OCL_None ||
        T.getObjCLifetime() == Qualifiers::OCL_ExplicitNone);
3663}

3665/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
3666QualType
3667ASTContext::getFunctionNoProtoType(QualType ResultTy,
                                 const FunctionType::ExtInfo &Info) const {
// Unique functions, to guarantee there is only one function of a particular
// structure.
llvm::FoldingSetNodeID ID;
FunctionNoProtoType::Profile(ID, ResultTy, Info);

void *InsertPos = nullptr;
if (FunctionNoProtoType *FT =
      FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(FT, 0);

QualType Canonical;
if (!isCanonicalResultType(ResultTy)) {
  Canonical =
    getFunctionNoProtoType(getCanonicalFunctionResultType(ResultTy), Info);

  // Get the new insert position for the node we care about.
  FunctionNoProtoType *NewIP =
    FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3687, __PRETTY_FUNCTION__)); (void)NewIP;
}

auto *New = new (*this, TypeAlignment)
  FunctionNoProtoType(ResultTy, Canonical, Info);
Types.push_back(New);
FunctionNoProtoTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
3695}

3697CanQualType
3698ASTContext::getCanonicalFunctionResultType(QualType ResultType) const {
CanQualType CanResultType = getCanonicalType(ResultType);

// Canonical result types do not have ARC lifetime qualifiers.
if (CanResultType.getQualifiers().hasObjCLifetime()) {
  Qualifiers Qs = CanResultType.getQualifiers();
  Qs.removeObjCLifetime();
  return CanQualType::CreateUnsafe(
           getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
}

return CanResultType;
3710}

3712static bool isCanonicalExceptionSpecification(
  const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType) {
if (ESI.Type == EST_None)
  return true;
if (!NoexceptInType)
  return false;

// C++17 onwards: exception specification is part of the type, as a simple
// boolean "can this function type throw".
if (ESI.Type == EST_BasicNoexcept)
  return true;

// A noexcept(expr) specification is (possibly) canonical if expr is
// value-dependent.
if (ESI.Type == EST_DependentNoexcept)
  return true;

// A dynamic exception specification is canonical if it only contains pack
// expansions (so we can't tell whether it's non-throwing) and all its
// contained types are canonical.
if (ESI.Type == EST_Dynamic) {
  bool AnyPackExpansions = false;
  for (QualType ET : ESI.Exceptions) {
    if (!ET.isCanonical())
      return false;
    if (ET->getAs<PackExpansionType>())
      AnyPackExpansions = true;
  }
  return AnyPackExpansions;
}

return false;
3744}

3746QualType ASTContext::getFunctionTypeInternal(
  QualType ResultTy, ArrayRef<QualType> ArgArray,
  const FunctionProtoType::ExtProtoInfo &EPI, bool OnlyWantCanonical) const {
size_t NumArgs = ArgArray.size();

// Unique functions, to guarantee there is only one function of a particular
// structure.
llvm::FoldingSetNodeID ID;
FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI,
                           *this, true);

QualType Canonical;
bool Unique = false;

void *InsertPos = nullptr;
if (FunctionProtoType *FPT =
      FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
  QualType Existing = QualType(FPT, 0);

  // If we find a pre-existing equivalent FunctionProtoType, we can just reuse
  // it so long as our exception specification doesn't contain a dependent
  // noexcept expression, or we're just looking for a canonical type.
  // Otherwise, we're going to need to create a type
  // sugar node to hold the concrete expression.
  if (OnlyWantCanonical || !isComputedNoexcept(EPI.ExceptionSpec.Type) ||
      EPI.ExceptionSpec.NoexceptExpr == FPT->getNoexceptExpr())
    return Existing;

  // We need a new type sugar node for this one, to hold the new noexcept
  // expression. We do no canonicalization here, but that's OK since we don't
  // expect to see the same noexcept expression much more than once.
  Canonical = getCanonicalType(Existing);
  Unique = true;
}

bool NoexceptInType = getLangOpts().CPlusPlus17;
bool IsCanonicalExceptionSpec =
    isCanonicalExceptionSpecification(EPI.ExceptionSpec, NoexceptInType);

// Determine whether the type being created is already canonical or not.
bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
                   isCanonicalResultType(ResultTy) && !EPI.HasTrailingReturn;
for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
  if (!ArgArray[i].isCanonicalAsParam())
    isCanonical = false;

if (OnlyWantCanonical)
  assert(isCanonical &&((isCanonical && "given non-canonical parameters constructing canonical type"
) ? static_cast<void> (0) : __assert_fail ("isCanonical && \"given non-canonical parameters constructing canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3794, __PRETTY_FUNCTION__))
         "given non-canonical parameters constructing canonical type")((isCanonical && "given non-canonical parameters constructing canonical type"
) ? static_cast<void> (0) : __assert_fail ("isCanonical && \"given non-canonical parameters constructing canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3794, __PRETTY_FUNCTION__));

// If this type isn't canonical, get the canonical version of it if we don't
// already have it. The exception spec is only partially part of the
// canonical type, and only in C++17 onwards.
if (!isCanonical && Canonical.isNull()) {
  SmallVector<QualType, 16> CanonicalArgs;
  CanonicalArgs.reserve(NumArgs);
  for (unsigned i = 0; i != NumArgs; ++i)
    CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));

  llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
  FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
  CanonicalEPI.HasTrailingReturn = false;

  if (IsCanonicalExceptionSpec) {
    // Exception spec is already OK.
  } else if (NoexceptInType) {
    switch (EPI.ExceptionSpec.Type) {
    case EST_Unparsed: case EST_Unevaluated: case EST_Uninstantiated:
      // We don't know yet. It shouldn't matter what we pick here; no-one
      // should ever look at this.
      LLVM_FALLTHROUGH[[gnu::fallthrough]];
    case EST_None: case EST_MSAny: case EST_NoexceptFalse:
      CanonicalEPI.ExceptionSpec.Type = EST_None;
      break;

      // A dynamic exception specification is almost always "not noexcept",
      // with the exception that a pack expansion might expand to no types.
    case EST_Dynamic: {
      bool AnyPacks = false;
      for (QualType ET : EPI.ExceptionSpec.Exceptions) {
        if (ET->getAs<PackExpansionType>())
          AnyPacks = true;
        ExceptionTypeStorage.push_back(getCanonicalType(ET));
      }
      if (!AnyPacks)
        CanonicalEPI.ExceptionSpec.Type = EST_None;
      else {
        CanonicalEPI.ExceptionSpec.Type = EST_Dynamic;
        CanonicalEPI.ExceptionSpec.Exceptions = ExceptionTypeStorage;
      }
      break;
    }

    case EST_DynamicNone:
    case EST_BasicNoexcept:
    case EST_NoexceptTrue:
    case EST_NoThrow:
      CanonicalEPI.ExceptionSpec.Type = EST_BasicNoexcept;
      break;

    case EST_DependentNoexcept:
      llvm_unreachable("dependent noexcept is already canonical")::llvm::llvm_unreachable_internal("dependent noexcept is already canonical"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3847);
    }
  } else {
    CanonicalEPI.ExceptionSpec = FunctionProtoType::ExceptionSpecInfo();
  }

  // Adjust the canonical function result type.
  CanQualType CanResultTy = getCanonicalFunctionResultType(ResultTy);
  Canonical =
      getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI, true);

  // Get the new insert position for the node we care about.
  FunctionProtoType *NewIP =
    FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3861, __PRETTY_FUNCTION__)); (void)NewIP;
}

// Compute the needed size to hold this FunctionProtoType and the
// various trailing objects.
auto ESH = FunctionProtoType::getExceptionSpecSize(
    EPI.ExceptionSpec.Type, EPI.ExceptionSpec.Exceptions.size());
size_t Size = FunctionProtoType::totalSizeToAlloc<
    QualType, FunctionType::FunctionTypeExtraBitfields,
    FunctionType::ExceptionType, Expr *, FunctionDecl *,
    FunctionProtoType::ExtParameterInfo, Qualifiers>(
    NumArgs, FunctionProtoType::hasExtraBitfields(EPI.ExceptionSpec.Type),
    ESH.NumExceptionType, ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
    EPI.ExtParameterInfos ? NumArgs : 0,
    EPI.TypeQuals.hasNonFastQualifiers() ? 1 : 0);

auto *FTP = (FunctionProtoType *)Allocate(Size, TypeAlignment);
FunctionProtoType::ExtProtoInfo newEPI = EPI;
new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
Types.push_back(FTP);
if (!Unique)
  FunctionProtoTypes.InsertNode(FTP, InsertPos);
return QualType(FTP, 0);
3884}

3886QualType ASTContext::getPipeType(QualType T, bool ReadOnly) const {
llvm::FoldingSetNodeID ID;
PipeType::Profile(ID, T, ReadOnly);

void *InsertPos = nullptr;
if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(PT, 0);

// If the pipe element type isn't canonical, this won't be a canonical type
// either, so fill in the canonical type field.
QualType Canonical;
if (!T.isCanonical()) {
  Canonical = getPipeType(getCanonicalType(T), ReadOnly);

  // Get the new insert position for the node we care about.
  PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3902, __PRETTY_FUNCTION__));
  (void)NewIP;
}
auto *New = new (*this, TypeAlignment) PipeType(T, Canonical, ReadOnly);
Types.push_back(New);
PipeTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
3909}

3911QualType ASTContext::adjustStringLiteralBaseType(QualType Ty) const {
// OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
return LangOpts.OpenCL ? getAddrSpaceQualType(Ty, LangAS::opencl_constant)
                       : Ty;
3915}

3917QualType ASTContext::getReadPipeType(QualType T) const {
return getPipeType(T, true);
3919}

3921QualType ASTContext::getWritePipeType(QualType T) const {
return getPipeType(T, false);
3923}

3925#ifndef NDEBUG
3926static bool NeedsInjectedClassNameType(const RecordDecl *D) {
if (!isa<CXXRecordDecl>(D)) return false;
const auto *RD = cast<CXXRecordDecl>(D);
if (isa<ClassTemplatePartialSpecializationDecl>(RD))
  return true;
if (RD->getDescribedClassTemplate() &&
    !isa<ClassTemplateSpecializationDecl>(RD))
  return true;
return false;
3935}
3936#endif

3938/// getInjectedClassNameType - Return the unique reference to the
3939/// injected class name type for the specified templated declaration.
3940QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl,
                                            QualType TST) const {
assert(NeedsInjectedClassNameType(Decl))((NeedsInjectedClassNameType(Decl)) ? static_cast<void>
 (0) : __assert_fail ("NeedsInjectedClassNameType(Decl)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3942, __PRETTY_FUNCTION__));
if (Decl->TypeForDecl) {
  assert(isa<InjectedClassNameType>(Decl->TypeForDecl))((isa<InjectedClassNameType>(Decl->TypeForDecl)) ? static_cast
<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3944, __PRETTY_FUNCTION__));
} else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) {
  assert(PrevDecl->TypeForDecl && "previous declaration has no type")((PrevDecl->TypeForDecl && "previous declaration has no type"
) ? static_cast<void> (0) : __assert_fail ("PrevDecl->TypeForDecl && \"previous declaration has no type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3946, __PRETTY_FUNCTION__));
  Decl->TypeForDecl = PrevDecl->TypeForDecl;
  assert(isa<InjectedClassNameType>(Decl->TypeForDecl))((isa<InjectedClassNameType>(Decl->TypeForDecl)) ? static_cast
<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3948, __PRETTY_FUNCTION__));
} else {
  Type *newType =
    new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
  Decl->TypeForDecl = newType;
  Types.push_back(newType);
}
return QualType(Decl->TypeForDecl, 0);
3956}

3958/// getTypeDeclType - Return the unique reference to the type for the
3959/// specified type declaration.
3960QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
assert(Decl && "Passed null for Decl param")((Decl && "Passed null for Decl param") ? static_cast
<void> (0) : __assert_fail ("Decl && \"Passed null for Decl param\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3961, __PRETTY_FUNCTION__));
assert(!Decl->TypeForDecl && "TypeForDecl present in slow case")((!Decl->TypeForDecl && "TypeForDecl present in slow case"
) ? static_cast<void> (0) : __assert_fail ("!Decl->TypeForDecl && \"TypeForDecl present in slow case\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3962, __PRETTY_FUNCTION__));

if (const auto *Typedef = dyn_cast<TypedefNameDecl>(Decl))
  return getTypedefType(Typedef);

assert(!isa<TemplateTypeParmDecl>(Decl) &&((!isa<TemplateTypeParmDecl>(Decl) && "Template type parameter types are always available."
) ? static_cast<void> (0) : __assert_fail ("!isa<TemplateTypeParmDecl>(Decl) && \"Template type parameter types are always available.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3968, __PRETTY_FUNCTION__))
       "Template type parameter types are always available.")((!isa<TemplateTypeParmDecl>(Decl) && "Template type parameter types are always available."
) ? static_cast<void> (0) : __assert_fail ("!isa<TemplateTypeParmDecl>(Decl) && \"Template type parameter types are always available.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3968, __PRETTY_FUNCTION__));

if (const auto *Record = dyn_cast<RecordDecl>(Decl)) {
  assert(Record->isFirstDecl() && "struct/union has previous declaration")((Record->isFirstDecl() && "struct/union has previous declaration"
) ? static_cast<void> (0) : __assert_fail ("Record->isFirstDecl() && \"struct/union has previous declaration\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3971, __PRETTY_FUNCTION__));
  assert(!NeedsInjectedClassNameType(Record))((!NeedsInjectedClassNameType(Record)) ? static_cast<void>
 (0) : __assert_fail ("!NeedsInjectedClassNameType(Record)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3972, __PRETTY_FUNCTION__));
  return getRecordType(Record);
} else if (const auto *Enum = dyn_cast<EnumDecl>(Decl)) {
  assert(Enum->isFirstDecl() && "enum has previous declaration")((Enum->isFirstDecl() && "enum has previous declaration"
) ? static_cast<void> (0) : __assert_fail ("Enum->isFirstDecl() && \"enum has previous declaration\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3975, __PRETTY_FUNCTION__));
  return getEnumType(Enum);
} else if (const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
  Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
  Decl->TypeForDecl = newType;
  Types.push_back(newType);
} else
  llvm_unreachable("TypeDecl without a type?")::llvm::llvm_unreachable_internal("TypeDecl without a type?",
 "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 3982);

return QualType(Decl->TypeForDecl, 0);
3985}

3987/// getTypedefType - Return the unique reference to the type for the
3988/// specified typedef name decl.
3989QualType
3990ASTContext::getTypedefType(const TypedefNameDecl *Decl,
                         QualType Canonical) const {
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);

if (Canonical.isNull())
  Canonical = getCanonicalType(Decl->getUnderlyingType());
auto *newType = new (*this, TypeAlignment)
  TypedefType(Type::Typedef, Decl, Canonical);
Decl->TypeForDecl = newType;
Types.push_back(newType);
return QualType(newType, 0);
4001}

4003QualType ASTContext::getRecordType(const RecordDecl *Decl) const {
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);

if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
  if (PrevDecl->TypeForDecl)
    return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);

auto *newType = new (*this, TypeAlignment) RecordType(Decl);
Decl->TypeForDecl = newType;
Types.push_back(newType);
return QualType(newType, 0);
4014}

4016QualType ASTContext::getEnumType(const EnumDecl *Decl) const {
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);

if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
  if (PrevDecl->TypeForDecl)
    return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);

auto *newType = new (*this, TypeAlignment) EnumType(Decl);
Decl->TypeForDecl = newType;
Types.push_back(newType);
return QualType(newType, 0);
4027}

4029QualType ASTContext::getAttributedType(attr::Kind attrKind,
                                     QualType modifiedType,
                                     QualType equivalentType) {
llvm::FoldingSetNodeID id;
AttributedType::Profile(id, attrKind, modifiedType, equivalentType);

void *insertPos = nullptr;
AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
if (type) return QualType(type, 0);

QualType canon = getCanonicalType(equivalentType);
type = new (*this, TypeAlignment)
    AttributedType(canon, attrKind, modifiedType, equivalentType);

Types.push_back(type);
AttributedTypes.InsertNode(type, insertPos);

return QualType(type, 0);
4047}

4049/// Retrieve a substitution-result type.
4050QualType
4051ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
                                       QualType Replacement) const {
assert(Replacement.isCanonical()((Replacement.isCanonical() && "replacement types must always be canonical"
) ? static_cast<void> (0) : __assert_fail ("Replacement.isCanonical() && \"replacement types must always be canonical\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4054, __PRETTY_FUNCTION__))
       && "replacement types must always be canonical")((Replacement.isCanonical() && "replacement types must always be canonical"
) ? static_cast<void> (0) : __assert_fail ("Replacement.isCanonical() && \"replacement types must always be canonical\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4054, __PRETTY_FUNCTION__));

llvm::FoldingSetNodeID ID;
SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
void *InsertPos = nullptr;
SubstTemplateTypeParmType *SubstParm
  = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);

if (!SubstParm) {
  SubstParm = new (*this, TypeAlignment)
    SubstTemplateTypeParmType(Parm, Replacement);
  Types.push_back(SubstParm);
  SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
}

return QualType(SubstParm, 0);
4070}

4072/// Retrieve a
4073QualType ASTContext::getSubstTemplateTypeParmPackType(
                                        const TemplateTypeParmType *Parm,
                                            const TemplateArgument &ArgPack) {
4076#ifndef NDEBUG
for (const auto &P : ArgPack.pack_elements()) {
  assert(P.getKind() == TemplateArgument::Type &&"Pack contains a non-type")((P.getKind() == TemplateArgument::Type &&"Pack contains a non-type"
) ? static_cast<void> (0) : __assert_fail ("P.getKind() == TemplateArgument::Type &&\"Pack contains a non-type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4078, __PRETTY_FUNCTION__));
  assert(P.getAsType().isCanonical() && "Pack contains non-canonical type")((P.getAsType().isCanonical() && "Pack contains non-canonical type"
) ? static_cast<void> (0) : __assert_fail ("P.getAsType().isCanonical() && \"Pack contains non-canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4079, __PRETTY_FUNCTION__));
}
4081#endif

llvm::FoldingSetNodeID ID;
SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
void *InsertPos = nullptr;
if (SubstTemplateTypeParmPackType *SubstParm
      = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(SubstParm, 0);

QualType Canon;
if (!Parm->isCanonicalUnqualified()) {
  Canon = getCanonicalType(QualType(Parm, 0));
  Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon),
                                           ArgPack);
  SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
}

auto *SubstParm
  = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
                                                             ArgPack);
Types.push_back(SubstParm);
SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
return QualType(SubstParm, 0);
4104}

4106/// Retrieve the template type parameter type for a template
4107/// parameter or parameter pack with the given depth, index, and (optionally)
4108/// name.
4109QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
                                           bool ParameterPack,
                                           TemplateTypeParmDecl *TTPDecl) const {
llvm::FoldingSetNodeID ID;
TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
void *InsertPos = nullptr;
TemplateTypeParmType *TypeParm
  = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);

if (TypeParm)
  return QualType(TypeParm, 0);

if (TTPDecl) {
  QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
  TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);

  TemplateTypeParmType *TypeCheck
    = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!TypeCheck && "Template type parameter canonical type broken")((!TypeCheck && "Template type parameter canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!TypeCheck && \"Template type parameter canonical type broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4127, __PRETTY_FUNCTION__));
  (void)TypeCheck;
} else
  TypeParm = new (*this, TypeAlignment)
    TemplateTypeParmType(Depth, Index, ParameterPack);

Types.push_back(TypeParm);
TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);

return QualType(TypeParm, 0);
4137}

4139TypeSourceInfo *
4140ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
                                            SourceLocation NameLoc,
                                      const TemplateArgumentListInfo &Args,
                                            QualType Underlying) const {
assert(!Name.getAsDependentTemplateName() &&((!Name.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Name.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4145, __PRETTY_FUNCTION__))
       "No dependent template names here!")((!Name.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Name.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4145, __PRETTY_FUNCTION__));
QualType TST = getTemplateSpecializationType(Name, Args, Underlying);

TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
TemplateSpecializationTypeLoc TL =
    DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>();
TL.setTemplateKeywordLoc(SourceLocation());
TL.setTemplateNameLoc(NameLoc);
TL.setLAngleLoc(Args.getLAngleLoc());
TL.setRAngleLoc(Args.getRAngleLoc());
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
  TL.setArgLocInfo(i, Args[i].getLocInfo());
return DI;
4158}

4160QualType
4161ASTContext::getTemplateSpecializationType(TemplateName Template,
                                        const TemplateArgumentListInfo &Args,
                                        QualType Underlying) const {
assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4165, __PRETTY_FUNCTION__))
       "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4165, __PRETTY_FUNCTION__));

SmallVector<TemplateArgument, 4> ArgVec;
ArgVec.reserve(Args.size());
for (const TemplateArgumentLoc &Arg : Args.arguments())
  ArgVec.push_back(Arg.getArgument());

return getTemplateSpecializationType(Template, ArgVec, Underlying);
4173}

4175#ifndef NDEBUG
4176static bool hasAnyPackExpansions(ArrayRef<TemplateArgument> Args) {
for (const TemplateArgument &Arg : Args)
  if (Arg.isPackExpansion())
    return true;

return true;
4182}
4183#endif

4185QualType
4186ASTContext::getTemplateSpecializationType(TemplateName Template,
                                        ArrayRef<TemplateArgument> Args,
                                        QualType Underlying) const {
assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4190, __PRETTY_FUNCTION__))
       "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4190, __PRETTY_FUNCTION__));
// Look through qualified template names.
if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
  Template = TemplateName(QTN->getTemplateDecl());

bool IsTypeAlias =
  Template.getAsTemplateDecl() &&
  isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
QualType CanonType;
if (!Underlying.isNull())
  CanonType = getCanonicalType(Underlying);
else {
  // We can get here with an alias template when the specialization contains
  // a pack expansion that does not match up with a parameter pack.
  assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&(((!IsTypeAlias || hasAnyPackExpansions(Args)) && "Caller must compute aliased type"
) ? static_cast<void> (0) : __assert_fail ("(!IsTypeAlias || hasAnyPackExpansions(Args)) && \"Caller must compute aliased type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4205, __PRETTY_FUNCTION__))
         "Caller must compute aliased type")(((!IsTypeAlias || hasAnyPackExpansions(Args)) && "Caller must compute aliased type"
) ? static_cast<void> (0) : __assert_fail ("(!IsTypeAlias || hasAnyPackExpansions(Args)) && \"Caller must compute aliased type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4205, __PRETTY_FUNCTION__));
  IsTypeAlias = false;
  CanonType = getCanonicalTemplateSpecializationType(Template, Args);
}

// Allocate the (non-canonical) template specialization type, but don't
// try to unique it: these types typically have location information that
// we don't unique and don't want to lose.
void *Mem = Allocate(sizeof(TemplateSpecializationType) +
                     sizeof(TemplateArgument) * Args.size() +
                     (IsTypeAlias? sizeof(QualType) : 0),
                     TypeAlignment);
auto *Spec
  = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
                                       IsTypeAlias ? Underlying : QualType());

Types.push_back(Spec);
return QualType(Spec, 0);
4223}

4225QualType ASTContext::getCanonicalTemplateSpecializationType(
  TemplateName Template, ArrayRef<TemplateArgument> Args) const {
assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4228, __PRETTY_FUNCTION__))
       "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4228, __PRETTY_FUNCTION__));

// Look through qualified template names.
if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
  Template = TemplateName(QTN->getTemplateDecl());

// Build the canonical template specialization type.
TemplateName CanonTemplate = getCanonicalTemplateName(Template);
SmallVector<TemplateArgument, 4> CanonArgs;
unsigned NumArgs = Args.size();
CanonArgs.reserve(NumArgs);
for (const TemplateArgument &Arg : Args)
  CanonArgs.push_back(getCanonicalTemplateArgument(Arg));

// Determine whether this canonical template specialization type already
// exists.
llvm::FoldingSetNodeID ID;
TemplateSpecializationType::Profile(ID, CanonTemplate,
                                    CanonArgs, *this);

void *InsertPos = nullptr;
TemplateSpecializationType *Spec
  = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);

if (!Spec) {
  // Allocate a new canonical template specialization type.
  void *Mem = Allocate((sizeof(TemplateSpecializationType) +
                        sizeof(TemplateArgument) * NumArgs),
                       TypeAlignment);
  Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
                                              CanonArgs,
                                              QualType(), QualType());
  Types.push_back(Spec);
  TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
}

assert(Spec->isDependentType() &&((Spec->isDependentType() && "Non-dependent template-id type must have a canonical type"
) ? static_cast<void> (0) : __assert_fail ("Spec->isDependentType() && \"Non-dependent template-id type must have a canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4265, __PRETTY_FUNCTION__))
       "Non-dependent template-id type must have a canonical type")((Spec->isDependentType() && "Non-dependent template-id type must have a canonical type"
) ? static_cast<void> (0) : __assert_fail ("Spec->isDependentType() && \"Non-dependent template-id type must have a canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4265, __PRETTY_FUNCTION__));
return QualType(Spec, 0);
4267}

4269QualType ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
                                     NestedNameSpecifier *NNS,
                                     QualType NamedType,
                                     TagDecl *OwnedTagDecl) const {
llvm::FoldingSetNodeID ID;
ElaboratedType::Profile(ID, Keyword, NNS, NamedType, OwnedTagDecl);

void *InsertPos = nullptr;
ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
if (T)
  return QualType(T, 0);

QualType Canon = NamedType;
if (!Canon.isCanonical()) {
  Canon = getCanonicalType(NamedType);
  ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!CheckT && "Elaborated canonical type broken")((!CheckT && "Elaborated canonical type broken") ? static_cast
<void> (0) : __assert_fail ("!CheckT && \"Elaborated canonical type broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4285, __PRETTY_FUNCTION__));
  (void)CheckT;
}

void *Mem = Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
                     TypeAlignment);
T = new (Mem) ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);

Types.push_back(T);
ElaboratedTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
4296}

4298QualType
4299ASTContext::getParenType(QualType InnerType) const {
llvm::FoldingSetNodeID ID;
ParenType::Profile(ID, InnerType);

void *InsertPos = nullptr;
ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
if (T)
  return QualType(T, 0);

QualType Canon = InnerType;
if (!Canon.isCanonical()) {
  Canon = getCanonicalType(InnerType);
  ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!CheckT && "Paren canonical type broken")((!CheckT && "Paren canonical type broken") ? static_cast
<void> (0) : __assert_fail ("!CheckT && \"Paren canonical type broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4312, __PRETTY_FUNCTION__));
  (void)CheckT;
}

T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
Types.push_back(T);
ParenTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
4320}

4322QualType
4323ASTContext::getMacroQualifiedType(QualType UnderlyingTy,
                                const IdentifierInfo *MacroII) const {
QualType Canon = UnderlyingTy;
if (!Canon.isCanonical())
  Canon = getCanonicalType(UnderlyingTy);

auto *newType = new (*this, TypeAlignment)
    MacroQualifiedType(UnderlyingTy, Canon, MacroII);
Types.push_back(newType);
return QualType(newType, 0);
4333}

4335QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
                                        NestedNameSpecifier *NNS,
                                        const IdentifierInfo *Name,
                                        QualType Canon) const {
if (Canon.isNull()) {
  NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
  if (CanonNNS != NNS)
    Canon = getDependentNameType(Keyword, CanonNNS, Name);
}

llvm::FoldingSetNodeID ID;
DependentNameType::Profile(ID, Keyword, NNS, Name);

void *InsertPos = nullptr;
DependentNameType *T
  = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
if (T)
  return QualType(T, 0);

T = new (*this, TypeAlignment) DependentNameType(Keyword, NNS, Name, Canon);
Types.push_back(T);
DependentNameTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
4358}

4360QualType
4361ASTContext::getDependentTemplateSpecializationType(
                               ElaboratedTypeKeyword Keyword,
                               NestedNameSpecifier *NNS,
                               const IdentifierInfo *Name,
                               const TemplateArgumentListInfo &Args) const {
// TODO: avoid this copy
SmallVector<TemplateArgument, 16> ArgCopy;
for (unsigned I = 0, E = Args.size(); I != E; ++I)
  ArgCopy.push_back(Args[I].getArgument());
return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
4371}

4373QualType
4374ASTContext::getDependentTemplateSpecializationType(
                               ElaboratedTypeKeyword Keyword,
                               NestedNameSpecifier *NNS,
                               const IdentifierInfo *Name,
                               ArrayRef<TemplateArgument> Args) const {
assert((!NNS || NNS->isDependent()) &&(((!NNS || NNS->isDependent()) && "nested-name-specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"nested-name-specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4380, __PRETTY_FUNCTION__))
       "nested-name-specifier must be dependent")(((!NNS || NNS->isDependent()) && "nested-name-specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"nested-name-specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4380, __PRETTY_FUNCTION__));

llvm::FoldingSetNodeID ID;
DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
                                             Name, Args);

void *InsertPos = nullptr;
DependentTemplateSpecializationType *T
  = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
if (T)
  return QualType(T, 0);

NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);

ElaboratedTypeKeyword CanonKeyword = Keyword;
if (Keyword == ETK_None) CanonKeyword = ETK_Typename;

bool AnyNonCanonArgs = false;
unsigned NumArgs = Args.size();
SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
for (unsigned I = 0; I != NumArgs; ++I) {
  CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
  if (!CanonArgs[I].structurallyEquals(Args[I]))
    AnyNonCanonArgs = true;
}

QualType Canon;
if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
  Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
                                                 Name,
                                                 CanonArgs);

  // Find the insert position again.
  DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
}

void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
                      sizeof(TemplateArgument) * NumArgs),
                     TypeAlignment);
T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
                                                  Name, Args, Canon);
Types.push_back(T);
DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
4424}

4426TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) {
TemplateArgument Arg;
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
  QualType ArgType = getTypeDeclType(TTP);
  if (TTP->isParameterPack())
    ArgType = getPackExpansionType(ArgType, None);

  Arg = TemplateArgument(ArgType);
} else if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
  Expr *E = new (*this) DeclRefExpr(
      *this, NTTP, /*enclosing*/ false,
      NTTP->getType().getNonLValueExprType(*this),
      Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());

  if (NTTP->isParameterPack())
    E = new (*this) PackExpansionExpr(DependentTy, E, NTTP->getLocation(),
                                      None);
  Arg = TemplateArgument(E);
} else {
  auto *TTP = cast<TemplateTemplateParmDecl>(Param);
  if (TTP->isParameterPack())
    Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
  else
    Arg = TemplateArgument(TemplateName(TTP));
}

if (Param->isTemplateParameterPack())
  Arg = TemplateArgument::CreatePackCopy(*this, Arg);

return Arg;
4456}

4458void
4459ASTContext::getInjectedTemplateArgs(const TemplateParameterList *Params,
                                  SmallVectorImpl<TemplateArgument> &Args) {
Args.reserve(Args.size() + Params->size());

for (NamedDecl *Param : *Params)
  Args.push_back(getInjectedTemplateArg(Param));
4465}

4467QualType ASTContext::getPackExpansionType(QualType Pattern,
                                        Optional<unsigned> NumExpansions) {
llvm::FoldingSetNodeID ID;
PackExpansionType::Profile(ID, Pattern, NumExpansions);

// A deduced type can deduce to a pack, eg
//   auto ...x = some_pack;
// That declaration isn't (yet) valid, but is created as part of building an
// init-capture pack:
//   [...x = some_pack] {}
assert((Pattern->containsUnexpandedParameterPack() ||(((Pattern->containsUnexpandedParameterPack() || Pattern->
getContainedDeducedType()) && "Pack expansions must expand one or more parameter packs"
) ? static_cast<void> (0) : __assert_fail ("(Pattern->containsUnexpandedParameterPack() || Pattern->getContainedDeducedType()) && \"Pack expansions must expand one or more parameter packs\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4479, __PRETTY_FUNCTION__))
        Pattern->getContainedDeducedType()) &&(((Pattern->containsUnexpandedParameterPack() || Pattern->
getContainedDeducedType()) && "Pack expansions must expand one or more parameter packs"
) ? static_cast<void> (0) : __assert_fail ("(Pattern->containsUnexpandedParameterPack() || Pattern->getContainedDeducedType()) && \"Pack expansions must expand one or more parameter packs\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4479, __PRETTY_FUNCTION__))
       "Pack expansions must expand one or more parameter packs")(((Pattern->containsUnexpandedParameterPack() || Pattern->
getContainedDeducedType()) && "Pack expansions must expand one or more parameter packs"
) ? static_cast<void> (0) : __assert_fail ("(Pattern->containsUnexpandedParameterPack() || Pattern->getContainedDeducedType()) && \"Pack expansions must expand one or more parameter packs\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4479, __PRETTY_FUNCTION__));
void *InsertPos = nullptr;
PackExpansionType *T
  = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
if (T)
  return QualType(T, 0);

QualType Canon;
if (!Pattern.isCanonical()) {
  Canon = getCanonicalType(Pattern);
  // The canonical type might not contain an unexpanded parameter pack, if it
  // contains an alias template specialization which ignores one of its
  // parameters.
  if (Canon->containsUnexpandedParameterPack()) {
    Canon = getPackExpansionType(Canon, NumExpansions);

    // Find the insert position again, in case we inserted an element into
    // PackExpansionTypes and invalidated our insert position.
    PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
  }
}

T = new (*this, TypeAlignment)
    PackExpansionType(Pattern, Canon, NumExpansions);
Types.push_back(T);
PackExpansionTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
4506}

4508/// CmpProtocolNames - Comparison predicate for sorting protocols
4509/// alphabetically.
4510static int CmpProtocolNames(ObjCProtocolDecl *const *LHS,
                          ObjCProtocolDecl *const *RHS) {
return DeclarationName::compare((*LHS)->getDeclName(), (*RHS)->getDeclName());
4513}

4515static bool areSortedAndUniqued(ArrayRef<ObjCProtocolDecl *> Protocols) {
if (Protocols.empty()) return true;

if (Protocols[0]->getCanonicalDecl() != Protocols[0])
  return false;

for (unsigned i = 1; i != Protocols.size(); ++i)
  if (CmpProtocolNames(&Protocols[i - 1], &Protocols[i]) >= 0 ||
      Protocols[i]->getCanonicalDecl() != Protocols[i])
    return false;
return true;
4526}

4528static void
4529SortAndUniqueProtocols(SmallVectorImpl<ObjCProtocolDecl *> &Protocols) {
// Sort protocols, keyed by name.
llvm::array_pod_sort(Protocols.begin(), Protocols.end(), CmpProtocolNames);

// Canonicalize.
for (ObjCProtocolDecl *&P : Protocols)
  P = P->getCanonicalDecl();

// Remove duplicates.
auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
Protocols.erase(ProtocolsEnd, Protocols.end());
4540}

4542QualType ASTContext::getObjCObjectType(QualType BaseType,
                                     ObjCProtocolDecl * const *Protocols,
                                     unsigned NumProtocols) const {
return getObjCObjectType(BaseType, {},
                         llvm::makeArrayRef(Protocols, NumProtocols),
                         /*isKindOf=*/false);
4548}

4550QualType ASTContext::getObjCObjectType(
         QualType baseType,
         ArrayRef<QualType> typeArgs,
         ArrayRef<ObjCProtocolDecl *> protocols,
         bool isKindOf) const {
// If the base type is an interface and there aren't any protocols or
// type arguments to add, then the interface type will do just fine.
if (typeArgs.empty() && protocols.empty() && !isKindOf &&
    isa<ObjCInterfaceType>(baseType))
  return baseType;

// Look in the folding set for an existing type.
llvm::FoldingSetNodeID ID;
ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
void *InsertPos = nullptr;
if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(QT, 0);

// Determine the type arguments to be used for canonicalization,
// which may be explicitly specified here or written on the base
// type.
ArrayRef<QualType> effectiveTypeArgs = typeArgs;
if (effectiveTypeArgs.empty()) {
  if (const auto *baseObject = baseType->getAs<ObjCObjectType>())
    effectiveTypeArgs = baseObject->getTypeArgs();
}

// Build the canonical type, which has the canonical base type and a
// sorted-and-uniqued list of protocols and the type arguments
// canonicalized.
QualType canonical;
bool typeArgsAreCanonical = std::all_of(effectiveTypeArgs.begin(),
                                        effectiveTypeArgs.end(),
                                        [&](QualType type) {
                                          return type.isCanonical();
                                        });
bool protocolsSorted = areSortedAndUniqued(protocols);
if (!typeArgsAreCanonical || !protocolsSorted || !baseType.isCanonical()) {
  // Determine the canonical type arguments.
  ArrayRef<QualType> canonTypeArgs;
  SmallVector<QualType, 4> canonTypeArgsVec;
  if (!typeArgsAreCanonical) {
    canonTypeArgsVec.reserve(effectiveTypeArgs.size());
    for (auto typeArg : effectiveTypeArgs)
      canonTypeArgsVec.push_back(getCanonicalType(typeArg));
    canonTypeArgs = canonTypeArgsVec;
  } else {
    canonTypeArgs = effectiveTypeArgs;
  }

  ArrayRef<ObjCProtocolDecl *> canonProtocols;
  SmallVector<ObjCProtocolDecl*, 8> canonProtocolsVec;
  if (!protocolsSorted) {
    canonProtocolsVec.append(protocols.begin(), protocols.end());
    SortAndUniqueProtocols(canonProtocolsVec);
    canonProtocols = canonProtocolsVec;
  } else {
    canonProtocols = protocols;
  }

  canonical = getObjCObjectType(getCanonicalType(baseType), canonTypeArgs,
                                canonProtocols, isKindOf);

  // Regenerate InsertPos.
  ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
}

unsigned size = sizeof(ObjCObjectTypeImpl);
size += typeArgs.size() * sizeof(QualType);
size += protocols.size() * sizeof(ObjCProtocolDecl *);
void *mem = Allocate(size, TypeAlignment);
auto *T =
  new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
                               isKindOf);

Types.push_back(T);
ObjCObjectTypes.InsertNode(T, InsertPos);
return QualType(T, 0);
4628}

4630/// Apply Objective-C protocol qualifiers to the given type.
4631/// If this is for the canonical type of a type parameter, we can apply
4632/// protocol qualifiers on the ObjCObjectPointerType.
4633QualType
4634ASTContext::applyObjCProtocolQualifiers(QualType type,
                ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
                bool allowOnPointerType) const {
hasError = false;

if (const auto *objT = dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
  return getObjCTypeParamType(objT->getDecl(), protocols);
}

// Apply protocol qualifiers to ObjCObjectPointerType.
if (allowOnPointerType) {
  if (const auto *objPtr =
          dyn_cast<ObjCObjectPointerType>(type.getTypePtr())) {
    const ObjCObjectType *objT = objPtr->getObjectType();
    // Merge protocol lists and construct ObjCObjectType.
    SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
    protocolsVec.append(objT->qual_begin(),
                        objT->qual_end());
    protocolsVec.append(protocols.begin(), protocols.end());
    ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
    type = getObjCObjectType(
           objT->getBaseType(),
           objT->getTypeArgsAsWritten(),
           protocols,
           objT->isKindOfTypeAsWritten());
    return getObjCObjectPointerType(type);
  }
}

// Apply protocol qualifiers to ObjCObjectType.
if (const auto *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
  // FIXME: Check for protocols to which the class type is already
  // known to conform.

  return getObjCObjectType(objT->getBaseType(),
                           objT->getTypeArgsAsWritten(),
                           protocols,
                           objT->isKindOfTypeAsWritten());
}

// If the canonical type is ObjCObjectType, ...
if (type->isObjCObjectType()) {
  // Silently overwrite any existing protocol qualifiers.
  // TODO: determine whether that's the right thing to do.

  // FIXME: Check for protocols to which the class type is already
  // known to conform.
  return getObjCObjectType(type, {}, protocols, false);
}

// id<protocol-list>
if (type->isObjCIdType()) {
  const auto *objPtr = type->castAs<ObjCObjectPointerType>();
  type = getObjCObjectType(ObjCBuiltinIdTy, {}, protocols,
                               objPtr->isKindOfType());
  return getObjCObjectPointerType(type);
}

// Class<protocol-list>
if (type->isObjCClassType()) {
  const auto *objPtr = type->castAs<ObjCObjectPointerType>();
  type = getObjCObjectType(ObjCBuiltinClassTy, {}, protocols,
                               objPtr->isKindOfType());
  return getObjCObjectPointerType(type);
}

hasError = true;
return type;
4702}

4704QualType
4705ASTContext::getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
                         ArrayRef<ObjCProtocolDecl *> protocols,
                         QualType Canonical) const {
// Look in the folding set for an existing type.
llvm::FoldingSetNodeID ID;
ObjCTypeParamType::Profile(ID, Decl, protocols);
void *InsertPos = nullptr;
if (ObjCTypeParamType *TypeParam =
    ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(TypeParam, 0);

if (Canonical.isNull()) {
  // We canonicalize to the underlying type.
  Canonical = getCanonicalType(Decl->getUnderlyingType());
  if (!protocols.empty()) {
    // Apply the protocol qualifers.
    bool hasError;
    Canonical = getCanonicalType(applyObjCProtocolQualifiers(
        Canonical, protocols, hasError, true /*allowOnPointerType*/));
    assert(!hasError && "Error when apply protocol qualifier to bound type")((!hasError && "Error when apply protocol qualifier to bound type"
) ? static_cast<void> (0) : __assert_fail ("!hasError && \"Error when apply protocol qualifier to bound type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4724, __PRETTY_FUNCTION__));
  }
}

unsigned size = sizeof(ObjCTypeParamType);
size += protocols.size() * sizeof(ObjCProtocolDecl *);
void *mem = Allocate(size, TypeAlignment);
auto *newType = new (mem) ObjCTypeParamType(Decl, Canonical, protocols);

Types.push_back(newType);
ObjCTypeParamTypes.InsertNode(newType, InsertPos);
return QualType(newType, 0);
4736}

4738/// ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's
4739/// protocol list adopt all protocols in QT's qualified-id protocol
4740/// list.
4741bool ASTContext::ObjCObjectAdoptsQTypeProtocols(QualType QT,
                                              ObjCInterfaceDecl *IC) {
if (!QT->isObjCQualifiedIdType())
  return false;

if (const auto *OPT = QT->getAs<ObjCObjectPointerType>()) {
  // If both the right and left sides have qualifiers.
  for (auto *Proto : OPT->quals()) {
    if (!IC->ClassImplementsProtocol(Proto, false))
      return false;
  }
  return true;
}
return false;
4755}

4757/// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
4758/// QT's qualified-id protocol list adopt all protocols in IDecl's list
4759/// of protocols.
4760bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
                                              ObjCInterfaceDecl *IDecl) {
if (!QT->isObjCQualifiedIdType())
  return false;
const auto *OPT = QT->getAs<ObjCObjectPointerType>();
if (!OPT)
  return false;
if (!IDecl->hasDefinition())
  return false;
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
CollectInheritedProtocols(IDecl, InheritedProtocols);
if (InheritedProtocols.empty())
  return false;
// Check that if every protocol in list of id<plist> conforms to a protocol
// of IDecl's, then bridge casting is ok.
bool Conforms = false;
for (auto *Proto : OPT->quals()) {
  Conforms = false;
  for (auto *PI : InheritedProtocols) {
    if (ProtocolCompatibleWithProtocol(Proto, PI)) {
      Conforms = true;
      break;
    }
  }
  if (!Conforms)
    break;
}
if (Conforms)
  return true;

for (auto *PI : InheritedProtocols) {
  // If both the right and left sides have qualifiers.
  bool Adopts = false;
  for (auto *Proto : OPT->quals()) {
    // return 'true' if 'PI' is in the inheritance hierarchy of Proto
    if ((Adopts = ProtocolCompatibleWithProtocol(PI, Proto)))
      break;
  }
  if (!Adopts)
    return false;
}
return true;
4802}

4804/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
4805/// the given object type.
4806QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const {
llvm::FoldingSetNodeID ID;
ObjCObjectPointerType::Profile(ID, ObjectT);

void *InsertPos = nullptr;
if (ObjCObjectPointerType *QT =
            ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(QT, 0);

// Find the canonical object type.
QualType Canonical;
if (!ObjectT.isCanonical()) {
  Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));

  // Regenerate InsertPos.
  ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
}

// No match.
void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
auto *QType =
  new (Mem) ObjCObjectPointerType(Canonical, ObjectT);

Types.push_back(QType);
ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
return QualType(QType, 0);
4832}

4834/// getObjCInterfaceType - Return the unique reference to the type for the
4835/// specified ObjC interface decl. The list of protocols is optional.
4836QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
                                        ObjCInterfaceDecl *PrevDecl) const {
if (Decl->TypeForDecl)
  return QualType(Decl->TypeForDecl, 0);

if (PrevDecl) {
  assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl")((PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"
) ? static_cast<void> (0) : __assert_fail ("PrevDecl->TypeForDecl && \"previous decl has no TypeForDecl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4842, __PRETTY_FUNCTION__));
  Decl->TypeForDecl = PrevDecl->TypeForDecl;
  return QualType(PrevDecl->TypeForDecl, 0);
}

// Prefer the definition, if there is one.
if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
  Decl = Def;

void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
auto *T = new (Mem) ObjCInterfaceType(Decl);
Decl->TypeForDecl = T;
Types.push_back(T);
return QualType(T, 0);
4856}

4858/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
4859/// TypeOfExprType AST's (since expression's are never shared). For example,
4860/// multiple declarations that refer to "typeof(x)" all contain different
4861/// DeclRefExpr's. This doesn't effect the type checker, since it operates
4862/// on canonical type's (which are always unique).
4863QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const {
TypeOfExprType *toe;
if (tofExpr->isTypeDependent()) {
  llvm::FoldingSetNodeID ID;
  DependentTypeOfExprType::Profile(ID, *this, tofExpr);

  void *InsertPos = nullptr;
  DependentTypeOfExprType *Canon
    = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
  if (Canon) {
    // We already have a "canonical" version of an identical, dependent
    // typeof(expr) type. Use that as our canonical type.
    toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
                                        QualType((TypeOfExprType*)Canon, 0));
  } else {
    // Build a new, canonical typeof(expr) type.
    Canon
      = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
    DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
    toe = Canon;
  }
} else {
  QualType Canonical = getCanonicalType(tofExpr->getType());
  toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
}
Types.push_back(toe);
return QualType(toe, 0);
4890}

4892/// getTypeOfType -  Unlike many "get<Type>" functions, we don't unique
4893/// TypeOfType nodes. The only motivation to unique these nodes would be
4894/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
4895/// an issue. This doesn't affect the type checker, since it operates
4896/// on canonical types (which are always unique).
4897QualType ASTContext::getTypeOfType(QualType tofType) const {
QualType Canonical = getCanonicalType(tofType);
auto *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
Types.push_back(tot);
return QualType(tot, 0);
4902}

4904/// Unlike many "get<Type>" functions, we don't unique DecltypeType
4905/// nodes. This would never be helpful, since each such type has its own
4906/// expression, and would not give a significant memory saving, since there
4907/// is an Expr tree under each such type.
4908QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const {
DecltypeType *dt;

// C++11 [temp.type]p2:
//   If an expression e involves a template parameter, decltype(e) denotes a
//   unique dependent type. Two such decltype-specifiers refer to the same
//   type only if their expressions are equivalent (14.5.6.1).
if (e->isInstantiationDependent()) {
  llvm::FoldingSetNodeID ID;
  DependentDecltypeType::Profile(ID, *this, e);

  void *InsertPos = nullptr;
  DependentDecltypeType *Canon
    = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
  if (!Canon) {
    // Build a new, canonical decltype(expr) type.
    Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
    DependentDecltypeTypes.InsertNode(Canon, InsertPos);
  }
  dt = new (*this, TypeAlignment)
      DecltypeType(e, UnderlyingType, QualType((DecltypeType *)Canon, 0));
} else {
  dt = new (*this, TypeAlignment)
      DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
}
Types.push_back(dt);
return QualType(dt, 0);
4935}

4937/// getUnaryTransformationType - We don't unique these, since the memory
4938/// savings are minimal and these are rare.
4939QualType ASTContext::getUnaryTransformType(QualType BaseType,
                                         QualType UnderlyingType,
                                         UnaryTransformType::UTTKind Kind)
  const {
UnaryTransformType *ut = nullptr;

if (BaseType->isDependentType()) {
  // Look in the folding set for an existing type.
  llvm::FoldingSetNodeID ID;
  DependentUnaryTransformType::Profile(ID, getCanonicalType(BaseType), Kind);

  void *InsertPos = nullptr;
  DependentUnaryTransformType *Canon
    = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);

  if (!Canon) {
    // Build a new, canonical __underlying_type(type) type.
    Canon = new (*this, TypeAlignment)
           DependentUnaryTransformType(*this, getCanonicalType(BaseType),
                                       Kind);
    DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
  }
  ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
                                                      QualType(), Kind,
                                                      QualType(Canon, 0));
} else {
  QualType CanonType = getCanonicalType(UnderlyingType);
  ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
                                                      UnderlyingType, Kind,
                                                      CanonType);
}
Types.push_back(ut);
return QualType(ut, 0);
4972}

4974/// getAutoType - Return the uniqued reference to the 'auto' type which has been
4975/// deduced to the given type, or to the canonical undeduced 'auto' type, or the
4976/// canonical deduced-but-dependent 'auto' type.
4977QualType ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
                               bool IsDependent, bool IsPack) const {
assert((!IsPack || IsDependent) && "only use IsPack for a dependent pack")(((!IsPack || IsDependent) && "only use IsPack for a dependent pack"
) ? static_cast<void> (0) : __assert_fail ("(!IsPack || IsDependent) && \"only use IsPack for a dependent pack\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 4979, __PRETTY_FUNCTION__));
if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto && !IsDependent)
  return getAutoDeductType();

// Look in the folding set for an existing type.
void *InsertPos = nullptr;
llvm::FoldingSetNodeID ID;
AutoType::Profile(ID, DeducedType, Keyword, IsDependent, IsPack);
if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(AT, 0);

auto *AT = new (*this, TypeAlignment)
    AutoType(DeducedType, Keyword, IsDependent, IsPack);
Types.push_back(AT);
if (InsertPos)
  AutoTypes.InsertNode(AT, InsertPos);
return QualType(AT, 0);
4996}

4998/// Return the uniqued reference to the deduced template specialization type
4999/// which has been deduced to the given type, or to the canonical undeduced
5000/// such type, or the canonical deduced-but-dependent such type.
5001QualType ASTContext::getDeducedTemplateSpecializationType(
  TemplateName Template, QualType DeducedType, bool IsDependent) const {
// Look in the folding set for an existing type.
void *InsertPos = nullptr;
llvm::FoldingSetNodeID ID;
DeducedTemplateSpecializationType::Profile(ID, Template, DeducedType,
                                           IsDependent);
if (DeducedTemplateSpecializationType *DTST =
        DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(DTST, 0);

auto *DTST = new (*this, TypeAlignment)
    DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
Types.push_back(DTST);
if (InsertPos)
  DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
return QualType(DTST, 0);
5018}

5020/// getAtomicType - Return the uniqued reference to the atomic type for
5021/// the given value type.
5022QualType ASTContext::getAtomicType(QualType T) const {
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
AtomicType::Profile(ID, T);

void *InsertPos = nullptr;
if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
  return QualType(AT, 0);

// If the atomic value type isn't canonical, this won't be a canonical type
// either, so fill in the canonical type field.
QualType Canonical;
if (!T.isCanonical()) {
  Canonical = getAtomicType(getCanonicalType(T));

  // Get the new insert position for the node we care about.
  AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
  assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5040, __PRETTY_FUNCTION__)); (void)NewIP;
}
auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
Types.push_back(New);
AtomicTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
5046}

5048/// getAutoDeductType - Get type pattern for deducing against 'auto'.
5049QualType ASTContext::getAutoDeductType() const {
if (AutoDeductTy.isNull())
  AutoDeductTy = QualType(
    new (*this, TypeAlignment) AutoType(QualType(), AutoTypeKeyword::Auto,
                                        /*dependent*/false, /*pack*/false),
    0);
return AutoDeductTy;
5056}

5058/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
5059QualType ASTContext::getAutoRRefDeductType() const {
if (AutoRRefDeductTy.isNull())
  AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType());
assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern")((!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"
) ? static_cast<void> (0) : __assert_fail ("!AutoRRefDeductTy.isNull() && \"can't build 'auto &&' pattern\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5062, __PRETTY_FUNCTION__));
return AutoRRefDeductTy;
5064}

5066/// getTagDeclType - Return the unique reference to the type for the
5067/// specified TagDecl (struct/union/class/enum) decl.
5068QualType ASTContext::getTagDeclType(const TagDecl *Decl) const {
assert(Decl)((Decl) ? static_cast<void> (0) : __assert_fail ("Decl"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5069, __PRETTY_FUNCTION__));
// FIXME: What is the design on getTagDeclType when it requires casting
// away const?  mutable?
return getTypeDeclType(const_cast<TagDecl*>(Decl));
5073}

5075/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
5076/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
5077/// needs to agree with the definition in <stddef.h>.
5078CanQualType ASTContext::getSizeType() const {
return getFromTargetType(Target->getSizeType());
5080}

5082/// Return the unique signed counterpart of the integer type
5083/// corresponding to size_t.
5084CanQualType ASTContext::getSignedSizeType() const {
return getFromTargetType(Target->getSignedSizeType());
5086}

5088/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5).
5089CanQualType ASTContext::getIntMaxType() const {
return getFromTargetType(Target->getIntMaxType());
5091}

5093/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5).
5094CanQualType ASTContext::getUIntMaxType() const {
return getFromTargetType(Target->getUIntMaxType());
5096}

5098/// getSignedWCharType - Return the type of "signed wchar_t".
5099/// Used when in C++, as a GCC extension.
5100QualType ASTContext::getSignedWCharType() const {
// FIXME: derive from "Target" ?
return WCharTy;
5103}

5105/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
5106/// Used when in C++, as a GCC extension.
5107QualType ASTContext::getUnsignedWCharType() const {
// FIXME: derive from "Target" ?
return UnsignedIntTy;
5110}

5112QualType ASTContext::getIntPtrType() const {
return getFromTargetType(Target->getIntPtrType());
5114}

5116QualType ASTContext::getUIntPtrType() const {
return getCorrespondingUnsignedType(getIntPtrType());
5118}

5120/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17)
5121/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
5122QualType ASTContext::getPointerDiffType() const {
return getFromTargetType(Target->getPtrDiffType(0));
5124}

5126/// Return the unique unsigned counterpart of "ptrdiff_t"
5127/// integer type. The standard (C11 7.21.6.1p7) refers to this type
5128/// in the definition of %tu format specifier.
5129QualType ASTContext::getUnsignedPointerDiffType() const {
return getFromTargetType(Target->getUnsignedPtrDiffType(0));
5131}

5133/// Return the unique type for "pid_t" defined in
5134/// <sys/types.h>. We need this to compute the correct type for vfork().
5135QualType ASTContext::getProcessIDType() const {
return getFromTargetType(Target->getProcessIDType());
5137}

5139//===----------------------------------------------------------------------===//
5140//                              Type Operators
5141//===----------------------------------------------------------------------===//

5143CanQualType ASTContext::getCanonicalParamType(QualType T) const {
// Push qualifiers into arrays, and then discard any remaining
// qualifiers.
T = getCanonicalType(T);
T = getVariableArrayDecayedType(T);
const Type *Ty = T.getTypePtr();
QualType Result;
if (isa<ArrayType>(Ty)) {
  Result = getArrayDecayedType(QualType(Ty,0));
} else if (isa<FunctionType>(Ty)) {
  Result = getPointerType(QualType(Ty, 0));
} else {
  Result = QualType(Ty, 0);
}

return CanQualType::CreateUnsafe(Result);
5159}

5161QualType ASTContext::getUnqualifiedArrayType(QualType type,
                                           Qualifiers &quals) {
SplitQualType splitType = type.getSplitUnqualifiedType();

// FIXME: getSplitUnqualifiedType() actually walks all the way to
// the unqualified desugared type and then drops it on the floor.
// We then have to strip that sugar back off with
// getUnqualifiedDesugaredType(), which is silly.
const auto *AT =
    dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());

// If we don't have an array, just use the results in splitType.
if (!AT) {
  quals = splitType.Quals;
  return QualType(splitType.Ty, 0);
}

// Otherwise, recurse on the array's element type.
QualType elementType = AT->getElementType();
QualType unqualElementType = getUnqualifiedArrayType(elementType, quals);

// If that didn't change the element type, AT has no qualifiers, so we
// can just use the results in splitType.
if (elementType == unqualElementType) {
  assert(quals.empty())((quals.empty()) ? static_cast<void> (0) : __assert_fail
 ("quals.empty()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5185, __PRETTY_FUNCTION__)); // from the recursive call
  quals = splitType.Quals;
  return QualType(splitType.Ty, 0);
}

// Otherwise, add in the qualifiers from the outermost type, then
// build the type back up.
quals.addConsistentQualifiers(splitType.Quals);

if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
  return getConstantArrayType(unqualElementType, CAT->getSize(),
                              CAT->getSizeModifier(), 0);
}

if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
  return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
}

if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
  return getVariableArrayType(unqualElementType,
                              VAT->getSizeExpr(),
                              VAT->getSizeModifier(),
                              VAT->getIndexTypeCVRQualifiers(),
                              VAT->getBracketsRange());
}

const auto *DSAT = cast<DependentSizedArrayType>(AT);
return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
                                  DSAT->getSizeModifier(), 0,
                                  SourceRange());
5215}

5217/// Attempt to unwrap two types that may both be array types with the same bound
5218/// (or both be array types of unknown bound) for the purpose of comparing the
5219/// cv-decomposition of two types per C++ [conv.qual].
5220bool ASTContext::UnwrapSimilarArrayTypes(QualType &T1, QualType &T2) {
bool UnwrappedAny = false;
while (true) {
  auto *AT1 = getAsArrayType(T1);
  if (!AT1) return UnwrappedAny;

  auto *AT2 = getAsArrayType(T2);
  if (!AT2) return UnwrappedAny;

  // If we don't have two array types with the same constant bound nor two
  // incomplete array types, we've unwrapped everything we can.
  if (auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
    auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
    if (!CAT2 || CAT1->getSize() != CAT2->getSize())
      return UnwrappedAny;
  } else if (!isa<IncompleteArrayType>(AT1) ||
             !isa<IncompleteArrayType>(AT2)) {
    return UnwrappedAny;
  }

  T1 = AT1->getElementType();
  T2 = AT2->getElementType();
  UnwrappedAny = true;
}
5244}

5246/// Attempt to unwrap two types that may be similar (C++ [conv.qual]).
5247///
5248/// If T1 and T2 are both pointer types of the same kind, or both array types
5249/// with the same bound, unwraps layers from T1 and T2 until a pointer type is
5250/// unwrapped. Top-level qualifiers on T1 and T2 are ignored.
5251///
5252/// This function will typically be called in a loop that successively
5253/// "unwraps" pointer and pointer-to-member types to compare them at each
5254/// level.
5255///
5256/// \return \c true if a pointer type was unwrapped, \c false if we reached a
5257/// pair of types that can't be unwrapped further.
5258bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2) {
UnwrapSimilarArrayTypes(T1, T2);

const auto *T1PtrType = T1->getAs<PointerType>();
const auto *T2PtrType = T2->getAs<PointerType>();
if (T1PtrType && T2PtrType) {
  T1 = T1PtrType->getPointeeType();
  T2 = T2PtrType->getPointeeType();
  return true;
}

const auto *T1MPType = T1->getAs<MemberPointerType>();
const auto *T2MPType = T2->getAs<MemberPointerType>();
if (T1MPType && T2MPType &&
    hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
                           QualType(T2MPType->getClass(), 0))) {
  T1 = T1MPType->getPointeeType();
  T2 = T2MPType->getPointeeType();
  return true;
}

if (getLangOpts().ObjC) {
  const auto *T1OPType = T1->getAs<ObjCObjectPointerType>();
  const auto *T2OPType = T2->getAs<ObjCObjectPointerType>();
  if (T1OPType && T2OPType) {
    T1 = T1OPType->getPointeeType();
    T2 = T2OPType->getPointeeType();
    return true;
  }
}

// FIXME: Block pointers, too?

return false;
5292}

5294bool ASTContext::hasSimilarType(QualType T1, QualType T2) {
while (true) {
  Qualifiers Quals;
  T1 = getUnqualifiedArrayType(T1, Quals);
  T2 = getUnqualifiedArrayType(T2, Quals);
  if (hasSameType(T1, T2))
    return true;
  if (!UnwrapSimilarTypes(T1, T2))
    return false;
}
5304}

5306bool ASTContext::hasCvrSimilarType(QualType T1, QualType T2) {
while (true) {
  Qualifiers Quals1, Quals2;
  T1 = getUnqualifiedArrayType(T1, Quals1);
  T2 = getUnqualifiedArrayType(T2, Quals2);

  Quals1.removeCVRQualifiers();
  Quals2.removeCVRQualifiers();
  if (Quals1 != Quals2)
    return false;

  if (hasSameType(T1, T2))
    return true;

  if (!UnwrapSimilarTypes(T1, T2))
    return false;
}
5323}

5325DeclarationNameInfo
5326ASTContext::getNameForTemplate(TemplateName Name,
                             SourceLocation NameLoc) const {
switch (Name.getKind()) {
case TemplateName::QualifiedTemplate:
case TemplateName::Template:
  // DNInfo work in progress: CHECKME: what about DNLoc?
  return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(),
                             NameLoc);

case TemplateName::OverloadedTemplate: {
  OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate();
  // DNInfo work in progress: CHECKME: what about DNLoc?
  return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
}

case TemplateName::AssumedTemplate: {
  AssumedTemplateStorage *Storage = Name.getAsAssumedTemplateName();
  return DeclarationNameInfo(Storage->getDeclName(), NameLoc);
}

case TemplateName::DependentTemplate: {
  DependentTemplateName *DTN = Name.getAsDependentTemplateName();
  DeclarationName DName;
  if (DTN->isIdentifier()) {
    DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
    return DeclarationNameInfo(DName, NameLoc);
  } else {
    DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
    // DNInfo work in progress: FIXME: source locations?
    DeclarationNameLoc DNLoc;
    DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
    DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
    return DeclarationNameInfo(DName, NameLoc, DNLoc);
  }
}

case TemplateName::SubstTemplateTemplateParm: {
  SubstTemplateTemplateParmStorage *subst
    = Name.getAsSubstTemplateTemplateParm();
  return DeclarationNameInfo(subst->getParameter()->getDeclName(),
                             NameLoc);
}

case TemplateName::SubstTemplateTemplateParmPack: {
  SubstTemplateTemplateParmPackStorage *subst
    = Name.getAsSubstTemplateTemplateParmPack();
  return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
                             NameLoc);
}
}

llvm_unreachable("bad template name kind!")::llvm::llvm_unreachable_internal("bad template name kind!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5377);
5378}

5380TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const {
switch (Name.getKind()) {
case TemplateName::QualifiedTemplate:
case TemplateName::Template: {
  TemplateDecl *Template = Name.getAsTemplateDecl();
  if (auto *TTP  = dyn_cast<TemplateTemplateParmDecl>(Template))
    Template = getCanonicalTemplateTemplateParmDecl(TTP);

  // The canonical template name is the canonical template declaration.
  return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
}

case TemplateName::OverloadedTemplate:
case TemplateName::AssumedTemplate:
  llvm_unreachable("cannot canonicalize unresolved template")::llvm::llvm_unreachable_internal("cannot canonicalize unresolved template"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5394);

case TemplateName::DependentTemplate: {
  DependentTemplateName *DTN = Name.getAsDependentTemplateName();
  assert(DTN && "Non-dependent template names must refer to template decls.")((DTN && "Non-dependent template names must refer to template decls."
) ? static_cast<void> (0) : __assert_fail ("DTN && \"Non-dependent template names must refer to template decls.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5398, __PRETTY_FUNCTION__));
  return DTN->CanonicalTemplateName;
}

case TemplateName::SubstTemplateTemplateParm: {
  SubstTemplateTemplateParmStorage *subst
    = Name.getAsSubstTemplateTemplateParm();
  return getCanonicalTemplateName(subst->getReplacement());
}

case TemplateName::SubstTemplateTemplateParmPack: {
  SubstTemplateTemplateParmPackStorage *subst
                                = Name.getAsSubstTemplateTemplateParmPack();
  TemplateTemplateParmDecl *canonParameter
    = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
  TemplateArgument canonArgPack
    = getCanonicalTemplateArgument(subst->getArgumentPack());
  return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
}
}

llvm_unreachable("bad template name!")::llvm::llvm_unreachable_internal("bad template name!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5419);
5420}

5422bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) {
X = getCanonicalTemplateName(X);
Y = getCanonicalTemplateName(Y);
return X.getAsVoidPointer() == Y.getAsVoidPointer();
5426}

5428TemplateArgument
5429ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
switch (Arg.getKind()) {
  case TemplateArgument::Null:
    return Arg;

  case TemplateArgument::Expression:
    return Arg;

  case TemplateArgument::Declaration: {
    auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
    return TemplateArgument(D, Arg.getParamTypeForDecl());
  }

  case TemplateArgument::NullPtr:
    return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
                            /*isNullPtr*/true);

  case TemplateArgument::Template:
    return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));

  case TemplateArgument::TemplateExpansion:
    return TemplateArgument(getCanonicalTemplateName(
                                       Arg.getAsTemplateOrTemplatePattern()),
                            Arg.getNumTemplateExpansions());

  case TemplateArgument::Integral:
    return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));

  case TemplateArgument::Type:
    return TemplateArgument(getCanonicalType(Arg.getAsType()));

  case TemplateArgument::Pack: {
    if (Arg.pack_size() == 0)
      return Arg;

    auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
    unsigned Idx = 0;
    for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
                                      AEnd = Arg.pack_end();
         A != AEnd; (void)++A, ++Idx)
      CanonArgs[Idx] = getCanonicalTemplateArgument(*A);

    return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
  }
}

// Silence GCC warning
llvm_unreachable("Unhandled template argument kind")::llvm::llvm_unreachable_internal("Unhandled template argument kind"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5476);
5477}

5479NestedNameSpecifier *
5480ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
if (!NNS)
  return nullptr;

switch (NNS->getKind()) {
case NestedNameSpecifier::Identifier:
  // Canonicalize the prefix but keep the identifier the same.
  return NestedNameSpecifier::Create(*this,
                       getCanonicalNestedNameSpecifier(NNS->getPrefix()),
                                     NNS->getAsIdentifier());

case NestedNameSpecifier::Namespace:
  // A namespace is canonical; build a nested-name-specifier with
  // this namespace and no prefix.
  return NestedNameSpecifier::Create(*this, nullptr,
                               NNS->getAsNamespace()->getOriginalNamespace());

case NestedNameSpecifier::NamespaceAlias:
  // A namespace is canonical; build a nested-name-specifier with
  // this namespace and no prefix.
  return NestedNameSpecifier::Create(*this, nullptr,
                                  NNS->getAsNamespaceAlias()->getNamespace()
                                                    ->getOriginalNamespace());

case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
  QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));

  // If we have some kind of dependent-named type (e.g., "typename T::type"),
  // break it apart into its prefix and identifier, then reconsititute those
  // as the canonical nested-name-specifier. This is required to canonicalize
  // a dependent nested-name-specifier involving typedefs of dependent-name
  // types, e.g.,
  //   typedef typename T::type T1;
  //   typedef typename T1::type T2;
  if (const auto *DNT = T->getAs<DependentNameType>())
    return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
                         const_cast<IdentifierInfo *>(DNT->getIdentifier()));

  // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
  // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
  // first place?
  return NestedNameSpecifier::Create(*this, nullptr, false,
                                     const_cast<Type *>(T.getTypePtr()));
}

case NestedNameSpecifier::Global:
case NestedNameSpecifier::Super:
  // The global specifier and __super specifer are canonical and unique.
  return NNS;
}

llvm_unreachable("Invalid NestedNameSpecifier::Kind!")::llvm::llvm_unreachable_internal("Invalid NestedNameSpecifier::Kind!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5532);
5533}

5535const ArrayType *ASTContext::getAsArrayType(QualType T) const {
// Handle the non-qualified case efficiently.
if (!T.hasLocalQualifiers()) {
  // Handle the common positive case fast.
  if (const auto *AT = dyn_cast<ArrayType>(T))
    return AT;
}

// Handle the common negative case fast.
if (!isa<ArrayType>(T.getCanonicalType()))
  return nullptr;

// Apply any qualifiers from the array type to the element type.  This
// implements C99 6.7.3p8: "If the specification of an array type includes
// any type qualifiers, the element type is so qualified, not the array type."

// If we get here, we either have type qualifiers on the type, or we have
// sugar such as a typedef in the way.  If we have type qualifiers on the type
// we must propagate them down into the element type.

SplitQualType split = T.getSplitDesugaredType();
Qualifiers qs = split.Quals;

// If we have a simple case, just return now.
const auto *ATy = dyn_cast<ArrayType>(split.Ty);
if (!ATy || qs.empty())
  return ATy;

// Otherwise, we have an array and we have qualifiers on it.  Push the
// qualifiers into the array element type and return a new array type.
QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);

if (const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
  return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
                                              CAT->getSizeModifier(),
                                         CAT->getIndexTypeCVRQualifiers()));
if (const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
  return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
                                                IAT->getSizeModifier(),
                                         IAT->getIndexTypeCVRQualifiers()));

if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
  return cast<ArrayType>(
                   getDependentSizedArrayType(NewEltTy,
                                              DSAT->getSizeExpr(),
                                              DSAT->getSizeModifier(),
                                            DSAT->getIndexTypeCVRQualifiers(),
                                              DSAT->getBracketsRange()));

const auto *VAT = cast<VariableArrayType>(ATy);
return cast<ArrayType>(getVariableArrayType(NewEltTy,
                                            VAT->getSizeExpr(),
                                            VAT->getSizeModifier(),
                                            VAT->getIndexTypeCVRQualifiers(),
                                            VAT->getBracketsRange()));
5590}

5592QualType ASTContext::getAdjustedParameterType(QualType T) const {
if (T->isArrayType() || T->isFunctionType())
  return getDecayedType(T);
return T;
5596}

5598QualType ASTContext::getSignatureParameterType(QualType T) const {
T = getVariableArrayDecayedType(T);
T = getAdjustedParameterType(T);
return T.getUnqualifiedType();
5602}

5604QualType ASTContext::getExceptionObjectType(QualType T) const {
// C++ [except.throw]p3:
//   A throw-expression initializes a temporary object, called the exception
//   object, the type of which is determined by removing any top-level
//   cv-qualifiers from the static type of the operand of throw and adjusting
//   the type from "array of T" or "function returning T" to "pointer to T"
//   or "pointer to function returning T", [...]
T = getVariableArrayDecayedType(T);
if (T->isArrayType() || T->isFunctionType())
  T = getDecayedType(T);
return T.getUnqualifiedType();
5615}

5617/// getArrayDecayedType - Return the properly qualified result of decaying the
5618/// specified array type to a pointer.  This operation is non-trivial when
5619/// handling typedefs etc.  The canonical type of "T" must be an array type,
5620/// this returns a pointer to a properly qualified element of the array.
5621///
5622/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
5623QualType ASTContext::getArrayDecayedType(QualType Ty) const {
// Get the element type with 'getAsArrayType' so that we don't lose any
// typedefs in the element type of the array.  This also handles propagation
// of type qualifiers from the array type into the element type if present
// (C99 6.7.3p8).
const ArrayType *PrettyArrayType = getAsArrayType(Ty);
assert(PrettyArrayType && "Not an array type!")((PrettyArrayType && "Not an array type!") ? static_cast
<void> (0) : __assert_fail ("PrettyArrayType && \"Not an array type!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5629, __PRETTY_FUNCTION__));

QualType PtrTy = getPointerType(PrettyArrayType->getElementType());

// int x[restrict 4] ->  int *restrict
QualType Result = getQualifiedType(PtrTy,
                                   PrettyArrayType->getIndexTypeQualifiers());

// int x[_Nullable] -> int * _Nullable
if (auto Nullability = Ty->getNullability(*this)) {
  Result = const_cast<ASTContext *>(this)->getAttributedType(
      AttributedType::getNullabilityAttrKind(*Nullability), Result, Result);
}
return Result;
5643}

5645QualType ASTContext::getBaseElementType(const ArrayType *array) const {
return getBaseElementType(array->getElementType());
5647}

5649QualType ASTContext::getBaseElementType(QualType type) const {
Qualifiers qs;
while (true) {
  SplitQualType split = type.getSplitDesugaredType();
  const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
  if (!array) break;

  type = array->getElementType();
  qs.addConsistentQualifiers(split.Quals);
}

return getQualifiedType(type, qs);
5661}

5663/// getConstantArrayElementCount - Returns number of constant array elements.
5664uint64_t
5665ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA)  const {
uint64_t ElementCount = 1;
do {
  ElementCount *= CA->getSize().getZExtValue();
  CA = dyn_cast_or_null<ConstantArrayType>(
    CA->getElementType()->getAsArrayTypeUnsafe());
} while (CA);
return ElementCount;
5673}

5675/// getFloatingRank - Return a relative rank for floating point types.
5676/// This routine will assert if passed a built-in type that isn't a float.
5677static FloatingRank getFloatingRank(QualType T) {
if (const auto *CT = T->getAs<ComplexType>())
  return getFloatingRank(CT->getElementType());

assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type")((T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"
) ? static_cast<void> (0) : __assert_fail ("T->getAs<BuiltinType>() && \"getFloatingRank(): not a floating type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5681, __PRETTY_FUNCTION__));
switch (T->castAs<BuiltinType>()->getKind()) {
default: llvm_unreachable("getFloatingRank(): not a floating type")::llvm::llvm_unreachable_internal("getFloatingRank(): not a floating type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5683);
case BuiltinType::Float16:    return Float16Rank;
case BuiltinType::Half:       return HalfRank;
case BuiltinType::Float:      return FloatRank;
case BuiltinType::Double:     return DoubleRank;
case BuiltinType::LongDouble: return LongDoubleRank;
case BuiltinType::Float128:   return Float128Rank;
}
5691}

5693/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
5694/// point or a complex type (based on typeDomain/typeSize).
5695/// 'typeDomain' is a real floating point or complex type.
5696/// 'typeSize' is a real floating point or complex type.
5697QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
                                                     QualType Domain) const {
FloatingRank EltRank = getFloatingRank(Size);
if (Domain->isComplexType()) {
  switch (EltRank) {
  case Float16Rank:
  case HalfRank: llvm_unreachable("Complex half is not supported")::llvm::llvm_unreachable_internal("Complex half is not supported"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5703);
  case FloatRank:      return FloatComplexTy;
  case DoubleRank:     return DoubleComplexTy;
  case LongDoubleRank: return LongDoubleComplexTy;
  case Float128Rank:   return Float128ComplexTy;
  }
}

assert(Domain->isRealFloatingType() && "Unknown domain!")((Domain->isRealFloatingType() && "Unknown domain!"
) ? static_cast<void> (0) : __assert_fail ("Domain->isRealFloatingType() && \"Unknown domain!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5711, __PRETTY_FUNCTION__));
switch (EltRank) {
case Float16Rank:    return HalfTy;
case HalfRank:       return HalfTy;
case FloatRank:      return FloatTy;
case DoubleRank:     return DoubleTy;
case LongDoubleRank: return LongDoubleTy;
case Float128Rank:   return Float128Ty;
}
llvm_unreachable("getFloatingRank(): illegal value for rank")::llvm::llvm_unreachable_internal("getFloatingRank(): illegal value for rank"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5720);
5721}

5723/// getFloatingTypeOrder - Compare the rank of the two specified floating
5724/// point types, ignoring the domain of the type (i.e. 'double' ==
5725/// '_Complex double').  If LHS > RHS, return 1.  If LHS == RHS, return 0. If
5726/// LHS < RHS, return -1.
5727int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
FloatingRank LHSR = getFloatingRank(LHS);
FloatingRank RHSR = getFloatingRank(RHS);

if (LHSR == RHSR)
  return 0;
if (LHSR > RHSR)
  return 1;
return -1;
5736}

5738int ASTContext::getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const {
if (&getFloatTypeSemantics(LHS) == &getFloatTypeSemantics(RHS))
  return 0;
return getFloatingTypeOrder(LHS, RHS);
5742}

5744/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
5745/// routine will assert if passed a built-in type that isn't an integer or enum,
5746/// or if it is not canonicalized.
5747unsigned ASTContext::getIntegerRank(const Type *T) const {
assert(T->isCanonicalUnqualified() && "T should be canonicalized")((T->isCanonicalUnqualified() && "T should be canonicalized"
) ? static_cast<void> (0) : __assert_fail ("T->isCanonicalUnqualified() && \"T should be canonicalized\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5748, __PRETTY_FUNCTION__));

switch (cast<BuiltinType>(T)->getKind()) {
default: llvm_unreachable("getIntegerRank(): not a built-in integer")::llvm::llvm_unreachable_internal("getIntegerRank(): not a built-in integer"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5751);
case BuiltinType::Bool:
  return 1 + (getIntWidth(BoolTy) << 3);
case BuiltinType::Char_S:
case BuiltinType::Char_U:
case BuiltinType::SChar:
case BuiltinType::UChar:
  return 2 + (getIntWidth(CharTy) << 3);
case BuiltinType::Short:
case BuiltinType::UShort:
  return 3 + (getIntWidth(ShortTy) << 3);
case BuiltinType::Int:
case BuiltinType::UInt:
  return 4 + (getIntWidth(IntTy) << 3);
case BuiltinType::Long:
case BuiltinType::ULong:
  return 5 + (getIntWidth(LongTy) << 3);
case BuiltinType::LongLong:
case BuiltinType::ULongLong:
  return 6 + (getIntWidth(LongLongTy) << 3);
case BuiltinType::Int128:
case BuiltinType::UInt128:
  return 7 + (getIntWidth(Int128Ty) << 3);
}
5775}

5777/// Whether this is a promotable bitfield reference according
5778/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
5779///
5780/// \returns the type this bit-field will promote to, or NULL if no
5781/// promotion occurs.
5782QualType ASTContext::isPromotableBitField(Expr *E) const {
if (E->isTypeDependent() || E->isValueDependent())
  return {};

// C++ [conv.prom]p5:
//    If the bit-field has an enumerated type, it is treated as any other
//    value of that type for promotion purposes.
if (getLangOpts().CPlusPlus && E->getType()->isEnumeralType())
  return {};

// FIXME: We should not do this unless E->refersToBitField() is true. This
// matters in C where getSourceBitField() will find bit-fields for various
// cases where the source expression is not a bit-field designator.

FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields?
if (!Field)
  return {};

QualType FT = Field->getType();

uint64_t BitWidth = Field->getBitWidthValue(*this);
uint64_t IntSize = getTypeSize(IntTy);
// C++ [conv.prom]p5:
//   A prvalue for an integral bit-field can be converted to a prvalue of type
//   int if int can represent all the values of the bit-field; otherwise, it
//   can be converted to unsigned int if unsigned int can represent all the
//   values of the bit-field. If the bit-field is larger yet, no integral
//   promotion applies to it.
// C11 6.3.1.1/2:
//   [For a bit-field of type _Bool, int, signed int, or unsigned int:]
//   If an int can represent all values of the original type (as restricted by
//   the width, for a bit-field), the value is converted to an int; otherwise,
//   it is converted to an unsigned int.
//
// FIXME: C does not permit promotion of a 'long : 3' bitfield to int.
//        We perform that promotion here to match GCC and C++.
// FIXME: C does not permit promotion of an enum bit-field whose rank is
//        greater than that of 'int'. We perform that promotion to match GCC.
if (BitWidth < IntSize)
  return IntTy;

if (BitWidth == IntSize)
  return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;

// Bit-fields wider than int are not subject to promotions, and therefore act
// like the base type. GCC has some weird bugs in this area that we
// deliberately do not follow (GCC follows a pre-standard resolution to
// C's DR315 which treats bit-width as being part of the type, and this leaks
// into their semantics in some cases).
return {};
5832}

5834/// getPromotedIntegerType - Returns the type that Promotable will
5835/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
5836/// integer type.
5837QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
assert(!Promotable.isNull())((!Promotable.isNull()) ? static_cast<void> (0) : __assert_fail
 ("!Promotable.isNull()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5838, __PRETTY_FUNCTION__));
assert(Promotable->isPromotableIntegerType())((Promotable->isPromotableIntegerType()) ? static_cast<
void> (0) : __assert_fail ("Promotable->isPromotableIntegerType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5839, __PRETTY_FUNCTION__));
if (const auto *ET = Promotable->getAs<EnumType>())
  return ET->getDecl()->getPromotionType();

if (const auto *BT = Promotable->getAs<BuiltinType>()) {
  // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
  // (3.9.1) can be converted to a prvalue of the first of the following
  // types that can represent all the values of its underlying type:
  // int, unsigned int, long int, unsigned long int, long long int, or
  // unsigned long long int [...]
  // FIXME: Is there some better way to compute this?
  if (BT->getKind() == BuiltinType::WChar_S ||
      BT->getKind() == BuiltinType::WChar_U ||
      BT->getKind() == BuiltinType::Char8 ||
      BT->getKind() == BuiltinType::Char16 ||
      BT->getKind() == BuiltinType::Char32) {
    bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
    uint64_t FromSize = getTypeSize(BT);
    QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
                                LongLongTy, UnsignedLongLongTy };
    for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
      uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
      if (FromSize < ToSize ||
          (FromSize == ToSize &&
           FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType()))
        return PromoteTypes[Idx];
    }
    llvm_unreachable("char type should fit into long long")::llvm::llvm_unreachable_internal("char type should fit into long long"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5866);
  }
}

// At this point, we should have a signed or unsigned integer type.
if (Promotable->isSignedIntegerType())
  return IntTy;
uint64_t PromotableSize = getIntWidth(Promotable);
uint64_t IntSize = getIntWidth(IntTy);
assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize)((Promotable->isUnsignedIntegerType() && PromotableSize
 <= IntSize) ? static_cast<void> (0) : __assert_fail
 ("Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5875, __PRETTY_FUNCTION__));
return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
5877}

5879/// Recurses in pointer/array types until it finds an objc retainable
5880/// type and returns its ownership.
5881Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const {
while (!T.isNull()) {
  if (T.getObjCLifetime() != Qualifiers::OCL_None)
    return T.getObjCLifetime();
  if (T->isArrayType())
    T = getBaseElementType(T);
  else if (const auto *PT = T->getAs<PointerType>())
    T = PT->getPointeeType();
  else if (const auto *RT = T->getAs<ReferenceType>())
    T = RT->getPointeeType();
  else
    break;
}

return Qualifiers::OCL_None;
5896}

5898static const Type *getIntegerTypeForEnum(const EnumType *ET) {
// Incomplete enum types are not treated as integer types.
// FIXME: In C++, enum types are never integer types.
if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
  return ET->getDecl()->getIntegerType().getTypePtr();
return nullptr;
5904}

5906/// getIntegerTypeOrder - Returns the highest ranked integer type:
5907/// C99 6.3.1.8p1.  If LHS > RHS, return 1.  If LHS == RHS, return 0. If
5908/// LHS < RHS, return -1.
5909int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const {
const Type *LHSC = getCanonicalType(LHS).getTypePtr();
const Type *RHSC = getCanonicalType(RHS).getTypePtr();

// Unwrap enums to their underlying type.
if (const auto *ET = dyn_cast<EnumType>(LHSC))
  LHSC = getIntegerTypeForEnum(ET);
if (const auto *ET = dyn_cast<EnumType>(RHSC))
  RHSC = getIntegerTypeForEnum(ET);

if (LHSC == RHSC) return 0;

bool LHSUnsigned = LHSC->isUnsignedIntegerType();
bool RHSUnsigned = RHSC->isUnsignedIntegerType();

unsigned LHSRank = getIntegerRank(LHSC);
unsigned RHSRank = getIntegerRank(RHSC);

if (LHSUnsigned == RHSUnsigned) {  // Both signed or both unsigned.
  if (LHSRank == RHSRank) return 0;
  return LHSRank > RHSRank ? 1 : -1;
}

// Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
if (LHSUnsigned) {
  // If the unsigned [LHS] type is larger, return it.
  if (LHSRank >= RHSRank)
    return 1;

  // If the signed type can represent all values of the unsigned type, it
  // wins.  Because we are dealing with 2's complement and types that are
  // powers of two larger than each other, this is always safe.
  return -1;
}

// If the unsigned [RHS] type is larger, return it.
if (RHSRank >= LHSRank)
  return -1;

// If the signed type can represent all values of the unsigned type, it
// wins.  Because we are dealing with 2's complement and types that are
// powers of two larger than each other, this is always safe.
return 1;
5952}

5954TypedefDecl *ASTContext::getCFConstantStringDecl() const {
if (CFConstantStringTypeDecl)
  return CFConstantStringTypeDecl;

assert(!CFConstantStringTagDecl &&((!CFConstantStringTagDecl && "tag and typedef should be initialized together"
) ? static_cast<void> (0) : __assert_fail ("!CFConstantStringTagDecl && \"tag and typedef should be initialized together\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5959, __PRETTY_FUNCTION__))
       "tag and typedef should be initialized together")((!CFConstantStringTagDecl && "tag and typedef should be initialized together"
) ? static_cast<void> (0) : __assert_fail ("!CFConstantStringTagDecl && \"tag and typedef should be initialized together\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 5959, __PRETTY_FUNCTION__));
CFConstantStringTagDecl = buildImplicitRecord("__NSConstantString_tag");
CFConstantStringTagDecl->startDefinition();

struct {
  QualType Type;
  const char *Name;
} Fields[5];
unsigned Count = 0;

/// Objective-C ABI
///
///    typedef struct __NSConstantString_tag {
///      const int *isa;
///      int flags;
///      const char *str;
///      long length;
///    } __NSConstantString;
///
/// Swift ABI (4.1, 4.2)
///
///    typedef struct __NSConstantString_tag {
///      uintptr_t _cfisa;
///      uintptr_t _swift_rc;
///      _Atomic(uint64_t) _cfinfoa;
///      const char *_ptr;
///      uint32_t _length;
///    } __NSConstantString;
///
/// Swift ABI (5.0)
///
///    typedef struct __NSConstantString_tag {
///      uintptr_t _cfisa;
///      uintptr_t _swift_rc;
///      _Atomic(uint64_t) _cfinfoa;
///      const char *_ptr;
///      uintptr_t _length;
///    } __NSConstantString;

const auto CFRuntime = getLangOpts().CFRuntime;
if (static_cast<unsigned>(CFRuntime) <
    static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift)) {
  Fields[Count++] = { getPointerType(IntTy.withConst()), "isa" };
  Fields[Count++] = { IntTy, "flags" };
  Fields[Count++] = { getPointerType(CharTy.withConst()), "str" };
  Fields[Count++] = { LongTy, "length" };
} else {
  Fields[Count++] = { getUIntPtrType(), "_cfisa" };
  Fields[Count++] = { getUIntPtrType(), "_swift_rc" };
  Fields[Count++] = { getFromTargetType(Target->getUInt64Type()), "_swift_rc" };
  Fields[Count++] = { getPointerType(CharTy.withConst()), "_ptr" };
  if (CFRuntime == LangOptions::CoreFoundationABI::Swift4_1 ||
      CFRuntime == LangOptions::CoreFoundationABI::Swift4_2)
    Fields[Count++] = { IntTy, "_ptr" };
  else
    Fields[Count++] = { getUIntPtrType(), "_ptr" };
}

// Create fields
for (unsigned i = 0; i < Count; ++i) {
  FieldDecl *Field =
      FieldDecl::Create(*this, CFConstantStringTagDecl, SourceLocation(),
                        SourceLocation(), &Idents.get(Fields[i].Name),
                        Fields[i].Type, /*TInfo=*/nullptr,
                        /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
  Field->setAccess(AS_public);
  CFConstantStringTagDecl->addDecl(Field);
}

CFConstantStringTagDecl->completeDefinition();
// This type is designed to be compatible with NSConstantString, but cannot
// use the same name, since NSConstantString is an interface.
auto tagType = getTagDeclType(CFConstantStringTagDecl);
CFConstantStringTypeDecl =
    buildImplicitTypedef(tagType, "__NSConstantString");

return CFConstantStringTypeDecl;
6036}

6038RecordDecl *ASTContext::getCFConstantStringTagDecl() const {
if (!CFConstantStringTagDecl)
  getCFConstantStringDecl(); // Build the tag and the typedef.
return CFConstantStringTagDecl;
6042}

6044// getCFConstantStringType - Return the type used for constant CFStrings.
6045QualType ASTContext::getCFConstantStringType() const {
return getTypedefType(getCFConstantStringDecl());
6047}

6049QualType ASTContext::getObjCSuperType() const {
if (ObjCSuperType.isNull()) {
  RecordDecl *ObjCSuperTypeDecl = buildImplicitRecord("objc_super");
  TUDecl->addDecl(ObjCSuperTypeDecl);
  ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
}
return ObjCSuperType;
6056}

6058void ASTContext::setCFConstantStringType(QualType T) {
const auto *TD = T->getAs<TypedefType>();
assert(TD && "Invalid CFConstantStringType")((TD && "Invalid CFConstantStringType") ? static_cast
<void> (0) : __assert_fail ("TD && \"Invalid CFConstantStringType\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6060, __PRETTY_FUNCTION__));
CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
const auto *TagType =
    CFConstantStringTypeDecl->getUnderlyingType()->getAs<RecordType>();
assert(TagType && "Invalid CFConstantStringType")((TagType && "Invalid CFConstantStringType") ? static_cast
<void> (0) : __assert_fail ("TagType && \"Invalid CFConstantStringType\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6064, __PRETTY_FUNCTION__));
CFConstantStringTagDecl = TagType->getDecl();
6066}

6068QualType ASTContext::getBlockDescriptorType() const {
if (BlockDescriptorType)
  return getTagDeclType(BlockDescriptorType);

RecordDecl *RD;
// FIXME: Needs the FlagAppleBlock bit.
RD = buildImplicitRecord("__block_descriptor");
RD->startDefinition();

QualType FieldTypes[] = {
  UnsignedLongTy,
  UnsignedLongTy,
};

static const char *const FieldNames[] = {
  "reserved",
  "Size"
};

for (size_t i = 0; i < 2; ++i) {
  FieldDecl *Field = FieldDecl::Create(
      *this, RD, SourceLocation(), SourceLocation(),
      &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
      /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
  Field->setAccess(AS_public);
  RD->addDecl(Field);
}

RD->completeDefinition();

BlockDescriptorType = RD;

return getTagDeclType(BlockDescriptorType);
6101}

6103QualType ASTContext::getBlockDescriptorExtendedType() const {
if (BlockDescriptorExtendedType)
  return getTagDeclType(BlockDescriptorExtendedType);

RecordDecl *RD;
// FIXME: Needs the FlagAppleBlock bit.
RD = buildImplicitRecord("__block_descriptor_withcopydispose");
RD->startDefinition();

QualType FieldTypes[] = {
  UnsignedLongTy,
  UnsignedLongTy,
  getPointerType(VoidPtrTy),
  getPointerType(VoidPtrTy)
};

static const char *const FieldNames[] = {
  "reserved",
  "Size",
  "CopyFuncPtr",
  "DestroyFuncPtr"
};

for (size_t i = 0; i < 4; ++i) {
  FieldDecl *Field = FieldDecl::Create(
      *this, RD, SourceLocation(), SourceLocation(),
      &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
      /*BitWidth=*/nullptr,
      /*Mutable=*/false, ICIS_NoInit);
  Field->setAccess(AS_public);
  RD->addDecl(Field);
}

RD->completeDefinition();

BlockDescriptorExtendedType = RD;
return getTagDeclType(BlockDescriptorExtendedType);
6140}

6142TargetInfo::OpenCLTypeKind ASTContext::getOpenCLTypeKind(const Type *T) const {
const auto *BT = dyn_cast<BuiltinType>(T);

if (!BT) {
  if (isa<PipeType>(T))
    return TargetInfo::OCLTK_Pipe;

  return TargetInfo::OCLTK_Default;
}

switch (BT->getKind()) {
6153#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
case BuiltinType::Id:                                                        \
  return TargetInfo::OCLTK_Image;
6156#include "clang/Basic/OpenCLImageTypes.def"

case BuiltinType::OCLClkEvent:
  return TargetInfo::OCLTK_ClkEvent;

case BuiltinType::OCLEvent:
  return TargetInfo::OCLTK_Event;

case BuiltinType::OCLQueue:
  return TargetInfo::OCLTK_Queue;

case BuiltinType::OCLReserveID:
  return TargetInfo::OCLTK_ReserveID;

case BuiltinType::OCLSampler:
  return TargetInfo::OCLTK_Sampler;

default:
  return TargetInfo::OCLTK_Default;
}
6176}

6178LangAS ASTContext::getOpenCLTypeAddrSpace(const Type *T) const {
return Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T));
6180}

6182/// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty"
6183/// requires copy/dispose. Note that this must match the logic
6184/// in buildByrefHelpers.
6185bool ASTContext::BlockRequiresCopying(QualType Ty,
                                    const VarDecl *D) {
if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) {
  const Expr *copyExpr = getBlockVarCopyInit(D).getCopyExpr();
  if (!copyExpr && record->hasTrivialDestructor()) return false;

  return true;
}

// The block needs copy/destroy helpers if Ty is non-trivial to destructively
// move or destroy.
if (Ty.isNonTrivialToPrimitiveDestructiveMove() || Ty.isDestructedType())
  return true;

if (!Ty->isObjCRetainableType()) return false;

Qualifiers qs = Ty.getQualifiers();

// If we have lifetime, that dominates.
if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
  switch (lifetime) {
    case Qualifiers::OCL_None: llvm_unreachable("impossible")::llvm::llvm_unreachable_internal("impossible", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6206);

    // These are just bits as far as the runtime is concerned.
    case Qualifiers::OCL_ExplicitNone:
    case Qualifiers::OCL_Autoreleasing:
      return false;

    // These cases should have been taken care of when checking the type's
    // non-triviality.
    case Qualifiers::OCL_Weak:
    case Qualifiers::OCL_Strong:
      llvm_unreachable("impossible")::llvm::llvm_unreachable_internal("impossible", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6217);
  }
  llvm_unreachable("fell out of lifetime switch!")::llvm::llvm_unreachable_internal("fell out of lifetime switch!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6219);
}
return (Ty->isBlockPointerType() || isObjCNSObjectType(Ty) ||
        Ty->isObjCObjectPointerType());
6223}

6225bool ASTContext::getByrefLifetime(QualType Ty,
                            Qualifiers::ObjCLifetime &LifeTime,
                            bool &HasByrefExtendedLayout) const {
if (!getLangOpts().ObjC ||
    getLangOpts().getGC() != LangOptions::NonGC)
  return false;

HasByrefExtendedLayout = false;
if (Ty->isRecordType()) {
  HasByrefExtendedLayout = true;
  LifeTime = Qualifiers::OCL_None;
} else if ((LifeTime = Ty.getObjCLifetime())) {
  // Honor the ARC qualifiers.
} else if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) {
  // The MRR rule.
  LifeTime = Qualifiers::OCL_ExplicitNone;
} else {
  LifeTime = Qualifiers::OCL_None;
}
return true;
6245}

6247TypedefDecl *ASTContext::getObjCInstanceTypeDecl() {
if (!ObjCInstanceTypeDecl)
  ObjCInstanceTypeDecl =
      buildImplicitTypedef(getObjCIdType(), "instancetype");
return ObjCInstanceTypeDecl;
6252}

6254// This returns true if a type has been typedefed to BOOL:
6255// typedef <type> BOOL;
6256static bool isTypeTypedefedAsBOOL(QualType T) {
if (const auto *TT = dyn_cast<TypedefType>(T))
  if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
    return II->isStr("BOOL");

return false;
6262}

6264/// getObjCEncodingTypeSize returns size of type for objective-c encoding
6265/// purpose.
6266CharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const {
if (!type->isIncompleteArrayType() && type->isIncompleteType())
  return CharUnits::Zero();

CharUnits sz = getTypeSizeInChars(type);

// Make all integer and enum types at least as large as an int
if (sz.isPositive() && type->isIntegralOrEnumerationType())
  sz = std::max(sz, getTypeSizeInChars(IntTy));
// Treat arrays as pointers, since that's how they're passed in.
else if (type->isArrayType())
  sz = getTypeSizeInChars(VoidPtrTy);
return sz;
6279}

6281bool ASTContext::isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const {
return getTargetInfo().getCXXABI().isMicrosoft() &&
       VD->isStaticDataMember() &&
       VD->getType()->isIntegralOrEnumerationType() &&
       !VD->getFirstDecl()->isOutOfLine() && VD->getFirstDecl()->hasInit();
6286}

6288ASTContext::InlineVariableDefinitionKind
6289ASTContext::getInlineVariableDefinitionKind(const VarDecl *VD) const {
if (!VD->isInline())
  return InlineVariableDefinitionKind::None;

// In almost all cases, it's a weak definition.
auto *First = VD->getFirstDecl();
if (First->isInlineSpecified() || !First->isStaticDataMember())
  return InlineVariableDefinitionKind::Weak;

// If there's a file-context declaration in this translation unit, it's a
// non-discardable definition.
for (auto *D : VD->redecls())
  if (D->getLexicalDeclContext()->isFileContext() &&
      !D->isInlineSpecified() && (D->isConstexpr() || First->isConstexpr()))
    return InlineVariableDefinitionKind::Strong;

// If we've not seen one yet, we don't know.
return InlineVariableDefinitionKind::WeakUnknown;
6307}

6309static std::string charUnitsToString(const CharUnits &CU) {
return llvm::itostr(CU.getQuantity());
6311}

6313/// getObjCEncodingForBlock - Return the encoded type for this block
6314/// declaration.
6315std::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const {
std::string S;

const BlockDecl *Decl = Expr->getBlockDecl();
QualType BlockTy =
    Expr->getType()->castAs<BlockPointerType>()->getPointeeType();
QualType BlockReturnTy = BlockTy->castAs<FunctionType>()->getReturnType();
// Encode result type.
if (getLangOpts().EncodeExtendedBlockSig)
  getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, BlockReturnTy, S,
                                    true /*Extended*/);
else
  getObjCEncodingForType(BlockReturnTy, S);
// Compute size of all parameters.
// Start with computing size of a pointer in number of bytes.
// FIXME: There might(should) be a better way of doing this computation!
CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
CharUnits ParmOffset = PtrSize;
for (auto PI : Decl->parameters()) {
  QualType PType = PI->getType();
  CharUnits sz = getObjCEncodingTypeSize(PType);
  if (sz.isZero())
    continue;
  assert(sz.isPositive() && "BlockExpr - Incomplete param type")((sz.isPositive() && "BlockExpr - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"BlockExpr - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6338, __PRETTY_FUNCTION__));
  ParmOffset += sz;
}
// Size of the argument frame
S += charUnitsToString(ParmOffset);
// Block pointer and offset.
S += "@?0";

// Argument types.
ParmOffset = PtrSize;
for (auto PVDecl : Decl->parameters()) {
  QualType PType = PVDecl->getOriginalType();
  if (const auto *AT =
          dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
    // Use array's original type only if it has known number of
    // elements.
    if (!isa<ConstantArrayType>(AT))
      PType = PVDecl->getType();
  } else if (PType->isFunctionType())
    PType = PVDecl->getType();
  if (getLangOpts().EncodeExtendedBlockSig)
    getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, PType,
                                    S, true /*Extended*/);
  else
    getObjCEncodingForType(PType, S);
  S += charUnitsToString(ParmOffset);
  ParmOffset += getObjCEncodingTypeSize(PType);
}

return S;
6368}

6370std::string
6371ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const {
std::string S;
// Encode result type.
getObjCEncodingForType(Decl->getReturnType(), S);
CharUnits ParmOffset;
// Compute size of all parameters.
for (auto PI : Decl->parameters()) {
  QualType PType = PI->getType();
  CharUnits sz = getObjCEncodingTypeSize(PType);
  if (sz.isZero())
    continue;

  assert(sz.isPositive() &&((sz.isPositive() && "getObjCEncodingForFunctionDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForFunctionDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6384, __PRETTY_FUNCTION__))
         "getObjCEncodingForFunctionDecl - Incomplete param type")((sz.isPositive() && "getObjCEncodingForFunctionDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForFunctionDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6384, __PRETTY_FUNCTION__));
  ParmOffset += sz;
}
S += charUnitsToString(ParmOffset);
ParmOffset = CharUnits::Zero();

// Argument types.
for (auto PVDecl : Decl->parameters()) {
  QualType PType = PVDecl->getOriginalType();
  if (const auto *AT =
          dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
    // Use array's original type only if it has known number of
    // elements.
    if (!isa<ConstantArrayType>(AT))
      PType = PVDecl->getType();
  } else if (PType->isFunctionType())
    PType = PVDecl->getType();
  getObjCEncodingForType(PType, S);
  S += charUnitsToString(ParmOffset);
  ParmOffset += getObjCEncodingTypeSize(PType);
}

return S;
6407}

6409/// getObjCEncodingForMethodParameter - Return the encoded type for a single
6410/// method parameter or return type. If Extended, include class names and
6411/// block object types.
6412void ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT,
                                                 QualType T, std::string& S,
                                                 bool Extended) const {
// Encode type qualifer, 'in', 'inout', etc. for the parameter.
getObjCEncodingForTypeQualifier(QT, S);
// Encode parameter type.
ObjCEncOptions Options = ObjCEncOptions()
                             .setExpandPointedToStructures()
                             .setExpandStructures()
                             .setIsOutermostType();
if (Extended)
  Options.setEncodeBlockParameters().setEncodeClassNames();
getObjCEncodingForTypeImpl(T, S, Options, /*Field=*/nullptr);
6425}

6427/// getObjCEncodingForMethodDecl - Return the encoded type for this method
6428/// declaration.
6429std::string ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
                                                   bool Extended) const {
// FIXME: This is not very efficient.
// Encode return type.
std::string S;
getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(),
                                  Decl->getReturnType(), S, Extended);
// Compute size of all parameters.
// Start with computing size of a pointer in number of bytes.
// FIXME: There might(should) be a better way of doing this computation!
CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
// The first two arguments (self and _cmd) are pointers; account for
// their size.
CharUnits ParmOffset = 2 * PtrSize;
for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
     E = Decl->sel_param_end(); PI != E; ++PI) {
  QualType PType = (*PI)->getType();
  CharUnits sz = getObjCEncodingTypeSize(PType);
  if (sz.isZero())
    continue;

  assert(sz.isPositive() &&((sz.isPositive() && "getObjCEncodingForMethodDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForMethodDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6451, __PRETTY_FUNCTION__))
         "getObjCEncodingForMethodDecl - Incomplete param type")((sz.isPositive() && "getObjCEncodingForMethodDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForMethodDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6451, __PRETTY_FUNCTION__));
  ParmOffset += sz;
}
S += charUnitsToString(ParmOffset);
S += "@0:";
S += charUnitsToString(PtrSize);

// Argument types.
ParmOffset = 2 * PtrSize;
for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
     E = Decl->sel_param_end(); PI != E; ++PI) {
  const ParmVarDecl *PVDecl = *PI;
  QualType PType = PVDecl->getOriginalType();
  if (const auto *AT =
          dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
    // Use array's original type only if it has known number of
    // elements.
    if (!isa<ConstantArrayType>(AT))
      PType = PVDecl->getType();
  } else if (PType->isFunctionType())
    PType = PVDecl->getType();
  getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(),
                                    PType, S, Extended);
  S += charUnitsToString(ParmOffset);
  ParmOffset += getObjCEncodingTypeSize(PType);
}

return S;
6479}

6481ObjCPropertyImplDecl *
6482ASTContext::getObjCPropertyImplDeclForPropertyDecl(
                                    const ObjCPropertyDecl *PD,
                                    const Decl *Container) const {
if (!Container)
  return nullptr;
if (const auto *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
  for (auto *PID : CID->property_impls())
    if (PID->getPropertyDecl() == PD)
      return PID;
} else {
  const auto *OID = cast<ObjCImplementationDecl>(Container);
  for (auto *PID : OID->property_impls())
    if (PID->getPropertyDecl() == PD)
      return PID;
}
return nullptr;
6498}

6500/// getObjCEncodingForPropertyDecl - Return the encoded type for this
6501/// property declaration. If non-NULL, Container must be either an
6502/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
6503/// NULL when getting encodings for protocol properties.
6504/// Property attributes are stored as a comma-delimited C string. The simple
6505/// attributes readonly and bycopy are encoded as single characters. The
6506/// parametrized attributes, getter=name, setter=name, and ivar=name, are
6507/// encoded as single characters, followed by an identifier. Property types
6508/// are also encoded as a parametrized attribute. The characters used to encode
6509/// these attributes are defined by the following enumeration:
6510/// @code
6511/// enum PropertyAttributes {
6512/// kPropertyReadOnly = 'R',   // property is read-only.
6513/// kPropertyBycopy = 'C',     // property is a copy of the value last assigned
6514/// kPropertyByref = '&',  // property is a reference to the value last assigned
6515/// kPropertyDynamic = 'D',    // property is dynamic
6516/// kPropertyGetter = 'G',     // followed by getter selector name
6517/// kPropertySetter = 'S',     // followed by setter selector name
6518/// kPropertyInstanceVariable = 'V'  // followed by instance variable  name
6519/// kPropertyType = 'T'              // followed by old-style type encoding.
6520/// kPropertyWeak = 'W'              // 'weak' property
6521/// kPropertyStrong = 'P'            // property GC'able
6522/// kPropertyNonAtomic = 'N'         // property non-atomic
6523/// };
6524/// @endcode
6525std::string
6526ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
                                         const Decl *Container) const {
// Collect information from the property implementation decl(s).
bool Dynamic = false;
ObjCPropertyImplDecl *SynthesizePID = nullptr;

if (ObjCPropertyImplDecl *PropertyImpDecl =
    getObjCPropertyImplDeclForPropertyDecl(PD, Container)) {
  if (PropertyImpDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
    Dynamic = true;
  else
    SynthesizePID = PropertyImpDecl;
}

// FIXME: This is not very efficient.
std::string S = "T";

// Encode result type.
// GCC has some special rules regarding encoding of properties which
// closely resembles encoding of ivars.
getObjCEncodingForPropertyType(PD->getType(), S);

if (PD->isReadOnly()) {
  S += ",R";
  if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy)
    S += ",C";
  if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain)
    S += ",&";
  if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
    S += ",W";
} else {
  switch (PD->getSetterKind()) {
  case ObjCPropertyDecl::Assign: break;
  case ObjCPropertyDecl::Copy:   S += ",C"; break;
  case ObjCPropertyDecl::Retain: S += ",&"; break;
  case ObjCPropertyDecl::Weak:   S += ",W"; break;
  }
}

// It really isn't clear at all what this means, since properties
// are "dynamic by default".
if (Dynamic)
  S += ",D";

if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
  S += ",N";

if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
  S += ",G";
  S += PD->getGetterName().getAsString();
}

if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
  S += ",S";
  S += PD->getSetterName().getAsString();
}

if (SynthesizePID) {
  const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
  S += ",V";
  S += OID->getNameAsString();
}

// FIXME: OBJCGC: weak & strong
return S;
6591}

6593/// getLegacyIntegralTypeEncoding -
6594/// Another legacy compatibility encoding: 32-bit longs are encoded as
6595/// 'l' or 'L' , but not always.  For typedefs, we need to use
6596/// 'i' or 'I' instead if encoding a struct field, or a pointer!
6597void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
if (isa<TypedefType>(PointeeTy.getTypePtr())) {
  if (const auto *BT = PointeeTy->getAs<BuiltinType>()) {
    if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32)
      PointeeTy = UnsignedIntTy;
    else
      if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32)
        PointeeTy = IntTy;
  }
}
6607}

6609void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
                                      const FieldDecl *Field,
                                      QualType *NotEncodedT) const {
// We follow the behavior of gcc, expanding structures which are
// directly pointed to, and expanding embedded structures. Note that
// these rules are sufficient to prevent recursive encoding of the
// same type.
getObjCEncodingForTypeImpl(T, S,
                           ObjCEncOptions()
                               .setExpandPointedToStructures()
                               .setExpandStructures()
                               .setIsOutermostType(),
                           Field, NotEncodedT);
6622}

6624void ASTContext::getObjCEncodingForPropertyType(QualType T,
                                              std::string& S) const {
// Encode result type.
// GCC has some special rules regarding encoding of properties which
// closely resembles encoding of ivars.
getObjCEncodingForTypeImpl(T, S,
                           ObjCEncOptions()
                               .setExpandPointedToStructures()
                               .setExpandStructures()
                               .setIsOutermostType()
                               .setEncodingProperty(),
                           /*Field=*/nullptr);
6636}

6638static char getObjCEncodingForPrimitiveType(const ASTContext *C,
                                          const BuiltinType *BT) {
  BuiltinType::Kind kind = BT->getKind();
  switch (kind) {
  case BuiltinType::Void:       return 'v';
  case BuiltinType::Bool:       return 'B';
  case BuiltinType::Char8:
  case BuiltinType::Char_U:
  case BuiltinType::UChar:      return 'C';
  case BuiltinType::Char16:
  case BuiltinType::UShort:     return 'S';
  case BuiltinType::Char32:
  case BuiltinType::UInt:       return 'I';
  case BuiltinType::ULong:
      return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q';
  case BuiltinType::UInt128:    return 'T';
  case BuiltinType::ULongLong:  return 'Q';
  case BuiltinType::Char_S:
  case BuiltinType::SChar:      return 'c';
  case BuiltinType::Short:      return 's';
  case BuiltinType::WChar_S:
  case BuiltinType::WChar_U:
  case BuiltinType::Int:        return 'i';
  case BuiltinType::Long:
    return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
  case BuiltinType::LongLong:   return 'q';
  case BuiltinType::Int128:     return 't';
  case BuiltinType::Float:      return 'f';
  case BuiltinType::Double:     return 'd';
  case BuiltinType::LongDouble: return 'D';
  case BuiltinType::NullPtr:    return '*'; // like char*

  case BuiltinType::Float16:
  case BuiltinType::Float128:
  case BuiltinType::Half:
  case BuiltinType::ShortAccum:
  case BuiltinType::Accum:
  case BuiltinType::LongAccum:
  case BuiltinType::UShortAccum:
  case BuiltinType::UAccum:
  case BuiltinType::ULongAccum:
  case BuiltinType::ShortFract:
  case BuiltinType::Fract:
  case BuiltinType::LongFract:
  case BuiltinType::UShortFract:
  case BuiltinType::UFract:
  case BuiltinType::ULongFract:
  case BuiltinType::SatShortAccum:
  case BuiltinType::SatAccum:
  case BuiltinType::SatLongAccum:
  case BuiltinType::SatUShortAccum:
  case BuiltinType::SatUAccum:
  case BuiltinType::SatULongAccum:
  case BuiltinType::SatShortFract:
  case BuiltinType::SatFract:
  case BuiltinType::SatLongFract:
  case BuiltinType::SatUShortFract:
  case BuiltinType::SatUFract:
  case BuiltinType::SatULongFract:
    // FIXME: potentially need @encodes for these!
    return ' ';

6700#define SVE_TYPE(Name, Id, SingletonId) \
  case BuiltinType::Id:
6702#include "clang/Basic/AArch64SVEACLETypes.def"
  {
    DiagnosticsEngine &Diags = C->getDiagnostics();
    unsigned DiagID = Diags.getCustomDiagID(
        DiagnosticsEngine::Error, "cannot yet @encode type %0");
    Diags.Report(DiagID) << BT->getName(C->getPrintingPolicy());
    return ' ';
  }

  case BuiltinType::ObjCId:
  case BuiltinType::ObjCClass:
  case BuiltinType::ObjCSel:
    llvm_unreachable("@encoding ObjC primitive type")::llvm::llvm_unreachable_internal("@encoding ObjC primitive type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6714);

  // OpenCL and placeholder types don't need @encodings.
6717#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
  case BuiltinType::Id:
6719#include "clang/Basic/OpenCLImageTypes.def"
6720#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
  case BuiltinType::Id:
6722#include "clang/Basic/OpenCLExtensionTypes.def"
  case BuiltinType::OCLEvent:
  case BuiltinType::OCLClkEvent:
  case BuiltinType::OCLQueue:
  case BuiltinType::OCLReserveID:
  case BuiltinType::OCLSampler:
  case BuiltinType::Dependent:
6729#define BUILTIN_TYPE(KIND, ID)
6730#define PLACEHOLDER_TYPE(KIND, ID) \
  case BuiltinType::KIND:
6732#include "clang/AST/BuiltinTypes.def"
    llvm_unreachable("invalid builtin type for @encode")::llvm::llvm_unreachable_internal("invalid builtin type for @encode"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6733);
  }
  llvm_unreachable("invalid BuiltinType::Kind value")::llvm::llvm_unreachable_internal("invalid BuiltinType::Kind value"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6735);
6736}

6738static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) {
EnumDecl *Enum = ET->getDecl();

// The encoding of an non-fixed enum type is always 'i', regardless of size.
if (!Enum->isFixed())
  return 'i';

// The encoding of a fixed enum type matches its fixed underlying type.
const auto *BT = Enum->getIntegerType()->castAs<BuiltinType>();
return getObjCEncodingForPrimitiveType(C, BT);
6748}

6750static void EncodeBitField(const ASTContext *Ctx, std::string& S,
                         QualType T, const FieldDecl *FD) {
assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl")((FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"
) ? static_cast<void> (0) : __assert_fail ("FD->isBitField() && \"not a bitfield - getObjCEncodingForTypeImpl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6752, __PRETTY_FUNCTION__));
S += 'b';
// The NeXT runtime encodes bit fields as b followed by the number of bits.
// The GNU runtime requires more information; bitfields are encoded as b,
// then the offset (in bits) of the first element, then the type of the
// bitfield, then the size in bits.  For example, in this structure:
//
// struct
// {
//    int integer;
//    int flags:2;
// };
// On a 32-bit system, the encoding for flags would be b2 for the NeXT
// runtime, but b32i2 for the GNU runtime.  The reason for this extra
// information is not especially sensible, but we're stuck with it for
// compatibility with GCC, although providing it breaks anything that
// actually uses runtime introspection and wants to work on both runtimes...
if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) {
  uint64_t Offset;

  if (const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
    Offset = Ctx->lookupFieldBitOffset(IVD->getContainingInterface(), nullptr,
                                       IVD);
  } else {
    const RecordDecl *RD = FD->getParent();
    const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD);
    Offset = RL.getFieldOffset(FD->getFieldIndex());
  }

  S += llvm::utostr(Offset);

  if (const auto *ET = T->getAs<EnumType>())
    S += ObjCEncodingForEnumType(Ctx, ET);
  else {
    const auto *BT = T->castAs<BuiltinType>();
    S += getObjCEncodingForPrimitiveType(Ctx, BT);
  }
}
S += llvm::utostr(FD->getBitWidthValue(*Ctx));
6791}

6793// FIXME: Use SmallString for accumulating string.
6794void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string &S,
                                          const ObjCEncOptions Options,
                                          const FieldDecl *FD,
                                          QualType *NotEncodedT) const {
CanQualType CT = getCanonicalType(T);
switch (CT->getTypeClass()) {
case Type::Builtin:
case Type::Enum:
  if (FD && FD->isBitField())
    return EncodeBitField(this, S, T, FD);
  if (const auto *BT = dyn_cast<BuiltinType>(CT))
    S += getObjCEncodingForPrimitiveType(this, BT);
  else
    S += ObjCEncodingForEnumType(this, cast<EnumType>(CT));
  return;

case Type::Complex: {
  const auto *CT = T->castAs<ComplexType>();
  S += 'j';
  getObjCEncodingForTypeImpl(CT->getElementType(), S, ObjCEncOptions(),
                             /*Field=*/nullptr);
  return;
}

case Type::Atomic: {
  const auto *AT = T->castAs<AtomicType>();
  S += 'A';
  getObjCEncodingForTypeImpl(AT->getValueType(), S, ObjCEncOptions(),
                             /*Field=*/nullptr);
  return;
}

// encoding for pointer or reference types.
case Type::Pointer:
case Type::LValueReference:
case Type::RValueReference: {
  QualType PointeeTy;
  if (isa<PointerType>(CT)) {
    const auto *PT = T->castAs<PointerType>();
    if (PT->isObjCSelType()) {
      S += ':';
      return;
    }
    PointeeTy = PT->getPointeeType();
  } else {
    PointeeTy = T->castAs<ReferenceType>()->getPointeeType();
  }

  bool isReadOnly = false;
  // For historical/compatibility reasons, the read-only qualifier of the
  // pointee gets emitted _before_ the '^'.  The read-only qualifier of
  // the pointer itself gets ignored, _unless_ we are looking at a typedef!
  // Also, do not emit the 'r' for anything but the outermost type!
  if (isa<TypedefType>(T.getTypePtr())) {
    if (Options.IsOutermostType() && T.isConstQualified()) {
      isReadOnly = true;
      S += 'r';
    }
  } else if (Options.IsOutermostType()) {
    QualType P = PointeeTy;
    while (P->getAs<PointerType>())
      P = P->getAs<PointerType>()->getPointeeType();
    if (P.isConstQualified()) {
      isReadOnly = true;
      S += 'r';
    }
  }
  if (isReadOnly) {
    // Another legacy compatibility encoding. Some ObjC qualifier and type
    // combinations need to be rearranged.
    // Rewrite "in const" from "nr" to "rn"
    if (StringRef(S).endswith("nr"))
      S.replace(S.end()-2, S.end(), "rn");
  }

  if (PointeeTy->isCharType()) {
    // char pointer types should be encoded as '*' unless it is a
    // type that has been typedef'd to 'BOOL'.
    if (!isTypeTypedefedAsBOOL(PointeeTy)) {
      S += '*';
      return;
    }
  } else if (const auto *RTy = PointeeTy->getAs<RecordType>()) {
    // GCC binary compat: Need to convert "struct objc_class *" to "#".
    if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
      S += '#';
      return;
    }
    // GCC binary compat: Need to convert "struct objc_object *" to "@".
    if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
      S += '@';
      return;
    }
    // fall through...
  }
  S += '^';
  getLegacyIntegralTypeEncoding(PointeeTy);

  ObjCEncOptions NewOptions;
  if (Options.ExpandPointedToStructures())
    NewOptions.setExpandStructures();
  getObjCEncodingForTypeImpl(PointeeTy, S, NewOptions,
                             /*Field=*/nullptr, NotEncodedT);
  return;
}

case Type::ConstantArray:
case Type::IncompleteArray:
case Type::VariableArray: {
  const auto *AT = cast<ArrayType>(CT);

  if (isa<IncompleteArrayType>(AT) && !Options.IsStructField()) {
    // Incomplete arrays are encoded as a pointer to the array element.
    S += '^';

    getObjCEncodingForTypeImpl(
        AT->getElementType(), S,
        Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD);
  } else {
    S += '[';

    if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
      S += llvm::utostr(CAT->getSize().getZExtValue());
    else {
      //Variable length arrays are encoded as a regular array with 0 elements.
      assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&(((isa<VariableArrayType>(AT) || isa<IncompleteArrayType
>(AT)) && "Unknown array type!") ? static_cast<
void> (0) : __assert_fail ("(isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && \"Unknown array type!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6920, __PRETTY_FUNCTION__))
             "Unknown array type!")(((isa<VariableArrayType>(AT) || isa<IncompleteArrayType
>(AT)) && "Unknown array type!") ? static_cast<
void> (0) : __assert_fail ("(isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && \"Unknown array type!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 6920, __PRETTY_FUNCTION__));
      S += '0';
    }

    getObjCEncodingForTypeImpl(
        AT->getElementType(), S,
        Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD,
        NotEncodedT);
    S += ']';
  }
  return;
}

case Type::FunctionNoProto:
case Type::FunctionProto:
  S += '?';
  return;

case Type::Record: {
  RecordDecl *RDecl = cast<RecordType>(CT)->getDecl();
  S += RDecl->isUnion() ? '(' : '{';
  // Anonymous structures print as '?'
  if (const IdentifierInfo *II = RDecl->getIdentifier()) {
    S += II->getName();
    if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
      const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
      llvm::raw_string_ostream OS(S);
      printTemplateArgumentList(OS, TemplateArgs.asArray(),
                                getPrintingPolicy());
    }
  } else {
    S += '?';
  }
  if (Options.ExpandStructures()) {
    S += '=';
    if (!RDecl->isUnion()) {
      getObjCEncodingForStructureImpl(RDecl, S, FD, true, NotEncodedT);
    } else {
      for (const auto *Field : RDecl->fields()) {
        if (FD) {
          S += '"';
          S += Field->getNameAsString();
          S += '"';
        }

        // Special case bit-fields.
        if (Field->isBitField()) {
          getObjCEncodingForTypeImpl(Field->getType(), S,
                                     ObjCEncOptions().setExpandStructures(),
                                     Field);
        } else {
          QualType qt = Field->getType();
          getLegacyIntegralTypeEncoding(qt);
          getObjCEncodingForTypeImpl(
              qt, S,
              ObjCEncOptions().setExpandStructures().setIsStructField(), FD,
              NotEncodedT);
        }
      }
    }
  }
  S += RDecl->isUnion() ? ')' : '}';
  return;
}

case Type::BlockPointer: {
  const auto *BT = T->castAs<BlockPointerType>();
  S += "@?"; // Unlike a pointer-to-function, which is "^?".
  if (Options.EncodeBlockParameters()) {
    const auto *FT = BT->getPointeeType()->castAs<FunctionType>();

    S += '<';
    // Block return type
    getObjCEncodingForTypeImpl(FT->getReturnType(), S,
                               Options.forComponentType(), FD, NotEncodedT);
    // Block self
    S += "@?";
    // Block parameters
    if (const auto *FPT = dyn_cast<FunctionProtoType>(FT)) {
      for (const auto &I : FPT->param_types())
        getObjCEncodingForTypeImpl(I, S, Options.forComponentType(), FD,
                                   NotEncodedT);
    }
    S += '>';
  }
  return;
}

case Type::ObjCObject: {
  // hack to match legacy encoding of *id and *Class
  QualType Ty = getObjCObjectPointerType(CT);
  if (Ty->isObjCIdType()) {
    S += "{objc_object=}";
    return;
  }
  else if (Ty->isObjCClassType()) {
    S += "{objc_class=}";
    return;
  }
  // TODO: Double check to make sure this intentionally falls through.
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
}

case Type::ObjCInterface: {
  // Ignore protocol qualifiers when mangling at this level.
  // @encode(class_name)
  ObjCInterfaceDecl *OI = T->castAs<ObjCObjectType>()->getInterface();
  S += '{';
  S += OI->getObjCRuntimeNameAsString();
  if (Options.ExpandStructures()) {
    S += '=';
    SmallVector<const ObjCIvarDecl*, 32> Ivars;
    DeepCollectObjCIvars(OI, true, Ivars);
    for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
      const FieldDecl *Field = Ivars[i];
      if (Field->isBitField())
        getObjCEncodingForTypeImpl(Field->getType(), S,
                                   ObjCEncOptions().setExpandStructures(),
                                   Field);
      else
        getObjCEncodingForTypeImpl(Field->getType(), S,
                                   ObjCEncOptions().setExpandStructures(), FD,
                                   NotEncodedT);
    }
  }
  S += '}';
  return;
}

case Type::ObjCObjectPointer: {
  const auto *OPT = T->castAs<ObjCObjectPointerType>();
  if (OPT->isObjCIdType()) {
    S += '@';
    return;
  }

  if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
    // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
    // Since this is a binary compatibility issue, need to consult with
    // runtime folks. Fortunately, this is a *very* obscure construct.
    S += '#';
    return;
  }

  if (OPT->isObjCQualifiedIdType()) {
    getObjCEncodingForTypeImpl(
        getObjCIdType(), S,
        Options.keepingOnly(ObjCEncOptions()
                                .setExpandPointedToStructures()
                                .setExpandStructures()),
        FD);
    if (FD || Options.EncodingProperty() || Options.EncodeClassNames()) {
      // Note that we do extended encoding of protocol qualifer list
      // Only when doing ivar or property encoding.
      S += '"';
      for (const auto *I : OPT->quals()) {
        S += '<';
        S += I->getObjCRuntimeNameAsString();
        S += '>';
      }
      S += '"';
    }
    return;
  }

  S += '@';
  if (OPT->getInterfaceDecl() &&
      (FD || Options.EncodingProperty() || Options.EncodeClassNames())) {
    S += '"';
    S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();
    for (const auto *I : OPT->quals()) {
      S += '<';
      S += I->getObjCRuntimeNameAsString();
      S += '>';
    }
    S += '"';
  }
  return;
}

// gcc just blithely ignores member pointers.
// FIXME: we should do better than that.  'M' is available.
case Type::MemberPointer:
// This matches gcc's encoding, even though technically it is insufficient.
//FIXME. We should do a better job than gcc.
case Type::Vector:
case Type::ExtVector:
// Until we have a coherent encoding of these three types, issue warning.
  if (NotEncodedT)
    *NotEncodedT = T;
  return;

// We could see an undeduced auto type here during error recovery.
// Just ignore it.
case Type::Auto:
case Type::DeducedTemplateSpecialization:
  return;

case Type::Pipe:
7119#define ABSTRACT_TYPE(KIND, BASE)
7120#define TYPE(KIND, BASE)
7121#define DEPENDENT_TYPE(KIND, BASE) \
case Type::KIND:
7123#define NON_CANONICAL_TYPE(KIND, BASE) \
case Type::KIND:
7125#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
case Type::KIND:
7127#include "clang/AST/TypeNodes.inc"
  llvm_unreachable("@encode for dependent type!")::llvm::llvm_unreachable_internal("@encode for dependent type!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7128);
}
llvm_unreachable("bad type kind!")::llvm::llvm_unreachable_internal("bad type kind!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7130);
7131}

7133void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
                                               std::string &S,
                                               const FieldDecl *FD,
                                               bool includeVBases,
                                               QualType *NotEncodedT) const {
assert(RDecl && "Expected non-null RecordDecl")((RDecl && "Expected non-null RecordDecl") ? static_cast
<void> (0) : __assert_fail ("RDecl && \"Expected non-null RecordDecl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7138, __PRETTY_FUNCTION__));
assert(!RDecl->isUnion() && "Should not be called for unions")((!RDecl->isUnion() && "Should not be called for unions"
) ? static_cast<void> (0) : __assert_fail ("!RDecl->isUnion() && \"Should not be called for unions\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7139, __PRETTY_FUNCTION__));
if (!RDecl->getDefinition() || RDecl->getDefinition()->isInvalidDecl())
  return;

const auto *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
const ASTRecordLayout &layout = getASTRecordLayout(RDecl);

if (CXXRec) {
  for (const auto &BI : CXXRec->bases()) {
    if (!BI.isVirtual()) {
      CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
      if (base->isEmpty())
        continue;
      uint64_t offs = toBits(layout.getBaseClassOffset(base));
      FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
                                std::make_pair(offs, base));
    }
  }
}

unsigned i = 0;
for (auto *Field : RDecl->fields()) {
  uint64_t offs = layout.getFieldOffset(i);
  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
                            std::make_pair(offs, Field));
  ++i;
}

if (CXXRec && includeVBases) {
  for (const auto &BI : CXXRec->vbases()) {
    CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
    if (base->isEmpty())
      continue;
    uint64_t offs = toBits(layout.getVBaseClassOffset(base));
    if (offs >= uint64_t(toBits(layout.getNonVirtualSize())) &&
        FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
      FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
                                std::make_pair(offs, base));
  }
}

CharUnits size;
if (CXXRec) {
  size = includeVBases ? layout.getSize() : layout.getNonVirtualSize();
} else {
  size = layout.getSize();
}

7188#ifndef NDEBUG
uint64_t CurOffs = 0;
7190#endif
std::multimap<uint64_t, NamedDecl *>::iterator
  CurLayObj = FieldOrBaseOffsets.begin();

if (CXXRec && CXXRec->isDynamicClass() &&
    (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
  if (FD) {
    S += "\"_vptr$";
    std::string recname = CXXRec->getNameAsString();
    if (recname.empty()) recname = "?";
    S += recname;
    S += '"';
  }
  S += "^^?";
7204#ifndef NDEBUG
  CurOffs += getTypeSize(VoidPtrTy);
7206#endif
}

if (!RDecl->hasFlexibleArrayMember()) {
  // Mark the end of the structure.
  uint64_t offs = toBits(size);
  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
                            std::make_pair(offs, nullptr));
}

for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
7217#ifndef NDEBUG
  assert(CurOffs <= CurLayObj->first)((CurOffs <= CurLayObj->first) ? static_cast<void>
 (0) : __assert_fail ("CurOffs <= CurLayObj->first", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7218, __PRETTY_FUNCTION__));
  if (CurOffs < CurLayObj->first) {
    uint64_t padding = CurLayObj->first - CurOffs;
    // FIXME: There doesn't seem to be a way to indicate in the encoding that
    // packing/alignment of members is different that normal, in which case
    // the encoding will be out-of-sync with the real layout.
    // If the runtime switches to just consider the size of types without
    // taking into account alignment, we could make padding explicit in the
    // encoding (e.g. using arrays of chars). The encoding strings would be
    // longer then though.
    CurOffs += padding;
  }
7230#endif

  NamedDecl *dcl = CurLayObj->second;
  if (!dcl)
    break; // reached end of structure.

  if (auto *base = dyn_cast<CXXRecordDecl>(dcl)) {
    // We expand the bases without their virtual bases since those are going
    // in the initial structure. Note that this differs from gcc which
    // expands virtual bases each time one is encountered in the hierarchy,
    // making the encoding type bigger than it really is.
    getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false,
                                    NotEncodedT);
    assert(!base->isEmpty())((!base->isEmpty()) ? static_cast<void> (0) : __assert_fail
 ("!base->isEmpty()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7243, __PRETTY_FUNCTION__));
7244#ifndef NDEBUG
    CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize());
7246#endif
  } else {
    const auto *field = cast<FieldDecl>(dcl);
    if (FD) {
      S += '"';
      S += field->getNameAsString();
      S += '"';
    }

    if (field->isBitField()) {
      EncodeBitField(this, S, field->getType(), field);
7257#ifndef NDEBUG
      CurOffs += field->getBitWidthValue(*this);
7259#endif
    } else {
      QualType qt = field->getType();
      getLegacyIntegralTypeEncoding(qt);
      getObjCEncodingForTypeImpl(
          qt, S, ObjCEncOptions().setExpandStructures().setIsStructField(),
          FD, NotEncodedT);
7266#ifndef NDEBUG
      CurOffs += getTypeSize(field->getType());
7268#endif
    }
  }
}
7272}

7274void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
                                               std::string& S) const {
if (QT & Decl::OBJC_TQ_In)
  S += 'n';
if (QT & Decl::OBJC_TQ_Inout)
  S += 'N';
if (QT & Decl::OBJC_TQ_Out)
  S += 'o';
if (QT & Decl::OBJC_TQ_Bycopy)
  S += 'O';
if (QT & Decl::OBJC_TQ_Byref)
  S += 'R';
if (QT & Decl::OBJC_TQ_Oneway)
  S += 'V';
7288}

7290TypedefDecl *ASTContext::getObjCIdDecl() const {
if (!ObjCIdDecl) {
  QualType T = getObjCObjectType(ObjCBuiltinIdTy, {}, {});
  T = getObjCObjectPointerType(T);
  ObjCIdDecl = buildImplicitTypedef(T, "id");
}
return ObjCIdDecl;
7297}

7299TypedefDecl *ASTContext::getObjCSelDecl() const {
if (!ObjCSelDecl) {
  QualType T = getPointerType(ObjCBuiltinSelTy);
  ObjCSelDecl = buildImplicitTypedef(T, "SEL");
}
return ObjCSelDecl;
7305}

7307TypedefDecl *ASTContext::getObjCClassDecl() const {
if (!ObjCClassDecl) {
  QualType T = getObjCObjectType(ObjCBuiltinClassTy, {}, {});
  T = getObjCObjectPointerType(T);
  ObjCClassDecl = buildImplicitTypedef(T, "Class");
}
return ObjCClassDecl;
7314}

7316ObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const {
if (!ObjCProtocolClassDecl) {
  ObjCProtocolClassDecl
    = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(),
                                SourceLocation(),
                                &Idents.get("Protocol"),
                                /*typeParamList=*/nullptr,
                                /*PrevDecl=*/nullptr,
                                SourceLocation(), true);
}

return ObjCProtocolClassDecl;
7328}

7330//===----------------------------------------------------------------------===//
7331// __builtin_va_list Construction Functions
7332//===----------------------------------------------------------------------===//

7334static TypedefDecl *CreateCharPtrNamedVaListDecl(const ASTContext *Context,
                                               StringRef Name) {
// typedef char* __builtin[_ms]_va_list;
QualType T = Context->getPointerType(Context->CharTy);
return Context->buildImplicitTypedef(T, Name);
7339}

7341static TypedefDecl *CreateMSVaListDecl(const ASTContext *Context) {
return CreateCharPtrNamedVaListDecl(Context, "__builtin_ms_va_list");
7343}

7345static TypedefDecl *CreateCharPtrBuiltinVaListDecl(const ASTContext *Context) {
return CreateCharPtrNamedVaListDecl(Context, "__builtin_va_list");
7347}

7349static TypedefDecl *CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context) {
// typedef void* __builtin_va_list;
QualType T = Context->getPointerType(Context->VoidTy);
return Context->buildImplicitTypedef(T, "__builtin_va_list");
7353}

7355static TypedefDecl *
7356CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context) {
// struct __va_list
RecordDecl *VaListTagDecl = Context->buildImplicitRecord("__va_list");
if (Context->getLangOpts().CPlusPlus) {
  // namespace std { struct __va_list {
  NamespaceDecl *NS;
  NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
                             Context->getTranslationUnitDecl(),
                             /*Inline*/ false, SourceLocation(),
                             SourceLocation(), &Context->Idents.get("std"),
                             /*PrevDecl*/ nullptr);
  NS->setImplicit();
  VaListTagDecl->setDeclContext(NS);
}

VaListTagDecl->startDefinition();

const size_t NumFields = 5;
QualType FieldTypes[NumFields];
const char *FieldNames[NumFields];

// void *__stack;
FieldTypes[0] = Context->getPointerType(Context->VoidTy);
FieldNames[0] = "__stack";

// void *__gr_top;
FieldTypes[1] = Context->getPointerType(Context->VoidTy);
FieldNames[1] = "__gr_top";

// void *__vr_top;
FieldTypes[2] = Context->getPointerType(Context->VoidTy);
FieldNames[2] = "__vr_top";

// int __gr_offs;
FieldTypes[3] = Context->IntTy;
FieldNames[3] = "__gr_offs";

// int __vr_offs;
FieldTypes[4] = Context->IntTy;
FieldNames[4] = "__vr_offs";

// Create fields
for (unsigned i = 0; i < NumFields; ++i) {
  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
                                       VaListTagDecl,
                                       SourceLocation(),
                                       SourceLocation(),
                                       &Context->Idents.get(FieldNames[i]),
                                       FieldTypes[i], /*TInfo=*/nullptr,
                                       /*BitWidth=*/nullptr,
                                       /*Mutable=*/false,
                                       ICIS_NoInit);
  Field->setAccess(AS_public);
  VaListTagDecl->addDecl(Field);
}
VaListTagDecl->completeDefinition();
Context->VaListTagDecl = VaListTagDecl;
QualType VaListTagType = Context->getRecordType(VaListTagDecl);

// } __builtin_va_list;
return Context->buildImplicitTypedef(VaListTagType, "__builtin_va_list");
7417}

7419static TypedefDecl *CreatePowerABIBuiltinVaListDecl(const ASTContext *Context) {
// typedef struct __va_list_tag {
RecordDecl *VaListTagDecl;

VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
VaListTagDecl->startDefinition();

const size_t NumFields = 5;
QualType FieldTypes[NumFields];
const char *FieldNames[NumFields];

//   unsigned char gpr;
FieldTypes[0] = Context->UnsignedCharTy;
FieldNames[0] = "gpr";

//   unsigned char fpr;
FieldTypes[1] = Context->UnsignedCharTy;
FieldNames[1] = "fpr";

//   unsigned short reserved;
FieldTypes[2] = Context->UnsignedShortTy;
FieldNames[2] = "reserved";

//   void* overflow_arg_area;
FieldTypes[3] = Context->getPointerType(Context->VoidTy);
FieldNames[3] = "overflow_arg_area";

//   void* reg_save_area;
FieldTypes[4] = Context->getPointerType(Context->VoidTy);
FieldNames[4] = "reg_save_area";

// Create fields
for (unsigned i = 0; i < NumFields; ++i) {
  FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl,
                                       SourceLocation(),
                                       SourceLocation(),
                                       &Context->Idents.get(FieldNames[i]),
                                       FieldTypes[i], /*TInfo=*/nullptr,
                                       /*BitWidth=*/nullptr,
                                       /*Mutable=*/false,
                                       ICIS_NoInit);
  Field->setAccess(AS_public);
  VaListTagDecl->addDecl(Field);
}
VaListTagDecl->completeDefinition();
Context->VaListTagDecl = VaListTagDecl;
QualType VaListTagType = Context->getRecordType(VaListTagDecl);

// } __va_list_tag;
TypedefDecl *VaListTagTypedefDecl =
    Context->buildImplicitTypedef(VaListTagType, "__va_list_tag");

QualType VaListTagTypedefType =
  Context->getTypedefType(VaListTagTypedefDecl);

// typedef __va_list_tag __builtin_va_list[1];
llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
QualType VaListTagArrayType
  = Context->getConstantArrayType(VaListTagTypedefType,
                                  Size, ArrayType::Normal, 0);
return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7480}

7482static TypedefDecl *
7483CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context) {
// struct __va_list_tag {
RecordDecl *VaListTagDecl;
VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
VaListTagDecl->startDefinition();

const size_t NumFields = 4;
QualType FieldTypes[NumFields];
const char *FieldNames[NumFields];

//   unsigned gp_offset;
FieldTypes[0] = Context->UnsignedIntTy;
FieldNames[0] = "gp_offset";

//   unsigned fp_offset;
FieldTypes[1] = Context->UnsignedIntTy;
FieldNames[1] = "fp_offset";

//   void* overflow_arg_area;
FieldTypes[2] = Context->getPointerType(Context->VoidTy);
FieldNames[2] = "overflow_arg_area";

//   void* reg_save_area;
FieldTypes[3] = Context->getPointerType(Context->VoidTy);
FieldNames[3] = "reg_save_area";

// Create fields
for (unsigned i = 0; i < NumFields; ++i) {
  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
                                       VaListTagDecl,
                                       SourceLocation(),
                                       SourceLocation(),
                                       &Context->Idents.get(FieldNames[i]),
                                       FieldTypes[i], /*TInfo=*/nullptr,
                                       /*BitWidth=*/nullptr,
                                       /*Mutable=*/false,
                                       ICIS_NoInit);
  Field->setAccess(AS_public);
  VaListTagDecl->addDecl(Field);
}
VaListTagDecl->completeDefinition();
Context->VaListTagDecl = VaListTagDecl;
QualType VaListTagType = Context->getRecordType(VaListTagDecl);

// };

// typedef struct __va_list_tag __builtin_va_list[1];
llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
QualType VaListTagArrayType =
    Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);
return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7534}

7536static TypedefDecl *CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context) {
// typedef int __builtin_va_list[4];
llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4);
QualType IntArrayType =
    Context->getConstantArrayType(Context->IntTy, Size, ArrayType::Normal, 0);
return Context->buildImplicitTypedef(IntArrayType, "__builtin_va_list");
7542}

7544static TypedefDecl *
7545CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context) {
// struct __va_list
RecordDecl *VaListDecl = Context->buildImplicitRecord("__va_list");
if (Context->getLangOpts().CPlusPlus) {
  // namespace std { struct __va_list {
  NamespaceDecl *NS;
  NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
                             Context->getTranslationUnitDecl(),
                             /*Inline*/false, SourceLocation(),
                             SourceLocation(), &Context->Idents.get("std"),
                             /*PrevDecl*/ nullptr);
  NS->setImplicit();
  VaListDecl->setDeclContext(NS);
}

VaListDecl->startDefinition();

// void * __ap;
FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
                                     VaListDecl,
                                     SourceLocation(),
                                     SourceLocation(),
                                     &Context->Idents.get("__ap"),
                                     Context->getPointerType(Context->VoidTy),
                                     /*TInfo=*/nullptr,
                                     /*BitWidth=*/nullptr,
                                     /*Mutable=*/false,
                                     ICIS_NoInit);
Field->setAccess(AS_public);
VaListDecl->addDecl(Field);

// };
VaListDecl->completeDefinition();
Context->VaListTagDecl = VaListDecl;

// typedef struct __va_list __builtin_va_list;
QualType T = Context->getRecordType(VaListDecl);
return Context->buildImplicitTypedef(T, "__builtin_va_list");
7583}

7585static TypedefDecl *
7586CreateSystemZBuiltinVaListDecl(const ASTContext *Context) {
// struct __va_list_tag {
RecordDecl *VaListTagDecl;
VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
VaListTagDecl->startDefinition();

const size_t NumFields = 4;
QualType FieldTypes[NumFields];
const char *FieldNames[NumFields];

//   long __gpr;
FieldTypes[0] = Context->LongTy;
FieldNames[0] = "__gpr";

//   long __fpr;
FieldTypes[1] = Context->LongTy;
FieldNames[1] = "__fpr";

//   void *__overflow_arg_area;
FieldTypes[2] = Context->getPointerType(Context->VoidTy);
FieldNames[2] = "__overflow_arg_area";

//   void *__reg_save_area;
FieldTypes[3] = Context->getPointerType(Context->VoidTy);
FieldNames[3] = "__reg_save_area";

// Create fields
for (unsigned i = 0; i < NumFields; ++i) {
  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
                                       VaListTagDecl,
                                       SourceLocation(),
                                       SourceLocation(),
                                       &Context->Idents.get(FieldNames[i]),
                                       FieldTypes[i], /*TInfo=*/nullptr,
                                       /*BitWidth=*/nullptr,
                                       /*Mutable=*/false,
                                       ICIS_NoInit);
  Field->setAccess(AS_public);
  VaListTagDecl->addDecl(Field);
}
VaListTagDecl->completeDefinition();
Context->VaListTagDecl = VaListTagDecl;
QualType VaListTagType = Context->getRecordType(VaListTagDecl);

// };

// typedef __va_list_tag __builtin_va_list[1];
llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
QualType VaListTagArrayType =
    Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);

return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7638}

7640static TypedefDecl *CreateVaListDecl(const ASTContext *Context,
                                   TargetInfo::BuiltinVaListKind Kind) {
switch (Kind) {
case TargetInfo::CharPtrBuiltinVaList:
  return CreateCharPtrBuiltinVaListDecl(Context);
case TargetInfo::VoidPtrBuiltinVaList:
  return CreateVoidPtrBuiltinVaListDecl(Context);
case TargetInfo::AArch64ABIBuiltinVaList:
  return CreateAArch64ABIBuiltinVaListDecl(Context);
case TargetInfo::PowerABIBuiltinVaList:
  return CreatePowerABIBuiltinVaListDecl(Context);
case TargetInfo::X86_64ABIBuiltinVaList:
  return CreateX86_64ABIBuiltinVaListDecl(Context);
case TargetInfo::PNaClABIBuiltinVaList:
  return CreatePNaClABIBuiltinVaListDecl(Context);
case TargetInfo::AAPCSABIBuiltinVaList:
  return CreateAAPCSABIBuiltinVaListDecl(Context);
case TargetInfo::SystemZBuiltinVaList:
  return CreateSystemZBuiltinVaListDecl(Context);
}

llvm_unreachable("Unhandled __builtin_va_list type kind")::llvm::llvm_unreachable_internal("Unhandled __builtin_va_list type kind"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7661);
7662}

7664TypedefDecl *ASTContext::getBuiltinVaListDecl() const {
if (!BuiltinVaListDecl) {
  BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind());
  assert(BuiltinVaListDecl->isImplicit())((BuiltinVaListDecl->isImplicit()) ? static_cast<void>
 (0) : __assert_fail ("BuiltinVaListDecl->isImplicit()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7667, __PRETTY_FUNCTION__));
}

return BuiltinVaListDecl;
7671}

7673Decl *ASTContext::getVaListTagDecl() const {
// Force the creation of VaListTagDecl by building the __builtin_va_list
// declaration.
if (!VaListTagDecl)
  (void)getBuiltinVaListDecl();

return VaListTagDecl;
7680}

7682TypedefDecl *ASTContext::getBuiltinMSVaListDecl() const {
if (!BuiltinMSVaListDecl)
  BuiltinMSVaListDecl = CreateMSVaListDecl(this);

return BuiltinMSVaListDecl;
7687}

7689bool ASTContext::canBuiltinBeRedeclared(const FunctionDecl *FD) const {
return BuiltinInfo.canBeRedeclared(FD->getBuiltinID());
7691}

7693void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
assert(ObjCConstantStringType.isNull() &&((ObjCConstantStringType.isNull() && "'NSConstantString' type already set!"
) ? static_cast<void> (0) : __assert_fail ("ObjCConstantStringType.isNull() && \"'NSConstantString' type already set!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7695, __PRETTY_FUNCTION__))
       "'NSConstantString' type already set!")((ObjCConstantStringType.isNull() && "'NSConstantString' type already set!"
) ? static_cast<void> (0) : __assert_fail ("ObjCConstantStringType.isNull() && \"'NSConstantString' type already set!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7695, __PRETTY_FUNCTION__));

ObjCConstantStringType = getObjCInterfaceType(Decl);
7698}

7700/// Retrieve the template name that corresponds to a non-empty
7701/// lookup.
7702TemplateName
7703ASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin,
                                    UnresolvedSetIterator End) const {
unsigned size = End - Begin;
assert(size > 1 && "set is not overloaded!")((size > 1 && "set is not overloaded!") ? static_cast
<void> (0) : __assert_fail ("size > 1 && \"set is not overloaded!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7706, __PRETTY_FUNCTION__));

void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
                        size * sizeof(FunctionTemplateDecl*));
auto *OT = new (memory) OverloadedTemplateStorage(size);

NamedDecl **Storage = OT->getStorage();
for (UnresolvedSetIterator I = Begin; I != End; ++I) {
  NamedDecl *D = *I;
  assert(isa<FunctionTemplateDecl>(D) ||((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7718, __PRETTY_FUNCTION__))
         isa<UnresolvedUsingValueDecl>(D) ||((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7718, __PRETTY_FUNCTION__))
         (isa<UsingShadowDecl>(D) &&((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7718, __PRETTY_FUNCTION__))
          isa<FunctionTemplateDecl>(D->getUnderlyingDecl())))((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7718, __PRETTY_FUNCTION__));
  *Storage++ = D;
}

return TemplateName(OT);
7723}

7725/// Retrieve a template name representing an unqualified-id that has been
7726/// assumed to name a template for ADL purposes.
7727TemplateName ASTContext::getAssumedTemplateName(DeclarationName Name) const {
auto *OT = new (*this) AssumedTemplateStorage(Name);
return TemplateName(OT);
7730}

7732/// Retrieve the template name that represents a qualified
7733/// template name such as \c std::vector.
7734TemplateName
7735ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
                                   bool TemplateKeyword,
                                   TemplateDecl *Template) const {
assert(NNS && "Missing nested-name-specifier in qualified template name")((NNS && "Missing nested-name-specifier in qualified template name"
) ? static_cast<void> (0) : __assert_fail ("NNS && \"Missing nested-name-specifier in qualified template name\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7738, __PRETTY_FUNCTION__));

// FIXME: Canonicalization?
llvm::FoldingSetNodeID ID;
QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);

void *InsertPos = nullptr;
QualifiedTemplateName *QTN =
  QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
if (!QTN) {
  QTN = new (*this, alignof(QualifiedTemplateName))
      QualifiedTemplateName(NNS, TemplateKeyword, Template);
  QualifiedTemplateNames.InsertNode(QTN, InsertPos);
}

return TemplateName(QTN);
7754}

7756/// Retrieve the template name that represents a dependent
7757/// template name such as \c MetaFun::template apply.
7758TemplateName
7759ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
                                   const IdentifierInfo *Name) const {
assert((!NNS || NNS->isDependent()) &&(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7762, __PRETTY_FUNCTION__))
       "Nested name specifier must be dependent")(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7762, __PRETTY_FUNCTION__));

llvm::FoldingSetNodeID ID;
DependentTemplateName::Profile(ID, NNS, Name);

void *InsertPos = nullptr;
DependentTemplateName *QTN =
  DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);

if (QTN)
  return TemplateName(QTN);

NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
if (CanonNNS == NNS) {
  QTN = new (*this, alignof(DependentTemplateName))
      DependentTemplateName(NNS, Name);
} else {
  TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
  QTN = new (*this, alignof(DependentTemplateName))
      DependentTemplateName(NNS, Name, Canon);
  DependentTemplateName *CheckQTN =
    DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
  assert(!CheckQTN && "Dependent type name canonicalization broken")((!CheckQTN && "Dependent type name canonicalization broken"
) ? static_cast<void> (0) : __assert_fail ("!CheckQTN && \"Dependent type name canonicalization broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7784, __PRETTY_FUNCTION__));
  (void)CheckQTN;
}

DependentTemplateNames.InsertNode(QTN, InsertPos);
return TemplateName(QTN);
7790}

7792/// Retrieve the template name that represents a dependent
7793/// template name such as \c MetaFun::template operator+.
7794TemplateName
7795ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
                                   OverloadedOperatorKind Operator) const {
assert((!NNS || NNS->isDependent()) &&(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7798, __PRETTY_FUNCTION__))
       "Nested name specifier must be dependent")(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7798, __PRETTY_FUNCTION__));

llvm::FoldingSetNodeID ID;
DependentTemplateName::Profile(ID, NNS, Operator);

void *InsertPos = nullptr;
DependentTemplateName *QTN
  = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);

if (QTN)
  return TemplateName(QTN);

NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
if (CanonNNS == NNS) {
  QTN = new (*this, alignof(DependentTemplateName))
      DependentTemplateName(NNS, Operator);
} else {
  TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
  QTN = new (*this, alignof(DependentTemplateName))
      DependentTemplateName(NNS, Operator, Canon);

  DependentTemplateName *CheckQTN
    = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
  assert(!CheckQTN && "Dependent template name canonicalization broken")((!CheckQTN && "Dependent template name canonicalization broken"
) ? static_cast<void> (0) : __assert_fail ("!CheckQTN && \"Dependent template name canonicalization broken\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7821, __PRETTY_FUNCTION__));
  (void)CheckQTN;
}

DependentTemplateNames.InsertNode(QTN, InsertPos);
return TemplateName(QTN);
7827}

7829TemplateName
7830ASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param,
                                       TemplateName replacement) const {
llvm::FoldingSetNodeID ID;
SubstTemplateTemplateParmStorage::Profile(ID, param, replacement);

void *insertPos = nullptr;
SubstTemplateTemplateParmStorage *subst
  = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);

if (!subst) {
  subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement);
  SubstTemplateTemplateParms.InsertNode(subst, insertPos);
}

return TemplateName(subst);
7845}

7847TemplateName
7848ASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,
                                     const TemplateArgument &ArgPack) const {
auto &Self = const_cast<ASTContext &>(*this);
llvm::FoldingSetNodeID ID;
SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack);

void *InsertPos = nullptr;
SubstTemplateTemplateParmPackStorage *Subst
  = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);

if (!Subst) {
  Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param,
                                                         ArgPack.pack_size(),
                                                       ArgPack.pack_begin());
  SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
}

return TemplateName(Subst);
7866}

7868/// getFromTargetType - Given one of the integer types provided by
7869/// TargetInfo, produce the corresponding type. The unsigned @p Type
7870/// is actually a value of type @c TargetInfo::IntType.
7871CanQualType ASTContext::getFromTargetType(unsigned Type) const {
switch (Type) {
case TargetInfo::NoInt: return {};
case TargetInfo::SignedChar: return SignedCharTy;
case TargetInfo::UnsignedChar: return UnsignedCharTy;
case TargetInfo::SignedShort: return ShortTy;
case TargetInfo::UnsignedShort: return UnsignedShortTy;
case TargetInfo::SignedInt: return IntTy;
case TargetInfo::UnsignedInt: return UnsignedIntTy;
case TargetInfo::SignedLong: return LongTy;
case TargetInfo::UnsignedLong: return UnsignedLongTy;
case TargetInfo::SignedLongLong: return LongLongTy;
case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
}

llvm_unreachable("Unhandled TargetInfo::IntType value")::llvm::llvm_unreachable_internal("Unhandled TargetInfo::IntType value"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7886);
7887}

7889//===----------------------------------------------------------------------===//
7890//                        Type Predicates.
7891//===----------------------------------------------------------------------===//

7893/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
7894/// garbage collection attribute.
7895///
7896Qualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const {
if (getLangOpts().getGC() == LangOptions::NonGC)
  return Qualifiers::GCNone;

assert(getLangOpts().ObjC)((getLangOpts().ObjC) ? static_cast<void> (0) : __assert_fail
 ("getLangOpts().ObjC", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7900, __PRETTY_FUNCTION__));
Qualifiers::GC GCAttrs = Ty.getObjCGCAttr();

// Default behaviour under objective-C's gc is for ObjC pointers
// (or pointers to them) be treated as though they were declared
// as __strong.
if (GCAttrs == Qualifiers::GCNone) {
  if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
    return Qualifiers::Strong;
  else if (Ty->isPointerType())
    return getObjCGCAttrKind(Ty->castAs<PointerType>()->getPointeeType());
} else {
  // It's not valid to set GC attributes on anything that isn't a
  // pointer.
7914#ifndef NDEBUG
  QualType CT = Ty->getCanonicalTypeInternal();
  while (const auto *AT = dyn_cast<ArrayType>(CT))
    CT = AT->getElementType();
  assert(CT->isAnyPointerType() || CT->isBlockPointerType())((CT->isAnyPointerType() || CT->isBlockPointerType()) ?
 static_cast<void> (0) : __assert_fail ("CT->isAnyPointerType() || CT->isBlockPointerType()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7918, __PRETTY_FUNCTION__));
7919#endif
}
return GCAttrs;
7922}

7924//===----------------------------------------------------------------------===//
7925//                        Type Compatibility Testing
7926//===----------------------------------------------------------------------===//

7928/// areCompatVectorTypes - Return true if the two specified vector types are
7929/// compatible.
7930static bool areCompatVectorTypes(const VectorType *LHS,
                               const VectorType *RHS) {
assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified())((LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified
()) ? static_cast<void> (0) : __assert_fail ("LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7932, __PRETTY_FUNCTION__));
return LHS->getElementType() == RHS->getElementType() &&
       LHS->getNumElements() == RHS->getNumElements();
7935}

7937bool ASTContext::areCompatibleVectorTypes(QualType FirstVec,
                                        QualType SecondVec) {
assert(FirstVec->isVectorType() && "FirstVec should be a vector type")((FirstVec->isVectorType() && "FirstVec should be a vector type"
) ? static_cast<void> (0) : __assert_fail ("FirstVec->isVectorType() && \"FirstVec should be a vector type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7939, __PRETTY_FUNCTION__));
assert(SecondVec->isVectorType() && "SecondVec should be a vector type")((SecondVec->isVectorType() && "SecondVec should be a vector type"
) ? static_cast<void> (0) : __assert_fail ("SecondVec->isVectorType() && \"SecondVec should be a vector type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 7940, __PRETTY_FUNCTION__));

if (hasSameUnqualifiedType(FirstVec, SecondVec))
  return true;

// Treat Neon vector types and most AltiVec vector types as if they are the
// equivalent GCC vector types.
const auto *First = FirstVec->castAs<VectorType>();
const auto *Second = SecondVec->castAs<VectorType>();
if (First->getNumElements() == Second->getNumElements() &&
    hasSameType(First->getElementType(), Second->getElementType()) &&
    First->getVectorKind() != VectorType::AltiVecPixel &&
    First->getVectorKind() != VectorType::AltiVecBool &&
    Second->getVectorKind() != VectorType::AltiVecPixel &&
    Second->getVectorKind() != VectorType::AltiVecBool)
  return true;

return false;
7958}

7960bool ASTContext::hasDirectOwnershipQualifier(QualType Ty) const {
while (true) {
  // __strong id
  if (const AttributedType *Attr = dyn_cast<AttributedType>(Ty)) {
    if (Attr->getAttrKind() == attr::ObjCOwnership)
      return true;

    Ty = Attr->getModifiedType();

  // X *__strong (...)
  } else if (const ParenType *Paren = dyn_cast<ParenType>(Ty)) {
    Ty = Paren->getInnerType();

  // We do not want to look through typedefs, typeof(expr),
  // typeof(type), or any other way that the type is somehow
  // abstracted.
  } else {
    return false;
  }
}
7980}

7982//===----------------------------------------------------------------------===//
7983// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
7984//===----------------------------------------------------------------------===//

7986/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
7987/// inheritance hierarchy of 'rProto'.
7988bool
7989ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
                                         ObjCProtocolDecl *rProto) const {
if (declaresSameEntity(lProto, rProto))
  return true;
for (auto *PI : rProto->protocols())
  if (ProtocolCompatibleWithProtocol(lProto, PI))
    return true;
return false;
7997}

7999/// ObjCQualifiedClassTypesAreCompatible - compare  Class<pr,...> and
8000/// Class<pr1, ...>.
8001bool ASTContext::ObjCQualifiedClassTypesAreCompatible(
  const ObjCObjectPointerType *lhs, const ObjCObjectPointerType *rhs) {
for (auto *lhsProto : lhs->quals()) {
  bool match = false;
  for (auto *rhsProto : rhs->quals()) {
    if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) {
      match = true;
      break;
    }
  }
  if (!match)
    return false;
}
return true;
8015}

8017/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
8018/// ObjCQualifiedIDType.
8019bool ASTContext::ObjCQualifiedIdTypesAreCompatible(
  const ObjCObjectPointerType *lhs, const ObjCObjectPointerType *rhs,
  bool compare) {
// Allow id<P..> and an 'id' or void* type in all cases.
if (lhs->isVoidPointerType() ||
    lhs->isObjCIdType() || lhs->isObjCClassType())
  return true;
else if (rhs->isVoidPointerType() ||
         rhs->isObjCIdType() || rhs->isObjCClassType())
  return true;

if (lhs->isObjCQualifiedIdType()) {
  if (rhs->qual_empty()) {
    // If the RHS is a unqualified interface pointer "NSString*",
    // make sure we check the class hierarchy.
    if (ObjCInterfaceDecl *rhsID = rhs->getInterfaceDecl()) {
      for (auto *I : lhs->quals()) {
        // when comparing an id<P> on lhs with a static type on rhs,
        // see if static class implements all of id's protocols, directly or
        // through its super class and categories.
        if (!rhsID->ClassImplementsProtocol(I, true))
          return false;
      }
    }
    // If there are no qualifiers and no interface, we have an 'id'.
    return true;
  }
  // Both the right and left sides have qualifiers.
  for (auto *lhsProto : lhs->quals()) {
    bool match = false;

    // when comparing an id<P> on lhs with a static type on rhs,
    // see if static class implements all of id's protocols, directly or
    // through its super class and categories.
    for (auto *rhsProto : rhs->quals()) {
      if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
          (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
        match = true;
        break;
      }
    }
    // If the RHS is a qualified interface pointer "NSString<P>*",
    // make sure we check the class hierarchy.
    if (ObjCInterfaceDecl *rhsID = rhs->getInterfaceDecl()) {
      for (auto *I : lhs->quals()) {
        // when comparing an id<P> on lhs with a static type on rhs,
        // see if static class implements all of id's protocols, directly or
        // through its super class and categories.
        if (rhsID->ClassImplementsProtocol(I, true)) {
          match = true;
          break;
        }
      }
    }
    if (!match)
      return false;
  }

  return true;
}

assert(rhs->isObjCQualifiedIdType() && "One of the LHS/RHS should be id<x>")((rhs->isObjCQualifiedIdType() && "One of the LHS/RHS should be id<x>"
) ? static_cast<void> (0) : __assert_fail ("rhs->isObjCQualifiedIdType() && \"One of the LHS/RHS should be id<x>\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8080, __PRETTY_FUNCTION__));

if (lhs->getInterfaceType()) {
  // If both the right and left sides have qualifiers.
  for (auto *lhsProto : lhs->quals()) {
    bool match = false;

    // when comparing an id<P> on rhs with a static type on lhs,
    // see if static class implements all of id's protocols, directly or
    // through its super class and categories.
    // First, lhs protocols in the qualifier list must be found, direct
    // or indirect in rhs's qualifier list or it is a mismatch.
    for (auto *rhsProto : rhs->quals()) {
      if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
          (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
        match = true;
        break;
      }
    }
    if (!match)
      return false;
  }

  // Static class's protocols, or its super class or category protocols
  // must be found, direct or indirect in rhs's qualifier list or it is a mismatch.
  if (ObjCInterfaceDecl *lhsID = lhs->getInterfaceDecl()) {
    llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
    CollectInheritedProtocols(lhsID, LHSInheritedProtocols);
    // This is rather dubious but matches gcc's behavior. If lhs has
    // no type qualifier and its class has no static protocol(s)
    // assume that it is mismatch.
    if (LHSInheritedProtocols.empty() && lhs->qual_empty())
      return false;
    for (auto *lhsProto : LHSInheritedProtocols) {
      bool match = false;
      for (auto *rhsProto : rhs->quals()) {
        if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
            (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
          match = true;
          break;
        }
      }
      if (!match)
        return false;
    }
  }
  return true;
}
return false;
8129}

8131/// canAssignObjCInterfaces - Return true if the two interface types are
8132/// compatible for assignment from RHS to LHS.  This handles validation of any
8133/// protocol qualifiers on the LHS or RHS.
8134bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
                                       const ObjCObjectPointerType *RHSOPT) {
const ObjCObjectType* LHS = LHSOPT->getObjectType();
const ObjCObjectType* RHS = RHSOPT->getObjectType();

// If either type represents the built-in 'id' or 'Class' types, return true.
if (LHS->isObjCUnqualifiedIdOrClass() ||
    RHS->isObjCUnqualifiedIdOrClass())
  return true;

// Function object that propagates a successful result or handles
// __kindof types.
auto finish = [&](bool succeeded) -> bool {
  if (succeeded)
    return true;

  if (!RHS->isKindOfType())
    return false;

  // Strip off __kindof and protocol qualifiers, then check whether
  // we can assign the other way.
  return canAssignObjCInterfaces(RHSOPT->stripObjCKindOfTypeAndQuals(*this),
                                 LHSOPT->stripObjCKindOfTypeAndQuals(*this));
};

if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
  return finish(ObjCQualifiedIdTypesAreCompatible(LHSOPT, RHSOPT, false));
}

if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {
  return finish(ObjCQualifiedClassTypesAreCompatible(LHSOPT, RHSOPT));
}

// If we have 2 user-defined types, fall into that path.
if (LHS->getInterface() && RHS->getInterface()) {
  return finish(canAssignObjCInterfaces(LHS, RHS));
}

return false;
8173}

8175/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written
8176/// for providing type-safety for objective-c pointers used to pass/return
8177/// arguments in block literals. When passed as arguments, passing 'A*' where
8178/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
8179/// not OK. For the return type, the opposite is not OK.
8180bool ASTContext::canAssignObjCInterfacesInBlockPointer(
                                       const ObjCObjectPointerType *LHSOPT,
                                       const ObjCObjectPointerType *RHSOPT,
                                       bool BlockReturnType) {

// Function object that propagates a successful result or handles
// __kindof types.
auto finish = [&](bool succeeded) -> bool {
  if (succeeded)
    return true;

  const ObjCObjectPointerType *Expected = BlockReturnType ? RHSOPT : LHSOPT;
  if (!Expected->isKindOfType())
    return false;

  // Strip off __kindof and protocol qualifiers, then check whether
  // we can assign the other way.
  return canAssignObjCInterfacesInBlockPointer(
           RHSOPT->stripObjCKindOfTypeAndQuals(*this),
           LHSOPT->stripObjCKindOfTypeAndQuals(*this),
           BlockReturnType);
};

if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())
47
←
Called C++ object pointer is null
  return true;

if (LHSOPT->isObjCBuiltinType()) {
  return finish(RHSOPT->isObjCBuiltinType() ||
                RHSOPT->isObjCQualifiedIdType());
}

if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
  return finish(ObjCQualifiedIdTypesAreCompatible(
      (BlockReturnType ? LHSOPT : RHSOPT),
      (BlockReturnType ? RHSOPT : LHSOPT), false));

const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
if (LHS && RHS)  { // We have 2 user-defined types.
  if (LHS != RHS) {
    if (LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
      return finish(BlockReturnType);
    if (RHS->getDecl()->isSuperClassOf(LHS->getDecl()))
      return finish(!BlockReturnType);
  }
  else
    return true;
}
return false;
8229}

8231/// Comparison routine for Objective-C protocols to be used with
8232/// llvm::array_pod_sort.
8233static int compareObjCProtocolsByName(ObjCProtocolDecl * const *lhs,
                                    ObjCProtocolDecl * const *rhs) {
return (*lhs)->getName().compare((*rhs)->getName());
8236}

8238/// getIntersectionOfProtocols - This routine finds the intersection of set
8239/// of protocols inherited from two distinct objective-c pointer objects with
8240/// the given common base.
8241/// It is used to build composite qualifier list of the composite type of
8242/// the conditional expression involving two objective-c pointer objects.
8243static
8244void getIntersectionOfProtocols(ASTContext &Context,
                              const ObjCInterfaceDecl *CommonBase,
                              const ObjCObjectPointerType *LHSOPT,
                              const ObjCObjectPointerType *RHSOPT,
    SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet) {

const ObjCObjectType* LHS = LHSOPT->getObjectType();
const ObjCObjectType* RHS = RHSOPT->getObjectType();
assert(LHS->getInterface() && "LHS must have an interface base")((LHS->getInterface() && "LHS must have an interface base"
) ? static_cast<void> (0) : __assert_fail ("LHS->getInterface() && \"LHS must have an interface base\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8252, __PRETTY_FUNCTION__));
assert(RHS->getInterface() && "RHS must have an interface base")((RHS->getInterface() && "RHS must have an interface base"
) ? static_cast<void> (0) : __assert_fail ("RHS->getInterface() && \"RHS must have an interface base\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8253, __PRETTY_FUNCTION__));

// Add all of the protocols for the LHS.
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSProtocolSet;

// Start with the protocol qualifiers.
for (auto proto : LHS->quals()) {
  Context.CollectInheritedProtocols(proto, LHSProtocolSet);
}

// Also add the protocols associated with the LHS interface.
Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet);

// Add all of the protocols for the RHS.
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSProtocolSet;

// Start with the protocol qualifiers.
for (auto proto : RHS->quals()) {
  Context.CollectInheritedProtocols(proto, RHSProtocolSet);
}

// Also add the protocols associated with the RHS interface.
Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet);

// Compute the intersection of the collected protocol sets.
for (auto proto : LHSProtocolSet) {
  if (RHSProtocolSet.count(proto))
    IntersectionSet.push_back(proto);
}

// Compute the set of protocols that is implied by either the common type or
// the protocols within the intersection.
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> ImpliedProtocols;
Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols);

// Remove any implied protocols from the list of inherited protocols.
if (!ImpliedProtocols.empty()) {
  IntersectionSet.erase(
    std::remove_if(IntersectionSet.begin(),
                   IntersectionSet.end(),
                   [&](ObjCProtocolDecl *proto) -> bool {
                     return ImpliedProtocols.count(proto) > 0;
                   }),
    IntersectionSet.end());
}

// Sort the remaining protocols by name.
llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),
                     compareObjCProtocolsByName);
8302}

8304/// Determine whether the first type is a subtype of the second.
8305static bool canAssignObjCObjectTypes(ASTContext &ctx, QualType lhs,
                                   QualType rhs) {
// Common case: two object pointers.
const auto *lhsOPT = lhs->getAs<ObjCObjectPointerType>();
const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
if (lhsOPT && rhsOPT)
  return ctx.canAssignObjCInterfaces(lhsOPT, rhsOPT);

// Two block pointers.
const auto *lhsBlock = lhs->getAs<BlockPointerType>();
const auto *rhsBlock = rhs->getAs<BlockPointerType>();
if (lhsBlock && rhsBlock)
  return ctx.typesAreBlockPointerCompatible(lhs, rhs);

// If either is an unqualified 'id' and the other is a block, it's
// acceptable.
if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
    (rhsOPT && rhsOPT->isObjCIdType() && lhsBlock))
  return true;

return false;
8326}

8328// Check that the given Objective-C type argument lists are equivalent.
8329static bool sameObjCTypeArgs(ASTContext &ctx,
                           const ObjCInterfaceDecl *iface,
                           ArrayRef<QualType> lhsArgs,
                           ArrayRef<QualType> rhsArgs,
                           bool stripKindOf) {
if (lhsArgs.size() != rhsArgs.size())
  return false;

ObjCTypeParamList *typeParams = iface->getTypeParamList();
for (unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
  if (ctx.hasSameType(lhsArgs[i], rhsArgs[i]))
    continue;

  switch (typeParams->begin()[i]->getVariance()) {
  case ObjCTypeParamVariance::Invariant:
    if (!stripKindOf ||
        !ctx.hasSameType(lhsArgs[i].stripObjCKindOfType(ctx),
                         rhsArgs[i].stripObjCKindOfType(ctx))) {
      return false;
    }
    break;

  case ObjCTypeParamVariance::Covariant:
    if (!canAssignObjCObjectTypes(ctx, lhsArgs[i], rhsArgs[i]))
      return false;
    break;

  case ObjCTypeParamVariance::Contravariant:
    if (!canAssignObjCObjectTypes(ctx, rhsArgs[i], lhsArgs[i]))
      return false;
    break;
  }
}

return true;
8364}

8366QualType ASTContext::areCommonBaseCompatible(
         const ObjCObjectPointerType *Lptr,
         const ObjCObjectPointerType *Rptr) {
const ObjCObjectType *LHS = Lptr->getObjectType();
const ObjCObjectType *RHS = Rptr->getObjectType();
const ObjCInterfaceDecl* LDecl = LHS->getInterface();
const ObjCInterfaceDecl* RDecl = RHS->getInterface();

if (!LDecl || !RDecl)
  return {};

// When either LHS or RHS is a kindof type, we should return a kindof type.
// For example, for common base of kindof(ASub1) and kindof(ASub2), we return
// kindof(A).
bool anyKindOf = LHS->isKindOfType() || RHS->isKindOfType();

// Follow the left-hand side up the class hierarchy until we either hit a
// root or find the RHS. Record the ancestors in case we don't find it.
llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
  LHSAncestors;
while (true) {
  // Record this ancestor. We'll need this if the common type isn't in the
  // path from the LHS to the root.
  LHSAncestors[LHS->getInterface()->getCanonicalDecl()] = LHS;

  if (declaresSameEntity(LHS->getInterface(), RDecl)) {
    // Get the type arguments.
    ArrayRef<QualType> LHSTypeArgs = LHS->getTypeArgsAsWritten();
    bool anyChanges = false;
    if (LHS->isSpecialized() && RHS->isSpecialized()) {
      // Both have type arguments, compare them.
      if (!sameObjCTypeArgs(*this, LHS->getInterface(),
                            LHS->getTypeArgs(), RHS->getTypeArgs(),
                            /*stripKindOf=*/true))
        return {};
    } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
      // If only one has type arguments, the result will not have type
      // arguments.
      LHSTypeArgs = {};
      anyChanges = true;
    }

    // Compute the intersection of protocols.
    SmallVector<ObjCProtocolDecl *, 8> Protocols;
    getIntersectionOfProtocols(*this, LHS->getInterface(), Lptr, Rptr,
                               Protocols);
    if (!Protocols.empty())
      anyChanges = true;

    // If anything in the LHS will have changed, build a new result type.
    // If we need to return a kindof type but LHS is not a kindof type, we
    // build a new result type.
    if (anyChanges || LHS->isKindOfType() != anyKindOf) {
      QualType Result = getObjCInterfaceType(LHS->getInterface());
      Result = getObjCObjectType(Result, LHSTypeArgs, Protocols,
                                 anyKindOf || LHS->isKindOfType());
      return getObjCObjectPointerType(Result);
    }

    return getObjCObjectPointerType(QualType(LHS, 0));
  }

  // Find the superclass.
  QualType LHSSuperType = LHS->getSuperClassType();
  if (LHSSuperType.isNull())
    break;

  LHS = LHSSuperType->castAs<ObjCObjectType>();
}

// We didn't find anything by following the LHS to its root; now check
// the RHS against the cached set of ancestors.
while (true) {
  auto KnownLHS = LHSAncestors.find(RHS->getInterface()->getCanonicalDecl());
  if (KnownLHS != LHSAncestors.end()) {
    LHS = KnownLHS->second;

    // Get the type arguments.
    ArrayRef<QualType> RHSTypeArgs = RHS->getTypeArgsAsWritten();
    bool anyChanges = false;
    if (LHS->isSpecialized() && RHS->isSpecialized()) {
      // Both have type arguments, compare them.
      if (!sameObjCTypeArgs(*this, LHS->getInterface(),
                            LHS->getTypeArgs(), RHS->getTypeArgs(),
                            /*stripKindOf=*/true))
        return {};
    } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
      // If only one has type arguments, the result will not have type
      // arguments.
      RHSTypeArgs = {};
      anyChanges = true;
    }

    // Compute the intersection of protocols.
    SmallVector<ObjCProtocolDecl *, 8> Protocols;
    getIntersectionOfProtocols(*this, RHS->getInterface(), Lptr, Rptr,
                               Protocols);
    if (!Protocols.empty())
      anyChanges = true;

    // If we need to return a kindof type but RHS is not a kindof type, we
    // build a new result type.
    if (anyChanges || RHS->isKindOfType() != anyKindOf) {
      QualType Result = getObjCInterfaceType(RHS->getInterface());
      Result = getObjCObjectType(Result, RHSTypeArgs, Protocols,
                                 anyKindOf || RHS->isKindOfType());
      return getObjCObjectPointerType(Result);
    }

    return getObjCObjectPointerType(QualType(RHS, 0));
  }

  // Find the superclass of the RHS.
  QualType RHSSuperType = RHS->getSuperClassType();
  if (RHSSuperType.isNull())
    break;

  RHS = RHSSuperType->castAs<ObjCObjectType>();
}

return {};
8487}

8489bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS,
                                       const ObjCObjectType *RHS) {
assert(LHS->getInterface() && "LHS is not an interface type")((LHS->getInterface() && "LHS is not an interface type"
) ? static_cast<void> (0) : __assert_fail ("LHS->getInterface() && \"LHS is not an interface type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8491, __PRETTY_FUNCTION__));
assert(RHS->getInterface() && "RHS is not an interface type")((RHS->getInterface() && "RHS is not an interface type"
) ? static_cast<void> (0) : __assert_fail ("RHS->getInterface() && \"RHS is not an interface type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8492, __PRETTY_FUNCTION__));

// Verify that the base decls are compatible: the RHS must be a subclass of
// the LHS.
ObjCInterfaceDecl *LHSInterface = LHS->getInterface();
bool IsSuperClass = LHSInterface->isSuperClassOf(RHS->getInterface());
if (!IsSuperClass)
  return false;

// If the LHS has protocol qualifiers, determine whether all of them are
// satisfied by the RHS (i.e., the RHS has a superset of the protocols in the
// LHS).
if (LHS->getNumProtocols() > 0) {
  // OK if conversion of LHS to SuperClass results in narrowing of types
  // ; i.e., SuperClass may implement at least one of the protocols
  // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok.
  // But not SuperObj<P1,P2,P3> = lhs<P1,P2>.
  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols;
  CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols);
  // Also, if RHS has explicit quelifiers, include them for comparing with LHS's
  // qualifiers.
  for (auto *RHSPI : RHS->quals())
    CollectInheritedProtocols(RHSPI, SuperClassInheritedProtocols);
  // If there is no protocols associated with RHS, it is not a match.
  if (SuperClassInheritedProtocols.empty())
    return false;

  for (const auto *LHSProto : LHS->quals()) {
    bool SuperImplementsProtocol = false;
    for (auto *SuperClassProto : SuperClassInheritedProtocols)
      if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
        SuperImplementsProtocol = true;
        break;
      }
    if (!SuperImplementsProtocol)
      return false;
  }
}

// If the LHS is specialized, we may need to check type arguments.
if (LHS->isSpecialized()) {
  // Follow the superclass chain until we've matched the LHS class in the
  // hierarchy. This substitutes type arguments through.
  const ObjCObjectType *RHSSuper = RHS;
  while (!declaresSameEntity(RHSSuper->getInterface(), LHSInterface))
    RHSSuper = RHSSuper->getSuperClassType()->castAs<ObjCObjectType>();

  // If the RHS is specializd, compare type arguments.
  if (RHSSuper->isSpecialized() &&
      !sameObjCTypeArgs(*this, LHS->getInterface(),
                        LHS->getTypeArgs(), RHSSuper->getTypeArgs(),
                        /*stripKindOf=*/true)) {
    return false;
  }
}

return true;
8549}

8551bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
// get the "pointed to" types
const auto *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
const auto *RHSOPT = RHS->getAs<ObjCObjectPointerType>();

if (!LHSOPT || !RHSOPT)
  return false;

return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
       canAssignObjCInterfaces(RHSOPT, LHSOPT);
8561}

8563bool ASTContext::canBindObjCObjectType(QualType To, QualType From) {
return canAssignObjCInterfaces(
              getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(),
              getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>());
8567}

8569/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
8570/// both shall have the identically qualified version of a compatible type.
8571/// C99 6.2.7p1: Two types have compatible types if their types are the
8572/// same. See 6.7.[2,3,5] for additional rules.
8573bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS,
                                  bool CompareUnqualified) {
if (getLangOpts().CPlusPlus)
  return hasSameType(LHS, RHS);

return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull();
8579}

8581bool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) {
return typesAreCompatible(LHS, RHS);
8583}

8585bool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) {
return !mergeTypes(LHS, RHS, true).isNull();
8587}

8589/// mergeTransparentUnionType - if T is a transparent union type and a member
8590/// of T is compatible with SubType, return the merged type, else return
8591/// QualType()
8592QualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType,
                                             bool OfBlockPointer,
                                             bool Unqualified) {
if (const RecordType *UT = T->getAsUnionType()) {
  RecordDecl *UD = UT->getDecl();
  if (UD->hasAttr<TransparentUnionAttr>()) {
    for (const auto *I : UD->fields()) {
      QualType ET = I->getType().getUnqualifiedType();
      QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified);
      if (!MT.isNull())
        return MT;
    }
  }
}

return {};
8608}

8610/// mergeFunctionParameterTypes - merge two types which appear as function
8611/// parameter types
8612QualType ASTContext::mergeFunctionParameterTypes(QualType lhs, QualType rhs,
                                               bool OfBlockPointer,
                                               bool Unqualified) {
// GNU extension: two types are compatible if they appear as a function
// argument, one of the types is a transparent union type and the other
// type is compatible with a union member
QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer,
                                            Unqualified);
if (!lmerge.isNull())
  return lmerge;

QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer,
                                            Unqualified);
if (!rmerge.isNull())
  return rmerge;

return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified);
8629}

8631QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs,
                                      bool OfBlockPointer,
                                      bool Unqualified) {
const auto *lbase = lhs->getAs<FunctionType>();
const auto *rbase = rhs->getAs<FunctionType>();
const auto *lproto = dyn_cast<FunctionProtoType>(lbase);
const auto *rproto = dyn_cast<FunctionProtoType>(rbase);
bool allLTypes = true;
bool allRTypes = true;

// Check return type
QualType retType;
if (OfBlockPointer) {
  QualType RHS = rbase->getReturnType();
  QualType LHS = lbase->getReturnType();
  bool UnqualifiedResult = Unqualified;
  if (!UnqualifiedResult)
    UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers());
  retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true);
}
else
  retType = mergeTypes(lbase->getReturnType(), rbase->getReturnType(), false,
                       Unqualified);
if (retType.isNull())
  return {};

if (Unqualified)
  retType = retType.getUnqualifiedType();

CanQualType LRetType = getCanonicalType(lbase->getReturnType());
CanQualType RRetType = getCanonicalType(rbase->getReturnType());
if (Unqualified) {
  LRetType = LRetType.getUnqualifiedType();
  RRetType = RRetType.getUnqualifiedType();
}

if (getCanonicalType(retType) != LRetType)
  allLTypes = false;
if (getCanonicalType(retType) != RRetType)
  allRTypes = false;

// FIXME: double check this
// FIXME: should we error if lbase->getRegParmAttr() != 0 &&
//                           rbase->getRegParmAttr() != 0 &&
//                           lbase->getRegParmAttr() != rbase->getRegParmAttr()?
FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo();
FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo();

// Compatible functions must have compatible calling conventions
if (lbaseInfo.getCC() != rbaseInfo.getCC())
  return {};

// Regparm is part of the calling convention.
if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm())
  return {};
if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm())
  return {};

if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult())
  return {};
if (lbaseInfo.getNoCallerSavedRegs() != rbaseInfo.getNoCallerSavedRegs())
  return {};
if (lbaseInfo.getNoCfCheck() != rbaseInfo.getNoCfCheck())
  return {};

// FIXME: some uses, e.g. conditional exprs, really want this to be 'both'.
bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();

if (lbaseInfo.getNoReturn() != NoReturn)
  allLTypes = false;
if (rbaseInfo.getNoReturn() != NoReturn)
  allRTypes = false;

FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn);

if (lproto && rproto) { // two C99 style function prototypes
  assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&((!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec
() && "C++ shouldn't be here") ? static_cast<void>
 (0) : __assert_fail ("!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && \"C++ shouldn't be here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8708, __PRETTY_FUNCTION__))
         "C++ shouldn't be here")((!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec
() && "C++ shouldn't be here") ? static_cast<void>
 (0) : __assert_fail ("!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && \"C++ shouldn't be here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8708, __PRETTY_FUNCTION__));
  // Compatible functions must have the same number of parameters
  if (lproto->getNumParams() != rproto->getNumParams())
    return {};

  // Variadic and non-variadic functions aren't compatible
  if (lproto->isVariadic() != rproto->isVariadic())
    return {};

  if (lproto->getMethodQuals() != rproto->getMethodQuals())
    return {};

  SmallVector<FunctionProtoType::ExtParameterInfo, 4> newParamInfos;
  bool canUseLeft, canUseRight;
  if (!mergeExtParameterInfo(lproto, rproto, canUseLeft, canUseRight,
                             newParamInfos))
    return {};

  if (!canUseLeft)
    allLTypes = false;
  if (!canUseRight)
    allRTypes = false;

  // Check parameter type compatibility
  SmallVector<QualType, 10> types;
  for (unsigned i = 0, n = lproto->getNumParams(); i < n; i++) {
    QualType lParamType = lproto->getParamType(i).getUnqualifiedType();
    QualType rParamType = rproto->getParamType(i).getUnqualifiedType();
    QualType paramType = mergeFunctionParameterTypes(
        lParamType, rParamType, OfBlockPointer, Unqualified);
    if (paramType.isNull())
      return {};

    if (Unqualified)
      paramType = paramType.getUnqualifiedType();

    types.push_back(paramType);
    if (Unqualified) {
      lParamType = lParamType.getUnqualifiedType();
      rParamType = rParamType.getUnqualifiedType();
    }

    if (getCanonicalType(paramType) != getCanonicalType(lParamType))
      allLTypes = false;
    if (getCanonicalType(paramType) != getCanonicalType(rParamType))
      allRTypes = false;
  }

  if (allLTypes) return lhs;
  if (allRTypes) return rhs;

  FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo();
  EPI.ExtInfo = einfo;
  EPI.ExtParameterInfos =
      newParamInfos.empty() ? nullptr : newParamInfos.data();
  return getFunctionType(retType, types, EPI);
}

if (lproto) allRTypes = false;
if (rproto) allLTypes = false;

const FunctionProtoType *proto = lproto ? lproto : rproto;
if (proto) {
  assert(!proto->hasExceptionSpec() && "C++ shouldn't be here")((!proto->hasExceptionSpec() && "C++ shouldn't be here"
) ? static_cast<void> (0) : __assert_fail ("!proto->hasExceptionSpec() && \"C++ shouldn't be here\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8771, __PRETTY_FUNCTION__));
  if (proto->isVariadic())
    return {};
  // Check that the types are compatible with the types that
  // would result from default argument promotions (C99 6.7.5.3p15).
  // The only types actually affected are promotable integer
  // types and floats, which would be passed as a different
  // type depending on whether the prototype is visible.
  for (unsigned i = 0, n = proto->getNumParams(); i < n; ++i) {
    QualType paramTy = proto->getParamType(i);

    // Look at the converted type of enum types, since that is the type used
    // to pass enum values.
    if (const auto *Enum = paramTy->getAs<EnumType>()) {
      paramTy = Enum->getDecl()->getIntegerType();
      if (paramTy.isNull())
        return {};
    }

    if (paramTy->isPromotableIntegerType() ||
        getCanonicalType(paramTy).getUnqualifiedType() == FloatTy)
      return {};
  }

  if (allLTypes) return lhs;
  if (allRTypes) return rhs;

  FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo();
  EPI.ExtInfo = einfo;
  return getFunctionType(retType, proto->getParamTypes(), EPI);
}

if (allLTypes) return lhs;
if (allRTypes) return rhs;
return getFunctionNoProtoType(retType, einfo);
8806}

8808/// Given that we have an enum type and a non-enum type, try to merge them.
8809static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET,
                                   QualType other, bool isBlockReturnType) {
// C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
// a signed integer type, or an unsigned integer type.
// Compatibility is based on the underlying type, not the promotion
// type.
QualType underlyingType = ET->getDecl()->getIntegerType();
if (underlyingType.isNull())
  return {};
if (Context.hasSameType(underlyingType, other))
  return other;

// In block return types, we're more permissive and accept any
// integral type of the same size.
if (isBlockReturnType && other->isIntegerType() &&
    Context.getTypeSize(underlyingType) == Context.getTypeSize(other))
  return other;

return {};
8828}

8830QualType ASTContext::mergeTypes(QualType LHS, QualType RHS,
                              bool OfBlockPointer,
                              bool Unqualified, bool BlockReturnType) {
// C++ [expr]: If an expression initially has the type "reference to T", the
// type is adjusted to "T" prior to any further analysis, the expression
// designates the object or function denoted by the reference, and the
// expression is an lvalue unless the reference is an rvalue reference and
// the expression is a function call (possibly inside parentheses).
assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?")((!LHS->getAs<ReferenceType>() && "LHS is a reference type?"
) ? static_cast<void> (0) : __assert_fail ("!LHS->getAs<ReferenceType>() && \"LHS is a reference type?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8838, __PRETTY_FUNCTION__));
1
Assuming the object is not a 'ReferenceType'→
2
←
'?' condition is true→
assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?")((!RHS->getAs<ReferenceType>() && "RHS is a reference type?"
) ? static_cast<void> (0) : __assert_fail ("!RHS->getAs<ReferenceType>() && \"RHS is a reference type?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8839, __PRETTY_FUNCTION__));
3
←
Assuming the object is not a 'ReferenceType'→
4
←
'?' condition is true→

if (Unqualified) {
5
←
Assuming 'Unqualified' is false→
6
←
Taking false branch→
  LHS = LHS.getUnqualifiedType();
  RHS = RHS.getUnqualifiedType();
}

QualType LHSCan = getCanonicalType(LHS),
         RHSCan = getCanonicalType(RHS);

// If two types are identical, they are compatible.
if (LHSCan == RHSCan)
7
←
Calling 'operator=='→
13
←
Returning from 'operator=='→
14
←
Taking false branch→
  return LHS;

// If the qualifiers are different, the types aren't compatible... mostly.
Qualifiers LQuals = LHSCan.getLocalQualifiers();
Qualifiers RQuals = RHSCan.getLocalQualifiers();
if (LQuals != RQuals) {
15
←
Calling 'Qualifiers::operator!='→
18
←
Returning from 'Qualifiers::operator!='→
19
←
Taking false branch→
  // If any of these qualifiers are different, we have a type
  // mismatch.
  if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
      LQuals.getAddressSpace() != RQuals.getAddressSpace() ||
      LQuals.getObjCLifetime() != RQuals.getObjCLifetime() ||
      LQuals.hasUnaligned() != RQuals.hasUnaligned())
    return {};

  // Exactly one GC qualifier difference is allowed: __strong is
  // okay if the other type has no GC qualifier but is an Objective
  // C object pointer (i.e. implicitly strong by default).  We fix
  // this by pretending that the unqualified type was actually
  // qualified __strong.
  Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
  Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
  assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements")(((GC_L != GC_R) && "unequal qualifier sets had only equal elements"
) ? static_cast<void> (0) : __assert_fail ("(GC_L != GC_R) && \"unequal qualifier sets had only equal elements\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8872, __PRETTY_FUNCTION__));

  if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
    return {};

  if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) {
    return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong));
  }
  if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) {
    return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS);
  }
  return {};
}

// Okay, qualifiers are equal.

Type::TypeClass LHSClass = LHSCan->getTypeClass();
Type::TypeClass RHSClass = RHSCan->getTypeClass();

// We want to consider the two function types to be the same for these
// comparisons, just force one to the other.
if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
20
←
Assuming 'LHSClass' is not equal to FunctionProto→
21
←
Taking false branch→
if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
22
←
Assuming 'RHSClass' is not equal to FunctionProto→
23
←
Taking false branch→

// Same as above for arrays
if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
24
←
Assuming 'LHSClass' is not equal to VariableArray→
25
←
Assuming 'LHSClass' is not equal to IncompleteArray→
26
←
Taking false branch→
  LHSClass = Type::ConstantArray;
if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
27
←
Assuming 'RHSClass' is not equal to VariableArray→
28
←
Assuming 'RHSClass' is not equal to IncompleteArray→
29
←
Taking false branch→
  RHSClass = Type::ConstantArray;

// ObjCInterfaces are just specialized ObjCObjects.
if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
30
←
Assuming 'LHSClass' is not equal to ObjCInterface→
31
←
Taking false branch→
if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
32
←
Assuming 'RHSClass' is not equal to ObjCInterface→
33
←
Taking false branch→

// Canonicalize ExtVector -> Vector.
if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
34
←
Assuming 'LHSClass' is not equal to ExtVector→
35
←
Taking false branch→
if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
36
←
Assuming 'RHSClass' is not equal to ExtVector→
37
←
Taking false branch→

// If the canonical type classes don't match.
if (LHSClass != RHSClass) {
38
←
Assuming 'LHSClass' is equal to 'RHSClass'→
39
←
Taking false branch→
  // Note that we only have special rules for turning block enum
  // returns into block int returns, not vice-versa.
  if (const auto *ETy = LHS->getAs<EnumType>()) {
    return mergeEnumWithInteger(*this, ETy, RHS, false);
  }
  if (const EnumType* ETy = RHS->getAs<EnumType>()) {
    return mergeEnumWithInteger(*this, ETy, LHS, BlockReturnType);
  }
  // allow block pointer type to match an 'id' type.
  if (OfBlockPointer && !BlockReturnType) {
     if (LHS->isObjCIdType() && RHS->isBlockPointerType())
       return LHS;
    if (RHS->isObjCIdType() && LHS->isBlockPointerType())
      return RHS;
  }

  return {};
}

// The canonical type classes match.
switch (LHSClass) {
40
←
Control jumps to 'case ObjCObjectPointer:'  at line 9132→
8933#define TYPE(Class, Base)
8934#define ABSTRACT_TYPE(Class, Base)
8935#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
8936#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
8937#define DEPENDENT_TYPE(Class, Base) case Type::Class:
8938#include "clang/AST/TypeNodes.inc"
  llvm_unreachable("Non-canonical and dependent types shouldn't get here")::llvm::llvm_unreachable_internal("Non-canonical and dependent types shouldn't get here"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8939);

case Type::Auto:
case Type::DeducedTemplateSpecialization:
case Type::LValueReference:
case Type::RValueReference:
case Type::MemberPointer:
  llvm_unreachable("C++ should never be in mergeTypes")::llvm::llvm_unreachable_internal("C++ should never be in mergeTypes"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8946);

case Type::ObjCInterface:
case Type::IncompleteArray:
case Type::VariableArray:
case Type::FunctionProto:
case Type::ExtVector:
  llvm_unreachable("Types are eliminated above")::llvm::llvm_unreachable_internal("Types are eliminated above"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 8953);

case Type::Pointer:
{
  // Merge two pointer types, while trying to preserve typedef info
  QualType LHSPointee = LHS->castAs<PointerType>()->getPointeeType();
  QualType RHSPointee = RHS->castAs<PointerType>()->getPointeeType();
  if (Unqualified) {
    LHSPointee = LHSPointee.getUnqualifiedType();
    RHSPointee = RHSPointee.getUnqualifiedType();
  }
  QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false,
                                   Unqualified);
  if (ResultType.isNull())
    return {};
  if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
    return LHS;
  if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
    return RHS;
  return getPointerType(ResultType);
}
case Type::BlockPointer:
{
  // Merge two block pointer types, while trying to preserve typedef info
  QualType LHSPointee = LHS->castAs<BlockPointerType>()->getPointeeType();
  QualType RHSPointee = RHS->castAs<BlockPointerType>()->getPointeeType();
  if (Unqualified) {
    LHSPointee = LHSPointee.getUnqualifiedType();
    RHSPointee = RHSPointee.getUnqualifiedType();
  }
  if (getLangOpts().OpenCL) {
    Qualifiers LHSPteeQual = LHSPointee.getQualifiers();
    Qualifiers RHSPteeQual = RHSPointee.getQualifiers();
    // Blocks can't be an expression in a ternary operator (OpenCL v2.0
    // 6.12.5) thus the following check is asymmetric.
    if (!LHSPteeQual.isAddressSpaceSupersetOf(RHSPteeQual))
      return {};
    LHSPteeQual.removeAddressSpace();
    RHSPteeQual.removeAddressSpace();
    LHSPointee =
        QualType(LHSPointee.getTypePtr(), LHSPteeQual.getAsOpaqueValue());
    RHSPointee =
        QualType(RHSPointee.getTypePtr(), RHSPteeQual.getAsOpaqueValue());
  }
  QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer,
                                   Unqualified);
  if (ResultType.isNull())
    return {};
  if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
    return LHS;
  if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
    return RHS;
  return getBlockPointerType(ResultType);
}
case Type::Atomic:
{
  // Merge two pointer types, while trying to preserve typedef info
  QualType LHSValue = LHS->castAs<AtomicType>()->getValueType();
  QualType RHSValue = RHS->castAs<AtomicType>()->getValueType();
  if (Unqualified) {
    LHSValue = LHSValue.getUnqualifiedType();
    RHSValue = RHSValue.getUnqualifiedType();
  }
  QualType ResultType = mergeTypes(LHSValue, RHSValue, false,
                                   Unqualified);
  if (ResultType.isNull())
    return {};
  if (getCanonicalType(LHSValue) == getCanonicalType(ResultType))
    return LHS;
  if (getCanonicalType(RHSValue) == getCanonicalType(ResultType))
    return RHS;
  return getAtomicType(ResultType);
}
case Type::ConstantArray:
{
  const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
  const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
  if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
    return {};

  QualType LHSElem = getAsArrayType(LHS)->getElementType();
  QualType RHSElem = getAsArrayType(RHS)->getElementType();
  if (Unqualified) {
    LHSElem = LHSElem.getUnqualifiedType();
    RHSElem = RHSElem.getUnqualifiedType();
  }

  QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified);
  if (ResultType.isNull())
    return {};

  const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
  const VariableArrayType* RVAT = getAsVariableArrayType(RHS);

  // If either side is a variable array, and both are complete, check whether
  // the current dimension is definite.
  if (LVAT || RVAT) {
    auto SizeFetch = [this](const VariableArrayType* VAT,
        const ConstantArrayType* CAT)
        -> std::pair<bool,llvm::APInt> {
      if (VAT) {
        llvm::APSInt TheInt;
        Expr *E = VAT->getSizeExpr();
        if (E && E->isIntegerConstantExpr(TheInt, *this))
          return std::make_pair(true, TheInt);
        else
          return std::make_pair(false, TheInt);
      } else if (CAT) {
          return std::make_pair(true, CAT->getSize());
      } else {
          return std::make_pair(false, llvm::APInt());
      }
    };

    bool HaveLSize, HaveRSize;
    llvm::APInt LSize, RSize;
    std::tie(HaveLSize, LSize) = SizeFetch(LVAT, LCAT);
    std::tie(HaveRSize, RSize) = SizeFetch(RVAT, RCAT);
    if (HaveLSize && HaveRSize && !llvm::APInt::isSameValue(LSize, RSize))
      return {}; // Definite, but unequal, array dimension
  }

  if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
    return LHS;
  if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
    return RHS;
  if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
                                        ArrayType::ArraySizeModifier(), 0);
  if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
                                        ArrayType::ArraySizeModifier(), 0);
  if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
    return LHS;
  if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
    return RHS;
  if (LVAT) {
    // FIXME: This isn't correct! But tricky to implement because
    // the array's size has to be the size of LHS, but the type
    // has to be different.
    return LHS;
  }
  if (RVAT) {
    // FIXME: This isn't correct! But tricky to implement because
    // the array's size has to be the size of RHS, but the type
    // has to be different.
    return RHS;
  }
  if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
  if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
  return getIncompleteArrayType(ResultType,
                                ArrayType::ArraySizeModifier(), 0);
}
case Type::FunctionNoProto:
  return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified);
case Type::Record:
case Type::Enum:
  return {};
case Type::Builtin:
  // Only exactly equal builtin types are compatible, which is tested above.
  return {};
case Type::Complex:
  // Distinct complex types are incompatible.
  return {};
case Type::Vector:
  // FIXME: The merged type should be an ExtVector!
  if (areCompatVectorTypes(LHSCan->getAs<VectorType>(),
                           RHSCan->getAs<VectorType>()))
    return LHS;
  return {};
case Type::ObjCObject: {
  // Check if the types are assignment compatible.
  // FIXME: This should be type compatibility, e.g. whether
  // "LHS x; RHS x;" at global scope is legal.
  const auto *LHSIface = LHS->getAs<ObjCObjectType>();
  const auto *RHSIface = RHS->getAs<ObjCObjectType>();
  if (canAssignObjCInterfaces(LHSIface, RHSIface))
    return LHS;

  return {};
}
case Type::ObjCObjectPointer:
  if (OfBlockPointer) {
41
←
Assuming 'OfBlockPointer' is true→
42
←
Taking true branch→
    if (canAssignObjCInterfacesInBlockPointer(
46
←
Calling 'ASTContext::canAssignObjCInterfacesInBlockPointer'→
                                        LHS->getAs<ObjCObjectPointerType>(),
43
←
Assuming the object is not a 'ObjCObjectPointerType'→
                                        RHS->getAs<ObjCObjectPointerType>(),
44
←
Assuming the object is not a 'ObjCObjectPointerType'→
45
←
Passing null pointer value via 2nd parameter 'RHSOPT'→
                                        BlockReturnType))
      return LHS;
    return {};
  }
  if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(),
                              RHS->getAs<ObjCObjectPointerType>()))
    return LHS;

  return {};
case Type::Pipe:
  assert(LHS != RHS &&((LHS != RHS && "Equivalent pipe types should have already been handled!"
) ? static_cast<void> (0) : __assert_fail ("LHS != RHS && \"Equivalent pipe types should have already been handled!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9148, __PRETTY_FUNCTION__))
         "Equivalent pipe types should have already been handled!")((LHS != RHS && "Equivalent pipe types should have already been handled!"
) ? static_cast<void> (0) : __assert_fail ("LHS != RHS && \"Equivalent pipe types should have already been handled!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9148, __PRETTY_FUNCTION__));
  return {};
}

llvm_unreachable("Invalid Type::Class!")::llvm::llvm_unreachable_internal("Invalid Type::Class!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9152);
9153}

9155bool ASTContext::mergeExtParameterInfo(
  const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType,
  bool &CanUseFirst, bool &CanUseSecond,
  SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &NewParamInfos) {
assert(NewParamInfos.empty() && "param info list not empty")((NewParamInfos.empty() && "param info list not empty"
) ? static_cast<void> (0) : __assert_fail ("NewParamInfos.empty() && \"param info list not empty\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9159, __PRETTY_FUNCTION__));
CanUseFirst = CanUseSecond = true;
bool FirstHasInfo = FirstFnType->hasExtParameterInfos();
bool SecondHasInfo = SecondFnType->hasExtParameterInfos();

// Fast path: if the first type doesn't have ext parameter infos,
// we match if and only if the second type also doesn't have them.
if (!FirstHasInfo && !SecondHasInfo)
  return true;

bool NeedParamInfo = false;
size_t E = FirstHasInfo ? FirstFnType->getExtParameterInfos().size()
                        : SecondFnType->getExtParameterInfos().size();

for (size_t I = 0; I < E; ++I) {
  FunctionProtoType::ExtParameterInfo FirstParam, SecondParam;
  if (FirstHasInfo)
    FirstParam = FirstFnType->getExtParameterInfo(I);
  if (SecondHasInfo)
    SecondParam = SecondFnType->getExtParameterInfo(I);

  // Cannot merge unless everything except the noescape flag matches.
  if (FirstParam.withIsNoEscape(false) != SecondParam.withIsNoEscape(false))
    return false;

  bool FirstNoEscape = FirstParam.isNoEscape();
  bool SecondNoEscape = SecondParam.isNoEscape();
  bool IsNoEscape = FirstNoEscape && SecondNoEscape;
  NewParamInfos.push_back(FirstParam.withIsNoEscape(IsNoEscape));
  if (NewParamInfos.back().getOpaqueValue())
    NeedParamInfo = true;
  if (FirstNoEscape != IsNoEscape)
    CanUseFirst = false;
  if (SecondNoEscape != IsNoEscape)
    CanUseSecond = false;
}

if (!NeedParamInfo)
  NewParamInfos.clear();

return true;
9200}

9202void ASTContext::ResetObjCLayout(const ObjCContainerDecl *CD) {
ObjCLayouts[CD] = nullptr;
9204}

9206/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and
9207/// 'RHS' attributes and returns the merged version; including for function
9208/// return types.
9209QualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) {
QualType LHSCan = getCanonicalType(LHS),
RHSCan = getCanonicalType(RHS);
// If two types are identical, they are compatible.
if (LHSCan == RHSCan)
  return LHS;
if (RHSCan->isFunctionType()) {
  if (!LHSCan->isFunctionType())
    return {};
  QualType OldReturnType =
      cast<FunctionType>(RHSCan.getTypePtr())->getReturnType();
  QualType NewReturnType =
      cast<FunctionType>(LHSCan.getTypePtr())->getReturnType();
  QualType ResReturnType =
    mergeObjCGCQualifiers(NewReturnType, OldReturnType);
  if (ResReturnType.isNull())
    return {};
  if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
    // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo();
    // In either case, use OldReturnType to build the new function type.
    const auto *F = LHS->getAs<FunctionType>();
    if (const auto *FPT = cast<FunctionProtoType>(F)) {
      FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
      EPI.ExtInfo = getFunctionExtInfo(LHS);
      QualType ResultType =
          getFunctionType(OldReturnType, FPT->getParamTypes(), EPI);
      return ResultType;
    }
  }
  return {};
}

// If the qualifiers are different, the types can still be merged.
Qualifiers LQuals = LHSCan.getLocalQualifiers();
Qualifiers RQuals = RHSCan.getLocalQualifiers();
if (LQuals != RQuals) {
  // If any of these qualifiers are different, we have a type mismatch.
  if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
      LQuals.getAddressSpace() != RQuals.getAddressSpace())
    return {};

  // Exactly one GC qualifier difference is allowed: __strong is
  // okay if the other type has no GC qualifier but is an Objective
  // C object pointer (i.e. implicitly strong by default).  We fix
  // this by pretending that the unqualified type was actually
  // qualified __strong.
  Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
  Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
  assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements")(((GC_L != GC_R) && "unequal qualifier sets had only equal elements"
) ? static_cast<void> (0) : __assert_fail ("(GC_L != GC_R) && \"unequal qualifier sets had only equal elements\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9257, __PRETTY_FUNCTION__));

  if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
    return {};

  if (GC_L == Qualifiers::Strong)
    return LHS;
  if (GC_R == Qualifiers::Strong)
    return RHS;
  return {};
}

if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) {
  QualType LHSBaseQT = LHS->castAs<ObjCObjectPointerType>()->getPointeeType();
  QualType RHSBaseQT = RHS->castAs<ObjCObjectPointerType>()->getPointeeType();
  QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT);
  if (ResQT == LHSBaseQT)
    return LHS;
  if (ResQT == RHSBaseQT)
    return RHS;
}
return {};
9279}

9281//===----------------------------------------------------------------------===//
9282//                         Integer Predicates
9283//===----------------------------------------------------------------------===//

9285unsigned ASTContext::getIntWidth(QualType T) const {
if (const auto *ET = T->getAs<EnumType>())
  T = ET->getDecl()->getIntegerType();
if (T->isBooleanType())
  return 1;
// For builtin types, just use the standard type sizing method
return (unsigned)getTypeSize(T);
9292}

9294QualType ASTContext::getCorrespondingUnsignedType(QualType T) const {
assert((T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) &&(((T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType
()) && "Unexpected type") ? static_cast<void> (
0) : __assert_fail ("(T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) && \"Unexpected type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9296, __PRETTY_FUNCTION__))
       "Unexpected type")(((T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType
()) && "Unexpected type") ? static_cast<void> (
0) : __assert_fail ("(T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) && \"Unexpected type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9296, __PRETTY_FUNCTION__));

// Turn <4 x signed int> -> <4 x unsigned int>
if (const auto *VTy = T->getAs<VectorType>())
  return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
                       VTy->getNumElements(), VTy->getVectorKind());

// For enums, we return the unsigned version of the base type.
if (const auto *ETy = T->getAs<EnumType>())
  T = ETy->getDecl()->getIntegerType();

const auto *BTy = T->getAs<BuiltinType>();
assert(BTy && "Unexpected signed integer or fixed point type")((BTy && "Unexpected signed integer or fixed point type"
) ? static_cast<void> (0) : __assert_fail ("BTy && \"Unexpected signed integer or fixed point type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9308, __PRETTY_FUNCTION__));
switch (BTy->getKind()) {
case BuiltinType::Char_S:
case BuiltinType::SChar:
  return UnsignedCharTy;
case BuiltinType::Short:
  return UnsignedShortTy;
case BuiltinType::Int:
  return UnsignedIntTy;
case BuiltinType::Long:
  return UnsignedLongTy;
case BuiltinType::LongLong:
  return UnsignedLongLongTy;
case BuiltinType::Int128:
  return UnsignedInt128Ty;

case BuiltinType::ShortAccum:
  return UnsignedShortAccumTy;
case BuiltinType::Accum:
  return UnsignedAccumTy;
case BuiltinType::LongAccum:
  return UnsignedLongAccumTy;
case BuiltinType::SatShortAccum:
  return SatUnsignedShortAccumTy;
case BuiltinType::SatAccum:
  return SatUnsignedAccumTy;
case BuiltinType::SatLongAccum:
  return SatUnsignedLongAccumTy;
case BuiltinType::ShortFract:
  return UnsignedShortFractTy;
case BuiltinType::Fract:
  return UnsignedFractTy;
case BuiltinType::LongFract:
  return UnsignedLongFractTy;
case BuiltinType::SatShortFract:
  return SatUnsignedShortFractTy;
case BuiltinType::SatFract:
  return SatUnsignedFractTy;
case BuiltinType::SatLongFract:
  return SatUnsignedLongFractTy;
default:
  llvm_unreachable("Unexpected signed integer or fixed point type")::llvm::llvm_unreachable_internal("Unexpected signed integer or fixed point type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9349);
}
9351}

9353ASTMutationListener::~ASTMutationListener() = default;

9355void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
                                          QualType ReturnType) {}

9358//===----------------------------------------------------------------------===//
9359//                          Builtin Type Computation
9360//===----------------------------------------------------------------------===//

9362/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
9363/// pointer over the consumed characters.  This returns the resultant type.  If
9364/// AllowTypeModifiers is false then modifier like * are not parsed, just basic
9365/// types.  This allows "v2i*" to be parsed as a pointer to a v2i instead of
9366/// a vector of "i*".
9367///
9368/// RequiresICE is filled in on return to indicate whether the value is required
9369/// to be an Integer Constant Expression.
9370static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
                                ASTContext::GetBuiltinTypeError &Error,
                                bool &RequiresICE,
                                bool AllowTypeModifiers) {
// Modifiers.
int HowLong = 0;
bool Signed = false, Unsigned = false;
RequiresICE = false;

// Read the prefixed modifiers first.
bool Done = false;
#ifndef NDEBUG
bool IsSpecial = false;
#endif
while (!Done) {
  switch (*Str++) {
  default: Done = true; --Str; break;
  case 'I':
    RequiresICE = true;
    break;
  case 'S':
    assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!")((!Unsigned && "Can't use both 'S' and 'U' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!Unsigned && \"Can't use both 'S' and 'U' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9391, __PRETTY_FUNCTION__));
    assert(!Signed && "Can't use 'S' modifier multiple times!")((!Signed && "Can't use 'S' modifier multiple times!"
) ? static_cast<void> (0) : __assert_fail ("!Signed && \"Can't use 'S' modifier multiple times!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9392, __PRETTY_FUNCTION__));
    Signed = true;
    break;
  case 'U':
    assert(!Signed && "Can't use both 'S' and 'U' modifiers!")((!Signed && "Can't use both 'S' and 'U' modifiers!")
 ? static_cast<void> (0) : __assert_fail ("!Signed && \"Can't use both 'S' and 'U' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9396, __PRETTY_FUNCTION__));
    assert(!Unsigned && "Can't use 'U' modifier multiple times!")((!Unsigned && "Can't use 'U' modifier multiple times!"
) ? static_cast<void> (0) : __assert_fail ("!Unsigned && \"Can't use 'U' modifier multiple times!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9397, __PRETTY_FUNCTION__));
    Unsigned = true;
    break;
  case 'L':
    assert(!IsSpecial && "Can't use 'L' with 'W', 'N', 'Z' or 'O' modifiers")((!IsSpecial && "Can't use 'L' with 'W', 'N', 'Z' or 'O' modifiers"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecial && \"Can't use 'L' with 'W', 'N', 'Z' or 'O' modifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9401, __PRETTY_FUNCTION__));
    assert(HowLong <= 2 && "Can't have LLLL modifier")((HowLong <= 2 && "Can't have LLLL modifier") ? static_cast
<void> (0) : __assert_fail ("HowLong <= 2 && \"Can't have LLLL modifier\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9402, __PRETTY_FUNCTION__));
    ++HowLong;
    break;
  case 'N':
    // 'N' behaves like 'L' for all non LP64 targets and 'int' otherwise.
    assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!")((!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecial && \"Can't use two 'N', 'W', 'Z' or 'O' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9407, __PRETTY_FUNCTION__));
    assert(HowLong == 0 && "Can't use both 'L' and 'N' modifiers!")((HowLong == 0 && "Can't use both 'L' and 'N' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("HowLong == 0 && \"Can't use both 'L' and 'N' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9408, __PRETTY_FUNCTION__));
    #ifndef NDEBUG
    IsSpecial = true;
    #endif
    if (Context.getTargetInfo().getLongWidth() == 32)
      ++HowLong;
    break;
  case 'W':
    // This modifier represents int64 type.
    assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!")((!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecial && \"Can't use two 'N', 'W', 'Z' or 'O' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9417, __PRETTY_FUNCTION__));
    assert(HowLong == 0 && "Can't use both 'L' and 'W' modifiers!")((HowLong == 0 && "Can't use both 'L' and 'W' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("HowLong == 0 && \"Can't use both 'L' and 'W' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9418, __PRETTY_FUNCTION__));
    #ifndef NDEBUG
    IsSpecial = true;
    #endif
    switch (Context.getTargetInfo().getInt64Type()) {
    default:
      llvm_unreachable("Unexpected integer type")::llvm::llvm_unreachable_internal("Unexpected integer type", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9424);
    case TargetInfo::SignedLong:
      HowLong = 1;
      break;
    case TargetInfo::SignedLongLong:
      HowLong = 2;
      break;
    }
    break;
  case 'Z':
    // This modifier represents int32 type.
    assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!")((!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecial && \"Can't use two 'N', 'W', 'Z' or 'O' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9435, __PRETTY_FUNCTION__));
    assert(HowLong == 0 && "Can't use both 'L' and 'Z' modifiers!")((HowLong == 0 && "Can't use both 'L' and 'Z' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("HowLong == 0 && \"Can't use both 'L' and 'Z' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9436, __PRETTY_FUNCTION__));
    #ifndef NDEBUG
    IsSpecial = true;
    #endif
    switch (Context.getTargetInfo().getIntTypeByWidth(32, true)) {
    default:
      llvm_unreachable("Unexpected integer type")::llvm::llvm_unreachable_internal("Unexpected integer type", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9442);
    case TargetInfo::SignedInt:
      HowLong = 0;
      break;
    case TargetInfo::SignedLong:
      HowLong = 1;
      break;
    case TargetInfo::SignedLongLong:
      HowLong = 2;
      break;
    }
    break;
  case 'O':
    assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!")((!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecial && \"Can't use two 'N', 'W', 'Z' or 'O' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9455, __PRETTY_FUNCTION__));
    assert(HowLong == 0 && "Can't use both 'L' and 'O' modifiers!")((HowLong == 0 && "Can't use both 'L' and 'O' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("HowLong == 0 && \"Can't use both 'L' and 'O' modifiers!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9456, __PRETTY_FUNCTION__));
    #ifndef NDEBUG
    IsSpecial = true;
    #endif
    if (Context.getLangOpts().OpenCL)
      HowLong = 1;
    else
      HowLong = 2;
    break;
  }
}

QualType Type;

// Read the base type.
switch (*Str++) {
default: llvm_unreachable("Unknown builtin type letter!")::llvm::llvm_unreachable_internal("Unknown builtin type letter!"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9472);
case 'v':
  assert(HowLong == 0 && !Signed && !Unsigned &&((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers used with 'v'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'v'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9475, __PRETTY_FUNCTION__))
         "Bad modifiers used with 'v'!")((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers used with 'v'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'v'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9475, __PRETTY_FUNCTION__));
  Type = Context.VoidTy;
  break;
case 'h':
  assert(HowLong == 0 && !Signed && !Unsigned &&((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers used with 'h'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'h'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9480, __PRETTY_FUNCTION__))
         "Bad modifiers used with 'h'!")((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers used with 'h'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'h'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9480, __PRETTY_FUNCTION__));
  Type = Context.HalfTy;
  break;
case 'f':
  assert(HowLong == 0 && !Signed && !Unsigned &&((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers used with 'f'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'f'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9485, __PRETTY_FUNCTION__))
         "Bad modifiers used with 'f'!")((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers used with 'f'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'f'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9485, __PRETTY_FUNCTION__));
  Type = Context.FloatTy;
  break;
case 'd':
  assert(HowLong < 3 && !Signed && !Unsigned &&((HowLong < 3 && !Signed && !Unsigned &&
 "Bad modifiers used with 'd'!") ? static_cast<void> (0
) : __assert_fail ("HowLong < 3 && !Signed && !Unsigned && \"Bad modifiers used with 'd'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9490, __PRETTY_FUNCTION__))
         "Bad modifiers used with 'd'!")((HowLong < 3 && !Signed && !Unsigned &&
 "Bad modifiers used with 'd'!") ? static_cast<void> (0
) : __assert_fail ("HowLong < 3 && !Signed && !Unsigned && \"Bad modifiers used with 'd'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9490, __PRETTY_FUNCTION__));
  if (HowLong == 1)
    Type = Context.LongDoubleTy;
  else if (HowLong == 2)
    Type = Context.Float128Ty;
  else
    Type = Context.DoubleTy;
  break;
case 's':
  assert(HowLong == 0 && "Bad modifiers used with 's'!")((HowLong == 0 && "Bad modifiers used with 's'!") ? static_cast
<void> (0) : __assert_fail ("HowLong == 0 && \"Bad modifiers used with 's'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9499, __PRETTY_FUNCTION__));
  if (Unsigned)
    Type = Context.UnsignedShortTy;
  else
    Type = Context.ShortTy;
  break;
case 'i':
  if (HowLong == 3)
    Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
  else if (HowLong == 2)
    Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
  else if (HowLong == 1)
    Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
  else
    Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
  break;
case 'c':
  assert(HowLong == 0 && "Bad modifiers used with 'c'!")((HowLong == 0 && "Bad modifiers used with 'c'!") ? static_cast
<void> (0) : __assert_fail ("HowLong == 0 && \"Bad modifiers used with 'c'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9516, __PRETTY_FUNCTION__));
  if (Signed)
    Type = Context.SignedCharTy;
  else if (Unsigned)
    Type = Context.UnsignedCharTy;
  else
    Type = Context.CharTy;
  break;
case 'b': // boolean
  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!")((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers for 'b'!") ? static_cast<void> (0) : __assert_fail
 ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'b'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9525, __PRETTY_FUNCTION__));
  Type = Context.BoolTy;
  break;
case 'z':  // size_t.
  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!")((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers for 'z'!") ? static_cast<void> (0) : __assert_fail
 ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'z'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9529, __PRETTY_FUNCTION__));
  Type = Context.getSizeType();
  break;
case 'w':  // wchar_t.
  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'w'!")((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers for 'w'!") ? static_cast<void> (0) : __assert_fail
 ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'w'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9533, __PRETTY_FUNCTION__));
  Type = Context.getWideCharType();
  break;
case 'F':
  Type = Context.getCFConstantStringType();
  break;
case 'G':
  Type = Context.getObjCIdType();
  break;
case 'H':
  Type = Context.getObjCSelType();
  break;
case 'M':
  Type = Context.getObjCSuperType();
  break;
case 'a':
  Type = Context.getBuiltinVaListType();
  assert(!Type.isNull() && "builtin va list type not initialized!")((!Type.isNull() && "builtin va list type not initialized!"
) ? static_cast<void> (0) : __assert_fail ("!Type.isNull() && \"builtin va list type not initialized!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9550, __PRETTY_FUNCTION__));
  break;
case 'A':
  // This is a "reference" to a va_list; however, what exactly
  // this means depends on how va_list is defined. There are two
  // different kinds of va_list: ones passed by value, and ones
  // passed by reference.  An example of a by-value va_list is
  // x86, where va_list is a char*. An example of by-ref va_list
  // is x86-64, where va_list is a __va_list_tag[1]. For x86,
  // we want this argument to be a char*&; for x86-64, we want
  // it to be a __va_list_tag*.
  Type = Context.getBuiltinVaListType();
  assert(!Type.isNull() && "builtin va list type not initialized!")((!Type.isNull() && "builtin va list type not initialized!"
) ? static_cast<void> (0) : __assert_fail ("!Type.isNull() && \"builtin va list type not initialized!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9562, __PRETTY_FUNCTION__));
  if (Type->isArrayType())
    Type = Context.getArrayDecayedType(Type);
  else
    Type = Context.getLValueReferenceType(Type);
  break;
case 'V': {
  char *End;
  unsigned NumElements = strtoul(Str, &End, 10);
  assert(End != Str && "Missing vector size")((End != Str && "Missing vector size") ? static_cast<
void> (0) : __assert_fail ("End != Str && \"Missing vector size\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9571, __PRETTY_FUNCTION__));
  Str = End;

  QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
                                           RequiresICE, false);
  assert(!RequiresICE && "Can't require vector ICE")((!RequiresICE && "Can't require vector ICE") ? static_cast
<void> (0) : __assert_fail ("!RequiresICE && \"Can't require vector ICE\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9576, __PRETTY_FUNCTION__));

  // TODO: No way to make AltiVec vectors in builtins yet.
  Type = Context.getVectorType(ElementType, NumElements,
                               VectorType::GenericVector);
  break;
}
case 'E': {
  char *End;

  unsigned NumElements = strtoul(Str, &End, 10);
  assert(End != Str && "Missing vector size")((End != Str && "Missing vector size") ? static_cast<
void> (0) : __assert_fail ("End != Str && \"Missing vector size\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9587, __PRETTY_FUNCTION__));

  Str = End;

  QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
                                           false);
  Type = Context.getExtVectorType(ElementType, NumElements);
  break;
}
case 'X': {
  QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
                                           false);
  assert(!RequiresICE && "Can't require complex ICE")((!RequiresICE && "Can't require complex ICE") ? static_cast
<void> (0) : __assert_fail ("!RequiresICE && \"Can't require complex ICE\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9599, __PRETTY_FUNCTION__));
  Type = Context.getComplexType(ElementType);
  break;
}
case 'Y':
  Type = Context.getPointerDiffType();
  break;
case 'P':
  Type = Context.getFILEType();
  if (Type.isNull()) {
    Error = ASTContext::GE_Missing_stdio;
    return {};
  }
  break;
case 'J':
  if (Signed)
    Type = Context.getsigjmp_bufType();
  else
    Type = Context.getjmp_bufType();

  if (Type.isNull()) {
    Error = ASTContext::GE_Missing_setjmp;
    return {};
  }
  break;
case 'K':
  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!")((HowLong == 0 && !Signed && !Unsigned &&
 "Bad modifiers for 'K'!") ? static_cast<void> (0) : __assert_fail
 ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'K'!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9625, __PRETTY_FUNCTION__));
  Type = Context.getucontext_tType();

  if (Type.isNull()) {
    Error = ASTContext::GE_Missing_ucontext;
    return {};
  }
  break;
case 'p':
  Type = Context.getProcessIDType();
  break;
}

// If there are modifiers and if we're allowed to parse them, go for it.
Done = !AllowTypeModifiers;
while (!Done) {
  switch (char c = *Str++) {
  default: Done = true; --Str; break;
  case '*':
  case '&': {
    // Both pointers and references can have their pointee types
    // qualified with an address space.
    char *End;
    unsigned AddrSpace = strtoul(Str, &End, 10);
    if (End != Str) {
      // Note AddrSpace == 0 is not the same as an unspecified address space.
      Type = Context.getAddrSpaceQualType(
        Type,
        Context.getLangASForBuiltinAddressSpace(AddrSpace));
      Str = End;
    }
    if (c == '*')
      Type = Context.getPointerType(Type);
    else
      Type = Context.getLValueReferenceType(Type);
    break;
  }
  // FIXME: There's no way to have a built-in with an rvalue ref arg.
  case 'C':
    Type = Type.withConst();
    break;
  case 'D':
    Type = Context.getVolatileType(Type);
    break;
  case 'R':
    Type = Type.withRestrict();
    break;
  }
}

assert((!RequiresICE || Type->isIntegralOrEnumerationType()) &&(((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
 "Integer constant 'I' type must be an integer") ? static_cast
<void> (0) : __assert_fail ("(!RequiresICE || Type->isIntegralOrEnumerationType()) && \"Integer constant 'I' type must be an integer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9676, __PRETTY_FUNCTION__))
       "Integer constant 'I' type must be an integer")(((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
 "Integer constant 'I' type must be an integer") ? static_cast
<void> (0) : __assert_fail ("(!RequiresICE || Type->isIntegralOrEnumerationType()) && \"Integer constant 'I' type must be an integer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9676, __PRETTY_FUNCTION__));

return Type;
9679}

9681/// GetBuiltinType - Return the type for the specified builtin.
9682QualType ASTContext::GetBuiltinType(unsigned Id,
                                  GetBuiltinTypeError &Error,
                                  unsigned *IntegerConstantArgs) const {
const char *TypeStr = BuiltinInfo.getTypeString(Id);
if (TypeStr[0] == '\0') {
  Error = GE_Missing_type;
  return {};
}

SmallVector<QualType, 8> ArgTypes;

bool RequiresICE = false;
Error = GE_None;
QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
                                     RequiresICE, true);
if (Error != GE_None)
  return {};

assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE")((!RequiresICE && "Result of intrinsic cannot be required to be an ICE"
) ? static_cast<void> (0) : __assert_fail ("!RequiresICE && \"Result of intrinsic cannot be required to be an ICE\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9700, __PRETTY_FUNCTION__));

while (TypeStr[0] && TypeStr[0] != '.') {
  QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
  if (Error != GE_None)
    return {};

  // If this argument is required to be an IntegerConstantExpression and the
  // caller cares, fill in the bitmask we return.
  if (RequiresICE && IntegerConstantArgs)
    *IntegerConstantArgs |= 1 << ArgTypes.size();

  // Do array -> pointer decay.  The builtin should use the decayed type.
  if (Ty->isArrayType())
    Ty = getArrayDecayedType(Ty);

  ArgTypes.push_back(Ty);
}

if (Id == Builtin::BI__GetExceptionInfo)
  return {};

assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&(((TypeStr[0] != '.' || TypeStr[1] == 0) && "'.' should only occur at end of builtin type list!"
) ? static_cast<void> (0) : __assert_fail ("(TypeStr[0] != '.' || TypeStr[1] == 0) && \"'.' should only occur at end of builtin type list!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9723, __PRETTY_FUNCTION__))
       "'.' should only occur at end of builtin type list!")(((TypeStr[0] != '.' || TypeStr[1] == 0) && "'.' should only occur at end of builtin type list!"
) ? static_cast<void> (0) : __assert_fail ("(TypeStr[0] != '.' || TypeStr[1] == 0) && \"'.' should only occur at end of builtin type list!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9723, __PRETTY_FUNCTION__));

bool Variadic = (TypeStr[0] == '.');

FunctionType::ExtInfo EI(getDefaultCallingConvention(
    Variadic, /*IsCXXMethod=*/false, /*IsBuiltin=*/true));
if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);


// We really shouldn't be making a no-proto type here.
if (ArgTypes.empty() && Variadic && !getLangOpts().CPlusPlus)
  return getFunctionNoProtoType(ResType, EI);

FunctionProtoType::ExtProtoInfo EPI;
EPI.ExtInfo = EI;
EPI.Variadic = Variadic;
if (getLangOpts().CPlusPlus && BuiltinInfo.isNoThrow(Id))
  EPI.ExceptionSpec.Type =
      getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;

return getFunctionType(ResType, ArgTypes, EPI);
9744}

9746static GVALinkage basicGVALinkageForFunction(const ASTContext &Context,
                                           const FunctionDecl *FD) {
if (!FD->isExternallyVisible())
  return GVA_Internal;

// Non-user-provided functions get emitted as weak definitions with every
// use, no matter whether they've been explicitly instantiated etc.
if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
  if (!MD->isUserProvided())
    return GVA_DiscardableODR;

GVALinkage External;
switch (FD->getTemplateSpecializationKind()) {
case TSK_Undeclared:
case TSK_ExplicitSpecialization:
  External = GVA_StrongExternal;
  break;

case TSK_ExplicitInstantiationDefinition:
  return GVA_StrongODR;

// C++11 [temp.explicit]p10:
//   [ Note: The intent is that an inline function that is the subject of
//   an explicit instantiation declaration will still be implicitly
//   instantiated when used so that the body can be considered for
//   inlining, but that no out-of-line copy of the inline function would be
//   generated in the translation unit. -- end note ]
case TSK_ExplicitInstantiationDeclaration:
  return GVA_AvailableExternally;

case TSK_ImplicitInstantiation:
  External = GVA_DiscardableODR;
  break;
}

if (!FD->isInlined())
  return External;

if ((!Context.getLangOpts().CPlusPlus &&
     !Context.getTargetInfo().getCXXABI().isMicrosoft() &&
     !FD->hasAttr<DLLExportAttr>()) ||
    FD->hasAttr<GNUInlineAttr>()) {
  // FIXME: This doesn't match gcc's behavior for dllexport inline functions.

  // GNU or C99 inline semantics. Determine whether this symbol should be
  // externally visible.
  if (FD->isInlineDefinitionExternallyVisible())
    return External;

  // C99 inline semantics, where the symbol is not externally visible.
  return GVA_AvailableExternally;
}

// Functions specified with extern and inline in -fms-compatibility mode
// forcibly get emitted.  While the body of the function cannot be later
// replaced, the function definition cannot be discarded.
if (FD->isMSExternInline())
  return GVA_StrongODR;

return GVA_DiscardableODR;
9806}

9808static GVALinkage adjustGVALinkageForAttributes(const ASTContext &Context,
                                              const Decl *D, GVALinkage L) {
// See http://msdn.microsoft.com/en-us/library/xa0d9ste.aspx
// dllexport/dllimport on inline functions.
if (D->hasAttr<DLLImportAttr>()) {
  if (L == GVA_DiscardableODR || L == GVA_StrongODR)
    return GVA_AvailableExternally;
} else if (D->hasAttr<DLLExportAttr>()) {
  if (L == GVA_DiscardableODR)
    return GVA_StrongODR;
} else if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice &&
           D->hasAttr<CUDAGlobalAttr>()) {
  // Device-side functions with __global__ attribute must always be
  // visible externally so they can be launched from host.
  if (L == GVA_DiscardableODR || L == GVA_Internal)
    return GVA_StrongODR;
}
return L;
9826}

9828/// Adjust the GVALinkage for a declaration based on what an external AST source
9829/// knows about whether there can be other definitions of this declaration.
9830static GVALinkage
9831adjustGVALinkageForExternalDefinitionKind(const ASTContext &Ctx, const Decl *D,
                                        GVALinkage L) {
ExternalASTSource *Source = Ctx.getExternalSource();
if (!Source)
  return L;

switch (Source->hasExternalDefinitions(D)) {
case ExternalASTSource::EK_Never:
  // Other translation units rely on us to provide the definition.
  if (L == GVA_DiscardableODR)
    return GVA_StrongODR;
  break;

case ExternalASTSource::EK_Always:
  return GVA_AvailableExternally;

case ExternalASTSource::EK_ReplyHazy:
  break;
}
return L;
9851}

9853GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) const {
return adjustGVALinkageForExternalDefinitionKind(*this, FD,
         adjustGVALinkageForAttributes(*this, FD,
           basicGVALinkageForFunction(*this, FD)));
9857}

9859static GVALinkage basicGVALinkageForVariable(const ASTContext &Context,
                                           const VarDecl *VD) {
if (!VD->isExternallyVisible())
  return GVA_Internal;

if (VD->isStaticLocal()) {
  const DeclContext *LexicalContext = VD->getParentFunctionOrMethod();
  while (LexicalContext && !isa<FunctionDecl>(LexicalContext))
    LexicalContext = LexicalContext->getLexicalParent();

  // ObjC Blocks can create local variables that don't have a FunctionDecl
  // LexicalContext.
  if (!LexicalContext)
    return GVA_DiscardableODR;

  // Otherwise, let the static local variable inherit its linkage from the
  // nearest enclosing function.
  auto StaticLocalLinkage =
      Context.GetGVALinkageForFunction(cast<FunctionDecl>(LexicalContext));

  // Itanium ABI 5.2.2: "Each COMDAT group [for a static local variable] must
  // be emitted in any object with references to the symbol for the object it
  // contains, whether inline or out-of-line."
  // Similar behavior is observed with MSVC. An alternative ABI could use
  // StrongODR/AvailableExternally to match the function, but none are
  // known/supported currently.
  if (StaticLocalLinkage == GVA_StrongODR ||
      StaticLocalLinkage == GVA_AvailableExternally)
    return GVA_DiscardableODR;
  return StaticLocalLinkage;
}

// MSVC treats in-class initialized static data members as definitions.
// By giving them non-strong linkage, out-of-line definitions won't
// cause link errors.
if (Context.isMSStaticDataMemberInlineDefinition(VD))
  return GVA_DiscardableODR;

// Most non-template variables have strong linkage; inline variables are
// linkonce_odr or (occasionally, for compatibility) weak_odr.
GVALinkage StrongLinkage;
switch (Context.getInlineVariableDefinitionKind(VD)) {
case ASTContext::InlineVariableDefinitionKind::None:
  StrongLinkage = GVA_StrongExternal;
  break;
case ASTContext::InlineVariableDefinitionKind::Weak:
case ASTContext::InlineVariableDefinitionKind::WeakUnknown:
  StrongLinkage = GVA_DiscardableODR;
  break;
case ASTContext::InlineVariableDefinitionKind::Strong:
  StrongLinkage = GVA_StrongODR;
  break;
}

switch (VD->getTemplateSpecializationKind()) {
case TSK_Undeclared:
  return StrongLinkage;

case TSK_ExplicitSpecialization:
  return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
                 VD->isStaticDataMember()
             ? GVA_StrongODR
             : StrongLinkage;

case TSK_ExplicitInstantiationDefinition:
  return GVA_StrongODR;

case TSK_ExplicitInstantiationDeclaration:
  return GVA_AvailableExternally;

case TSK_ImplicitInstantiation:
  return GVA_DiscardableODR;
}

llvm_unreachable("Invalid Linkage!")::llvm::llvm_unreachable_internal("Invalid Linkage!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9933);
9934}

9936GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) {
return adjustGVALinkageForExternalDefinitionKind(*this, VD,
         adjustGVALinkageForAttributes(*this, VD,
           basicGVALinkageForVariable(*this, VD)));
9940}

9942bool ASTContext::DeclMustBeEmitted(const Decl *D) {
if (const auto *VD = dyn_cast<VarDecl>(D)) {
  if (!VD->isFileVarDecl())
    return false;
  // Global named register variables (GNU extension) are never emitted.
  if (VD->getStorageClass() == SC_Register)
    return false;
  if (VD->getDescribedVarTemplate() ||
      isa<VarTemplatePartialSpecializationDecl>(VD))
    return false;
} else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  // We never need to emit an uninstantiated function template.
  if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
    return false;
} else if (isa<PragmaCommentDecl>(D))
  return true;
else if (isa<PragmaDetectMismatchDecl>(D))
  return true;
else if (isa<OMPThreadPrivateDecl>(D))
  return !D->getDeclContext()->isDependentContext();
else if (isa<OMPAllocateDecl>(D))
  return !D->getDeclContext()->isDependentContext();
else if (isa<OMPDeclareReductionDecl>(D) || isa<OMPDeclareMapperDecl>(D))
  return !D->getDeclContext()->isDependentContext();
else if (isa<ImportDecl>(D))
  return true;
else
  return false;

if (D->isFromASTFile() && !LangOpts.BuildingPCHWithObjectFile) {
  assert(getExternalSource() && "It's from an AST file; must have a source.")((getExternalSource() && "It's from an AST file; must have a source."
) ? static_cast<void> (0) : __assert_fail ("getExternalSource() && \"It's from an AST file; must have a source.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 9972, __PRETTY_FUNCTION__));
  // On Windows, PCH files are built together with an object file. If this
  // declaration comes from such a PCH and DeclMustBeEmitted would return
  // true, it would have returned true and the decl would have been emitted
  // into that object file, so it doesn't need to be emitted here.
  // Note that decls are still emitted if they're referenced, as usual;
  // DeclMustBeEmitted is used to decide whether a decl must be emitted even
  // if it's not referenced.
  //
  // Explicit template instantiation definitions are tricky. If there was an
  // explicit template instantiation decl in the PCH before, it will look like
  // the definition comes from there, even if that was just the declaration.
  // (Explicit instantiation defs of variable templates always get emitted.)
  bool IsExpInstDef =
      isa<FunctionDecl>(D) &&
      cast<FunctionDecl>(D)->getTemplateSpecializationKind() ==
          TSK_ExplicitInstantiationDefinition;

  // Implicit member function definitions, such as operator= might not be
  // marked as template specializations, since they're not coming from a
  // template but synthesized directly on the class.
  IsExpInstDef |=
      isa<CXXMethodDecl>(D) &&
      cast<CXXMethodDecl>(D)->getParent()->getTemplateSpecializationKind() ==
          TSK_ExplicitInstantiationDefinition;

  if (getExternalSource()->DeclIsFromPCHWithObjectFile(D) && !IsExpInstDef)
    return false;
}

// If this is a member of a class template, we do not need to emit it.
if (D->getDeclContext()->isDependentContext())
  return false;

// Weak references don't produce any output by themselves.
if (D->hasAttr<WeakRefAttr>())
  return false;

// Aliases and used decls are required.
if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
  return true;

if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  // Forward declarations aren't required.
  if (!FD->doesThisDeclarationHaveABody())
    return FD->doesDeclarationForceExternallyVisibleDefinition();

  // Constructors and destructors are required.
  if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
    return true;

  // The key function for a class is required.  This rule only comes
  // into play when inline functions can be key functions, though.
  if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
    if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
      const CXXRecordDecl *RD = MD->getParent();
      if (MD->isOutOfLine() && RD->isDynamicClass()) {
        const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD);
        if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
          return true;
      }
    }
  }

  GVALinkage Linkage = GetGVALinkageForFunction(FD);

  // static, static inline, always_inline, and extern inline functions can
  // always be deferred.  Normal inline functions can be deferred in C99/C++.
  // Implicit template instantiations can also be deferred in C++.
  return !isDiscardableGVALinkage(Linkage);
}

const auto *VD = cast<VarDecl>(D);
assert(VD->isFileVarDecl() && "Expected file scoped var")((VD->isFileVarDecl() && "Expected file scoped var"
) ? static_cast<void> (0) : __assert_fail ("VD->isFileVarDecl() && \"Expected file scoped var\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10045, __PRETTY_FUNCTION__));

// If the decl is marked as `declare target to`, it should be emitted for the
// host and for the device.
if (LangOpts.OpenMP &&
    OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
  return true;

if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly &&
    !isMSStaticDataMemberInlineDefinition(VD))
  return false;

// Variables that can be needed in other TUs are required.
auto Linkage = GetGVALinkageForVariable(VD);
if (!isDiscardableGVALinkage(Linkage))
  return true;

// We never need to emit a variable that is available in another TU.
if (Linkage == GVA_AvailableExternally)
  return false;

// Variables that have destruction with side-effects are required.
if (VD->needsDestruction(*this))
  return true;

// Variables that have initialization with side-effects are required.
if (VD->getInit() && VD->getInit()->HasSideEffects(*this) &&
    // We can get a value-dependent initializer during error recovery.
    (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
  return true;

// Likewise, variables with tuple-like bindings are required if their
// bindings have side-effects.
if (const auto *DD = dyn_cast<DecompositionDecl>(VD))
  for (const auto *BD : DD->bindings())
    if (const auto *BindingVD = BD->getHoldingVar())
      if (DeclMustBeEmitted(BindingVD))
        return true;

return false;
10085}

10087void ASTContext::forEachMultiversionedFunctionVersion(
  const FunctionDecl *FD,
  llvm::function_ref<void(FunctionDecl *)> Pred) const {
assert(FD->isMultiVersion() && "Only valid for multiversioned functions")((FD->isMultiVersion() && "Only valid for multiversioned functions"
) ? static_cast<void> (0) : __assert_fail ("FD->isMultiVersion() && \"Only valid for multiversioned functions\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10090, __PRETTY_FUNCTION__));
llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;
FD = FD->getMostRecentDecl();
for (auto *CurDecl :
     FD->getDeclContext()->getRedeclContext()->lookup(FD->getDeclName())) {
  FunctionDecl *CurFD = CurDecl->getAsFunction()->getMostRecentDecl();
  if (CurFD && hasSameType(CurFD->getType(), FD->getType()) &&
      std::end(SeenDecls) == llvm::find(SeenDecls, CurFD)) {
    SeenDecls.insert(CurFD);
    Pred(CurFD);
  }
}
10102}

10104CallingConv ASTContext::getDefaultCallingConvention(bool IsVariadic,
                                                  bool IsCXXMethod,
                                                  bool IsBuiltin) const {
// Pass through to the C++ ABI object
if (IsCXXMethod)
  return ABI->getDefaultMethodCallConv(IsVariadic);

// Builtins ignore user-specified default calling convention and remain the
// Target's default calling convention.
if (!IsBuiltin) {
  switch (LangOpts.getDefaultCallingConv()) {
  case LangOptions::DCC_None:
    break;
  case LangOptions::DCC_CDecl:
    return CC_C;
  case LangOptions::DCC_FastCall:
    if (getTargetInfo().hasFeature("sse2") && !IsVariadic)
      return CC_X86FastCall;
    break;
  case LangOptions::DCC_StdCall:
    if (!IsVariadic)
      return CC_X86StdCall;
    break;
  case LangOptions::DCC_VectorCall:
    // __vectorcall cannot be applied to variadic functions.
    if (!IsVariadic)
      return CC_X86VectorCall;
    break;
  case LangOptions::DCC_RegCall:
    // __regcall cannot be applied to variadic functions.
    if (!IsVariadic)
      return CC_X86RegCall;
    break;
  }
}
return Target->getDefaultCallingConv();
10140}

10142bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const {
// Pass through to the C++ ABI object
return ABI->isNearlyEmpty(RD);
10145}

10147VTableContextBase *ASTContext::getVTableContext() {
if (!VTContext.get()) {
  if (Target->getCXXABI().isMicrosoft())
    VTContext.reset(new MicrosoftVTableContext(*this));
  else
    VTContext.reset(new ItaniumVTableContext(*this));
}
return VTContext.get();
10155}

10157MangleContext *ASTContext::createMangleContext(const TargetInfo *T) {
if (!T)
  T = Target;
switch (T->getCXXABI().getKind()) {
case TargetCXXABI::GenericAArch64:
case TargetCXXABI::GenericItanium:
case TargetCXXABI::GenericARM:
case TargetCXXABI::GenericMIPS:
case TargetCXXABI::iOS:
case TargetCXXABI::iOS64:
case TargetCXXABI::WebAssembly:
case TargetCXXABI::WatchOS:
  return ItaniumMangleContext::create(*this, getDiagnostics());
case TargetCXXABI::Microsoft:
  return MicrosoftMangleContext::create(*this, getDiagnostics());
}
llvm_unreachable("Unsupported ABI")::llvm::llvm_unreachable_internal("Unsupported ABI", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10173);
10174}

10176CXXABI::~CXXABI() = default;

10178size_t ASTContext::getSideTableAllocatedMemory() const {
return ASTRecordLayouts.getMemorySize() +
       llvm::capacity_in_bytes(ObjCLayouts) +
       llvm::capacity_in_bytes(KeyFunctions) +
       llvm::capacity_in_bytes(ObjCImpls) +
       llvm::capacity_in_bytes(BlockVarCopyInits) +
       llvm::capacity_in_bytes(DeclAttrs) +
       llvm::capacity_in_bytes(TemplateOrInstantiation) +
       llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +
       llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +
       llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +
       llvm::capacity_in_bytes(OverriddenMethods) +
       llvm::capacity_in_bytes(Types) +
       llvm::capacity_in_bytes(VariableArrayTypes);
10192}

10194/// getIntTypeForBitwidth -
10195/// sets integer QualTy according to specified details:
10196/// bitwidth, signed/unsigned.
10197/// Returns empty type if there is no appropriate target types.
10198QualType ASTContext::getIntTypeForBitwidth(unsigned DestWidth,
                                         unsigned Signed) const {
TargetInfo::IntType Ty = getTargetInfo().getIntTypeByWidth(DestWidth, Signed);
CanQualType QualTy = getFromTargetType(Ty);
if (!QualTy && DestWidth == 128)
  return Signed ? Int128Ty : UnsignedInt128Ty;
return QualTy;
10205}

10207/// getRealTypeForBitwidth -
10208/// sets floating point QualTy according to specified bitwidth.
10209/// Returns empty type if there is no appropriate target types.
10210QualType ASTContext::getRealTypeForBitwidth(unsigned DestWidth) const {
TargetInfo::RealType Ty = getTargetInfo().getRealTypeByWidth(DestWidth);
switch (Ty) {
case TargetInfo::Float:
  return FloatTy;
case TargetInfo::Double:
  return DoubleTy;
case TargetInfo::LongDouble:
  return LongDoubleTy;
case TargetInfo::Float128:
  return Float128Ty;
case TargetInfo::NoFloat:
  return {};
}

llvm_unreachable("Unhandled TargetInfo::RealType value")::llvm::llvm_unreachable_internal("Unhandled TargetInfo::RealType value"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10225);
10226}

10228void ASTContext::setManglingNumber(const NamedDecl *ND, unsigned Number) {
if (Number > 1)
  MangleNumbers[ND] = Number;
10231}

10233unsigned ASTContext::getManglingNumber(const NamedDecl *ND) const {
auto I = MangleNumbers.find(ND);
return I != MangleNumbers.end() ? I->second : 1;
10236}

10238void ASTContext::setStaticLocalNumber(const VarDecl *VD, unsigned Number) {
if (Number > 1)
  StaticLocalNumbers[VD] = Number;
10241}

10243unsigned ASTContext::getStaticLocalNumber(const VarDecl *VD) const {
auto I = StaticLocalNumbers.find(VD);
return I != StaticLocalNumbers.end() ? I->second : 1;
10246}

10248MangleNumberingContext &
10249ASTContext::getManglingNumberContext(const DeclContext *DC) {
assert(LangOpts.CPlusPlus)((LangOpts.CPlusPlus) ? static_cast<void> (0) : __assert_fail
 ("LangOpts.CPlusPlus", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10250, __PRETTY_FUNCTION__));  // We don't need mangling numbers for plain C.
std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
if (!MCtx)
  MCtx = createMangleNumberingContext();
return *MCtx;
10255}

10257std::unique_ptr<MangleNumberingContext>
10258ASTContext::createMangleNumberingContext() const {
return ABI->createMangleNumberingContext();
10260}

10262const CXXConstructorDecl *
10263ASTContext::getCopyConstructorForExceptionObject(CXXRecordDecl *RD) {
return ABI->getCopyConstructorForExceptionObject(
    cast<CXXRecordDecl>(RD->getFirstDecl()));
10266}

10268void ASTContext::addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
                                                    CXXConstructorDecl *CD) {
return ABI->addCopyConstructorForExceptionObject(
    cast<CXXRecordDecl>(RD->getFirstDecl()),
    cast<CXXConstructorDecl>(CD->getFirstDecl()));
10273}

10275void ASTContext::addTypedefNameForUnnamedTagDecl(TagDecl *TD,
                                               TypedefNameDecl *DD) {
return ABI->addTypedefNameForUnnamedTagDecl(TD, DD);
10278}

10280TypedefNameDecl *
10281ASTContext::getTypedefNameForUnnamedTagDecl(const TagDecl *TD) {
return ABI->getTypedefNameForUnnamedTagDecl(TD);
10283}

10285void ASTContext::addDeclaratorForUnnamedTagDecl(TagDecl *TD,
                                              DeclaratorDecl *DD) {
return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
10288}

10290DeclaratorDecl *ASTContext::getDeclaratorForUnnamedTagDecl(const TagDecl *TD) {
return ABI->getDeclaratorForUnnamedTagDecl(TD);
10292}

10294void ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) {
ParamIndices[D] = index;
10296}

10298unsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const {
ParameterIndexTable::const_iterator I = ParamIndices.find(D);
assert(I != ParamIndices.end() &&((I != ParamIndices.end() && "ParmIndices lacks entry set by ParmVarDecl"
) ? static_cast<void> (0) : __assert_fail ("I != ParamIndices.end() && \"ParmIndices lacks entry set by ParmVarDecl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10301, __PRETTY_FUNCTION__))
       "ParmIndices lacks entry set by ParmVarDecl")((I != ParamIndices.end() && "ParmIndices lacks entry set by ParmVarDecl"
) ? static_cast<void> (0) : __assert_fail ("I != ParamIndices.end() && \"ParmIndices lacks entry set by ParmVarDecl\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10301, __PRETTY_FUNCTION__));
return I->second;
10303}

10305APValue *
10306ASTContext::getMaterializedTemporaryValue(const MaterializeTemporaryExpr *E,
                                        bool MayCreate) {
assert(E && E->getStorageDuration() == SD_Static &&((E && E->getStorageDuration() == SD_Static &&
 "don't need to cache the computed value for this temporary")
 ? static_cast<void> (0) : __assert_fail ("E && E->getStorageDuration() == SD_Static && \"don't need to cache the computed value for this temporary\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10309, __PRETTY_FUNCTION__))
       "don't need to cache the computed value for this temporary")((E && E->getStorageDuration() == SD_Static &&
 "don't need to cache the computed value for this temporary")
 ? static_cast<void> (0) : __assert_fail ("E && E->getStorageDuration() == SD_Static && \"don't need to cache the computed value for this temporary\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10309, __PRETTY_FUNCTION__));
if (MayCreate) {
  APValue *&MTVI = MaterializedTemporaryValues[E];
  if (!MTVI)
    MTVI = new (*this) APValue;
  return MTVI;
}

return MaterializedTemporaryValues.lookup(E);
10318}

10320QualType ASTContext::getStringLiteralArrayType(QualType EltTy,
                                             unsigned Length) const {
// A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
  EltTy = EltTy.withConst();

EltTy = adjustStringLiteralBaseType(EltTy);

// Get an array type for the string, according to C99 6.4.5. This includes
// the null terminator character.
return getConstantArrayType(EltTy, llvm::APInt(32, Length + 1),
                            ArrayType::Normal, /*IndexTypeQuals*/ 0);
10332}

10334StringLiteral *
10335ASTContext::getPredefinedStringLiteralFromCache(StringRef Key) const {
StringLiteral *&Result = StringLiteralCache[Key];
if (!Result)
  Result = StringLiteral::Create(
      *this, Key, StringLiteral::Ascii,
      /*Pascal*/ false, getStringLiteralArrayType(CharTy, Key.size()),
      SourceLocation());
return Result;
10343}

10345bool ASTContext::AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const {
const llvm::Triple &T = getTargetInfo().getTriple();
if (!T.isOSDarwin())
  return false;

if (!(T.isiOS() && T.isOSVersionLT(7)) &&
    !(T.isMacOSX() && T.isOSVersionLT(10, 9)))
  return false;

QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
CharUnits sizeChars = getTypeSizeInChars(AtomicTy);
uint64_t Size = sizeChars.getQuantity();
CharUnits alignChars = getTypeAlignInChars(AtomicTy);
unsigned Align = alignChars.getQuantity();
unsigned MaxInlineWidthInBits = getTargetInfo().getMaxAtomicInlineWidth();
return (Size != Align || toBits(sizeChars) > MaxInlineWidthInBits);
10361}

10363/// Template specializations to abstract away from pointers and TypeLocs.
10364/// @{
10365template <typename T>
10366static ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) {
return ast_type_traits::DynTypedNode::create(*Node);
10368}
10369template <>
10370ast_type_traits::DynTypedNode createDynTypedNode(const TypeLoc &Node) {
return ast_type_traits::DynTypedNode::create(Node);
10372}
10373template <>
10374ast_type_traits::DynTypedNode
10375createDynTypedNode(const NestedNameSpecifierLoc &Node) {
return ast_type_traits::DynTypedNode::create(Node);
10377}
10378/// @}

10380/// A \c RecursiveASTVisitor that builds a map from nodes to their
10381/// parents as defined by the \c RecursiveASTVisitor.
10382///
10383/// Note that the relationship described here is purely in terms of AST
10384/// traversal - there are other relationships (for example declaration context)
10385/// in the AST that are better modeled by special matchers.
10386///
10387/// FIXME: Currently only builds up the map using \c Stmt and \c Decl nodes.
10388class ASTContext::ParentMap::ASTVisitor
  : public RecursiveASTVisitor<ASTVisitor> {
10390public:
ASTVisitor(ParentMap &Map) : Map(Map) {}

10393private:
friend class RecursiveASTVisitor<ASTVisitor>;

using VisitorBase = RecursiveASTVisitor<ASTVisitor>;

bool shouldVisitTemplateInstantiations() const { return true; }

bool shouldVisitImplicitCode() const { return true; }

template <typename T, typename MapNodeTy, typename BaseTraverseFn,
          typename MapTy>
bool TraverseNode(T Node, MapNodeTy MapNode, BaseTraverseFn BaseTraverse,
                  MapTy *Parents) {
  if (!Node)
    return true;
  if (ParentStack.size() > 0) {
    // FIXME: Currently we add the same parent multiple times, but only
    // when no memoization data is available for the type.
    // For example when we visit all subexpressions of template
    // instantiations; this is suboptimal, but benign: the only way to
    // visit those is with hasAncestor / hasParent, and those do not create
    // new matches.
    // The plan is to enable DynTypedNode to be storable in a map or hash
    // map. The main problem there is to implement hash functions /
    // comparison operators for all types that DynTypedNode supports that
    // do not have pointer identity.
    auto &NodeOrVector = (*Parents)[MapNode];
    if (NodeOrVector.isNull()) {
      if (const auto *D = ParentStack.back().get<Decl>())
        NodeOrVector = D;
      else if (const auto *S = ParentStack.back().get<Stmt>())
        NodeOrVector = S;
      else
        NodeOrVector = new ast_type_traits::DynTypedNode(ParentStack.back());
    } else {
      if (!NodeOrVector.template is<ParentVector *>()) {
        auto *Vector = new ParentVector(
            1, getSingleDynTypedNodeFromParentMap(NodeOrVector));
        delete NodeOrVector
            .template dyn_cast<ast_type_traits::DynTypedNode *>();
        NodeOrVector = Vector;
      }

      auto *Vector = NodeOrVector.template get<ParentVector *>();
      // Skip duplicates for types that have memoization data.
      // We must check that the type has memoization data before calling
      // std::find() because DynTypedNode::operator== can't compare all
      // types.
      bool Found = ParentStack.back().getMemoizationData() &&
                   std::find(Vector->begin(), Vector->end(),
                             ParentStack.back()) != Vector->end();
      if (!Found)
        Vector->push_back(ParentStack.back());
    }
  }
  ParentStack.push_back(createDynTypedNode(Node));
  bool Result = BaseTraverse();
  ParentStack.pop_back();
  return Result;
}

bool TraverseDecl(Decl *DeclNode) {
  return TraverseNode(
      DeclNode, DeclNode, [&] { return VisitorBase::TraverseDecl(DeclNode); },
      &Map.PointerParents);
}

bool TraverseStmt(Stmt *StmtNode) {
  return TraverseNode(
      StmtNode, StmtNode, [&] { return VisitorBase::TraverseStmt(StmtNode); },
      &Map.PointerParents);
}

bool TraverseTypeLoc(TypeLoc TypeLocNode) {
  return TraverseNode(
      TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
      [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
      &Map.OtherParents);
}

bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
  return TraverseNode(
      NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
      [&] { return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode); },
      &Map.OtherParents);
}

ParentMap &Map;
llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack;
10482};

10484ASTContext::ParentMap::ParentMap(ASTContext &Ctx) {
ASTVisitor(*this).TraverseAST(Ctx);
10486}

10488ASTContext::DynTypedNodeList
10489ASTContext::getParents(const ast_type_traits::DynTypedNode &Node) {
if (!Parents)
  // We build the parent map for the traversal scope (usually whole TU), as
  // hasAncestor can escape any subtree.
  Parents = std::make_unique<ParentMap>(*this);
return Parents->getParents(Node);
10495}

10497bool
10498ASTContext::ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
                              const ObjCMethodDecl *MethodImpl) {
// No point trying to match an unavailable/deprecated mothod.
if (MethodDecl->hasAttr<UnavailableAttr>()
    || MethodDecl->hasAttr<DeprecatedAttr>())
  return false;
if (MethodDecl->getObjCDeclQualifier() !=
    MethodImpl->getObjCDeclQualifier())
  return false;
if (!hasSameType(MethodDecl->getReturnType(), MethodImpl->getReturnType()))
  return false;

if (MethodDecl->param_size() != MethodImpl->param_size())
  return false;

for (ObjCMethodDecl::param_const_iterator IM = MethodImpl->param_begin(),
     IF = MethodDecl->param_begin(), EM = MethodImpl->param_end(),
     EF = MethodDecl->param_end();
     IM != EM && IF != EF; ++IM, ++IF) {
  const ParmVarDecl *DeclVar = (*IF);
  const ParmVarDecl *ImplVar = (*IM);
  if (ImplVar->getObjCDeclQualifier() != DeclVar->getObjCDeclQualifier())
    return false;
  if (!hasSameType(DeclVar->getType(), ImplVar->getType()))
    return false;
}

return (MethodDecl->isVariadic() == MethodImpl->isVariadic());
10526}

10528uint64_t ASTContext::getTargetNullPointerValue(QualType QT) const {
LangAS AS;
if (QT->getUnqualifiedDesugaredType()->isNullPtrType())
  AS = LangAS::Default;
else
  AS = QT->getPointeeType().getAddressSpace();

return getTargetInfo().getNullPointerValue(AS);
10536}

10538unsigned ASTContext::getTargetAddressSpace(LangAS AS) const {
if (isTargetAddressSpace(AS))
  return toTargetAddressSpace(AS);
else
  return (*AddrSpaceMap)[(unsigned)AS];
10543}

10545QualType ASTContext::getCorrespondingSaturatedType(QualType Ty) const {
assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
 ("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10546, __PRETTY_FUNCTION__));

if (Ty->isSaturatedFixedPointType()) return Ty;

switch (Ty->castAs<BuiltinType>()->getKind()) {
  default:
    llvm_unreachable("Not a fixed point type!")::llvm::llvm_unreachable_internal("Not a fixed point type!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10552);
  case BuiltinType::ShortAccum:
    return SatShortAccumTy;
  case BuiltinType::Accum:
    return SatAccumTy;
  case BuiltinType::LongAccum:
    return SatLongAccumTy;
  case BuiltinType::UShortAccum:
    return SatUnsignedShortAccumTy;
  case BuiltinType::UAccum:
    return SatUnsignedAccumTy;
  case BuiltinType::ULongAccum:
    return SatUnsignedLongAccumTy;
  case BuiltinType::ShortFract:
    return SatShortFractTy;
  case BuiltinType::Fract:
    return SatFractTy;
  case BuiltinType::LongFract:
    return SatLongFractTy;
  case BuiltinType::UShortFract:
    return SatUnsignedShortFractTy;
  case BuiltinType::UFract:
    return SatUnsignedFractTy;
  case BuiltinType::ULongFract:
    return SatUnsignedLongFractTy;
}
10578}

10580LangAS ASTContext::getLangASForBuiltinAddressSpace(unsigned AS) const {
if (LangOpts.OpenCL)
  return getTargetInfo().getOpenCLBuiltinAddressSpace(AS);

if (LangOpts.CUDA)
  return getTargetInfo().getCUDABuiltinAddressSpace(AS);

return getLangASFromTargetAS(AS);
10588}

10590// Explicitly instantiate this in case a Redeclarable<T> is used from a TU that
10591// doesn't include ASTContext.h
10592template
10593clang::LazyGenerationalUpdatePtr<
  const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::ValueType
10595clang::LazyGenerationalUpdatePtr<
  const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::makeValue(
      const clang::ASTContext &Ctx, Decl *Value);

10599unsigned char ASTContext::getFixedPointScale(QualType Ty) const {
assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
 ("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10600, __PRETTY_FUNCTION__));

const auto *BT = Ty->getAs<BuiltinType>();
const TargetInfo &Target = getTargetInfo();
switch (BT->getKind()) {
  default:
    llvm_unreachable("Not a fixed point type!")::llvm::llvm_unreachable_internal("Not a fixed point type!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10606);
  case BuiltinType::ShortAccum:
  case BuiltinType::SatShortAccum:
    return Target.getShortAccumScale();
  case BuiltinType::Accum:
  case BuiltinType::SatAccum:
    return Target.getAccumScale();
  case BuiltinType::LongAccum:
  case BuiltinType::SatLongAccum:
    return Target.getLongAccumScale();
  case BuiltinType::UShortAccum:
  case BuiltinType::SatUShortAccum:
    return Target.getUnsignedShortAccumScale();
  case BuiltinType::UAccum:
  case BuiltinType::SatUAccum:
    return Target.getUnsignedAccumScale();
  case BuiltinType::ULongAccum:
  case BuiltinType::SatULongAccum:
    return Target.getUnsignedLongAccumScale();
  case BuiltinType::ShortFract:
  case BuiltinType::SatShortFract:
    return Target.getShortFractScale();
  case BuiltinType::Fract:
  case BuiltinType::SatFract:
    return Target.getFractScale();
  case BuiltinType::LongFract:
  case BuiltinType::SatLongFract:
    return Target.getLongFractScale();
  case BuiltinType::UShortFract:
  case BuiltinType::SatUShortFract:
    return Target.getUnsignedShortFractScale();
  case BuiltinType::UFract:
  case BuiltinType::SatUFract:
    return Target.getUnsignedFractScale();
  case BuiltinType::ULongFract:
  case BuiltinType::SatULongFract:
    return Target.getUnsignedLongFractScale();
}
10644}

10646unsigned char ASTContext::getFixedPointIBits(QualType Ty) const {
assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
 ("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10647, __PRETTY_FUNCTION__));

const auto *BT = Ty->getAs<BuiltinType>();
const TargetInfo &Target = getTargetInfo();
switch (BT->getKind()) {
  default:
    llvm_unreachable("Not a fixed point type!")::llvm::llvm_unreachable_internal("Not a fixed point type!", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10653);
  case BuiltinType::ShortAccum:
  case BuiltinType::SatShortAccum:
    return Target.getShortAccumIBits();
  case BuiltinType::Accum:
  case BuiltinType::SatAccum:
    return Target.getAccumIBits();
  case BuiltinType::LongAccum:
  case BuiltinType::SatLongAccum:
    return Target.getLongAccumIBits();
  case BuiltinType::UShortAccum:
  case BuiltinType::SatUShortAccum:
    return Target.getUnsignedShortAccumIBits();
  case BuiltinType::UAccum:
  case BuiltinType::SatUAccum:
    return Target.getUnsignedAccumIBits();
  case BuiltinType::ULongAccum:
  case BuiltinType::SatULongAccum:
    return Target.getUnsignedLongAccumIBits();
  case BuiltinType::ShortFract:
  case BuiltinType::SatShortFract:
  case BuiltinType::Fract:
  case BuiltinType::SatFract:
  case BuiltinType::LongFract:
  case BuiltinType::SatLongFract:
  case BuiltinType::UShortFract:
  case BuiltinType::SatUShortFract:
  case BuiltinType::UFract:
  case BuiltinType::SatUFract:
  case BuiltinType::ULongFract:
  case BuiltinType::SatULongFract:
    return 0;
}
10686}

10688FixedPointSemantics ASTContext::getFixedPointSemantics(QualType Ty) const {
assert((Ty->isFixedPointType() || Ty->isIntegerType()) &&(((Ty->isFixedPointType() || Ty->isIntegerType()) &&
 "Can only get the fixed point semantics for a " "fixed point or integer type."
) ? static_cast<void> (0) : __assert_fail ("(Ty->isFixedPointType() || Ty->isIntegerType()) && \"Can only get the fixed point semantics for a \" \"fixed point or integer type.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10691, __PRETTY_FUNCTION__))
       "Can only get the fixed point semantics for a "(((Ty->isFixedPointType() || Ty->isIntegerType()) &&
 "Can only get the fixed point semantics for a " "fixed point or integer type."
) ? static_cast<void> (0) : __assert_fail ("(Ty->isFixedPointType() || Ty->isIntegerType()) && \"Can only get the fixed point semantics for a \" \"fixed point or integer type.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10691, __PRETTY_FUNCTION__))
       "fixed point or integer type.")(((Ty->isFixedPointType() || Ty->isIntegerType()) &&
 "Can only get the fixed point semantics for a " "fixed point or integer type."
) ? static_cast<void> (0) : __assert_fail ("(Ty->isFixedPointType() || Ty->isIntegerType()) && \"Can only get the fixed point semantics for a \" \"fixed point or integer type.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10691, __PRETTY_FUNCTION__));
if (Ty->isIntegerType())
  return FixedPointSemantics::GetIntegerSemantics(getIntWidth(Ty),
                                                  Ty->isSignedIntegerType());

bool isSigned = Ty->isSignedFixedPointType();
return FixedPointSemantics(
    static_cast<unsigned>(getTypeSize(Ty)), getFixedPointScale(Ty), isSigned,
    Ty->isSaturatedFixedPointType(),
    !isSigned && getTargetInfo().doUnsignedFixedPointTypesHavePadding());
10701}

10703APFixedPoint ASTContext::getFixedPointMax(QualType Ty) const {
assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
 ("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10704, __PRETTY_FUNCTION__));
return APFixedPoint::getMax(getFixedPointSemantics(Ty));
10706}

10708APFixedPoint ASTContext::getFixedPointMin(QualType Ty) const {
assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
 ("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10709, __PRETTY_FUNCTION__));
return APFixedPoint::getMin(getFixedPointSemantics(Ty));
10711}

10713QualType ASTContext::getCorrespondingSignedFixedPointType(QualType Ty) const {
assert(Ty->isUnsignedFixedPointType() &&((Ty->isUnsignedFixedPointType() && "Expected unsigned fixed point type"
) ? static_cast<void> (0) : __assert_fail ("Ty->isUnsignedFixedPointType() && \"Expected unsigned fixed point type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10715, __PRETTY_FUNCTION__))
       "Expected unsigned fixed point type")((Ty->isUnsignedFixedPointType() && "Expected unsigned fixed point type"
) ? static_cast<void> (0) : __assert_fail ("Ty->isUnsignedFixedPointType() && \"Expected unsigned fixed point type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10715, __PRETTY_FUNCTION__));
const auto *BTy = Ty->getAs<BuiltinType>();

switch (BTy->getKind()) {
case BuiltinType::UShortAccum:
  return ShortAccumTy;
case BuiltinType::UAccum:
  return AccumTy;
case BuiltinType::ULongAccum:
  return LongAccumTy;
case BuiltinType::SatUShortAccum:
  return SatShortAccumTy;
case BuiltinType::SatUAccum:
  return SatAccumTy;
case BuiltinType::SatULongAccum:
  return SatLongAccumTy;
case BuiltinType::UShortFract:
  return ShortFractTy;
case BuiltinType::UFract:
  return FractTy;
case BuiltinType::ULongFract:
  return LongFractTy;
case BuiltinType::SatUShortFract:
  return SatShortFractTy;
case BuiltinType::SatUFract:
  return SatFractTy;
case BuiltinType::SatULongFract:
  return SatLongFractTy;
default:
  llvm_unreachable("Unexpected unsigned fixed point type")::llvm::llvm_unreachable_internal("Unexpected unsigned fixed point type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/ASTContext.cpp"
, 10744);
}
10746}

←

/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h

→

1//===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H

20#include "clang/AST/NestedNameSpecifier.h"
21#include "clang/AST/TemplateName.h"
22#include "clang/Basic/AddressSpaces.h"
23#include "clang/Basic/AttrKinds.h"
24#include "clang/Basic/Diagnostic.h"
25#include "clang/Basic/ExceptionSpecificationType.h"
26#include "clang/Basic/LLVM.h"
27#include "clang/Basic/Linkage.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/SourceLocation.h"
30#include "clang/Basic/Specifiers.h"
31#include "clang/Basic/Visibility.h"
32#include "llvm/ADT/APInt.h"
33#include "llvm/ADT/APSInt.h"
34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/ADT/FoldingSet.h"
36#include "llvm/ADT/None.h"
37#include "llvm/ADT/Optional.h"
38#include "llvm/ADT/PointerIntPair.h"
39#include "llvm/ADT/PointerUnion.h"
40#include "llvm/ADT/StringRef.h"
41#include "llvm/ADT/Twine.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/ErrorHandling.h"
46#include "llvm/Support/PointerLikeTypeTraits.h"
47#include "llvm/Support/type_traits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <cstring>
53#include <string>
54#include <type_traits>
55#include <utility>

57namespace clang {

59class ExtQuals;
60class QualType;
61class TagDecl;
62class Type;

64enum {
TypeAlignmentInBits = 4,
TypeAlignment = 1 << TypeAlignmentInBits
67};

69} // namespace clang

71namespace llvm {

template <typename T>
struct PointerLikeTypeTraits;
template<>
struct PointerLikeTypeTraits< ::clang::Type*> {
  static inline void *getAsVoidPointer(::clang::Type *P) { return P; }

  static inline ::clang::Type *getFromVoidPointer(void *P) {
    return static_cast< ::clang::Type*>(P);
  }

  enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
};

template<>
struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
  static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }

  static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
    return static_cast< ::clang::ExtQuals*>(P);
  }

  enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
};

97} // namespace llvm

99namespace clang {

101class ASTContext;
102template <typename> class CanQual;
103class CXXRecordDecl;
104class DeclContext;
105class EnumDecl;
106class Expr;
107class ExtQualsTypeCommonBase;
108class FunctionDecl;
109class IdentifierInfo;
110class NamedDecl;
111class ObjCInterfaceDecl;
112class ObjCProtocolDecl;
113class ObjCTypeParamDecl;
114struct PrintingPolicy;
115class RecordDecl;
116class Stmt;
117class TagDecl;
118class TemplateArgument;
119class TemplateArgumentListInfo;
120class TemplateArgumentLoc;
121class TemplateTypeParmDecl;
122class TypedefNameDecl;
123class UnresolvedUsingTypenameDecl;

125using CanQualType = CanQual<Type>;

127// Provide forward declarations for all of the *Type classes.
128#define TYPE(Class, Base) class Class##Type;
129#include "clang/AST/TypeNodes.inc"

131/// The collection of all-type qualifiers we support.
132/// Clang supports five independent qualifiers:
133/// * C99: const, volatile, and restrict
134/// * MS: __unaligned
135/// * Embedded C (TR18037): address spaces
136/// * Objective C: the GC attributes (none, weak, or strong)
137class Qualifiers {
138public:
enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
  Const    = 0x1,
  Restrict = 0x2,
  Volatile = 0x4,
  CVRMask = Const | Volatile | Restrict
};

enum GC {
  GCNone = 0,
  Weak,
  Strong
};

enum ObjCLifetime {
  /// There is no lifetime qualification on this type.
  OCL_None,

  /// This object can be modified without requiring retains or
  /// releases.
  OCL_ExplicitNone,

  /// Assigning into this object requires the old value to be
  /// released and the new value to be retained.  The timing of the
  /// release of the old value is inexact: it may be moved to
  /// immediately after the last known point where the value is
  /// live.
  OCL_Strong,

  /// Reading or writing from this object requires a barrier call.
  OCL_Weak,

  /// Assigning into this object requires a lifetime extension.
  OCL_Autoreleasing
};

enum {
  /// The maximum supported address space number.
  /// 23 bits should be enough for anyone.
  MaxAddressSpace = 0x7fffffu,

  /// The width of the "fast" qualifier mask.
  FastWidth = 3,

  /// The fast qualifier mask.
  FastMask = (1 << FastWidth) - 1
};

/// Returns the common set of qualifiers while removing them from
/// the given sets.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
  // If both are only CVR-qualified, bit operations are sufficient.
  if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
    Qualifiers Q;
    Q.Mask = L.Mask & R.Mask;
    L.Mask &= ~Q.Mask;
    R.Mask &= ~Q.Mask;
    return Q;
  }

  Qualifiers Q;
  unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
  Q.addCVRQualifiers(CommonCRV);
  L.removeCVRQualifiers(CommonCRV);
  R.removeCVRQualifiers(CommonCRV);

  if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
    Q.setObjCGCAttr(L.getObjCGCAttr());
    L.removeObjCGCAttr();
    R.removeObjCGCAttr();
  }

  if (L.getObjCLifetime() == R.getObjCLifetime()) {
    Q.setObjCLifetime(L.getObjCLifetime());
    L.removeObjCLifetime();
    R.removeObjCLifetime();
  }

  if (L.getAddressSpace() == R.getAddressSpace()) {
    Q.setAddressSpace(L.getAddressSpace());
    L.removeAddressSpace();
    R.removeAddressSpace();
  }
  return Q;
}

static Qualifiers fromFastMask(unsigned Mask) {
  Qualifiers Qs;
  Qs.addFastQualifiers(Mask);
  return Qs;
}

static Qualifiers fromCVRMask(unsigned CVR) {
  Qualifiers Qs;
  Qs.addCVRQualifiers(CVR);
  return Qs;
}

static Qualifiers fromCVRUMask(unsigned CVRU) {
  Qualifiers Qs;
  Qs.addCVRUQualifiers(CVRU);
  return Qs;
}

// Deserialize qualifiers from an opaque representation.
static Qualifiers fromOpaqueValue(unsigned opaque) {
  Qualifiers Qs;
  Qs.Mask = opaque;
  return Qs;
}

// Serialize these qualifiers into an opaque representation.
unsigned getAsOpaqueValue() const {
  return Mask;
}

bool hasConst() const { return Mask & Const; }
bool hasOnlyConst() const { return Mask == Const; }
void removeConst() { Mask &= ~Const; }
void addConst() { Mask |= Const; }

bool hasVolatile() const { return Mask & Volatile; }
bool hasOnlyVolatile() const { return Mask == Volatile; }
void removeVolatile() { Mask &= ~Volatile; }
void addVolatile() { Mask |= Volatile; }

bool hasRestrict() const { return Mask & Restrict; }
bool hasOnlyRestrict() const { return Mask == Restrict; }
void removeRestrict() { Mask &= ~Restrict; }
void addRestrict() { Mask |= Restrict; }

bool hasCVRQualifiers() const { return getCVRQualifiers(); }
unsigned getCVRQualifiers() const { return Mask & CVRMask; }
unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }

void setCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 274, __PRETTY_FUNCTION__));
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 278, __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 285, __PRETTY_FUNCTION__));
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 289, __PRETTY_FUNCTION__));
  Mask |= mask;
}

bool hasUnaligned() const { return Mask & UMask; }
void setUnaligned(bool flag) {
  Mask = (Mask & ~UMask) | (flag ? UMask : 0);
}
void removeUnaligned() { Mask &= ~UMask; }
void addUnaligned() { Mask |= UMask; }

bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
void setObjCGCAttr(GC type) {
  Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
}
void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
void addObjCGCAttr(GC type) {
  assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 307, __PRETTY_FUNCTION__));
  setObjCGCAttr(type);
}
Qualifiers withoutObjCGCAttr() const {
  Qualifiers qs = *this;
  qs.removeObjCGCAttr();
  return qs;
}
Qualifiers withoutObjCLifetime() const {
  Qualifiers qs = *this;
  qs.removeObjCLifetime();
  return qs;
}
Qualifiers withoutAddressSpace() const {
  Qualifiers qs = *this;
  qs.removeAddressSpace();
  return qs;
}

bool hasObjCLifetime() const { return Mask & LifetimeMask; }
ObjCLifetime getObjCLifetime() const {
  return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
}
void setObjCLifetime(ObjCLifetime type) {
  Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
}
void removeObjCLifetime() { setObjCLifetime(OCL_None); }
void addObjCLifetime(ObjCLifetime type) {
  assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 335, __PRETTY_FUNCTION__));
  assert(!hasObjCLifetime())((!hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 336, __PRETTY_FUNCTION__));
  Mask |= (type << LifetimeShift);
}

/// True if the lifetime is neither None or ExplicitNone.
bool hasNonTrivialObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime > OCL_ExplicitNone);
}

/// True if the lifetime is either strong or weak.
bool hasStrongOrWeakObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime == OCL_Strong || lifetime == OCL_Weak);
}

bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
LangAS getAddressSpace() const {
  return static_cast<LangAS>(Mask >> AddressSpaceShift);
}
bool hasTargetSpecificAddressSpace() const {
  return isTargetAddressSpace(getAddressSpace());
}
/// Get the address space attribute value to be printed by diagnostics.
unsigned getAddressSpaceAttributePrintValue() const {
  auto Addr = getAddressSpace();
  // This function is not supposed to be used with language specific
  // address spaces. If that happens, the diagnostic message should consider
  // printing the QualType instead of the address space value.
  assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((Addr == LangAS::Default || hasTargetSpecificAddressSpace())
 ? static_cast<void> (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 365, __PRETTY_FUNCTION__));
  if (Addr != LangAS::Default)
    return toTargetAddressSpace(Addr);
  // TODO: The diagnostic messages where Addr may be 0 should be fixed
  // since it cannot differentiate the situation where 0 denotes the default
  // address space or user specified __attribute__((address_space(0))).
  return 0;
}
void setAddressSpace(LangAS space) {
  assert((unsigned)space <= MaxAddressSpace)(((unsigned)space <= MaxAddressSpace) ? static_cast<void
> (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 374, __PRETTY_FUNCTION__));
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)((space != LangAS::Default) ? static_cast<void> (0) : __assert_fail
 ("space != LangAS::Default", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 380, __PRETTY_FUNCTION__));
  setAddressSpace(space);
}

// Fast qualifiers are those that can be allocated directly
// on a QualType object.
bool hasFastQualifiers() const { return getFastQualifiers(); }
unsigned getFastQualifiers() const { return Mask & FastMask; }
void setFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 389, __PRETTY_FUNCTION__));
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 393, __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 400, __PRETTY_FUNCTION__));
  Mask |= mask;
}

/// Return true if the set contains any qualifiers which require an ExtQuals
/// node to be allocated.
bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
Qualifiers getNonFastQualifiers() const {
  Qualifiers Quals = *this;
  Quals.setFastQualifiers(0);
  return Quals;
}

/// Return true if the set contains any qualifiers.
bool hasQualifiers() const { return Mask; }
bool empty() const { return !Mask; }

/// Add the qualifiers from the given set to this set.
void addQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-or it in.
  if (!(Q.Mask & ~CVRMask))
    Mask |= Q.Mask;
  else {
    Mask |= (Q.Mask & CVRMask);
    if (Q.hasAddressSpace())
      addAddressSpace(Q.getAddressSpace());
    if (Q.hasObjCGCAttr())
      addObjCGCAttr(Q.getObjCGCAttr());
    if (Q.hasObjCLifetime())
      addObjCLifetime(Q.getObjCLifetime());
  }
}

/// Remove the qualifiers from the given set from this set.
void removeQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-and the inverse in.
  if (!(Q.Mask & ~CVRMask))
    Mask &= ~Q.Mask;
  else {
    Mask &= ~(Q.Mask & CVRMask);
    if (getObjCGCAttr() == Q.getObjCGCAttr())
      removeObjCGCAttr();
    if (getObjCLifetime() == Q.getObjCLifetime())
      removeObjCLifetime();
    if (getAddressSpace() == Q.getAddressSpace())
      removeAddressSpace();
  }
}

/// Add the qualifiers from the given set to this set, given that
/// they don't conflict.
void addConsistentQualifiers(Qualifiers qs) {
  assert(getAddressSpace() == qs.getAddressSpace() ||((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
 ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 455, __PRETTY_FUNCTION__))
         !hasAddressSpace() || !qs.hasAddressSpace())((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
 ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 455, __PRETTY_FUNCTION__));
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
 !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 457, __PRETTY_FUNCTION__))
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
 !qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 457, __PRETTY_FUNCTION__));
  assert(getObjCLifetime() == qs.getObjCLifetime() ||((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 459, __PRETTY_FUNCTION__))
         !hasObjCLifetime() || !qs.hasObjCLifetime())((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
 ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 459, __PRETTY_FUNCTION__));
  Mask |= qs.Mask;
}

/// Returns true if address space A is equal to or a superset of B.
/// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
/// overlapping address spaces.
/// CL1.1 or CL1.2:
///   every address space is a superset of itself.
/// CL2.0 adds:
///   __generic is a superset of any address space except for __constant.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
  // Address spaces must match exactly.
  return A == B ||
         // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
         // for __constant can be used as __generic.
         (A == LangAS::opencl_generic && B != LangAS::opencl_constant);
}

/// Returns true if the address space in these qualifiers is equal to or
/// a superset of the address space in the argument qualifiers.
bool isAddressSpaceSupersetOf(Qualifiers other) const {
  return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
}

/// Determines if these qualifiers compatibly include another set.
/// Generally this answers the question of whether an object with the other
/// qualifiers can be safely used as an object with these qualifiers.
bool compatiblyIncludes(Qualifiers other) const {
  return isAddressSpaceSupersetOf(other) &&
         // ObjC GC qualifiers can match, be added, or be removed, but can't
         // be changed.
         (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
          !other.hasObjCGCAttr()) &&
         // ObjC lifetime qualifiers must match exactly.
         getObjCLifetime() == other.getObjCLifetime() &&
         // CVR qualifiers may subset.
         (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
         // U qualifier may superset.
         (!other.hasUnaligned() || hasUnaligned());
}

/// Determines if these qualifiers compatibly include another set of
/// qualifiers from the narrow perspective of Objective-C ARC lifetime.
///
/// One set of Objective-C lifetime qualifiers compatibly includes the other
/// if the lifetime qualifiers match, or if both are non-__weak and the
/// including set also contains the 'const' qualifier, or both are non-__weak
/// and one is None (which can only happen in non-ARC modes).
bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
  if (getObjCLifetime() == other.getObjCLifetime())
    return true;

  if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
    return false;

  if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
    return true;

  return hasConst();
}

/// Determine whether this set of qualifiers is a strict superset of
/// another set of qualifiers, not considering qualifier compatibility.
bool isStrictSupersetOf(Qualifiers Other) const;

bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
16
←
Assuming 'Mask' is equal to 'Other.Mask'→
17
←
Returning zero, which participates in a condition later→

explicit operator bool() const { return hasQualifiers(); }

Qualifiers &operator+=(Qualifiers R) {
  addQualifiers(R);
  return *this;
}

// Union two qualifier sets.  If an enumerated qualifier appears
// in both sets, use the one from the right.
friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
  L += R;
  return L;
}

Qualifiers &operator-=(Qualifiers R) {
  removeQualifiers(R);
  return *this;
}

/// Compute the difference between two qualifier sets.
friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
  L -= R;
  return L;
}

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
void print(raw_ostream &OS, const PrintingPolicy &Policy,
           bool appendSpaceIfNonEmpty = false) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddInteger(Mask);
}

564private:
// bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
//           |C R V|U|GCAttr|Lifetime|AddressSpace|
uint32_t Mask = 0;

static const uint32_t UMask = 0x8;
static const uint32_t UShift = 3;
static const uint32_t GCAttrMask = 0x30;
static const uint32_t GCAttrShift = 4;
static const uint32_t LifetimeMask = 0x1C0;
static const uint32_t LifetimeShift = 6;
static const uint32_t AddressSpaceMask =
    ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
static const uint32_t AddressSpaceShift = 9;
578};

580/// A std::pair-like structure for storing a qualified type split
581/// into its local qualifiers and its locally-unqualified type.
582struct SplitQualType {
/// The locally-unqualified type.
const Type *Ty = nullptr;

/// The local qualifiers.
Qualifiers Quals;

SplitQualType() = default;
SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}

SplitQualType getSingleStepDesugaredType() const; // end of this file

// Make std::tie work.
std::pair<const Type *,Qualifiers> asPair() const {
  return std::pair<const Type *, Qualifiers>(Ty, Quals);
}

friend bool operator==(SplitQualType a, SplitQualType b) {
  return a.Ty == b.Ty && a.Quals == b.Quals;
}
friend bool operator!=(SplitQualType a, SplitQualType b) {
  return a.Ty != b.Ty || a.Quals != b.Quals;
}
605};

607/// The kind of type we are substituting Objective-C type arguments into.
608///
609/// The kind of substitution affects the replacement of type parameters when
610/// no concrete type information is provided, e.g., when dealing with an
611/// unspecialized type.
612enum class ObjCSubstitutionContext {
/// An ordinary type.
Ordinary,

/// The result type of a method or function.
Result,

/// The parameter type of a method or function.
Parameter,

/// The type of a property.
Property,

/// The superclass of a type.
Superclass,
627};

629/// A (possibly-)qualified type.
630///
631/// For efficiency, we don't store CV-qualified types as nodes on their
632/// own: instead each reference to a type stores the qualifiers.  This
633/// greatly reduces the number of nodes we need to allocate for types (for
634/// example we only need one for 'int', 'const int', 'volatile int',
635/// 'const volatile int', etc).
636///
637/// As an added efficiency bonus, instead of making this a pair, we
638/// just store the two bits we care about in the low bits of the
639/// pointer.  To handle the packing/unpacking, we make QualType be a
640/// simple wrapper class that acts like a smart pointer.  A third bit
641/// indicates whether there are extended qualifiers present, in which
642/// case the pointer points to a special structure.
643class QualType {
friend class QualifierCollector;

// Thankfully, these are efficiently composable.
llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
                     Qualifiers::FastWidth> Value;

const ExtQuals *getExtQualsUnsafe() const {
  return Value.getPointer().get<const ExtQuals*>();
}

const Type *getTypePtrUnsafe() const {
  return Value.getPointer().get<const Type*>();
}

const ExtQualsTypeCommonBase *getCommonPtr() const {
  assert(!isNull() && "Cannot retrieve a NULL type pointer")((!isNull() && "Cannot retrieve a NULL type pointer")
 ? static_cast<void> (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 659, __PRETTY_FUNCTION__));
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

665public:
QualType() = default;
QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}

unsigned getLocalFastQualifiers() const { return Value.getInt(); }
void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }

/// Retrieves a pointer to the underlying (unqualified) type.
///
/// This function requires that the type not be NULL. If the type might be
/// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
const Type *getTypePtr() const;

const Type *getTypePtrOrNull() const;

/// Retrieves a pointer to the name of the base type.
const IdentifierInfo *getBaseTypeIdentifier() const;

/// Divides a QualType into its unqualified type and a set of local
/// qualifiers.
SplitQualType split() const;

void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }

static QualType getFromOpaquePtr(const void *Ptr) {
  QualType T;
  T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
  return T;
}

const Type &operator*() const {
  return *getTypePtr();
}

const Type *operator->() const {
  return getTypePtr();
}

bool isCanonical() const;
bool isCanonicalAsParam() const;

/// Return true if this QualType doesn't point to a type yet.
bool isNull() const {
  return Value.getPointer().isNull();
}

/// Determine whether this particular QualType instance has the
/// "const" qualifier set, without looking through typedefs that may have
/// added "const" at a different level.
bool isLocalConstQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Const);
}

/// Determine whether this type is const-qualified.
bool isConstQualified() const;

/// Determine whether this particular QualType instance has the
/// "restrict" qualifier set, without looking through typedefs that may have
/// added "restrict" at a different level.
bool isLocalRestrictQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Restrict);
}

/// Determine whether this type is restrict-qualified.
bool isRestrictQualified() const;

/// Determine whether this particular QualType instance has the
/// "volatile" qualifier set, without looking through typedefs that may have
/// added "volatile" at a different level.
bool isLocalVolatileQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Volatile);
}

/// Determine whether this type is volatile-qualified.
bool isVolatileQualified() const;

/// Determine whether this particular QualType instance has any
/// qualifiers, without looking through any typedefs that might add
/// qualifiers at a different level.
bool hasLocalQualifiers() const {
  return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
}

/// Determine whether this type has any qualifiers.
bool hasQualifiers() const;

/// Determine whether this particular QualType instance has any
/// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
/// instance.
bool hasLocalNonFastQualifiers() const {
  return Value.getPointer().is<const ExtQuals*>();
}

/// Retrieve the set of qualifiers local to this particular QualType
/// instance, not including any qualifiers acquired through typedefs or
/// other sugar.
Qualifiers getLocalQualifiers() const;

/// Retrieve the set of qualifiers applied to this type.
Qualifiers getQualifiers() const;

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// local to this particular QualType instance, not including any qualifiers
/// acquired through typedefs or other sugar.
unsigned getLocalCVRQualifiers() const {
  return getLocalFastQualifiers();
}

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// applied to this type.
unsigned getCVRQualifiers() const;

bool isConstant(const ASTContext& Ctx) const {
  return QualType::isConstant(*this, Ctx);
}

/// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isPODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the rules of the C++98
/// standard, regardless of the current compilation's language.
bool isCXX98PODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the more relaxed rules
/// of the C++11 standard, regardless of the current compilation's language.
/// (C++0x [basic.types]p9). Note that, unlike
/// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
bool isCXX11PODType(const ASTContext &Context) const;

/// Return true if this is a trivial type per (C++0x [basic.types]p9)
bool isTrivialType(const ASTContext &Context) const;

/// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool isTriviallyCopyableType(const ASTContext &Context) const;


/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;

/// Returns true if it is not a class or if the class might not be dynamic.
bool mayBeNotDynamicClass() const;

// Don't promise in the API that anything besides 'const' can be
// easily added.

/// Add the `const` type qualifier to this QualType.
void addConst() {
  addFastQualifiers(Qualifiers::Const);
}
QualType withConst() const {
  return withFastQualifiers(Qualifiers::Const);
}

/// Add the `volatile` type qualifier to this QualType.
void addVolatile() {
  addFastQualifiers(Qualifiers::Volatile);
}
QualType withVolatile() const {
  return withFastQualifiers(Qualifiers::Volatile);
}

/// Add the `restrict` qualifier to this QualType.
void addRestrict() {
  addFastQualifiers(Qualifiers::Restrict);
}
QualType withRestrict() const {
  return withFastQualifiers(Qualifiers::Restrict);
}

QualType withCVRQualifiers(unsigned CVR) const {
  return withFastQualifiers(CVR);
}

void addFastQualifiers(unsigned TQs) {
  assert(!(TQs & ~Qualifiers::FastMask)((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 841, __PRETTY_FUNCTION__))
         && "non-fast qualifier bits set in mask!")((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 841, __PRETTY_FUNCTION__));
  Value.setInt(Value.getInt() | TQs);
}

void removeLocalConst();
void removeLocalVolatile();
void removeLocalRestrict();
void removeLocalCVRQualifiers(unsigned Mask);

void removeLocalFastQualifiers() { Value.setInt(0); }
void removeLocalFastQualifiers(unsigned Mask) {
  assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 852, __PRETTY_FUNCTION__));
  Value.setInt(Value.getInt() & ~Mask);
}

// Creates a type with the given qualifiers in addition to any
// qualifiers already on this type.
QualType withFastQualifiers(unsigned TQs) const {
  QualType T = *this;
  T.addFastQualifiers(TQs);
  return T;
}

// Creates a type with exactly the given fast qualifiers, removing
// any existing fast qualifiers.
QualType withExactLocalFastQualifiers(unsigned TQs) const {
  return withoutLocalFastQualifiers().withFastQualifiers(TQs);
}

// Removes fast qualifiers, but leaves any extended qualifiers in place.
QualType withoutLocalFastQualifiers() const {
  QualType T = *this;
  T.removeLocalFastQualifiers();
  return T;
}

QualType getCanonicalType() const;

/// Return this type with all of the instance-specific qualifiers
/// removed, but without removing any qualifiers that may have been applied
/// through typedefs.
QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }

/// Retrieve the unqualified variant of the given type,
/// removing as little sugar as possible.
///
/// This routine looks through various kinds of sugar to find the
/// least-desugared type that is unqualified. For example, given:
///
/// \code
/// typedef int Integer;
/// typedef const Integer CInteger;
/// typedef CInteger DifferenceType;
/// \endcode
///
/// Executing \c getUnqualifiedType() on the type \c DifferenceType will
/// desugar until we hit the type \c Integer, which has no qualifiers on it.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline QualType getUnqualifiedType() const;

/// Retrieve the unqualified variant of the given type, removing as little
/// sugar as possible.
///
/// Like getUnqualifiedType(), but also returns the set of
/// qualifiers that were built up.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline SplitQualType getSplitUnqualifiedType() const;

/// Determine whether this type is more qualified than the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isMoreQualifiedThan(QualType Other) const;

/// Determine whether this type is at least as qualified as the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isAtLeastAsQualifiedAs(QualType Other) const;

QualType getNonReferenceType() const;

/// Determine the type of a (typically non-lvalue) expression with the
/// specified result type.
///
/// This routine should be used for expressions for which the return type is
/// explicitly specified (e.g., in a cast or call) and isn't necessarily
/// an lvalue. It removes a top-level reference (since there are no
/// expressions of reference type) and deletes top-level cvr-qualifiers
/// from non-class types (in C++) or all types (in C).
QualType getNonLValueExprType(const ASTContext &Context) const;

/// Return the specified type with any "sugar" removed from
/// the type.  This takes off typedefs, typeof's etc.  If the outer level of
/// the type is already concrete, it returns it unmodified.  This is similar
/// to getting the canonical type, but it doesn't remove *all* typedefs.  For
/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
/// concrete.
///
/// Qualifiers are left in place.
QualType getDesugaredType(const ASTContext &Context) const {
  return getDesugaredType(*this, Context);
}

SplitQualType getSplitDesugaredType() const {
  return getSplitDesugaredType(*this);
}

/// Return the specified type with one level of "sugar" removed from
/// the type.
///
/// This routine takes off the first typedef, typeof, etc. If the outer level
/// of the type is already concrete, it returns it unmodified.
QualType getSingleStepDesugaredType(const ASTContext &Context) const {
  return getSingleStepDesugaredTypeImpl(*this, Context);
}

/// Returns the specified type after dropping any
/// outer-level parentheses.
QualType IgnoreParens() const {
  if (isa<ParenType>(*this))
    return QualType::IgnoreParens(*this);
  return *this;
}

/// Indicate whether the specified types and qualifiers are identical.
friend bool operator==(const QualType &LHS, const QualType &RHS) {
  return LHS.Value == RHS.Value;
8
←
Calling 'PointerIntPair::operator=='→
11
←
Returning from 'PointerIntPair::operator=='→
12
←
Returning zero, which participates in a condition later→
}
friend bool operator!=(const QualType &LHS, const QualType &RHS) {
  return LHS.Value != RHS.Value;
}
friend bool operator<(const QualType &LHS, const QualType &RHS) {
  return LHS.Value < RHS.Value;
}

static std::string getAsString(SplitQualType split,
                               const PrintingPolicy &Policy) {
  return getAsString(split.Ty, split.Quals, Policy);
}
static std::string getAsString(const Type *ty, Qualifiers qs,
                               const PrintingPolicy &Policy);

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

void print(raw_ostream &OS, const PrintingPolicy &Policy,
           const Twine &PlaceHolder = Twine(),
           unsigned Indentation = 0) const;

static void print(SplitQualType split, raw_ostream &OS,
                  const PrintingPolicy &policy, const Twine &PlaceHolder,
                  unsigned Indentation = 0) {
  return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
}

static void print(const Type *ty, Qualifiers qs,
                  raw_ostream &OS, const PrintingPolicy &policy,
                  const Twine &PlaceHolder,
                  unsigned Indentation = 0);

void getAsStringInternal(std::string &Str,
                         const PrintingPolicy &Policy) const;

static void getAsStringInternal(SplitQualType split, std::string &out,
                                const PrintingPolicy &policy) {
  return getAsStringInternal(split.Ty, split.Quals, out, policy);
}

static void getAsStringInternal(const Type *ty, Qualifiers qs,
                                std::string &out,
                                const PrintingPolicy &policy);

class StreamedQualTypeHelper {
  const QualType &T;
  const PrintingPolicy &Policy;
  const Twine &PlaceHolder;
  unsigned Indentation;

public:
  StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
                         const Twine &PlaceHolder, unsigned Indentation)
      : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
        Indentation(Indentation) {}

  friend raw_ostream &operator<<(raw_ostream &OS,
                                 const StreamedQualTypeHelper &SQT) {
    SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
    return OS;
  }
};

StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
                              const Twine &PlaceHolder = Twine(),
                              unsigned Indentation = 0) const {
  return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
}

void dump(const char *s) const;
void dump() const;
void dump(llvm::raw_ostream &OS) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddPointer(getAsOpaquePtr());
}

/// Return the address space of this type.
inline LangAS getAddressSpace() const;

/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;

/// true when Type is objc's weak.
bool isObjCGCWeak() const {
  return getObjCGCAttr() == Qualifiers::Weak;
}

/// true when Type is objc's strong.
bool isObjCGCStrong() const {
  return getObjCGCAttr() == Qualifiers::Strong;
}

/// Returns lifetime attribute of this type.
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return getQualifiers().getObjCLifetime();
}

bool hasNonTrivialObjCLifetime() const {
  return getQualifiers().hasNonTrivialObjCLifetime();
}

bool hasStrongOrWeakObjCLifetime() const {
  return getQualifiers().hasStrongOrWeakObjCLifetime();
}

// true when Type is objc's weak and weak is enabled but ARC isn't.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;

enum PrimitiveDefaultInitializeKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PDIK_Trivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PDIK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PDIK_ARCWeak,

  /// The type is a struct containing a field whose type is not PCK_Trivial.
  PDIK_Struct
};

/// Functions to query basic properties of non-trivial C struct types.

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to default initialize
/// and return the kind.
PrimitiveDefaultInitializeKind
isNonTrivialToPrimitiveDefaultInitialize() const;

enum PrimitiveCopyKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PCK_Trivial,

  /// The type would be trivial except that it is volatile-qualified. Types
  /// that fall into one of the other non-trivial cases may additionally be
  /// volatile-qualified.
  PCK_VolatileTrivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PCK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PCK_ARCWeak,

  /// The type is a struct containing a field whose type is neither
  /// PCK_Trivial nor PCK_VolatileTrivial.
  /// Note that a C++ struct type does not necessarily match this; C++ copying
  /// semantics are too complex to express here, in part because they depend
  /// on the exact constructor or assignment operator that is chosen by
  /// overload resolution to do the copy.
  PCK_Struct
};

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to copy and return the
/// kind.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to destructively
/// move and return the kind. Destructive move in this context is a C++-style
/// move in which the source object is placed in a valid but unspecified state
/// after it is moved, as opposed to a truly destructive move in which the
/// source object is placed in an uninitialized state.
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;

enum DestructionKind {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime,
  DK_nontrivial_c_struct
};

/// Returns a nonzero value if objects of this type require
/// non-trivial work to clean up after.  Non-zero because it's
/// conceivable that qualifiers (objc_gc(weak)?) could make
/// something require destruction.
DestructionKind isDestructedType() const {
  return isDestructedTypeImpl(*this);
}

/// Check if this is or contains a C union that is non-trivial to
/// default-initialize, which is a union that has a member that is non-trivial
/// to default-initialize. If this returns true,
/// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;

/// Check if this is or contains a C union that is non-trivial to destruct,
/// which is a union that has a member that is non-trivial to destruct. If
/// this returns true, isDestructedType returns DK_nontrivial_c_struct.
bool hasNonTrivialToPrimitiveDestructCUnion() const;

/// Check if this is or contains a C union that is non-trivial to copy, which
/// is a union that has a member that is non-trivial to copy. If this returns
/// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
bool hasNonTrivialToPrimitiveCopyCUnion() const;

/// Determine whether expressions of the given type are forbidden
/// from being lvalues in C.
///
/// The expression types that are forbidden to be lvalues are:
///   - 'void', but not qualified void
///   - function types
///
/// The exact rule here is C99 6.3.2.1:
///   An lvalue is an expression with an object type or an incomplete
///   type other than void.
bool isCForbiddenLValueType() const;

/// Substitute type arguments for the Objective-C type parameters used in the
/// subject type.
///
/// \param ctx ASTContext in which the type exists.
///
/// \param typeArgs The type arguments that will be substituted for the
/// Objective-C type parameters in the subject type, which are generally
/// computed via \c Type::getObjCSubstitutions. If empty, the type
/// parameters will be replaced with their bounds or id/Class, as appropriate
/// for the context.
///
/// \param context The context in which the subject type was written.
///
/// \returns the resulting type.
QualType substObjCTypeArgs(ASTContext &ctx,
                           ArrayRef<QualType> typeArgs,
                           ObjCSubstitutionContext context) const;

/// Substitute type arguments from an object type for the Objective-C type
/// parameters used in the subject type.
///
/// This operation combines the computation of type arguments for
/// substitution (\c Type::getObjCSubstitutions) with the actual process of
/// substitution (\c QualType::substObjCTypeArgs) for the convenience of
/// callers that need to perform a single substitution in isolation.
///
/// \param objectType The type of the object whose member type we're
/// substituting into. For example, this might be the receiver of a message
/// or the base of a property access.
///
/// \param dc The declaration context from which the subject type was
/// retrieved, which indicates (for example) which type parameters should
/// be substituted.
///
/// \param context The context in which the subject type was written.
///
/// \returns the subject type after replacing all of the Objective-C type
/// parameters with their corresponding arguments.
QualType substObjCMemberType(QualType objectType,
                             const DeclContext *dc,
                             ObjCSubstitutionContext context) const;

/// Strip Objective-C "__kindof" types from the given type.
QualType stripObjCKindOfType(const ASTContext &ctx) const;

/// Remove all qualifiers including _Atomic.
QualType getAtomicUnqualifiedType() const;

1240private:
// These methods are implemented in a separate translation unit;
// "static"-ize them to avoid creating temporary QualTypes in the
// caller.
static bool isConstant(QualType T, const ASTContext& Ctx);
static QualType getDesugaredType(QualType T, const ASTContext &Context);
static SplitQualType getSplitDesugaredType(QualType T);
static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
static QualType getSingleStepDesugaredTypeImpl(QualType type,
                                               const ASTContext &C);
static QualType IgnoreParens(QualType T);
static DestructionKind isDestructedTypeImpl(QualType type);

/// Check if \param RD is or contains a non-trivial C union.
static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1257};

1259} // namespace clang

1261namespace llvm {

1263/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1264/// to a specific Type class.
1265template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1271};

1273// Teach SmallPtrSet that QualType is "basically a pointer".
1274template<>
1275struct PointerLikeTypeTraits<clang::QualType> {
static inline void *getAsVoidPointer(clang::QualType P) {
  return P.getAsOpaquePtr();
}

static inline clang::QualType getFromVoidPointer(void *P) {
  return clang::QualType::getFromOpaquePtr(P);
}

// Various qualifiers go in low bits.
enum { NumLowBitsAvailable = 0 };
1286};

1288} // namespace llvm

1290namespace clang {

1292/// Base class that is common to both the \c ExtQuals and \c Type
1293/// classes, which allows \c QualType to access the common fields between the
1294/// two.
1295class ExtQualsTypeCommonBase {
friend class ExtQuals;
friend class QualType;
friend class Type;

/// The "base" type of an extended qualifiers type (\c ExtQuals) or
/// a self-referential pointer (for \c Type).
///
/// This pointer allows an efficient mapping from a QualType to its
/// underlying type pointer.
const Type *const BaseType;

/// The canonical type of this type.  A QualType.
QualType CanonicalType;

ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
    : BaseType(baseType), CanonicalType(canon) {}
1312};

1314/// We can encode up to four bits in the low bits of a
1315/// type pointer, but there are many more type qualifiers that we want
1316/// to be able to apply to an arbitrary type.  Therefore we have this
1317/// struct, intended to be heap-allocated and used by QualType to
1318/// store qualifiers.
1319///
1320/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1321/// in three low bits on the QualType pointer; a fourth bit records whether
1322/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1323/// Objective-C GC attributes) are much more rare.
1324class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
// NOTE: changing the fast qualifiers should be straightforward as
// long as you don't make 'const' non-fast.
// 1. Qualifiers:
//    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
//       Fast qualifiers must occupy the low-order bits.
//    b) Update Qualifiers::FastWidth and FastMask.
// 2. QualType:
//    a) Update is{Volatile,Restrict}Qualified(), defined inline.
//    b) Update remove{Volatile,Restrict}, defined near the end of
//       this header.
// 3. ASTContext:
//    a) Update get{Volatile,Restrict}Type.

/// The immutable set of qualifiers applied by this node. Always contains
/// extended qualifiers.
Qualifiers Quals;

ExtQuals *this_() { return this; }

1344public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1350, __PRETTY_FUNCTION__))
         && "ExtQuals created with no fast qualifiers")((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1350, __PRETTY_FUNCTION__));
  assert(!Quals.hasFastQualifiers()((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1352, __PRETTY_FUNCTION__))
         && "ExtQuals created with fast qualifiers")((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1352, __PRETTY_FUNCTION__));
}

Qualifiers getQualifiers() const { return Quals; }

bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }

bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return Quals.getObjCLifetime();
}

bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
LangAS getAddressSpace() const { return Quals.getAddressSpace(); }

const Type *getBaseType() const { return BaseType; }

1370public:
void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, getBaseType(), Quals);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const Type *BaseType,
                    Qualifiers Quals) {
  assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"fast qualifiers in ExtQuals hash!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1378, __PRETTY_FUNCTION__));
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1382};

1384/// The kind of C++11 ref-qualifier associated with a function type.
1385/// This determines whether a member function's "this" object can be an
1386/// lvalue, rvalue, or neither.
1387enum RefQualifierKind {
/// No ref-qualifier was provided.
RQ_None = 0,

/// An lvalue ref-qualifier was provided (\c &).
RQ_LValue,

/// An rvalue ref-qualifier was provided (\c &&).
RQ_RValue
1396};

1398/// Which keyword(s) were used to create an AutoType.
1399enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1408};

1410/// The base class of the type hierarchy.
1411///
1412/// A central concept with types is that each type always has a canonical
1413/// type.  A canonical type is the type with any typedef names stripped out
1414/// of it or the types it references.  For example, consider:
1415///
1416///  typedef int  foo;
1417///  typedef foo* bar;
1418///    'int *'    'foo *'    'bar'
1419///
1420/// There will be a Type object created for 'int'.  Since int is canonical, its
1421/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1422/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1423/// there is a PointerType that represents 'int*', which, like 'int', is
1424/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1425/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1426/// is also 'int*'.
1427///
1428/// Non-canonical types are useful for emitting diagnostics, without losing
1429/// information about typedefs being used.  Canonical types are useful for type
1430/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1431/// about whether something has a particular form (e.g. is a function type),
1432/// because they implicitly, recursively, strip all typedefs out of a type.
1433///
1434/// Types, once created, are immutable.
1435///
1436class alignas(8) Type : public ExtQualsTypeCommonBase {
1437public:
enum TypeClass {
1439#define TYPE(Class, Base) Class,
1440#define LAST_TYPE(Class) TypeLast = Class
1441#define ABSTRACT_TYPE(Class, Base)
1442#include "clang/AST/TypeNodes.inc"
};

1445private:
/// Bitfields required by the Type class.
class TypeBitfields {
  friend class Type;
  template <class T> friend class TypePropertyCache;

  /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
  unsigned TC : 8;

  /// Whether this type is a dependent type (C++ [temp.dep.type]).
  unsigned Dependent : 1;

  /// Whether this type somehow involves a template parameter, even
  /// if the resolution of the type does not depend on a template parameter.
  unsigned InstantiationDependent : 1;

  /// Whether this type is a variably-modified type (C99 6.7.5).
  unsigned VariablyModified : 1;

  /// Whether this type contains an unexpanded parameter pack
  /// (for C++11 variadic templates).
  unsigned ContainsUnexpandedParameterPack : 1;

  /// True if the cache (i.e. the bitfields here starting with
  /// 'Cache') is valid.
  mutable unsigned CacheValid : 1;

  /// Linkage of this type.
  mutable unsigned CachedLinkage : 3;

  /// Whether this type involves and local or unnamed types.
  mutable unsigned CachedLocalOrUnnamed : 1;

  /// Whether this type comes from an AST file.
  mutable unsigned FromAST : 1;

  bool isCacheValid() const {
    return CacheValid;
  }

  Linkage getLinkage() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1486, __PRETTY_FUNCTION__));
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 1491, __PRETTY_FUNCTION__));
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 18 };

1497protected:
// These classes allow subclasses to somewhat cleanly pack bitfields
// into Type.

class ArrayTypeBitfields {
  friend class ArrayType;

  unsigned : NumTypeBits;

  /// CVR qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  unsigned IndexTypeQuals : 3;

  /// Storage class qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  /// Actually an ArrayType::ArraySizeModifier.
  unsigned SizeModifier : 3;
};

class BuiltinTypeBitfields {
  friend class BuiltinType;

  unsigned : NumTypeBits;

  /// The kind (BuiltinType::Kind) of builtin type this is.
  unsigned Kind : 8;
};

/// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
/// Only common bits are stored here. Additional uncommon bits are stored
/// in a trailing object after FunctionProtoType.
class FunctionTypeBitfields {
  friend class FunctionProtoType;
  friend class FunctionType;

  unsigned : NumTypeBits;

  /// Extra information which affects how the function is called, like
  /// regparm and the calling convention.
  unsigned ExtInfo : 12;

  /// The ref-qualifier associated with a \c FunctionProtoType.
  ///
  /// This is a value of type \c RefQualifierKind.
  unsigned RefQualifier : 2;

  /// Used only by FunctionProtoType, put here to pack with the
  /// other bitfields.
  /// The qualifiers are part of FunctionProtoType because...
  ///
  /// C++ 8.3.5p4: The return type, the parameter type list and the
  /// cv-qualifier-seq, [...], are part of the function type.
  unsigned FastTypeQuals : Qualifiers::FastWidth;
  /// Whether this function has extended Qualifiers.
  unsigned HasExtQuals : 1;

  /// The number of parameters this function has, not counting '...'.
  /// According to [implimits] 8 bits should be enough here but this is
  /// somewhat easy to exceed with metaprogramming and so we would like to
  /// keep NumParams as wide as reasonably possible.
  unsigned NumParams : 16;

  /// The type of exception specification this function has.
  unsigned ExceptionSpecType : 4;

  /// Whether this function has extended parameter information.
  unsigned HasExtParameterInfos : 1;

  /// Whether the function is variadic.
  unsigned Variadic : 1;

  /// Whether this function has a trailing return type.
  unsigned HasTrailingReturn : 1;
};

class ObjCObjectTypeBitfields {
  friend class ObjCObjectType;

  unsigned : NumTypeBits;

  /// The number of type arguments stored directly on this object type.
  unsigned NumTypeArgs : 7;

  /// The number of protocols stored directly on this object type.
  unsigned NumProtocols : 6;

  /// Whether this is a "kindof" type.
  unsigned IsKindOf : 1;
};

class ReferenceTypeBitfields {
  friend class ReferenceType;

  unsigned : NumTypeBits;

  /// True if the type was originally spelled with an lvalue sigil.
  /// This is never true of rvalue references but can also be false
  /// on lvalue references because of C++0x [dcl.typedef]p9,
  /// as follows:
  ///
  ///   typedef int &ref;    // lvalue, spelled lvalue
  ///   typedef int &&rvref; // rvalue
  ///   ref &a;              // lvalue, inner ref, spelled lvalue
  ///   ref &&a;             // lvalue, inner ref
  ///   rvref &a;            // lvalue, inner ref, spelled lvalue
  ///   rvref &&a;           // rvalue, inner ref
  unsigned SpelledAsLValue : 1;

  /// True if the inner type is a reference type.  This only happens
  /// in non-canonical forms.
  unsigned InnerRef : 1;
};

class TypeWithKeywordBitfields {
  friend class TypeWithKeyword;

  unsigned : NumTypeBits;

  /// An ElaboratedTypeKeyword.  8 bits for efficient access.
  unsigned Keyword : 8;
};

enum { NumTypeWithKeywordBits = 8 };

class ElaboratedTypeBitfields {
  friend class ElaboratedType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// Whether the ElaboratedType has a trailing OwnedTagDecl.
  unsigned HasOwnedTagDecl : 1;
};

class VectorTypeBitfields {
  friend class VectorType;
  friend class DependentVectorType;

  unsigned : NumTypeBits;

  /// The kind of vector, either a generic vector type or some
  /// target-specific vector type such as for AltiVec or Neon.
  unsigned VecKind : 3;

  /// The number of elements in the vector.
  unsigned NumElements : 29 - NumTypeBits;

  enum { MaxNumElements = (1 << (29 - NumTypeBits)) - 1 };
};

class AttributedTypeBitfields {
  friend class AttributedType;

  unsigned : NumTypeBits;

  /// An AttributedType::Kind
  unsigned AttrKind : 32 - NumTypeBits;
};

class AutoTypeBitfields {
  friend class AutoType;

  unsigned : NumTypeBits;

  /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
  /// or '__auto_type'?  AutoTypeKeyword value.
  unsigned Keyword : 2;
};

class SubstTemplateTypeParmPackTypeBitfields {
  friend class SubstTemplateTypeParmPackType;

  unsigned : NumTypeBits;

  /// The number of template arguments in \c Arguments, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class TemplateSpecializationTypeBitfields {
  friend class TemplateSpecializationType;

  unsigned : NumTypeBits;

  /// Whether this template specialization type is a substituted type alias.
  unsigned TypeAlias : 1;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class DependentTemplateSpecializationTypeBitfields {
  friend class DependentTemplateSpecializationType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class PackExpansionTypeBitfields {
  friend class PackExpansionType;

  unsigned : NumTypeBits;

  /// The number of expansions that this pack expansion will
  /// generate when substituted (+1), which is expected to be able to
  /// hold at least 1024 according to [implimits]. However, as this limit
  /// is somewhat easy to hit with template metaprogramming we'd prefer to
  /// keep it as large as possible. At the moment it has been left as a
  /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
  /// there is no reason to introduce the performance impact of a bitfield.
  ///
  /// This field will only have a non-zero value when some of the parameter
  /// packs that occur within the pattern have been substituted but others
  /// have not.
  unsigned NumExpansions;
};

union {
  TypeBitfields TypeBits;
  ArrayTypeBitfields ArrayTypeBits;
  AttributedTypeBitfields AttributedTypeBits;
  AutoTypeBitfields AutoTypeBits;
  BuiltinTypeBitfields BuiltinTypeBits;
  FunctionTypeBitfields FunctionTypeBits;
  ObjCObjectTypeBitfields ObjCObjectTypeBits;
  ReferenceTypeBitfields ReferenceTypeBits;
  TypeWithKeywordBitfields TypeWithKeywordBits;
  ElaboratedTypeBitfields ElaboratedTypeBits;
  VectorTypeBitfields VectorTypeBits;
  SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
  TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
  DependentTemplateSpecializationTypeBitfields
    DependentTemplateSpecializationTypeBits;
  PackExpansionTypeBitfields PackExpansionTypeBits;

  static_assert(sizeof(TypeBitfields) <= 8,
                "TypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ArrayTypeBitfields) <= 8,
                "ArrayTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(AttributedTypeBitfields) <= 8,
                "AttributedTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(AutoTypeBitfields) <= 8,
                "AutoTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(BuiltinTypeBitfields) <= 8,
                "BuiltinTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(FunctionTypeBitfields) <= 8,
                "FunctionTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ObjCObjectTypeBitfields) <= 8,
                "ObjCObjectTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(ReferenceTypeBitfields) <= 8,
                "ReferenceTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(TypeWithKeywordBitfields) <= 8,
                "TypeWithKeywordBitfields is larger than 8 bytes!");
  static_assert(sizeof(ElaboratedTypeBitfields) <= 8,
                "ElaboratedTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(VectorTypeBitfields) <= 8,
                "VectorTypeBitfields is larger than 8 bytes!");
  static_assert(sizeof(SubstTemplateTypeParmPackTypeBitfields) <= 8,
                "SubstTemplateTypeParmPackTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(TemplateSpecializationTypeBitfields) <= 8,
                "TemplateSpecializationTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(DependentTemplateSpecializationTypeBitfields) <= 8,
                "DependentTemplateSpecializationTypeBitfields is larger"
                " than 8 bytes!");
  static_assert(sizeof(PackExpansionTypeBitfields) <= 8,
                "PackExpansionTypeBitfields is larger than 8 bytes");
};

1787private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1795protected:
friend class ASTContext;

Type(TypeClass tc, QualType canon, bool Dependent,
     bool InstantiationDependent, bool VariablyModified,
     bool ContainsUnexpandedParameterPack)
    : ExtQualsTypeCommonBase(this,
                             canon.isNull() ? QualType(this_(), 0) : canon) {
  TypeBits.TC = tc;
  TypeBits.Dependent = Dependent;
  TypeBits.InstantiationDependent = Dependent || InstantiationDependent;
  TypeBits.VariablyModified = VariablyModified;
  TypeBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
  TypeBits.CacheValid = false;
  TypeBits.CachedLocalOrUnnamed = false;
  TypeBits.CachedLinkage = NoLinkage;
  TypeBits.FromAST = false;
}

// silence VC++ warning C4355: 'this' : used in base member initializer list
Type *this_() { return this; }

void setDependent(bool D = true) {
  TypeBits.Dependent = D;
  if (D)
    TypeBits.InstantiationDependent = true;
}

void setInstantiationDependent(bool D = true) {
  TypeBits.InstantiationDependent = D; }

void setVariablyModified(bool VM = true) { TypeBits.VariablyModified = VM; }

void setContainsUnexpandedParameterPack(bool PP = true) {
  TypeBits.ContainsUnexpandedParameterPack = PP;
}

1832public:
friend class ASTReader;
friend class ASTWriter;

Type(const Type &) = delete;
Type(Type &&) = delete;
Type &operator=(const Type &) = delete;
Type &operator=(Type &&) = delete;

TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }

/// Whether this type comes from an AST file.
bool isFromAST() const { return TypeBits.FromAST; }

/// Whether this type is or contains an unexpanded parameter
/// pack, used to support C++0x variadic templates.
///
/// A type that contains a parameter pack shall be expanded by the
/// ellipsis operator at some point. For example, the typedef in the
/// following example contains an unexpanded parameter pack 'T':
///
/// \code
/// template<typename ...T>
/// struct X {
///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
/// };
/// \endcode
///
/// Note that this routine does not specify which
bool containsUnexpandedParameterPack() const {
  return TypeBits.ContainsUnexpandedParameterPack;
}

/// Determines if this type would be canonical if it had no further
/// qualification.
bool isCanonicalUnqualified() const {
  return CanonicalType == QualType(this, 0);
}

/// Pull a single level of sugar off of this locally-unqualified type.
/// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
/// or QualType::getSingleStepDesugaredType(const ASTContext&).
QualType getLocallyUnqualifiedSingleStepDesugaredType() const;

/// Types are partitioned into 3 broad categories (C99 6.2.5p1):
/// object types, function types, and incomplete types.

/// Return true if this is an incomplete type.
/// A type that can describe objects, but which lacks information needed to
/// determine its size (e.g. void, or a fwd declared struct). Clients of this
/// routine will need to determine if the size is actually required.
///
/// Def If non-null, and the type refers to some kind of declaration
/// that can be completed (such as a C struct, C++ class, or Objective-C
/// class), will be set to the declaration.
bool isIncompleteType(NamedDecl **Def = nullptr) const;

/// Return true if this is an incomplete or object
/// type, in other words, not a function type.
bool isIncompleteOrObjectType() const {
  return !isFunctionType();
}

/// Determine whether this type is an object type.
bool isObjectType() const {
  // C++ [basic.types]p8:
  //   An object type is a (possibly cv-qualified) type that is not a
  //   function type, not a reference type, and not a void type.
  return !isReferenceType() && !isFunctionType() && !isVoidType();
}

/// Return true if this is a literal type
/// (C++11 [basic.types]p10)
bool isLiteralType(const ASTContext &Ctx) const;

/// Test if this type is a standard-layout type.
/// (C++0x [basic.type]p9)
bool isStandardLayoutType() const;

/// Helper methods to distinguish type categories. All type predicates
/// operate on the canonical type, ignoring typedefs and qualifiers.

/// Returns true if the type is a builtin type.
bool isBuiltinType() const;

/// Test for a particular builtin type.
bool isSpecificBuiltinType(unsigned K) const;

/// Test for a type which does not represent an actual type-system type but
/// is instead used as a placeholder for various convenient purposes within
/// Clang.  All such types are BuiltinTypes.
bool isPlaceholderType() const;
const BuiltinType *getAsPlaceholderType() const;

/// Test for a specific placeholder type.
bool isSpecificPlaceholderType(unsigned K) const;

/// Test for a placeholder type other than Overload; see
/// BuiltinType::isNonOverloadPlaceholderType.
bool isNonOverloadPlaceholderType() const;

/// isIntegerType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
bool isEnumeralType() const;

/// Determine whether this type is a scoped enumeration type.
bool isScopedEnumeralType() const;
bool isBooleanType() const;
bool isCharType() const;
bool isWideCharType() const;
bool isChar8Type() const;
bool isChar16Type() const;
bool isChar32Type() const;
bool isAnyCharacterType() const;
bool isIntegralType(const ASTContext &Ctx) const;

/// Determine whether this type is an integral or enumeration type.
bool isIntegralOrEnumerationType() const;

/// Determine whether this type is an integral or unscoped enumeration type.
bool isIntegralOrUnscopedEnumerationType() const;

/// Floating point categories.
bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
/// isComplexType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isComplexType() const;      // C99 6.2.5p11 (complex)
bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
bool isFloat128Type() const;
bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
bool isVoidType() const;         // C99 6.2.5p19
bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
bool isAggregateType() const;
bool isFundamentalType() const;
bool isCompoundType() const;

// Type Predicates: Check to see if this type is structurally the specified
// type, ignoring typedefs and qualifiers.
bool isFunctionType() const;
bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
bool isPointerType() const;
bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
bool isBlockPointerType() const;
bool isVoidPointerType() const;
bool isReferenceType() const;
bool isLValueReferenceType() const;
bool isRValueReferenceType() const;
bool isFunctionPointerType() const;
bool isFunctionReferenceType() const;
bool isMemberPointerType() const;
bool isMemberFunctionPointerType() const;
bool isMemberDataPointerType() const;
bool isArrayType() const;
bool isConstantArrayType() const;
bool isIncompleteArrayType() const;
bool isVariableArrayType() const;
bool isDependentSizedArrayType() const;
bool isRecordType() const;
bool isClassType() const;
bool isStructureType() const;
bool isObjCBoxableRecordType() const;
bool isInterfaceType() const;
bool isStructureOrClassType() const;
bool isUnionType() const;
bool isComplexIntegerType() const;            // GCC _Complex integer type.
bool isVectorType() const;                    // GCC vector type.
bool isExtVectorType() const;                 // Extended vector type.
bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
bool isObjCObjectPointerType() const;         // pointer to ObjC object
bool isObjCRetainableType() const;            // ObjC object or block pointer
bool isObjCLifetimeType() const;              // (array of)* retainable type
bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
bool isObjCNSObjectType() const;              // __attribute__((NSObject))
bool isObjCIndependentClassType() const;      // __attribute__((objc_independent_class))
// FIXME: change this to 'raw' interface type, so we can used 'interface' type
// for the common case.
bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
bool isObjCQualifiedIdType() const;           // id<foo>
bool isObjCQualifiedClassType() const;        // Class<foo>
bool isObjCObjectOrInterfaceType() const;
bool isObjCIdType() const;                    // id
bool isDecltypeType() const;
/// Was this type written with the special inert-in-ARC __unsafe_unretained
/// qualifier?
///
/// This approximates the answer to the following question: if this
/// translation unit were compiled in ARC, would this type be qualified
/// with __unsafe_unretained?
bool isObjCInertUnsafeUnretainedType() const {
  return hasAttr(attr::ObjCInertUnsafeUnretained);
}

/// Whether the type is Objective-C 'id' or a __kindof type of an
/// object type, e.g., __kindof NSView * or __kindof id
/// <NSCopying>.
///
/// \param bound Will be set to the bound on non-id subtype types,
/// which will be (possibly specialized) Objective-C class type, or
/// null for 'id.
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
                                const ObjCObjectType *&bound) const;

bool isObjCClassType() const;                 // Class

/// Whether the type is Objective-C 'Class' or a __kindof type of an
/// Class type, e.g., __kindof Class <NSCopying>.
///
/// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
/// here because Objective-C's type system cannot express "a class
/// object for a subclass of NSFoo".
bool isObjCClassOrClassKindOfType() const;

bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
bool isObjCSelType() const;                 // Class
bool isObjCBuiltinType() const;               // 'id' or 'Class'
bool isObjCARCBridgableType() const;
bool isCARCBridgableType() const;
bool isTemplateTypeParmType() const;          // C++ template type parameter
bool isNullPtrType() const;                   // C++11 std::nullptr_t
bool isNothrowT() const;                      // C++   std::nothrow_t
bool isAlignValT() const;                     // C++17 std::align_val_t
bool isStdByteType() const;                   // C++17 std::byte
bool isAtomicType() const;                    // C11 _Atomic()

2063#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2065#include "clang/Basic/OpenCLImageTypes.def"

bool isImageType() const;                     // Any OpenCL image type

bool isSamplerT() const;                      // OpenCL sampler_t
bool isEventT() const;                        // OpenCL event_t
bool isClkEventT() const;                     // OpenCL clk_event_t
bool isQueueT() const;                        // OpenCL queue_t
bool isReserveIDT() const;                    // OpenCL reserve_id_t

2075#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2077#include "clang/Basic/OpenCLExtensionTypes.def"
// Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
bool isOCLIntelSubgroupAVCType() const;
bool isOCLExtOpaqueType() const;              // Any OpenCL extension type

bool isPipeType() const;                      // OpenCL pipe type
bool isOpenCLSpecificType() const;            // Any OpenCL specific type

/// Determines if this type, which must satisfy
/// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
/// than implicitly __strong.
bool isObjCARCImplicitlyUnretainedType() const;

/// Return the implicit lifetime for this type, which must not be dependent.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;

enum ScalarTypeKind {
  STK_CPointer,
  STK_BlockPointer,
  STK_ObjCObjectPointer,
  STK_MemberPointer,
  STK_Bool,
  STK_Integral,
  STK_Floating,
  STK_IntegralComplex,
  STK_FloatingComplex,
  STK_FixedPoint
};

/// Given that this is a scalar type, classify it.
ScalarTypeKind getScalarTypeKind() const;

/// Whether this type is a dependent type, meaning that its definition
/// somehow depends on a template parameter (C++ [temp.dep.type]).
bool isDependentType() const { return TypeBits.Dependent; }

/// Determine whether this type is an instantiation-dependent type,
/// meaning that the type involves a template parameter (even if the
/// definition does not actually depend on the type substituted for that
/// template parameter).
bool isInstantiationDependentType() const {
  return TypeBits.InstantiationDependent;
}

/// Determine whether this type is an undeduced type, meaning that
/// it somehow involves a C++11 'auto' type or similar which has not yet been
/// deduced.
bool isUndeducedType() const;

/// Whether this type is a variably-modified type (C99 6.7.5).
bool isVariablyModifiedType() const { return TypeBits.VariablyModified; }

/// Whether this type involves a variable-length array type
/// with a definite size.
bool hasSizedVLAType() const;

/// Whether this type is or contains a local or unnamed type.
bool hasUnnamedOrLocalType() const;

bool isOverloadableType() const;

/// Determine wither this type is a C++ elaborated-type-specifier.
bool isElaboratedTypeSpecifier() const;

bool canDecayToPointerType() const;

/// Whether this type is represented natively as a pointer.  This includes
/// pointers, references, block pointers, and Objective-C interface,
/// qualified id, and qualified interface types, as well as nullptr_t.
bool hasPointerRepresentation() const;

/// Whether this type can represent an objective pointer type for the
/// purpose of GC'ability
bool hasObjCPointerRepresentation() const;

/// Determine whether this type has an integer representation
/// of some sort, e.g., it is an integer type or a vector.
bool hasIntegerRepresentation() const;

/// Determine whether this type has an signed integer representation
/// of some sort, e.g., it is an signed integer type or a vector.
bool hasSignedIntegerRepresentation() const;

/// Determine whether this type has an unsigned integer representation
/// of some sort, e.g., it is an unsigned integer type or a vector.
bool hasUnsignedIntegerRepresentation() const;

/// Determine whether this type has a floating-point representation
/// of some sort, e.g., it is a floating-point type or a vector thereof.
bool hasFloatingRepresentation() const;

// Type Checking Functions: Check to see if this type is structurally the
// specified type, ignoring typedefs and qualifiers, and return a pointer to
// the best type we can.
const RecordType *getAsStructureType() const;
/// NOTE: getAs*ArrayType are methods on ASTContext.
const RecordType *getAsUnionType() const;
const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
const ObjCObjectType *getAsObjCInterfaceType() const;

// The following is a convenience method that returns an ObjCObjectPointerType
// for object declared using an interface.
const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;

/// Retrieves the CXXRecordDecl that this type refers to, either
/// because the type is a RecordType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
CXXRecordDecl *getAsCXXRecordDecl() const;

/// Retrieves the RecordDecl this type refers to.
RecordDecl *getAsRecordDecl() const;

/// Retrieves the TagDecl that this type refers to, either
/// because the type is a TagType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
TagDecl *getAsTagDecl() const;

/// If this is a pointer or reference to a RecordType, return the
/// CXXRecordDecl that the type refers to.
///
/// If this is not a pointer or reference, or the type being pointed to does
/// not refer to a CXXRecordDecl, returns NULL.
const CXXRecordDecl *getPointeeCXXRecordDecl() const;

/// Get the DeducedType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
DeducedType *getContainedDeducedType() const;

/// Get the AutoType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
AutoType *getContainedAutoType() const {
  return dyn_cast_or_null<AutoType>(getContainedDeducedType());
}

/// Determine whether this type was written with a leading 'auto'
/// corresponding to a trailing return type (possibly for a nested
/// function type within a pointer to function type or similar).
bool hasAutoForTrailingReturnType() const;

/// Member-template getAs<specific type>'.  Look through sugar for
/// an instance of \<specific type>.   This scheme will eventually
/// replace the specific getAsXXXX methods above.
///
/// There are some specializations of this member template listed
/// immediately following this class.
template <typename T> const T *getAs() const;

/// Member-template getAsAdjusted<specific type>. Look through specific kinds
/// of sugar (parens, attributes, etc) for an instance of \<specific type>.
/// This is used when you need to walk over sugar nodes that represent some
/// kind of type adjustment from a type that was written as a \<specific type>
/// to another type that is still canonically a \<specific type>.
template <typename T> const T *getAsAdjusted() const;

/// A variant of getAs<> for array types which silently discards
/// qualifiers from the outermost type.
const ArrayType *getAsArrayTypeUnsafe() const;

/// Member-template castAs<specific type>.  Look through sugar for
/// the underlying instance of \<specific type>.
///
/// This method has the same relationship to getAs<T> as cast<T> has
/// to dyn_cast<T>; which is to say, the underlying type *must*
/// have the intended type, and this method will never return null.
template <typename T> const T *castAs() const;

/// A variant of castAs<> for array type which silently discards
/// qualifiers from the outermost type.
const ArrayType *castAsArrayTypeUnsafe() const;

/// Determine whether this type had the specified attribute applied to it
/// (looking through top-level type sugar).
bool hasAttr(attr::Kind AK) const;

/// Get the base element type of this type, potentially discarding type
/// qualifiers.  This should never be used when type qualifiers
/// are meaningful.
const Type *getBaseElementTypeUnsafe() const;

/// If this is an array type, return the element type of the array,
/// potentially with type qualifiers missing.
/// This should never be used when type qualifiers are meaningful.
const Type *getArrayElementTypeNoTypeQual() const;

/// If this is a pointer type, return the pointee type.
/// If this is an array type, return the array element type.
/// This should never be used when type qualifiers are meaningful.
const Type *getPointeeOrArrayElementType() const;

/// If this is a pointer, ObjC object pointer, or block
/// pointer, this returns the respective pointee.
QualType getPointeeType() const;

/// Return the specified type with any "sugar" removed from the type,
/// removing any typedefs, typeofs, etc., as well as any qualifiers.
const Type *getUnqualifiedDesugaredType() const;

/// More type predicates useful for type checking/promotion
bool isPromotableIntegerType() const; // C99 6.3.1.1p2

/// Return true if this is an integer type that is
/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
/// or an enum decl which has a signed representation.
bool isSignedIntegerType() const;

/// Return true if this is an integer type that is
/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
/// or an enum decl which has an unsigned representation.
bool isUnsignedIntegerType() const;

/// Determines whether this is an integer type that is signed or an
/// enumeration types whose underlying type is a signed integer type.
bool isSignedIntegerOrEnumerationType() const;

/// Determines whether this is an integer type that is unsigned or an
/// enumeration types whose underlying type is a unsigned integer type.
bool isUnsignedIntegerOrEnumerationType() const;

/// Return true if this is a fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169.
bool isFixedPointType() const;

/// Return true if this is a fixed point or integer type.
bool isFixedPointOrIntegerType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isSaturatedFixedPointType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isUnsaturatedFixedPointType() const;

/// Return true if this is a fixed point type that is signed according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isSignedFixedPointType() const;

/// Return true if this is a fixed point type that is unsigned according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isUnsignedFixedPointType() const;

/// Return true if this is not a variable sized type,
/// according to the rules of C99 6.7.5p3.  It is not legal to call this on
/// incomplete types.
bool isConstantSizeType() const;

/// Returns true if this type can be represented by some
/// set of type specifiers.
bool isSpecifierType() const;

/// Determine the linkage of this type.
Linkage getLinkage() const;

/// Determine the visibility of this type.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Return true if the visibility was explicitly set is the code.
bool isVisibilityExplicit() const {
  return getLinkageAndVisibility().isVisibilityExplicit();
}

/// Determine the linkage and visibility of this type.
LinkageInfo getLinkageAndVisibility() const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// Determine the nullability of the given type.
///
/// Note that nullability is only captured as sugar within the type
/// system, not as part of the canonical type, so nullability will
/// be lost by canonicalization and desugaring.
Optional<NullabilityKind> getNullability(const ASTContext &context) const;

/// Determine whether the given type can have a nullability
/// specifier applied to it, i.e., if it is any kind of pointer type.
///
/// \param ResultIfUnknown The value to return if we don't yet know whether
///        this type can have nullability because it is dependent.
bool canHaveNullability(bool ResultIfUnknown = true) const;

/// Retrieve the set of substitutions required when accessing a member
/// of the Objective-C receiver type that is declared in the given context.
///
/// \c *this is the type of the object we're operating on, e.g., the
/// receiver for a message send or the base of a property access, and is
/// expected to be of some object or object pointer type.
///
/// \param dc The declaration context for which we are building up a
/// substitution mapping, which should be an Objective-C class, extension,
/// category, or method within.
///
/// \returns an array of type arguments that can be substituted for
/// the type parameters of the given declaration context in any type described
/// within that context, or an empty optional to indicate that no
/// substitution is required.
Optional<ArrayRef<QualType>>
getObjCSubstitutions(const DeclContext *dc) const;

/// Determines if this is an ObjC interface type that may accept type
/// parameters.
bool acceptsObjCTypeParams() const;

const char *getTypeClassName() const;

QualType getCanonicalTypeInternal() const {
  return CanonicalType;
}

CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
void dump() const;
void dump(llvm::raw_ostream &OS) const;
2397};

2399/// This will check for a TypedefType by removing any existing sugar
2400/// until it reaches a TypedefType or a non-sugared type.
2401template <> const TypedefType *Type::getAs() const;

2403/// This will check for a TemplateSpecializationType by removing any
2404/// existing sugar until it reaches a TemplateSpecializationType or a
2405/// non-sugared type.
2406template <> const TemplateSpecializationType *Type::getAs() const;

2408/// This will check for an AttributedType by removing any existing sugar
2409/// until it reaches an AttributedType or a non-sugared type.
2410template <> const AttributedType *Type::getAs() const;

2412// We can do canonical leaf types faster, because we don't have to
2413// worry about preserving child type decoration.
2414#define TYPE(Class, Base)
2415#define LEAF_TYPE(Class) \
2416template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2418} \
2419template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2421}
2422#include "clang/AST/TypeNodes.inc"

2424/// This class is used for builtin types like 'int'.  Builtin
2425/// types are always canonical and have a literal name field.
2426class BuiltinType : public Type {
2427public:
enum Kind {
2429// OpenCL image types
2430#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2431#include "clang/Basic/OpenCLImageTypes.def"
2432// OpenCL extension types
2433#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2434#include "clang/Basic/OpenCLExtensionTypes.def"
2435// SVE Types
2436#define SVE_TYPE(Name, Id, SingletonId) Id,
2437#include "clang/Basic/AArch64SVEACLETypes.def"
2438// All other builtin types
2439#define BUILTIN_TYPE(Id, SingletonId) Id,
2440#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2441#include "clang/AST/BuiltinTypes.def"
};

2444private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent),
           /*InstantiationDependent=*/(K == Dependent),
           /*VariablyModified=*/false,
           /*Unexpanded parameter pack=*/false) {
  BuiltinTypeBits.Kind = K;
}

2455public:
Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
StringRef getName(const PrintingPolicy &Policy) const;

const char *getNameAsCString(const PrintingPolicy &Policy) const {
  // The StringRef is null-terminated.
  StringRef str = getName(Policy);
  assert(!str.empty() && str.data()[str.size()] == '\0')((!str.empty() && str.data()[str.size()] == '\0') ? static_cast
<void> (0) : __assert_fail ("!str.empty() && str.data()[str.size()] == '\\0'"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 2462, __PRETTY_FUNCTION__));
  return str.data();
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

bool isInteger() const {
  return getKind() >= Bool && getKind() <= Int128;
}

bool isSignedInteger() const {
  return getKind() >= Char_S && getKind() <= Int128;
}

bool isUnsignedInteger() const {
  return getKind() >= Bool && getKind() <= UInt128;
}

bool isFloatingPoint() const {
  return getKind() >= Half && getKind() <= Float128;
}

/// Determines whether the given kind corresponds to a placeholder type.
static bool isPlaceholderTypeKind(Kind K) {
  return K >= Overload;
}

/// Determines whether this type is a placeholder type, i.e. a type
/// which cannot appear in arbitrary positions in a fully-formed
/// expression.
bool isPlaceholderType() const {
  return isPlaceholderTypeKind(getKind());
}

/// Determines whether this type is a placeholder type other than
/// Overload.  Most placeholder types require only syntactic
/// information about their context in order to be resolved (e.g.
/// whether it is a call expression), which means they can (and
/// should) be resolved in an earlier "phase" of analysis.
/// Overload expressions sometimes pick up further information
/// from their context, like whether the context expects a
/// specific function-pointer type, and so frequently need
/// special treatment.
bool isNonOverloadPlaceholderType() const {
  return getKind() > Overload;
}

static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2511};

2513/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2514/// types (_Complex float etc) as well as the GCC integer complex extensions.
2515class ComplexType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;

ComplexType(QualType Element, QualType CanonicalPtr)
    : Type(Complex, CanonicalPtr, Element->isDependentType(),
           Element->isInstantiationDependentType(),
           Element->isVariablyModifiedType(),
           Element->containsUnexpandedParameterPack()),
      ElementType(Element) {}

2527public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
  ID.AddPointer(Element.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2542};

2544/// Sugar for parentheses used when specifying types.
2545class ParenType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType Inner;

ParenType(QualType InnerType, QualType CanonType)
    : Type(Paren, CanonType, InnerType->isDependentType(),
           InnerType->isInstantiationDependentType(),
           InnerType->isVariablyModifiedType(),
           InnerType->containsUnexpandedParameterPack()),
      Inner(InnerType) {}

2557public:
QualType getInnerType() const { return Inner; }

bool isSugared() const { return true; }
QualType desugar() const { return getInnerType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getInnerType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
  Inner.Profile(ID);
}

static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2572};

2574/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2575class PointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

PointerType(QualType Pointee, QualType CanonicalPtr)
    : Type(Pointer, CanonicalPtr, Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

2587public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if address spaces of pointers overlap.
/// OpenCL v2.0 defines conversion rules for pointers to different
/// address spaces (OpenCLC v2.0 s6.5.5) and notion of overlapping
/// address spaces.
/// CL1.1 or CL1.2:
///   address spaces overlap iff they are they same.
/// CL2.0 adds:
///   __generic overlaps with any address space except for __constant.
bool isAddressSpaceOverlapping(const PointerType &other) const {
  Qualifiers thisQuals = PointeeType.getQualifiers();
  Qualifiers otherQuals = other.getPointeeType().getQualifiers();
  // Address spaces overlap if at least one of them is a superset of another
  return thisQuals.isAddressSpaceSupersetOf(otherQuals) ||
         otherQuals.isAddressSpaceSupersetOf(thisQuals);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2618};

2620/// Represents a type which was implicitly adjusted by the semantic
2621/// engine for arbitrary reasons.  For example, array and function types can
2622/// decay, and function types can have their calling conventions adjusted.
2623class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2627protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->isDependentType(),
           OriginalTy->isInstantiationDependentType(),
           OriginalTy->isVariablyModifiedType(),
           OriginalTy->containsUnexpandedParameterPack()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2638public:
QualType getOriginalType() const { return OriginalTy; }
QualType getAdjustedType() const { return AdjustedTy; }

bool isSugared() const { return true; }
QualType desugar() const { return AdjustedTy; }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, OriginalTy, AdjustedTy);
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
  ID.AddPointer(Orig.getAsOpaquePtr());
  ID.AddPointer(New.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
}
2657};

2659/// Represents a pointer type decayed from an array or function type.
2660class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2666public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2672};

2674/// Pointer to a block type.
2675/// This type is to represent types syntactically represented as
2676/// "void (^)(int)", etc. Pointee is required to always be a function type.
2677class BlockPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

// Block is some kind of pointer type
QualType PointeeType;

BlockPointerType(QualType Pointee, QualType CanonicalCls)
    : Type(BlockPointer, CanonicalCls, Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

2690public:
// Get the pointee type. Pointee is required to always be a function type.
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
    Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
    ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == BlockPointer;
}
2708};

2710/// Base for LValueReferenceType and RValueReferenceType
2711class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2714protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->isDependentType(),
           Referencee->isInstantiationDependentType(),
           Referencee->isVariablyModifiedType(),
           Referencee->containsUnexpandedParameterPack()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2726public:
bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }

QualType getPointeeTypeAsWritten() const { return PointeeType; }

QualType getPointeeType() const {
  // FIXME: this might strip inner qualifiers; okay?
  const ReferenceType *T = this;
  while (T->isInnerRef())
    T = T->PointeeType->castAs<ReferenceType>();
  return T->PointeeType;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, PointeeType, isSpelledAsLValue());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Referencee,
                    bool SpelledAsLValue) {
  ID.AddPointer(Referencee.getAsOpaquePtr());
  ID.AddBoolean(SpelledAsLValue);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference ||
         T->getTypeClass() == RValueReference;
}
2755};

2757/// An lvalue reference type, per C++11 [dcl.ref].
2758class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2766public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2773};

2775/// An rvalue reference type, per C++11 [dcl.ref].
2776class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2782public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2789};

2791/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2792///
2793/// This includes both pointers to data members and pointer to member functions.
2794class MemberPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

/// The class of which the pointee is a member. Must ultimately be a
/// RecordType, but could be a typedef or a template parameter too.
const Type *Class;

MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
    : Type(MemberPointer, CanonicalPtr,
           Cls->isDependentType() || Pointee->isDependentType(),
           (Cls->isInstantiationDependentType() ||
            Pointee->isInstantiationDependentType()),
           Pointee->isVariablyModifiedType(),
           (Cls->containsUnexpandedParameterPack() ||
            Pointee->containsUnexpandedParameterPack())),
           PointeeType(Pointee), Class(Cls) {}

2813public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if the member type (i.e. the pointee type) is a
/// function type rather than a data-member type.
bool isMemberFunctionPointer() const {
  return PointeeType->isFunctionProtoType();
}

/// Returns true if the member type (i.e. the pointee type) is a
/// data type rather than a function type.
bool isMemberDataPointer() const {
  return !PointeeType->isFunctionProtoType();
}

const Type *getClass() const { return Class; }
CXXRecordDecl *getMostRecentCXXRecordDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType(), getClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
                    const Type *Class) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
  ID.AddPointer(Class);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == MemberPointer;
}
2847};

2849/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2850class ArrayType : public Type, public llvm::FoldingSetNode {
2851public:
/// Capture whether this is a normal array (e.g. int X[4])
/// an array with a static size (e.g. int X[static 4]), or an array
/// with a star size (e.g. int X[*]).
/// 'static' is only allowed on function parameters.
enum ArraySizeModifier {
  Normal, Static, Star
};

2860private:
/// The element type of the array.
QualType ElementType;

2864protected:
friend class ASTContext; // ASTContext creates these.

// C++ [temp.dep.type]p1:
//   A type is dependent if it is...
//     - an array type constructed from any dependent type or whose
//       size is specified by a constant expression that is
//       value-dependent,
ArrayType(TypeClass tc, QualType et, QualType can,
          ArraySizeModifier sm, unsigned tq,
          bool ContainsUnexpandedParameterPack)
    : Type(tc, can, et->isDependentType() || tc == DependentSizedArray,
           et->isInstantiationDependentType() || tc == DependentSizedArray,
           (tc == VariableArray || et->isVariablyModifiedType()),
           ContainsUnexpandedParameterPack),
      ElementType(et) {
  ArrayTypeBits.IndexTypeQuals = tq;
  ArrayTypeBits.SizeModifier = sm;
}

2884public:
QualType getElementType() const { return ElementType; }

ArraySizeModifier getSizeModifier() const {
  return ArraySizeModifier(ArrayTypeBits.SizeModifier);
}

Qualifiers getIndexTypeQualifiers() const {
  return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
}

unsigned getIndexTypeCVRQualifiers() const {
  return ArrayTypeBits.IndexTypeQuals;
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray ||
         T->getTypeClass() == VariableArray ||
         T->getTypeClass() == IncompleteArray ||
         T->getTypeClass() == DependentSizedArray;
}
2905};

2907/// Represents the canonical version of C arrays with a specified constant size.
2908/// For example, the canonical type for 'int A[4 + 4*100]' is a
2909/// ConstantArrayType where the element type is 'int' and the size is 404.
2910class ConstantArrayType : public ArrayType {
llvm::APInt Size; // Allows us to unique the type.

ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
                  ArraySizeModifier sm, unsigned tq)
    : ArrayType(ConstantArray, et, can, sm, tq,
                et->containsUnexpandedParameterPack()),
      Size(size) {}

2919protected:
friend class ASTContext; // ASTContext creates these.

ConstantArrayType(TypeClass tc, QualType et, QualType can,
                  const llvm::APInt &size, ArraySizeModifier sm, unsigned tq)
    : ArrayType(tc, et, can, sm, tq, et->containsUnexpandedParameterPack()),
      Size(size) {}

2927public:
const llvm::APInt &getSize() const { return Size; }
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Determine the number of bits required to address a member of
// an array with the given element type and number of elements.
static unsigned getNumAddressingBits(const ASTContext &Context,
                                     QualType ElementType,
                                     const llvm::APInt &NumElements);

/// Determine the maximum number of active bits that an array's size
/// can require, which limits the maximum size of the array.
static unsigned getMaxSizeBits(const ASTContext &Context);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSize(),
          getSizeModifier(), getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    const llvm::APInt &ArraySize, ArraySizeModifier SizeMod,
                    unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(ArraySize.getZExtValue());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray;
}
2959};

2961/// Represents a C array with an unspecified size.  For example 'int A[]' has
2962/// an IncompleteArrayType where the element type is 'int' and the size is
2963/// unspecified.
2964class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq,
                et->containsUnexpandedParameterPack()) {}

2972public:
friend class StmtIteratorBase;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == IncompleteArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSizeModifier(),
          getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    ArraySizeModifier SizeMod, unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}
2993};

2995/// Represents a C array with a specified size that is not an
2996/// integer-constant-expression.  For example, 'int s[x+foo()]'.
2997/// Since the size expression is an arbitrary expression, we store it as such.
2998///
2999/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3000/// should not be: two lexically equivalent variable array types could mean
3001/// different things, for example, these variables do not have the same type
3002/// dynamically:
3003///
3004/// void foo(int x) {
3005///   int Y[x];
3006///   ++x;
3007///   int Z[x];
3008/// }
3009class VariableArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

/// An assignment-expression. VLA's are only permitted within
/// a function block.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

VariableArrayType(QualType et, QualType can, Expr *e,
                  ArraySizeModifier sm, unsigned tq,
                  SourceRange brackets)
    : ArrayType(VariableArray, et, can, sm, tq,
                et->containsUnexpandedParameterPack()),
      SizeExpr((Stmt*) e), Brackets(brackets) {}

3026public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == VariableArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  llvm_unreachable("Cannot unique VariableArrayTypes.")::llvm::llvm_unreachable_internal("Cannot unique VariableArrayTypes."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3047);
}
3049};

3051/// Represents an array type in C++ whose size is a value-dependent expression.
3052///
3053/// For example:
3054/// \code
3055/// template<typename T, int Size>
3056/// class array {
3057///   T data[Size];
3058/// };
3059/// \endcode
3060///
3061/// For these types, we won't actually know what the array bound is
3062/// until template instantiation occurs, at which point this will
3063/// become either a ConstantArrayType or a VariableArrayType.
3064class DependentSizedArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

const ASTContext &Context;

/// An assignment expression that will instantiate to the
/// size of the array.
///
/// The expression itself might be null, in which case the array
/// type will have its size deduced from an initializer.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
                        Expr *e, ArraySizeModifier sm, unsigned tq,
                        SourceRange brackets);

3083public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(),
          getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ET, ArraySizeModifier SizeMod,
                    unsigned TypeQuals, Expr *E);
3111};

3113/// Represents an extended address space qualifier where the input address space
3114/// value is dependent. Non-dependent address spaces are not represented with a
3115/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3116///
3117/// For example:
3118/// \code
3119/// template<typename T, int AddrSpace>
3120/// class AddressSpace {
3121///   typedef T __attribute__((address_space(AddrSpace))) type;
3122/// }
3123/// \endcode
3124class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *AddrSpaceExpr;
QualType PointeeType;
SourceLocation loc;

DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
                          QualType can, Expr *AddrSpaceExpr,
                          SourceLocation loc);

3136public:
Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
QualType getPointeeType() const { return PointeeType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentAddressSpace;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType PointeeType, Expr *AddrSpaceExpr);
3154};

3156/// Represents an extended vector type where either the type or size is
3157/// dependent.
3158///
3159/// For example:
3160/// \code
3161/// template<typename T, int Size>
3162/// class vector {
3163///   typedef T __attribute__((ext_vector_type(Size))) type;
3164/// }
3165/// \endcode
3166class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *SizeExpr;

/// The element type of the array.
QualType ElementType;

SourceLocation loc;

DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
                            QualType can, Expr *SizeExpr, SourceLocation loc);

3180public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedExtVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *SizeExpr);
3198};


3201/// Represents a GCC generic vector type. This type is created using
3202/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3203/// bytes; or from an Altivec __vector or vector declaration.
3204/// Since the constructor takes the number of vector elements, the
3205/// client is responsible for converting the size into the number of elements.
3206class VectorType : public Type, public llvm::FoldingSetNode {
3207public:
enum VectorKind {
  /// not a target-specific vector type
  GenericVector,

  /// is AltiVec vector
  AltiVecVector,

  /// is AltiVec 'vector Pixel'
  AltiVecPixel,

  /// is AltiVec 'vector bool ...'
  AltiVecBool,

  /// is ARM Neon vector
  NeonVector,

  /// is ARM Neon polynomial vector
  NeonPolyVector
};

3228protected:
friend class ASTContext; // ASTContext creates these.

/// The element type of the vector.
QualType ElementType;

VectorType(QualType vecType, unsigned nElements, QualType canonType,
           VectorKind vecKind);

VectorType(TypeClass tc, QualType vecType, unsigned nElements,
           QualType canonType, VectorKind vecKind);

3240public:
QualType getElementType() const { return ElementType; }
unsigned getNumElements() const { return VectorTypeBits.NumElements; }

static bool isVectorSizeTooLarge(unsigned NumElements) {
  return NumElements > VectorTypeBitfields::MaxNumElements;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

VectorKind getVectorKind() const {
  return VectorKind(VectorTypeBits.VecKind);
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumElements(),
          getTypeClass(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumElements, TypeClass TypeClass,
                    VectorKind VecKind) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumElements);
  ID.AddInteger(TypeClass);
  ID.AddInteger(VecKind);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
}
3272};

3274/// Represents a vector type where either the type or size is dependent.
3275////
3276/// For example:
3277/// \code
3278/// template<typename T, int Size>
3279/// class vector {
3280///   typedef T __attribute__((vector_size(Size))) type;
3281/// }
3282/// \endcode
3283class DependentVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
QualType ElementType;
Expr *SizeExpr;
SourceLocation Loc;

DependentVectorType(const ASTContext &Context, QualType ElementType,
                         QualType CanonType, Expr *SizeExpr,
                         SourceLocation Loc, VectorType::VectorKind vecKind);

3295public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return Loc; }
VectorType::VectorKind getVectorKind() const {
  return VectorType::VectorKind(VectorTypeBits.VecKind);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, const Expr *SizeExpr,
                    VectorType::VectorKind VecKind);
3317};

3319/// ExtVectorType - Extended vector type. This type is created using
3320/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3321/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3322/// class enables syntactic extensions, like Vector Components for accessing
3323/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3324/// Shading Language).
3325class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3331public:
static int getPointAccessorIdx(char c) {
  switch (c) {
  default: return -1;
  case 'x': case 'r': return 0;
  case 'y': case 'g': return 1;
  case 'z': case 'b': return 2;
  case 'w': case 'a': return 3;
  }
}

static int getNumericAccessorIdx(char c) {
  switch (c) {
    default: return -1;
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'A':
    case 'a': return 10;
    case 'B':
    case 'b': return 11;
    case 'C':
    case 'c': return 12;
    case 'D':
    case 'd': return 13;
    case 'E':
    case 'e': return 14;
    case 'F':
    case 'f': return 15;
  }
}

static int getAccessorIdx(char c, bool isNumericAccessor) {
  if (isNumericAccessor)
    return getNumericAccessorIdx(c);
  else
    return getPointAccessorIdx(c);
}

bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
  if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
    return unsigned(idx-1) < getNumElements();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ExtVector;
}
3389};

3391/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3392/// class of FunctionNoProtoType and FunctionProtoType.
3393class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3397public:
/// Interesting information about a specific parameter that can't simply
/// be reflected in parameter's type. This is only used by FunctionProtoType
/// but is in FunctionType to make this class available during the
/// specification of the bases of FunctionProtoType.
///
/// It makes sense to model language features this way when there's some
/// sort of parameter-specific override (such as an attribute) that
/// affects how the function is called.  For example, the ARC ns_consumed
/// attribute changes whether a parameter is passed at +0 (the default)
/// or +1 (ns_consumed).  This must be reflected in the function type,
/// but isn't really a change to the parameter type.
///
/// One serious disadvantage of modelling language features this way is
/// that they generally do not work with language features that attempt
/// to destructure types.  For example, template argument deduction will
/// not be able to match a parameter declared as
///   T (*)(U)
/// against an argument of type
///   void (*)(__attribute__((ns_consumed)) id)
/// because the substitution of T=void, U=id into the former will
/// not produce the latter.
class ExtParameterInfo {
  enum {
    ABIMask = 0x0F,
    IsConsumed = 0x10,
    HasPassObjSize = 0x20,
    IsNoEscape = 0x40,
  };
  unsigned char Data = 0;

public:
  ExtParameterInfo() = default;

  /// Return the ABI treatment of this parameter.
  ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
  ExtParameterInfo withABI(ParameterABI kind) const {
    ExtParameterInfo copy = *this;
    copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
    return copy;
  }

  /// Is this parameter considered "consumed" by Objective-C ARC?
  /// Consumed parameters must have retainable object type.
  bool isConsumed() const { return (Data & IsConsumed); }
  ExtParameterInfo withIsConsumed(bool consumed) const {
    ExtParameterInfo copy = *this;
    if (consumed)
      copy.Data |= IsConsumed;
    else
      copy.Data &= ~IsConsumed;
    return copy;
  }

  bool hasPassObjectSize() const { return Data & HasPassObjSize; }
  ExtParameterInfo withHasPassObjectSize() const {
    ExtParameterInfo Copy = *this;
    Copy.Data |= HasPassObjSize;
    return Copy;
  }

  bool isNoEscape() const { return Data & IsNoEscape; }
  ExtParameterInfo withIsNoEscape(bool NoEscape) const {
    ExtParameterInfo Copy = *this;
    if (NoEscape)
      Copy.Data |= IsNoEscape;
    else
      Copy.Data &= ~IsNoEscape;
    return Copy;
  }

  unsigned char getOpaqueValue() const { return Data; }
  static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
    ExtParameterInfo result;
    result.Data = data;
    return result;
  }

  friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data == rhs.Data;
  }

  friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data != rhs.Data;
  }
};

/// A class which abstracts out some details necessary for
/// making a call.
///
/// It is not actually used directly for storing this information in
/// a FunctionType, although FunctionType does currently use the
/// same bit-pattern.
///
// If you add a field (say Foo), other than the obvious places (both,
// constructors, compile failures), what you need to update is
// * Operator==
// * getFoo
// * withFoo
// * functionType. Add Foo, getFoo.
// * ASTContext::getFooType
// * ASTContext::mergeFunctionTypes
// * FunctionNoProtoType::Profile
// * FunctionProtoType::Profile
// * TypePrinter::PrintFunctionProto
// * AST read and write
// * Codegen
class ExtInfo {
  friend class FunctionType;

  // Feel free to rearrange or add bits, but if you go over 12,
  // you'll need to adjust both the Bits field below and
  // Type::FunctionTypeBitfields.

  //   |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|
  //   |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |
  //
  // regparm is either 0 (no regparm attribute) or the regparm value+1.
  enum { CallConvMask = 0x1F };
  enum { NoReturnMask = 0x20 };
  enum { ProducesResultMask = 0x40 };
  enum { NoCallerSavedRegsMask = 0x80 };
  enum { NoCfCheckMask = 0x800 };
  enum {
    RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask |
                    NoCallerSavedRegsMask | NoCfCheckMask),
    RegParmOffset = 8
  }; // Assumed to be the last field
  uint16_t Bits = CC_C;

  ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}

 public:
   // Constructor with no defaults. Use this when you know that you
   // have all the elements (when reading an AST file for example).
   ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
           bool producesResult, bool noCallerSavedRegs, bool NoCfCheck) {
     assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(((!hasRegParm || regParm < 7) && "Invalid regparm value"
) ? static_cast<void> (0) : __assert_fail ("(!hasRegParm || regParm < 7) && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3534, __PRETTY_FUNCTION__));
     Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
            (producesResult ? ProducesResultMask : 0) |
            (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
            (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
            (NoCfCheck ? NoCfCheckMask : 0);
  }

  // Constructor with all defaults. Use when for example creating a
  // function known to use defaults.
  ExtInfo() = default;

  // Constructor with just the calling convention, which is an important part
  // of the canonical type.
  ExtInfo(CallingConv CC) : Bits(CC) {}

  bool getNoReturn() const { return Bits & NoReturnMask; }
  bool getProducesResult() const { return Bits & ProducesResultMask; }
  bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
  bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
  bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }

  unsigned getRegParm() const {
    unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
    if (RegParm > 0)
      --RegParm;
    return RegParm;
  }

  CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }

  bool operator==(ExtInfo Other) const {
    return Bits == Other.Bits;
  }
  bool operator!=(ExtInfo Other) const {
    return Bits != Other.Bits;
  }

  // Note that we don't have setters. That is by design, use
  // the following with methods instead of mutating these objects.

  ExtInfo withNoReturn(bool noReturn) const {
    if (noReturn)
      return ExtInfo(Bits | NoReturnMask);
    else
      return ExtInfo(Bits & ~NoReturnMask);
  }

  ExtInfo withProducesResult(bool producesResult) const {
    if (producesResult)
      return ExtInfo(Bits | ProducesResultMask);
    else
      return ExtInfo(Bits & ~ProducesResultMask);
  }

  ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
    if (noCallerSavedRegs)
      return ExtInfo(Bits | NoCallerSavedRegsMask);
    else
      return ExtInfo(Bits & ~NoCallerSavedRegsMask);
  }

  ExtInfo withNoCfCheck(bool noCfCheck) const {
    if (noCfCheck)
      return ExtInfo(Bits | NoCfCheckMask);
    else
      return ExtInfo(Bits & ~NoCfCheckMask);
  }

  ExtInfo withRegParm(unsigned RegParm) const {
    assert(RegParm < 7 && "Invalid regparm value")((RegParm < 7 && "Invalid regparm value") ? static_cast
<void> (0) : __assert_fail ("RegParm < 7 && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3604, __PRETTY_FUNCTION__));
    return ExtInfo((Bits & ~RegParmMask) |
                   ((RegParm + 1) << RegParmOffset));
  }

  ExtInfo withCallingConv(CallingConv cc) const {
    return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
  }

  void Profile(llvm::FoldingSetNodeID &ID) const {
    ID.AddInteger(Bits);
  }
};

/// A simple holder for a QualType representing a type in an
/// exception specification. Unfortunately needed by FunctionProtoType
/// because TrailingObjects cannot handle repeated types.
struct ExceptionType { QualType Type; };

/// A simple holder for various uncommon bits which do not fit in
/// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
/// alignment of subsequent objects in TrailingObjects. You must update
/// hasExtraBitfields in FunctionProtoType after adding extra data here.
struct alignas(void *) FunctionTypeExtraBitfields {
  /// The number of types in the exception specification.
  /// A whole unsigned is not needed here and according to
  /// [implimits] 8 bits would be enough here.
  unsigned NumExceptionType;
};

3634protected:
FunctionType(TypeClass tc, QualType res,
             QualType Canonical, bool Dependent,
             bool InstantiationDependent,
             bool VariablyModified, bool ContainsUnexpandedParameterPack,
             ExtInfo Info)
    : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
           ContainsUnexpandedParameterPack),
      ResultType(res) {
  FunctionTypeBits.ExtInfo = Info.Bits;
}

Qualifiers getFastTypeQuals() const {
  return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
}

3650public:
QualType getReturnType() const { return ResultType; }

bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
unsigned getRegParmType() const { return getExtInfo().getRegParm(); }

/// Determine whether this function type includes the GNU noreturn
/// attribute. The C++11 [[noreturn]] attribute does not affect the function
/// type.
bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }

CallingConv getCallConv() const { return getExtInfo().getCC(); }
ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }

static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
              "Const, volatile and restrict are assumed to be a subset of "
              "the fast qualifiers.");

bool isConst() const { return getFastTypeQuals().hasConst(); }
bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }

/// Determine the type of an expression that calls a function of
/// this type.
QualType getCallResultType(const ASTContext &Context) const {
  return getReturnType().getNonLValueExprType(Context);
}

static StringRef getNameForCallConv(CallingConv CC);

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto ||
         T->getTypeClass() == FunctionProto;
}
3684};

3686/// Represents a K&R-style 'int foo()' function, which has
3687/// no information available about its arguments.
3688class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
    : FunctionType(FunctionNoProto, Result, Canonical,
                   /*Dependent=*/false, /*InstantiationDependent=*/false,
                   Result->isVariablyModifiedType(),
                   /*ContainsUnexpandedParameterPack=*/false, Info) {}

3697public:
// No additional state past what FunctionType provides.

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReturnType(), getExtInfo());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
                    ExtInfo Info) {
  Info.Profile(ID);
  ID.AddPointer(ResultType.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto;
}
3716};

3718/// Represents a prototype with parameter type info, e.g.
3719/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3720/// parameters, not as having a single void parameter. Such a type can have
3721/// an exception specification, but this specification is not part of the
3722/// canonical type. FunctionProtoType has several trailing objects, some of
3723/// which optional. For more information about the trailing objects see
3724/// the first comment inside FunctionProtoType.
3725class FunctionProtoType final
  : public FunctionType,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<
        FunctionProtoType, QualType, FunctionType::FunctionTypeExtraBitfields,
        FunctionType::ExceptionType, Expr *, FunctionDecl *,
        FunctionType::ExtParameterInfo, Qualifiers> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

// FunctionProtoType is followed by several trailing objects, some of
// which optional. They are in order:
//
// * An array of getNumParams() QualType holding the parameter types.
//   Always present. Note that for the vast majority of FunctionProtoType,
//   these will be the only trailing objects.
//
// * Optionally if some extra data is stored in FunctionTypeExtraBitfields
//   (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
//   a single FunctionTypeExtraBitfields. Present if and only if
//   hasExtraBitfields() is true.
//
// * Optionally exactly one of:
//   * an array of getNumExceptions() ExceptionType,
//   * a single Expr *,
//   * a pair of FunctionDecl *,
//   * a single FunctionDecl *
//   used to store information about the various types of exception
//   specification. See getExceptionSpecSize for the details.
//
// * Optionally an array of getNumParams() ExtParameterInfo holding
//   an ExtParameterInfo for each of the parameters. Present if and
//   only if hasExtParameterInfos() is true.
//
// * Optionally a Qualifiers object to represent extra qualifiers that can't
//   be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
//   if hasExtQualifiers() is true.
//
// The optional FunctionTypeExtraBitfields has to be before the data
// related to the exception specification since it contains the number
// of exception types.
//
// We put the ExtParameterInfos last.  If all were equal, it would make
// more sense to put these before the exception specification, because
// it's much easier to skip past them compared to the elaborate switch
// required to skip the exception specification.  However, all is not
// equal; ExtParameterInfos are used to model very uncommon features,
// and it's better not to burden the more common paths.

3774public:
/// Holds information about the various types of exception specification.
/// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
/// used to group together the various bits of information about the
/// exception specification.
struct ExceptionSpecInfo {
  /// The kind of exception specification this is.
  ExceptionSpecificationType Type = EST_None;

  /// Explicitly-specified list of exception types.
  ArrayRef<QualType> Exceptions;

  /// Noexcept expression, if this is a computed noexcept specification.
  Expr *NoexceptExpr = nullptr;

  /// The function whose exception specification this is, for
  /// EST_Unevaluated and EST_Uninstantiated.
  FunctionDecl *SourceDecl = nullptr;

  /// The function template whose exception specification this is instantiated
  /// from, for EST_Uninstantiated.
  FunctionDecl *SourceTemplate = nullptr;

  ExceptionSpecInfo() = default;

  ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
};

/// Extra information about a function prototype. ExtProtoInfo is not
/// stored as such in FunctionProtoType but is used to group together
/// the various bits of extra information about a function prototype.
struct ExtProtoInfo {
  FunctionType::ExtInfo ExtInfo;
  bool Variadic : 1;
  bool HasTrailingReturn : 1;
  Qualifiers TypeQuals;
  RefQualifierKind RefQualifier = RQ_None;
  ExceptionSpecInfo ExceptionSpec;
  const ExtParameterInfo *ExtParameterInfos = nullptr;

  ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo(CallingConv CC)
      : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
    ExtProtoInfo Result(*this);
    Result.ExceptionSpec = ESI;
    return Result;
  }
};

3826private:
unsigned numTrailingObjects(OverloadToken<QualType>) const {
  return getNumParams();
}

unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
  return hasExtraBitfields();
}

unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
  return getExceptionSpecSize().NumExceptionType;
}

unsigned numTrailingObjects(OverloadToken<Expr *>) const {
  return getExceptionSpecSize().NumExprPtr;
}

unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
  return getExceptionSpecSize().NumFunctionDeclPtr;
}

unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
  return hasExtParameterInfos() ? getNumParams() : 0;
}

/// Determine whether there are any argument types that
/// contain an unexpanded parameter pack.
static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
                                               unsigned numArgs) {
  for (unsigned Idx = 0; Idx < numArgs; ++Idx)
    if (ArgArray[Idx]->containsUnexpandedParameterPack())
      return true;

  return false;
}

FunctionProtoType(QualType result, ArrayRef<QualType> params,
                  QualType canonical, const ExtProtoInfo &epi);

/// This struct is returned by getExceptionSpecSize and is used to
/// translate an ExceptionSpecificationType to the number and kind
/// of trailing objects related to the exception specification.
struct ExceptionSpecSizeHolder {
  unsigned NumExceptionType;
  unsigned NumExprPtr;
  unsigned NumFunctionDeclPtr;
};

/// Return the number and kind of trailing objects
/// related to the exception specification.
static ExceptionSpecSizeHolder
getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
  switch (EST) {
  case EST_None:
  case EST_DynamicNone:
  case EST_MSAny:
  case EST_BasicNoexcept:
  case EST_Unparsed:
  case EST_NoThrow:
    return {0, 0, 0};

  case EST_Dynamic:
    return {NumExceptions, 0, 0};

  case EST_DependentNoexcept:
  case EST_NoexceptFalse:
  case EST_NoexceptTrue:
    return {0, 1, 0};

  case EST_Uninstantiated:
    return {0, 0, 2};

  case EST_Unevaluated:
    return {0, 0, 1};
  }
  llvm_unreachable("bad exception specification kind")::llvm::llvm_unreachable_internal("bad exception specification kind"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3901);
}

/// Return the number and kind of trailing objects
/// related to the exception specification.
ExceptionSpecSizeHolder getExceptionSpecSize() const {
  return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
static bool hasExtraBitfields(ExceptionSpecificationType EST) {
  // If the exception spec type is EST_Dynamic then we have > 0 exception
  // types and the exact number is stored in FunctionTypeExtraBitfields.
  return EST == EST_Dynamic;
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
bool hasExtraBitfields() const {
  return hasExtraBitfields(getExceptionSpecType());
}

bool hasExtQualifiers() const {
  return FunctionTypeBits.HasExtQuals;
}

3926public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")((i < getNumParams() && "invalid parameter index")
 ? static_cast<void> (0) : __assert_fail ("i < getNumParams() && \"invalid parameter index\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3930, __PRETTY_FUNCTION__));
  return param_type_begin()[i];
}

ArrayRef<QualType> getParamTypes() const {
  return llvm::makeArrayRef(param_type_begin(), param_type_end());
}

ExtProtoInfo getExtProtoInfo() const {
  ExtProtoInfo EPI;
  EPI.ExtInfo = getExtInfo();
  EPI.Variadic = isVariadic();
  EPI.HasTrailingReturn = hasTrailingReturn();
  EPI.ExceptionSpec.Type = getExceptionSpecType();
  EPI.TypeQuals = getMethodQuals();
  EPI.RefQualifier = getRefQualifier();
  if (EPI.ExceptionSpec.Type == EST_Dynamic) {
    EPI.ExceptionSpec.Exceptions = exceptions();
  } else if (isComputedNoexcept(EPI.ExceptionSpec.Type)) {
    EPI.ExceptionSpec.NoexceptExpr = getNoexceptExpr();
  } else if (EPI.ExceptionSpec.Type == EST_Uninstantiated) {
    EPI.ExceptionSpec.SourceDecl = getExceptionSpecDecl();
    EPI.ExceptionSpec.SourceTemplate = getExceptionSpecTemplate();
  } else if (EPI.ExceptionSpec.Type == EST_Unevaluated) {
    EPI.ExceptionSpec.SourceDecl = getExceptionSpecDecl();
  }
  EPI.ExtParameterInfos = getExtParameterInfosOrNull();
  return EPI;
}

/// Get the kind of exception specification on this function.
ExceptionSpecificationType getExceptionSpecType() const {
  return static_cast<ExceptionSpecificationType>(
      FunctionTypeBits.ExceptionSpecType);
}

/// Return whether this function has any kind of exception spec.
bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }

/// Return whether this function has a dynamic (throw) exception spec.
bool hasDynamicExceptionSpec() const {
  return isDynamicExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a noexcept exception spec.
bool hasNoexceptExceptionSpec() const {
  return isNoexceptExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a dependent exception spec.
bool hasDependentExceptionSpec() const;

/// Return whether this function has an instantiation-dependent exception
/// spec.
bool hasInstantiationDependentExceptionSpec() const;

/// Return the number of types in the exception specification.
unsigned getNumExceptions() const {
  return getExceptionSpecType() == EST_Dynamic
             ? getTrailingObjects<FunctionTypeExtraBitfields>()
                   ->NumExceptionType
             : 0;
}

/// Return the ith exception type, where 0 <= i < getNumExceptions().
QualType getExceptionType(unsigned i) const {
  assert(i < getNumExceptions() && "Invalid exception number!")((i < getNumExceptions() && "Invalid exception number!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumExceptions() && \"Invalid exception number!\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 3996, __PRETTY_FUNCTION__));
  return exception_begin()[i];
}

/// Return the expression inside noexcept(expression), or a null pointer
/// if there is none (because the exception spec is not of this form).
Expr *getNoexceptExpr() const {
  if (!isComputedNoexcept(getExceptionSpecType()))
    return nullptr;
  return *getTrailingObjects<Expr *>();
}

/// If this function type has an exception specification which hasn't
/// been determined yet (either because it has not been evaluated or because
/// it has not been instantiated), this is the function whose exception
/// specification is represented by this type.
FunctionDecl *getExceptionSpecDecl() const {
  if (getExceptionSpecType() != EST_Uninstantiated &&
      getExceptionSpecType() != EST_Unevaluated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[0];
}

/// If this function type has an uninstantiated exception
/// specification, this is the function whose exception specification
/// should be instantiated to find the exception specification for
/// this type.
FunctionDecl *getExceptionSpecTemplate() const {
  if (getExceptionSpecType() != EST_Uninstantiated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[1];
}

/// Determine whether this function type has a non-throwing exception
/// specification.
CanThrowResult canThrow() const;

/// Determine whether this function type has a non-throwing exception
/// specification. If this depends on template arguments, returns
/// \c ResultIfDependent.
bool isNothrow(bool ResultIfDependent = false) const {
  return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
}

/// Whether this function prototype is variadic.
bool isVariadic() const { return FunctionTypeBits.Variadic; }

/// Determines whether this function prototype contains a
/// parameter pack at the end.
///
/// A function template whose last parameter is a parameter pack can be
/// called with an arbitrary number of arguments, much like a variadic
/// function.
bool isTemplateVariadic() const;

/// Whether this function prototype has a trailing return type.
bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }

Qualifiers getMethodQuals() const {
  if (hasExtQualifiers())
    return *getTrailingObjects<Qualifiers>();
  else
    return getFastTypeQuals();
}

/// Retrieve the ref-qualifier associated with this function type.
RefQualifierKind getRefQualifier() const {
  return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
}

using param_type_iterator = const QualType *;
using param_type_range = llvm::iterator_range<param_type_iterator>;

param_type_range param_types() const {
  return param_type_range(param_type_begin(), param_type_end());
}

param_type_iterator param_type_begin() const {
  return getTrailingObjects<QualType>();
}

param_type_iterator param_type_end() const {
  return param_type_begin() + getNumParams();
}

using exception_iterator = const QualType *;

ArrayRef<QualType> exceptions() const {
  return llvm::makeArrayRef(exception_begin(), exception_end());
}

exception_iterator exception_begin() const {
  return reinterpret_cast<exception_iterator>(
      getTrailingObjects<ExceptionType>());
}

exception_iterator exception_end() const {
  return exception_begin() + getNumExceptions();
}

/// Is there any interesting extra information for any of the parameters
/// of this function type?
bool hasExtParameterInfos() const {
  return FunctionTypeBits.HasExtParameterInfos;
}

ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
  assert(hasExtParameterInfos())((hasExtParameterInfos()) ? static_cast<void> (0) : __assert_fail
 ("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4103, __PRETTY_FUNCTION__));
  return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
                                    getNumParams());
}

/// Return a pointer to the beginning of the array of extra parameter
/// information, if present, or else null if none of the parameters
/// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
const ExtParameterInfo *getExtParameterInfosOrNull() const {
  if (!hasExtParameterInfos())
    return nullptr;
  return getTrailingObjects<ExtParameterInfo>();
}

ExtParameterInfo getExtParameterInfo(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4118, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4125, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4132, __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void printExceptionSpecification(raw_ostream &OS,
                                 const PrintingPolicy &Policy) const;

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionProto;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                    param_type_iterator ArgTys, unsigned NumArgs,
                    const ExtProtoInfo &EPI, const ASTContext &Context,
                    bool Canonical);
4153};

4155/// Represents the dependent type named by a dependently-scoped
4156/// typename using declaration, e.g.
4157///   using typename Base<T>::foo;
4158///
4159/// Template instantiation turns these into the underlying type.
4160class UnresolvedUsingType : public Type {
friend class ASTContext; // ASTContext creates these.

UnresolvedUsingTypenameDecl *Decl;

UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
    : Type(UnresolvedUsing, QualType(), true, true, false,
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(const_cast<UnresolvedUsingTypenameDecl*>(D)) {}

4170public:
UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnresolvedUsing;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  return Profile(ID, Decl);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    UnresolvedUsingTypenameDecl *D) {
  ID.AddPointer(D);
}
4188};

4190class TypedefType : public Type {
TypedefNameDecl *Decl;

4193protected:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType can)
    : Type(tc, can, can->isDependentType(),
           can->isInstantiationDependentType(),
           can->isVariablyModifiedType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(const_cast<TypedefNameDecl*>(D)) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4202, __PRETTY_FUNCTION__));
}

4205public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4212};

4214/// Sugar type that represents a type that was qualified by a qualifier written
4215/// as a macro invocation.
4216class MacroQualifiedType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType UnderlyingTy;
const IdentifierInfo *MacroII;

MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
                   const IdentifierInfo *MacroII)
    : Type(MacroQualified, CanonTy, UnderlyingTy->isDependentType(),
           UnderlyingTy->isInstantiationDependentType(),
           UnderlyingTy->isVariablyModifiedType(),
           UnderlyingTy->containsUnexpandedParameterPack()),
      UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
  assert(isa<AttributedType>(UnderlyingTy) &&((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4230, __PRETTY_FUNCTION__))
         "Expected a macro qualified type to only wrap attributed types.")((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4230, __PRETTY_FUNCTION__));
}

4233public:
const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
QualType getUnderlyingType() const { return UnderlyingTy; }

/// Return this attributed type's modified type with no qualifiers attached to
/// it.
QualType getModifiedType() const;

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == MacroQualified;
}
4247};

4249/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4250class TypeOfExprType : public Type {
Expr *TOExpr;

4253protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4258public:
Expr *getUnderlyingExpr() const { return TOExpr; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4268};

4270/// Internal representation of canonical, dependent
4271/// `typeof(expr)` types.
4272///
4273/// This class is used internally by the ASTContext to manage
4274/// canonical, dependent types, only. Clients will only see instances
4275/// of this class via TypeOfExprType nodes.
4276class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4280public:
DependentTypeOfExprType(const ASTContext &Context, Expr *E)
    : TypeOfExprType(E), Context(Context) {}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4290};

4292/// Represents `typeof(type)`, a GCC extension.
4293class TypeOfType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType TOType;

TypeOfType(QualType T, QualType can)
    : Type(TypeOf, can, T->isDependentType(),
           T->isInstantiationDependentType(),
           T->isVariablyModifiedType(),
           T->containsUnexpandedParameterPack()),
      TOType(T) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4304, __PRETTY_FUNCTION__));
}

4307public:
QualType getUnderlyingType() const { return TOType; }

/// Remove a single level of sugar.
QualType desugar() const { return getUnderlyingType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4317};

4319/// Represents the type `decltype(expr)` (C++11).
4320class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4324protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4329public:
Expr *getUnderlyingExpr() const { return E; }
QualType getUnderlyingType() const { return UnderlyingType; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4340};

4342/// Internal representation of canonical, dependent
4343/// decltype(expr) types.
4344///
4345/// This class is used internally by the ASTContext to manage
4346/// canonical, dependent types, only. Clients will only see instances
4347/// of this class via DecltypeType nodes.
4348class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4351public:
DependentDecltypeType(const ASTContext &Context, Expr *E);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4360};

4362/// A unary type transform, which is a type constructed from another.
4363class UnaryTransformType : public Type {
4364public:
enum UTTKind {
  EnumUnderlyingType
};

4369private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4378protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4384public:
bool isSugared() const { return !isDependentType(); }
QualType desugar() const { return UnderlyingType; }

QualType getUnderlyingType() const { return UnderlyingType; }
QualType getBaseType() const { return BaseType; }

UTTKind getUTTKind() const { return UKind; }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnaryTransform;
}
4396};

4398/// Internal representation of canonical, dependent
4399/// __underlying_type(type) types.
4400///
4401/// This class is used internally by the ASTContext to manage
4402/// canonical, dependent types, only. Clients will only see instances
4403/// of this class via UnaryTransformType nodes.
4404class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4406public:
DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
                            UTTKind UKind);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getBaseType(), getUTTKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
                    UTTKind UKind) {
  ID.AddPointer(BaseType.getAsOpaquePtr());
  ID.AddInteger((unsigned)UKind);
}
4419};

4421class TagType : public Type {
friend class ASTReader;

/// Stores the TagDecl associated with this type. The decl may point to any
/// TagDecl that declares the entity.
TagDecl *decl;

4428protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4431public:
TagDecl *getDecl() const;

/// Determines whether this type is in the process of being defined.
bool isBeingDefined() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == Enum || T->getTypeClass() == Record;
}
4440};

4442/// A helper class that allows the use of isa/cast/dyncast
4443/// to detect TagType objects of structs/unions/classes.
4444class RecordType : public TagType {
4445protected:
friend class ASTContext; // ASTContext creates these.

explicit RecordType(const RecordDecl *D)
    : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
explicit RecordType(TypeClass TC, RecordDecl *D)
    : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4453public:
RecordDecl *getDecl() const {
  return reinterpret_cast<RecordDecl*>(TagType::getDecl());
}

/// Recursively check all fields in the record for const-ness. If any field
/// is declared const, return true. Otherwise, return false.
bool hasConstFields() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4466};

4468/// A helper class that allows the use of isa/cast/dyncast
4469/// to detect TagType objects of enums.
4470class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4476public:
EnumDecl *getDecl() const {
  return reinterpret_cast<EnumDecl*>(TagType::getDecl());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4485};

4487/// An attributed type is a type to which a type attribute has been applied.
4488///
4489/// The "modified type" is the fully-sugared type to which the attributed
4490/// type was applied; generally it is not canonically equivalent to the
4491/// attributed type. The "equivalent type" is the minimally-desugared type
4492/// which the type is canonically equivalent to.
4493///
4494/// For example, in the following attributed type:
4495///     int32_t __attribute__((vector_size(16)))
4496///   - the modified type is the TypedefType for int32_t
4497///   - the equivalent type is VectorType(16, int32_t)
4498///   - the canonical type is VectorType(16, int)
4499class AttributedType : public Type, public llvm::FoldingSetNode {
4500public:
using Kind = attr::Kind;

4503private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->isDependentType(),
           equivalent->isInstantiationDependentType(),
           equivalent->isVariablyModifiedType(),
           equivalent->containsUnexpandedParameterPack()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4519public:
Kind getAttrKind() const {
  return static_cast<Kind>(AttributedTypeBits.AttrKind);
}

QualType getModifiedType() const { return ModifiedType; }
QualType getEquivalentType() const { return EquivalentType; }

bool isSugared() const { return true; }
QualType desugar() const { return getEquivalentType(); }

/// Does this attribute behave like a type qualifier?
///
/// A type qualifier adjusts a type to provide specialized rules for
/// a specific object, like the standard const and volatile qualifiers.
/// This includes attributes controlling things like nullability,
/// address spaces, and ARC ownership.  The value of the object is still
/// largely described by the modified type.
///
/// In contrast, many type attributes "rewrite" their modified type to
/// produce a fundamentally different type, not necessarily related in any
/// formalizable way to the original type.  For example, calling convention
/// and vector attributes are not simple type qualifiers.
///
/// Type qualifiers are often, but not always, reflected in the canonical
/// type.
bool isQualifier() const;

bool isMSTypeSpec() const;

bool isCallingConv() const;

llvm::Optional<NullabilityKind> getImmediateNullability() const;

/// Retrieve the attribute kind corresponding to the given
/// nullability kind.
static Kind getNullabilityAttrKind(NullabilityKind kind) {
  switch (kind) {
  case NullabilityKind::NonNull:
    return attr::TypeNonNull;

  case NullabilityKind::Nullable:
    return attr::TypeNullable;

  case NullabilityKind::Unspecified:
    return attr::TypeNullUnspecified;
  }
  llvm_unreachable("Unknown nullability kind.")::llvm::llvm_unreachable_internal("Unknown nullability kind."
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4566);
}

/// Strip off the top-level nullability annotation on the given
/// type, if it's there.
///
/// \param T The type to strip. If the type is exactly an
/// AttributedType specifying nullability (without looking through
/// type sugar), the nullability is returned and this type changed
/// to the underlying modified type.
///
/// \returns the top-level nullability, if present.
static Optional<NullabilityKind> stripOuterNullability(QualType &T);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
}

static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
                    QualType modified, QualType equivalent) {
  ID.AddInteger(attrKind);
  ID.AddPointer(modified.getAsOpaquePtr());
  ID.AddPointer(equivalent.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Attributed;
}
4594};

4596class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

// Helper data collector for canonical types.
struct CanonicalTTPTInfo {
  unsigned Depth : 15;
  unsigned ParameterPack : 1;
  unsigned Index : 16;
};

union {
  // Info for the canonical type.
  CanonicalTTPTInfo CanTTPTInfo;

  // Info for the non-canonical type.
  TemplateTypeParmDecl *TTPDecl;
};

/// Build a non-canonical type.
TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
    : Type(TemplateTypeParm, Canon, /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false,
           Canon->containsUnexpandedParameterPack()),
      TTPDecl(TTPDecl) {}

/// Build the canonical type.
TemplateTypeParmType(unsigned D, unsigned I, bool PP)
    : Type(TemplateTypeParm, QualType(this, 0),
           /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false, PP) {
  CanTTPTInfo.Depth = D;
  CanTTPTInfo.Index = I;
  CanTTPTInfo.ParameterPack = PP;
}

const CanonicalTTPTInfo& getCanTTPTInfo() const {
  QualType Can = getCanonicalTypeInternal();
  return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
}

4638public:
unsigned getDepth() const { return getCanTTPTInfo().Depth; }
unsigned getIndex() const { return getCanTTPTInfo().Index; }
bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }

TemplateTypeParmDecl *getDecl() const {
  return isCanonicalUnqualified() ? nullptr : TTPDecl;
}

IdentifierInfo *getIdentifier() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
                    unsigned Index, bool ParameterPack,
                    TemplateTypeParmDecl *TTPDecl) {
  ID.AddInteger(Depth);
  ID.AddInteger(Index);
  ID.AddBoolean(ParameterPack);
  ID.AddPointer(TTPDecl);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateTypeParm;
}
4668};

4670/// Represents the result of substituting a type for a template
4671/// type parameter.
4672///
4673/// Within an instantiated template, all template type parameters have
4674/// been replaced with these.  They are used solely to record that a
4675/// type was originally written as a template type parameter;
4676/// therefore they are never canonical.
4677class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

// The original type parameter.
const TemplateTypeParmType *Replaced;

SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
    : Type(SubstTemplateTypeParm, Canon, Canon->isDependentType(),
           Canon->isInstantiationDependentType(),
           Canon->isVariablyModifiedType(),
           Canon->containsUnexpandedParameterPack()),
      Replaced(Param) {}

4690public:
/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

/// Gets the type that was substituted for the template
/// parameter.
QualType getReplacementType() const {
  return getCanonicalTypeInternal();
}

bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReplacedParameter(), getReplacementType());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    QualType Replacement) {
  ID.AddPointer(Replaced);
  ID.AddPointer(Replacement.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParm;
}
4719};

4721/// Represents the result of substituting a set of types for a template
4722/// type parameter pack.
4723///
4724/// When a pack expansion in the source code contains multiple parameter packs
4725/// and those parameter packs correspond to different levels of template
4726/// parameter lists, this type node is used to represent a template type
4727/// parameter pack from an outer level, which has already had its argument pack
4728/// substituted but that still lives within a pack expansion that itself
4729/// could not be instantiated. When actually performing a substitution into
4730/// that pack expansion (e.g., when all template parameters have corresponding
4731/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4732/// at the current pack substitution index.
4733class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

/// The original type parameter.
const TemplateTypeParmType *Replaced;

/// A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                              QualType Canon,
                              const TemplateArgument &ArgPack);

4747public:
IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }

/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

unsigned getNumArgs() const {
  return SubstTemplateTypeParmPackTypeBits.NumArgs;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

TemplateArgument getArgumentPack() const;

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    const TemplateArgument &ArgPack);

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParmPack;
}
4772};

4774/// Common base class for placeholders for types that get replaced by
4775/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4776/// class template types, and (eventually) constrained type names from the C++
4777/// Concepts TS.
4778///
4779/// These types are usually a placeholder for a deduced type. However, before
4780/// the initializer is attached, or (usually) if the initializer is
4781/// type-dependent, there is no deduced type and the type is canonical. In
4782/// the latter case, it is also a dependent type.
4783class DeducedType : public Type {
4784protected:
DeducedType(TypeClass TC, QualType DeducedAsType, bool IsDependent,
            bool IsInstantiationDependent, bool ContainsParameterPack)
    : Type(TC,
           // FIXME: Retain the sugared deduced type?
           DeducedAsType.isNull() ? QualType(this, 0)
                                  : DeducedAsType.getCanonicalType(),
           IsDependent, IsInstantiationDependent,
           /*VariablyModified=*/false, ContainsParameterPack) {
  if (!DeducedAsType.isNull()) {
    if (DeducedAsType->isDependentType())
      setDependent();
    if (DeducedAsType->isInstantiationDependentType())
      setInstantiationDependent();
    if (DeducedAsType->containsUnexpandedParameterPack())
      setContainsUnexpandedParameterPack();
  }
}

4803public:
bool isSugared() const { return !isCanonicalUnqualified(); }
QualType desugar() const { return getCanonicalTypeInternal(); }

/// Get the type deduced for this placeholder type, or null if it's
/// either not been deduced or was deduced to a dependent type.
QualType getDeducedType() const {
  return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
}
bool isDeduced() const {
  return !isCanonicalUnqualified() || isDependentType();
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto ||
         T->getTypeClass() == DeducedTemplateSpecialization;
}
4820};

4822/// Represents a C++11 auto or C++14 decltype(auto) type.
4823class AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         bool IsDeducedAsDependent, bool IsDeducedAsPack)
    : DeducedType(Auto, DeducedAsType, IsDeducedAsDependent,
                  IsDeducedAsDependent, IsDeducedAsPack) {
  AutoTypeBits.Keyword = (unsigned)Keyword;
}

4833public:
bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDeducedType(), getKeyword(), isDependentType(),
          containsUnexpandedParameterPack());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Deduced,
                    AutoTypeKeyword Keyword, bool IsDependent, bool IsPack) {
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddInteger((unsigned)Keyword);
  ID.AddBoolean(IsDependent);
  ID.AddBoolean(IsPack);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
4858};

4860/// Represents a C++17 deduced template specialization type.
4861class DeducedTemplateSpecializationType : public DeducedType,
                                        public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template whose arguments will be deduced.
TemplateName Template;

DeducedTemplateSpecializationType(TemplateName Template,
                                  QualType DeducedAsType,
                                  bool IsDeducedAsDependent)
    : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
                  IsDeducedAsDependent || Template.isDependent(),
                  IsDeducedAsDependent || Template.isInstantiationDependent(),
                  Template.containsUnexpandedParameterPack()),
      Template(Template) {}

4877public:
/// Retrieve the name of the template that we are deducing.
TemplateName getTemplateName() const { return Template;}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
                    QualType Deduced, bool IsDependent) {
  Template.Profile(ID);
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddBoolean(IsDependent);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DeducedTemplateSpecialization;
}
4895};

4897/// Represents a type template specialization; the template
4898/// must be a class template, a type alias template, or a template
4899/// template parameter.  A template which cannot be resolved to one of
4900/// these, e.g. because it is written with a dependent scope
4901/// specifier, is instead represented as a
4902/// @c DependentTemplateSpecializationType.
4903///
4904/// A non-dependent template specialization type is always "sugar",
4905/// typically for a \c RecordType.  For example, a class template
4906/// specialization type of \c vector<int> will refer to a tag type for
4907/// the instantiation \c std::vector<int, std::allocator<int>>
4908///
4909/// Template specializations are dependent if either the template or
4910/// any of the template arguments are dependent, in which case the
4911/// type may also be canonical.
4912///
4913/// Instances of this type are allocated with a trailing array of
4914/// TemplateArguments, followed by a QualType representing the
4915/// non-canonical aliased type when the template is a type alias
4916/// template.
4917class alignas(8) TemplateSpecializationType
  : public Type,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template being specialized.  This is
/// either a TemplateName::Template (in which case it is a
/// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
/// TypeAliasTemplateDecl*), a
/// TemplateName::SubstTemplateTemplateParmPack, or a
/// TemplateName::SubstTemplateTemplateParm (in which case the
/// replacement must, recursively, be one of these).
TemplateName Template;

TemplateSpecializationType(TemplateName T,
                           ArrayRef<TemplateArgument> Args,
                           QualType Canon,
                           QualType Aliased);

4936public:
/// Determine whether any of the given template arguments are dependent.
static bool anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                                          bool &InstantiationDependent);

static bool anyDependentTemplateArguments(const TemplateArgumentListInfo &,
                                          bool &InstantiationDependent);

/// True if this template specialization type matches a current
/// instantiation in the context in which it is found.
bool isCurrentInstantiation() const {
  return isa<InjectedClassNameType>(getCanonicalTypeInternal());
}

/// Determine if this template specialization type is for a type alias
/// template that has been substituted.
///
/// Nearly every template specialization type whose template is an alias
/// template will be substituted. However, this is not the case when
/// the specialization contains a pack expansion but the template alias
/// does not have a corresponding parameter pack, e.g.,
///
/// \code
/// template<typename T, typename U, typename V> struct S;
/// template<typename T, typename U> using A = S<T, int, U>;
/// template<typename... Ts> struct X {
///   typedef A<Ts...> type; // not a type alias
/// };
/// \endcode
bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }

/// Get the aliased type, if this is a specialization of a type alias
/// template.
QualType getAliasedType() const {
  assert(isTypeAlias() && "not a type alias template specialization")((isTypeAlias() && "not a type alias template specialization"
) ? static_cast<void> (0) : __assert_fail ("isTypeAlias() && \"not a type alias template specialization\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 4970, __PRETTY_FUNCTION__));
  return *reinterpret_cast<const QualType*>(end());
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // defined inline in TemplateBase.h

/// Retrieve the name of the template that we are specializing.
TemplateName getTemplateName() const { return Template; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return reinterpret_cast<const TemplateArgument *>(this + 1);
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return TemplateSpecializationTypeBits.NumArgs;
}

/// Retrieve a specific template argument as a type.
/// \pre \c isArgType(Arg)
const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

bool isSugared() const {
  return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
}

QualType desugar() const {
  return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Template, template_arguments(), Ctx);
  if (isTypeAlias())
    getAliasedType().Profile(ID);
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
                    ArrayRef<TemplateArgument> Args,
                    const ASTContext &Context);

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateSpecialization;
}
5021};

5023/// Print a template argument list, including the '<' and '>'
5024/// enclosing the template arguments.
5025void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy);

5029void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy);

5033void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy);

5037/// The injected class name of a C++ class template or class
5038/// template partial specialization.  Used to record that a type was
5039/// spelled with a bare identifier rather than as a template-id; the
5040/// equivalent for non-templated classes is just RecordType.
5041///
5042/// Injected class name types are always dependent.  Template
5043/// instantiation turns these into RecordTypes.
5044///
5045/// Injected class name types are always canonical.  This works
5046/// because it is impossible to compare an injected class name type
5047/// with the corresponding non-injected template type, for the same
5048/// reason that it is impossible to directly compare template
5049/// parameters from different dependent contexts: injected class name
5050/// types can only occur within the scope of a particular templated
5051/// declaration, and within that scope every template specialization
5052/// will canonicalize to the injected class name (when appropriate
5053/// according to the rules of the language).
5054class InjectedClassNameType : public Type {
friend class ASTContext; // ASTContext creates these.
friend class ASTNodeImporter;
friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
                        // currently suitable for AST reading, too much
                        // interdependencies.

CXXRecordDecl *Decl;

/// The template specialization which this type represents.
/// For example, in
///   template <class T> class A { ... };
/// this is A<T>, whereas in
///   template <class X, class Y> class A<B<X,Y> > { ... };
/// this is A<B<X,Y> >.
///
/// It is always unqualified, always a template specialization type,
/// and always dependent.
QualType InjectedType;

InjectedClassNameType(CXXRecordDecl *D, QualType TST)
    : Type(InjectedClassName, QualType(), /*Dependent=*/true,
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/false,
           /*ContainsUnexpandedParameterPack=*/false),
      Decl(D), InjectedType(TST) {
  assert(isa<TemplateSpecializationType>(TST))((isa<TemplateSpecializationType>(TST)) ? static_cast<
void> (0) : __assert_fail ("isa<TemplateSpecializationType>(TST)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5080, __PRETTY_FUNCTION__));
  assert(!TST.hasQualifiers())((!TST.hasQualifiers()) ? static_cast<void> (0) : __assert_fail
 ("!TST.hasQualifiers()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5081, __PRETTY_FUNCTION__));
  assert(TST->isDependentType())((TST->isDependentType()) ? static_cast<void> (0) : __assert_fail
 ("TST->isDependentType()", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5082, __PRETTY_FUNCTION__));
}

5085public:
QualType getInjectedSpecializationType() const { return InjectedType; }

const TemplateSpecializationType *getInjectedTST() const {
  return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
}

TemplateName getTemplateName() const {
  return getInjectedTST()->getTemplateName();
}

CXXRecordDecl *getDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == InjectedClassName;
}
5104};

5106/// The kind of a tag type.
5107enum TagTypeKind {
/// The "struct" keyword.
TTK_Struct,

/// The "__interface" keyword.
TTK_Interface,

/// The "union" keyword.
TTK_Union,

/// The "class" keyword.
TTK_Class,

/// The "enum" keyword.
TTK_Enum
5122};

5124/// The elaboration keyword that precedes a qualified type name or
5125/// introduces an elaborated-type-specifier.
5126enum ElaboratedTypeKeyword {
/// The "struct" keyword introduces the elaborated-type-specifier.
ETK_Struct,

/// The "__interface" keyword introduces the elaborated-type-specifier.
ETK_Interface,

/// The "union" keyword introduces the elaborated-type-specifier.
ETK_Union,

/// The "class" keyword introduces the elaborated-type-specifier.
ETK_Class,

/// The "enum" keyword introduces the elaborated-type-specifier.
ETK_Enum,

/// The "typename" keyword precedes the qualified type name, e.g.,
/// \c typename T::type.
ETK_Typename,

/// No keyword precedes the qualified type name.
ETK_None
5148};

5150/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5151/// The keyword in stored in the free bits of the base class.
5152/// Also provides a few static helpers for converting and printing
5153/// elaborated type keyword and tag type kind enumerations.
5154class TypeWithKeyword : public Type {
5155protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, bool Dependent,
                bool InstantiationDependent, bool VariablyModified,
                bool ContainsUnexpandedParameterPack)
    : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
           ContainsUnexpandedParameterPack) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5165public:
ElaboratedTypeKeyword getKeyword() const {
  return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
}

/// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);

/// Converts a type specifier (DeclSpec::TST) into a tag type kind.
/// It is an error to provide a type specifier which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);

/// Converts a TagTypeKind into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);

/// Converts an elaborated type keyword into a TagTypeKind.
/// It is an error to provide an elaborated type keyword
/// which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);

static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);

static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);

static StringRef getTagTypeKindName(TagTypeKind Kind) {
  return getKeywordName(getKeywordForTagTypeKind(Kind));
}

class CannotCastToThisType {};
static CannotCastToThisType classof(const Type *);
5195};

5197/// Represents a type that was referred to using an elaborated type
5198/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5199/// or both.
5200///
5201/// This type is used to keep track of a type name as written in the
5202/// source code, including tag keywords and any nested-name-specifiers.
5203/// The type itself is always "sugar", used to express what was written
5204/// in the source code but containing no additional semantic information.
5205class ElaboratedType final
  : public TypeWithKeyword,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
friend class ASTContext; // ASTContext creates these
friend TrailingObjects;

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this qualified name refers to.
QualType NamedType;

/// The (re)declaration of this tag type owned by this occurrence is stored
/// as a trailing object if there is one. Use getOwnedTagDecl to obtain
/// it, or obtain a null pointer if there is none.

ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
               QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
    : TypeWithKeyword(Keyword, Elaborated, CanonType,
                      NamedType->isDependentType(),
                      NamedType->isInstantiationDependentType(),
                      NamedType->isVariablyModifiedType(),
                      NamedType->containsUnexpandedParameterPack()),
      NNS(NNS), NamedType(NamedType) {
  ElaboratedTypeBits.HasOwnedTagDecl = false;
  if (OwnedTagDecl) {
    ElaboratedTypeBits.HasOwnedTagDecl = true;
    *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
  }
  assert(!(Keyword == ETK_None && NNS == nullptr) &&((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5237, __PRETTY_FUNCTION__))
         "ElaboratedType cannot have elaborated type keyword "((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5237, __PRETTY_FUNCTION__))
         "and name qualifier both null.")((!(Keyword == ETK_None && NNS == nullptr) &&
 "ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5237, __PRETTY_FUNCTION__));
}

5240public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the qualified-id.
QualType getNamedType() const { return NamedType; }

/// Remove a single level of sugar.
QualType desugar() const { return getNamedType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

/// Return the (re)declaration of this type owned by this occurrence of this
/// type, or nullptr if there is none.
TagDecl *getOwnedTagDecl() const {
  return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
                                            : nullptr;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, QualType NamedType,
                    TagDecl *OwnedTagDecl) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  NamedType.Profile(ID);
  ID.AddPointer(OwnedTagDecl);
}

static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5274};

5276/// Represents a qualified type name for which the type name is
5277/// dependent.
5278///
5279/// DependentNameType represents a class of dependent types that involve a
5280/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5281/// name of a type. The DependentNameType may start with a "typename" (for a
5282/// typename-specifier), "class", "struct", "union", or "enum" (for a
5283/// dependent elaborated-type-specifier), or nothing (in contexts where we
5284/// know that we must be referring to a type, e.g., in a base class specifier).
5285/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5286/// mode, this type is used with non-dependent names to delay name lookup until
5287/// instantiation.
5288class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this typename specifier refers to.
const IdentifierInfo *Name;

DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
                  const IdentifierInfo *Name, QualType CanonType)
    : TypeWithKeyword(Keyword, DependentName, CanonType, /*Dependent=*/true,
                      /*InstantiationDependent=*/true,
                      /*VariablyModified=*/false,
                      NNS->containsUnexpandedParameterPack()),
      NNS(NNS), Name(Name) {}

5305public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the typename specifier as an identifier.
///
/// This routine will return a non-NULL identifier pointer when the
/// form of the original typename was terminated by an identifier,
/// e.g., "typename T::type".
const IdentifierInfo *getIdentifier() const {
  return Name;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, Name);
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  ID.AddPointer(Name);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentName;
}
5335};

5337/// Represents a template specialization type whose template cannot be
5338/// resolved, e.g.
5339///   A<T>::template B<T>
5340class alignas(8) DependentTemplateSpecializationType
  : public TypeWithKeyword,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The identifier of the template.
const IdentifierInfo *Name;

DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                    NestedNameSpecifier *NNS,
                                    const IdentifierInfo *Name,
                                    ArrayRef<TemplateArgument> Args,
                                    QualType Canon);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

5365public:
NestedNameSpecifier *getQualifier() const { return NNS; }
const IdentifierInfo *getIdentifier() const { return Name; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return DependentTemplateSpecializationTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // inline in TemplateBase.h

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const ASTContext &Context,
                    ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *Qualifier,
                    const IdentifierInfo *Name,
                    ArrayRef<TemplateArgument> Args);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentTemplateSpecialization;
}
5407};

5409/// Represents a pack expansion of types.
5410///
5411/// Pack expansions are part of C++11 variadic templates. A pack
5412/// expansion contains a pattern, which itself contains one or more
5413/// "unexpanded" parameter packs. When instantiated, a pack expansion
5414/// produces a series of types, each instantiated from the pattern of
5415/// the expansion, where the Ith instantiation of the pattern uses the
5416/// Ith arguments bound to each of the unexpanded parameter packs. The
5417/// pack expansion is considered to "expand" these unexpanded
5418/// parameter packs.
5419///
5420/// \code
5421/// template<typename ...Types> struct tuple;
5422///
5423/// template<typename ...Types>
5424/// struct tuple_of_references {
5425///   typedef tuple<Types&...> type;
5426/// };
5427/// \endcode
5428///
5429/// Here, the pack expansion \c Types&... is represented via a
5430/// PackExpansionType whose pattern is Types&.
5431class PackExpansionType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The pattern of the pack expansion.
QualType Pattern;

PackExpansionType(QualType Pattern, QualType Canon,
                  Optional<unsigned> NumExpansions)
    : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(),
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/Pattern->isVariablyModifiedType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Pattern(Pattern) {
  PackExpansionTypeBits.NumExpansions =
      NumExpansions ? *NumExpansions + 1 : 0;
}

5448public:
/// Retrieve the pattern of this pack expansion, which is the
/// type that will be repeatedly instantiated when instantiating the
/// pack expansion itself.
QualType getPattern() const { return Pattern; }

/// Retrieve the number of expansions that this pack expansion will
/// generate, if known.
Optional<unsigned> getNumExpansions() const {
  if (PackExpansionTypeBits.NumExpansions)
    return PackExpansionTypeBits.NumExpansions - 1;
  return None;
}

bool isSugared() const { return !Pattern->isDependentType(); }
QualType desugar() const { return isSugared() ? Pattern : QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPattern(), getNumExpansions());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
                    Optional<unsigned> NumExpansions) {
  ID.AddPointer(Pattern.getAsOpaquePtr());
  ID.AddBoolean(NumExpansions.hasValue());
  if (NumExpansions)
    ID.AddInteger(*NumExpansions);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == PackExpansion;
}
5480};

5482/// This class wraps the list of protocol qualifiers. For types that can
5483/// take ObjC protocol qualifers, they can subclass this class.
5484template <class T>
5485class ObjCProtocolQualifiers {
5486protected:
ObjCProtocolQualifiers() = default;

ObjCProtocolDecl * const *getProtocolStorage() const {
  return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
}

ObjCProtocolDecl **getProtocolStorage() {
  return static_cast<T*>(this)->getProtocolStorageImpl();
}

void setNumProtocols(unsigned N) {
  static_cast<T*>(this)->setNumProtocolsImpl(N);
}

void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
  setNumProtocols(protocols.size());
  assert(getNumProtocols() == protocols.size() &&((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5504, __PRETTY_FUNCTION__))
         "bitfield overflow in protocol count")((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5504, __PRETTY_FUNCTION__));
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5510public:
using qual_iterator = ObjCProtocolDecl * const *;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
qual_iterator qual_begin() const { return getProtocolStorage(); }
qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }

bool qual_empty() const { return getNumProtocols() == 0; }

/// Return the number of qualifying protocols in this type, or 0 if
/// there are none.
unsigned getNumProtocols() const {
  return static_cast<const T*>(this)->getNumProtocolsImpl();
}

/// Fetch a protocol by index.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  assert(I < getNumProtocols() && "Out-of-range protocol access")((I < getNumProtocols() && "Out-of-range protocol access"
) ? static_cast<void> (0) : __assert_fail ("I < getNumProtocols() && \"Out-of-range protocol access\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5528, __PRETTY_FUNCTION__));
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5536};

5538/// Represents a type parameter type in Objective C. It can take
5539/// a list of protocols.
5540class ObjCTypeParamType : public Type,
                        public ObjCProtocolQualifiers<ObjCTypeParamType>,
                        public llvm::FoldingSetNode {
friend class ASTContext;
friend class ObjCProtocolQualifiers<ObjCTypeParamType>;

/// The number of protocols stored on this type.
unsigned NumProtocols : 6;

ObjCTypeParamDecl *OTPDecl;

/// The protocols are stored after the ObjCTypeParamType node. In the
/// canonical type, the list of protocols are sorted alphabetically
/// and uniqued.
ObjCProtocolDecl **getProtocolStorageImpl();

/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return NumProtocols;
}

void setNumProtocolsImpl(unsigned N) {
  NumProtocols = N;
}

ObjCTypeParamType(const ObjCTypeParamDecl *D,
                  QualType can,
                  ArrayRef<ObjCProtocolDecl *> protocols);

5570public:
bool isSugared() const { return true; }
QualType desugar() const { return getCanonicalTypeInternal(); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCTypeParam;
}

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const ObjCTypeParamDecl *OTPDecl,
                    ArrayRef<ObjCProtocolDecl *> protocols);

ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5584};

5586/// Represents a class type in Objective C.
5587///
5588/// Every Objective C type is a combination of a base type, a set of
5589/// type arguments (optional, for parameterized classes) and a list of
5590/// protocols.
5591///
5592/// Given the following declarations:
5593/// \code
5594///   \@class C<T>;
5595///   \@protocol P;
5596/// \endcode
5597///
5598/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5599/// with base C and no protocols.
5600///
5601/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5602/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5603/// protocol list.
5604/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5605/// and protocol list [P].
5606///
5607/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5608/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5609/// and no protocols.
5610///
5611/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5612/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5613/// this should get its own sugar class to better represent the source.
5614class ObjCObjectType : public Type,
                     public ObjCProtocolQualifiers<ObjCObjectType> {
friend class ObjCProtocolQualifiers<ObjCObjectType>;

// ObjCObjectType.NumTypeArgs - the number of type arguments stored
// after the ObjCObjectPointerType node.
// ObjCObjectType.NumProtocols - the number of protocols stored
// after the type arguments of ObjCObjectPointerType node.
//
// These protocols are those written directly on the type.  If
// protocol qualifiers ever become additive, the iterators will need
// to get kindof complicated.
//
// In the canonical object type, these are sorted alphabetically
// and uniqued.

/// Either a BuiltinType or an InterfaceType or sugar for either.
QualType BaseType;

/// Cached superclass type.
mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
  CachedSuperClassType;

QualType *getTypeArgStorage();
const QualType *getTypeArgStorage() const {
  return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
}

ObjCProtocolDecl **getProtocolStorageImpl();
/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return ObjCObjectTypeBits.NumProtocols;
}
void setNumProtocolsImpl(unsigned N) {
  ObjCObjectTypeBits.NumProtocols = N;
}

5652protected:
enum Nonce_ObjCInterface { Nonce_ObjCInterface };

ObjCObjectType(QualType Canonical, QualType Base,
               ArrayRef<QualType> typeArgs,
               ArrayRef<ObjCProtocolDecl *> protocols,
               bool isKindOf);

ObjCObjectType(enum Nonce_ObjCInterface)
      : Type(ObjCInterface, QualType(), false, false, false, false),
        BaseType(QualType(this_(), 0)) {
  ObjCObjectTypeBits.NumProtocols = 0;
  ObjCObjectTypeBits.NumTypeArgs = 0;
  ObjCObjectTypeBits.IsKindOf = 0;
}

void computeSuperClassTypeSlow() const;

5670public:
/// Gets the base type of this object type.  This is always (possibly
/// sugar for) one of:
///  - the 'id' builtin type (as opposed to the 'id' type visible to the
///    user, which is a typedef for an ObjCObjectPointerType)
///  - the 'Class' builtin type (same caveat)
///  - an ObjCObjectType (currently always an ObjCInterfaceType)
QualType getBaseType() const { return BaseType; }

bool isObjCId() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
}

bool isObjCClass() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
}

bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
bool isObjCUnqualifiedIdOrClass() const {
  if (!qual_empty()) return false;
  if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
    return T->getKind() == BuiltinType::ObjCId ||
           T->getKind() == BuiltinType::ObjCClass;
  return false;
}
bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }

/// Gets the interface declaration for this object type, if the base type
/// really is an interface.
ObjCInterfaceDecl *getInterface() const;

/// Determine whether this object type is "specialized", meaning
/// that it has type arguments.
bool isSpecialized() const;

/// Determine whether this object type was written with type arguments.
bool isSpecializedAsWritten() const {
  return ObjCObjectTypeBits.NumTypeArgs > 0;
}

/// Determine whether this object type is "unspecialized", meaning
/// that it has no type arguments.
bool isUnspecialized() const { return !isSpecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments of this object type (semantically).
ArrayRef<QualType> getTypeArgs() const;

/// Retrieve the type arguments of this object type as they were
/// written.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return llvm::makeArrayRef(getTypeArgStorage(),
                            ObjCObjectTypeBits.NumTypeArgs);
}

/// Whether this is a "__kindof" type as written.
bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }

/// Whether this ia a "__kindof" type (semantically).
bool isKindOfType() const;

/// Retrieve the type of the superclass of this object type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// specialization of the superclass type. Produces a null type if
/// there is no superclass.
QualType getSuperClassType() const {
  if (!CachedSuperClassType.getInt())
    computeSuperClassTypeSlow();

  assert(CachedSuperClassType.getInt() && "Superclass not set?")((CachedSuperClassType.getInt() && "Superclass not set?"
) ? static_cast<void> (0) : __assert_fail ("CachedSuperClassType.getInt() && \"Superclass not set?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 5746, __PRETTY_FUNCTION__));
  return QualType(CachedSuperClassType.getPointer(), 0);
}

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObject ||
         T->getTypeClass() == ObjCInterface;
}
5761};

5763/// A class providing a concrete implementation
5764/// of ObjCObjectType, so as to not increase the footprint of
5765/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5766/// system should not reference this type.
5767class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
friend class ASTContext;

// If anyone adds fields here, ObjCObjectType::getProtocolStorage()
// will need to be modified.

ObjCObjectTypeImpl(QualType Canonical, QualType Base,
                   ArrayRef<QualType> typeArgs,
                   ArrayRef<ObjCProtocolDecl *> protocols,
                   bool isKindOf)
    : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}

5779public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5786};

5788inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5790}

5792inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5795}

5797inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
5800}

5802/// Interfaces are the core concept in Objective-C for object oriented design.
5803/// They basically correspond to C++ classes.  There are two kinds of interface
5804/// types: normal interfaces like `NSString`, and qualified interfaces, which
5805/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
5806///
5807/// ObjCInterfaceType guarantees the following properties when considered
5808/// as a subtype of its superclass, ObjCObjectType:
5809///   - There are no protocol qualifiers.  To reinforce this, code which
5810///     tries to invoke the protocol methods via an ObjCInterfaceType will
5811///     fail to compile.
5812///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
5813///     T->getBaseType() == QualType(T, 0).
5814class ObjCInterfaceType : public ObjCObjectType {
friend class ASTContext; // ASTContext creates these.
friend class ASTReader;
friend class ObjCInterfaceDecl;

mutable ObjCInterfaceDecl *Decl;

ObjCInterfaceType(const ObjCInterfaceDecl *D)
    : ObjCObjectType(Nonce_ObjCInterface),
      Decl(const_cast<ObjCInterfaceDecl*>(D)) {}

5825public:
/// Get the declaration of this interface.
ObjCInterfaceDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCInterface;
}

// Nonsense to "hide" certain members of ObjCObjectType within this
// class.  People asking for protocols on an ObjCInterfaceType are
// not going to get what they want: ObjCInterfaceTypes are
// guaranteed to have no protocols.
enum {
  qual_iterator,
  qual_begin,
  qual_end,
  getNumProtocols,
  getProtocol
};
5847};

5849inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
QualType baseType = getBaseType();
while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
  if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
    return T->getDecl();

  baseType = ObjT->getBaseType();
}

return nullptr;
5859}

5861/// Represents a pointer to an Objective C object.
5862///
5863/// These are constructed from pointer declarators when the pointee type is
5864/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
5865/// types are typedefs for these, and the protocol-qualified types 'id<P>'
5866/// and 'Class<P>' are translated into these.
5867///
5868/// Pointers to pointers to Objective C objects are still PointerTypes;
5869/// only the first level of pointer gets it own type implementation.
5870class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

ObjCObjectPointerType(QualType Canonical, QualType Pointee)
    : Type(ObjCObjectPointer, Canonical,
           Pointee->isDependentType(),
           Pointee->isInstantiationDependentType(),
           Pointee->isVariablyModifiedType(),
           Pointee->containsUnexpandedParameterPack()),
      PointeeType(Pointee) {}

5883public:
/// Gets the type pointed to by this ObjC pointer.
/// The result will always be an ObjCObjectType or sugar thereof.
QualType getPointeeType() const { return PointeeType; }

/// Gets the type pointed to by this ObjC pointer.  Always returns non-null.
///
/// This method is equivalent to getPointeeType() except that
/// it discards any typedefs (or other sugar) between this
/// type and the "outermost" object type.  So for:
/// \code
///   \@class A; \@protocol P; \@protocol Q;
///   typedef A<P> AP;
///   typedef A A1;
///   typedef A1<P> A1P;
///   typedef A1P<Q> A1PQ;
/// \endcode
/// For 'A*', getObjectType() will return 'A'.
/// For 'A<P>*', getObjectType() will return 'A<P>'.
/// For 'AP*', getObjectType() will return 'A<P>'.
/// For 'A1*', getObjectType() will return 'A'.
/// For 'A1<P>*', getObjectType() will return 'A1<P>'.
/// For 'A1P*', getObjectType() will return 'A1<P>'.
/// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
///   adding protocols to a protocol-qualified base discards the
///   old qualifiers (for now).  But if it didn't, getObjectType()
///   would return 'A1P<Q>' (and we'd have to make iterating over
///   qualifiers more complicated).
const ObjCObjectType *getObjectType() const {
  return PointeeType->castAs<ObjCObjectType>();
}

/// If this pointer points to an Objective C
/// \@interface type, gets the type for that interface.  Any protocol
/// qualifiers on the interface are ignored.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
const ObjCInterfaceType *getInterfaceType() const;

/// If this pointer points to an Objective \@interface
/// type, gets the declaration for that interface.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
ObjCInterfaceDecl *getInterfaceDecl() const {
  return getObjectType()->getInterface();
}

/// True if this is equivalent to the 'id' type, i.e. if
/// its object type is the primitive 'id' type with no protocols.
bool isObjCIdType() const {
  return getObjectType()->isObjCUnqualifiedId();
}

/// True if this is equivalent to the 'Class' type,
/// i.e. if its object tive is the primitive 'Class' type with no protocols.
bool isObjCClassType() const {
  return getObjectType()->isObjCUnqualifiedClass();
}

/// True if this is equivalent to the 'id' or 'Class' type,
bool isObjCIdOrClassType() const {
  return getObjectType()->isObjCUnqualifiedIdOrClass();
}

/// True if this is equivalent to 'id<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedIdType() const {
  return getObjectType()->isObjCQualifiedId();
}

/// True if this is equivalent to 'Class<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedClassType() const {
  return getObjectType()->isObjCQualifiedClass();
}

/// Whether this is a "__kindof" type.
bool isKindOfType() const { return getObjectType()->isKindOfType(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecialized() const { return getObjectType()->isSpecialized(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecializedAsWritten() const {
  return getObjectType()->isSpecializedAsWritten();
}

/// Whether this type is unspecialized, meaning that is has no type arguments.
bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgs() const {
  return getObjectType()->getTypeArgs();
}

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return getObjectType()->getTypeArgsAsWritten();
}

/// An iterator over the qualifiers on the object type.  Provided
/// for convenience.  This will always iterate over the full set of
/// protocols on a type, not just those provided directly.
using qual_iterator = ObjCObjectType::qual_iterator;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }

qual_iterator qual_begin() const {
  return getObjectType()->qual_begin();
}

qual_iterator qual_end() const {
  return getObjectType()->qual_end();
}

bool qual_empty() const { return getObjectType()->qual_empty(); }

/// Return the number of qualifying protocols on the object type.
unsigned getNumProtocols() const {
  return getObjectType()->getNumProtocols();
}

/// Retrieve a qualifying protocol by index on the object type.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  return getObjectType()->getProtocol(I);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Retrieve the type of the superclass of this object pointer type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// pointer to a specialization of the superclass type. Produces a
/// null type if there is no superclass.
QualType getSuperClassType() const;

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
                               const ASTContext &ctx) const;

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObjectPointer;
}
6042};

6044class AtomicType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ValueType;

AtomicType(QualType ValTy, QualType Canonical)
    : Type(Atomic, Canonical, ValTy->isDependentType(),
           ValTy->isInstantiationDependentType(),
           ValTy->isVariablyModifiedType(),
           ValTy->containsUnexpandedParameterPack()),
      ValueType(ValTy) {}

6056public:
/// Gets the type contained by this atomic type, i.e.
/// the type returned by performing an atomic load of this atomic type.
QualType getValueType() const { return ValueType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getValueType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Atomic;
}
6075};

6077/// PipeType - OpenCL20.
6078class PipeType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;
bool isRead;

PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
    : Type(Pipe, CanonicalPtr, elemType->isDependentType(),
           elemType->isInstantiationDependentType(),
           elemType->isVariablyModifiedType(),
           elemType->containsUnexpandedParameterPack()),
      ElementType(elemType), isRead(isRead) {}

6091public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }

QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), isReadOnly());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
  ID.AddPointer(T.getAsOpaquePtr());
  ID.AddBoolean(isRead);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Pipe;
}

bool isReadOnly() const { return isRead; }
6112};

6114/// A qualifier set is used to build a set of qualifiers.
6115class QualifierCollector : public Qualifiers {
6116public:
QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}

/// Collect any qualifiers on the given type and return an
/// unqualified type.  The qualifiers are assumed to be consistent
/// with those already in the type.
const Type *strip(QualType type) {
  addFastQualifiers(type.getLocalFastQualifiers());
  if (!type.hasLocalNonFastQualifiers())
    return type.getTypePtrUnsafe();

  const ExtQuals *extQuals = type.getExtQualsUnsafe();
  addConsistentQualifiers(extQuals->getQualifiers());
  return extQuals->getBaseType();
}

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, QualType QT) const;

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, const Type* T) const;
6137};

6139// Inline function definitions.

6141inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6146}

6148inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6150}

6152inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6154}

6156inline SplitQualType QualType::split() const {
if (!hasLocalNonFastQualifiers())
  return SplitQualType(getTypePtrUnsafe(),
                       Qualifiers::fromFastMask(getLocalFastQualifiers()));

const ExtQuals *eq = getExtQualsUnsafe();
Qualifiers qs = eq->getQualifiers();
qs.addFastQualifiers(getLocalFastQualifiers());
return SplitQualType(eq->getBaseType(), qs);
6165}

6167inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6173}

6175inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6179}

6181inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6185}

6187inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6190}

6192inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6194}

6196inline bool QualType::isCanonicalAsParam() const {
if (!isCanonical()) return false;
if (hasLocalQualifiers()) return false;

const Type *T = getTypePtr();
if (T->isVariablyModifiedType() && T->hasSizedVLAType())
  return false;

return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6205}

6207inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6210}

6212inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6215}


6218inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6221}

6223inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6226}

6228inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6233}

6235inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6240}

6242inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6244}

6246inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6248}

6250inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6252}

6254inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::CVRMask) && \"mask has non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6255, __PRETTY_FUNCTION__));
static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
              "Fast bits differ from CVR bits!");

// Fast path: we don't need to touch the slow qualifiers.
removeLocalFastQualifiers(Mask);
6261}

6263/// Return the address space of this type.
6264inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6266}

6268/// Return the gc attribute of this type.
6269inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6271}

6273inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6277}

6279inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6283}

6285inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6289}

6291inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
if (const auto *PT = t.getAs<PointerType>()) {
  if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
    return FT->getExtInfo();
} else if (const auto *FT = t.getAs<FunctionType>())
  return FT->getExtInfo();

return FunctionType::ExtInfo();
6299}

6301inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6303}

6305/// Determine whether this type is more
6306/// qualified than the Other type. For example, "const volatile int"
6307/// is more qualified than "const int", "volatile int", and
6308/// "int". However, it is not more qualified than "const volatile
6309/// int".
6310inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6314}

6316/// Determine whether this type is at last
6317/// as qualified as the Other type. For example, "const volatile
6318/// int" is at least as qualified as "const int", "volatile int",
6319/// "int", and "const volatile int".
6320inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
Qualifiers OtherQuals = other.getQualifiers();

// Ignore __unaligned qualifier if this type is a void.
if (getUnqualifiedType()->isVoidType())
  OtherQuals.removeUnaligned();

return getQualifiers().compatiblyIncludes(OtherQuals);
6328}

6330/// If Type is a reference type (e.g., const
6331/// int&), returns the type that the reference refers to ("const
6332/// int"). Otherwise, returns the type itself. This routine is used
6333/// throughout Sema to implement C++ 5p6:
6334///
6335///   If an expression initially has the type "reference to T" (8.3.2,
6336///   8.5.3), the type is adjusted to "T" prior to any further
6337///   analysis, the expression designates the object or function
6338///   denoted by the reference, and the expression is an lvalue.
6339inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6344}

6346inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6349}

6351/// Tests whether the type is categorized as a fundamental type.
6352///
6353/// \returns True for types specified in C++0x [basic.fundamental].
6354inline bool Type::isFundamentalType() const {
return isVoidType() ||
       isNullPtrType() ||
       // FIXME: It's really annoying that we don't have an
       // 'isArithmeticType()' which agrees with the standard definition.
       (isArithmeticType() && !isEnumeralType());
6360}

6362/// Tests whether the type is categorized as a compound type.
6363///
6364/// \returns True for types specified in C++0x [basic.compound].
6365inline bool Type::isCompoundType() const {
// C++0x [basic.compound]p1:
//   Compound types can be constructed in the following ways:
//    -- arrays of objects of a given type [...];
return isArrayType() ||
//    -- functions, which have parameters of given types [...];
       isFunctionType() ||
//    -- pointers to void or objects or functions [...];
       isPointerType() ||
//    -- references to objects or functions of a given type. [...]
       isReferenceType() ||
//    -- classes containing a sequence of objects of various types, [...];
       isRecordType() ||
//    -- unions, which are classes capable of containing objects of different
//               types at different times;
       isUnionType() ||
//    -- enumerations, which comprise a set of named constant values. [...];
       isEnumeralType() ||
//    -- pointers to non-static class members, [...].
       isMemberPointerType();
6385}

6387inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
6389}

6391inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6393}

6395inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6397}

6399inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6401}

6403inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6405}

6407inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6409}

6411inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6413}

6415inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6420}

6422inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6427}

6429inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6431}

6433inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6438}

6440inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6445}

6447inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6449}

6451inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6453}

6455inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6457}

6459inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6461}

6463inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6465}

6467inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6469}

6471inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6473}

6475inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6477}

6479inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6481}

6483inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6485}

6487inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6489}

6491inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6493}

6495inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6497}

6499inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6501}

6503inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6506}

6508inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6510}

6512inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6516}

6518inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6522}

6524inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6528}

6530inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6534}

6536inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6540}

6542inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6544}

6546inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6548}

6550#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6554#include "clang/Basic/OpenCLImageTypes.def"

6556inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6558}

6560inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6562}

6564inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6566}

6568inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6570}

6572inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6574}

6576inline bool Type::isImageType() const {
6577#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6579#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6581}

6583inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6585}

6587#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6591#include "clang/Basic/OpenCLExtensionTypes.def"

6593inline bool Type::isOCLIntelSubgroupAVCType() const {
6594#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6597#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6599}

6601inline bool Type::isOCLExtOpaqueType() const {
6602#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6604#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6606}

6608inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6611}

6613inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6615}

6617inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>())
  if (BT->getKind() == (BuiltinType::Kind) K)
    return true;
return false;
6622}

6624inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6628}

6630inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6635}

6637inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)) ?
 static_cast<void> (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6638, __PRETTY_FUNCTION__));
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return (BT->getKind() == (BuiltinType::Kind) K);
return false;
6642}

6644inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6648}

6650inline bool Type::isVoidType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Void;
return false;
6654}

6656inline bool Type::isHalfType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Half;
// FIXME: Should we allow complex __fp16? Probably not.
return false;
6661}

6663inline bool Type::isFloat16Type() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Float16;
return false;
6667}

6669inline bool Type::isFloat128Type() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Float128;
return false;
6673}

6675inline bool Type::isNullPtrType() const {
if (const auto *BT = getAs<BuiltinType>())
  return BT->getKind() == BuiltinType::NullPtr;
return false;
6679}

6681bool IsEnumDeclComplete(EnumDecl *);
6682bool IsEnumDeclScoped(EnumDecl *);

6684inline bool Type::isIntegerType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
  // Incomplete enum types are not treated as integer types.
  // FIXME: In C++, enum types are never integer types.
  return IsEnumDeclComplete(ET->getDecl()) &&
    !IsEnumDeclScoped(ET->getDecl());
}
return false;
6695}

6697inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
6703}

6705inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
6707}

6709inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
6715}

6717inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
6719}

6721inline bool Type::isSignedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return ((BT->getKind() >= BuiltinType::ShortAccum &&
           BT->getKind() <= BuiltinType::LongAccum) ||
          (BT->getKind() >= BuiltinType::ShortFract &&
           BT->getKind() <= BuiltinType::LongFract) ||
          (BT->getKind() >= BuiltinType::SatShortAccum &&
           BT->getKind() <= BuiltinType::SatLongAccum) ||
          (BT->getKind() >= BuiltinType::SatShortFract &&
           BT->getKind() <= BuiltinType::SatLongFract));
}
return false;
6733}

6735inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
6737}

6739inline bool Type::isScalarType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() > BuiltinType::Void &&
         BT->getKind() <= BuiltinType::NullPtr;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
  // Enums are scalar types, but only if they are defined.  Incomplete enums
  // are not treated as scalar types.
  return IsEnumDeclComplete(ET->getDecl());
return isa<PointerType>(CanonicalType) ||
       isa<BlockPointerType>(CanonicalType) ||
       isa<MemberPointerType>(CanonicalType) ||
       isa<ComplexType>(CanonicalType) ||
       isa<ObjCObjectPointerType>(CanonicalType);
6752}

6754inline bool Type::isIntegralOrEnumerationType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;

// Check for a complete enum type; incomplete enum types are not properly an
// enumeration type in the sense required here.
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
  return IsEnumDeclComplete(ET->getDecl());

return false;
6765}

6767inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
6771}

6773inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
6776}

6778/// Determines whether this is a type for which one can define
6779/// an overloaded operator.
6780inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
6782}

6784/// Determines whether this type can decay to a pointer type.
6785inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
6787}

6789inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
6792}

6794inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
6796}

6798inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
6803}

6805inline const Type *Type::getPointeeOrArrayElementType() const {
const Type *type = this;
if (type->isAnyPointerType())
  return type->getPointeeType().getTypePtr();
else if (type->isArrayType())
  return type->getBaseElementTypeUnsafe();
return type;
6812}

6814/// Insertion operator for diagnostics. This allows sending Qualifiers into a
6815/// diagnostic with <<.
6816inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         Qualifiers Q) {
DB.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return DB;
6821}

6823/// Insertion operator for partial diagnostics. This allows sending Qualifiers
6824/// into a diagnostic with <<.
6825inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
6830}

6832/// Insertion operator for diagnostics.  This allows sending QualType's into a
6833/// diagnostic with <<.
6834inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         QualType T) {
DB.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return DB;
6839}

6841/// Insertion operator for partial diagnostics.  This allows sending QualType's
6842/// into a diagnostic with <<.
6843inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
6848}

6850// Helper class template that is used by Type::getAs to ensure that one does
6851// not try to look through a qualified type to get to an array type.
6852template <typename T>
6853using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

6857// Member-template getAs<specific type>'.
6858template <typename T> const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with getAs!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
6873}

6875template <typename T> const T *Type::getAsAdjusted() const {
static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// Strip off type adjustments that do not modify the underlying nature of the
// type.
const Type *Ty = this;
while (Ty) {
  if (const auto *A = dyn_cast<AttributedType>(Ty))
    Ty = A->getModifiedType().getTypePtr();
  else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
    Ty = E->desugar().getTypePtr();
  else if (const auto *P = dyn_cast<ParenType>(Ty))
    Ty = P->desugar().getTypePtr();
  else if (const auto *A = dyn_cast<AdjustedType>(Ty))
    Ty = A->desugar().getTypePtr();
  else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
    Ty = M->desugar().getTypePtr();
  else
    break;
}

// Just because the canonical type is correct does not mean we can use cast<>,
// since we may not have stripped off all the sugar down to the base type.
return dyn_cast<T>(Ty);
6907}

6909inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
// If this is directly an array type, return it.
if (const auto *arr = dyn_cast<ArrayType>(this))
  return arr;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<ArrayType>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<ArrayType>(getUnqualifiedDesugaredType());
6921}

6923template <typename T> const T *Type::castAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with castAs!");

if (const auto *ty = dyn_cast<T>(this)) return ty;
assert(isa<T>(CanonicalType))((isa<T>(CanonicalType)) ? static_cast<void> (0) :
 __assert_fail ("isa<T>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6928, __PRETTY_FUNCTION__));
return cast<T>(getUnqualifiedDesugaredType());
6930}

6932inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))((isa<ArrayType>(CanonicalType)) ? static_cast<void>
 (0) : __assert_fail ("isa<ArrayType>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6933, __PRETTY_FUNCTION__));
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
6936}

6938DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
6941#ifndef NDEBUG
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))((isa<PointerType>(Adjusted)) ? static_cast<void>
 (0) : __assert_fail ("isa<PointerType>(Adjusted)", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include/clang/AST/Type.h"
, 6944, __PRETTY_FUNCTION__));
6945#endif
6946}

6948QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
6952}

6954// Get the decimal string representation of a fixed point type, represented
6955// as a scaled integer.
6956// TODO: At some point, we should change the arguments to instead just accept an
6957// APFixedPoint instead of APSInt and scale.
6958void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

6961} // namespace clang

6963#endif // LLVM_CLANG_AST_TYPE_H

←

/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerIntPair.h

1//===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the PointerIntPair class.
10//
11//===----------------------------------------------------------------------===//
12 
13#ifndef LLVM_ADT_POINTERINTPAIR_H
14#define LLVM_ADT_POINTERINTPAIR_H
15 
16#include "llvm/Support/PointerLikeTypeTraits.h"
17#include "llvm/Support/type_traits.h"
18#include <cassert>
19#include <cstdint>
20#include <limits>
21 
22namespace llvm {
23 
24template <typename T> struct DenseMapInfo;
25template <typename PointerT, unsigned IntBits, typename PtrTraits>
26struct PointerIntPairInfo;
27 
28/// PointerIntPair - This class implements a pair of a pointer and small
29/// integer.  It is designed to represent this in the space required by one
30/// pointer by bitmangling the integer into the low part of the pointer.  This
31/// can only be done for small integers: typically up to 3 bits, but it depends
32/// on the number of bits available according to PointerLikeTypeTraits for the
33/// type.
34///
35/// Note that PointerIntPair always puts the IntVal part in the highest bits
36/// possible.  For example, PointerIntPair<void*, 1, bool> will put the bit for
37/// the bool into bit #2, not bit #0, which allows the low two bits to be used
38/// for something else.  For example, this allows:
39///   PointerIntPair<PointerIntPair<void*, 1, bool>, 1, bool>
40/// ... and the two bools will land in different bits.
41template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,
42          typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
43          typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
44class PointerIntPair {
45  // Used by MSVC visualizer and generally helpful for debugging/visualizing.
46  using InfoTy = Info;
47  intptr_t Value = 0;
48 
49public:
50  constexpr PointerIntPair() = default;
51 
52  PointerIntPair(PointerTy PtrVal, IntType IntVal) {
53    setPointerAndInt(PtrVal, IntVal);
54  }
55 
56  explicit PointerIntPair(PointerTy PtrVal) { initWithPointer(PtrVal); }
57 
58  PointerTy getPointer() const { return Info::getPointer(Value); }
59 
60  IntType getInt() const { return (IntType)Info::getInt(Value); }
61 
62  void setPointer(PointerTy PtrVal) {
63    Value = Info::updatePointer(Value, PtrVal);
64  }
65 
66  void setInt(IntType IntVal) {
67    Value = Info::updateInt(Value, static_cast<intptr_t>(IntVal));
68  }
69 
70  void initWithPointer(PointerTy PtrVal) {
71    Value = Info::updatePointer(0, PtrVal);
72  }
73 
74  void setPointerAndInt(PointerTy PtrVal, IntType IntVal) {
75    Value = Info::updateInt(Info::updatePointer(0, PtrVal),
76                            static_cast<intptr_t>(IntVal));
77  }
78 
79  PointerTy const *getAddrOfPointer() const {
80    return const_cast<PointerIntPair *>(this)->getAddrOfPointer();
81  }
82 
83  PointerTy *getAddrOfPointer() {
84    assert(Value == reinterpret_cast<intptr_t>(getPointer()) &&((Value == reinterpret_cast<intptr_t>(getPointer()) &&
 "Can only return the address if IntBits is cleared and " "PtrTraits doesn't change the pointer"
) ? static_cast<void> (0) : __assert_fail ("Value == reinterpret_cast<intptr_t>(getPointer()) && \"Can only return the address if IntBits is cleared and \" \"PtrTraits doesn't change the pointer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerIntPair.h"
, 86, __PRETTY_FUNCTION__))
85           "Can only return the address if IntBits is cleared and "((Value == reinterpret_cast<intptr_t>(getPointer()) &&
 "Can only return the address if IntBits is cleared and " "PtrTraits doesn't change the pointer"
) ? static_cast<void> (0) : __assert_fail ("Value == reinterpret_cast<intptr_t>(getPointer()) && \"Can only return the address if IntBits is cleared and \" \"PtrTraits doesn't change the pointer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerIntPair.h"
, 86, __PRETTY_FUNCTION__))
86           "PtrTraits doesn't change the pointer")((Value == reinterpret_cast<intptr_t>(getPointer()) &&
 "Can only return the address if IntBits is cleared and " "PtrTraits doesn't change the pointer"
) ? static_cast<void> (0) : __assert_fail ("Value == reinterpret_cast<intptr_t>(getPointer()) && \"Can only return the address if IntBits is cleared and \" \"PtrTraits doesn't change the pointer\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerIntPair.h"
, 86, __PRETTY_FUNCTION__));
87    return reinterpret_cast<PointerTy *>(&Value);
88  }
89 
90  void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
91 
92  void setFromOpaqueValue(void *Val) {
93    Value = reinterpret_cast<intptr_t>(Val);
94  }
95 
96  static PointerIntPair getFromOpaqueValue(void *V) {
97    PointerIntPair P;
98    P.setFromOpaqueValue(V);
99    return P;
100  }
101 
102  // Allow PointerIntPairs to be created from const void * if and only if the
103  // pointer type could be created from a const void *.
104  static PointerIntPair getFromOpaqueValue(const void *V) {
105    (void)PtrTraits::getFromVoidPointer(V);
106    return getFromOpaqueValue(const_cast<void *>(V));
107  }
108 
109  bool operator==(const PointerIntPair &RHS) const {
110    return Value == RHS.Value;
9
←
Assuming 'Value' is not equal to 'RHS.Value'→
10
←
Returning zero, which participates in a condition later→
111  }
112 
113  bool operator!=(const PointerIntPair &RHS) const {
114    return Value != RHS.Value;
115  }
116 
117  bool operator<(const PointerIntPair &RHS) const { return Value < RHS.Value; }
118  bool operator>(const PointerIntPair &RHS) const { return Value > RHS.Value; }
119 
120  bool operator<=(const PointerIntPair &RHS) const {
121    return Value <= RHS.Value;
122  }
123 
124  bool operator>=(const PointerIntPair &RHS) const {
125    return Value >= RHS.Value;
126  }
127};
128 
129// Specialize is_trivially_copyable to avoid limitation of llvm::is_trivially_copyable
130// when compiled with gcc 4.9.
131template <typename PointerTy, unsigned IntBits, typename IntType,
132          typename PtrTraits,
133          typename Info>
134struct is_trivially_copyable<PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>> : std::true_type {
135#ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE
136  static_assert(std::is_trivially_copyable<PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>>::value,
137                "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable");
138#endif
139};
140 
141 
142template <typename PointerT, unsigned IntBits, typename PtrTraits>
143struct PointerIntPairInfo {
144  static_assert(PtrTraits::NumLowBitsAvailable <
145                    std::numeric_limits<uintptr_t>::digits,
146                "cannot use a pointer type that has all bits free");
147  static_assert(IntBits <= PtrTraits::NumLowBitsAvailable,
148                "PointerIntPair with integer size too large for pointer");
149  enum : uintptr_t {
150    /// PointerBitMask - The bits that come from the pointer.
151    PointerBitMask =
152        ~(uintptr_t)(((intptr_t)1 << PtrTraits::NumLowBitsAvailable) - 1),
153 
154    /// IntShift - The number of low bits that we reserve for other uses, and
155    /// keep zero.
156    IntShift = (uintptr_t)PtrTraits::NumLowBitsAvailable - IntBits,
157 
158    /// IntMask - This is the unshifted mask for valid bits of the int type.
159    IntMask = (uintptr_t)(((intptr_t)1 << IntBits) - 1),
160 
161    // ShiftedIntMask - This is the bits for the integer shifted in place.
162    ShiftedIntMask = (uintptr_t)(IntMask << IntShift)
163  };
164 
165  static PointerT getPointer(intptr_t Value) {
166    return PtrTraits::getFromVoidPointer(
167        reinterpret_cast<void *>(Value & PointerBitMask));
168  }
169 
170  static intptr_t getInt(intptr_t Value) {
171    return (Value >> IntShift) & IntMask;
172  }
173 
174  static intptr_t updatePointer(intptr_t OrigValue, PointerT Ptr) {
175    intptr_t PtrWord =
176        reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(Ptr));
177    assert((PtrWord & ~PointerBitMask) == 0 &&(((PtrWord & ~PointerBitMask) == 0 && "Pointer is not sufficiently aligned"
) ? static_cast<void> (0) : __assert_fail ("(PtrWord & ~PointerBitMask) == 0 && \"Pointer is not sufficiently aligned\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerIntPair.h"
, 178, __PRETTY_FUNCTION__))
178           "Pointer is not sufficiently aligned")(((PtrWord & ~PointerBitMask) == 0 && "Pointer is not sufficiently aligned"
) ? static_cast<void> (0) : __assert_fail ("(PtrWord & ~PointerBitMask) == 0 && \"Pointer is not sufficiently aligned\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerIntPair.h"
, 178, __PRETTY_FUNCTION__));
179    // Preserve all low bits, just update the pointer.
180    return PtrWord | (OrigValue & ~PointerBitMask);
181  }
182 
183  static intptr_t updateInt(intptr_t OrigValue, intptr_t Int) {
184    intptr_t IntWord = static_cast<intptr_t>(Int);
185    assert((IntWord & ~IntMask) == 0 && "Integer too large for field")(((IntWord & ~IntMask) == 0 && "Integer too large for field"
) ? static_cast<void> (0) : __assert_fail ("(IntWord & ~IntMask) == 0 && \"Integer too large for field\""
, "/build/llvm-toolchain-snapshot-10~svn373517/include/llvm/ADT/PointerIntPair.h"
, 185, __PRETTY_FUNCTION__));
186 
187    // Preserve all bits other than the ones we are updating.
188    return (OrigValue & ~ShiftedIntMask) | IntWord << IntShift;
189  }
190};
191 
192// Provide specialization of DenseMapInfo for PointerIntPair.
193template <typename PointerTy, unsigned IntBits, typename IntType>
194struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {
195  using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
196 
197  static Ty getEmptyKey() {
198    uintptr_t Val = static_cast<uintptr_t>(-1);
199    Val <<= PointerLikeTypeTraits<Ty>::NumLowBitsAvailable;
200    return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
201  }
202 
203  static Ty getTombstoneKey() {
204    uintptr_t Val = static_cast<uintptr_t>(-2);
205    Val <<= PointerLikeTypeTraits<PointerTy>::NumLowBitsAvailable;
206    return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
207  }
208 
209  static unsigned getHashValue(Ty V) {
210    uintptr_t IV = reinterpret_cast<uintptr_t>(V.getOpaqueValue());
211    return unsigned(IV) ^ unsigned(IV >> 9);
212  }
213 
214  static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; }
215};
216 
217// Teach SmallPtrSet that PointerIntPair is "basically a pointer".
218template <typename PointerTy, unsigned IntBits, typename IntType,
219          typename PtrTraits>
220struct PointerLikeTypeTraits<
221    PointerIntPair<PointerTy, IntBits, IntType, PtrTraits>> {
222  static inline void *
223  getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
224    return P.getOpaqueValue();
225  }
226 
227  static inline PointerIntPair<PointerTy, IntBits, IntType>
228  getFromVoidPointer(void *P) {
229    return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
230  }
231 
232  static inline PointerIntPair<PointerTy, IntBits, IntType>
233  getFromVoidPointer(const void *P) {
234    return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
235  }
236 
237  enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };
238};
239 
240} // end namespace llvm
241 
242#endif // LLVM_ADT_POINTERINTPAIR_H