/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp

Bug Summary

File:	tools/clang/lib/Sema/SemaDeclCXX.cpp
Warning:	line 4208, column 43 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 SemaDeclCXX.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.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++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp

→

1//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file implements semantic analysis for C++ declarations.
11//
12//===----------------------------------------------------------------------===//

14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTLambda.h"
17#include "clang/AST/ASTMutationListener.h"
18#include "clang/AST/CXXInheritance.h"
19#include "clang/AST/CharUnits.h"
20#include "clang/AST/EvaluatedExprVisitor.h"
21#include "clang/AST/ExprCXX.h"
22#include "clang/AST/RecordLayout.h"
23#include "clang/AST/RecursiveASTVisitor.h"
24#include "clang/AST/StmtVisitor.h"
25#include "clang/AST/TypeLoc.h"
26#include "clang/AST/TypeOrdering.h"
27#include "clang/Basic/PartialDiagnostic.h"
28#include "clang/Basic/TargetInfo.h"
29#include "clang/Lex/LiteralSupport.h"
30#include "clang/Lex/Preprocessor.h"
31#include "clang/Sema/CXXFieldCollector.h"
32#include "clang/Sema/DeclSpec.h"
33#include "clang/Sema/Initialization.h"
34#include "clang/Sema/Lookup.h"
35#include "clang/Sema/ParsedTemplate.h"
36#include "clang/Sema/Scope.h"
37#include "clang/Sema/ScopeInfo.h"
38#include "clang/Sema/SemaInternal.h"
39#include "clang/Sema/Template.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/SmallString.h"
42#include "llvm/ADT/StringExtras.h"
43#include <map>
44#include <set>

46using namespace clang;

48//===----------------------------------------------------------------------===//
49// CheckDefaultArgumentVisitor
50//===----------------------------------------------------------------------===//

52namespace {
/// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
/// the default argument of a parameter to determine whether it
/// contains any ill-formed subexpressions. For example, this will
/// diagnose the use of local variables or parameters within the
/// default argument expression.
class CheckDefaultArgumentVisitor
  : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
  Expr *DefaultArg;
  Sema *S;

public:
  CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
    : DefaultArg(defarg), S(s) {}

  bool VisitExpr(Expr *Node);
  bool VisitDeclRefExpr(DeclRefExpr *DRE);
  bool VisitCXXThisExpr(CXXThisExpr *ThisE);
  bool VisitLambdaExpr(LambdaExpr *Lambda);
  bool VisitPseudoObjectExpr(PseudoObjectExpr *POE);
};

/// VisitExpr - Visit all of the children of this expression.
bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
  bool IsInvalid = false;
  for (Stmt *SubStmt : Node->children())
    IsInvalid |= Visit(SubStmt);
  return IsInvalid;
}

/// VisitDeclRefExpr - Visit a reference to a declaration, to
/// determine whether this declaration can be used in the default
/// argument expression.
bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
  NamedDecl *Decl = DRE->getDecl();
  if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
    // C++ [dcl.fct.default]p9
    //   Default arguments are evaluated each time the function is
    //   called. The order of evaluation of function arguments is
    //   unspecified. Consequently, parameters of a function shall not
    //   be used in default argument expressions, even if they are not
    //   evaluated. Parameters of a function declared before a default
    //   argument expression are in scope and can hide namespace and
    //   class member names.
    return S->Diag(DRE->getLocStart(),
                   diag::err_param_default_argument_references_param)
       << Param->getDeclName() << DefaultArg->getSourceRange();
  } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
    // C++ [dcl.fct.default]p7
    //   Local variables shall not be used in default argument
    //   expressions.
    if (VDecl->isLocalVarDecl())
      return S->Diag(DRE->getLocStart(),
                     diag::err_param_default_argument_references_local)
        << VDecl->getDeclName() << DefaultArg->getSourceRange();
  }

  return false;
}

/// VisitCXXThisExpr - Visit a C++ "this" expression.
bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
  // C++ [dcl.fct.default]p8:
  //   The keyword this shall not be used in a default argument of a
  //   member function.
  return S->Diag(ThisE->getLocStart(),
                 diag::err_param_default_argument_references_this)
             << ThisE->getSourceRange();
}

bool CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
  bool Invalid = false;
  for (PseudoObjectExpr::semantics_iterator
         i = POE->semantics_begin(), e = POE->semantics_end(); i != e; ++i) {
    Expr *E = *i;

    // Look through bindings.
    if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
      E = OVE->getSourceExpr();
      assert(E && "pseudo-object binding without source expression?")(static_cast <bool> (E && "pseudo-object binding without source expression?"
) ? void (0) : __assert_fail ("E && \"pseudo-object binding without source expression?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 131, __extension__ __PRETTY_FUNCTION__));
    }

    Invalid |= Visit(E);
  }
  return Invalid;
}

bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
  // C++11 [expr.lambda.prim]p13:
  //   A lambda-expression appearing in a default argument shall not
  //   implicitly or explicitly capture any entity.
  if (Lambda->capture_begin() == Lambda->capture_end())
    return false;

  return S->Diag(Lambda->getLocStart(),
                 diag::err_lambda_capture_default_arg);
}
149}

151void
152Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc,
                                               const CXXMethodDecl *Method) {
// If we have an MSAny spec already, don't bother.
if (!Method || ComputedEST == EST_MSAny)
  return;

const FunctionProtoType *Proto
  = Method->getType()->getAs<FunctionProtoType>();
Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
if (!Proto)
  return;

ExceptionSpecificationType EST = Proto->getExceptionSpecType();

// If we have a throw-all spec at this point, ignore the function.
if (ComputedEST == EST_None)
  return;

if (EST == EST_None && Method->hasAttr<NoThrowAttr>())
  EST = EST_BasicNoexcept;

switch(EST) {
// If this function can throw any exceptions, make a note of that.
case EST_MSAny:
case EST_None:
  ClearExceptions();
  ComputedEST = EST;
  return;
// FIXME: If the call to this decl is using any of its default arguments, we
// need to search them for potentially-throwing calls.
// If this function has a basic noexcept, it doesn't affect the outcome.
case EST_BasicNoexcept:
  return;
// If we're still at noexcept(true) and there's a nothrow() callee,
// change to that specification.
case EST_DynamicNone:
  if (ComputedEST == EST_BasicNoexcept)
    ComputedEST = EST_DynamicNone;
  return;
// Check out noexcept specs.
case EST_ComputedNoexcept:
{
  FunctionProtoType::NoexceptResult NR =
      Proto->getNoexceptSpec(Self->Context);
  assert(NR != FunctionProtoType::NR_NoNoexcept &&(static_cast <bool> (NR != FunctionProtoType::NR_NoNoexcept
 && "Must have noexcept result for EST_ComputedNoexcept."
) ? void (0) : __assert_fail ("NR != FunctionProtoType::NR_NoNoexcept && \"Must have noexcept result for EST_ComputedNoexcept.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 197, __extension__ __PRETTY_FUNCTION__))
         "Must have noexcept result for EST_ComputedNoexcept.")(static_cast <bool> (NR != FunctionProtoType::NR_NoNoexcept
 && "Must have noexcept result for EST_ComputedNoexcept."
) ? void (0) : __assert_fail ("NR != FunctionProtoType::NR_NoNoexcept && \"Must have noexcept result for EST_ComputedNoexcept.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 197, __extension__ __PRETTY_FUNCTION__));
  assert(NR != FunctionProtoType::NR_Dependent &&(static_cast <bool> (NR != FunctionProtoType::NR_Dependent
 && "Should not generate implicit declarations for dependent cases, "
 "and don't know how to handle them anyway.") ? void (0) : __assert_fail
 ("NR != FunctionProtoType::NR_Dependent && \"Should not generate implicit declarations for dependent cases, \" \"and don't know how to handle them anyway.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 200, __extension__ __PRETTY_FUNCTION__))
         "Should not generate implicit declarations for dependent cases, "(static_cast <bool> (NR != FunctionProtoType::NR_Dependent
 && "Should not generate implicit declarations for dependent cases, "
 "and don't know how to handle them anyway.") ? void (0) : __assert_fail
 ("NR != FunctionProtoType::NR_Dependent && \"Should not generate implicit declarations for dependent cases, \" \"and don't know how to handle them anyway.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 200, __extension__ __PRETTY_FUNCTION__))
         "and don't know how to handle them anyway.")(static_cast <bool> (NR != FunctionProtoType::NR_Dependent
 && "Should not generate implicit declarations for dependent cases, "
 "and don't know how to handle them anyway.") ? void (0) : __assert_fail
 ("NR != FunctionProtoType::NR_Dependent && \"Should not generate implicit declarations for dependent cases, \" \"and don't know how to handle them anyway.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 200, __extension__ __PRETTY_FUNCTION__));
  // noexcept(false) -> no spec on the new function
  if (NR == FunctionProtoType::NR_Throw) {
    ClearExceptions();
    ComputedEST = EST_None;
  }
  // noexcept(true) won't change anything either.
  return;
}
default:
  break;
}
assert(EST == EST_Dynamic && "EST case not considered earlier.")(static_cast <bool> (EST == EST_Dynamic && "EST case not considered earlier."
) ? void (0) : __assert_fail ("EST == EST_Dynamic && \"EST case not considered earlier.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 212, __extension__ __PRETTY_FUNCTION__));
assert(ComputedEST != EST_None &&(static_cast <bool> (ComputedEST != EST_None &&
 "Shouldn't collect exceptions when throw-all is guaranteed."
) ? void (0) : __assert_fail ("ComputedEST != EST_None && \"Shouldn't collect exceptions when throw-all is guaranteed.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 214, __extension__ __PRETTY_FUNCTION__))
       "Shouldn't collect exceptions when throw-all is guaranteed.")(static_cast <bool> (ComputedEST != EST_None &&
 "Shouldn't collect exceptions when throw-all is guaranteed."
) ? void (0) : __assert_fail ("ComputedEST != EST_None && \"Shouldn't collect exceptions when throw-all is guaranteed.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 214, __extension__ __PRETTY_FUNCTION__));
ComputedEST = EST_Dynamic;
// Record the exceptions in this function's exception specification.
for (const auto &E : Proto->exceptions())
  if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
    Exceptions.push_back(E);
220}

222void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) {
if (!E || ComputedEST == EST_MSAny)
  return;

// FIXME:
//
// C++0x [except.spec]p14:
//   [An] implicit exception-specification specifies the type-id T if and
// only if T is allowed by the exception-specification of a function directly
// invoked by f's implicit definition; f shall allow all exceptions if any
// function it directly invokes allows all exceptions, and f shall allow no
// exceptions if every function it directly invokes allows no exceptions.
//
// Note in particular that if an implicit exception-specification is generated
// for a function containing a throw-expression, that specification can still
// be noexcept(true).
//
// Note also that 'directly invoked' is not defined in the standard, and there
// is no indication that we should only consider potentially-evaluated calls.
//
// Ultimately we should implement the intent of the standard: the exception
// specification should be the set of exceptions which can be thrown by the
// implicit definition. For now, we assume that any non-nothrow expression can
// throw any exception.

if (Self->canThrow(E))
  ComputedEST = EST_None;
249}

251bool
252Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
                            SourceLocation EqualLoc) {
if (RequireCompleteType(Param->getLocation(), Param->getType(),
                        diag::err_typecheck_decl_incomplete_type)) {
  Param->setInvalidDecl();
  return true;
}

// C++ [dcl.fct.default]p5
//   A default argument expression is implicitly converted (clause
//   4) to the parameter type. The default argument expression has
//   the same semantic constraints as the initializer expression in
//   a declaration of a variable of the parameter type, using the
//   copy-initialization semantics (8.5).
InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
                                                                  Param);
InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
                                                         EqualLoc);
InitializationSequence InitSeq(*this, Entity, Kind, Arg);
ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
if (Result.isInvalid())
  return true;
Arg = Result.getAs<Expr>();

CheckCompletedExpr(Arg, EqualLoc);
Arg = MaybeCreateExprWithCleanups(Arg);

// Okay: add the default argument to the parameter
Param->setDefaultArg(Arg);

// We have already instantiated this parameter; provide each of the
// instantiations with the uninstantiated default argument.
UnparsedDefaultArgInstantiationsMap::iterator InstPos
  = UnparsedDefaultArgInstantiations.find(Param);
if (InstPos != UnparsedDefaultArgInstantiations.end()) {
  for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
    InstPos->second[I]->setUninstantiatedDefaultArg(Arg);

  // We're done tracking this parameter's instantiations.
  UnparsedDefaultArgInstantiations.erase(InstPos);
}

return false;
295}

297/// ActOnParamDefaultArgument - Check whether the default argument
298/// provided for a function parameter is well-formed. If so, attach it
299/// to the parameter declaration.
300void
301Sema::ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc,
                              Expr *DefaultArg) {
if (!param || !DefaultArg)
  return;

ParmVarDecl *Param = cast<ParmVarDecl>(param);
UnparsedDefaultArgLocs.erase(Param);

// Default arguments are only permitted in C++
if (!getLangOpts().CPlusPlus) {
  Diag(EqualLoc, diag::err_param_default_argument)
    << DefaultArg->getSourceRange();
  Param->setInvalidDecl();
  return;
}

// Check for unexpanded parameter packs.
if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {
  Param->setInvalidDecl();
  return;
}

// C++11 [dcl.fct.default]p3
//   A default argument expression [...] shall not be specified for a
//   parameter pack.
if (Param->isParameterPack()) {
  Diag(EqualLoc, diag::err_param_default_argument_on_parameter_pack)
      << DefaultArg->getSourceRange();
  return;
}

// Check that the default argument is well-formed
CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
if (DefaultArgChecker.Visit(DefaultArg)) {
  Param->setInvalidDecl();
  return;
}

SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
340}

342/// ActOnParamUnparsedDefaultArgument - We've seen a default
343/// argument for a function parameter, but we can't parse it yet
344/// because we're inside a class definition. Note that this default
345/// argument will be parsed later.
346void Sema::ActOnParamUnparsedDefaultArgument(Decl *param,
                                           SourceLocation EqualLoc,
                                           SourceLocation ArgLoc) {
if (!param)
  return;

ParmVarDecl *Param = cast<ParmVarDecl>(param);
Param->setUnparsedDefaultArg();
UnparsedDefaultArgLocs[Param] = ArgLoc;
355}

357/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
358/// the default argument for the parameter param failed.
359void Sema::ActOnParamDefaultArgumentError(Decl *param,
                                        SourceLocation EqualLoc) {
if (!param)
  return;

ParmVarDecl *Param = cast<ParmVarDecl>(param);
Param->setInvalidDecl();
UnparsedDefaultArgLocs.erase(Param);
Param->setDefaultArg(new(Context)
                     OpaqueValueExpr(EqualLoc,
                                     Param->getType().getNonReferenceType(),
                                     VK_RValue));
371}

373/// CheckExtraCXXDefaultArguments - Check for any extra default
374/// arguments in the declarator, which is not a function declaration
375/// or definition and therefore is not permitted to have default
376/// arguments. This routine should be invoked for every declarator
377/// that is not a function declaration or definition.
378void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
// C++ [dcl.fct.default]p3
//   A default argument expression shall be specified only in the
//   parameter-declaration-clause of a function declaration or in a
//   template-parameter (14.1). It shall not be specified for a
//   parameter pack. If it is specified in a
//   parameter-declaration-clause, it shall not occur within a
//   declarator or abstract-declarator of a parameter-declaration.
bool MightBeFunction = D.isFunctionDeclarationContext();
for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
  DeclaratorChunk &chunk = D.getTypeObject(i);
  if (chunk.Kind == DeclaratorChunk::Function) {
    if (MightBeFunction) {
      // This is a function declaration. It can have default arguments, but
      // keep looking in case its return type is a function type with default
      // arguments.
      MightBeFunction = false;
      continue;
    }
    for (unsigned argIdx = 0, e = chunk.Fun.NumParams; argIdx != e;
         ++argIdx) {
      ParmVarDecl *Param = cast<ParmVarDecl>(chunk.Fun.Params[argIdx].Param);
      if (Param->hasUnparsedDefaultArg()) {
        std::unique_ptr<CachedTokens> Toks =
            std::move(chunk.Fun.Params[argIdx].DefaultArgTokens);
        SourceRange SR;
        if (Toks->size() > 1)
          SR = SourceRange((*Toks)[1].getLocation(),
                           Toks->back().getLocation());
        else
          SR = UnparsedDefaultArgLocs[Param];
        Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
          << SR;
      } else if (Param->getDefaultArg()) {
        Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
          << Param->getDefaultArg()->getSourceRange();
        Param->setDefaultArg(nullptr);
      }
    }
  } else if (chunk.Kind != DeclaratorChunk::Paren) {
    MightBeFunction = false;
  }
}
421}

423static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) {
for (unsigned NumParams = FD->getNumParams(); NumParams > 0; --NumParams) {
  const ParmVarDecl *PVD = FD->getParamDecl(NumParams-1);
  if (!PVD->hasDefaultArg())
    return false;
  if (!PVD->hasInheritedDefaultArg())
    return true;
}
return false;
432}

434/// MergeCXXFunctionDecl - Merge two declarations of the same C++
435/// function, once we already know that they have the same
436/// type. Subroutine of MergeFunctionDecl. Returns true if there was an
437/// error, false otherwise.
438bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old,
                              Scope *S) {
bool Invalid = false;

// The declaration context corresponding to the scope is the semantic
// parent, unless this is a local function declaration, in which case
// it is that surrounding function.
DeclContext *ScopeDC = New->isLocalExternDecl()
                           ? New->getLexicalDeclContext()
                           : New->getDeclContext();

// Find the previous declaration for the purpose of default arguments.
FunctionDecl *PrevForDefaultArgs = Old;
for (/**/; PrevForDefaultArgs;
     // Don't bother looking back past the latest decl if this is a local
     // extern declaration; nothing else could work.
     PrevForDefaultArgs = New->isLocalExternDecl()
                              ? nullptr
                              : PrevForDefaultArgs->getPreviousDecl()) {
  // Ignore hidden declarations.
  if (!LookupResult::isVisible(*this, PrevForDefaultArgs))
    continue;

  if (S && !isDeclInScope(PrevForDefaultArgs, ScopeDC, S) &&
      !New->isCXXClassMember()) {
    // Ignore default arguments of old decl if they are not in
    // the same scope and this is not an out-of-line definition of
    // a member function.
    continue;
  }

  if (PrevForDefaultArgs->isLocalExternDecl() != New->isLocalExternDecl()) {
    // If only one of these is a local function declaration, then they are
    // declared in different scopes, even though isDeclInScope may think
    // they're in the same scope. (If both are local, the scope check is
    // sufficient, and if neither is local, then they are in the same scope.)
    continue;
  }

  // We found the right previous declaration.
  break;
}

// C++ [dcl.fct.default]p4:
//   For non-template functions, default arguments can be added in
//   later declarations of a function in the same
//   scope. Declarations in different scopes have completely
//   distinct sets of default arguments. That is, declarations in
//   inner scopes do not acquire default arguments from
//   declarations in outer scopes, and vice versa. In a given
//   function declaration, all parameters subsequent to a
//   parameter with a default argument shall have default
//   arguments supplied in this or previous declarations. A
//   default argument shall not be redefined by a later
//   declaration (not even to the same value).
//
// C++ [dcl.fct.default]p6:
//   Except for member functions of class templates, the default arguments
//   in a member function definition that appears outside of the class
//   definition are added to the set of default arguments provided by the
//   member function declaration in the class definition.
for (unsigned p = 0, NumParams = PrevForDefaultArgs
                                     ? PrevForDefaultArgs->getNumParams()
                                     : 0;
     p < NumParams; ++p) {
  ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);
  ParmVarDecl *NewParam = New->getParamDecl(p);

  bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : false;
  bool NewParamHasDfl = NewParam->hasDefaultArg();

  if (OldParamHasDfl && NewParamHasDfl) {
    unsigned DiagDefaultParamID =
      diag::err_param_default_argument_redefinition;

    // MSVC accepts that default parameters be redefined for member functions
    // of template class. The new default parameter's value is ignored.
    Invalid = true;
    if (getLangOpts().MicrosoftExt) {
      CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(New);
      if (MD && MD->getParent()->getDescribedClassTemplate()) {
        // Merge the old default argument into the new parameter.
        NewParam->setHasInheritedDefaultArg();
        if (OldParam->hasUninstantiatedDefaultArg())
          NewParam->setUninstantiatedDefaultArg(
                                    OldParam->getUninstantiatedDefaultArg());
        else
          NewParam->setDefaultArg(OldParam->getInit());
        DiagDefaultParamID = diag::ext_param_default_argument_redefinition;
        Invalid = false;
      }
    }

    // FIXME: If we knew where the '=' was, we could easily provide a fix-it
    // hint here. Alternatively, we could walk the type-source information
    // for NewParam to find the last source location in the type... but it
    // isn't worth the effort right now. This is the kind of test case that
    // is hard to get right:
    //   int f(int);
    //   void g(int (*fp)(int) = f);
    //   void g(int (*fp)(int) = &f);
    Diag(NewParam->getLocation(), DiagDefaultParamID)
      << NewParam->getDefaultArgRange();

    // Look for the function declaration where the default argument was
    // actually written, which may be a declaration prior to Old.
    for (auto Older = PrevForDefaultArgs;
         OldParam->hasInheritedDefaultArg(); /**/) {
      Older = Older->getPreviousDecl();
      OldParam = Older->getParamDecl(p);
    }

    Diag(OldParam->getLocation(), diag::note_previous_definition)
      << OldParam->getDefaultArgRange();
  } else if (OldParamHasDfl) {
    // Merge the old default argument into the new parameter unless the new
    // function is a friend declaration in a template class. In the latter
    // case the default arguments will be inherited when the friend
    // declaration will be instantiated.
    if (New->getFriendObjectKind() == Decl::FOK_None ||
        !New->getLexicalDeclContext()->isDependentContext()) {
      // It's important to use getInit() here;  getDefaultArg()
      // strips off any top-level ExprWithCleanups.
      NewParam->setHasInheritedDefaultArg();
      if (OldParam->hasUnparsedDefaultArg())
        NewParam->setUnparsedDefaultArg();
      else if (OldParam->hasUninstantiatedDefaultArg())
        NewParam->setUninstantiatedDefaultArg(
                                     OldParam->getUninstantiatedDefaultArg());
      else
        NewParam->setDefaultArg(OldParam->getInit());
    }
  } else if (NewParamHasDfl) {
    if (New->getDescribedFunctionTemplate()) {
      // Paragraph 4, quoted above, only applies to non-template functions.
      Diag(NewParam->getLocation(),
           diag::err_param_default_argument_template_redecl)
        << NewParam->getDefaultArgRange();
      Diag(PrevForDefaultArgs->getLocation(),
           diag::note_template_prev_declaration)
          << false;
    } else if (New->getTemplateSpecializationKind()
                 != TSK_ImplicitInstantiation &&
               New->getTemplateSpecializationKind() != TSK_Undeclared) {
      // C++ [temp.expr.spec]p21:
      //   Default function arguments shall not be specified in a declaration
      //   or a definition for one of the following explicit specializations:
      //     - the explicit specialization of a function template;
      //     - the explicit specialization of a member function template;
      //     - the explicit specialization of a member function of a class
      //       template where the class template specialization to which the
      //       member function specialization belongs is implicitly
      //       instantiated.
      Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
        << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
        << New->getDeclName()
        << NewParam->getDefaultArgRange();
    } else if (New->getDeclContext()->isDependentContext()) {
      // C++ [dcl.fct.default]p6 (DR217):
      //   Default arguments for a member function of a class template shall
      //   be specified on the initial declaration of the member function
      //   within the class template.
      //
      // Reading the tea leaves a bit in DR217 and its reference to DR205
      // leads me to the conclusion that one cannot add default function
      // arguments for an out-of-line definition of a member function of a
      // dependent type.
      int WhichKind = 2;
      if (CXXRecordDecl *Record
            = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
        if (Record->getDescribedClassTemplate())
          WhichKind = 0;
        else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
          WhichKind = 1;
        else
          WhichKind = 2;
      }

      Diag(NewParam->getLocation(),
           diag::err_param_default_argument_member_template_redecl)
        << WhichKind
        << NewParam->getDefaultArgRange();
    }
  }
}

// DR1344: If a default argument is added outside a class definition and that
// default argument makes the function a special member function, the program
// is ill-formed. This can only happen for constructors.
if (isa<CXXConstructorDecl>(New) &&
    New->getMinRequiredArguments() < Old->getMinRequiredArguments()) {
  CXXSpecialMember NewSM = getSpecialMember(cast<CXXMethodDecl>(New)),
                   OldSM = getSpecialMember(cast<CXXMethodDecl>(Old));
  if (NewSM != OldSM) {
    ParmVarDecl *NewParam = New->getParamDecl(New->getMinRequiredArguments());
    assert(NewParam->hasDefaultArg())(static_cast <bool> (NewParam->hasDefaultArg()) ? void
 (0) : __assert_fail ("NewParam->hasDefaultArg()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 633, __extension__ __PRETTY_FUNCTION__));
    Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
      << NewParam->getDefaultArgRange() << NewSM;
    Diag(Old->getLocation(), diag::note_previous_declaration);
  }
}

const FunctionDecl *Def;
// C++11 [dcl.constexpr]p1: If any declaration of a function or function
// template has a constexpr specifier then all its declarations shall
// contain the constexpr specifier.
if (New->isConstexpr() != Old->isConstexpr()) {
  Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
    << New << New->isConstexpr();
  Diag(Old->getLocation(), diag::note_previous_declaration);
  Invalid = true;
} else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
           Old->isDefined(Def) &&
           // If a friend function is inlined but does not have 'inline'
           // specifier, it is a definition. Do not report attribute conflict
           // in this case, redefinition will be diagnosed later.
           (New->isInlineSpecified() ||
            New->getFriendObjectKind() == Decl::FOK_None)) {
  // C++11 [dcl.fcn.spec]p4:
  //   If the definition of a function appears in a translation unit before its
  //   first declaration as inline, the program is ill-formed.
  Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
  Diag(Def->getLocation(), diag::note_previous_definition);
  Invalid = true;
}

// FIXME: It's not clear what should happen if multiple declarations of a
// deduction guide have different explicitness. For now at least we simply
// reject any case where the explicitness changes.
auto *NewGuide = dyn_cast<CXXDeductionGuideDecl>(New);
if (NewGuide && NewGuide->isExplicitSpecified() !=
                    cast<CXXDeductionGuideDecl>(Old)->isExplicitSpecified()) {
  Diag(New->getLocation(), diag::err_deduction_guide_explicit_mismatch)
    << NewGuide->isExplicitSpecified();
  Diag(Old->getLocation(), diag::note_previous_declaration);
}

// C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
// argument expression, that declaration shall be a definition and shall be
// the only declaration of the function or function template in the
// translation unit.
if (Old->getFriendObjectKind() == Decl::FOK_Undeclared &&
    functionDeclHasDefaultArgument(Old)) {
  Diag(New->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
  Diag(Old->getLocation(), diag::note_previous_declaration);
  Invalid = true;
}

return Invalid;
687}

689NamedDecl *
690Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,
                                 MultiTemplateParamsArg TemplateParamLists) {
assert(D.isDecompositionDeclarator())(static_cast <bool> (D.isDecompositionDeclarator()) ? void
 (0) : __assert_fail ("D.isDecompositionDeclarator()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 692, __extension__ __PRETTY_FUNCTION__));
const DecompositionDeclarator &Decomp = D.getDecompositionDeclarator();

// The syntax only allows a decomposition declarator as a simple-declaration,
// a for-range-declaration, or a condition in Clang, but we parse it in more
// cases than that.
if (!D.mayHaveDecompositionDeclarator()) {
  Diag(Decomp.getLSquareLoc(), diag::err_decomp_decl_context)
    << Decomp.getSourceRange();
  return nullptr;
}

if (!TemplateParamLists.empty()) {
  // FIXME: There's no rule against this, but there are also no rules that
  // would actually make it usable, so we reject it for now.
  Diag(TemplateParamLists.front()->getTemplateLoc(),
       diag::err_decomp_decl_template);
  return nullptr;
}

Diag(Decomp.getLSquareLoc(),
     !getLangOpts().CPlusPlus17
         ? diag::ext_decomp_decl
         : D.getContext() == DeclaratorContext::ConditionContext
               ? diag::ext_decomp_decl_cond
               : diag::warn_cxx14_compat_decomp_decl)
    << Decomp.getSourceRange();

// The semantic context is always just the current context.
DeclContext *const DC = CurContext;

// C++1z [dcl.dcl]/8:
//   The decl-specifier-seq shall contain only the type-specifier auto
//   and cv-qualifiers.
auto &DS = D.getDeclSpec();
{
  SmallVector<StringRef, 8> BadSpecifiers;
  SmallVector<SourceLocation, 8> BadSpecifierLocs;
  if (auto SCS = DS.getStorageClassSpec()) {
    BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
    BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
  }
  if (auto TSCS = DS.getThreadStorageClassSpec()) {
    BadSpecifiers.push_back(DeclSpec::getSpecifierName(TSCS));
    BadSpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
  }
  if (DS.isConstexprSpecified()) {
    BadSpecifiers.push_back("constexpr");
    BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());
  }
  if (DS.isInlineSpecified()) {
    BadSpecifiers.push_back("inline");
    BadSpecifierLocs.push_back(DS.getInlineSpecLoc());
  }
  if (!BadSpecifiers.empty()) {
    auto &&Err = Diag(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);
    Err << (int)BadSpecifiers.size()
        << llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(), " ");
    // Don't add FixItHints to remove the specifiers; we do still respect
    // them when building the underlying variable.
    for (auto Loc : BadSpecifierLocs)
      Err << SourceRange(Loc, Loc);
  }
  // We can't recover from it being declared as a typedef.
  if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
    return nullptr;
}

TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType R = TInfo->getType();

if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
                                    UPPC_DeclarationType))
  D.setInvalidType();

// The syntax only allows a single ref-qualifier prior to the decomposition
// declarator. No other declarator chunks are permitted. Also check the type
// specifier here.
if (DS.getTypeSpecType() != DeclSpec::TST_auto ||
    D.hasGroupingParens() || D.getNumTypeObjects() > 1 ||
    (D.getNumTypeObjects() == 1 &&
     D.getTypeObject(0).Kind != DeclaratorChunk::Reference)) {
  Diag(Decomp.getLSquareLoc(),
       (D.hasGroupingParens() ||
        (D.getNumTypeObjects() &&
         D.getTypeObject(0).Kind == DeclaratorChunk::Paren))
           ? diag::err_decomp_decl_parens
           : diag::err_decomp_decl_type)
      << R;

  // In most cases, there's no actual problem with an explicitly-specified
  // type, but a function type won't work here, and ActOnVariableDeclarator
  // shouldn't be called for such a type.
  if (R->isFunctionType())
    D.setInvalidType();
}

// Build the BindingDecls.
SmallVector<BindingDecl*, 8> Bindings;

// Build the BindingDecls.
for (auto &B : D.getDecompositionDeclarator().bindings()) {
  // Check for name conflicts.
  DeclarationNameInfo NameInfo(B.Name, B.NameLoc);
  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                        ForVisibleRedeclaration);
  LookupName(Previous, S,
             /*CreateBuiltins*/DC->getRedeclContext()->isTranslationUnit());

  // It's not permitted to shadow a template parameter name.
  if (Previous.isSingleResult() &&
      Previous.getFoundDecl()->isTemplateParameter()) {
    DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
                                    Previous.getFoundDecl());
    Previous.clear();
  }

  bool ConsiderLinkage = DC->isFunctionOrMethod() &&
                         DS.getStorageClassSpec() == DeclSpec::SCS_extern;
  FilterLookupForScope(Previous, DC, S, ConsiderLinkage,
                       /*AllowInlineNamespace*/false);
  if (!Previous.empty()) {
    auto *Old = Previous.getRepresentativeDecl();
    Diag(B.NameLoc, diag::err_redefinition) << B.Name;
    Diag(Old->getLocation(), diag::note_previous_definition);
  }

  auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, B.Name);
  PushOnScopeChains(BD, S, true);
  Bindings.push_back(BD);
  ParsingInitForAutoVars.insert(BD);
}

// There are no prior lookup results for the variable itself, because it
// is unnamed.
DeclarationNameInfo NameInfo((IdentifierInfo *)nullptr,
                             Decomp.getLSquareLoc());
LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                      ForVisibleRedeclaration);

// Build the variable that holds the non-decomposed object.
bool AddToScope = true;
NamedDecl *New =
    ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
                            MultiTemplateParamsArg(), AddToScope, Bindings);
if (AddToScope) {
  S->AddDecl(New);
  CurContext->addHiddenDecl(New);
}

if (isInOpenMPDeclareTargetContext())
  checkDeclIsAllowedInOpenMPTarget(nullptr, New);

return New;
846}

848static bool checkSimpleDecomposition(
  Sema &S, ArrayRef<BindingDecl *> Bindings, ValueDecl *Src,
  QualType DecompType, const llvm::APSInt &NumElems, QualType ElemType,
  llvm::function_ref<ExprResult(SourceLocation, Expr *, unsigned)> GetInit) {
if ((int64_t)Bindings.size() != NumElems) {
  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
      << DecompType << (unsigned)Bindings.size() << NumElems.toString(10)
      << (NumElems < Bindings.size());
  return true;
}

unsigned I = 0;
for (auto *B : Bindings) {
  SourceLocation Loc = B->getLocation();
  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
  if (E.isInvalid())
    return true;
  E = GetInit(Loc, E.get(), I++);
  if (E.isInvalid())
    return true;
  B->setBinding(ElemType, E.get());
}

return false;
872}

874static bool checkArrayLikeDecomposition(Sema &S,
                                      ArrayRef<BindingDecl *> Bindings,
                                      ValueDecl *Src, QualType DecompType,
                                      const llvm::APSInt &NumElems,
                                      QualType ElemType) {
return checkSimpleDecomposition(
    S, Bindings, Src, DecompType, NumElems, ElemType,
    [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
      ExprResult E = S.ActOnIntegerConstant(Loc, I);
      if (E.isInvalid())
        return ExprError();
      return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
    });
887}

889static bool checkArrayDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
                                  ValueDecl *Src, QualType DecompType,
                                  const ConstantArrayType *CAT) {
return checkArrayLikeDecomposition(S, Bindings, Src, DecompType,
                                   llvm::APSInt(CAT->getSize()),
                                   CAT->getElementType());
895}

897static bool checkVectorDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
                                   ValueDecl *Src, QualType DecompType,
                                   const VectorType *VT) {
return checkArrayLikeDecomposition(
    S, Bindings, Src, DecompType, llvm::APSInt::get(VT->getNumElements()),
    S.Context.getQualifiedType(VT->getElementType(),
                               DecompType.getQualifiers()));
904}

906static bool checkComplexDecomposition(Sema &S,
                                    ArrayRef<BindingDecl *> Bindings,
                                    ValueDecl *Src, QualType DecompType,
                                    const ComplexType *CT) {
return checkSimpleDecomposition(
    S, Bindings, Src, DecompType, llvm::APSInt::get(2),
    S.Context.getQualifiedType(CT->getElementType(),
                               DecompType.getQualifiers()),
    [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
      return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
    });
917}

919static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy,
                                   TemplateArgumentListInfo &Args) {
SmallString<128> SS;
llvm::raw_svector_ostream OS(SS);
bool First = true;
for (auto &Arg : Args.arguments()) {
  if (!First)
    OS << ", ";
  Arg.getArgument().print(PrintingPolicy, OS);
  First = false;
}
return OS.str();
931}

933static bool lookupStdTypeTraitMember(Sema &S, LookupResult &TraitMemberLookup,
                                   SourceLocation Loc, StringRef Trait,
                                   TemplateArgumentListInfo &Args,
                                   unsigned DiagID) {
auto DiagnoseMissing = [&] {
  if (DiagID)
    S.Diag(Loc, DiagID) << printTemplateArgs(S.Context.getPrintingPolicy(),
                                             Args);
  return true;
};

// FIXME: Factor out duplication with lookupPromiseType in SemaCoroutine.
NamespaceDecl *Std = S.getStdNamespace();
if (!Std)
  return DiagnoseMissing();

// Look up the trait itself, within namespace std. We can diagnose various
// problems with this lookup even if we've been asked to not diagnose a
// missing specialization, because this can only fail if the user has been
// declaring their own names in namespace std or we don't support the
// standard library implementation in use.
LookupResult Result(S, &S.PP.getIdentifierTable().get(Trait),
                    Loc, Sema::LookupOrdinaryName);
if (!S.LookupQualifiedName(Result, Std))
  return DiagnoseMissing();
if (Result.isAmbiguous())
  return true;

ClassTemplateDecl *TraitTD = Result.getAsSingle<ClassTemplateDecl>();
if (!TraitTD) {
  Result.suppressDiagnostics();
  NamedDecl *Found = *Result.begin();
  S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
  S.Diag(Found->getLocation(), diag::note_declared_at);
  return true;
}

// Build the template-id.
QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
if (TraitTy.isNull())
  return true;
if (!S.isCompleteType(Loc, TraitTy)) {
  if (DiagID)
    S.RequireCompleteType(
        Loc, TraitTy, DiagID,
        printTemplateArgs(S.Context.getPrintingPolicy(), Args));
  return true;
}

CXXRecordDecl *RD = TraitTy->getAsCXXRecordDecl();
assert(RD && "specialization of class template is not a class?")(static_cast <bool> (RD && "specialization of class template is not a class?"
) ? void (0) : __assert_fail ("RD && \"specialization of class template is not a class?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 983, __extension__ __PRETTY_FUNCTION__));

// Look up the member of the trait type.
S.LookupQualifiedName(TraitMemberLookup, RD);
return TraitMemberLookup.isAmbiguous();
988}

990static TemplateArgumentLoc
991getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T,
                                 uint64_t I) {
TemplateArgument Arg(S.Context, S.Context.MakeIntValue(I, T), T);
return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
995}

997static TemplateArgumentLoc
998getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T) {
return S.getTrivialTemplateArgumentLoc(TemplateArgument(T), QualType(), Loc);
1000}

1002namespace { enum class IsTupleLike { TupleLike, NotTupleLike, Error }; }

1004static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T,
                             llvm::APSInt &Size) {
EnterExpressionEvaluationContext ContextRAII(
    S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

DeclarationName Value = S.PP.getIdentifierInfo("value");
LookupResult R(S, Value, Loc, Sema::LookupOrdinaryName);

// Form template argument list for tuple_size<T>.
TemplateArgumentListInfo Args(Loc, Loc);
Args.addArgument(getTrivialTypeTemplateArgument(S, Loc, T));

// If there's no tuple_size specialization, it's not tuple-like.
if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/0))
  return IsTupleLike::NotTupleLike;

// If we get this far, we've committed to the tuple interpretation, but
// we can still fail if there actually isn't a usable ::value.

struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
  LookupResult &R;
  TemplateArgumentListInfo &Args;
  ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
      : R(R), Args(Args) {}
  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
    S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
        << printTemplateArgs(S.Context.getPrintingPolicy(), Args);
  }
} Diagnoser(R, Args);

if (R.empty()) {
  Diagnoser.diagnoseNotICE(S, Loc, SourceRange());
  return IsTupleLike::Error;
}

ExprResult E =
    S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
if (E.isInvalid())
  return IsTupleLike::Error;

E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser, false);
if (E.isInvalid())
  return IsTupleLike::Error;

return IsTupleLike::TupleLike;
1049}

1051/// \return std::tuple_element<I, T>::type.
1052static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc,
                                      unsigned I, QualType T) {
// Form template argument list for tuple_element<I, T>.
TemplateArgumentListInfo Args(Loc, Loc);
Args.addArgument(
    getTrivialIntegralTemplateArgument(S, Loc, S.Context.getSizeType(), I));
Args.addArgument(getTrivialTypeTemplateArgument(S, Loc, T));

DeclarationName TypeDN = S.PP.getIdentifierInfo("type");
LookupResult R(S, TypeDN, Loc, Sema::LookupOrdinaryName);
if (lookupStdTypeTraitMember(
        S, R, Loc, "tuple_element", Args,
        diag::err_decomp_decl_std_tuple_element_not_specialized))
  return QualType();

auto *TD = R.getAsSingle<TypeDecl>();
if (!TD) {
  R.suppressDiagnostics();
  S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
    << printTemplateArgs(S.Context.getPrintingPolicy(), Args);
  if (!R.empty())
    S.Diag(R.getRepresentativeDecl()->getLocation(), diag::note_declared_at);
  return QualType();
}

return S.Context.getTypeDeclType(TD);
1078}

1080namespace {
1081struct BindingDiagnosticTrap {
Sema &S;
DiagnosticErrorTrap Trap;
BindingDecl *BD;

BindingDiagnosticTrap(Sema &S, BindingDecl *BD)
    : S(S), Trap(S.Diags), BD(BD) {}
~BindingDiagnosticTrap() {
  if (Trap.hasErrorOccurred())
    S.Diag(BD->getLocation(), diag::note_in_binding_decl_init) << BD;
}
1092};
1093}

1095static bool checkTupleLikeDecomposition(Sema &S,
                                      ArrayRef<BindingDecl *> Bindings,
                                      VarDecl *Src, QualType DecompType,
                                      const llvm::APSInt &TupleSize) {
if ((int64_t)Bindings.size() != TupleSize) {
  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
      << DecompType << (unsigned)Bindings.size() << TupleSize.toString(10)
      << (TupleSize < Bindings.size());
  return true;
}

if (Bindings.empty())
  return false;

DeclarationName GetDN = S.PP.getIdentifierInfo("get");

// [dcl.decomp]p3:
//   The unqualified-id get is looked up in the scope of E by class member
//   access lookup
LookupResult MemberGet(S, GetDN, Src->getLocation(), Sema::LookupMemberName);
bool UseMemberGet = false;
if (S.isCompleteType(Src->getLocation(), DecompType)) {
  if (auto *RD = DecompType->getAsCXXRecordDecl())
    S.LookupQualifiedName(MemberGet, RD);
  if (MemberGet.isAmbiguous())
    return true;
  UseMemberGet = !MemberGet.empty();
  S.FilterAcceptableTemplateNames(MemberGet);
}

unsigned I = 0;
for (auto *B : Bindings) {
  BindingDiagnosticTrap Trap(S, B);
  SourceLocation Loc = B->getLocation();

  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
  if (E.isInvalid())
    return true;

  //   e is an lvalue if the type of the entity is an lvalue reference and
  //   an xvalue otherwise
  if (!Src->getType()->isLValueReferenceType())
    E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
                                 E.get(), nullptr, VK_XValue);

  TemplateArgumentListInfo Args(Loc, Loc);
  Args.addArgument(
      getTrivialIntegralTemplateArgument(S, Loc, S.Context.getSizeType(), I));

  if (UseMemberGet) {
    //   if [lookup of member get] finds at least one declaration, the
    //   initializer is e.get<i-1>().
    E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
                                   CXXScopeSpec(), SourceLocation(), nullptr,
                                   MemberGet, &Args, nullptr);
    if (E.isInvalid())
      return true;

    E = S.ActOnCallExpr(nullptr, E.get(), Loc, None, Loc);
  } else {
    //   Otherwise, the initializer is get<i-1>(e), where get is looked up
    //   in the associated namespaces.
    Expr *Get = UnresolvedLookupExpr::Create(
        S.Context, nullptr, NestedNameSpecifierLoc(), SourceLocation(),
        DeclarationNameInfo(GetDN, Loc), /*RequiresADL*/true, &Args,
        UnresolvedSetIterator(), UnresolvedSetIterator());

    Expr *Arg = E.get();
    E = S.ActOnCallExpr(nullptr, Get, Loc, Arg, Loc);
  }
  if (E.isInvalid())
    return true;
  Expr *Init = E.get();

  //   Given the type T designated by std::tuple_element<i - 1, E>::type,
  QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
  if (T.isNull())
    return true;

  //   each vi is a variable of type "reference to T" initialized with the
  //   initializer, where the reference is an lvalue reference if the
  //   initializer is an lvalue and an rvalue reference otherwise
  QualType RefType =
      S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
  if (RefType.isNull())
    return true;
  auto *RefVD = VarDecl::Create(
      S.Context, Src->getDeclContext(), Loc, Loc,
      B->getDeclName().getAsIdentifierInfo(), RefType,
      S.Context.getTrivialTypeSourceInfo(T, Loc), Src->getStorageClass());
  RefVD->setLexicalDeclContext(Src->getLexicalDeclContext());
  RefVD->setTSCSpec(Src->getTSCSpec());
  RefVD->setImplicit();
  if (Src->isInlineSpecified())
    RefVD->setInlineSpecified();
  RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);

  InitializedEntity Entity = InitializedEntity::InitializeBinding(RefVD);
  InitializationKind Kind = InitializationKind::CreateCopy(Loc, Loc);
  InitializationSequence Seq(S, Entity, Kind, Init);
  E = Seq.Perform(S, Entity, Kind, Init);
  if (E.isInvalid())
    return true;
  E = S.ActOnFinishFullExpr(E.get(), Loc);
  if (E.isInvalid())
    return true;
  RefVD->setInit(E.get());
  RefVD->checkInitIsICE();

  E = S.BuildDeclarationNameExpr(CXXScopeSpec(),
                                 DeclarationNameInfo(B->getDeclName(), Loc),
                                 RefVD);
  if (E.isInvalid())
    return true;

  B->setBinding(T, E.get());
  I++;
}

return false;
1215}

1217/// Find the base class to decompose in a built-in decomposition of a class type.
1218/// This base class search is, unfortunately, not quite like any other that we
1219/// perform anywhere else in C++.
1220static const CXXRecordDecl *findDecomposableBaseClass(Sema &S,
                                                    SourceLocation Loc,
                                                    const CXXRecordDecl *RD,
                                                    CXXCastPath &BasePath) {
auto BaseHasFields = [](const CXXBaseSpecifier *Specifier,
                        CXXBasePath &Path) {
  return Specifier->getType()->getAsCXXRecordDecl()->hasDirectFields();
};

const CXXRecordDecl *ClassWithFields = nullptr;
if (RD->hasDirectFields())
  // [dcl.decomp]p4:
  //   Otherwise, all of E's non-static data members shall be public direct
  //   members of E ...
  ClassWithFields = RD;
else {
  //   ... or of ...
  CXXBasePaths Paths;
  Paths.setOrigin(const_cast<CXXRecordDecl*>(RD));
  if (!RD->lookupInBases(BaseHasFields, Paths)) {
    // If no classes have fields, just decompose RD itself. (This will work
    // if and only if zero bindings were provided.)
    return RD;
  }

  CXXBasePath *BestPath = nullptr;
  for (auto &P : Paths) {
    if (!BestPath)
      BestPath = &P;
    else if (!S.Context.hasSameType(P.back().Base->getType(),
                                    BestPath->back().Base->getType())) {
      //   ... the same ...
      S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
        << false << RD << BestPath->back().Base->getType()
        << P.back().Base->getType();
      return nullptr;
    } else if (P.Access < BestPath->Access) {
      BestPath = &P;
    }
  }

  //   ... unambiguous ...
  QualType BaseType = BestPath->back().Base->getType();
  if (Paths.isAmbiguous(S.Context.getCanonicalType(BaseType))) {
    S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
      << RD << BaseType << S.getAmbiguousPathsDisplayString(Paths);
    return nullptr;
  }

  //   ... public base class of E.
  if (BestPath->Access != AS_public) {
    S.Diag(Loc, diag::err_decomp_decl_non_public_base)
      << RD << BaseType;
    for (auto &BS : *BestPath) {
      if (BS.Base->getAccessSpecifier() != AS_public) {
        S.Diag(BS.Base->getLocStart(), diag::note_access_constrained_by_path)
          << (BS.Base->getAccessSpecifier() == AS_protected)
          << (BS.Base->getAccessSpecifierAsWritten() == AS_none);
        break;
      }
    }
    return nullptr;
  }

  ClassWithFields = BaseType->getAsCXXRecordDecl();
  S.BuildBasePathArray(Paths, BasePath);
}

// The above search did not check whether the selected class itself has base
// classes with fields, so check that now.
CXXBasePaths Paths;
if (ClassWithFields->lookupInBases(BaseHasFields, Paths)) {
  S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
    << (ClassWithFields == RD) << RD << ClassWithFields
    << Paths.front().back().Base->getType();
  return nullptr;
}

return ClassWithFields;
1299}

1301static bool checkMemberDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
                                   ValueDecl *Src, QualType DecompType,
                                   const CXXRecordDecl *RD) {
CXXCastPath BasePath;
RD = findDecomposableBaseClass(S, Src->getLocation(), RD, BasePath);
if (!RD)
  return true;
QualType BaseType = S.Context.getQualifiedType(S.Context.getRecordType(RD),
                                               DecompType.getQualifiers());

auto DiagnoseBadNumberOfBindings = [&]() -> bool {
  unsigned NumFields =
      std::count_if(RD->field_begin(), RD->field_end(),
                    [](FieldDecl *FD) { return !FD->isUnnamedBitfield(); });
  assert(Bindings.size() != NumFields)(static_cast <bool> (Bindings.size() != NumFields) ? void
 (0) : __assert_fail ("Bindings.size() != NumFields", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1315, __extension__ __PRETTY_FUNCTION__));
  S.Diag(Src->getLocation(), diag::err_decomp_decl_wrong_number_bindings)
      << DecompType << (unsigned)Bindings.size() << NumFields
      << (NumFields < Bindings.size());
  return true;
};

//   all of E's non-static data members shall be public [...] members,
//   E shall not have an anonymous union member, ...
unsigned I = 0;
for (auto *FD : RD->fields()) {
  if (FD->isUnnamedBitfield())
    continue;

  if (FD->isAnonymousStructOrUnion()) {
    S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
      << DecompType << FD->getType()->isUnionType();
    S.Diag(FD->getLocation(), diag::note_declared_at);
    return true;
  }

  // We have a real field to bind.
  if (I >= Bindings.size())
    return DiagnoseBadNumberOfBindings();
  auto *B = Bindings[I++];

  SourceLocation Loc = B->getLocation();
  if (FD->getAccess() != AS_public) {
    S.Diag(Loc, diag::err_decomp_decl_non_public_member) << FD << DecompType;

    // Determine whether the access specifier was explicit.
    bool Implicit = true;
    for (const auto *D : RD->decls()) {
      if (declaresSameEntity(D, FD))
        break;
      if (isa<AccessSpecDecl>(D)) {
        Implicit = false;
        break;
      }
    }

    S.Diag(FD->getLocation(), diag::note_access_natural)
      << (FD->getAccess() == AS_protected) << Implicit;
    return true;
  }

  // Initialize the binding to Src.FD.
  ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
  if (E.isInvalid())
    return true;
  E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
                          VK_LValue, &BasePath);
  if (E.isInvalid())
    return true;
  E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
                                CXXScopeSpec(), FD,
                                DeclAccessPair::make(FD, FD->getAccess()),
                                DeclarationNameInfo(FD->getDeclName(), Loc));
  if (E.isInvalid())
    return true;

  // If the type of the member is T, the referenced type is cv T, where cv is
  // the cv-qualification of the decomposition expression.
  //
  // FIXME: We resolve a defect here: if the field is mutable, we do not add
  // 'const' to the type of the field.
  Qualifiers Q = DecompType.getQualifiers();
  if (FD->isMutable())
    Q.removeConst();
  B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
}

if (I != Bindings.size())
  return DiagnoseBadNumberOfBindings();

return false;
1391}

1393void Sema::CheckCompleteDecompositionDeclaration(DecompositionDecl *DD) {
QualType DecompType = DD->getType();

// If the type of the decomposition is dependent, then so is the type of
// each binding.
if (DecompType->isDependentType()) {
  for (auto *B : DD->bindings())
    B->setType(Context.DependentTy);
  return;
}

DecompType = DecompType.getNonReferenceType();
ArrayRef<BindingDecl*> Bindings = DD->bindings();

// C++1z [dcl.decomp]/2:
//   If E is an array type [...]
// As an extension, we also support decomposition of built-in complex and
// vector types.
if (auto *CAT = Context.getAsConstantArrayType(DecompType)) {
  if (checkArrayDecomposition(*this, Bindings, DD, DecompType, CAT))
    DD->setInvalidDecl();
  return;
}
if (auto *VT = DecompType->getAs<VectorType>()) {
  if (checkVectorDecomposition(*this, Bindings, DD, DecompType, VT))
    DD->setInvalidDecl();
  return;
}
if (auto *CT = DecompType->getAs<ComplexType>()) {
  if (checkComplexDecomposition(*this, Bindings, DD, DecompType, CT))
    DD->setInvalidDecl();
  return;
}

// C++1z [dcl.decomp]/3:
//   if the expression std::tuple_size<E>::value is a well-formed integral
//   constant expression, [...]
llvm::APSInt TupleSize(32);
switch (isTupleLike(*this, DD->getLocation(), DecompType, TupleSize)) {
case IsTupleLike::Error:
  DD->setInvalidDecl();
  return;

case IsTupleLike::TupleLike:
  if (checkTupleLikeDecomposition(*this, Bindings, DD, DecompType, TupleSize))
    DD->setInvalidDecl();
  return;

case IsTupleLike::NotTupleLike:
  break;
}

// C++1z [dcl.dcl]/8:
//   [E shall be of array or non-union class type]
CXXRecordDecl *RD = DecompType->getAsCXXRecordDecl();
if (!RD || RD->isUnion()) {
  Diag(DD->getLocation(), diag::err_decomp_decl_unbindable_type)
      << DD << !RD << DecompType;
  DD->setInvalidDecl();
  return;
}

// C++1z [dcl.decomp]/4:
//   all of E's non-static data members shall be [...] direct members of
//   E or of the same unambiguous public base class of E, ...
if (checkMemberDecomposition(*this, Bindings, DD, DecompType, RD))
  DD->setInvalidDecl();
1460}

1462/// \brief Merge the exception specifications of two variable declarations.
1463///
1464/// This is called when there's a redeclaration of a VarDecl. The function
1465/// checks if the redeclaration might have an exception specification and
1466/// validates compatibility and merges the specs if necessary.
1467void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) {
// Shortcut if exceptions are disabled.
if (!getLangOpts().CXXExceptions)
  return;

assert(Context.hasSameType(New->getType(), Old->getType()) &&(static_cast <bool> (Context.hasSameType(New->getType
(), Old->getType()) && "Should only be called if types are otherwise the same."
) ? void (0) : __assert_fail ("Context.hasSameType(New->getType(), Old->getType()) && \"Should only be called if types are otherwise the same.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1473, __extension__ __PRETTY_FUNCTION__))
       "Should only be called if types are otherwise the same.")(static_cast <bool> (Context.hasSameType(New->getType
(), Old->getType()) && "Should only be called if types are otherwise the same."
) ? void (0) : __assert_fail ("Context.hasSameType(New->getType(), Old->getType()) && \"Should only be called if types are otherwise the same.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1473, __extension__ __PRETTY_FUNCTION__));

QualType NewType = New->getType();
QualType OldType = Old->getType();

// We're only interested in pointers and references to functions, as well
// as pointers to member functions.
if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
  NewType = R->getPointeeType();
  OldType = OldType->getAs<ReferenceType>()->getPointeeType();
} else if (const PointerType *P = NewType->getAs<PointerType>()) {
  NewType = P->getPointeeType();
  OldType = OldType->getAs<PointerType>()->getPointeeType();
} else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
  NewType = M->getPointeeType();
  OldType = OldType->getAs<MemberPointerType>()->getPointeeType();
}

if (!NewType->isFunctionProtoType())
  return;

// There's lots of special cases for functions. For function pointers, system
// libraries are hopefully not as broken so that we don't need these
// workarounds.
if (CheckEquivalentExceptionSpec(
      OldType->getAs<FunctionProtoType>(), Old->getLocation(),
      NewType->getAs<FunctionProtoType>(), New->getLocation())) {
  New->setInvalidDecl();
}
1502}

1504/// CheckCXXDefaultArguments - Verify that the default arguments for a
1505/// function declaration are well-formed according to C++
1506/// [dcl.fct.default].
1507void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
unsigned NumParams = FD->getNumParams();
unsigned p;

// Find first parameter with a default argument
for (p = 0; p < NumParams; ++p) {
  ParmVarDecl *Param = FD->getParamDecl(p);
  if (Param->hasDefaultArg())
    break;
}

// C++11 [dcl.fct.default]p4:
//   In a given function declaration, each parameter subsequent to a parameter
//   with a default argument shall have a default argument supplied in this or
//   a previous declaration or shall be a function parameter pack. A default
//   argument shall not be redefined by a later declaration (not even to the
//   same value).
unsigned LastMissingDefaultArg = 0;
for (; p < NumParams; ++p) {
  ParmVarDecl *Param = FD->getParamDecl(p);
  if (!Param->hasDefaultArg() && !Param->isParameterPack()) {
    if (Param->isInvalidDecl())
      /* We already complained about this parameter. */;
    else if (Param->getIdentifier())
      Diag(Param->getLocation(),
           diag::err_param_default_argument_missing_name)
        << Param->getIdentifier();
    else
      Diag(Param->getLocation(),
           diag::err_param_default_argument_missing);

    LastMissingDefaultArg = p;
  }
}

if (LastMissingDefaultArg > 0) {
  // Some default arguments were missing. Clear out all of the
  // default arguments up to (and including) the last missing
  // default argument, so that we leave the function parameters
  // in a semantically valid state.
  for (p = 0; p <= LastMissingDefaultArg; ++p) {
    ParmVarDecl *Param = FD->getParamDecl(p);
    if (Param->hasDefaultArg()) {
      Param->setDefaultArg(nullptr);
    }
  }
}
1554}

1556// CheckConstexprParameterTypes - Check whether a function's parameter types
1557// are all literal types. If so, return true. If not, produce a suitable
1558// diagnostic and return false.
1559static bool CheckConstexprParameterTypes(Sema &SemaRef,
                                       const FunctionDecl *FD) {
unsigned ArgIndex = 0;
const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
                                            e = FT->param_type_end();
     i != e; ++i, ++ArgIndex) {
  const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
  SourceLocation ParamLoc = PD->getLocation();
  if (!(*i)->isDependentType() &&
      SemaRef.RequireLiteralType(ParamLoc, *i,
                                 diag::err_constexpr_non_literal_param,
                                 ArgIndex+1, PD->getSourceRange(),
                                 isa<CXXConstructorDecl>(FD)))
    return false;
}
return true;
1576}

1578/// \brief Get diagnostic %select index for tag kind for
1579/// record diagnostic message.
1580/// WARNING: Indexes apply to particular diagnostics only!
1581///
1582/// \returns diagnostic %select index.
1583static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) {
switch (Tag) {
case TTK_Struct: return 0;
case TTK_Interface: return 1;
case TTK_Class:  return 2;
default: llvm_unreachable("Invalid tag kind for record diagnostic!")::llvm::llvm_unreachable_internal("Invalid tag kind for record diagnostic!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1588);
}
1590}

1592// CheckConstexprFunctionDecl - Check whether a function declaration satisfies
1593// the requirements of a constexpr function definition or a constexpr
1594// constructor definition. If so, return true. If not, produce appropriate
1595// diagnostics and return false.
1596//
1597// This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
1598bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) {
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
if (MD && MD->isInstance()) {
  // C++11 [dcl.constexpr]p4:
  //  The definition of a constexpr constructor shall satisfy the following
  //  constraints:
  //  - the class shall not have any virtual base classes;
  const CXXRecordDecl *RD = MD->getParent();
  if (RD->getNumVBases()) {
    Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
      << isa<CXXConstructorDecl>(NewFD)
      << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases();
    for (const auto &I : RD->vbases())
      Diag(I.getLocStart(),
           diag::note_constexpr_virtual_base_here) << I.getSourceRange();
    return false;
  }
}

if (!isa<CXXConstructorDecl>(NewFD)) {
  // C++11 [dcl.constexpr]p3:
  //  The definition of a constexpr function shall satisfy the following
  //  constraints:
  // - it shall not be virtual;
  const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
  if (Method && Method->isVirtual()) {
    Method = Method->getCanonicalDecl();
    Diag(Method->getLocation(), diag::err_constexpr_virtual);

    // If it's not obvious why this function is virtual, find an overridden
    // function which uses the 'virtual' keyword.
    const CXXMethodDecl *WrittenVirtual = Method;
    while (!WrittenVirtual->isVirtualAsWritten())
      WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
    if (WrittenVirtual != Method)
      Diag(WrittenVirtual->getLocation(),
           diag::note_overridden_virtual_function);
    return false;
  }

  // - its return type shall be a literal type;
  QualType RT = NewFD->getReturnType();
  if (!RT->isDependentType() &&
      RequireLiteralType(NewFD->getLocation(), RT,
                         diag::err_constexpr_non_literal_return))
    return false;
}

// - each of its parameter types shall be a literal type;
if (!CheckConstexprParameterTypes(*this, NewFD))
  return false;

return true;
1651}

1653/// Check the given declaration statement is legal within a constexpr function
1654/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
1655///
1656/// \return true if the body is OK (maybe only as an extension), false if we
1657///         have diagnosed a problem.
1658static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
                                 DeclStmt *DS, SourceLocation &Cxx1yLoc) {
// C++11 [dcl.constexpr]p3 and p4:
//  The definition of a constexpr function(p3) or constructor(p4) [...] shall
//  contain only
for (const auto *DclIt : DS->decls()) {
  switch (DclIt->getKind()) {
  case Decl::StaticAssert:
  case Decl::Using:
  case Decl::UsingShadow:
  case Decl::UsingDirective:
  case Decl::UnresolvedUsingTypename:
  case Decl::UnresolvedUsingValue:
    //   - static_assert-declarations
    //   - using-declarations,
    //   - using-directives,
    continue;

  case Decl::Typedef:
  case Decl::TypeAlias: {
    //   - typedef declarations and alias-declarations that do not define
    //     classes or enumerations,
    const auto *TN = cast<TypedefNameDecl>(DclIt);
    if (TN->getUnderlyingType()->isVariablyModifiedType()) {
      // Don't allow variably-modified types in constexpr functions.
      TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
      SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
        << TL.getSourceRange() << TL.getType()
        << isa<CXXConstructorDecl>(Dcl);
      return false;
    }
    continue;
  }

  case Decl::Enum:
  case Decl::CXXRecord:
    // C++1y allows types to be defined, not just declared.
    if (cast<TagDecl>(DclIt)->isThisDeclarationADefinition())
      SemaRef.Diag(DS->getLocStart(),
                   SemaRef.getLangOpts().CPlusPlus14
                     ? diag::warn_cxx11_compat_constexpr_type_definition
                     : diag::ext_constexpr_type_definition)
        << isa<CXXConstructorDecl>(Dcl);
    continue;

  case Decl::EnumConstant:
  case Decl::IndirectField:
  case Decl::ParmVar:
    // These can only appear with other declarations which are banned in
    // C++11 and permitted in C++1y, so ignore them.
    continue;

  case Decl::Var:
  case Decl::Decomposition: {
    // C++1y [dcl.constexpr]p3 allows anything except:
    //   a definition of a variable of non-literal type or of static or
    //   thread storage duration or for which no initialization is performed.
    const auto *VD = cast<VarDecl>(DclIt);
    if (VD->isThisDeclarationADefinition()) {
      if (VD->isStaticLocal()) {
        SemaRef.Diag(VD->getLocation(),
                     diag::err_constexpr_local_var_static)
          << isa<CXXConstructorDecl>(Dcl)
          << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
        return false;
      }
      if (!VD->getType()->isDependentType() &&
          SemaRef.RequireLiteralType(
            VD->getLocation(), VD->getType(),
            diag::err_constexpr_local_var_non_literal_type,
            isa<CXXConstructorDecl>(Dcl)))
        return false;
      if (!VD->getType()->isDependentType() &&
          !VD->hasInit() && !VD->isCXXForRangeDecl()) {
        SemaRef.Diag(VD->getLocation(),
                     diag::err_constexpr_local_var_no_init)
          << isa<CXXConstructorDecl>(Dcl);
        return false;
      }
    }
    SemaRef.Diag(VD->getLocation(),
                 SemaRef.getLangOpts().CPlusPlus14
                  ? diag::warn_cxx11_compat_constexpr_local_var
                  : diag::ext_constexpr_local_var)
      << isa<CXXConstructorDecl>(Dcl);
    continue;
  }

  case Decl::NamespaceAlias:
  case Decl::Function:
    // These are disallowed in C++11 and permitted in C++1y. Allow them
    // everywhere as an extension.
    if (!Cxx1yLoc.isValid())
      Cxx1yLoc = DS->getLocStart();
    continue;

  default:
    SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt)
      << isa<CXXConstructorDecl>(Dcl);
    return false;
  }
}

return true;
1762}

1764/// Check that the given field is initialized within a constexpr constructor.
1765///
1766/// \param Dcl The constexpr constructor being checked.
1767/// \param Field The field being checked. This may be a member of an anonymous
1768///        struct or union nested within the class being checked.
1769/// \param Inits All declarations, including anonymous struct/union members and
1770///        indirect members, for which any initialization was provided.
1771/// \param Diagnosed Set to true if an error is produced.
1772static void CheckConstexprCtorInitializer(Sema &SemaRef,
                                        const FunctionDecl *Dcl,
                                        FieldDecl *Field,
                                        llvm::SmallSet<Decl*, 16> &Inits,
                                        bool &Diagnosed) {
if (Field->isInvalidDecl())
  return;

if (Field->isUnnamedBitfield())
  return;

// Anonymous unions with no variant members and empty anonymous structs do not
// need to be explicitly initialized. FIXME: Anonymous structs that contain no
// indirect fields don't need initializing.
if (Field->isAnonymousStructOrUnion() &&
    (Field->getType()->isUnionType()
         ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
         : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
  return;

if (!Inits.count(Field)) {
  if (!Diagnosed) {
    SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
    Diagnosed = true;
  }
  SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
} else if (Field->isAnonymousStructOrUnion()) {
  const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
  for (auto *I : RD->fields())
    // If an anonymous union contains an anonymous struct of which any member
    // is initialized, all members must be initialized.
    if (!RD->isUnion() || Inits.count(I))
      CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed);
}
1806}

1808/// Check the provided statement is allowed in a constexpr function
1809/// definition.
1810static bool
1811CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
                         SmallVectorImpl<SourceLocation> &ReturnStmts,
                         SourceLocation &Cxx1yLoc) {
// - its function-body shall be [...] a compound-statement that contains only
switch (S->getStmtClass()) {
case Stmt::NullStmtClass:
  //   - null statements,
  return true;

case Stmt::DeclStmtClass:
  //   - static_assert-declarations
  //   - using-declarations,
  //   - using-directives,
  //   - typedef declarations and alias-declarations that do not define
  //     classes or enumerations,
  if (!CheckConstexprDeclStmt(SemaRef, Dcl, cast<DeclStmt>(S), Cxx1yLoc))
    return false;
  return true;

case Stmt::ReturnStmtClass:
  //   - and exactly one return statement;
  if (isa<CXXConstructorDecl>(Dcl)) {
    // C++1y allows return statements in constexpr constructors.
    if (!Cxx1yLoc.isValid())
      Cxx1yLoc = S->getLocStart();
    return true;
  }

  ReturnStmts.push_back(S->getLocStart());
  return true;

case Stmt::CompoundStmtClass: {
  // C++1y allows compound-statements.
  if (!Cxx1yLoc.isValid())
    Cxx1yLoc = S->getLocStart();

  CompoundStmt *CompStmt = cast<CompoundStmt>(S);
  for (auto *BodyIt : CompStmt->body()) {
    if (!CheckConstexprFunctionStmt(SemaRef, Dcl, BodyIt, ReturnStmts,
                                    Cxx1yLoc))
      return false;
  }
  return true;
}

case Stmt::AttributedStmtClass:
  if (!Cxx1yLoc.isValid())
    Cxx1yLoc = S->getLocStart();
  return true;

case Stmt::IfStmtClass: {
  // C++1y allows if-statements.
  if (!Cxx1yLoc.isValid())
    Cxx1yLoc = S->getLocStart();

  IfStmt *If = cast<IfStmt>(S);
  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
                                  Cxx1yLoc))
    return false;
  if (If->getElse() &&
      !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
                                  Cxx1yLoc))
    return false;
  return true;
}

case Stmt::WhileStmtClass:
case Stmt::DoStmtClass:
case Stmt::ForStmtClass:
case Stmt::CXXForRangeStmtClass:
case Stmt::ContinueStmtClass:
  // C++1y allows all of these. We don't allow them as extensions in C++11,
  // because they don't make sense without variable mutation.
  if (!SemaRef.getLangOpts().CPlusPlus14)
    break;
  if (!Cxx1yLoc.isValid())
    Cxx1yLoc = S->getLocStart();
  for (Stmt *SubStmt : S->children())
    if (SubStmt &&
        !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
                                    Cxx1yLoc))
      return false;
  return true;

case Stmt::SwitchStmtClass:
case Stmt::CaseStmtClass:
case Stmt::DefaultStmtClass:
case Stmt::BreakStmtClass:
  // C++1y allows switch-statements, and since they don't need variable
  // mutation, we can reasonably allow them in C++11 as an extension.
  if (!Cxx1yLoc.isValid())
    Cxx1yLoc = S->getLocStart();
  for (Stmt *SubStmt : S->children())
    if (SubStmt &&
        !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
                                    Cxx1yLoc))
      return false;
  return true;

default:
  if (!isa<Expr>(S))
    break;

  // C++1y allows expression-statements.
  if (!Cxx1yLoc.isValid())
    Cxx1yLoc = S->getLocStart();
  return true;
}

SemaRef.Diag(S->getLocStart(), diag::err_constexpr_body_invalid_stmt)
  << isa<CXXConstructorDecl>(Dcl);
return false;
1923}

1925/// Check the body for the given constexpr function declaration only contains
1926/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
1927///
1928/// \return true if the body is OK, false if we have diagnosed a problem.
1929bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
if (isa<CXXTryStmt>(Body)) {
  // C++11 [dcl.constexpr]p3:
  //  The definition of a constexpr function shall satisfy the following
  //  constraints: [...]
  // - its function-body shall be = delete, = default, or a
  //   compound-statement
  //
  // C++11 [dcl.constexpr]p4:
  //  In the definition of a constexpr constructor, [...]
  // - its function-body shall not be a function-try-block;
  Diag(Body->getLocStart(), diag::err_constexpr_function_try_block)
    << isa<CXXConstructorDecl>(Dcl);
  return false;
}

SmallVector<SourceLocation, 4> ReturnStmts;

// - its function-body shall be [...] a compound-statement that contains only
//   [... list of cases ...]
CompoundStmt *CompBody = cast<CompoundStmt>(Body);
SourceLocation Cxx1yLoc;
for (auto *BodyIt : CompBody->body()) {
  if (!CheckConstexprFunctionStmt(*this, Dcl, BodyIt, ReturnStmts, Cxx1yLoc))
    return false;
}

if (Cxx1yLoc.isValid())
  Diag(Cxx1yLoc,
       getLangOpts().CPlusPlus14
         ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
         : diag::ext_constexpr_body_invalid_stmt)
    << isa<CXXConstructorDecl>(Dcl);

if (const CXXConstructorDecl *Constructor
      = dyn_cast<CXXConstructorDecl>(Dcl)) {
  const CXXRecordDecl *RD = Constructor->getParent();
  // DR1359:
  // - every non-variant non-static data member and base class sub-object
  //   shall be initialized;
  // DR1460:
  // - if the class is a union having variant members, exactly one of them
  //   shall be initialized;
  if (RD->isUnion()) {
    if (Constructor->getNumCtorInitializers() == 0 &&
        RD->hasVariantMembers()) {
      Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init);
      return false;
    }
  } else if (!Constructor->isDependentContext() &&
             !Constructor->isDelegatingConstructor()) {
    assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases")(static_cast <bool> (RD->getNumVBases() == 0 &&
 "constexpr ctor with virtual bases") ? void (0) : __assert_fail
 ("RD->getNumVBases() == 0 && \"constexpr ctor with virtual bases\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1980, __extension__ __PRETTY_FUNCTION__));

    // Skip detailed checking if we have enough initializers, and we would
    // allow at most one initializer per member.
    bool AnyAnonStructUnionMembers = false;
    unsigned Fields = 0;
    for (CXXRecordDecl::field_iterator I = RD->field_begin(),
         E = RD->field_end(); I != E; ++I, ++Fields) {
      if (I->isAnonymousStructOrUnion()) {
        AnyAnonStructUnionMembers = true;
        break;
      }
    }
    // DR1460:
    // - if the class is a union-like class, but is not a union, for each of
    //   its anonymous union members having variant members, exactly one of
    //   them shall be initialized;
    if (AnyAnonStructUnionMembers ||
        Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
      // Check initialization of non-static data members. Base classes are
      // always initialized so do not need to be checked. Dependent bases
      // might not have initializers in the member initializer list.
      llvm::SmallSet<Decl*, 16> Inits;
      for (const auto *I: Constructor->inits()) {
        if (FieldDecl *FD = I->getMember())
          Inits.insert(FD);
        else if (IndirectFieldDecl *ID = I->getIndirectMember())
          Inits.insert(ID->chain_begin(), ID->chain_end());
      }

      bool Diagnosed = false;
      for (auto *I : RD->fields())
        CheckConstexprCtorInitializer(*this, Dcl, I, Inits, Diagnosed);
      if (Diagnosed)
        return false;
    }
  }
} else {
  if (ReturnStmts.empty()) {
    // C++1y doesn't require constexpr functions to contain a 'return'
    // statement. We still do, unless the return type might be void, because
    // otherwise if there's no return statement, the function cannot
    // be used in a core constant expression.
    bool OK = getLangOpts().CPlusPlus14 &&
              (Dcl->getReturnType()->isVoidType() ||
               Dcl->getReturnType()->isDependentType());
    Diag(Dcl->getLocation(),
         OK ? diag::warn_cxx11_compat_constexpr_body_no_return
            : diag::err_constexpr_body_no_return);
    if (!OK)
      return false;
  } else if (ReturnStmts.size() > 1) {
    Diag(ReturnStmts.back(),
         getLangOpts().CPlusPlus14
           ? diag::warn_cxx11_compat_constexpr_body_multiple_return
           : diag::ext_constexpr_body_multiple_return);
    for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
      Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);
  }
}

// C++11 [dcl.constexpr]p5:
//   if no function argument values exist such that the function invocation
//   substitution would produce a constant expression, the program is
//   ill-formed; no diagnostic required.
// C++11 [dcl.constexpr]p3:
//   - every constructor call and implicit conversion used in initializing the
//     return value shall be one of those allowed in a constant expression.
// C++11 [dcl.constexpr]p4:
//   - every constructor involved in initializing non-static data members and
//     base class sub-objects shall be a constexpr constructor.
SmallVector<PartialDiagnosticAt, 8> Diags;
if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
  Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr)
    << isa<CXXConstructorDecl>(Dcl);
  for (size_t I = 0, N = Diags.size(); I != N; ++I)
    Diag(Diags[I].first, Diags[I].second);
  // Don't return false here: we allow this for compatibility in
  // system headers.
}

return true;
2062}

2064/// isCurrentClassName - Determine whether the identifier II is the
2065/// name of the class type currently being defined. In the case of
2066/// nested classes, this will only return true if II is the name of
2067/// the innermost class.
2068bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
                            const CXXScopeSpec *SS) {
assert(getLangOpts().CPlusPlus && "No class names in C!")(static_cast <bool> (getLangOpts().CPlusPlus &&
 "No class names in C!") ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"No class names in C!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2070, __extension__ __PRETTY_FUNCTION__));

CXXRecordDecl *CurDecl;
if (SS && SS->isSet() && !SS->isInvalid()) {
  DeclContext *DC = computeDeclContext(*SS, true);
  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
} else
  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);

if (CurDecl && CurDecl->getIdentifier())
  return &II == CurDecl->getIdentifier();
return false;
2082}

2084/// \brief Determine whether the identifier II is a typo for the name of
2085/// the class type currently being defined. If so, update it to the identifier
2086/// that should have been used.
2087bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) {
assert(getLangOpts().CPlusPlus && "No class names in C!")(static_cast <bool> (getLangOpts().CPlusPlus &&
 "No class names in C!") ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"No class names in C!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2088, __extension__ __PRETTY_FUNCTION__));

if (!getLangOpts().SpellChecking)
  return false;

CXXRecordDecl *CurDecl;
if (SS && SS->isSet() && !SS->isInvalid()) {
  DeclContext *DC = computeDeclContext(*SS, true);
  CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
} else
  CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);

if (CurDecl && CurDecl->getIdentifier() && II != CurDecl->getIdentifier() &&
    3 * II->getName().edit_distance(CurDecl->getIdentifier()->getName())
        < II->getLength()) {
  II = CurDecl->getIdentifier();
  return true;
}

return false;
2108}

2110/// \brief Determine whether the given class is a base class of the given
2111/// class, including looking at dependent bases.
2112static bool findCircularInheritance(const CXXRecordDecl *Class,
                                  const CXXRecordDecl *Current) {
SmallVector<const CXXRecordDecl*, 8> Queue;

Class = Class->getCanonicalDecl();
while (true) {
  for (const auto &I : Current->bases()) {
    CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
    if (!Base)
      continue;

    Base = Base->getDefinition();
    if (!Base)
      continue;

    if (Base->getCanonicalDecl() == Class)
      return true;

    Queue.push_back(Base);
  }

  if (Queue.empty())
    return false;

  Current = Queue.pop_back_val();
}

return false;
2140}

2142/// \brief Check the validity of a C++ base class specifier.
2143///
2144/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
2145/// and returns NULL otherwise.
2146CXXBaseSpecifier *
2147Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
                       SourceRange SpecifierRange,
                       bool Virtual, AccessSpecifier Access,
                       TypeSourceInfo *TInfo,
                       SourceLocation EllipsisLoc) {
QualType BaseType = TInfo->getType();

// C++ [class.union]p1:
//   A union shall not have base classes.
if (Class->isUnion()) {
  Diag(Class->getLocation(), diag::err_base_clause_on_union)
    << SpecifierRange;
  return nullptr;
}

if (EllipsisLoc.isValid() &&
    !TInfo->getType()->containsUnexpandedParameterPack()) {
  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
    << TInfo->getTypeLoc().getSourceRange();
  EllipsisLoc = SourceLocation();
}

SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();

if (BaseType->isDependentType()) {
  // Make sure that we don't have circular inheritance among our dependent
  // bases. For non-dependent bases, the check for completeness below handles
  // this.
  if (CXXRecordDecl *BaseDecl = BaseType->getAsCXXRecordDecl()) {
    if (BaseDecl->getCanonicalDecl() == Class->getCanonicalDecl() ||
        ((BaseDecl = BaseDecl->getDefinition()) &&
         findCircularInheritance(Class, BaseDecl))) {
      Diag(BaseLoc, diag::err_circular_inheritance)
        << BaseType << Context.getTypeDeclType(Class);

      if (BaseDecl->getCanonicalDecl() != Class->getCanonicalDecl())
        Diag(BaseDecl->getLocation(), diag::note_previous_decl)
          << BaseType;

      return nullptr;
    }
  }

  return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
                                        Class->getTagKind() == TTK_Class,
                                        Access, TInfo, EllipsisLoc);
}

// Base specifiers must be record types.
if (!BaseType->isRecordType()) {
  Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
  return nullptr;
}

// C++ [class.union]p1:
//   A union shall not be used as a base class.
if (BaseType->isUnionType()) {
  Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
  return nullptr;
}

// For the MS ABI, propagate DLL attributes to base class templates.
if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
  if (Attr *ClassAttr = getDLLAttr(Class)) {
    if (auto *BaseTemplate = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
            BaseType->getAsCXXRecordDecl())) {
      propagateDLLAttrToBaseClassTemplate(Class, ClassAttr, BaseTemplate,
                                          BaseLoc);
    }
  }
}

// C++ [class.derived]p2:
//   The class-name in a base-specifier shall not be an incompletely
//   defined class.
if (RequireCompleteType(BaseLoc, BaseType,
                        diag::err_incomplete_base_class, SpecifierRange)) {
  Class->setInvalidDecl();
  return nullptr;
}

// If the base class is polymorphic or isn't empty, the new one is/isn't, too.
RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
assert(BaseDecl && "Record type has no declaration")(static_cast <bool> (BaseDecl && "Record type has no declaration"
) ? void (0) : __assert_fail ("BaseDecl && \"Record type has no declaration\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2230, __extension__ __PRETTY_FUNCTION__));
BaseDecl = BaseDecl->getDefinition();
assert(BaseDecl && "Base type is not incomplete, but has no definition")(static_cast <bool> (BaseDecl && "Base type is not incomplete, but has no definition"
) ? void (0) : __assert_fail ("BaseDecl && \"Base type is not incomplete, but has no definition\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2232, __extension__ __PRETTY_FUNCTION__));
CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
assert(CXXBaseDecl && "Base type is not a C++ type")(static_cast <bool> (CXXBaseDecl && "Base type is not a C++ type"
) ? void (0) : __assert_fail ("CXXBaseDecl && \"Base type is not a C++ type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2234, __extension__ __PRETTY_FUNCTION__));

// A class which contains a flexible array member is not suitable for use as a
// base class:
//   - If the layout determines that a base comes before another base,
//     the flexible array member would index into the subsequent base.
//   - If the layout determines that base comes before the derived class,
//     the flexible array member would index into the derived class.
if (CXXBaseDecl->hasFlexibleArrayMember()) {
  Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
    << CXXBaseDecl->getDeclName();
  return nullptr;
}

// C++ [class]p3:
//   If a class is marked final and it appears as a base-type-specifier in
//   base-clause, the program is ill-formed.
if (FinalAttr *FA = CXXBaseDecl->getAttr<FinalAttr>()) {
  Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
    << CXXBaseDecl->getDeclName()
    << FA->isSpelledAsSealed();
  Diag(CXXBaseDecl->getLocation(), diag::note_entity_declared_at)
      << CXXBaseDecl->getDeclName() << FA->getRange();
  return nullptr;
}

if (BaseDecl->isInvalidDecl())
  Class->setInvalidDecl();

// Create the base specifier.
return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
                                      Class->getTagKind() == TTK_Class,
                                      Access, TInfo, EllipsisLoc);
2267}

2269/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
2270/// one entry in the base class list of a class specifier, for
2271/// example:
2272///    class foo : public bar, virtual private baz {
2273/// 'public bar' and 'virtual private baz' are each base-specifiers.
2274BaseResult
2275Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
                       ParsedAttributes &Attributes,
                       bool Virtual, AccessSpecifier Access,
                       ParsedType basetype, SourceLocation BaseLoc,
                       SourceLocation EllipsisLoc) {
if (!classdecl)
  return true;

AdjustDeclIfTemplate(classdecl);
CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
if (!Class)
  return true;

// We haven't yet attached the base specifiers.
Class->setIsParsingBaseSpecifiers();

// We do not support any C++11 attributes on base-specifiers yet.
// Diagnose any attributes we see.
if (!Attributes.empty()) {
  for (AttributeList *Attr = Attributes.getList(); Attr;
       Attr = Attr->getNext()) {
    if (Attr->isInvalid() ||
        Attr->getKind() == AttributeList::IgnoredAttribute)
      continue;
    Diag(Attr->getLoc(),
         Attr->getKind() == AttributeList::UnknownAttribute
           ? diag::warn_unknown_attribute_ignored
           : diag::err_base_specifier_attribute)
      << Attr->getName();
  }
}

TypeSourceInfo *TInfo = nullptr;
GetTypeFromParser(basetype, &TInfo);

if (EllipsisLoc.isInvalid() &&
    DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
                                    UPPC_BaseType))
  return true;

if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
                                                    Virtual, Access, TInfo,
                                                    EllipsisLoc))
  return BaseSpec;
else
  Class->setInvalidDecl();

return true;
2323}

2325/// Use small set to collect indirect bases.  As this is only used
2326/// locally, there's no need to abstract the small size parameter.
2327typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet;

2329/// \brief Recursively add the bases of Type.  Don't add Type itself.
2330static void
2331NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set,
                const QualType &Type)
2333{
// Even though the incoming type is a base, it might not be
// a class -- it could be a template parm, for instance.
if (auto Rec = Type->getAs<RecordType>()) {
  auto Decl = Rec->getAsCXXRecordDecl();

  // Iterate over its bases.
  for (const auto &BaseSpec : Decl->bases()) {
    QualType Base = Context.getCanonicalType(BaseSpec.getType())
      .getUnqualifiedType();
    if (Set.insert(Base).second)
      // If we've not already seen it, recurse.
      NoteIndirectBases(Context, Set, Base);
  }
}
2348}

2350/// \brief Performs the actual work of attaching the given base class
2351/// specifiers to a C++ class.
2352bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class,
                              MutableArrayRef<CXXBaseSpecifier *> Bases) {
if (Bases.empty())
  return false;

// Used to keep track of which base types we have already seen, so
// that we can properly diagnose redundant direct base types. Note
// that the key is always the unqualified canonical type of the base
// class.
std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;

// Used to track indirect bases so we can see if a direct base is
// ambiguous.
IndirectBaseSet IndirectBaseTypes;

// Copy non-redundant base specifiers into permanent storage.
unsigned NumGoodBases = 0;
bool Invalid = false;
for (unsigned idx = 0; idx < Bases.size(); ++idx) {
  QualType NewBaseType
    = Context.getCanonicalType(Bases[idx]->getType());
  NewBaseType = NewBaseType.getLocalUnqualifiedType();

  CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
  if (KnownBase) {
    // C++ [class.mi]p3:
    //   A class shall not be specified as a direct base class of a
    //   derived class more than once.
    Diag(Bases[idx]->getLocStart(),
         diag::err_duplicate_base_class)
      << KnownBase->getType()
      << Bases[idx]->getSourceRange();

    // Delete the duplicate base class specifier; we're going to
    // overwrite its pointer later.
    Context.Deallocate(Bases[idx]);

    Invalid = true;
  } else {
    // Okay, add this new base class.
    KnownBase = Bases[idx];
    Bases[NumGoodBases++] = Bases[idx];

    // Note this base's direct & indirect bases, if there could be ambiguity.
    if (Bases.size() > 1)
      NoteIndirectBases(Context, IndirectBaseTypes, NewBaseType);

    if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
      const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
      if (Class->isInterface() &&
            (!RD->isInterfaceLike() ||
             KnownBase->getAccessSpecifier() != AS_public)) {
        // The Microsoft extension __interface does not permit bases that
        // are not themselves public interfaces.
        Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface)
          << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName()
          << RD->getSourceRange();
        Invalid = true;
      }
      if (RD->hasAttr<WeakAttr>())
        Class->addAttr(WeakAttr::CreateImplicit(Context));
    }
  }
}

// Attach the remaining base class specifiers to the derived class.
Class->setBases(Bases.data(), NumGoodBases);

// Check that the only base classes that are duplicate are virtual.
for (unsigned idx = 0; idx < NumGoodBases; ++idx) {
  // Check whether this direct base is inaccessible due to ambiguity.
  QualType BaseType = Bases[idx]->getType();

  // Skip all dependent types in templates being used as base specifiers.
  // Checks below assume that the base specifier is a CXXRecord.
  if (BaseType->isDependentType())
    continue;

  CanQualType CanonicalBase = Context.getCanonicalType(BaseType)
    .getUnqualifiedType();

  if (IndirectBaseTypes.count(CanonicalBase)) {
    CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
                       /*DetectVirtual=*/true);
    bool found
      = Class->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);
    assert(found)(static_cast <bool> (found) ? void (0) : __assert_fail (
"found", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2438, __extension__ __PRETTY_FUNCTION__));
    (void)found;

    if (Paths.isAmbiguous(CanonicalBase))
      Diag(Bases[idx]->getLocStart (), diag::warn_inaccessible_base_class)
        << BaseType << getAmbiguousPathsDisplayString(Paths)
        << Bases[idx]->getSourceRange();
    else
      assert(Bases[idx]->isVirtual())(static_cast <bool> (Bases[idx]->isVirtual()) ? void
 (0) : __assert_fail ("Bases[idx]->isVirtual()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2446, __extension__ __PRETTY_FUNCTION__));
  }

  // Delete the base class specifier, since its data has been copied
  // into the CXXRecordDecl.
  Context.Deallocate(Bases[idx]);
}

return Invalid;
2455}

2457/// ActOnBaseSpecifiers - Attach the given base specifiers to the
2458/// class, after checking whether there are any duplicate base
2459/// classes.
2460void Sema::ActOnBaseSpecifiers(Decl *ClassDecl,
                             MutableArrayRef<CXXBaseSpecifier *> Bases) {
if (!ClassDecl || Bases.empty())
  return;

AdjustDeclIfTemplate(ClassDecl);
AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases);
2467}

2469/// \brief Determine whether the type \p Derived is a C++ class that is
2470/// derived from the type \p Base.
2471bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
if (!getLangOpts().CPlusPlus)
  return false;

CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
if (!DerivedRD)
  return false;

CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
if (!BaseRD)
  return false;

// If either the base or the derived type is invalid, don't try to
// check whether one is derived from the other.
if (BaseRD->isInvalidDecl() || DerivedRD->isInvalidDecl())
  return false;

// FIXME: In a modules build, do we need the entire path to be visible for us
// to be able to use the inheritance relationship?
if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
  return false;

return DerivedRD->isDerivedFrom(BaseRD);
2494}

2496/// \brief Determine whether the type \p Derived is a C++ class that is
2497/// derived from the type \p Base.
2498bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
                       CXXBasePaths &Paths) {
if (!getLangOpts().CPlusPlus)
  return false;

CXXRecordDecl *DerivedRD = Derived->getAsCXXRecordDecl();
if (!DerivedRD)
  return false;

CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
if (!BaseRD)
  return false;

if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
  return false;

return DerivedRD->isDerivedFrom(BaseRD, Paths);
2515}

2517static void BuildBasePathArray(const CXXBasePath &Path,
                             CXXCastPath &BasePathArray) {
// We first go backward and check if we have a virtual base.
// FIXME: It would be better if CXXBasePath had the base specifier for
// the nearest virtual base.
unsigned Start = 0;
for (unsigned I = Path.size(); I != 0; --I) {
  if (Path[I - 1].Base->isVirtual()) {
    Start = I - 1;
    break;
  }
}

// Now add all bases.
for (unsigned I = Start, E = Path.size(); I != E; ++I)
  BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
2533}


2536void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
                            CXXCastPath &BasePathArray) {
assert(BasePathArray.empty() && "Base path array must be empty!")(static_cast <bool> (BasePathArray.empty() && "Base path array must be empty!"
) ? void (0) : __assert_fail ("BasePathArray.empty() && \"Base path array must be empty!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2538, __extension__ __PRETTY_FUNCTION__));
assert(Paths.isRecordingPaths() && "Must record paths!")(static_cast <bool> (Paths.isRecordingPaths() &&
 "Must record paths!") ? void (0) : __assert_fail ("Paths.isRecordingPaths() && \"Must record paths!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2539, __extension__ __PRETTY_FUNCTION__));
return ::BuildBasePathArray(Paths.front(), BasePathArray);
2541}
2542/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
2543/// conversion (where Derived and Base are class types) is
2544/// well-formed, meaning that the conversion is unambiguous (and
2545/// that all of the base classes are accessible). Returns true
2546/// and emits a diagnostic if the code is ill-formed, returns false
2547/// otherwise. Loc is the location where this routine should point to
2548/// if there is an error, and Range is the source range to highlight
2549/// if there is an error.
2550///
2551/// If either InaccessibleBaseID or AmbigiousBaseConvID are 0, then the
2552/// diagnostic for the respective type of error will be suppressed, but the
2553/// check for ill-formed code will still be performed.
2554bool
2555Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
                                 unsigned InaccessibleBaseID,
                                 unsigned AmbigiousBaseConvID,
                                 SourceLocation Loc, SourceRange Range,
                                 DeclarationName Name,
                                 CXXCastPath *BasePath,
                                 bool IgnoreAccess) {
// First, determine whether the path from Derived to Base is
// ambiguous. This is slightly more expensive than checking whether
// the Derived to Base conversion exists, because here we need to
// explore multiple paths to determine if there is an ambiguity.
CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
                   /*DetectVirtual=*/false);
bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
if (!DerivationOkay)
  return true;

const CXXBasePath *Path = nullptr;
if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
  Path = &Paths.front();

// For MSVC compatibility, check if Derived directly inherits from Base. Clang
// warns about this hierarchy under -Winaccessible-base, but MSVC allows the
// user to access such bases.
if (!Path && getLangOpts().MSVCCompat) {
  for (const CXXBasePath &PossiblePath : Paths) {
    if (PossiblePath.size() == 1) {
      Path = &PossiblePath;
      if (AmbigiousBaseConvID)
        Diag(Loc, diag::ext_ms_ambiguous_direct_base)
            << Base << Derived << Range;
      break;
    }
  }
}

if (Path) {
  if (!IgnoreAccess) {
    // Check that the base class can be accessed.
    switch (
        CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
    case AR_inaccessible:
      return true;
    case AR_accessible:
    case AR_dependent:
    case AR_delayed:
      break;
    }
  }

  // Build a base path if necessary.
  if (BasePath)
    ::BuildBasePathArray(*Path, *BasePath);
  return false;
}

if (AmbigiousBaseConvID) {
  // We know that the derived-to-base conversion is ambiguous, and
  // we're going to produce a diagnostic. Perform the derived-to-base
  // search just one more time to compute all of the possible paths so
  // that we can print them out. This is more expensive than any of
  // the previous derived-to-base checks we've done, but at this point
  // performance isn't as much of an issue.
  Paths.clear();
  Paths.setRecordingPaths(true);
  bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
  assert(StillOkay && "Can only be used with a derived-to-base conversion")(static_cast <bool> (StillOkay && "Can only be used with a derived-to-base conversion"
) ? void (0) : __assert_fail ("StillOkay && \"Can only be used with a derived-to-base conversion\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2621, __extension__ __PRETTY_FUNCTION__));
  (void)StillOkay;

  // Build up a textual representation of the ambiguous paths, e.g.,
  // D -> B -> A, that will be used to illustrate the ambiguous
  // conversions in the diagnostic. We only print one of the paths
  // to each base class subobject.
  std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);

  Diag(Loc, AmbigiousBaseConvID)
  << Derived << Base << PathDisplayStr << Range << Name;
}
return true;
2634}

2636bool
2637Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
                                 SourceLocation Loc, SourceRange Range,
                                 CXXCastPath *BasePath,
                                 bool IgnoreAccess) {
return CheckDerivedToBaseConversion(
    Derived, Base, diag::err_upcast_to_inaccessible_base,
    diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
    BasePath, IgnoreAccess);
2645}


2648/// @brief Builds a string representing ambiguous paths from a
2649/// specific derived class to different subobjects of the same base
2650/// class.
2651///
2652/// This function builds a string that can be used in error messages
2653/// to show the different paths that one can take through the
2654/// inheritance hierarchy to go from the derived class to different
2655/// subobjects of a base class. The result looks something like this:
2656/// @code
2657/// struct D -> struct B -> struct A
2658/// struct D -> struct C -> struct A
2659/// @endcode
2660std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
std::string PathDisplayStr;
std::set<unsigned> DisplayedPaths;
for (CXXBasePaths::paths_iterator Path = Paths.begin();
     Path != Paths.end(); ++Path) {
  if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
    // We haven't displayed a path to this particular base
    // class subobject yet.
    PathDisplayStr += "\n    ";
    PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
    for (CXXBasePath::const_iterator Element = Path->begin();
         Element != Path->end(); ++Element)
      PathDisplayStr += " -> " + Element->Base->getType().getAsString();
  }
}

return PathDisplayStr;
2677}

2679//===----------------------------------------------------------------------===//
2680// C++ class member Handling
2681//===----------------------------------------------------------------------===//

2683/// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
2684bool Sema::ActOnAccessSpecifier(AccessSpecifier Access,
                              SourceLocation ASLoc,
                              SourceLocation ColonLoc,
                              AttributeList *Attrs) {
assert(Access != AS_none && "Invalid kind for syntactic access specifier!")(static_cast <bool> (Access != AS_none && "Invalid kind for syntactic access specifier!"
) ? void (0) : __assert_fail ("Access != AS_none && \"Invalid kind for syntactic access specifier!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2688, __extension__ __PRETTY_FUNCTION__));
AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
                                                ASLoc, ColonLoc);
CurContext->addHiddenDecl(ASDecl);
return ProcessAccessDeclAttributeList(ASDecl, Attrs);
2693}

2695/// CheckOverrideControl - Check C++11 override control semantics.
2696void Sema::CheckOverrideControl(NamedDecl *D) {
if (D->isInvalidDecl())
  return;

// We only care about "override" and "final" declarations.
if (!D->hasAttr<OverrideAttr>() && !D->hasAttr<FinalAttr>())
  return;

CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);

// We can't check dependent instance methods.
if (MD && MD->isInstance() &&
    (MD->getParent()->hasAnyDependentBases() ||
     MD->getType()->isDependentType()))
  return;

if (MD && !MD->isVirtual()) {
  // If we have a non-virtual method, check if if hides a virtual method.
  // (In that case, it's most likely the method has the wrong type.)
  SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
  FindHiddenVirtualMethods(MD, OverloadedMethods);

  if (!OverloadedMethods.empty()) {
    if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
      Diag(OA->getLocation(),
           diag::override_keyword_hides_virtual_member_function)
        << "override" << (OverloadedMethods.size() > 1);
    } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
      Diag(FA->getLocation(),
           diag::override_keyword_hides_virtual_member_function)
        << (FA->isSpelledAsSealed() ? "sealed" : "final")
        << (OverloadedMethods.size() > 1);
    }
    NoteHiddenVirtualMethods(MD, OverloadedMethods);
    MD->setInvalidDecl();
    return;
  }
  // Fall through into the general case diagnostic.
  // FIXME: We might want to attempt typo correction here.
}

if (!MD || !MD->isVirtual()) {
  if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
    Diag(OA->getLocation(),
         diag::override_keyword_only_allowed_on_virtual_member_functions)
      << "override" << FixItHint::CreateRemoval(OA->getLocation());
    D->dropAttr<OverrideAttr>();
  }
  if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
    Diag(FA->getLocation(),
         diag::override_keyword_only_allowed_on_virtual_member_functions)
      << (FA->isSpelledAsSealed() ? "sealed" : "final")
      << FixItHint::CreateRemoval(FA->getLocation());
    D->dropAttr<FinalAttr>();
  }
  return;
}

// C++11 [class.virtual]p5:
//   If a function is marked with the virt-specifier override and
//   does not override a member function of a base class, the program is
//   ill-formed.
bool HasOverriddenMethods = MD->size_overridden_methods() != 0;
if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
  Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
    << MD->getDeclName();
2762}

2764void Sema::DiagnoseAbsenceOfOverrideControl(NamedDecl *D) {
if (D->isInvalidDecl() || D->hasAttr<OverrideAttr>())
  return;
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
if (!MD || MD->isImplicit() || MD->hasAttr<FinalAttr>())
  return;

SourceLocation Loc = MD->getLocation();
SourceLocation SpellingLoc = Loc;
if (getSourceManager().isMacroArgExpansion(Loc))
  SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).first;
SpellingLoc = getSourceManager().getSpellingLoc(SpellingLoc);
if (SpellingLoc.isValid() && getSourceManager().isInSystemHeader(SpellingLoc))
    return;

if (MD->size_overridden_methods() > 0) {
  unsigned DiagID = isa<CXXDestructorDecl>(MD)
                        ? diag::warn_destructor_marked_not_override_overriding
                        : diag::warn_function_marked_not_override_overriding;
  Diag(MD->getLocation(), DiagID) << MD->getDeclName();
  const CXXMethodDecl *OMD = *MD->begin_overridden_methods();
  Diag(OMD->getLocation(), diag::note_overridden_virtual_function);
}
2787}

2789/// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
2790/// function overrides a virtual member function marked 'final', according to
2791/// C++11 [class.virtual]p4.
2792bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
                                                const CXXMethodDecl *Old) {
FinalAttr *FA = Old->getAttr<FinalAttr>();
if (!FA)
  return false;

Diag(New->getLocation(), diag::err_final_function_overridden)
  << New->getDeclName()
  << FA->isSpelledAsSealed();
Diag(Old->getLocation(), diag::note_overridden_virtual_function);
return true;
2803}

2805static bool InitializationHasSideEffects(const FieldDecl &FD) {
const Type *T = FD.getType()->getBaseElementTypeUnsafe();
// FIXME: Destruction of ObjC lifetime types has side-effects.
if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
  return !RD->isCompleteDefinition() ||
         !RD->hasTrivialDefaultConstructor() ||
         !RD->hasTrivialDestructor();
return false;
2813}

2815static AttributeList *getMSPropertyAttr(AttributeList *list) {
for (AttributeList *it = list; it != nullptr; it = it->getNext())
  if (it->isDeclspecPropertyAttribute())
    return it;
return nullptr;
2820}

2822// Check if there is a field shadowing.
2823void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
                                    DeclarationName FieldName,
                                    const CXXRecordDecl *RD) {
if (Diags.isIgnored(diag::warn_shadow_field, Loc))
  return;

// To record a shadowed field in a base
std::map<CXXRecordDecl*, NamedDecl*> Bases;
auto FieldShadowed = [&](const CXXBaseSpecifier *Specifier,
                         CXXBasePath &Path) {
  const auto Base = Specifier->getType()->getAsCXXRecordDecl();
  // Record an ambiguous path directly
  if (Bases.find(Base) != Bases.end())
    return true;
  for (const auto Field : Base->lookup(FieldName)) {
    if ((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&
        Field->getAccess() != AS_private) {
      assert(Field->getAccess() != AS_none)(static_cast <bool> (Field->getAccess() != AS_none) ?
 void (0) : __assert_fail ("Field->getAccess() != AS_none"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2840, __extension__ __PRETTY_FUNCTION__));
      assert(Bases.find(Base) == Bases.end())(static_cast <bool> (Bases.find(Base) == Bases.end()) ?
 void (0) : __assert_fail ("Bases.find(Base) == Bases.end()",
 "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2841, __extension__ __PRETTY_FUNCTION__));
      Bases[Base] = Field;
      return true;
    }
  }
  return false;
};

CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
                   /*DetectVirtual=*/true);
if (!RD->lookupInBases(FieldShadowed, Paths))
  return;

for (const auto &P : Paths) {
  auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
  auto It = Bases.find(Base);
  // Skip duplicated bases
  if (It == Bases.end())
    continue;
  auto BaseField = It->second;
  assert(BaseField->getAccess() != AS_private)(static_cast <bool> (BaseField->getAccess() != AS_private
) ? void (0) : __assert_fail ("BaseField->getAccess() != AS_private"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2861, __extension__ __PRETTY_FUNCTION__));
  if (AS_none !=
      CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
    Diag(Loc, diag::warn_shadow_field)
      << FieldName.getAsString() << RD->getName() << Base->getName();
    Diag(BaseField->getLocation(), diag::note_shadow_field);
    Bases.erase(It);
  }
}
2870}

2872/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
2873/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
2874/// bitfield width if there is one, 'InitExpr' specifies the initializer if
2875/// one has been parsed, and 'InitStyle' is set if an in-class initializer is
2876/// present (but parsing it has been deferred).
2877NamedDecl *
2878Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
                             MultiTemplateParamsArg TemplateParameterLists,
                             Expr *BW, const VirtSpecifiers &VS,
                             InClassInitStyle InitStyle) {
const DeclSpec &DS = D.getDeclSpec();
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
SourceLocation Loc = NameInfo.getLoc();

// For anonymous bitfields, the location should point to the type.
if (Loc.isInvalid())
  Loc = D.getLocStart();

Expr *BitWidth = static_cast<Expr*>(BW);

assert(isa<CXXRecordDecl>(CurContext))(static_cast <bool> (isa<CXXRecordDecl>(CurContext
)) ? void (0) : __assert_fail ("isa<CXXRecordDecl>(CurContext)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2893, __extension__ __PRETTY_FUNCTION__));
assert(!DS.isFriendSpecified())(static_cast <bool> (!DS.isFriendSpecified()) ? void (0
) : __assert_fail ("!DS.isFriendSpecified()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2894, __extension__ __PRETTY_FUNCTION__));

bool isFunc = D.isDeclarationOfFunction();
AttributeList *MSPropertyAttr =
    getMSPropertyAttr(D.getDeclSpec().getAttributes().getList());

if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
  // The Microsoft extension __interface only permits public member functions
  // and prohibits constructors, destructors, operators, non-public member
  // functions, static methods and data members.
  unsigned InvalidDecl;
  bool ShowDeclName = true;
  if (!isFunc &&
      (DS.getStorageClassSpec() == DeclSpec::SCS_typedef || MSPropertyAttr))
    InvalidDecl = 0;
  else if (!isFunc)
    InvalidDecl = 1;
  else if (AS != AS_public)
    InvalidDecl = 2;
  else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
    InvalidDecl = 3;
  else switch (Name.getNameKind()) {
    case DeclarationName::CXXConstructorName:
      InvalidDecl = 4;
      ShowDeclName = false;
      break;

    case DeclarationName::CXXDestructorName:
      InvalidDecl = 5;
      ShowDeclName = false;
      break;

    case DeclarationName::CXXOperatorName:
    case DeclarationName::CXXConversionFunctionName:
      InvalidDecl = 6;
      break;

    default:
      InvalidDecl = 0;
      break;
  }

  if (InvalidDecl) {
    if (ShowDeclName)
      Diag(Loc, diag::err_invalid_member_in_interface)
        << (InvalidDecl-1) << Name;
    else
      Diag(Loc, diag::err_invalid_member_in_interface)
        << (InvalidDecl-1) << "";
    return nullptr;
  }
}

// C++ 9.2p6: A member shall not be declared to have automatic storage
// duration (auto, register) or with the extern storage-class-specifier.
// C++ 7.1.1p8: The mutable specifier can be applied only to names of class
// data members and cannot be applied to names declared const or static,
// and cannot be applied to reference members.
switch (DS.getStorageClassSpec()) {
case DeclSpec::SCS_unspecified:
case DeclSpec::SCS_typedef:
case DeclSpec::SCS_static:
  break;
case DeclSpec::SCS_mutable:
  if (isFunc) {
    Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);

    // FIXME: It would be nicer if the keyword was ignored only for this
    // declarator. Otherwise we could get follow-up errors.
    D.getMutableDeclSpec().ClearStorageClassSpecs();
  }
  break;
default:
  Diag(DS.getStorageClassSpecLoc(),
       diag::err_storageclass_invalid_for_member);
  D.getMutableDeclSpec().ClearStorageClassSpecs();
  break;
}

bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
                     DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
                    !isFunc);

if (DS.isConstexprSpecified() && isInstField) {
  SemaDiagnosticBuilder B =
      Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr_member);
  SourceLocation ConstexprLoc = DS.getConstexprSpecLoc();
  if (InitStyle == ICIS_NoInit) {
    B << 0 << 0;
    if (D.getDeclSpec().getTypeQualifiers() & DeclSpec::TQ_const)
      B << FixItHint::CreateRemoval(ConstexprLoc);
    else {
      B << FixItHint::CreateReplacement(ConstexprLoc, "const");
      D.getMutableDeclSpec().ClearConstexprSpec();
      const char *PrevSpec;
      unsigned DiagID;
      bool Failed = D.getMutableDeclSpec().SetTypeQual(
          DeclSpec::TQ_const, ConstexprLoc, PrevSpec, DiagID, getLangOpts());
      (void)Failed;
      assert(!Failed && "Making a constexpr member const shouldn't fail")(static_cast <bool> (!Failed && "Making a constexpr member const shouldn't fail"
) ? void (0) : __assert_fail ("!Failed && \"Making a constexpr member const shouldn't fail\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2993, __extension__ __PRETTY_FUNCTION__));
    }
  } else {
    B << 1;
    const char *PrevSpec;
    unsigned DiagID;
    if (D.getMutableDeclSpec().SetStorageClassSpec(
        *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
        Context.getPrintingPolicy())) {
      assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&(static_cast <bool> (DS.getStorageClassSpec() == DeclSpec
::SCS_mutable && "This is the only DeclSpec that should fail to be applied"
) ? void (0) : __assert_fail ("DS.getStorageClassSpec() == DeclSpec::SCS_mutable && \"This is the only DeclSpec that should fail to be applied\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3003, __extension__ __PRETTY_FUNCTION__))
             "This is the only DeclSpec that should fail to be applied")(static_cast <bool> (DS.getStorageClassSpec() == DeclSpec
::SCS_mutable && "This is the only DeclSpec that should fail to be applied"
) ? void (0) : __assert_fail ("DS.getStorageClassSpec() == DeclSpec::SCS_mutable && \"This is the only DeclSpec that should fail to be applied\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3003, __extension__ __PRETTY_FUNCTION__));
      B << 1;
    } else {
      B << 0 << FixItHint::CreateInsertion(ConstexprLoc, "static ");
      isInstField = false;
    }
  }
}

NamedDecl *Member;
if (isInstField) {
  CXXScopeSpec &SS = D.getCXXScopeSpec();

  // Data members must have identifiers for names.
  if (!Name.isIdentifier()) {
    Diag(Loc, diag::err_bad_variable_name)
      << Name;
    return nullptr;
  }

  IdentifierInfo *II = Name.getAsIdentifierInfo();

  // Member field could not be with "template" keyword.
  // So TemplateParameterLists should be empty in this case.
  if (TemplateParameterLists.size()) {
    TemplateParameterList* TemplateParams = TemplateParameterLists[0];
    if (TemplateParams->size()) {
      // There is no such thing as a member field template.
      Diag(D.getIdentifierLoc(), diag::err_template_member)
          << II
          << SourceRange(TemplateParams->getTemplateLoc(),
              TemplateParams->getRAngleLoc());
    } else {
      // There is an extraneous 'template<>' for this member.
      Diag(TemplateParams->getTemplateLoc(),
          diag::err_template_member_noparams)
          << II
          << SourceRange(TemplateParams->getTemplateLoc(),
              TemplateParams->getRAngleLoc());
    }
    return nullptr;
  }

  if (SS.isSet() && !SS.isInvalid()) {
    // The user provided a superfluous scope specifier inside a class
    // definition:
    //
    // class X {
    //   int X::member;
    // };
    if (DeclContext *DC = computeDeclContext(SS, false))
      diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc());
    else
      Diag(D.getIdentifierLoc(), diag::err_member_qualification)
        << Name << SS.getRange();

    SS.clear();
  }

  if (MSPropertyAttr) {
    Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
                              BitWidth, InitStyle, AS, MSPropertyAttr);
    if (!Member)
      return nullptr;
    isInstField = false;
  } else {
    Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
                              BitWidth, InitStyle, AS);
    if (!Member)
      return nullptr;
  }

  CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
} else {
  Member = HandleDeclarator(S, D, TemplateParameterLists);
  if (!Member)
    return nullptr;

  // Non-instance-fields can't have a bitfield.
  if (BitWidth) {
    if (Member->isInvalidDecl()) {
      // don't emit another diagnostic.
    } else if (isa<VarDecl>(Member) || isa<VarTemplateDecl>(Member)) {
      // C++ 9.6p3: A bit-field shall not be a static member.
      // "static member 'A' cannot be a bit-field"
      Diag(Loc, diag::err_static_not_bitfield)
        << Name << BitWidth->getSourceRange();
    } else if (isa<TypedefDecl>(Member)) {
      // "typedef member 'x' cannot be a bit-field"
      Diag(Loc, diag::err_typedef_not_bitfield)
        << Name << BitWidth->getSourceRange();
    } else {
      // A function typedef ("typedef int f(); f a;").
      // C++ 9.6p3: A bit-field shall have integral or enumeration type.
      Diag(Loc, diag::err_not_integral_type_bitfield)
        << Name << cast<ValueDecl>(Member)->getType()
        << BitWidth->getSourceRange();
    }

    BitWidth = nullptr;
    Member->setInvalidDecl();
  }

  Member->setAccess(AS);

  // If we have declared a member function template or static data member
  // template, set the access of the templated declaration as well.
  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
    FunTmpl->getTemplatedDecl()->setAccess(AS);
  else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
    VarTmpl->getTemplatedDecl()->setAccess(AS);
}

if (VS.isOverrideSpecified())
  Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context, 0));
if (VS.isFinalSpecified())
  Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context,
                                          VS.isFinalSpelledSealed()));

if (VS.getLastLocation().isValid()) {
  // Update the end location of a method that has a virt-specifiers.
  if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
    MD->setRangeEnd(VS.getLastLocation());
}

CheckOverrideControl(Member);

assert((Name || isInstField) && "No identifier for non-field ?")(static_cast <bool> ((Name || isInstField) && "No identifier for non-field ?"
) ? void (0) : __assert_fail ("(Name || isInstField) && \"No identifier for non-field ?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3130, __extension__ __PRETTY_FUNCTION__));

if (isInstField) {
  FieldDecl *FD = cast<FieldDecl>(Member);
  FieldCollector->Add(FD);

  if (!Diags.isIgnored(diag::warn_unused_private_field, FD->getLocation())) {
    // Remember all explicit private FieldDecls that have a name, no side
    // effects and are not part of a dependent type declaration.
    if (!FD->isImplicit() && FD->getDeclName() &&
        FD->getAccess() == AS_private &&
        !FD->hasAttr<UnusedAttr>() &&
        !FD->getParent()->isDependentContext() &&
        !InitializationHasSideEffects(*FD))
      UnusedPrivateFields.insert(FD);
  }
}

return Member;
3149}

3151namespace {
class UninitializedFieldVisitor
    : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
  Sema &S;
  // List of Decls to generate a warning on.  Also remove Decls that become
  // initialized.
  llvm::SmallPtrSetImpl<ValueDecl*> &Decls;
  // List of base classes of the record.  Classes are removed after their
  // initializers.
  llvm::SmallPtrSetImpl<QualType> &BaseClasses;
  // Vector of decls to be removed from the Decl set prior to visiting the
  // nodes.  These Decls may have been initialized in the prior initializer.
  llvm::SmallVector<ValueDecl*, 4> DeclsToRemove;
  // If non-null, add a note to the warning pointing back to the constructor.
  const CXXConstructorDecl *Constructor;
  // Variables to hold state when processing an initializer list.  When
  // InitList is true, special case initialization of FieldDecls matching
  // InitListFieldDecl.
  bool InitList;
  FieldDecl *InitListFieldDecl;
  llvm::SmallVector<unsigned, 4> InitFieldIndex;

public:
  typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited;
  UninitializedFieldVisitor(Sema &S,
                            llvm::SmallPtrSetImpl<ValueDecl*> &Decls,
                            llvm::SmallPtrSetImpl<QualType> &BaseClasses)
    : Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),
      Constructor(nullptr), InitList(false), InitListFieldDecl(nullptr) {}

  // Returns true if the use of ME is not an uninitialized use.
  bool IsInitListMemberExprInitialized(MemberExpr *ME,
                                       bool CheckReferenceOnly) {
    llvm::SmallVector<FieldDecl*, 4> Fields;
    bool ReferenceField = false;
    while (ME) {
      FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
      if (!FD)
        return false;
      Fields.push_back(FD);
      if (FD->getType()->isReferenceType())
        ReferenceField = true;
      ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
    }

    // Binding a reference to an unintialized field is not an
    // uninitialized use.
    if (CheckReferenceOnly && !ReferenceField)
      return true;

    llvm::SmallVector<unsigned, 4> UsedFieldIndex;
    // Discard the first field since it is the field decl that is being
    // initialized.
    for (auto I = Fields.rbegin() + 1, E = Fields.rend(); I != E; ++I) {
      UsedFieldIndex.push_back((*I)->getFieldIndex());
    }

    for (auto UsedIter = UsedFieldIndex.begin(),
              UsedEnd = UsedFieldIndex.end(),
              OrigIter = InitFieldIndex.begin(),
              OrigEnd = InitFieldIndex.end();
         UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
      if (*UsedIter < *OrigIter)
        return true;
      if (*UsedIter > *OrigIter)
        break;
    }

    return false;
  }

  void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly,
                        bool AddressOf) {
    if (isa<EnumConstantDecl>(ME->getMemberDecl()))
      return;

    // FieldME is the inner-most MemberExpr that is not an anonymous struct
    // or union.
    MemberExpr *FieldME = ME;

    bool AllPODFields = FieldME->getType().isPODType(S.Context);

    Expr *Base = ME;
    while (MemberExpr *SubME =
               dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {

      if (isa<VarDecl>(SubME->getMemberDecl()))
        return;

      if (FieldDecl *FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))
        if (!FD->isAnonymousStructOrUnion())
          FieldME = SubME;

      if (!FieldME->getType().isPODType(S.Context))
        AllPODFields = false;

      Base = SubME->getBase();
    }

    if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts()))
      return;

    if (AddressOf && AllPODFields)
      return;

    ValueDecl* FoundVD = FieldME->getMemberDecl();

    if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
      while (isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {
        BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());
      }

      if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {
        QualType T = BaseCast->getType();
        if (T->isPointerType() &&
            BaseClasses.count(T->getPointeeType())) {
          S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit)
              << T->getPointeeType() << FoundVD;
        }
      }
    }

    if (!Decls.count(FoundVD))
      return;

    const bool IsReference = FoundVD->getType()->isReferenceType();

    if (InitList && !AddressOf && FoundVD == InitListFieldDecl) {
      // Special checking for initializer lists.
      if (IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {
        return;
      }
    } else {
      // Prevent double warnings on use of unbounded references.
      if (CheckReferenceOnly && !IsReference)
        return;
    }

    unsigned diag = IsReference
        ? diag::warn_reference_field_is_uninit
        : diag::warn_field_is_uninit;
    S.Diag(FieldME->getExprLoc(), diag) << FoundVD;
    if (Constructor)
      S.Diag(Constructor->getLocation(),
             diag::note_uninit_in_this_constructor)
        << (Constructor->isDefaultConstructor() && Constructor->isImplicit());

  }

  void HandleValue(Expr *E, bool AddressOf) {
    E = E->IgnoreParens();

    if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
      HandleMemberExpr(ME, false /*CheckReferenceOnly*/,
                       AddressOf /*AddressOf*/);
      return;
    }

    if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
      Visit(CO->getCond());
      HandleValue(CO->getTrueExpr(), AddressOf);
      HandleValue(CO->getFalseExpr(), AddressOf);
      return;
    }

    if (BinaryConditionalOperator *BCO =
            dyn_cast<BinaryConditionalOperator>(E)) {
      Visit(BCO->getCond());
      HandleValue(BCO->getFalseExpr(), AddressOf);
      return;
    }

    if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
      HandleValue(OVE->getSourceExpr(), AddressOf);
      return;
    }

    if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
      switch (BO->getOpcode()) {
      default:
        break;
      case(BO_PtrMemD):
      case(BO_PtrMemI):
        HandleValue(BO->getLHS(), AddressOf);
        Visit(BO->getRHS());
        return;
      case(BO_Comma):
        Visit(BO->getLHS());
        HandleValue(BO->getRHS(), AddressOf);
        return;
      }
    }

    Visit(E);
  }

  void CheckInitListExpr(InitListExpr *ILE) {
    InitFieldIndex.push_back(0);
    for (auto Child : ILE->children()) {
      if (InitListExpr *SubList = dyn_cast<InitListExpr>(Child)) {
        CheckInitListExpr(SubList);
      } else {
        Visit(Child);
      }
      ++InitFieldIndex.back();
    }
    InitFieldIndex.pop_back();
  }

  void CheckInitializer(Expr *E, const CXXConstructorDecl *FieldConstructor,
                        FieldDecl *Field, const Type *BaseClass) {
    // Remove Decls that may have been initialized in the previous
    // initializer.
    for (ValueDecl* VD : DeclsToRemove)
      Decls.erase(VD);
    DeclsToRemove.clear();

    Constructor = FieldConstructor;
    InitListExpr *ILE = dyn_cast<InitListExpr>(E);

    if (ILE && Field) {
      InitList = true;
      InitListFieldDecl = Field;
      InitFieldIndex.clear();
      CheckInitListExpr(ILE);
    } else {
      InitList = false;
      Visit(E);
    }

    if (Field)
      Decls.erase(Field);
    if (BaseClass)
      BaseClasses.erase(BaseClass->getCanonicalTypeInternal());
  }

  void VisitMemberExpr(MemberExpr *ME) {
    // All uses of unbounded reference fields will warn.
    HandleMemberExpr(ME, true /*CheckReferenceOnly*/, false /*AddressOf*/);
  }

  void VisitImplicitCastExpr(ImplicitCastExpr *E) {
    if (E->getCastKind() == CK_LValueToRValue) {
      HandleValue(E->getSubExpr(), false /*AddressOf*/);
      return;
    }

    Inherited::VisitImplicitCastExpr(E);
  }

  void VisitCXXConstructExpr(CXXConstructExpr *E) {
    if (E->getConstructor()->isCopyConstructor()) {
      Expr *ArgExpr = E->getArg(0);
      if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
        if (ILE->getNumInits() == 1)
          ArgExpr = ILE->getInit(0);
      if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
        if (ICE->getCastKind() == CK_NoOp)
          ArgExpr = ICE->getSubExpr();
      HandleValue(ArgExpr, false /*AddressOf*/);
      return;
    }
    Inherited::VisitCXXConstructExpr(E);
  }

  void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
    Expr *Callee = E->getCallee();
    if (isa<MemberExpr>(Callee)) {
      HandleValue(Callee, false /*AddressOf*/);
      for (auto Arg : E->arguments())
        Visit(Arg);
      return;
    }

    Inherited::VisitCXXMemberCallExpr(E);
  }

  void VisitCallExpr(CallExpr *E) {
    // Treat std::move as a use.
    if (E->isCallToStdMove()) {
      HandleValue(E->getArg(0), /*AddressOf=*/false);
      return;
    }

    Inherited::VisitCallExpr(E);
  }

  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
    Expr *Callee = E->getCallee();

    if (isa<UnresolvedLookupExpr>(Callee))
      return Inherited::VisitCXXOperatorCallExpr(E);

    Visit(Callee);
    for (auto Arg : E->arguments())
      HandleValue(Arg->IgnoreParenImpCasts(), false /*AddressOf*/);
  }

  void VisitBinaryOperator(BinaryOperator *E) {
    // If a field assignment is detected, remove the field from the
    // uninitiailized field set.
    if (E->getOpcode() == BO_Assign)
      if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getLHS()))
        if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
          if (!FD->getType()->isReferenceType())
            DeclsToRemove.push_back(FD);

    if (E->isCompoundAssignmentOp()) {
      HandleValue(E->getLHS(), false /*AddressOf*/);
      Visit(E->getRHS());
      return;
    }

    Inherited::VisitBinaryOperator(E);
  }

  void VisitUnaryOperator(UnaryOperator *E) {
    if (E->isIncrementDecrementOp()) {
      HandleValue(E->getSubExpr(), false /*AddressOf*/);
      return;
    }
    if (E->getOpcode() == UO_AddrOf) {
      if (MemberExpr *ME = dyn_cast<MemberExpr>(E->getSubExpr())) {
        HandleValue(ME->getBase(), true /*AddressOf*/);
        return;
      }
    }

    Inherited::VisitUnaryOperator(E);
  }
};

// Diagnose value-uses of fields to initialize themselves, e.g.
//   foo(foo)
// where foo is not also a parameter to the constructor.
// Also diagnose across field uninitialized use such as
//   x(y), y(x)
// TODO: implement -Wuninitialized and fold this into that framework.
static void DiagnoseUninitializedFields(
    Sema &SemaRef, const CXXConstructorDecl *Constructor) {

  if (SemaRef.getDiagnostics().isIgnored(diag::warn_field_is_uninit,
                                         Constructor->getLocation())) {
    return;
  }

  if (Constructor->isInvalidDecl())
    return;

  const CXXRecordDecl *RD = Constructor->getParent();

  if (RD->getDescribedClassTemplate())
    return;

  // Holds fields that are uninitialized.
  llvm::SmallPtrSet<ValueDecl*, 4> UninitializedFields;

  // At the beginning, all fields are uninitialized.
  for (auto *I : RD->decls()) {
    if (auto *FD = dyn_cast<FieldDecl>(I)) {
      UninitializedFields.insert(FD);
    } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(I)) {
      UninitializedFields.insert(IFD->getAnonField());
    }
  }

  llvm::SmallPtrSet<QualType, 4> UninitializedBaseClasses;
  for (auto I : RD->bases())
    UninitializedBaseClasses.insert(I.getType().getCanonicalType());

  if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
    return;

  UninitializedFieldVisitor UninitializedChecker(SemaRef,
                                                 UninitializedFields,
                                                 UninitializedBaseClasses);

  for (const auto *FieldInit : Constructor->inits()) {
    if (UninitializedFields.empty() && UninitializedBaseClasses.empty())
      break;

    Expr *InitExpr = FieldInit->getInit();
    if (!InitExpr)
      continue;

    if (CXXDefaultInitExpr *Default =
            dyn_cast<CXXDefaultInitExpr>(InitExpr)) {
      InitExpr = Default->getExpr();
      if (!InitExpr)
        continue;
      // In class initializers will point to the constructor.
      UninitializedChecker.CheckInitializer(InitExpr, Constructor,
                                            FieldInit->getAnyMember(),
                                            FieldInit->getBaseClass());
    } else {
      UninitializedChecker.CheckInitializer(InitExpr, nullptr,
                                            FieldInit->getAnyMember(),
                                            FieldInit->getBaseClass());
    }
  }
}
3552} // namespace

3554/// \brief Enter a new C++ default initializer scope. After calling this, the
3555/// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if
3556/// parsing or instantiating the initializer failed.
3557void Sema::ActOnStartCXXInClassMemberInitializer() {
// Create a synthetic function scope to represent the call to the constructor
// that notionally surrounds a use of this initializer.
PushFunctionScope();
3561}

3563/// \brief This is invoked after parsing an in-class initializer for a
3564/// non-static C++ class member, and after instantiating an in-class initializer
3565/// in a class template. Such actions are deferred until the class is complete.
3566void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D,
                                                SourceLocation InitLoc,
                                                Expr *InitExpr) {
// Pop the notional constructor scope we created earlier.
PopFunctionScopeInfo(nullptr, D);

FieldDecl *FD = dyn_cast<FieldDecl>(D);
assert((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) &&(static_cast <bool> ((isa<MSPropertyDecl>(D) || FD
->getInClassInitStyle() != ICIS_NoInit) && "must set init style when field is created"
) ? void (0) : __assert_fail ("(isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) && \"must set init style when field is created\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3574, __extension__ __PRETTY_FUNCTION__))
       "must set init style when field is created")(static_cast <bool> ((isa<MSPropertyDecl>(D) || FD
->getInClassInitStyle() != ICIS_NoInit) && "must set init style when field is created"
) ? void (0) : __assert_fail ("(isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) && \"must set init style when field is created\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3574, __extension__ __PRETTY_FUNCTION__));

if (!InitExpr) {
  D->setInvalidDecl();
  if (FD)
    FD->removeInClassInitializer();
  return;
}

if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
  FD->setInvalidDecl();
  FD->removeInClassInitializer();
  return;
}

ExprResult Init = InitExpr;
if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
  InitializedEntity Entity = InitializedEntity::InitializeMember(FD);
  InitializationKind Kind =
      FD->getInClassInitStyle() == ICIS_ListInit
          ? InitializationKind::CreateDirectList(InitExpr->getLocStart(),
                                                 InitExpr->getLocStart(),
                                                 InitExpr->getLocEnd())
          : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc);
  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
  Init = Seq.Perform(*this, Entity, Kind, InitExpr);
  if (Init.isInvalid()) {
    FD->setInvalidDecl();
    return;
  }
}

// C++11 [class.base.init]p7:
//   The initialization of each base and member constitutes a
//   full-expression.
Init = ActOnFinishFullExpr(Init.get(), InitLoc);
if (Init.isInvalid()) {
  FD->setInvalidDecl();
  return;
}

InitExpr = Init.get();

FD->setInClassInitializer(InitExpr);
3618}

3620/// \brief Find the direct and/or virtual base specifiers that
3621/// correspond to the given base type, for use in base initialization
3622/// within a constructor.
3623static bool FindBaseInitializer(Sema &SemaRef,
                              CXXRecordDecl *ClassDecl,
                              QualType BaseType,
                              const CXXBaseSpecifier *&DirectBaseSpec,
                              const CXXBaseSpecifier *&VirtualBaseSpec) {
// First, check for a direct base class.
DirectBaseSpec = nullptr;
for (const auto &Base : ClassDecl->bases()) {
28
←
Calling 'CXXRecordDecl::bases'→
204
←
Returning from 'CXXRecordDecl::bases'→
205
←
Assuming '__begin1' is not equal to '__end1'→
  if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
206
←
Calling 'CXXBaseSpecifier::getType'→
294
←
Returning from 'CXXBaseSpecifier::getType'→
295
←
Calling 'ASTContext::hasSameUnqualifiedType'→
533
←
Returning from 'ASTContext::hasSameUnqualifiedType'→
534
←
Taking false branch→
535
←
Calling 'CXXBaseSpecifier::getType'→
622
←
Returning from 'CXXBaseSpecifier::getType'→
623
←
Calling 'ASTContext::hasSameUnqualifiedType'→
861
←
Returning from 'ASTContext::hasSameUnqualifiedType'→
862
←
Taking true branch→
    // We found a direct base of this type. That's what we're
    // initializing.
    DirectBaseSpec = &Base;
    break;
863
←
 Execution continues on line 3642→
  }
}

// Check for a virtual base class.
// FIXME: We might be able to short-circuit this if we know in advance that
// there are no virtual bases.
VirtualBaseSpec = nullptr;
864
←
Null pointer value stored to 'VirtualBaseSpec'→
if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
865
←
Assuming the condition is false→
866
←
Calling 'CXXBaseSpecifier::isVirtual'→
867
←
Returning from 'CXXBaseSpecifier::isVirtual'→
868
←
Assuming the condition is false→
869
←
Taking false branch→
  // We haven't found a base yet; search the class hierarchy for a
  // virtual base class.
  CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
                     /*DetectVirtual=*/false);
  if (SemaRef.IsDerivedFrom(ClassDecl->getLocation(),
                            SemaRef.Context.getTypeDeclType(ClassDecl),
                            BaseType, Paths)) {
    for (CXXBasePaths::paths_iterator Path = Paths.begin();
         Path != Paths.end(); ++Path) {
      if (Path->back().Base->isVirtual()) {
        VirtualBaseSpec = Path->back().Base;
        break;
      }
    }
  }
}

return DirectBaseSpec || VirtualBaseSpec;
3662}

3664/// \brief Handle a C++ member initializer using braced-init-list syntax.
3665MemInitResult
3666Sema::ActOnMemInitializer(Decl *ConstructorD,
                        Scope *S,
                        CXXScopeSpec &SS,
                        IdentifierInfo *MemberOrBase,
                        ParsedType TemplateTypeTy,
                        const DeclSpec &DS,
                        SourceLocation IdLoc,
                        Expr *InitList,
                        SourceLocation EllipsisLoc) {
return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
                           DS, IdLoc, InitList,
                           EllipsisLoc);
3678}

3680/// \brief Handle a C++ member initializer using parentheses syntax.
3681MemInitResult
3682Sema::ActOnMemInitializer(Decl *ConstructorD,
                        Scope *S,
                        CXXScopeSpec &SS,
                        IdentifierInfo *MemberOrBase,
                        ParsedType TemplateTypeTy,
                        const DeclSpec &DS,
                        SourceLocation IdLoc,
                        SourceLocation LParenLoc,
                        ArrayRef<Expr *> Args,
                        SourceLocation RParenLoc,
                        SourceLocation EllipsisLoc) {
Expr *List = new (Context) ParenListExpr(Context, LParenLoc,
                                         Args, RParenLoc);
return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
1
Calling 'Sema::BuildMemInitializer'→
                           DS, IdLoc, List, EllipsisLoc);
3697}

3699namespace {

3701// Callback to only accept typo corrections that can be a valid C++ member
3702// intializer: either a non-static field member or a base class.
3703class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
3704public:
explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
    : ClassDecl(ClassDecl) {}

bool ValidateCandidate(const TypoCorrection &candidate) override {
  if (NamedDecl *ND = candidate.getCorrectionDecl()) {
    if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
      return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
    return isa<TypeDecl>(ND);
  }
  return false;
}

3717private:
CXXRecordDecl *ClassDecl;
3719};

3721}

3723/// \brief Handle a C++ member initializer.
3724MemInitResult
3725Sema::BuildMemInitializer(Decl *ConstructorD,
                        Scope *S,
                        CXXScopeSpec &SS,
                        IdentifierInfo *MemberOrBase,
                        ParsedType TemplateTypeTy,
                        const DeclSpec &DS,
                        SourceLocation IdLoc,
                        Expr *Init,
                        SourceLocation EllipsisLoc) {
ExprResult Res = CorrectDelayedTyposInExpr(Init);
if (!Res.isUsable())
2
←
Taking false branch→
  return true;
Init = Res.get();

if (!ConstructorD)
3
←
Assuming 'ConstructorD' is non-null→
4
←
Taking false branch→
  return true;

AdjustDeclIfTemplate(ConstructorD);

CXXConstructorDecl *Constructor
  = dyn_cast<CXXConstructorDecl>(ConstructorD);
if (!Constructor) {
5
←
Assuming 'Constructor' is non-null→
6
←
Taking false branch→
  // The user wrote a constructor initializer on a function that is
  // not a C++ constructor. Ignore the error for now, because we may
  // have more member initializers coming; we'll diagnose it just
  // once in ActOnMemInitializers.
  return true;
}

CXXRecordDecl *ClassDecl = Constructor->getParent();

// C++ [class.base.init]p2:
//   Names in a mem-initializer-id are looked up in the scope of the
//   constructor's class and, if not found in that scope, are looked
//   up in the scope containing the constructor's definition.
//   [Note: if the constructor's class contains a member with the
//   same name as a direct or virtual base class of the class, a
//   mem-initializer-id naming the member or base class and composed
//   of a single identifier refers to the class member. A
//   mem-initializer-id for the hidden base class may be specified
//   using a qualified name. ]
if (!SS.getScopeRep() && !TemplateTypeTy) {
7
←
Assuming the condition is false→
  // Look for a member, first.
  DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
  if (!Result.empty()) {
    ValueDecl *Member;
    if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
        (Member = dyn_cast<IndirectFieldDecl>(Result.front()))) {
      if (EllipsisLoc.isValid())
        Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
          << MemberOrBase
          << SourceRange(IdLoc, Init->getSourceRange().getEnd());

      return BuildMemberInitializer(Member, Init, IdLoc);
    }
  }
}
// It didn't name a member, so see if it names a class.
QualType BaseType;
TypeSourceInfo *TInfo = nullptr;

if (TemplateTypeTy) {
8
←
Taking false branch→
  BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
} else if (DS.getTypeSpecType() == TST_decltype) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
  BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
} else if (DS.getTypeSpecType() == TST_decltype_auto) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
  Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
  return true;
} else {
  LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
  LookupParsedName(R, S, &SS);

  TypeDecl *TyD = R.getAsSingle<TypeDecl>();
  if (!TyD) {
13
←
Assuming 'TyD' is non-null→
14
←
Taking false branch→
    if (R.isAmbiguous()) return true;

    // We don't want access-control diagnostics here.
    R.suppressDiagnostics();

    if (SS.isSet() && isDependentScopeSpecifier(SS)) {
      bool NotUnknownSpecialization = false;
      DeclContext *DC = computeDeclContext(SS, false);
      if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
        NotUnknownSpecialization = !Record->hasAnyDependentBases();

      if (!NotUnknownSpecialization) {
        // When the scope specifier can refer to a member of an unknown
        // specialization, we take it as a type name.
        BaseType = CheckTypenameType(ETK_None, SourceLocation(),
                                     SS.getWithLocInContext(Context),
                                     *MemberOrBase, IdLoc);
        if (BaseType.isNull())
          return true;

        TInfo = Context.CreateTypeSourceInfo(BaseType);
        DependentNameTypeLoc TL =
            TInfo->getTypeLoc().castAs<DependentNameTypeLoc>();
        if (!TL.isNull()) {
          TL.setNameLoc(IdLoc);
          TL.setElaboratedKeywordLoc(SourceLocation());
          TL.setQualifierLoc(SS.getWithLocInContext(Context));
        }

        R.clear();
        R.setLookupName(MemberOrBase);
      }
    }

    // If no results were found, try to correct typos.
    TypoCorrection Corr;
    if (R.empty() && BaseType.isNull() &&
        (Corr = CorrectTypo(
             R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
             llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
             CTK_ErrorRecovery, ClassDecl))) {
      if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
        // We have found a non-static data member with a similar
        // name to what was typed; complain and initialize that
        // member.
        diagnoseTypo(Corr,
                     PDiag(diag::err_mem_init_not_member_or_class_suggest)
                       << MemberOrBase << true);
        return BuildMemberInitializer(Member, Init, IdLoc);
      } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
        const CXXBaseSpecifier *DirectBaseSpec;
        const CXXBaseSpecifier *VirtualBaseSpec;
        if (FindBaseInitializer(*this, ClassDecl,
                                Context.getTypeDeclType(Type),
                                DirectBaseSpec, VirtualBaseSpec)) {
          // We have found a direct or virtual base class with a
          // similar name to what was typed; complain and initialize
          // that base class.
          diagnoseTypo(Corr,
                       PDiag(diag::err_mem_init_not_member_or_class_suggest)
                         << MemberOrBase << false,
                       PDiag() /*Suppress note, we provide our own.*/);

          const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
                                                            : VirtualBaseSpec;
          Diag(BaseSpec->getLocStart(),
               diag::note_base_class_specified_here)
            << BaseSpec->getType()
            << BaseSpec->getSourceRange();

          TyD = Type;
        }
      }
    }

    if (!TyD && BaseType.isNull()) {
      Diag(IdLoc, diag::err_mem_init_not_member_or_class)
        << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
      return true;
    }
  }

  if (BaseType.isNull()) {
15
←
Taking true branch→
    BaseType = Context.getTypeDeclType(TyD);
    MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
    if (SS.isSet()) {
16
←
Taking false branch→
      BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
                                           BaseType);
      TInfo = Context.CreateTypeSourceInfo(BaseType);
      ElaboratedTypeLoc TL = TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>();
      TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
      TL.setElaboratedKeywordLoc(SourceLocation());
      TL.setQualifierLoc(SS.getWithLocInContext(Context));
    }
  }
}

if (!TInfo)
17
←
Taking true branch→
  TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);

return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
18
←
Calling 'Sema::BuildBaseInitializer'→
3900}

3902/// Checks a member initializer expression for cases where reference (or
3903/// pointer) members are bound to by-value parameters (or their addresses).
3904static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member,
                                             Expr *Init,
                                             SourceLocation IdLoc) {
QualType MemberTy = Member->getType();

// We only handle pointers and references currently.
// FIXME: Would this be relevant for ObjC object pointers? Or block pointers?
if (!MemberTy->isReferenceType() && !MemberTy->isPointerType())
  return;

const bool IsPointer = MemberTy->isPointerType();
if (IsPointer) {
  if (const UnaryOperator *Op
        = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) {
    // The only case we're worried about with pointers requires taking the
    // address.
    if (Op->getOpcode() != UO_AddrOf)
      return;

    Init = Op->getSubExpr();
  } else {
    // We only handle address-of expression initializers for pointers.
    return;
  }
}

if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
  // We only warn when referring to a non-reference parameter declaration.
  const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
  if (!Parameter || Parameter->getType()->isReferenceType())
    return;

  S.Diag(Init->getExprLoc(),
         IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
                   : diag::warn_bind_ref_member_to_parameter)
    << Member << Parameter << Init->getSourceRange();
} else {
  // Other initializers are fine.
  return;
}

S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here)
  << (unsigned)IsPointer;
3947}

3949MemInitResult
3950Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
                           SourceLocation IdLoc) {
FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
assert((DirectMember || IndirectMember) &&(static_cast <bool> ((DirectMember || IndirectMember) &&
 "Member must be a FieldDecl or IndirectFieldDecl") ? void (0
) : __assert_fail ("(DirectMember || IndirectMember) && \"Member must be a FieldDecl or IndirectFieldDecl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3955, __extension__ __PRETTY_FUNCTION__))
       "Member must be a FieldDecl or IndirectFieldDecl")(static_cast <bool> ((DirectMember || IndirectMember) &&
 "Member must be a FieldDecl or IndirectFieldDecl") ? void (0
) : __assert_fail ("(DirectMember || IndirectMember) && \"Member must be a FieldDecl or IndirectFieldDecl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3955, __extension__ __PRETTY_FUNCTION__));

if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
  return true;

if (Member->isInvalidDecl())
  return true;

MultiExprArg Args;
if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
} else if (InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
  Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
} else {
  // Template instantiation doesn't reconstruct ParenListExprs for us.
  Args = Init;
}

SourceRange InitRange = Init->getSourceRange();

if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
  // Can't check initialization for a member of dependent type or when
  // any of the arguments are type-dependent expressions.
  DiscardCleanupsInEvaluationContext();
} else {
  bool InitList = false;
  if (isa<InitListExpr>(Init)) {
    InitList = true;
    Args = Init;
  }

  // Initialize the member.
  InitializedEntity MemberEntity =
    DirectMember ? InitializedEntity::InitializeMember(DirectMember, nullptr)
                 : InitializedEntity::InitializeMember(IndirectMember,
                                                       nullptr);
  InitializationKind Kind =
      InitList ? InitializationKind::CreateDirectList(
                     IdLoc, Init->getLocStart(), Init->getLocEnd())
               : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
                                                  InitRange.getEnd());

  InitializationSequence InitSeq(*this, MemberEntity, Kind, Args);
  ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind, Args,
                                          nullptr);
  if (MemberInit.isInvalid())
    return true;

  CheckForDanglingReferenceOrPointer(*this, Member, MemberInit.get(), IdLoc);

  // C++11 [class.base.init]p7:
  //   The initialization of each base and member constitutes a
  //   full-expression.
  MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin());
  if (MemberInit.isInvalid())
    return true;

  Init = MemberInit.get();
}

if (DirectMember) {
  return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
                                          InitRange.getBegin(), Init,
                                          InitRange.getEnd());
} else {
  return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
                                          InitRange.getBegin(), Init,
                                          InitRange.getEnd());
}
4024}

4026MemInitResult
4027Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init,
                               CXXRecordDecl *ClassDecl) {
SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
if (!LangOpts.CPlusPlus11)
  return Diag(NameLoc, diag::err_delegating_ctor)
    << TInfo->getTypeLoc().getLocalSourceRange();
Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);

bool InitList = true;
MultiExprArg Args = Init;
if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
  InitList = false;
  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
}

SourceRange InitRange = Init->getSourceRange();
// Initialize the object.
InitializedEntity DelegationEntity = InitializedEntity::InitializeDelegation(
                                   QualType(ClassDecl->getTypeForDecl(), 0));
InitializationKind Kind =
    InitList ? InitializationKind::CreateDirectList(
                   NameLoc, Init->getLocStart(), Init->getLocEnd())
             : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
                                                InitRange.getEnd());
InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args);
ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
                                            Args, nullptr);
if (DelegationInit.isInvalid())
  return true;

assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&(static_cast <bool> (cast<CXXConstructExpr>(DelegationInit
.get())->getConstructor() && "Delegating constructor with no target?"
) ? void (0) : __assert_fail ("cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() && \"Delegating constructor with no target?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4058, __extension__ __PRETTY_FUNCTION__))
       "Delegating constructor with no target?")(static_cast <bool> (cast<CXXConstructExpr>(DelegationInit
.get())->getConstructor() && "Delegating constructor with no target?"
) ? void (0) : __assert_fail ("cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() && \"Delegating constructor with no target?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4058, __extension__ __PRETTY_FUNCTION__));

// C++11 [class.base.init]p7:
//   The initialization of each base and member constitutes a
//   full-expression.
DelegationInit = ActOnFinishFullExpr(DelegationInit.get(),
                                     InitRange.getBegin());
if (DelegationInit.isInvalid())
  return true;

// If we are in a dependent context, template instantiation will
// perform this type-checking again. Just save the arguments that we
// received in a ParenListExpr.
// FIXME: This isn't quite ideal, since our ASTs don't capture all
// of the information that we have about the base
// initializer. However, deconstructing the ASTs is a dicey process,
// and this approach is far more likely to get the corner cases right.
if (CurContext->isDependentContext())
  DelegationInit = Init;

return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
                                        DelegationInit.getAs<Expr>(),
                                        InitRange.getEnd());
4081}

4083MemInitResult
4084Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
                         Expr *Init, CXXRecordDecl *ClassDecl,
                         SourceLocation EllipsisLoc) {
SourceLocation BaseLoc
  = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();

if (!BaseType->isDependentType() && !BaseType->isRecordType())
  return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
           << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();

// C++ [class.base.init]p2:
//   [...] Unless the mem-initializer-id names a nonstatic data
//   member of the constructor's class or a direct or virtual base
//   of that class, the mem-initializer is ill-formed. A
//   mem-initializer-list can initialize a base class using any
//   name that denotes that base class type.
bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();

SourceRange InitRange = Init->getSourceRange();
if (EllipsisLoc.isValid()) {
19
←
Taking false branch→
  // This is a pack expansion.
  if (!BaseType->containsUnexpandedParameterPack())  {
    Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
      << SourceRange(BaseLoc, InitRange.getEnd());

    EllipsisLoc = SourceLocation();
  }
} else {
  // Check for any unexpanded parameter packs.
  if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
20
←
Assuming the condition is false→
21
←
Taking false branch→
    return true;

  if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
22
←
Assuming the condition is false→
23
←
Taking false branch→
    return true;
}

// Check for direct and virtual base classes.
const CXXBaseSpecifier *DirectBaseSpec = nullptr;
const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
if (!Dependent) {
24
←
Assuming 'Dependent' is 0→
25
←
Taking true branch→
  if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
26
←
Taking false branch→
                                     BaseType))
    return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);

  FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
27
←
Calling 'FindBaseInitializer'→
870
←
Returning from 'FindBaseInitializer'→
                      VirtualBaseSpec);

  // C++ [base.class.init]p2:
  // Unless the mem-initializer-id names a nonstatic data member of the
  // constructor's class or a direct or virtual base of that class, the
  // mem-initializer is ill-formed.
  if (!DirectBaseSpec && !VirtualBaseSpec) {
    // If the class has any dependent bases, then it's possible that
    // one of those types will resolve to the same type as
    // BaseType. Therefore, just treat this as a dependent base
    // class initialization.  FIXME: Should we try to check the
    // initialization anyway? It seems odd.
    if (ClassDecl->hasAnyDependentBases())
      Dependent = true;
    else
      return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
        << BaseType << Context.getTypeDeclType(ClassDecl)
        << BaseTInfo->getTypeLoc().getLocalSourceRange();
  }
}

if (Dependent) {
871
←
Taking false branch→
  DiscardCleanupsInEvaluationContext();

  return new (Context) CXXCtorInitializer(Context, BaseTInfo,
                                          /*IsVirtual=*/false,
                                          InitRange.getBegin(), Init,
                                          InitRange.getEnd(), EllipsisLoc);
}

// C++ [base.class.init]p2:
//   If a mem-initializer-id is ambiguous because it designates both
//   a direct non-virtual base class and an inherited virtual base
//   class, the mem-initializer is ill-formed.
if (DirectBaseSpec && VirtualBaseSpec)
872
←
Assuming 'DirectBaseSpec' is null→
  return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
    << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();

const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
if (!BaseSpec)
873
←
Assuming 'BaseSpec' is null→
874
←
Taking true branch→
  BaseSpec = VirtualBaseSpec;
875
←
Null pointer value stored to 'BaseSpec'→

// Initialize the base.
bool InitList = true;
MultiExprArg Args = Init;
if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
876
←
Taking false branch→
  InitList = false;
  Args = MultiExprArg(ParenList->getExprs(), ParenList->getNumExprs());
}

InitializedEntity BaseEntity =
  InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
InitializationKind Kind =
    InitList ? InitializationKind::CreateDirectList(BaseLoc)
877
←
'?' condition is true→
             : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
                                                InitRange.getEnd());
InitializationSequence InitSeq(*this, BaseEntity, Kind, Args);
ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind, Args, nullptr);
if (BaseInit.isInvalid())
878
←
Assuming the condition is false→
879
←
Taking false branch→
  return true;

// C++11 [class.base.init]p7:
//   The initialization of each base and member constitutes a
//   full-expression.
BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin());
if (BaseInit.isInvalid())
880
←
Assuming the condition is false→
881
←
Taking false branch→
  return true;

// If we are in a dependent context, template instantiation will
// perform this type-checking again. Just save the arguments that we
// received in a ParenListExpr.
// FIXME: This isn't quite ideal, since our ASTs don't capture all
// of the information that we have about the base
// initializer. However, deconstructing the ASTs is a dicey process,
// and this approach is far more likely to get the corner cases right.
if (CurContext->isDependentContext())
882
←
Assuming the condition is false→
883
←
Taking false branch→
  BaseInit = Init;

return new (Context) CXXCtorInitializer(Context, BaseTInfo,
                                        BaseSpec->isVirtual(),
884
←
Called C++ object pointer is null
                                        InitRange.getBegin(),
                                        BaseInit.getAs<Expr>(),
                                        InitRange.getEnd(), EllipsisLoc);
4212}

4214// Create a static_cast\<T&&>(expr).
4215static Expr *CastForMoving(Sema &SemaRef, Expr *E, QualType T = QualType()) {
if (T.isNull()) T = E->getType();
QualType TargetType = SemaRef.BuildReferenceType(
    T, /*SpelledAsLValue*/false, SourceLocation(), DeclarationName());
SourceLocation ExprLoc = E->getLocStart();
TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
    TargetType, ExprLoc);

return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
                                 SourceRange(ExprLoc, ExprLoc),
                                 E->getSourceRange()).get();
4226}

4228/// ImplicitInitializerKind - How an implicit base or member initializer should
4229/// initialize its base or member.
4230enum ImplicitInitializerKind {
IIK_Default,
IIK_Copy,
IIK_Move,
IIK_Inherit
4235};

4237static bool
4238BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
                           ImplicitInitializerKind ImplicitInitKind,
                           CXXBaseSpecifier *BaseSpec,
                           bool IsInheritedVirtualBase,
                           CXXCtorInitializer *&CXXBaseInit) {
InitializedEntity InitEntity
  = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
                                      IsInheritedVirtualBase);

ExprResult BaseInit;

switch (ImplicitInitKind) {
case IIK_Inherit:
case IIK_Default: {
  InitializationKind InitKind
    = InitializationKind::CreateDefault(Constructor->getLocation());
  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, None);
  break;
}

case IIK_Move:
case IIK_Copy: {
  bool Moving = ImplicitInitKind == IIK_Move;
  ParmVarDecl *Param = Constructor->getParamDecl(0);
  QualType ParamType = Param->getType().getNonReferenceType();

  Expr *CopyCtorArg =
    DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
                        SourceLocation(), Param, false,
                        Constructor->getLocation(), ParamType,
                        VK_LValue, nullptr);

  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));

  // Cast to the base class to avoid ambiguities.
  QualType ArgTy =
    SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
                                     ParamType.getQualifiers());

  if (Moving) {
    CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
  }

  CXXCastPath BasePath;
  BasePath.push_back(BaseSpec);
  CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
                                          CK_UncheckedDerivedToBase,
                                          Moving ? VK_XValue : VK_LValue,
                                          &BasePath).get();

  InitializationKind InitKind
    = InitializationKind::CreateDirect(Constructor->getLocation(),
                                       SourceLocation(), SourceLocation());
  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, CopyCtorArg);
  BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, CopyCtorArg);
  break;
}
}

BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
if (BaseInit.isInvalid())
  return true;

CXXBaseInit =
  new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
             SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
                                                      SourceLocation()),
                                           BaseSpec->isVirtual(),
                                           SourceLocation(),
                                           BaseInit.getAs<Expr>(),
                                           SourceLocation(),
                                           SourceLocation());

return false;
4313}

4315static bool RefersToRValueRef(Expr *MemRef) {
ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
return Referenced->getType()->isRValueReferenceType();
4318}

4320static bool
4321BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
                             ImplicitInitializerKind ImplicitInitKind,
                             FieldDecl *Field, IndirectFieldDecl *Indirect,
                             CXXCtorInitializer *&CXXMemberInit) {
if (Field->isInvalidDecl())
  return true;

SourceLocation Loc = Constructor->getLocation();

if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
  bool Moving = ImplicitInitKind == IIK_Move;
  ParmVarDecl *Param = Constructor->getParamDecl(0);
  QualType ParamType = Param->getType().getNonReferenceType();

  // Suppress copying zero-width bitfields.
  if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0)
    return false;

  Expr *MemberExprBase =
    DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
                        SourceLocation(), Param, false,
                        Loc, ParamType, VK_LValue, nullptr);

  SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));

  if (Moving) {
    MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
  }

  // Build a reference to this field within the parameter.
  CXXScopeSpec SS;
  LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
                            Sema::LookupMemberName);
  MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
                                : cast<ValueDecl>(Field), AS_public);
  MemberLookup.resolveKind();
  ExprResult CtorArg
    = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
                                       ParamType, Loc,
                                       /*IsArrow=*/false,
                                       SS,
                                       /*TemplateKWLoc=*/SourceLocation(),
                                       /*FirstQualifierInScope=*/nullptr,
                                       MemberLookup,
                                       /*TemplateArgs=*/nullptr,
                                       /*S*/nullptr);
  if (CtorArg.isInvalid())
    return true;

  // C++11 [class.copy]p15:
  //   - if a member m has rvalue reference type T&&, it is direct-initialized
  //     with static_cast<T&&>(x.m);
  if (RefersToRValueRef(CtorArg.get())) {
    CtorArg = CastForMoving(SemaRef, CtorArg.get());
  }

  InitializedEntity Entity =
      Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
                                                     /*Implicit*/ true)
               : InitializedEntity::InitializeMember(Field, nullptr,
                                                     /*Implicit*/ true);

  // Direct-initialize to use the copy constructor.
  InitializationKind InitKind =
    InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation());

  Expr *CtorArgE = CtorArg.getAs<Expr>();
  InitializationSequence InitSeq(SemaRef, Entity, InitKind, CtorArgE);
  ExprResult MemberInit =
      InitSeq.Perform(SemaRef, Entity, InitKind, MultiExprArg(&CtorArgE, 1));
  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
  if (MemberInit.isInvalid())
    return true;

  if (Indirect)
    CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
        SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
  else
    CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(
        SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
  return false;
}

assert((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) &&(static_cast <bool> ((ImplicitInitKind == IIK_Default ||
 ImplicitInitKind == IIK_Inherit) && "Unhandled implicit init kind!"
) ? void (0) : __assert_fail ("(ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) && \"Unhandled implicit init kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4405, __extension__ __PRETTY_FUNCTION__))
       "Unhandled implicit init kind!")(static_cast <bool> ((ImplicitInitKind == IIK_Default ||
 ImplicitInitKind == IIK_Inherit) && "Unhandled implicit init kind!"
) ? void (0) : __assert_fail ("(ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) && \"Unhandled implicit init kind!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4405, __extension__ __PRETTY_FUNCTION__));

QualType FieldBaseElementType =
  SemaRef.Context.getBaseElementType(Field->getType());

if (FieldBaseElementType->isRecordType()) {
  InitializedEntity InitEntity =
      Indirect ? InitializedEntity::InitializeMember(Indirect, nullptr,
                                                     /*Implicit*/ true)
               : InitializedEntity::InitializeMember(Field, nullptr,
                                                     /*Implicit*/ true);
  InitializationKind InitKind =
    InitializationKind::CreateDefault(Loc);

  InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, None);
  ExprResult MemberInit =
    InitSeq.Perform(SemaRef, InitEntity, InitKind, None);

  MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
  if (MemberInit.isInvalid())
    return true;

  if (Indirect)
    CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
                                                             Indirect, Loc,
                                                             Loc,
                                                             MemberInit.get(),
                                                             Loc);
  else
    CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
                                                             Field, Loc, Loc,
                                                             MemberInit.get(),
                                                             Loc);
  return false;
}

if (!Field->getParent()->isUnion()) {
  if (FieldBaseElementType->isReferenceType()) {
    SemaRef.Diag(Constructor->getLocation(),
                 diag::err_uninitialized_member_in_ctor)
    << (int)Constructor->isImplicit()
    << SemaRef.Context.getTagDeclType(Constructor->getParent())
    << 0 << Field->getDeclName();
    SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
    return true;
  }

  if (FieldBaseElementType.isConstQualified()) {
    SemaRef.Diag(Constructor->getLocation(),
                 diag::err_uninitialized_member_in_ctor)
    << (int)Constructor->isImplicit()
    << SemaRef.Context.getTagDeclType(Constructor->getParent())
    << 1 << Field->getDeclName();
    SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
    return true;
  }
}

if (FieldBaseElementType.hasNonTrivialObjCLifetime()) {
  // ARC and Weak:
  //   Default-initialize Objective-C pointers to NULL.
  CXXMemberInit
    = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
                                               Loc, Loc,
               new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
                                               Loc);
  return false;
}

// Nothing to initialize.
CXXMemberInit = nullptr;
return false;
4477}

4479namespace {
4480struct BaseAndFieldInfo {
Sema &S;
CXXConstructorDecl *Ctor;
bool AnyErrorsInInits;
ImplicitInitializerKind IIK;
llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
SmallVector<CXXCtorInitializer*, 8> AllToInit;
llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;

BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
  : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
  bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
  if (Ctor->getInheritedConstructor())
    IIK = IIK_Inherit;
  else if (Generated && Ctor->isCopyConstructor())
    IIK = IIK_Copy;
  else if (Generated && Ctor->isMoveConstructor())
    IIK = IIK_Move;
  else
    IIK = IIK_Default;
}

bool isImplicitCopyOrMove() const {
  switch (IIK) {
  case IIK_Copy:
  case IIK_Move:
    return true;

  case IIK_Default:
  case IIK_Inherit:
    return false;
  }

  llvm_unreachable("Invalid ImplicitInitializerKind!")::llvm::llvm_unreachable_internal("Invalid ImplicitInitializerKind!"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4513);
}

bool addFieldInitializer(CXXCtorInitializer *Init) {
  AllToInit.push_back(Init);

  // Check whether this initializer makes the field "used".
  if (Init->getInit()->HasSideEffects(S.Context))
    S.UnusedPrivateFields.remove(Init->getAnyMember());

  return false;
}

bool isInactiveUnionMember(FieldDecl *Field) {
  RecordDecl *Record = Field->getParent();
  if (!Record->isUnion())
    return false;

  if (FieldDecl *Active =
          ActiveUnionMember.lookup(Record->getCanonicalDecl()))
    return Active != Field->getCanonicalDecl();

  // In an implicit copy or move constructor, ignore any in-class initializer.
  if (isImplicitCopyOrMove())
    return true;

  // If there's no explicit initialization, the field is active only if it
  // has an in-class initializer...
  if (Field->hasInClassInitializer())
    return false;
  // ... or it's an anonymous struct or union whose class has an in-class
  // initializer.
  if (!Field->isAnonymousStructOrUnion())
    return true;
  CXXRecordDecl *FieldRD = Field->getType()->getAsCXXRecordDecl();
  return !FieldRD->hasInClassInitializer();
}

/// \brief Determine whether the given field is, or is within, a union member
/// that is inactive (because there was an initializer given for a different
/// member of the union, or because the union was not initialized at all).
bool isWithinInactiveUnionMember(FieldDecl *Field,
                                 IndirectFieldDecl *Indirect) {
  if (!Indirect)
    return isInactiveUnionMember(Field);

  for (auto *C : Indirect->chain()) {
    FieldDecl *Field = dyn_cast<FieldDecl>(C);
    if (Field && isInactiveUnionMember(Field))
      return true;
  }
  return false;
}
4566};
4567}

4569/// \brief Determine whether the given type is an incomplete or zero-lenfgth
4570/// array type.
4571static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) {
if (T->isIncompleteArrayType())
  return true;

while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
  if (!ArrayT->getSize())
    return true;

  T = ArrayT->getElementType();
}

return false;
4583}

4585static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
                                  FieldDecl *Field,
                                  IndirectFieldDecl *Indirect = nullptr) {
if (Field->isInvalidDecl())
  return false;

// Overwhelmingly common case: we have a direct initializer for this field.
if (CXXCtorInitializer *Init =
        Info.AllBaseFields.lookup(Field->getCanonicalDecl()))
  return Info.addFieldInitializer(Init);

// C++11 [class.base.init]p8:
//   if the entity is a non-static data member that has a
//   brace-or-equal-initializer and either
//   -- the constructor's class is a union and no other variant member of that
//      union is designated by a mem-initializer-id or
//   -- the constructor's class is not a union, and, if the entity is a member
//      of an anonymous union, no other member of that union is designated by
//      a mem-initializer-id,
//   the entity is initialized as specified in [dcl.init].
//
// We also apply the same rules to handle anonymous structs within anonymous
// unions.
if (Info.isWithinInactiveUnionMember(Field, Indirect))
  return false;

if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
  ExprResult DIE =
      SemaRef.BuildCXXDefaultInitExpr(Info.Ctor->getLocation(), Field);
  if (DIE.isInvalid())
    return true;
  CXXCtorInitializer *Init;
  if (Indirect)
    Init = new (SemaRef.Context)
        CXXCtorInitializer(SemaRef.Context, Indirect, SourceLocation(),
                           SourceLocation(), DIE.get(), SourceLocation());
  else
    Init = new (SemaRef.Context)
        CXXCtorInitializer(SemaRef.Context, Field, SourceLocation(),
                           SourceLocation(), DIE.get(), SourceLocation());
  return Info.addFieldInitializer(Init);
}

// Don't initialize incomplete or zero-length arrays.
if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
  return false;

// Don't try to build an implicit initializer if there were semantic
// errors in any of the initializers (and therefore we might be
// missing some that the user actually wrote).
if (Info.AnyErrorsInInits)
  return false;

CXXCtorInitializer *Init = nullptr;
if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
                                   Indirect, Init))
  return true;

if (!Init)
  return false;

return Info.addFieldInitializer(Init);
4647}

4649bool
4650Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor,
                             CXXCtorInitializer *Initializer) {
assert(Initializer->isDelegatingInitializer())(static_cast <bool> (Initializer->isDelegatingInitializer
()) ? void (0) : __assert_fail ("Initializer->isDelegatingInitializer()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4652, __extension__ __PRETTY_FUNCTION__));
Constructor->setNumCtorInitializers(1);
CXXCtorInitializer **initializer =
  new (Context) CXXCtorInitializer*[1];
memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
Constructor->setCtorInitializers(initializer);

if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
  MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
  DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
}

DelegatingCtorDecls.push_back(Constructor);

DiagnoseUninitializedFields(*this, Constructor);

return false;
4669}

4671bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
                             ArrayRef<CXXCtorInitializer *> Initializers) {
if (Constructor->isDependentContext()) {
  // Just store the initializers as written, they will be checked during
  // instantiation.
  if (!Initializers.empty()) {
    Constructor->setNumCtorInitializers(Initializers.size());
    CXXCtorInitializer **baseOrMemberInitializers =
      new (Context) CXXCtorInitializer*[Initializers.size()];
    memcpy(baseOrMemberInitializers, Initializers.data(),
           Initializers.size() * sizeof(CXXCtorInitializer*));
    Constructor->setCtorInitializers(baseOrMemberInitializers);
  }

  // Let template instantiation know whether we had errors.
  if (AnyErrors)
    Constructor->setInvalidDecl();

  return false;
}

BaseAndFieldInfo Info(*this, Constructor, AnyErrors);

// We need to build the initializer AST according to order of construction
// and not what user specified in the Initializers list.
CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
if (!ClassDecl)
  return true;

bool HadError = false;

for (unsigned i = 0; i < Initializers.size(); i++) {
  CXXCtorInitializer *Member = Initializers[i];

  if (Member->isBaseInitializer())
    Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
  else {
    Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;

    if (IndirectFieldDecl *F = Member->getIndirectMember()) {
      for (auto *C : F->chain()) {
        FieldDecl *FD = dyn_cast<FieldDecl>(C);
        if (FD && FD->getParent()->isUnion())
          Info.ActiveUnionMember.insert(std::make_pair(
              FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
      }
    } else if (FieldDecl *FD = Member->getMember()) {
      if (FD->getParent()->isUnion())
        Info.ActiveUnionMember.insert(std::make_pair(
            FD->getParent()->getCanonicalDecl(), FD->getCanonicalDecl()));
    }
  }
}

// Keep track of the direct virtual bases.
llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
for (auto &I : ClassDecl->bases()) {
  if (I.isVirtual())
    DirectVBases.insert(&I);
}

// Push virtual bases before others.
for (auto &VBase : ClassDecl->vbases()) {
  if (CXXCtorInitializer *Value
      = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {
    // [class.base.init]p7, per DR257:
    //   A mem-initializer where the mem-initializer-id names a virtual base
    //   class is ignored during execution of a constructor of any class that
    //   is not the most derived class.
    if (ClassDecl->isAbstract()) {
      // FIXME: Provide a fixit to remove the base specifier. This requires
      // tracking the location of the associated comma for a base specifier.
      Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)
        << VBase.getType() << ClassDecl;
      DiagnoseAbstractType(ClassDecl);
    }

    Info.AllToInit.push_back(Value);
  } else if (!AnyErrors && !ClassDecl->isAbstract()) {
    // [class.base.init]p8, per DR257:
    //   If a given [...] base class is not named by a mem-initializer-id
    //   [...] and the entity is not a virtual base class of an abstract
    //   class, then [...] the entity is default-initialized.
    bool IsInheritedVirtualBase = !DirectVBases.count(&VBase);
    CXXCtorInitializer *CXXBaseInit;
    if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
                                     &VBase, IsInheritedVirtualBase,
                                     CXXBaseInit)) {
      HadError = true;
      continue;
    }

    Info.AllToInit.push_back(CXXBaseInit);
  }
}

// Non-virtual bases.
for (auto &Base : ClassDecl->bases()) {
  // Virtuals are in the virtual base list and already constructed.
  if (Base.isVirtual())
    continue;

  if (CXXCtorInitializer *Value
        = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
    Info.AllToInit.push_back(Value);
  } else if (!AnyErrors) {
    CXXCtorInitializer *CXXBaseInit;
    if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
                                     &Base, /*IsInheritedVirtualBase=*/false,
                                     CXXBaseInit)) {
      HadError = true;
      continue;
    }

    Info.AllToInit.push_back(CXXBaseInit);
  }
}

// Fields.
for (auto *Mem : ClassDecl->decls()) {
  if (auto *F = dyn_cast<FieldDecl>(Mem)) {
    // C++ [class.bit]p2:
    //   A declaration for a bit-field that omits the identifier declares an
    //   unnamed bit-field. Unnamed bit-fields are not members and cannot be
    //   initialized.
    if (F->isUnnamedBitfield())
      continue;

    // If we're not generating the implicit copy/move constructor, then we'll
    // handle anonymous struct/union fields based on their individual
    // indirect fields.
    if (F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())
      continue;

    if (CollectFieldInitializer(*this, Info, F))
      HadError = true;
    continue;
  }

  // Beyond this point, we only consider default initialization.
  if (Info.isImplicitCopyOrMove())
    continue;

  if (auto *F = dyn_cast<IndirectFieldDecl>(Mem)) {
    if (F->getType()->isIncompleteArrayType()) {
      assert(ClassDecl->hasFlexibleArrayMember() &&(static_cast <bool> (ClassDecl->hasFlexibleArrayMember
() && "Incomplete array type is not valid") ? void (0
) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4817, __extension__ __PRETTY_FUNCTION__))
             "Incomplete array type is not valid")(static_cast <bool> (ClassDecl->hasFlexibleArrayMember
() && "Incomplete array type is not valid") ? void (0
) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4817, __extension__ __PRETTY_FUNCTION__));
      continue;
    }

    // Initialize each field of an anonymous struct individually.
    if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
      HadError = true;

    continue;
  }
}

unsigned NumInitializers = Info.AllToInit.size();
if (NumInitializers > 0) {
  Constructor->setNumCtorInitializers(NumInitializers);
  CXXCtorInitializer **baseOrMemberInitializers =
    new (Context) CXXCtorInitializer*[NumInitializers];
  memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
         NumInitializers * sizeof(CXXCtorInitializer*));
  Constructor->setCtorInitializers(baseOrMemberInitializers);

  // Constructors implicitly reference the base and member
  // destructors.
  MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
                                         Constructor->getParent());
}

return HadError;
4845}

4847static void PopulateKeysForFields(FieldDecl *Field, SmallVectorImpl<const void*> &IdealInits) {
if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
  const RecordDecl *RD = RT->getDecl();
  if (RD->isAnonymousStructOrUnion()) {
    for (auto *Field : RD->fields())
      PopulateKeysForFields(Field, IdealInits);
    return;
  }
}
IdealInits.push_back(Field->getCanonicalDecl());
4857}

4859static const void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
return Context.getCanonicalType(BaseType).getTypePtr();
4861}

4863static const void *GetKeyForMember(ASTContext &Context,
                                 CXXCtorInitializer *Member) {
if (!Member->isAnyMemberInitializer())
  return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));

return Member->getAnyMember()->getCanonicalDecl();
4869}

4871static void DiagnoseBaseOrMemInitializerOrder(
  Sema &SemaRef, const CXXConstructorDecl *Constructor,
  ArrayRef<CXXCtorInitializer *> Inits) {
if (Constructor->getDeclContext()->isDependentContext())
  return;

// Don't check initializers order unless the warning is enabled at the
// location of at least one initializer.
bool ShouldCheckOrder = false;
for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
  CXXCtorInitializer *Init = Inits[InitIndex];
  if (!SemaRef.Diags.isIgnored(diag::warn_initializer_out_of_order,
                               Init->getSourceLocation())) {
    ShouldCheckOrder = true;
    break;
  }
}
if (!ShouldCheckOrder)
  return;

// Build the list of bases and members in the order that they'll
// actually be initialized.  The explicit initializers should be in
// this same order but may be missing things.
SmallVector<const void*, 32> IdealInitKeys;

const CXXRecordDecl *ClassDecl = Constructor->getParent();

// 1. Virtual bases.
for (const auto &VBase : ClassDecl->vbases())
  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase.getType()));

// 2. Non-virtual bases.
for (const auto &Base : ClassDecl->bases()) {
  if (Base.isVirtual())
    continue;
  IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
}

// 3. Direct fields.
for (auto *Field : ClassDecl->fields()) {
  if (Field->isUnnamedBitfield())
    continue;

  PopulateKeysForFields(Field, IdealInitKeys);
}

unsigned NumIdealInits = IdealInitKeys.size();
unsigned IdealIndex = 0;

CXXCtorInitializer *PrevInit = nullptr;
for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
  CXXCtorInitializer *Init = Inits[InitIndex];
  const void *InitKey = GetKeyForMember(SemaRef.Context, Init);

  // Scan forward to try to find this initializer in the idealized
  // initializers list.
  for (; IdealIndex != NumIdealInits; ++IdealIndex)
    if (InitKey == IdealInitKeys[IdealIndex])
      break;

  // If we didn't find this initializer, it must be because we
  // scanned past it on a previous iteration.  That can only
  // happen if we're out of order;  emit a warning.
  if (IdealIndex == NumIdealInits && PrevInit) {
    Sema::SemaDiagnosticBuilder D =
      SemaRef.Diag(PrevInit->getSourceLocation(),
                   diag::warn_initializer_out_of_order);

    if (PrevInit->isAnyMemberInitializer())
      D << 0 << PrevInit->getAnyMember()->getDeclName();
    else
      D << 1 << PrevInit->getTypeSourceInfo()->getType();

    if (Init->isAnyMemberInitializer())
      D << 0 << Init->getAnyMember()->getDeclName();
    else
      D << 1 << Init->getTypeSourceInfo()->getType();

    // Move back to the initializer's location in the ideal list.
    for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
      if (InitKey == IdealInitKeys[IdealIndex])
        break;

    assert(IdealIndex < NumIdealInits &&(static_cast <bool> (IdealIndex < NumIdealInits &&
 "initializer not found in initializer list") ? void (0) : __assert_fail
 ("IdealIndex < NumIdealInits && \"initializer not found in initializer list\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4955, __extension__ __PRETTY_FUNCTION__))
           "initializer not found in initializer list")(static_cast <bool> (IdealIndex < NumIdealInits &&
 "initializer not found in initializer list") ? void (0) : __assert_fail
 ("IdealIndex < NumIdealInits && \"initializer not found in initializer list\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4955, __extension__ __PRETTY_FUNCTION__));
  }

  PrevInit = Init;
}
4960}

4962namespace {
4963bool CheckRedundantInit(Sema &S,
                      CXXCtorInitializer *Init,
                      CXXCtorInitializer *&PrevInit) {
if (!PrevInit) {
  PrevInit = Init;
  return false;
}

if (FieldDecl *Field = Init->getAnyMember())
  S.Diag(Init->getSourceLocation(),
         diag::err_multiple_mem_initialization)
    << Field->getDeclName()
    << Init->getSourceRange();
else {
  const Type *BaseClass = Init->getBaseClass();
  assert(BaseClass && "neither field nor base")(static_cast <bool> (BaseClass && "neither field nor base"
) ? void (0) : __assert_fail ("BaseClass && \"neither field nor base\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4978, __extension__ __PRETTY_FUNCTION__));
  S.Diag(Init->getSourceLocation(),
         diag::err_multiple_base_initialization)
    << QualType(BaseClass, 0)
    << Init->getSourceRange();
}
S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
  << 0 << PrevInit->getSourceRange();

return true;
4988}

4990typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
4991typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;

4993bool CheckRedundantUnionInit(Sema &S,
                           CXXCtorInitializer *Init,
                           RedundantUnionMap &Unions) {
FieldDecl *Field = Init->getAnyMember();
RecordDecl *Parent = Field->getParent();
NamedDecl *Child = Field;

while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
  if (Parent->isUnion()) {
    UnionEntry &En = Unions[Parent];
    if (En.first && En.first != Child) {
      S.Diag(Init->getSourceLocation(),
             diag::err_multiple_mem_union_initialization)
        << Field->getDeclName()
        << Init->getSourceRange();
      S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
        << 0 << En.second->getSourceRange();
      return true;
    }
    if (!En.first) {
      En.first = Child;
      En.second = Init;
    }
    if (!Parent->isAnonymousStructOrUnion())
      return false;
  }

  Child = Parent;
  Parent = cast<RecordDecl>(Parent->getDeclContext());
}

return false;
5025}
5026}

5028/// ActOnMemInitializers - Handle the member initializers for a constructor.
5029void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
                              SourceLocation ColonLoc,
                              ArrayRef<CXXCtorInitializer*> MemInits,
                              bool AnyErrors) {
if (!ConstructorDecl)
  return;

AdjustDeclIfTemplate(ConstructorDecl);

CXXConstructorDecl *Constructor
  = dyn_cast<CXXConstructorDecl>(ConstructorDecl);

if (!Constructor) {
  Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
  return;
}

// Mapping for the duplicate initializers check.
// For member initializers, this is keyed with a FieldDecl*.
// For base initializers, this is keyed with a Type*.
llvm::DenseMap<const void *, CXXCtorInitializer *> Members;

// Mapping for the inconsistent anonymous-union initializers check.
RedundantUnionMap MemberUnions;

bool HadError = false;
for (unsigned i = 0; i < MemInits.size(); i++) {
  CXXCtorInitializer *Init = MemInits[i];

  // Set the source order index.
  Init->setSourceOrder(i);

  if (Init->isAnyMemberInitializer()) {
    const void *Key = GetKeyForMember(Context, Init);
    if (CheckRedundantInit(*this, Init, Members[Key]) ||
        CheckRedundantUnionInit(*this, Init, MemberUnions))
      HadError = true;
  } else if (Init->isBaseInitializer()) {
    const void *Key = GetKeyForMember(Context, Init);
    if (CheckRedundantInit(*this, Init, Members[Key]))
      HadError = true;
  } else {
    assert(Init->isDelegatingInitializer())(static_cast <bool> (Init->isDelegatingInitializer()
) ? void (0) : __assert_fail ("Init->isDelegatingInitializer()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5071, __extension__ __PRETTY_FUNCTION__));
    // This must be the only initializer
    if (MemInits.size() != 1) {
      Diag(Init->getSourceLocation(),
           diag::err_delegating_initializer_alone)
        << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
      // We will treat this as being the only initializer.
    }
    SetDelegatingInitializer(Constructor, MemInits[i]);
    // Return immediately as the initializer is set.
    return;
  }
}

if (HadError)
  return;

DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits);

SetCtorInitializers(Constructor, AnyErrors, MemInits);

DiagnoseUninitializedFields(*this, Constructor);
5093}

5095void
5096Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,
                                           CXXRecordDecl *ClassDecl) {
// Ignore dependent contexts. Also ignore unions, since their members never
// have destructors implicitly called.
if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
  return;

// FIXME: all the access-control diagnostics are positioned on the
// field/base declaration.  That's probably good; that said, the
// user might reasonably want to know why the destructor is being
// emitted, and we currently don't say.

// Non-static data members.
for (auto *Field : ClassDecl->fields()) {
  if (Field->isInvalidDecl())
    continue;

  // Don't destroy incomplete or zero-length arrays.
  if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
    continue;

  QualType FieldType = Context.getBaseElementType(Field->getType());

  const RecordType* RT = FieldType->getAs<RecordType>();
  if (!RT)
    continue;

  CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
  if (FieldClassDecl->isInvalidDecl())
    continue;
  if (FieldClassDecl->hasIrrelevantDestructor())
    continue;
  // The destructor for an implicit anonymous union member is never invoked.
  if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
    continue;

  CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
  assert(Dtor && "No dtor found for FieldClassDecl!")(static_cast <bool> (Dtor && "No dtor found for FieldClassDecl!"
) ? void (0) : __assert_fail ("Dtor && \"No dtor found for FieldClassDecl!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5133, __extension__ __PRETTY_FUNCTION__));
  CheckDestructorAccess(Field->getLocation(), Dtor,
                        PDiag(diag::err_access_dtor_field)
                          << Field->getDeclName()
                          << FieldType);

  MarkFunctionReferenced(Location, Dtor);
  DiagnoseUseOfDecl(Dtor, Location);
}

// We only potentially invoke the destructors of potentially constructed
// subobjects.
bool VisitVirtualBases = !ClassDecl->isAbstract();

llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;

// Bases.
for (const auto &Base : ClassDecl->bases()) {
  // Bases are always records in a well-formed non-dependent class.
  const RecordType *RT = Base.getType()->getAs<RecordType>();

  // Remember direct virtual bases.
  if (Base.isVirtual()) {
    if (!VisitVirtualBases)
      continue;
    DirectVirtualBases.insert(RT);
  }

  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
  // If our base class is invalid, we probably can't get its dtor anyway.
  if (BaseClassDecl->isInvalidDecl())
    continue;
  if (BaseClassDecl->hasIrrelevantDestructor())
    continue;

  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
  assert(Dtor && "No dtor found for BaseClassDecl!")(static_cast <bool> (Dtor && "No dtor found for BaseClassDecl!"
) ? void (0) : __assert_fail ("Dtor && \"No dtor found for BaseClassDecl!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5169, __extension__ __PRETTY_FUNCTION__));

  // FIXME: caret should be on the start of the class name
  CheckDestructorAccess(Base.getLocStart(), Dtor,
                        PDiag(diag::err_access_dtor_base)
                          << Base.getType()
                          << Base.getSourceRange(),
                        Context.getTypeDeclType(ClassDecl));

  MarkFunctionReferenced(Location, Dtor);
  DiagnoseUseOfDecl(Dtor, Location);
}

if (!VisitVirtualBases)
  return;

// Virtual bases.
for (const auto &VBase : ClassDecl->vbases()) {
  // Bases are always records in a well-formed non-dependent class.
  const RecordType *RT = VBase.getType()->castAs<RecordType>();

  // Ignore direct virtual bases.
  if (DirectVirtualBases.count(RT))
    continue;

  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
  // If our base class is invalid, we probably can't get its dtor anyway.
  if (BaseClassDecl->isInvalidDecl())
    continue;
  if (BaseClassDecl->hasIrrelevantDestructor())
    continue;

  CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
  assert(Dtor && "No dtor found for BaseClassDecl!")(static_cast <bool> (Dtor && "No dtor found for BaseClassDecl!"
) ? void (0) : __assert_fail ("Dtor && \"No dtor found for BaseClassDecl!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5202, __extension__ __PRETTY_FUNCTION__));
  if (CheckDestructorAccess(
          ClassDecl->getLocation(), Dtor,
          PDiag(diag::err_access_dtor_vbase)
              << Context.getTypeDeclType(ClassDecl) << VBase.getType(),
          Context.getTypeDeclType(ClassDecl)) ==
      AR_accessible) {
    CheckDerivedToBaseConversion(
        Context.getTypeDeclType(ClassDecl), VBase.getType(),
        diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(),
        SourceRange(), DeclarationName(), nullptr);
  }

  MarkFunctionReferenced(Location, Dtor);
  DiagnoseUseOfDecl(Dtor, Location);
}
5218}

5220void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
if (!CDtorDecl)
  return;

if (CXXConstructorDecl *Constructor
    = dyn_cast<CXXConstructorDecl>(CDtorDecl)) {
  SetCtorInitializers(Constructor, /*AnyErrors=*/false);
  DiagnoseUninitializedFields(*this, Constructor);
}
5229}

5231bool Sema::isAbstractType(SourceLocation Loc, QualType T) {
if (!getLangOpts().CPlusPlus)
  return false;

const auto *RD = Context.getBaseElementType(T)->getAsCXXRecordDecl();
if (!RD)
  return false;

// FIXME: Per [temp.inst]p1, we are supposed to trigger instantiation of a
// class template specialization here, but doing so breaks a lot of code.

// We can't answer whether something is abstract until it has a
// definition. If it's currently being defined, we'll walk back
// over all the declarations when we have a full definition.
const CXXRecordDecl *Def = RD->getDefinition();
if (!Def || Def->isBeingDefined())
  return false;

return RD->isAbstract();
5250}

5252bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
                                TypeDiagnoser &Diagnoser) {
if (!isAbstractType(Loc, T))
  return false;

T = Context.getBaseElementType(T);
Diagnoser.diagnose(*this, Loc, T);
DiagnoseAbstractType(T->getAsCXXRecordDecl());
return true;
5261}

5263void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
// Check if we've already emitted the list of pure virtual functions
// for this class.
if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
  return;

// If the diagnostic is suppressed, don't emit the notes. We're only
// going to emit them once, so try to attach them to a diagnostic we're
// actually going to show.
if (Diags.isLastDiagnosticIgnored())
  return;

CXXFinalOverriderMap FinalOverriders;
RD->getFinalOverriders(FinalOverriders);

// Keep a set of seen pure methods so we won't diagnose the same method
// more than once.
llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;

for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
                                 MEnd = FinalOverriders.end();
     M != MEnd;
     ++M) {
  for (OverridingMethods::iterator SO = M->second.begin(),
                                SOEnd = M->second.end();
       SO != SOEnd; ++SO) {
    // C++ [class.abstract]p4:
    //   A class is abstract if it contains or inherits at least one
    //   pure virtual function for which the final overrider is pure
    //   virtual.

    //
    if (SO->second.size() != 1)
      continue;

    if (!SO->second.front().Method->isPure())
      continue;

    if (!SeenPureMethods.insert(SO->second.front().Method).second)
      continue;

    Diag(SO->second.front().Method->getLocation(),
         diag::note_pure_virtual_function)
      << SO->second.front().Method->getDeclName() << RD->getDeclName();
  }
}

if (!PureVirtualClassDiagSet)
  PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
PureVirtualClassDiagSet->insert(RD);
5313}

5315namespace {
5316struct AbstractUsageInfo {
Sema &S;
CXXRecordDecl *Record;
CanQualType AbstractType;
bool Invalid;

AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
  : S(S), Record(Record),
    AbstractType(S.Context.getCanonicalType(
                 S.Context.getTypeDeclType(Record))),
    Invalid(false) {}

void DiagnoseAbstractType() {
  if (Invalid) return;
  S.DiagnoseAbstractType(Record);
  Invalid = true;
}

void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
5335};

5337struct CheckAbstractUsage {
AbstractUsageInfo &Info;
const NamedDecl *Ctx;

CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
  : Info(Info), Ctx(Ctx) {}

void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
  switch (TL.getTypeLocClass()) {
5346#define ABSTRACT_TYPELOC(CLASS, PARENT)
5347#define TYPELOC(CLASS, PARENT) \
  case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
5349#include "clang/AST/TypeLocNodes.def"
  }
}

void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
  Visit(TL.getReturnLoc(), Sema::AbstractReturnType);
  for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
    if (!TL.getParam(I))
      continue;

    TypeSourceInfo *TSI = TL.getParam(I)->getTypeSourceInfo();
    if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
  }
}

void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
  Visit(TL.getElementLoc(), Sema::AbstractArrayType);
}

void Check(TemplateSpecializationTypeLoc TL, Sema::AbstractDiagSelID Sel) {
  // Visit the type parameters from a permissive context.
  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
    TemplateArgumentLoc TAL = TL.getArgLoc(I);
    if (TAL.getArgument().getKind() == TemplateArgument::Type)
      if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
        Visit(TSI->getTypeLoc(), Sema::AbstractNone);
    // TODO: other template argument types?
  }
}

// Visit pointee types from a permissive context.
5380#define CheckPolymorphic(Type)void Check(Type TL, Sema::AbstractDiagSelID Sel) { Visit(TL.getNextTypeLoc
(), Sema::AbstractNone); } \
void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
  Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
}
CheckPolymorphic(PointerTypeLoc)void Check(PointerTypeLoc TL, Sema::AbstractDiagSelID Sel) { Visit
(TL.getNextTypeLoc(), Sema::AbstractNone); }
CheckPolymorphic(ReferenceTypeLoc)void Check(ReferenceTypeLoc TL, Sema::AbstractDiagSelID Sel) {
 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); }
CheckPolymorphic(MemberPointerTypeLoc)void Check(MemberPointerTypeLoc TL, Sema::AbstractDiagSelID Sel
) { Visit(TL.getNextTypeLoc(), Sema::AbstractNone); }
CheckPolymorphic(BlockPointerTypeLoc)void Check(BlockPointerTypeLoc TL, Sema::AbstractDiagSelID Sel
) { Visit(TL.getNextTypeLoc(), Sema::AbstractNone); }
CheckPolymorphic(AtomicTypeLoc)void Check(AtomicTypeLoc TL, Sema::AbstractDiagSelID Sel) { Visit
(TL.getNextTypeLoc(), Sema::AbstractNone); }

/// Handle all the types we haven't given a more specific
/// implementation for above.
void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
  // Every other kind of type that we haven't called out already
  // that has an inner type is either (1) sugar or (2) contains that
  // inner type in some way as a subobject.
  if (TypeLoc Next = TL.getNextTypeLoc())
    return Visit(Next, Sel);

  // If there's no inner type and we're in a permissive context,
  // don't diagnose.
  if (Sel == Sema::AbstractNone) return;

  // Check whether the type matches the abstract type.
  QualType T = TL.getType();
  if (T->isArrayType()) {
    Sel = Sema::AbstractArrayType;
    T = Info.S.Context.getBaseElementType(T);
  }
  CanQualType CT = T->getCanonicalTypeUnqualified().getUnqualifiedType();
  if (CT != Info.AbstractType) return;

  // It matched; do some magic.
  if (Sel == Sema::AbstractArrayType) {
    Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
      << T << TL.getSourceRange();
  } else {
    Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
      << Sel << T << TL.getSourceRange();
  }
  Info.DiagnoseAbstractType();
}
5422};

5424void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
                                Sema::AbstractDiagSelID Sel) {
CheckAbstractUsage(*this, D).Visit(TL, Sel);
5427}

5429}

5431/// Check for invalid uses of an abstract type in a method declaration.
5432static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
                                  CXXMethodDecl *MD) {
// No need to do the check on definitions, which require that
// the return/param types be complete.
if (MD->doesThisDeclarationHaveABody())
  return;

// For safety's sake, just ignore it if we don't have type source
// information.  This should never happen for non-implicit methods,
// but...
if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
  Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
5444}

5446/// Check for invalid uses of an abstract type within a class definition.
5447static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
                                  CXXRecordDecl *RD) {
for (auto *D : RD->decls()) {
  if (D->isImplicit()) continue;

  // Methods and method templates.
  if (isa<CXXMethodDecl>(D)) {
    CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
  } else if (isa<FunctionTemplateDecl>(D)) {
    FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
    CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));

  // Fields and static variables.
  } else if (isa<FieldDecl>(D)) {
    FieldDecl *FD = cast<FieldDecl>(D);
    if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
      Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
  } else if (isa<VarDecl>(D)) {
    VarDecl *VD = cast<VarDecl>(D);
    if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
      Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);

  // Nested classes and class templates.
  } else if (isa<CXXRecordDecl>(D)) {
    CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
  } else if (isa<ClassTemplateDecl>(D)) {
    CheckAbstractClassUsage(Info,
                           cast<ClassTemplateDecl>(D)->getTemplatedDecl());
  }
}
5477}

5479static void ReferenceDllExportedMembers(Sema &S, CXXRecordDecl *Class) {
Attr *ClassAttr = getDLLAttr(Class);
if (!ClassAttr)
  return;

assert(ClassAttr->getKind() == attr::DLLExport)(static_cast <bool> (ClassAttr->getKind() == attr::DLLExport
) ? void (0) : __assert_fail ("ClassAttr->getKind() == attr::DLLExport"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5484, __extension__ __PRETTY_FUNCTION__));

TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();

if (TSK == TSK_ExplicitInstantiationDeclaration)
  // Don't go any further if this is just an explicit instantiation
  // declaration.
  return;

for (Decl *Member : Class->decls()) {
  // Defined static variables that are members of an exported base
  // class must be marked export too.
  auto *VD = dyn_cast<VarDecl>(Member);
  if (VD && Member->getAttr<DLLExportAttr>() &&
      VD->getStorageClass() == SC_Static &&
      TSK == TSK_ImplicitInstantiation)
    S.MarkVariableReferenced(VD->getLocation(), VD);

  auto *MD = dyn_cast<CXXMethodDecl>(Member);
  if (!MD)
    continue;

  if (Member->getAttr<DLLExportAttr>()) {
    if (MD->isUserProvided()) {
      // Instantiate non-default class member functions ...

      // .. except for certain kinds of template specializations.
      if (TSK == TSK_ImplicitInstantiation && !ClassAttr->isInherited())
        continue;

      S.MarkFunctionReferenced(Class->getLocation(), MD);

      // The function will be passed to the consumer when its definition is
      // encountered.
    } else if (!MD->isTrivial() || MD->isExplicitlyDefaulted() ||
               MD->isCopyAssignmentOperator() ||
               MD->isMoveAssignmentOperator()) {
      // Synthesize and instantiate non-trivial implicit methods, explicitly
      // defaulted methods, and the copy and move assignment operators. The
      // latter are exported even if they are trivial, because the address of
      // an operator can be taken and should compare equal across libraries.
      DiagnosticErrorTrap Trap(S.Diags);
      S.MarkFunctionReferenced(Class->getLocation(), MD);
      if (Trap.hasErrorOccurred()) {
        S.Diag(ClassAttr->getLocation(), diag::note_due_to_dllexported_class)
            << Class->getName() << !S.getLangOpts().CPlusPlus11;
        break;
      }

      // There is no later point when we will see the definition of this
      // function, so pass it to the consumer now.
      S.Consumer.HandleTopLevelDecl(DeclGroupRef(MD));
    }
  }
}
5539}

5541static void checkForMultipleExportedDefaultConstructors(Sema &S,
                                                      CXXRecordDecl *Class) {
// Only the MS ABI has default constructor closures, so we don't need to do
// this semantic checking anywhere else.
if (!S.Context.getTargetInfo().getCXXABI().isMicrosoft())
  return;

CXXConstructorDecl *LastExportedDefaultCtor = nullptr;
for (Decl *Member : Class->decls()) {
  // Look for exported default constructors.
  auto *CD = dyn_cast<CXXConstructorDecl>(Member);
  if (!CD || !CD->isDefaultConstructor())
    continue;
  auto *Attr = CD->getAttr<DLLExportAttr>();
  if (!Attr)
    continue;

  // If the class is non-dependent, mark the default arguments as ODR-used so
  // that we can properly codegen the constructor closure.
  if (!Class->isDependentContext()) {
    for (ParmVarDecl *PD : CD->parameters()) {
      (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), CD, PD);
      S.DiscardCleanupsInEvaluationContext();
    }
  }

  if (LastExportedDefaultCtor) {
    S.Diag(LastExportedDefaultCtor->getLocation(),
           diag::err_attribute_dll_ambiguous_default_ctor)
        << Class;
    S.Diag(CD->getLocation(), diag::note_entity_declared_at)
        << CD->getDeclName();
    return;
  }
  LastExportedDefaultCtor = CD;
}
5577}

5579/// \brief Check class-level dllimport/dllexport attribute.
5580void Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) {
Attr *ClassAttr = getDLLAttr(Class);

// MSVC inherits DLL attributes to partial class template specializations.
if (Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
  if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
    if (Attr *TemplateAttr =
            getDLLAttr(Spec->getSpecializedTemplate()->getTemplatedDecl())) {
      auto *A = cast<InheritableAttr>(TemplateAttr->clone(getASTContext()));
      A->setInherited(true);
      ClassAttr = A;
    }
  }
}

if (!ClassAttr)
  return;

if (!Class->isExternallyVisible()) {
  Diag(Class->getLocation(), diag::err_attribute_dll_not_extern)
      << Class << ClassAttr;
  return;
}

if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
    !ClassAttr->isInherited()) {
  // Diagnose dll attributes on members of class with dll attribute.
  for (Decl *Member : Class->decls()) {
    if (!isa<VarDecl>(Member) && !isa<CXXMethodDecl>(Member))
      continue;
    InheritableAttr *MemberAttr = getDLLAttr(Member);
    if (!MemberAttr || MemberAttr->isInherited() || Member->isInvalidDecl())
      continue;

    Diag(MemberAttr->getLocation(),
           diag::err_attribute_dll_member_of_dll_class)
        << MemberAttr << ClassAttr;
    Diag(ClassAttr->getLocation(), diag::note_previous_attribute);
    Member->setInvalidDecl();
  }
}

if (Class->getDescribedClassTemplate())
  // Don't inherit dll attribute until the template is instantiated.
  return;

// The class is either imported or exported.
const bool ClassExported = ClassAttr->getKind() == attr::DLLExport;

TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();

// Ignore explicit dllexport on explicit class template instantiation declarations.
if (ClassExported && !ClassAttr->isInherited() &&
    TSK == TSK_ExplicitInstantiationDeclaration) {
  Class->dropAttr<DLLExportAttr>();
  return;
}

// Force declaration of implicit members so they can inherit the attribute.
ForceDeclarationOfImplicitMembers(Class);

// FIXME: MSVC's docs say all bases must be exportable, but this doesn't
// seem to be true in practice?

for (Decl *Member : Class->decls()) {
  VarDecl *VD = dyn_cast<VarDecl>(Member);
  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member);

  // Only methods and static fields inherit the attributes.
  if (!VD && !MD)
    continue;

  if (MD) {
    // Don't process deleted methods.
    if (MD->isDeleted())
      continue;

    if (MD->isInlined()) {
      // MinGW does not import or export inline methods.
      if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
          !Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())
        continue;

      // MSVC versions before 2015 don't export the move assignment operators
      // and move constructor, so don't attempt to import/export them if
      // we have a definition.
      auto *Ctor = dyn_cast<CXXConstructorDecl>(MD);
      if ((MD->isMoveAssignmentOperator() ||
           (Ctor && Ctor->isMoveConstructor())) &&
          !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
        continue;

      // MSVC2015 doesn't export trivial defaulted x-tor but copy assign
      // operator is exported anyway.
      if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
          (Ctor || isa<CXXDestructorDecl>(MD)) && MD->isTrivial())
        continue;
    }
  }

  if (!cast<NamedDecl>(Member)->isExternallyVisible())
    continue;

  if (!getDLLAttr(Member)) {
    auto *NewAttr =
        cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
    NewAttr->setInherited(true);
    Member->addAttr(NewAttr);
  }
}

if (ClassExported)
  DelayedDllExportClasses.push_back(Class);
5693}

5695/// \brief Perform propagation of DLL attributes from a derived class to a
5696/// templated base class for MS compatibility.
5697void Sema::propagateDLLAttrToBaseClassTemplate(
  CXXRecordDecl *Class, Attr *ClassAttr,
  ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {
if (getDLLAttr(
        BaseTemplateSpec->getSpecializedTemplate()->getTemplatedDecl())) {
  // If the base class template has a DLL attribute, don't try to change it.
  return;
}

auto TSK = BaseTemplateSpec->getSpecializationKind();
if (!getDLLAttr(BaseTemplateSpec) &&
    (TSK == TSK_Undeclared || TSK == TSK_ExplicitInstantiationDeclaration ||
     TSK == TSK_ImplicitInstantiation)) {
  // The template hasn't been instantiated yet (or it has, but only as an
  // explicit instantiation declaration or implicit instantiation, which means
  // we haven't codegenned any members yet), so propagate the attribute.
  auto *NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
  NewAttr->setInherited(true);
  BaseTemplateSpec->addAttr(NewAttr);

  // If the template is already instantiated, checkDLLAttributeRedeclaration()
  // needs to be run again to work see the new attribute. Otherwise this will
  // get run whenever the template is instantiated.
  if (TSK != TSK_Undeclared)
    checkClassLevelDLLAttribute(BaseTemplateSpec);

  return;
}

if (getDLLAttr(BaseTemplateSpec)) {
  // The template has already been specialized or instantiated with an
  // attribute, explicitly or through propagation. We should not try to change
  // it.
  return;
}

// The template was previously instantiated or explicitly specialized without
// a dll attribute, It's too late for us to add an attribute, so warn that
// this is unsupported.
Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)
    << BaseTemplateSpec->isExplicitSpecialization();
Diag(ClassAttr->getLocation(), diag::note_attribute);
if (BaseTemplateSpec->isExplicitSpecialization()) {
  Diag(BaseTemplateSpec->getLocation(),
         diag::note_template_class_explicit_specialization_was_here)
      << BaseTemplateSpec;
} else {
  Diag(BaseTemplateSpec->getPointOfInstantiation(),
         diag::note_template_class_instantiation_was_here)
      << BaseTemplateSpec;
}
5748}

5750static void DefineImplicitSpecialMember(Sema &S, CXXMethodDecl *MD,
                                      SourceLocation DefaultLoc) {
switch (S.getSpecialMember(MD)) {
case Sema::CXXDefaultConstructor:
  S.DefineImplicitDefaultConstructor(DefaultLoc,
                                     cast<CXXConstructorDecl>(MD));
  break;
case Sema::CXXCopyConstructor:
  S.DefineImplicitCopyConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
  break;
case Sema::CXXCopyAssignment:
  S.DefineImplicitCopyAssignment(DefaultLoc, MD);
  break;
case Sema::CXXDestructor:
  S.DefineImplicitDestructor(DefaultLoc, cast<CXXDestructorDecl>(MD));
  break;
case Sema::CXXMoveConstructor:
  S.DefineImplicitMoveConstructor(DefaultLoc, cast<CXXConstructorDecl>(MD));
  break;
case Sema::CXXMoveAssignment:
  S.DefineImplicitMoveAssignment(DefaultLoc, MD);
  break;
case Sema::CXXInvalid:
  llvm_unreachable("Invalid special member.")::llvm::llvm_unreachable_internal("Invalid special member.", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5773);
}
5775}

5777/// Determine whether a type is permitted to be passed or returned in
5778/// registers, per C++ [class.temporary]p3.
5779static bool computeCanPassInRegisters(Sema &S, CXXRecordDecl *D) {
if (D->isDependentType() || D->isInvalidDecl())
  return false;

// Per C++ [class.temporary]p3, the relevant condition is:
//   each copy constructor, move constructor, and destructor of X is
//   either trivial or deleted, and X has at least one non-deleted copy
//   or move constructor
bool HasNonDeletedCopyOrMove = false;

if (D->needsImplicitCopyConstructor() &&
    !D->defaultedCopyConstructorIsDeleted()) {
  if (!D->hasTrivialCopyConstructorForCall())
    return false;
  HasNonDeletedCopyOrMove = true;
}

if (S.getLangOpts().CPlusPlus11 && D->needsImplicitMoveConstructor() &&
    !D->defaultedMoveConstructorIsDeleted()) {
  if (!D->hasTrivialMoveConstructorForCall())
    return false;
  HasNonDeletedCopyOrMove = true;
}

if (D->needsImplicitDestructor() && !D->defaultedDestructorIsDeleted() &&
    !D->hasTrivialDestructorForCall())
  return false;

for (const CXXMethodDecl *MD : D->methods()) {
  if (MD->isDeleted())
    continue;

  auto *CD = dyn_cast<CXXConstructorDecl>(MD);
  if (CD && CD->isCopyOrMoveConstructor())
    HasNonDeletedCopyOrMove = true;
  else if (!isa<CXXDestructorDecl>(MD))
    continue;

  if (!MD->isTrivialForCall())
    return false;
}

return HasNonDeletedCopyOrMove;
5822}

5824/// \brief Perform semantic checks on a class definition that has been
5825/// completing, introducing implicitly-declared members, checking for
5826/// abstract types, etc.
5827void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
if (!Record)
  return;

if (Record->isAbstract() && !Record->isInvalidDecl()) {
  AbstractUsageInfo Info(*this, Record);
  CheckAbstractClassUsage(Info, Record);
}

// If this is not an aggregate type and has no user-declared constructor,
// complain about any non-static data members of reference or const scalar
// type, since they will never get initializers.
if (!Record->isInvalidDecl() && !Record->isDependentType() &&
    !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
    !Record->isLambda()) {
  bool Complained = false;
  for (const auto *F : Record->fields()) {
    if (F->hasInClassInitializer() || F->isUnnamedBitfield())
      continue;

    if (F->getType()->isReferenceType() ||
        (F->getType().isConstQualified() && F->getType()->isScalarType())) {
      if (!Complained) {
        Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
          << Record->getTagKind() << Record;
        Complained = true;
      }

      Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
        << F->getType()->isReferenceType()
        << F->getDeclName();
    }
  }
}

if (Record->getIdentifier()) {
  // C++ [class.mem]p13:
  //   If T is the name of a class, then each of the following shall have a
  //   name different from T:
  //     - every member of every anonymous union that is a member of class T.
  //
  // C++ [class.mem]p14:
  //   In addition, if class T has a user-declared constructor (12.1), every
  //   non-static data member of class T shall have a name different from T.
  DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
       ++I) {
    NamedDecl *D = *I;
    if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) ||
        isa<IndirectFieldDecl>(D)) {
      Diag(D->getLocation(), diag::err_member_name_of_class)
        << D->getDeclName();
      break;
    }
  }
}

// Warn if the class has virtual methods but non-virtual public destructor.
if (Record->isPolymorphic() && !Record->isDependentType()) {
  CXXDestructorDecl *dtor = Record->getDestructor();
  if ((!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public)) &&
      !Record->hasAttr<FinalAttr>())
    Diag(dtor ? dtor->getLocation() : Record->getLocation(),
         diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
}

if (Record->isAbstract()) {
  if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
    Diag(Record->getLocation(), diag::warn_abstract_final_class)
      << FA->isSpelledAsSealed();
    DiagnoseAbstractType(Record);
  }
}

// Set HasTrivialSpecialMemberForCall if the record has attribute
// "trivial_abi".
bool HasTrivialABI = Record->hasAttr<TrivialABIAttr>();

if (HasTrivialABI)
  Record->setHasTrivialSpecialMemberForCall();

bool HasMethodWithOverrideControl = false,
     HasOverridingMethodWithoutOverrideControl = false;
if (!Record->isDependentType()) {
  for (auto *M : Record->methods()) {
    // See if a method overloads virtual methods in a base
    // class without overriding any.
    if (!M->isStatic())
      DiagnoseHiddenVirtualMethods(M);
    if (M->hasAttr<OverrideAttr>())
      HasMethodWithOverrideControl = true;
    else if (M->size_overridden_methods() > 0)
      HasOverridingMethodWithoutOverrideControl = true;
    // Check whether the explicitly-defaulted special members are valid.
    if (!M->isInvalidDecl() && M->isExplicitlyDefaulted())
      CheckExplicitlyDefaultedSpecialMember(M);

    // For an explicitly defaulted or deleted special member, we defer
    // determining triviality until the class is complete. That time is now!
    CXXSpecialMember CSM = getSpecialMember(M);
    if (!M->isImplicit() && !M->isUserProvided()) {
      if (CSM != CXXInvalid) {
        M->setTrivial(SpecialMemberIsTrivial(M, CSM));
        // Inform the class that we've finished declaring this member.
        Record->finishedDefaultedOrDeletedMember(M);
        M->setTrivialForCall(
            HasTrivialABI ||
            SpecialMemberIsTrivial(M, CSM, TAH_ConsiderTrivialABI));
        Record->setTrivialForCallFlags(M);
      }
    }

    // Set triviality for the purpose of calls if this is a user-provided
    // copy/move constructor or destructor.
    if ((CSM == CXXCopyConstructor || CSM == CXXMoveConstructor ||
         CSM == CXXDestructor) && M->isUserProvided()) {
      M->setTrivialForCall(HasTrivialABI);
      Record->setTrivialForCallFlags(M);
    }

    if (!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&
        M->hasAttr<DLLExportAttr>()) {
      if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015) &&
          M->isTrivial() &&
          (CSM == CXXDefaultConstructor || CSM == CXXCopyConstructor ||
           CSM == CXXDestructor))
        M->dropAttr<DLLExportAttr>();

      if (M->hasAttr<DLLExportAttr>()) {
        DefineImplicitSpecialMember(*this, M, M->getLocation());
        ActOnFinishInlineFunctionDef(M);
      }
    }
  }
}

if (HasMethodWithOverrideControl &&
    HasOverridingMethodWithoutOverrideControl) {
  // At least one method has the 'override' control declared.
  // Diagnose all other overridden methods which do not have 'override' specified on them.
  for (auto *M : Record->methods())
    DiagnoseAbsenceOfOverrideControl(M);
}

// ms_struct is a request to use the same ABI rules as MSVC.  Check
// whether this class uses any C++ features that are implemented
// completely differently in MSVC, and if so, emit a diagnostic.
// That diagnostic defaults to an error, but we allow projects to
// map it down to a warning (or ignore it).  It's a fairly common
// practice among users of the ms_struct pragma to mass-annotate
// headers, sweeping up a bunch of types that the project doesn't
// really rely on MSVC-compatible layout for.  We must therefore
// support "ms_struct except for C++ stuff" as a secondary ABI.
if (Record->isMsStruct(Context) &&
    (Record->isPolymorphic() || Record->getNumBases())) {
  Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
}

checkClassLevelDLLAttribute(Record);

Record->setCanPassInRegisters(computeCanPassInRegisters(*this, Record));
5988}

5990/// Look up the special member function that would be called by a special
5991/// member function for a subobject of class type.
5992///
5993/// \param Class The class type of the subobject.
5994/// \param CSM The kind of special member function.
5995/// \param FieldQuals If the subobject is a field, its cv-qualifiers.
5996/// \param ConstRHS True if this is a copy operation with a const object
5997///        on its RHS, that is, if the argument to the outer special member
5998///        function is 'const' and this is not a field marked 'mutable'.
5999static Sema::SpecialMemberOverloadResult lookupCallFromSpecialMember(
  Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
  unsigned FieldQuals, bool ConstRHS) {
unsigned LHSQuals = 0;
if (CSM == Sema::CXXCopyAssignment || CSM == Sema::CXXMoveAssignment)
  LHSQuals = FieldQuals;

unsigned RHSQuals = FieldQuals;
if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
  RHSQuals = 0;
else if (ConstRHS)
  RHSQuals |= Qualifiers::Const;

return S.LookupSpecialMember(Class, CSM,
                             RHSQuals & Qualifiers::Const,
                             RHSQuals & Qualifiers::Volatile,
                             false,
                             LHSQuals & Qualifiers::Const,
                             LHSQuals & Qualifiers::Volatile);
6018}

6020class Sema::InheritedConstructorInfo {
Sema &S;
SourceLocation UseLoc;

/// A mapping from the base classes through which the constructor was
/// inherited to the using shadow declaration in that base class (or a null
/// pointer if the constructor was declared in that base class).
llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
    InheritedFromBases;

6030public:
InheritedConstructorInfo(Sema &S, SourceLocation UseLoc,
                         ConstructorUsingShadowDecl *Shadow)
    : S(S), UseLoc(UseLoc) {
  bool DiagnosedMultipleConstructedBases = false;
  CXXRecordDecl *ConstructedBase = nullptr;
  UsingDecl *ConstructedBaseUsing = nullptr;

  // Find the set of such base class subobjects and check that there's a
  // unique constructed subobject.
  for (auto *D : Shadow->redecls()) {
    auto *DShadow = cast<ConstructorUsingShadowDecl>(D);
    auto *DNominatedBase = DShadow->getNominatedBaseClass();
    auto *DConstructedBase = DShadow->getConstructedBaseClass();

    InheritedFromBases.insert(
        std::make_pair(DNominatedBase->getCanonicalDecl(),
                       DShadow->getNominatedBaseClassShadowDecl()));
    if (DShadow->constructsVirtualBase())
      InheritedFromBases.insert(
          std::make_pair(DConstructedBase->getCanonicalDecl(),
                         DShadow->getConstructedBaseClassShadowDecl()));
    else
      assert(DNominatedBase == DConstructedBase)(static_cast <bool> (DNominatedBase == DConstructedBase
) ? void (0) : __assert_fail ("DNominatedBase == DConstructedBase"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6053, __extension__ __PRETTY_FUNCTION__));

    // [class.inhctor.init]p2:
    //   If the constructor was inherited from multiple base class subobjects
    //   of type B, the program is ill-formed.
    if (!ConstructedBase) {
      ConstructedBase = DConstructedBase;
      ConstructedBaseUsing = D->getUsingDecl();
    } else if (ConstructedBase != DConstructedBase &&
               !Shadow->isInvalidDecl()) {
      if (!DiagnosedMultipleConstructedBases) {
        S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor)
            << Shadow->getTargetDecl();
        S.Diag(ConstructedBaseUsing->getLocation(),
             diag::note_ambiguous_inherited_constructor_using)
            << ConstructedBase;
        DiagnosedMultipleConstructedBases = true;
      }
      S.Diag(D->getUsingDecl()->getLocation(),
             diag::note_ambiguous_inherited_constructor_using)
          << DConstructedBase;
    }
  }

  if (DiagnosedMultipleConstructedBases)
    Shadow->setInvalidDecl();
}

/// Find the constructor to use for inherited construction of a base class,
/// and whether that base class constructor inherits the constructor from a
/// virtual base class (in which case it won't actually invoke it).
std::pair<CXXConstructorDecl *, bool>
findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const {
  auto It = InheritedFromBases.find(Base->getCanonicalDecl());
  if (It == InheritedFromBases.end())
    return std::make_pair(nullptr, false);

  // This is an intermediary class.
  if (It->second)
    return std::make_pair(
        S.findInheritingConstructor(UseLoc, Ctor, It->second),
        It->second->constructsVirtualBase());

  // This is the base class from which the constructor was inherited.
  return std::make_pair(Ctor, false);
}
6099};

6101/// Is the special member function which would be selected to perform the
6102/// specified operation on the specified class type a constexpr constructor?
6103static bool
6104specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
                       Sema::CXXSpecialMember CSM, unsigned Quals,
                       bool ConstRHS,
                       CXXConstructorDecl *InheritedCtor = nullptr,
                       Sema::InheritedConstructorInfo *Inherited = nullptr) {
// If we're inheriting a constructor, see if we need to call it for this base
// class.
if (InheritedCtor) {
  assert(CSM == Sema::CXXDefaultConstructor)(static_cast <bool> (CSM == Sema::CXXDefaultConstructor
) ? void (0) : __assert_fail ("CSM == Sema::CXXDefaultConstructor"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6112, __extension__ __PRETTY_FUNCTION__));
  auto BaseCtor =
      Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
  if (BaseCtor)
    return BaseCtor->isConstexpr();
}

if (CSM == Sema::CXXDefaultConstructor)
  return ClassDecl->hasConstexprDefaultConstructor();

Sema::SpecialMemberOverloadResult SMOR =
    lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
if (!SMOR.getMethod())
  // A constructor we wouldn't select can't be "involved in initializing"
  // anything.
  return true;
return SMOR.getMethod()->isConstexpr();
6129}

6131/// Determine whether the specified special member function would be constexpr
6132/// if it were implicitly defined.
6133static bool defaultedSpecialMemberIsConstexpr(
  Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM,
  bool ConstArg, CXXConstructorDecl *InheritedCtor = nullptr,
  Sema::InheritedConstructorInfo *Inherited = nullptr) {
if (!S.getLangOpts().CPlusPlus11)
  return false;

// C++11 [dcl.constexpr]p4:
// In the definition of a constexpr constructor [...]
bool Ctor = true;
switch (CSM) {
case Sema::CXXDefaultConstructor:
  if (Inherited)
    break;
  // Since default constructor lookup is essentially trivial (and cannot
  // involve, for instance, template instantiation), we compute whether a
  // defaulted default constructor is constexpr directly within CXXRecordDecl.
  //
  // This is important for performance; we need to know whether the default
  // constructor is constexpr to determine whether the type is a literal type.
  return ClassDecl->defaultedDefaultConstructorIsConstexpr();

case Sema::CXXCopyConstructor:
case Sema::CXXMoveConstructor:
  // For copy or move constructors, we need to perform overload resolution.
  break;

case Sema::CXXCopyAssignment:
case Sema::CXXMoveAssignment:
  if (!S.getLangOpts().CPlusPlus14)
    return false;
  // In C++1y, we need to perform overload resolution.
  Ctor = false;
  break;

case Sema::CXXDestructor:
case Sema::CXXInvalid:
  return false;
}

//   -- if the class is a non-empty union, or for each non-empty anonymous
//      union member of a non-union class, exactly one non-static data member
//      shall be initialized; [DR1359]
//
// If we squint, this is guaranteed, since exactly one non-static data member
// will be initialized (if the constructor isn't deleted), we just don't know
// which one.
if (Ctor && ClassDecl->isUnion())
  return CSM == Sema::CXXDefaultConstructor
             ? ClassDecl->hasInClassInitializer() ||
                   !ClassDecl->hasVariantMembers()
             : true;

//   -- the class shall not have any virtual base classes;
if (Ctor && ClassDecl->getNumVBases())
  return false;

// C++1y [class.copy]p26:
//   -- [the class] is a literal type, and
if (!Ctor && !ClassDecl->isLiteral())
  return false;

//   -- every constructor involved in initializing [...] base class
//      sub-objects shall be a constexpr constructor;
//   -- the assignment operator selected to copy/move each direct base
//      class is a constexpr function, and
for (const auto &B : ClassDecl->bases()) {
  const RecordType *BaseType = B.getType()->getAs<RecordType>();
  if (!BaseType) continue;

  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
  if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, 0, ConstArg,
                                InheritedCtor, Inherited))
    return false;
}

//   -- every constructor involved in initializing non-static data members
//      [...] shall be a constexpr constructor;
//   -- every non-static data member and base class sub-object shall be
//      initialized
//   -- for each non-static data member of X that is of class type (or array
//      thereof), the assignment operator selected to copy/move that member is
//      a constexpr function
for (const auto *F : ClassDecl->fields()) {
  if (F->isInvalidDecl())
    continue;
  if (CSM == Sema::CXXDefaultConstructor && F->hasInClassInitializer())
    continue;
  QualType BaseType = S.Context.getBaseElementType(F->getType());
  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
    CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
    if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM,
                                  BaseType.getCVRQualifiers(),
                                  ConstArg && !F->isMutable()))
      return false;
  } else if (CSM == Sema::CXXDefaultConstructor) {
    return false;
  }
}

// All OK, it's constexpr!
return true;
6235}

6237static Sema::ImplicitExceptionSpecification
6238ComputeDefaultedSpecialMemberExceptionSpec(
  Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
  Sema::InheritedConstructorInfo *ICI);

6242static Sema::ImplicitExceptionSpecification
6243computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD) {
auto CSM = S.getSpecialMember(MD);
if (CSM != Sema::CXXInvalid)
  return ComputeDefaultedSpecialMemberExceptionSpec(S, Loc, MD, CSM, nullptr);

auto *CD = cast<CXXConstructorDecl>(MD);
assert(CD->getInheritedConstructor() &&(static_cast <bool> (CD->getInheritedConstructor() &&
 "only special members have implicit exception specs") ? void
 (0) : __assert_fail ("CD->getInheritedConstructor() && \"only special members have implicit exception specs\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6250, __extension__ __PRETTY_FUNCTION__))
       "only special members have implicit exception specs")(static_cast <bool> (CD->getInheritedConstructor() &&
 "only special members have implicit exception specs") ? void
 (0) : __assert_fail ("CD->getInheritedConstructor() && \"only special members have implicit exception specs\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6250, __extension__ __PRETTY_FUNCTION__));
Sema::InheritedConstructorInfo ICI(
    S, Loc, CD->getInheritedConstructor().getShadowDecl());
return ComputeDefaultedSpecialMemberExceptionSpec(
    S, Loc, CD, Sema::CXXDefaultConstructor, &ICI);
6255}

6257static FunctionProtoType::ExtProtoInfo getImplicitMethodEPI(Sema &S,
                                                          CXXMethodDecl *MD) {
FunctionProtoType::ExtProtoInfo EPI;

// Build an exception specification pointing back at this member.
EPI.ExceptionSpec.Type = EST_Unevaluated;
EPI.ExceptionSpec.SourceDecl = MD;

// Set the calling convention to the default for C++ instance methods.
EPI.ExtInfo = EPI.ExtInfo.withCallingConv(
    S.Context.getDefaultCallingConvention(/*IsVariadic=*/false,
                                          /*IsCXXMethod=*/true));
return EPI;
6270}

6272void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) {
const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
if (FPT->getExceptionSpecType() != EST_Unevaluated)
  return;

// Evaluate the exception specification.
auto IES = computeImplicitExceptionSpec(*this, Loc, MD);
auto ESI = IES.getExceptionSpec();

// Update the type of the special member to use it.
UpdateExceptionSpec(MD, ESI);

// A user-provided destructor can be defined outside the class. When that
// happens, be sure to update the exception specification on both
// declarations.
const FunctionProtoType *CanonicalFPT =
  MD->getCanonicalDecl()->getType()->castAs<FunctionProtoType>();
if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
  UpdateExceptionSpec(MD->getCanonicalDecl(), ESI);
6291}

6293void Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD) {
CXXRecordDecl *RD = MD->getParent();
CXXSpecialMember CSM = getSpecialMember(MD);

assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&(static_cast <bool> (MD->isExplicitlyDefaulted() &&
 CSM != CXXInvalid && "not an explicitly-defaulted special member"
) ? void (0) : __assert_fail ("MD->isExplicitlyDefaulted() && CSM != CXXInvalid && \"not an explicitly-defaulted special member\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6298, __extension__ __PRETTY_FUNCTION__))
       "not an explicitly-defaulted special member")(static_cast <bool> (MD->isExplicitlyDefaulted() &&
 CSM != CXXInvalid && "not an explicitly-defaulted special member"
) ? void (0) : __assert_fail ("MD->isExplicitlyDefaulted() && CSM != CXXInvalid && \"not an explicitly-defaulted special member\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6298, __extension__ __PRETTY_FUNCTION__));

// Whether this was the first-declared instance of the constructor.
// This affects whether we implicitly add an exception spec and constexpr.
bool First = MD == MD->getCanonicalDecl();

bool HadError = false;

// C++11 [dcl.fct.def.default]p1:
//   A function that is explicitly defaulted shall
//     -- be a special member function (checked elsewhere),
//     -- have the same type (except for ref-qualifiers, and except that a
//        copy operation can take a non-const reference) as an implicit
//        declaration, and
//     -- not have default arguments.
unsigned ExpectedParams = 1;
if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
  ExpectedParams = 0;
if (MD->getNumParams() != ExpectedParams) {
  // This also checks for default arguments: a copy or move constructor with a
  // default argument is classified as a default constructor, and assignment
  // operations and destructors can't have default arguments.
  Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
    << CSM << MD->getSourceRange();
  HadError = true;
} else if (MD->isVariadic()) {
  Diag(MD->getLocation(), diag::err_defaulted_special_member_variadic)
    << CSM << MD->getSourceRange();
  HadError = true;
}

const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>();

bool CanHaveConstParam = false;
if (CSM == CXXCopyConstructor)
  CanHaveConstParam = RD->implicitCopyConstructorHasConstParam();
else if (CSM == CXXCopyAssignment)
  CanHaveConstParam = RD->implicitCopyAssignmentHasConstParam();

QualType ReturnType = Context.VoidTy;
if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
  // Check for return type matching.
  ReturnType = Type->getReturnType();
  QualType ExpectedReturnType =
      Context.getLValueReferenceType(Context.getTypeDeclType(RD));
  if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
    Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
      << (CSM == CXXMoveAssignment) << ExpectedReturnType;
    HadError = true;
  }

  // A defaulted special member cannot have cv-qualifiers.
  if (Type->getTypeQuals()) {
    Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
      << (CSM == CXXMoveAssignment) << getLangOpts().CPlusPlus14;
    HadError = true;
  }
}

// Check for parameter type matching.
QualType ArgType = ExpectedParams ? Type->getParamType(0) : QualType();
bool HasConstParam = false;
if (ExpectedParams && ArgType->isReferenceType()) {
  // Argument must be reference to possibly-const T.
  QualType ReferentType = ArgType->getPointeeType();
  HasConstParam = ReferentType.isConstQualified();

  if (ReferentType.isVolatileQualified()) {
    Diag(MD->getLocation(),
         diag::err_defaulted_special_member_volatile_param) << CSM;
    HadError = true;
  }

  if (HasConstParam && !CanHaveConstParam) {
    if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
      Diag(MD->getLocation(),
           diag::err_defaulted_special_member_copy_const_param)
        << (CSM == CXXCopyAssignment);
      // FIXME: Explain why this special member can't be const.
    } else {
      Diag(MD->getLocation(),
           diag::err_defaulted_special_member_move_const_param)
        << (CSM == CXXMoveAssignment);
    }
    HadError = true;
  }
} else if (ExpectedParams) {
  // A copy assignment operator can take its argument by value, but a
  // defaulted one cannot.
  assert(CSM == CXXCopyAssignment && "unexpected non-ref argument")(static_cast <bool> (CSM == CXXCopyAssignment &&
 "unexpected non-ref argument") ? void (0) : __assert_fail ("CSM == CXXCopyAssignment && \"unexpected non-ref argument\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6387, __extension__ __PRETTY_FUNCTION__));
  Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
  HadError = true;
}

// C++11 [dcl.fct.def.default]p2:
//   An explicitly-defaulted function may be declared constexpr only if it
//   would have been implicitly declared as constexpr,
// Do not apply this rule to members of class templates, since core issue 1358
// makes such functions always instantiate to constexpr functions. For
// functions which cannot be constexpr (for non-constructors in C++11 and for
// destructors in C++1y), this is checked elsewhere.
bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
                                                   HasConstParam);
if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
                               : isa<CXXConstructorDecl>(MD)) &&
    MD->isConstexpr() && !Constexpr &&
    MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
  Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM;
  // FIXME: Explain why the special member can't be constexpr.
  HadError = true;
}

//   and may have an explicit exception-specification only if it is compatible
//   with the exception-specification on the implicit declaration.
if (Type->hasExceptionSpec()) {
  // Delay the check if this is the first declaration of the special member,
  // since we may not have parsed some necessary in-class initializers yet.
  if (First) {
    // If the exception specification needs to be instantiated, do so now,
    // before we clobber it with an EST_Unevaluated specification below.
    if (Type->getExceptionSpecType() == EST_Uninstantiated) {
      InstantiateExceptionSpec(MD->getLocStart(), MD);
      Type = MD->getType()->getAs<FunctionProtoType>();
    }
    DelayedDefaultedMemberExceptionSpecs.push_back(std::make_pair(MD, Type));
  } else
    CheckExplicitlyDefaultedMemberExceptionSpec(MD, Type);
}

//   If a function is explicitly defaulted on its first declaration,
if (First) {
  //  -- it is implicitly considered to be constexpr if the implicit
  //     definition would be,
  MD->setConstexpr(Constexpr);

  //  -- it is implicitly considered to have the same exception-specification
  //     as if it had been implicitly declared,
  FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
  EPI.ExceptionSpec.Type = EST_Unevaluated;
  EPI.ExceptionSpec.SourceDecl = MD;
  MD->setType(Context.getFunctionType(ReturnType,
                                      llvm::makeArrayRef(&ArgType,
                                                         ExpectedParams),
                                      EPI));
}

if (ShouldDeleteSpecialMember(MD, CSM)) {
  if (First) {
    SetDeclDeleted(MD, MD->getLocation());
  } else {
    // C++11 [dcl.fct.def.default]p4:
    //   [For a] user-provided explicitly-defaulted function [...] if such a
    //   function is implicitly defined as deleted, the program is ill-formed.
    Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
    ShouldDeleteSpecialMember(MD, CSM, nullptr, /*Diagnose*/true);
    HadError = true;
  }
}

if (HadError)
  MD->setInvalidDecl();
6459}

6461/// Check whether the exception specification provided for an
6462/// explicitly-defaulted special member matches the exception specification
6463/// that would have been generated for an implicit special member, per
6464/// C++11 [dcl.fct.def.default]p2.
6465void Sema::CheckExplicitlyDefaultedMemberExceptionSpec(
  CXXMethodDecl *MD, const FunctionProtoType *SpecifiedType) {
// If the exception specification was explicitly specified but hadn't been
// parsed when the method was defaulted, grab it now.
if (SpecifiedType->getExceptionSpecType() == EST_Unparsed)
  SpecifiedType =
      MD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();

// Compute the implicit exception specification.
CallingConv CC = Context.getDefaultCallingConvention(/*IsVariadic=*/false,
                                                     /*IsCXXMethod=*/true);
FunctionProtoType::ExtProtoInfo EPI(CC);
auto IES = computeImplicitExceptionSpec(*this, MD->getLocation(), MD);
EPI.ExceptionSpec = IES.getExceptionSpec();
const FunctionProtoType *ImplicitType = cast<FunctionProtoType>(
  Context.getFunctionType(Context.VoidTy, None, EPI));

// Ensure that it matches.
CheckEquivalentExceptionSpec(
  PDiag(diag::err_incorrect_defaulted_exception_spec)
    << getSpecialMember(MD), PDiag(),
  ImplicitType, SourceLocation(),
  SpecifiedType, MD->getLocation());
6488}

6490void Sema::CheckDelayedMemberExceptionSpecs() {
decltype(DelayedExceptionSpecChecks) Checks;
decltype(DelayedDefaultedMemberExceptionSpecs) Specs;

std::swap(Checks, DelayedExceptionSpecChecks);
std::swap(Specs, DelayedDefaultedMemberExceptionSpecs);

// Perform any deferred checking of exception specifications for virtual
// destructors.
for (auto &Check : Checks)
  CheckOverridingFunctionExceptionSpec(Check.first, Check.second);

// Check that any explicitly-defaulted methods have exception specifications
// compatible with their implicit exception specifications.
for (auto &Spec : Specs)
  CheckExplicitlyDefaultedMemberExceptionSpec(Spec.first, Spec.second);
6506}

6508namespace {
6509/// CRTP base class for visiting operations performed by a special member
6510/// function (or inherited constructor).
6511template<typename Derived>
6512struct SpecialMemberVisitor {
Sema &S;
CXXMethodDecl *MD;
Sema::CXXSpecialMember CSM;
Sema::InheritedConstructorInfo *ICI;

// Properties of the special member, computed for convenience.
bool IsConstructor = false, IsAssignment = false, ConstArg = false;

SpecialMemberVisitor(Sema &S, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
                     Sema::InheritedConstructorInfo *ICI)
    : S(S), MD(MD), CSM(CSM), ICI(ICI) {
  switch (CSM) {
  case Sema::CXXDefaultConstructor:
  case Sema::CXXCopyConstructor:
  case Sema::CXXMoveConstructor:
    IsConstructor = true;
    break;
  case Sema::CXXCopyAssignment:
  case Sema::CXXMoveAssignment:
    IsAssignment = true;
    break;
  case Sema::CXXDestructor:
    break;
  case Sema::CXXInvalid:
    llvm_unreachable("invalid special member kind")::llvm::llvm_unreachable_internal("invalid special member kind"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6537);
  }

  if (MD->getNumParams()) {
    if (const ReferenceType *RT =
            MD->getParamDecl(0)->getType()->getAs<ReferenceType>())
      ConstArg = RT->getPointeeType().isConstQualified();
  }
}

Derived &getDerived() { return static_cast<Derived&>(*this); }

/// Is this a "move" special member?
bool isMove() const {
  return CSM == Sema::CXXMoveConstructor || CSM == Sema::CXXMoveAssignment;
}

/// Look up the corresponding special member in the given class.
Sema::SpecialMemberOverloadResult lookupIn(CXXRecordDecl *Class,
                                           unsigned Quals, bool IsMutable) {
  return lookupCallFromSpecialMember(S, Class, CSM, Quals,
                                     ConstArg && !IsMutable);
}

/// Look up the constructor for the specified base class to see if it's
/// overridden due to this being an inherited constructor.
Sema::SpecialMemberOverloadResult lookupInheritedCtor(CXXRecordDecl *Class) {
  if (!ICI)
    return {};
  assert(CSM == Sema::CXXDefaultConstructor)(static_cast <bool> (CSM == Sema::CXXDefaultConstructor
) ? void (0) : __assert_fail ("CSM == Sema::CXXDefaultConstructor"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6566, __extension__ __PRETTY_FUNCTION__));
  auto *BaseCtor =
    cast<CXXConstructorDecl>(MD)->getInheritedConstructor().getConstructor();
  if (auto *MD = ICI->findConstructorForBase(Class, BaseCtor).first)
    return MD;
  return {};
}

/// A base or member subobject.
typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;

/// Get the location to use for a subobject in diagnostics.
static SourceLocation getSubobjectLoc(Subobject Subobj) {
  // FIXME: For an indirect virtual base, the direct base leading to
  // the indirect virtual base would be a more useful choice.
  if (auto *B = Subobj.dyn_cast<CXXBaseSpecifier*>())
    return B->getBaseTypeLoc();
  else
    return Subobj.get<FieldDecl*>()->getLocation();
}

enum BasesToVisit {
  /// Visit all non-virtual (direct) bases.
  VisitNonVirtualBases,
  /// Visit all direct bases, virtual or not.
  VisitDirectBases,
  /// Visit all non-virtual bases, and all virtual bases if the class
  /// is not abstract.
  VisitPotentiallyConstructedBases,
  /// Visit all direct or virtual bases.
  VisitAllBases
};

// Visit the bases and members of the class.
bool visit(BasesToVisit Bases) {
  CXXRecordDecl *RD = MD->getParent();

  if (Bases == VisitPotentiallyConstructedBases)
    Bases = RD->isAbstract() ? VisitNonVirtualBases : VisitAllBases;

  for (auto &B : RD->bases())
    if ((Bases == VisitDirectBases || !B.isVirtual()) &&
        getDerived().visitBase(&B))
      return true;

  if (Bases == VisitAllBases)
    for (auto &B : RD->vbases())
      if (getDerived().visitBase(&B))
        return true;

  for (auto *F : RD->fields())
    if (!F->isInvalidDecl() && !F->isUnnamedBitfield() &&
        getDerived().visitField(F))
      return true;

  return false;
}
6623};
6624}

6626namespace {
6627struct SpecialMemberDeletionInfo
  : SpecialMemberVisitor<SpecialMemberDeletionInfo> {
bool Diagnose;

SourceLocation Loc;

bool AllFieldsAreConst;

SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
                          Sema::CXXSpecialMember CSM,
                          Sema::InheritedConstructorInfo *ICI, bool Diagnose)
    : SpecialMemberVisitor(S, MD, CSM, ICI), Diagnose(Diagnose),
      Loc(MD->getLocation()), AllFieldsAreConst(true) {}

bool inUnion() const { return MD->getParent()->isUnion(); }

Sema::CXXSpecialMember getEffectiveCSM() {
  return ICI ? Sema::CXXInvalid : CSM;
}

bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
bool visitField(FieldDecl *Field) { return shouldDeleteForField(Field); }

bool shouldDeleteForBase(CXXBaseSpecifier *Base);
bool shouldDeleteForField(FieldDecl *FD);
bool shouldDeleteForAllConstMembers();

bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
                                   unsigned Quals);
bool shouldDeleteForSubobjectCall(Subobject Subobj,
                                  Sema::SpecialMemberOverloadResult SMOR,
                                  bool IsDtorCallInCtor);

bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
6661};
6662}

6664/// Is the given special member inaccessible when used on the given
6665/// sub-object.
6666bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
                                           CXXMethodDecl *target) {
/// If we're operating on a base class, the object type is the
/// type of this special member.
QualType objectTy;
AccessSpecifier access = target->getAccess();
if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
  objectTy = S.Context.getTypeDeclType(MD->getParent());
  access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);

// If we're operating on a field, the object type is the type of the field.
} else {
  objectTy = S.Context.getTypeDeclType(target->getParent());
}

return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
6682}

6684/// Check whether we should delete a special member due to the implicit
6685/// definition containing a call to a special member of a subobject.
6686bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR,
  bool IsDtorCallInCtor) {
CXXMethodDecl *Decl = SMOR.getMethod();
FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();

int DiagKind = -1;

if (SMOR.getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted)
  DiagKind = !Decl ? 0 : 1;
else if (SMOR.getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
  DiagKind = 2;
else if (!isAccessible(Subobj, Decl))
  DiagKind = 3;
else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
         !Decl->isTrivial()) {
  // A member of a union must have a trivial corresponding special member.
  // As a weird special case, a destructor call from a union's constructor
  // must be accessible and non-deleted, but need not be trivial. Such a
  // destructor is never actually called, but is semantically checked as
  // if it were.
  DiagKind = 4;
}

if (DiagKind == -1)
  return false;

if (Diagnose) {
  if (Field) {
    S.Diag(Field->getLocation(),
           diag::note_deleted_special_member_class_subobject)
      << getEffectiveCSM() << MD->getParent() << /*IsField*/true
      << Field << DiagKind << IsDtorCallInCtor;
  } else {
    CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
    S.Diag(Base->getLocStart(),
           diag::note_deleted_special_member_class_subobject)
      << getEffectiveCSM() << MD->getParent() << /*IsField*/false
      << Base->getType() << DiagKind << IsDtorCallInCtor;
  }

  if (DiagKind == 1)
    S.NoteDeletedFunction(Decl);
  // FIXME: Explain inaccessibility if DiagKind == 3.
}

return true;
6733}

6735/// Check whether we should delete a special member function due to having a
6736/// direct or virtual base class or non-static data member of class type M.
6737bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
  CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
bool IsMutable = Field && Field->isMutable();

// C++11 [class.ctor]p5:
// -- any direct or virtual base class, or non-static data member with no
//    brace-or-equal-initializer, has class type M (or array thereof) and
//    either M has no default constructor or overload resolution as applied
//    to M's default constructor results in an ambiguity or in a function
//    that is deleted or inaccessible
// C++11 [class.copy]p11, C++11 [class.copy]p23:
// -- a direct or virtual base class B that cannot be copied/moved because
//    overload resolution, as applied to B's corresponding special member,
//    results in an ambiguity or a function that is deleted or inaccessible
//    from the defaulted special member
// C++11 [class.dtor]p5:
// -- any direct or virtual base class [...] has a type with a destructor
//    that is deleted or inaccessible
if (!(CSM == Sema::CXXDefaultConstructor &&
      Field && Field->hasInClassInitializer()) &&
    shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable),
                                 false))
  return true;

// C++11 [class.ctor]p5, C++11 [class.copy]p11:
// -- any direct or virtual base class or non-static data member has a
//    type with a destructor that is deleted or inaccessible
if (IsConstructor) {
  Sema::SpecialMemberOverloadResult SMOR =
      S.LookupSpecialMember(Class, Sema::CXXDestructor,
                            false, false, false, false, false);
  if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
    return true;
}

return false;
6774}

6776/// Check whether we should delete a special member function due to the class
6777/// having a particular direct or virtual base class.
6778bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
// If program is correct, BaseClass cannot be null, but if it is, the error
// must be reported elsewhere.
if (!BaseClass)
  return false;
// If we have an inheriting constructor, check whether we're calling an
// inherited constructor instead of a default constructor.
Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
if (auto *BaseCtor = SMOR.getMethod()) {
  // Note that we do not check access along this path; other than that,
  // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
  // FIXME: Check that the base has a usable destructor! Sink this into
  // shouldDeleteForClassSubobject.
  if (BaseCtor->isDeleted() && Diagnose) {
    S.Diag(Base->getLocStart(),
           diag::note_deleted_special_member_class_subobject)
      << getEffectiveCSM() << MD->getParent() << /*IsField*/false
      << Base->getType() << /*Deleted*/1 << /*IsDtorCallInCtor*/false;
    S.NoteDeletedFunction(BaseCtor);
  }
  return BaseCtor->isDeleted();
}
return shouldDeleteForClassSubobject(BaseClass, Base, 0);
6802}

6804/// Check whether we should delete a special member function due to the class
6805/// having a particular non-static data member.
6806bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
QualType FieldType = S.Context.getBaseElementType(FD->getType());
CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();

if (CSM == Sema::CXXDefaultConstructor) {
  // For a default constructor, all references must be initialized in-class
  // and, if a union, it must have a non-const member.
  if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
    if (Diagnose)
      S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
        << !!ICI << MD->getParent() << FD << FieldType << /*Reference*/0;
    return true;
  }
  // C++11 [class.ctor]p5: any non-variant non-static data member of
  // const-qualified type (or array thereof) with no
  // brace-or-equal-initializer does not have a user-provided default
  // constructor.
  if (!inUnion() && FieldType.isConstQualified() &&
      !FD->hasInClassInitializer() &&
      (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
    if (Diagnose)
      S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
        << !!ICI << MD->getParent() << FD << FD->getType() << /*Const*/1;
    return true;
  }

  if (inUnion() && !FieldType.isConstQualified())
    AllFieldsAreConst = false;
} else if (CSM == Sema::CXXCopyConstructor) {
  // For a copy constructor, data members must not be of rvalue reference
  // type.
  if (FieldType->isRValueReferenceType()) {
    if (Diagnose)
      S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
        << MD->getParent() << FD << FieldType;
    return true;
  }
} else if (IsAssignment) {
  // For an assignment operator, data members must not be of reference type.
  if (FieldType->isReferenceType()) {
    if (Diagnose)
      S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
        << isMove() << MD->getParent() << FD << FieldType << /*Reference*/0;
    return true;
  }
  if (!FieldRecord && FieldType.isConstQualified()) {
    // C++11 [class.copy]p23:
    // -- a non-static data member of const non-class type (or array thereof)
    if (Diagnose)
      S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
        << isMove() << MD->getParent() << FD << FD->getType() << /*Const*/1;
    return true;
  }
}

if (FieldRecord) {
  // Some additional restrictions exist on the variant members.
  if (!inUnion() && FieldRecord->isUnion() &&
      FieldRecord->isAnonymousStructOrUnion()) {
    bool AllVariantFieldsAreConst = true;

    // FIXME: Handle anonymous unions declared within anonymous unions.
    for (auto *UI : FieldRecord->fields()) {
      QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());

      if (!UnionFieldType.isConstQualified())
        AllVariantFieldsAreConst = false;

      CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
      if (UnionFieldRecord &&
          shouldDeleteForClassSubobject(UnionFieldRecord, UI,
                                        UnionFieldType.getCVRQualifiers()))
        return true;
    }

    // At least one member in each anonymous union must be non-const
    if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
        !FieldRecord->field_empty()) {
      if (Diagnose)
        S.Diag(FieldRecord->getLocation(),
               diag::note_deleted_default_ctor_all_const)
          << !!ICI << MD->getParent() << /*anonymous union*/1;
      return true;
    }

    // Don't check the implicit member of the anonymous union type.
    // This is technically non-conformant, but sanity demands it.
    return false;
  }

  if (shouldDeleteForClassSubobject(FieldRecord, FD,
                                    FieldType.getCVRQualifiers()))
    return true;
}

return false;
6902}

6904/// C++11 [class.ctor] p5:
6905///   A defaulted default constructor for a class X is defined as deleted if
6906/// X is a union and all of its variant members are of const-qualified type.
6907bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
// This is a silly definition, because it gives an empty union a deleted
// default constructor. Don't do that.
if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst) {
  bool AnyFields = false;
  for (auto *F : MD->getParent()->fields())
    if ((AnyFields = !F->isUnnamedBitfield()))
      break;
  if (!AnyFields)
    return false;
  if (Diagnose)
    S.Diag(MD->getParent()->getLocation(),
           diag::note_deleted_default_ctor_all_const)
      << !!ICI << MD->getParent() << /*not anonymous union*/0;
  return true;
}
return false;
6924}

6926/// Determine whether a defaulted special member function should be defined as
6927/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
6928/// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
6929bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
                                   InheritedConstructorInfo *ICI,
                                   bool Diagnose) {
if (MD->isInvalidDecl())
  return false;
CXXRecordDecl *RD = MD->getParent();
assert(!RD->isDependentType() && "do deletion after instantiation")(static_cast <bool> (!RD->isDependentType() &&
 "do deletion after instantiation") ? void (0) : __assert_fail
 ("!RD->isDependentType() && \"do deletion after instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6935, __extension__ __PRETTY_FUNCTION__));
if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
  return false;

// C++11 [expr.lambda.prim]p19:
//   The closure type associated with a lambda-expression has a
//   deleted (8.4.3) default constructor and a deleted copy
//   assignment operator.
if (RD->isLambda() &&
    (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
  if (Diagnose)
    Diag(RD->getLocation(), diag::note_lambda_decl);
  return true;
}

// For an anonymous struct or union, the copy and assignment special members
// will never be used, so skip the check. For an anonymous union declared at
// namespace scope, the constructor and destructor are used.
if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
    RD->isAnonymousStructOrUnion())
  return false;

// C++11 [class.copy]p7, p18:
//   If the class definition declares a move constructor or move assignment
//   operator, an implicitly declared copy constructor or copy assignment
//   operator is defined as deleted.
if (MD->isImplicit() &&
    (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
  CXXMethodDecl *UserDeclaredMove = nullptr;

  // In Microsoft mode up to MSVC 2013, a user-declared move only causes the
  // deletion of the corresponding copy operation, not both copy operations.
  // MSVC 2015 has adopted the standards conforming behavior.
  bool DeletesOnlyMatchingCopy =
      getLangOpts().MSVCCompat &&
      !getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015);

  if (RD->hasUserDeclaredMoveConstructor() &&
      (!DeletesOnlyMatchingCopy || CSM == CXXCopyConstructor)) {
    if (!Diagnose) return true;

    // Find any user-declared move constructor.
    for (auto *I : RD->ctors()) {
      if (I->isMoveConstructor()) {
        UserDeclaredMove = I;
        break;
      }
    }
    assert(UserDeclaredMove)(static_cast <bool> (UserDeclaredMove) ? void (0) : __assert_fail
 ("UserDeclaredMove", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6983, __extension__ __PRETTY_FUNCTION__));
  } else if (RD->hasUserDeclaredMoveAssignment() &&
             (!DeletesOnlyMatchingCopy || CSM == CXXCopyAssignment)) {
    if (!Diagnose) return true;

    // Find any user-declared move assignment operator.
    for (auto *I : RD->methods()) {
      if (I->isMoveAssignmentOperator()) {
        UserDeclaredMove = I;
        break;
      }
    }
    assert(UserDeclaredMove)(static_cast <bool> (UserDeclaredMove) ? void (0) : __assert_fail
 ("UserDeclaredMove", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6995, __extension__ __PRETTY_FUNCTION__));
  }

  if (UserDeclaredMove) {
    Diag(UserDeclaredMove->getLocation(),
         diag::note_deleted_copy_user_declared_move)
      << (CSM == CXXCopyAssignment) << RD
      << UserDeclaredMove->isMoveAssignmentOperator();
    return true;
  }
}

// Do access control from the special member function
ContextRAII MethodContext(*this, MD);

// C++11 [class.dtor]p5:
// -- for a virtual destructor, lookup of the non-array deallocation function
//    results in an ambiguity or in a function that is deleted or inaccessible
if (CSM == CXXDestructor && MD->isVirtual()) {
  FunctionDecl *OperatorDelete = nullptr;
  DeclarationName Name =
    Context.DeclarationNames.getCXXOperatorName(OO_Delete);
  if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
                               OperatorDelete, /*Diagnose*/false)) {
    if (Diagnose)
      Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
    return true;
  }
}

SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);

// Per DR1611, do not consider virtual bases of constructors of abstract
// classes, since we are not going to construct them.
// Per DR1658, do not consider virtual bases of destructors of abstract
// classes either.
// Per DR2180, for assignment operators we only assign (and thus only
// consider) direct bases.
if (SMI.visit(SMI.IsAssignment ? SMI.VisitDirectBases
                               : SMI.VisitPotentiallyConstructedBases))
  return true;

if (SMI.shouldDeleteForAllConstMembers())
  return true;

if (getLangOpts().CUDA) {
  // We should delete the special member in CUDA mode if target inference
  // failed.
  return inferCUDATargetForImplicitSpecialMember(RD, CSM, MD, SMI.ConstArg,
                                                 Diagnose);
}

return false;
7048}

7050/// Perform lookup for a special member of the specified kind, and determine
7051/// whether it is trivial. If the triviality can be determined without the
7052/// lookup, skip it. This is intended for use when determining whether a
7053/// special member of a containing object is trivial, and thus does not ever
7054/// perform overload resolution for default constructors.
7055///
7056/// If \p Selected is not \c NULL, \c *Selected will be filled in with the
7057/// member that was most likely to be intended to be trivial, if any.
7058///
7059/// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
7060/// determine whether the special member is trivial.
7061static bool findTrivialSpecialMember(Sema &S, CXXRecordDecl *RD,
                                   Sema::CXXSpecialMember CSM, unsigned Quals,
                                   bool ConstRHS,
                                   Sema::TrivialABIHandling TAH,
                                   CXXMethodDecl **Selected) {
if (Selected)
  *Selected = nullptr;

switch (CSM) {
case Sema::CXXInvalid:
  llvm_unreachable("not a special member")::llvm::llvm_unreachable_internal("not a special member", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7071);

case Sema::CXXDefaultConstructor:
  // C++11 [class.ctor]p5:
  //   A default constructor is trivial if:
  //    - all the [direct subobjects] have trivial default constructors
  //
  // Note, no overload resolution is performed in this case.
  if (RD->hasTrivialDefaultConstructor())
    return true;

  if (Selected) {
    // If there's a default constructor which could have been trivial, dig it
    // out. Otherwise, if there's any user-provided default constructor, point
    // to that as an example of why there's not a trivial one.
    CXXConstructorDecl *DefCtor = nullptr;
    if (RD->needsImplicitDefaultConstructor())
      S.DeclareImplicitDefaultConstructor(RD);
    for (auto *CI : RD->ctors()) {
      if (!CI->isDefaultConstructor())
        continue;
      DefCtor = CI;
      if (!DefCtor->isUserProvided())
        break;
    }

    *Selected = DefCtor;
  }

  return false;

case Sema::CXXDestructor:
  // C++11 [class.dtor]p5:
  //   A destructor is trivial if:
  //    - all the direct [subobjects] have trivial destructors
  if (RD->hasTrivialDestructor() ||
      (TAH == Sema::TAH_ConsiderTrivialABI &&
       RD->hasTrivialDestructorForCall()))
    return true;

  if (Selected) {
    if (RD->needsImplicitDestructor())
      S.DeclareImplicitDestructor(RD);
    *Selected = RD->getDestructor();
  }

  return false;

case Sema::CXXCopyConstructor:
  // C++11 [class.copy]p12:
  //   A copy constructor is trivial if:
  //    - the constructor selected to copy each direct [subobject] is trivial
  if (RD->hasTrivialCopyConstructor() ||
      (TAH == Sema::TAH_ConsiderTrivialABI &&
       RD->hasTrivialCopyConstructorForCall())) {
    if (Quals == Qualifiers::Const)
      // We must either select the trivial copy constructor or reach an
      // ambiguity; no need to actually perform overload resolution.
      return true;
  } else if (!Selected) {
    return false;
  }
  // In C++98, we are not supposed to perform overload resolution here, but we
  // treat that as a language defect, as suggested on cxx-abi-dev, to treat
  // cases like B as having a non-trivial copy constructor:
  //   struct A { template<typename T> A(T&); };
  //   struct B { mutable A a; };
  goto NeedOverloadResolution;

case Sema::CXXCopyAssignment:
  // C++11 [class.copy]p25:
  //   A copy assignment operator is trivial if:
  //    - the assignment operator selected to copy each direct [subobject] is
  //      trivial
  if (RD->hasTrivialCopyAssignment()) {
    if (Quals == Qualifiers::Const)
      return true;
  } else if (!Selected) {
    return false;
  }
  // In C++98, we are not supposed to perform overload resolution here, but we
  // treat that as a language defect.
  goto NeedOverloadResolution;

case Sema::CXXMoveConstructor:
case Sema::CXXMoveAssignment:
NeedOverloadResolution:
  Sema::SpecialMemberOverloadResult SMOR =
      lookupCallFromSpecialMember(S, RD, CSM, Quals, ConstRHS);

  // The standard doesn't describe how to behave if the lookup is ambiguous.
  // We treat it as not making the member non-trivial, just like the standard
  // mandates for the default constructor. This should rarely matter, because
  // the member will also be deleted.
  if (SMOR.getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
    return true;

  if (!SMOR.getMethod()) {
    assert(SMOR.getKind() ==(static_cast <bool> (SMOR.getKind() == Sema::SpecialMemberOverloadResult
::NoMemberOrDeleted) ? void (0) : __assert_fail ("SMOR.getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7170, __extension__ __PRETTY_FUNCTION__))
           Sema::SpecialMemberOverloadResult::NoMemberOrDeleted)(static_cast <bool> (SMOR.getKind() == Sema::SpecialMemberOverloadResult
::NoMemberOrDeleted) ? void (0) : __assert_fail ("SMOR.getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7170, __extension__ __PRETTY_FUNCTION__));
    return false;
  }

  // We deliberately don't check if we found a deleted special member. We're
  // not supposed to!
  if (Selected)
    *Selected = SMOR.getMethod();

  if (TAH == Sema::TAH_ConsiderTrivialABI &&
      (CSM == Sema::CXXCopyConstructor || CSM == Sema::CXXMoveConstructor))
    return SMOR.getMethod()->isTrivialForCall();
  return SMOR.getMethod()->isTrivial();
}

llvm_unreachable("unknown special method kind")::llvm::llvm_unreachable_internal("unknown special method kind"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7185);
7186}

7188static CXXConstructorDecl *findUserDeclaredCtor(CXXRecordDecl *RD) {
for (auto *CI : RD->ctors())
  if (!CI->isImplicit())
    return CI;

// Look for constructor templates.
typedef CXXRecordDecl::specific_decl_iterator<FunctionTemplateDecl> tmpl_iter;
for (tmpl_iter TI(RD->decls_begin()), TE(RD->decls_end()); TI != TE; ++TI) {
  if (CXXConstructorDecl *CD =
        dyn_cast<CXXConstructorDecl>(TI->getTemplatedDecl()))
    return CD;
}

return nullptr;
7202}

7204/// The kind of subobject we are checking for triviality. The values of this
7205/// enumeration are used in diagnostics.
7206enum TrivialSubobjectKind {
/// The subobject is a base class.
TSK_BaseClass,
/// The subobject is a non-static data member.
TSK_Field,
/// The object is actually the complete object.
TSK_CompleteObject
7213};

7215/// Check whether the special member selected for a given type would be trivial.
7216static bool checkTrivialSubobjectCall(Sema &S, SourceLocation SubobjLoc,
                                    QualType SubType, bool ConstRHS,
                                    Sema::CXXSpecialMember CSM,
                                    TrivialSubobjectKind Kind,
                                    Sema::TrivialABIHandling TAH, bool Diagnose) {
CXXRecordDecl *SubRD = SubType->getAsCXXRecordDecl();
if (!SubRD)
  return true;

CXXMethodDecl *Selected;
if (findTrivialSpecialMember(S, SubRD, CSM, SubType.getCVRQualifiers(),
                             ConstRHS, TAH, Diagnose ? &Selected : nullptr))
  return true;

if (Diagnose) {
  if (ConstRHS)
    SubType.addConst();

  if (!Selected && CSM == Sema::CXXDefaultConstructor) {
    S.Diag(SubobjLoc, diag::note_nontrivial_no_def_ctor)
      << Kind << SubType.getUnqualifiedType();
    if (CXXConstructorDecl *CD = findUserDeclaredCtor(SubRD))
      S.Diag(CD->getLocation(), diag::note_user_declared_ctor);
  } else if (!Selected)
    S.Diag(SubobjLoc, diag::note_nontrivial_no_copy)
      << Kind << SubType.getUnqualifiedType() << CSM << SubType;
  else if (Selected->isUserProvided()) {
    if (Kind == TSK_CompleteObject)
      S.Diag(Selected->getLocation(), diag::note_nontrivial_user_provided)
        << Kind << SubType.getUnqualifiedType() << CSM;
    else {
      S.Diag(SubobjLoc, diag::note_nontrivial_user_provided)
        << Kind << SubType.getUnqualifiedType() << CSM;
      S.Diag(Selected->getLocation(), diag::note_declared_at);
    }
  } else {
    if (Kind != TSK_CompleteObject)
      S.Diag(SubobjLoc, diag::note_nontrivial_subobject)
        << Kind << SubType.getUnqualifiedType() << CSM;

    // Explain why the defaulted or deleted special member isn't trivial.
    S.SpecialMemberIsTrivial(Selected, CSM, Sema::TAH_IgnoreTrivialABI,
                             Diagnose);
  }
}

return false;
7263}

7265/// Check whether the members of a class type allow a special member to be
7266/// trivial.
7267static bool checkTrivialClassMembers(Sema &S, CXXRecordDecl *RD,
                                   Sema::CXXSpecialMember CSM,
                                   bool ConstArg,
                                   Sema::TrivialABIHandling TAH,
                                   bool Diagnose) {
for (const auto *FI : RD->fields()) {
  if (FI->isInvalidDecl() || FI->isUnnamedBitfield())
    continue;

  QualType FieldType = S.Context.getBaseElementType(FI->getType());

  // Pretend anonymous struct or union members are members of this class.
  if (FI->isAnonymousStructOrUnion()) {
    if (!checkTrivialClassMembers(S, FieldType->getAsCXXRecordDecl(),
                                  CSM, ConstArg, TAH, Diagnose))
      return false;
    continue;
  }

  // C++11 [class.ctor]p5:
  //   A default constructor is trivial if [...]
  //    -- no non-static data member of its class has a
  //       brace-or-equal-initializer
  if (CSM == Sema::CXXDefaultConstructor && FI->hasInClassInitializer()) {
    if (Diagnose)
      S.Diag(FI->getLocation(), diag::note_nontrivial_in_class_init) << FI;
    return false;
  }

  // Objective C ARC 4.3.5:
  //   [...] nontrivally ownership-qualified types are [...] not trivially
  //   default constructible, copy constructible, move constructible, copy
  //   assignable, move assignable, or destructible [...]
  if (FieldType.hasNonTrivialObjCLifetime()) {
    if (Diagnose)
      S.Diag(FI->getLocation(), diag::note_nontrivial_objc_ownership)
        << RD << FieldType.getObjCLifetime();
    return false;
  }

  bool ConstRHS = ConstArg && !FI->isMutable();
  if (!checkTrivialSubobjectCall(S, FI->getLocation(), FieldType, ConstRHS,
                                 CSM, TSK_Field, TAH, Diagnose))
    return false;
}

return true;
7314}

7316/// Diagnose why the specified class does not have a trivial special member of
7317/// the given kind.
7318void Sema::DiagnoseNontrivial(const CXXRecordDecl *RD, CXXSpecialMember CSM) {
QualType Ty = Context.getRecordType(RD);

bool ConstArg = (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment);
checkTrivialSubobjectCall(*this, RD->getLocation(), Ty, ConstArg, CSM,
                          TSK_CompleteObject, TAH_IgnoreTrivialABI,
                          /*Diagnose*/true);
7325}

7327/// Determine whether a defaulted or deleted special member function is trivial,
7328/// as specified in C++11 [class.ctor]p5, C++11 [class.copy]p12,
7329/// C++11 [class.copy]p25, and C++11 [class.dtor]p5.
7330bool Sema::SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
                                TrivialABIHandling TAH, bool Diagnose) {
assert(!MD->isUserProvided() && CSM != CXXInvalid && "not special enough")(static_cast <bool> (!MD->isUserProvided() &&
 CSM != CXXInvalid && "not special enough") ? void (0
) : __assert_fail ("!MD->isUserProvided() && CSM != CXXInvalid && \"not special enough\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7332, __extension__ __PRETTY_FUNCTION__));

CXXRecordDecl *RD = MD->getParent();

bool ConstArg = false;

// C++11 [class.copy]p12, p25: [DR1593]
//   A [special member] is trivial if [...] its parameter-type-list is
//   equivalent to the parameter-type-list of an implicit declaration [...]
switch (CSM) {
case CXXDefaultConstructor:
case CXXDestructor:
  // Trivial default constructors and destructors cannot have parameters.
  break;

case CXXCopyConstructor:
case CXXCopyAssignment: {
  // Trivial copy operations always have const, non-volatile parameter types.
  ConstArg = true;
  const ParmVarDecl *Param0 = MD->getParamDecl(0);
  const ReferenceType *RT = Param0->getType()->getAs<ReferenceType>();
  if (!RT || RT->getPointeeType().getCVRQualifiers() != Qualifiers::Const) {
    if (Diagnose)
      Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
        << Param0->getSourceRange() << Param0->getType()
        << Context.getLValueReferenceType(
             Context.getRecordType(RD).withConst());
    return false;
  }
  break;
}

case CXXMoveConstructor:
case CXXMoveAssignment: {
  // Trivial move operations always have non-cv-qualified parameters.
  const ParmVarDecl *Param0 = MD->getParamDecl(0);
  const RValueReferenceType *RT =
    Param0->getType()->getAs<RValueReferenceType>();
  if (!RT || RT->getPointeeType().getCVRQualifiers()) {
    if (Diagnose)
      Diag(Param0->getLocation(), diag::note_nontrivial_param_type)
        << Param0->getSourceRange() << Param0->getType()
        << Context.getRValueReferenceType(Context.getRecordType(RD));
    return false;
  }
  break;
}

case CXXInvalid:
  llvm_unreachable("not a special member")::llvm::llvm_unreachable_internal("not a special member", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7381);
}

if (MD->getMinRequiredArguments() < MD->getNumParams()) {
  if (Diagnose)
    Diag(MD->getParamDecl(MD->getMinRequiredArguments())->getLocation(),
         diag::note_nontrivial_default_arg)
      << MD->getParamDecl(MD->getMinRequiredArguments())->getSourceRange();
  return false;
}
if (MD->isVariadic()) {
  if (Diagnose)
    Diag(MD->getLocation(), diag::note_nontrivial_variadic);
  return false;
}

// C++11 [class.ctor]p5, C++11 [class.dtor]p5:
//   A copy/move [constructor or assignment operator] is trivial if
//    -- the [member] selected to copy/move each direct base class subobject
//       is trivial
//
// C++11 [class.copy]p12, C++11 [class.copy]p25:
//   A [default constructor or destructor] is trivial if
//    -- all the direct base classes have trivial [default constructors or
//       destructors]
for (const auto &BI : RD->bases())
  if (!checkTrivialSubobjectCall(*this, BI.getLocStart(), BI.getType(),
                                 ConstArg, CSM, TSK_BaseClass, TAH, Diagnose))
    return false;

// C++11 [class.ctor]p5, C++11 [class.dtor]p5:
//   A copy/move [constructor or assignment operator] for a class X is
//   trivial if
//    -- for each non-static data member of X that is of class type (or array
//       thereof), the constructor selected to copy/move that member is
//       trivial
//
// C++11 [class.copy]p12, C++11 [class.copy]p25:
//   A [default constructor or destructor] is trivial if
//    -- for all of the non-static data members of its class that are of class
//       type (or array thereof), each such class has a trivial [default
//       constructor or destructor]
if (!checkTrivialClassMembers(*this, RD, CSM, ConstArg, TAH, Diagnose))
  return false;

// C++11 [class.dtor]p5:
//   A destructor is trivial if [...]
//    -- the destructor is not virtual
if (CSM == CXXDestructor && MD->isVirtual()) {
  if (Diagnose)
    Diag(MD->getLocation(), diag::note_nontrivial_virtual_dtor) << RD;
  return false;
}

// C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
//   A [special member] for class X is trivial if [...]
//    -- class X has no virtual functions and no virtual base classes
if (CSM != CXXDestructor && MD->getParent()->isDynamicClass()) {
  if (!Diagnose)
    return false;

  if (RD->getNumVBases()) {
    // Check for virtual bases. We already know that the corresponding
    // member in all bases is trivial, so vbases must all be direct.
    CXXBaseSpecifier &BS = *RD->vbases_begin();
    assert(BS.isVirtual())(static_cast <bool> (BS.isVirtual()) ? void (0) : __assert_fail
 ("BS.isVirtual()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7446, __extension__ __PRETTY_FUNCTION__));
    Diag(BS.getLocStart(), diag::note_nontrivial_has_virtual) << RD << 1;
    return false;
  }

  // Must have a virtual method.
  for (const auto *MI : RD->methods()) {
    if (MI->isVirtual()) {
      SourceLocation MLoc = MI->getLocStart();
      Diag(MLoc, diag::note_nontrivial_has_virtual) << RD << 0;
      return false;
    }
  }

  llvm_unreachable("dynamic class with no vbases and no virtual functions")::llvm::llvm_unreachable_internal("dynamic class with no vbases and no virtual functions"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7460);
}

// Looks like it's trivial!
return true;
7465}

7467namespace {
7468struct FindHiddenVirtualMethod {
Sema *S;
CXXMethodDecl *Method;
llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
SmallVector<CXXMethodDecl *, 8> OverloadedMethods;

7474private:
/// Check whether any most overriden method from MD in Methods
static bool CheckMostOverridenMethods(
    const CXXMethodDecl *MD,
    const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {
  if (MD->size_overridden_methods() == 0)
    return Methods.count(MD->getCanonicalDecl());
  for (const CXXMethodDecl *O : MD->overridden_methods())
    if (CheckMostOverridenMethods(O, Methods))
      return true;
  return false;
}

7487public:
/// Member lookup function that determines whether a given C++
/// method overloads virtual methods in a base class without overriding any,
/// to be used with CXXRecordDecl::lookupInBases().
bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
  RecordDecl *BaseRecord =
      Specifier->getType()->getAs<RecordType>()->getDecl();

  DeclarationName Name = Method->getDeclName();
  assert(Name.getNameKind() == DeclarationName::Identifier)(static_cast <bool> (Name.getNameKind() == DeclarationName
::Identifier) ? void (0) : __assert_fail ("Name.getNameKind() == DeclarationName::Identifier"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 7496, __extension__ __PRETTY_FUNCTION__));

  bool foundSameNameMethod = false;
  SmallVector<CXXMethodDecl *, 8> overloadedMethods;
  for (Path.Decls = BaseRecord->lookup(Name); !Path.Decls.empty();
       Path.Decls = Path.Decls.slice(1)) {
    NamedDecl *D = Path.Decls.front();
    if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
      MD = MD->getCanonicalDecl();
      foundSameNameMethod = true;
      // Interested only in hidden virtual methods.
      if (!MD->isVirtual())
        continue;
      // If the method we are checking overrides a method from its base
      // don't warn about the other overloaded methods. Clang deviates from
      // GCC by only diagnosing overloads of inherited virtual functions that
      // do not override any other virtual functions in the base. GCC's
      // -Woverloaded-virtual diagnoses any derived function hiding a virtual
      // function from a base class. These cases may be better served by a
      // warning (not specific to virtual functions) on call sites when the
      // call would select a different function from the base class, were it
      // visible.
      // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example.
      if (!S->IsOverload(Method, MD, false))
        return true;
      // Collect the overload only if its hidden.
      if (!CheckMostOverridenMethods(MD, OverridenAndUsingBaseMethods))
        overloadedMethods.push_back(MD);
    }
  }

  if (foundSameNameMethod)
    OverloadedMethods.append(overloadedMethods.begin(),
                             overloadedMethods.end());
  return foundSameNameMethod;
}
7532};
7533} // end anonymous namespace

7535/// \brief Add the most overriden methods from MD to Methods
7536static void AddMostOverridenMethods(const CXXMethodDecl *MD,
                      llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
if (MD->size_overridden_methods() == 0)
  Methods.insert(MD->getCanonicalDecl());
else
  for (const CXXMethodDecl *O : MD->overridden_methods())
    AddMostOverridenMethods(O, Methods);
7543}

7545/// \brief Check if a method overloads virtual methods in a base class without
7546/// overriding any.
7547void Sema::FindHiddenVirtualMethods(CXXMethodDecl *MD,
                        SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
if (!MD->getDeclName().isIdentifier())
  return;

CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
                   /*bool RecordPaths=*/false,
                   /*bool DetectVirtual=*/false);
FindHiddenVirtualMethod FHVM;
FHVM.Method = MD;
FHVM.S = this;

// Keep the base methods that were overriden or introduced in the subclass
// by 'using' in a set. A base method not in this set is hidden.
CXXRecordDecl *DC = MD->getParent();
DeclContext::lookup_result R = DC->lookup(MD->getDeclName());
for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
  NamedDecl *ND = *I;
  if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
    ND = shad->getTargetDecl();
  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
    AddMostOverridenMethods(MD, FHVM.OverridenAndUsingBaseMethods);
}

if (DC->lookupInBases(FHVM, Paths))
  OverloadedMethods = FHVM.OverloadedMethods;
7573}

7575void Sema::NoteHiddenVirtualMethods(CXXMethodDecl *MD,
                        SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) {
for (unsigned i = 0, e = OverloadedMethods.size(); i != e; ++i) {
  CXXMethodDecl *overloadedMD = OverloadedMethods[i];
  PartialDiagnostic PD = PDiag(
       diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
  HandleFunctionTypeMismatch(PD, MD->getType(), overloadedMD->getType());
  Diag(overloadedMD->getLocation(), PD);
}
7584}

7586/// \brief Diagnose methods which overload virtual methods in a base class
7587/// without overriding any.
7588void Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) {
if (MD->isInvalidDecl())
  return;

if (Diags.isIgnored(diag::warn_overloaded_virtual, MD->getLocation()))
  return;

SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
FindHiddenVirtualMethods(MD, OverloadedMethods);
if (!OverloadedMethods.empty()) {
  Diag(MD->getLocation(), diag::warn_overloaded_virtual)
    << MD << (OverloadedMethods.size() > 1);

  NoteHiddenVirtualMethods(MD, OverloadedMethods);
}
7603}

7605void Sema::checkIllFormedTrivialABIStruct(CXXRecordDecl &RD) {
auto PrintDiagAndRemoveAttr = [&]() {
  // No diagnostics if this is a template instantiation.
  if (!isTemplateInstantiation(RD.getTemplateSpecializationKind()))
    Diag(RD.getAttr<TrivialABIAttr>()->getLocation(),
         diag::ext_cannot_use_trivial_abi) << &RD;
  RD.dropAttr<TrivialABIAttr>();
};

// Ill-formed if the struct has virtual functions.
if (RD.isPolymorphic()) {
  PrintDiagAndRemoveAttr();
  return;
}

for (const auto &B : RD.bases()) {
  // Ill-formed if the base class is non-trivial for the purpose of calls or a
  // virtual base.
  if ((!B.getType()->isDependentType() &&
       !B.getType()->getAsCXXRecordDecl()->canPassInRegisters()) ||
      B.isVirtual()) {
    PrintDiagAndRemoveAttr();
    return;
  }
}

for (const auto *FD : RD.fields()) {
  // Ill-formed if the field is an ObjectiveC pointer or of a type that is
  // non-trivial for the purpose of calls.
  QualType FT = FD->getType();
  if (FT.getObjCLifetime() == Qualifiers::OCL_Weak) {
    PrintDiagAndRemoveAttr();
    return;
  }

  if (const auto *RT = FT->getBaseElementTypeUnsafe()->getAs<RecordType>())
    if (!RT->isDependentType() &&
        !cast<CXXRecordDecl>(RT->getDecl())->canPassInRegisters()) {
      PrintDiagAndRemoveAttr();
      return;
    }
}
7647}

7649void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
                                           Decl *TagDecl,
                                           SourceLocation LBrac,
                                           SourceLocation RBrac,
                                           AttributeList *AttrList) {
if (!TagDecl)
  return;

AdjustDeclIfTemplate(TagDecl);

for (const AttributeList* l = AttrList; l; l = l->getNext()) {
  if (l->getKind() != AttributeList::AT_Visibility)
    continue;
  l->setInvalid();
  Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) <<
    l->getName();
}

// See if trivial_abi has to be dropped.
auto *RD = dyn_cast<CXXRecordDecl>(TagDecl);
if (RD && RD->hasAttr<TrivialABIAttr>())
  checkIllFormedTrivialABIStruct(*RD);

ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
            // strict aliasing violation!
            reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
            FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);

CheckCompletedCXXClass(RD);
7678}

7680/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
7681/// special functions, such as the default constructor, copy
7682/// constructor, or destructor, to the given C++ class (C++
7683/// [special]p1).  This routine can only be executed just before the
7684/// definition of the class is complete.
7685void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
if (ClassDecl->needsImplicitDefaultConstructor()) {
  ++ASTContext::NumImplicitDefaultConstructors;

  if (ClassDecl->hasInheritedConstructor())
    DeclareImplicitDefaultConstructor(ClassDecl);
}

if (ClassDecl->needsImplicitCopyConstructor()) {
  ++ASTContext::NumImplicitCopyConstructors;

  // If the properties or semantics of the copy constructor couldn't be
  // determined while the class was being declared, force a declaration
  // of it now.
  if (ClassDecl->needsOverloadResolutionForCopyConstructor() ||
      ClassDecl->hasInheritedConstructor())
    DeclareImplicitCopyConstructor(ClassDecl);
  // For the MS ABI we need to know whether the copy ctor is deleted. A
  // prerequisite for deleting the implicit copy ctor is that the class has a
  // move ctor or move assignment that is either user-declared or whose
  // semantics are inherited from a subobject. FIXME: We should provide a more
  // direct way for CodeGen to ask whether the constructor was deleted.
  else if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
           (ClassDecl->hasUserDeclaredMoveConstructor() ||
            ClassDecl->needsOverloadResolutionForMoveConstructor() ||
            ClassDecl->hasUserDeclaredMoveAssignment() ||
            ClassDecl->needsOverloadResolutionForMoveAssignment()))
    DeclareImplicitCopyConstructor(ClassDecl);
}

if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveConstructor()) {
  ++ASTContext::NumImplicitMoveConstructors;

  if (ClassDecl->needsOverloadResolutionForMoveConstructor() ||
      ClassDecl->hasInheritedConstructor())
    DeclareImplicitMoveConstructor(ClassDecl);
}

if (ClassDecl->needsImplicitCopyAssignment()) {
  ++ASTContext::NumImplicitCopyAssignmentOperators;

  // If we have a dynamic class, then the copy assignment operator may be
  // virtual, so we have to declare it immediately. This ensures that, e.g.,
  // it shows up in the right place in the vtable and that we diagnose
  // problems with the implicit exception specification.
  if (ClassDecl->isDynamicClass() ||
      ClassDecl->needsOverloadResolutionForCopyAssignment() ||
      ClassDecl->hasInheritedAssignment())
    DeclareImplicitCopyAssignment(ClassDecl);
}

if (getLangOpts().CPlusPlus11 && ClassDecl->needsImplicitMoveAssignment()) {
  ++ASTContext::NumImplicitMoveAssignmentOperators;

  // Likewise for the move assignment operator.
  if (ClassDecl->isDynamicClass() ||
      ClassDecl->needsOverloadResolutionForMoveAssignment() ||
      ClassDecl->hasInheritedAssignment())
    DeclareImplicitMoveAssignment(ClassDecl);
}

if (ClassDecl->needsImplicitDestructor()) {
  ++ASTContext::NumImplicitDestructors;

  // If we have a dynamic class, then the destructor may be virtual, so we
  // have to declare the destructor immediately. This ensures that, e.g., it
  // shows up in the right place in the vtable and that we diagnose problems
  // with the implicit exception specification.
  if (ClassDecl->isDynamicClass() ||
      ClassDecl->needsOverloadResolutionForDestructor())
    DeclareImplicitDestructor(ClassDecl);
}
7757}

7759unsigned Sema::ActOnReenterTemplateScope(Scope *S, Decl *D) {
if (!D)
  return 0;

// The order of template parameters is not important here. All names
// get added to the same scope.
SmallVector<TemplateParameterList *, 4> ParameterLists;

if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
  D = TD->getTemplatedDecl();

if (auto *PSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
  ParameterLists.push_back(PSD->getTemplateParameters());

if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
  for (unsigned i = 0; i < DD->getNumTemplateParameterLists(); ++i)
    ParameterLists.push_back(DD->getTemplateParameterList(i));

  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
    if (FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
      ParameterLists.push_back(FTD->getTemplateParameters());
  }
}

if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
  for (unsigned i = 0; i < TD->getNumTemplateParameterLists(); ++i)
    ParameterLists.push_back(TD->getTemplateParameterList(i));

  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD)) {
    if (ClassTemplateDecl *CTD = RD->getDescribedClassTemplate())
      ParameterLists.push_back(CTD->getTemplateParameters());
  }
}

unsigned Count = 0;
for (TemplateParameterList *Params : ParameterLists) {
  if (Params->size() > 0)
    // Ignore explicit specializations; they don't contribute to the template
    // depth.
    ++Count;
  for (NamedDecl *Param : *Params) {
    if (Param->getDeclName()) {
      S->AddDecl(Param);
      IdResolver.AddDecl(Param);
    }
  }
}

return Count;
7808}

7810void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
if (!RecordD) return;
AdjustDeclIfTemplate(RecordD);
CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
PushDeclContext(S, Record);
7815}

7817void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
if (!RecordD) return;
PopDeclContext();
7820}

7822/// This is used to implement the constant expression evaluation part of the
7823/// attribute enable_if extension. There is nothing in standard C++ which would
7824/// require reentering parameters.
7825void Sema::ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param) {
if (!Param)
  return;

S->AddDecl(Param);
if (Param->getDeclName())
  IdResolver.AddDecl(Param);
7832}

7834/// ActOnStartDelayedCXXMethodDeclaration - We have completed
7835/// parsing a top-level (non-nested) C++ class, and we are now
7836/// parsing those parts of the given Method declaration that could
7837/// not be parsed earlier (C++ [class.mem]p2), such as default
7838/// arguments. This action should enter the scope of the given
7839/// Method declaration as if we had just parsed the qualified method
7840/// name. However, it should not bring the parameters into scope;
7841/// that will be performed by ActOnDelayedCXXMethodParameter.
7842void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
7843}

7845/// ActOnDelayedCXXMethodParameter - We've already started a delayed
7846/// C++ method declaration. We're (re-)introducing the given
7847/// function parameter into scope for use in parsing later parts of
7848/// the method declaration. For example, we could see an
7849/// ActOnParamDefaultArgument event for this parameter.
7850void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) {
if (!ParamD)
  return;

ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);

// If this parameter has an unparsed default argument, clear it out
// to make way for the parsed default argument.
if (Param->hasUnparsedDefaultArg())
  Param->setDefaultArg(nullptr);

S->AddDecl(Param);
if (Param->getDeclName())
  IdResolver.AddDecl(Param);
7864}

7866/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
7867/// processing the delayed method declaration for Method. The method
7868/// declaration is now considered finished. There may be a separate
7869/// ActOnStartOfFunctionDef action later (not necessarily
7870/// immediately!) for this method, if it was also defined inside the
7871/// class body.
7872void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
if (!MethodD)
  return;

AdjustDeclIfTemplate(MethodD);

FunctionDecl *Method = cast<FunctionDecl>(MethodD);

// Now that we have our default arguments, check the constructor
// again. It could produce additional diagnostics or affect whether
// the class has implicitly-declared destructors, among other
// things.
if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
  CheckConstructor(Constructor);

// Check the default arguments, which we may have added.
if (!Method->isInvalidDecl())
  CheckCXXDefaultArguments(Method);
7890}

7892/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
7893/// the well-formedness of the constructor declarator @p D with type @p
7894/// R. If there are any errors in the declarator, this routine will
7895/// emit diagnostics and set the invalid bit to true.  In any case, the type
7896/// will be updated to reflect a well-formed type for the constructor and
7897/// returned.
7898QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
                                        StorageClass &SC) {
bool isVirtual = D.getDeclSpec().isVirtualSpecified();

// C++ [class.ctor]p3:
//   A constructor shall not be virtual (10.3) or static (9.4). A
//   constructor can be invoked for a const, volatile or const
//   volatile object. A constructor shall not be declared const,
//   volatile, or const volatile (9.3.2).
if (isVirtual) {
  if (!D.isInvalidType())
    Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
      << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
      << SourceRange(D.getIdentifierLoc());
  D.setInvalidType();
}
if (SC == SC_Static) {
  if (!D.isInvalidType())
    Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
      << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
      << SourceRange(D.getIdentifierLoc());
  D.setInvalidType();
  SC = SC_None;
}

if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
  diagnoseIgnoredQualifiers(
      diag::err_constructor_return_type, TypeQuals, SourceLocation(),
      D.getDeclSpec().getConstSpecLoc(), D.getDeclSpec().getVolatileSpecLoc(),
      D.getDeclSpec().getRestrictSpecLoc(),
      D.getDeclSpec().getAtomicSpecLoc());
  D.setInvalidType();
}

DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
if (FTI.TypeQuals != 0) {
  if (FTI.TypeQuals & Qualifiers::Const)
    Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
      << "const" << SourceRange(D.getIdentifierLoc());
  if (FTI.TypeQuals & Qualifiers::Volatile)
    Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
      << "volatile" << SourceRange(D.getIdentifierLoc());
  if (FTI.TypeQuals & Qualifiers::Restrict)
    Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
      << "restrict" << SourceRange(D.getIdentifierLoc());
  D.setInvalidType();
}

// C++0x [class.ctor]p4:
//   A constructor shall not be declared with a ref-qualifier.
if (FTI.hasRefQualifier()) {
  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
    << FTI.RefQualifierIsLValueRef
    << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
  D.setInvalidType();
}

// Rebuild the function type "R" without any type qualifiers (in
// case any of the errors above fired) and with "void" as the
// return type, since constructors don't have return types.
const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
if (Proto->getReturnType() == Context.VoidTy && !D.isInvalidType())
  return R;

FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
EPI.TypeQuals = 0;
EPI.RefQualifier = RQ_None;

return Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(), EPI);
7967}

7969/// CheckConstructor - Checks a fully-formed constructor for
7970/// well-formedness, issuing any diagnostics required. Returns true if
7971/// the constructor declarator is invalid.
7972void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
CXXRecordDecl *ClassDecl
  = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
if (!ClassDecl)
  return Constructor->setInvalidDecl();

// C++ [class.copy]p3:
//   A declaration of a constructor for a class X is ill-formed if
//   its first parameter is of type (optionally cv-qualified) X and
//   either there are no other parameters or else all other
//   parameters have default arguments.
if (!Constructor->isInvalidDecl() &&
    ((Constructor->getNumParams() == 1) ||
     (Constructor->getNumParams() > 1 &&
      Constructor->getParamDecl(1)->hasDefaultArg())) &&
    Constructor->getTemplateSpecializationKind()
                                            != TSK_ImplicitInstantiation) {
  QualType ParamType = Constructor->getParamDecl(0)->getType();
  QualType ClassTy = Context.getTagDeclType(ClassDecl);
  if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
    SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
    const char *ConstRef
      = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
                                                      : " const &";
    Diag(ParamLoc, diag::err_constructor_byvalue_arg)
      << FixItHint::CreateInsertion(ParamLoc, ConstRef);

    // FIXME: Rather that making the constructor invalid, we should endeavor
    // to fix the type.
    Constructor->setInvalidDecl();
  }
}
8004}

8006/// CheckDestructor - Checks a fully-formed destructor definition for
8007/// well-formedness, issuing any diagnostics required.  Returns true
8008/// on error.
8009bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
CXXRecordDecl *RD = Destructor->getParent();

if (!Destructor->getOperatorDelete() && Destructor->isVirtual()) {
  SourceLocation Loc;

  if (!Destructor->isImplicit())
    Loc = Destructor->getLocation();
  else
    Loc = RD->getLocation();

  // If we have a virtual destructor, look up the deallocation function
  if (FunctionDecl *OperatorDelete =
          FindDeallocationFunctionForDestructor(Loc, RD)) {
    Expr *ThisArg = nullptr;

    // If the notional 'delete this' expression requires a non-trivial
    // conversion from 'this' to the type of a destroying operator delete's
    // first parameter, perform that conversion now.
    if (OperatorDelete->isDestroyingOperatorDelete()) {
      QualType ParamType = OperatorDelete->getParamDecl(0)->getType();
      if (!declaresSameEntity(ParamType->getAsCXXRecordDecl(), RD)) {
        // C++ [class.dtor]p13:
        //   ... as if for the expression 'delete this' appearing in a
        //   non-virtual destructor of the destructor's class.
        ContextRAII SwitchContext(*this, Destructor);
        ExprResult This =
            ActOnCXXThis(OperatorDelete->getParamDecl(0)->getLocation());
        assert(!This.isInvalid() && "couldn't form 'this' expr in dtor?")(static_cast <bool> (!This.isInvalid() && "couldn't form 'this' expr in dtor?"
) ? void (0) : __assert_fail ("!This.isInvalid() && \"couldn't form 'this' expr in dtor?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8037, __extension__ __PRETTY_FUNCTION__));
        This = PerformImplicitConversion(This.get(), ParamType, AA_Passing);
        if (This.isInvalid()) {
          // FIXME: Register this as a context note so that it comes out
          // in the right order.
          Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
          return true;
        }
        ThisArg = This.get();
      }
    }

    MarkFunctionReferenced(Loc, OperatorDelete);
    Destructor->setOperatorDelete(OperatorDelete, ThisArg);
  }
}

return false;
8055}

8057/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
8058/// the well-formednes of the destructor declarator @p D with type @p
8059/// R. If there are any errors in the declarator, this routine will
8060/// emit diagnostics and set the declarator to invalid.  Even if this happens,
8061/// will be updated to reflect a well-formed type for the destructor and
8062/// returned.
8063QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
                                       StorageClass& SC) {
// C++ [class.dtor]p1:
//   [...] A typedef-name that names a class is a class-name
//   (7.1.3); however, a typedef-name that names a class shall not
//   be used as the identifier in the declarator for a destructor
//   declaration.
QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
  Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
    << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
else if (const TemplateSpecializationType *TST =
           DeclaratorType->getAs<TemplateSpecializationType>())
  if (TST->isTypeAlias())
    Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
      << DeclaratorType << 1;

// C++ [class.dtor]p2:
//   A destructor is used to destroy objects of its class type. A
//   destructor takes no parameters, and no return type can be
//   specified for it (not even void). The address of a destructor
//   shall not be taken. A destructor shall not be static. A
//   destructor can be invoked for a const, volatile or const
//   volatile object. A destructor shall not be declared const,
//   volatile or const volatile (9.3.2).
if (SC == SC_Static) {
  if (!D.isInvalidType())
    Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
      << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
      << SourceRange(D.getIdentifierLoc())
      << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());

  SC = SC_None;
}
if (!D.isInvalidType()) {
  // Destructors don't have return types, but the parser will
  // happily parse something like:
  //
  //   class X {
  //     float ~X();
  //   };
  //
  // The return type will be eliminated later.
  if (D.getDeclSpec().hasTypeSpecifier())
    Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
      << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
      << SourceRange(D.getIdentifierLoc());
  else if (unsigned TypeQuals = D.getDeclSpec().getTypeQualifiers()) {
    diagnoseIgnoredQualifiers(diag::err_destructor_return_type, TypeQuals,
                              SourceLocation(),
                              D.getDeclSpec().getConstSpecLoc(),
                              D.getDeclSpec().getVolatileSpecLoc(),
                              D.getDeclSpec().getRestrictSpecLoc(),
                              D.getDeclSpec().getAtomicSpecLoc());
    D.setInvalidType();
  }
}

DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
  if (FTI.TypeQuals & Qualifiers::Const)
    Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
      << "const" << SourceRange(D.getIdentifierLoc());
  if (FTI.TypeQuals & Qualifiers::Volatile)
    Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
      << "volatile" << SourceRange(D.getIdentifierLoc());
  if (FTI.TypeQuals & Qualifiers::Restrict)
    Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
      << "restrict" << SourceRange(D.getIdentifierLoc());
  D.setInvalidType();
}

// C++0x [class.dtor]p2:
//   A destructor shall not be declared with a ref-qualifier.
if (FTI.hasRefQualifier()) {
  Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
    << FTI.RefQualifierIsLValueRef
    << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
  D.setInvalidType();
}

// Make sure we don't have any parameters.
if (FTIHasNonVoidParameters(FTI)) {
  Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);

  // Delete the parameters.
  FTI.freeParams();
  D.setInvalidType();
}

// Make sure the destructor isn't variadic.
if (FTI.isVariadic) {
  Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
  D.setInvalidType();
}

// Rebuild the function type "R" without any type qualifiers or
// parameters (in case any of the errors above fired) and with
// "void" as the return type, since destructors don't have return
// types.
if (!D.isInvalidType())
  return R;

const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
EPI.Variadic = false;
EPI.TypeQuals = 0;
EPI.RefQualifier = RQ_None;
return Context.getFunctionType(Context.VoidTy, None, EPI);
8172}

8174static void extendLeft(SourceRange &R, SourceRange Before) {
if (Before.isInvalid())
  return;
R.setBegin(Before.getBegin());
if (R.getEnd().isInvalid())
  R.setEnd(Before.getEnd());
8180}

8182static void extendRight(SourceRange &R, SourceRange After) {
if (After.isInvalid())
  return;
if (R.getBegin().isInvalid())
  R.setBegin(After.getBegin());
R.setEnd(After.getEnd());
8188}

8190/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
8191/// well-formednes of the conversion function declarator @p D with
8192/// type @p R. If there are any errors in the declarator, this routine
8193/// will emit diagnostics and return true. Otherwise, it will return
8194/// false. Either way, the type @p R will be updated to reflect a
8195/// well-formed type for the conversion operator.
8196void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
                                   StorageClass& SC) {
// C++ [class.conv.fct]p1:
//   Neither parameter types nor return type can be specified. The
//   type of a conversion function (8.3.5) is "function taking no
//   parameter returning conversion-type-id."
if (SC == SC_Static) {
  if (!D.isInvalidType())
    Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
      << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
      << D.getName().getSourceRange();
  D.setInvalidType();
  SC = SC_None;
}

TypeSourceInfo *ConvTSI = nullptr;
QualType ConvType =
    GetTypeFromParser(D.getName().ConversionFunctionId, &ConvTSI);

if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
  // Conversion functions don't have return types, but the parser will
  // happily parse something like:
  //
  //   class X {
  //     float operator bool();
  //   };
  //
  // The return type will be changed later anyway.
  Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
    << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
    << SourceRange(D.getIdentifierLoc());
  D.setInvalidType();
}

const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();

// Make sure we don't have any parameters.
if (Proto->getNumParams() > 0) {
  Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);

  // Delete the parameters.
  D.getFunctionTypeInfo().freeParams();
  D.setInvalidType();
} else if (Proto->isVariadic()) {
  Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
  D.setInvalidType();
}

// Diagnose "&operator bool()" and other such nonsense.  This
// is actually a gcc extension which we don't support.
if (Proto->getReturnType() != ConvType) {
  bool NeedsTypedef = false;
  SourceRange Before, After;

  // Walk the chunks and extract information on them for our diagnostic.
  bool PastFunctionChunk = false;
  for (auto &Chunk : D.type_objects()) {
    switch (Chunk.Kind) {
    case DeclaratorChunk::Function:
      if (!PastFunctionChunk) {
        if (Chunk.Fun.HasTrailingReturnType) {
          TypeSourceInfo *TRT = nullptr;
          GetTypeFromParser(Chunk.Fun.getTrailingReturnType(), &TRT);
          if (TRT) extendRight(After, TRT->getTypeLoc().getSourceRange());
        }
        PastFunctionChunk = true;
        break;
      }
      LLVM_FALLTHROUGH[[clang::fallthrough]];
    case DeclaratorChunk::Array:
      NeedsTypedef = true;
      extendRight(After, Chunk.getSourceRange());
      break;

    case DeclaratorChunk::Pointer:
    case DeclaratorChunk::BlockPointer:
    case DeclaratorChunk::Reference:
    case DeclaratorChunk::MemberPointer:
    case DeclaratorChunk::Pipe:
      extendLeft(Before, Chunk.getSourceRange());
      break;

    case DeclaratorChunk::Paren:
      extendLeft(Before, Chunk.Loc);
      extendRight(After, Chunk.EndLoc);
      break;
    }
  }

  SourceLocation Loc = Before.isValid() ? Before.getBegin() :
                       After.isValid()  ? After.getBegin() :
                                          D.getIdentifierLoc();
  auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
  DB << Before << After;

  if (!NeedsTypedef) {
    DB << /*don't need a typedef*/0;

    // If we can provide a correct fix-it hint, do so.
    if (After.isInvalid() && ConvTSI) {
      SourceLocation InsertLoc =
          getLocForEndOfToken(ConvTSI->getTypeLoc().getLocEnd());
      DB << FixItHint::CreateInsertion(InsertLoc, " ")
         << FixItHint::CreateInsertionFromRange(
                InsertLoc, CharSourceRange::getTokenRange(Before))
         << FixItHint::CreateRemoval(Before);
    }
  } else if (!Proto->getReturnType()->isDependentType()) {
    DB << /*typedef*/1 << Proto->getReturnType();
  } else if (getLangOpts().CPlusPlus11) {
    DB << /*alias template*/2 << Proto->getReturnType();
  } else {
    DB << /*might not be fixable*/3;
  }

  // Recover by incorporating the other type chunks into the result type.
  // Note, this does *not* change the name of the function. This is compatible
  // with the GCC extension:
  //   struct S { &operator int(); } s;
  //   int &r = s.operator int(); // ok in GCC
  //   S::operator int&() {} // error in GCC, function name is 'operator int'.
  ConvType = Proto->getReturnType();
}

// C++ [class.conv.fct]p4:
//   The conversion-type-id shall not represent a function type nor
//   an array type.
if (ConvType->isArrayType()) {
  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
  ConvType = Context.getPointerType(ConvType);
  D.setInvalidType();
} else if (ConvType->isFunctionType()) {
  Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
  ConvType = Context.getPointerType(ConvType);
  D.setInvalidType();
}

// Rebuild the function type "R" without any parameters (in case any
// of the errors above fired) and with the conversion type as the
// return type.
if (D.isInvalidType())
  R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());

// C++0x explicit conversion operators.
if (D.getDeclSpec().isExplicitSpecified())
  Diag(D.getDeclSpec().getExplicitSpecLoc(),
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_explicit_conversion_functions :
         diag::ext_explicit_conversion_functions)
    << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
8346}

8348/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
8349/// the declaration of the given C++ conversion function. This routine
8350/// is responsible for recording the conversion function in the C++
8351/// class, if possible.
8352Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
assert(Conversion && "Expected to receive a conversion function declaration")(static_cast <bool> (Conversion && "Expected to receive a conversion function declaration"
) ? void (0) : __assert_fail ("Conversion && \"Expected to receive a conversion function declaration\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8353, __extension__ __PRETTY_FUNCTION__));

CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());

// Make sure we aren't redeclaring the conversion function.
QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());

// C++ [class.conv.fct]p1:
//   [...] A conversion function is never used to convert a
//   (possibly cv-qualified) object to the (possibly cv-qualified)
//   same object type (or a reference to it), to a (possibly
//   cv-qualified) base class of that type (or a reference to it),
//   or to (possibly cv-qualified) void.
// FIXME: Suppress this warning if the conversion function ends up being a
// virtual function that overrides a virtual function in a base class.
QualType ClassType
  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
  ConvType = ConvTypeRef->getPointeeType();
if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
    Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
  /* Suppress diagnostics for instantiations. */;
else if (ConvType->isRecordType()) {
  ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
  if (ConvType == ClassType)
    Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
      << ClassType;
  else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))
    Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
      <<  ClassType << ConvType;
} else if (ConvType->isVoidType()) {
  Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
    << ClassType << ConvType;
}

if (FunctionTemplateDecl *ConversionTemplate
                              = Conversion->getDescribedFunctionTemplate())
  return ConversionTemplate;

return Conversion;
8393}

8395namespace {
8396/// Utility class to accumulate and print a diagnostic listing the invalid
8397/// specifier(s) on a declaration.
8398struct BadSpecifierDiagnoser {
BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
    : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
~BadSpecifierDiagnoser() {
  Diagnostic << Specifiers;
}

template<typename T> void check(SourceLocation SpecLoc, T Spec) {
  return check(SpecLoc, DeclSpec::getSpecifierName(Spec));
}
void check(SourceLocation SpecLoc, DeclSpec::TST Spec) {
  return check(SpecLoc,
               DeclSpec::getSpecifierName(Spec, S.getPrintingPolicy()));
}
void check(SourceLocation SpecLoc, const char *Spec) {
  if (SpecLoc.isInvalid()) return;
  Diagnostic << SourceRange(SpecLoc, SpecLoc);
  if (!Specifiers.empty()) Specifiers += " ";
  Specifiers += Spec;
}

Sema &S;
Sema::SemaDiagnosticBuilder Diagnostic;
std::string Specifiers;
8422};
8423}

8425/// Check the validity of a declarator that we parsed for a deduction-guide.
8426/// These aren't actually declarators in the grammar, so we need to check that
8427/// the user didn't specify any pieces that are not part of the deduction-guide
8428/// grammar.
8429void Sema::CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
                                       StorageClass &SC) {
TemplateName GuidedTemplate = D.getName().TemplateName.get().get();
TemplateDecl *GuidedTemplateDecl = GuidedTemplate.getAsTemplateDecl();
assert(GuidedTemplateDecl && "missing template decl for deduction guide")(static_cast <bool> (GuidedTemplateDecl && "missing template decl for deduction guide"
) ? void (0) : __assert_fail ("GuidedTemplateDecl && \"missing template decl for deduction guide\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8433, __extension__ __PRETTY_FUNCTION__));

// C++ [temp.deduct.guide]p3:
//   A deduction-gide shall be declared in the same scope as the
//   corresponding class template.
if (!CurContext->getRedeclContext()->Equals(
        GuidedTemplateDecl->getDeclContext()->getRedeclContext())) {
  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_wrong_scope)
    << GuidedTemplateDecl;
  Diag(GuidedTemplateDecl->getLocation(), diag::note_template_decl_here);
}

auto &DS = D.getMutableDeclSpec();
// We leave 'friend' and 'virtual' to be rejected in the normal way.
if (DS.hasTypeSpecifier() || DS.getTypeQualifiers() ||
    DS.getStorageClassSpecLoc().isValid() || DS.isInlineSpecified() ||
    DS.isNoreturnSpecified() || DS.isConstexprSpecified()) {
  BadSpecifierDiagnoser Diagnoser(
      *this, D.getIdentifierLoc(),
      diag::err_deduction_guide_invalid_specifier);

  Diagnoser.check(DS.getStorageClassSpecLoc(), DS.getStorageClassSpec());
  DS.ClearStorageClassSpecs();
  SC = SC_None;

  // 'explicit' is permitted.
  Diagnoser.check(DS.getInlineSpecLoc(), "inline");
  Diagnoser.check(DS.getNoreturnSpecLoc(), "_Noreturn");
  Diagnoser.check(DS.getConstexprSpecLoc(), "constexpr");
  DS.ClearConstexprSpec();

  Diagnoser.check(DS.getConstSpecLoc(), "const");
  Diagnoser.check(DS.getRestrictSpecLoc(), "__restrict");
  Diagnoser.check(DS.getVolatileSpecLoc(), "volatile");
  Diagnoser.check(DS.getAtomicSpecLoc(), "_Atomic");
  Diagnoser.check(DS.getUnalignedSpecLoc(), "__unaligned");
  DS.ClearTypeQualifiers();

  Diagnoser.check(DS.getTypeSpecComplexLoc(), DS.getTypeSpecComplex());
  Diagnoser.check(DS.getTypeSpecSignLoc(), DS.getTypeSpecSign());
  Diagnoser.check(DS.getTypeSpecWidthLoc(), DS.getTypeSpecWidth());
  Diagnoser.check(DS.getTypeSpecTypeLoc(), DS.getTypeSpecType());
  DS.ClearTypeSpecType();
}

if (D.isInvalidType())
  return;

// Check the declarator is simple enough.
bool FoundFunction = false;
for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
  if (Chunk.Kind == DeclaratorChunk::Paren)
    continue;
  if (Chunk.Kind != DeclaratorChunk::Function || FoundFunction) {
    Diag(D.getDeclSpec().getLocStart(),
        diag::err_deduction_guide_with_complex_decl)
      << D.getSourceRange();
    break;
  }
  if (!Chunk.Fun.hasTrailingReturnType()) {
    Diag(D.getName().getLocStart(),
         diag::err_deduction_guide_no_trailing_return_type);
    break;
  }

  // Check that the return type is written as a specialization of
  // the template specified as the deduction-guide's name.
  ParsedType TrailingReturnType = Chunk.Fun.getTrailingReturnType();
  TypeSourceInfo *TSI = nullptr;
  QualType RetTy = GetTypeFromParser(TrailingReturnType, &TSI);
  assert(TSI && "deduction guide has valid type but invalid return type?")(static_cast <bool> (TSI && "deduction guide has valid type but invalid return type?"
) ? void (0) : __assert_fail ("TSI && \"deduction guide has valid type but invalid return type?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8503, __extension__ __PRETTY_FUNCTION__));
  bool AcceptableReturnType = false;
  bool MightInstantiateToSpecialization = false;
  if (auto RetTST =
          TSI->getTypeLoc().getAs<TemplateSpecializationTypeLoc>()) {
    TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
    bool TemplateMatches =
        Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
    if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches)
      AcceptableReturnType = true;
    else {
      // This could still instantiate to the right type, unless we know it
      // names the wrong class template.
      auto *TD = SpecifiedName.getAsTemplateDecl();
      MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
                                           !TemplateMatches);
    }
  } else if (!RetTy.hasQualifiers() && RetTy->isDependentType()) {
    MightInstantiateToSpecialization = true;
  }

  if (!AcceptableReturnType) {
    Diag(TSI->getTypeLoc().getLocStart(),
         diag::err_deduction_guide_bad_trailing_return_type)
      << GuidedTemplate << TSI->getType() << MightInstantiateToSpecialization
      << TSI->getTypeLoc().getSourceRange();
  }

  // Keep going to check that we don't have any inner declarator pieces (we
  // could still have a function returning a pointer to a function).
  FoundFunction = true;
}

if (D.isFunctionDefinition())
  Diag(D.getIdentifierLoc(), diag::err_deduction_guide_defines_function);
8538}

8540//===----------------------------------------------------------------------===//
8541// Namespace Handling
8542//===----------------------------------------------------------------------===//

8544/// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is
8545/// reopened.
8546static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc,
                                          SourceLocation Loc,
                                          IdentifierInfo *II, bool *IsInline,
                                          NamespaceDecl *PrevNS) {
assert(*IsInline != PrevNS->isInline())(static_cast <bool> (*IsInline != PrevNS->isInline()
) ? void (0) : __assert_fail ("*IsInline != PrevNS->isInline()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8550, __extension__ __PRETTY_FUNCTION__));

// HACK: Work around a bug in libstdc++4.6's <atomic>, where
// std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
// inline namespaces, with the intention of bringing names into namespace std.
//
// We support this just well enough to get that case working; this is not
// sufficient to support reopening namespaces as inline in general.
if (*IsInline && II && II->getName().startswith("__atomic") &&
    S.getSourceManager().isInSystemHeader(Loc)) {
  // Mark all prior declarations of the namespace as inline.
  for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
       NS = NS->getPreviousDecl())
    NS->setInline(*IsInline);
  // Patch up the lookup table for the containing namespace. This isn't really
  // correct, but it's good enough for this particular case.
  for (auto *I : PrevNS->decls())
    if (auto *ND = dyn_cast<NamedDecl>(I))
      PrevNS->getParent()->makeDeclVisibleInContext(ND);
  return;
}

if (PrevNS->isInline())
  // The user probably just forgot the 'inline', so suggest that it
  // be added back.
  S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
    << FixItHint::CreateInsertion(KeywordLoc, "inline ");
else
  S.Diag(Loc, diag::err_inline_namespace_mismatch);

S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
*IsInline = PrevNS->isInline();
8582}

8584/// ActOnStartNamespaceDef - This is called at the start of a namespace
8585/// definition.
8586Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
                                 SourceLocation InlineLoc,
                                 SourceLocation NamespaceLoc,
                                 SourceLocation IdentLoc,
                                 IdentifierInfo *II,
                                 SourceLocation LBrace,
                                 AttributeList *AttrList,
                                 UsingDirectiveDecl *&UD) {
SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
// For anonymous namespace, take the location of the left brace.
SourceLocation Loc = II ? IdentLoc : LBrace;
bool IsInline = InlineLoc.isValid();
bool IsInvalid = false;
bool IsStd = false;
bool AddToKnown = false;
Scope *DeclRegionScope = NamespcScope->getParent();

NamespaceDecl *PrevNS = nullptr;
if (II) {
  // C++ [namespace.def]p2:
  //   The identifier in an original-namespace-definition shall not
  //   have been previously defined in the declarative region in
  //   which the original-namespace-definition appears. The
  //   identifier in an original-namespace-definition is the name of
  //   the namespace. Subsequently in that declarative region, it is
  //   treated as an original-namespace-name.
  //
  // Since namespace names are unique in their scope, and we don't
  // look through using directives, just look for any ordinary names
  // as if by qualified name lookup.
  LookupResult R(*this, II, IdentLoc, LookupOrdinaryName,
                 ForExternalRedeclaration);
  LookupQualifiedName(R, CurContext->getRedeclContext());
  NamedDecl *PrevDecl =
      R.isSingleResult() ? R.getRepresentativeDecl() : nullptr;
  PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);

  if (PrevNS) {
    // This is an extended namespace definition.
    if (IsInline != PrevNS->isInline())
      DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
                                      &IsInline, PrevNS);
  } else if (PrevDecl) {
    // This is an invalid name redefinition.
    Diag(Loc, diag::err_redefinition_different_kind)
      << II;
    Diag(PrevDecl->getLocation(), diag::note_previous_definition);
    IsInvalid = true;
    // Continue on to push Namespc as current DeclContext and return it.
  } else if (II->isStr("std") &&
             CurContext->getRedeclContext()->isTranslationUnit()) {
    // This is the first "real" definition of the namespace "std", so update
    // our cache of the "std" namespace to point at this definition.
    PrevNS = getStdNamespace();
    IsStd = true;
    AddToKnown = !IsInline;
  } else {
    // We've seen this namespace for the first time.
    AddToKnown = !IsInline;
  }
} else {
  // Anonymous namespaces.

  // Determine whether the parent already has an anonymous namespace.
  DeclContext *Parent = CurContext->getRedeclContext();
  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
    PrevNS = TU->getAnonymousNamespace();
  } else {
    NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
    PrevNS = ND->getAnonymousNamespace();
  }

  if (PrevNS && IsInline != PrevNS->isInline())
    DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
                                    &IsInline, PrevNS);
}

NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
                                               StartLoc, Loc, II, PrevNS);
if (IsInvalid)
  Namespc->setInvalidDecl();

ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
AddPragmaAttributes(DeclRegionScope, Namespc);

// FIXME: Should we be merging attributes?
if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
  PushNamespaceVisibilityAttr(Attr, Loc);

if (IsStd)
  StdNamespace = Namespc;
if (AddToKnown)
  KnownNamespaces[Namespc] = false;

if (II) {
  PushOnScopeChains(Namespc, DeclRegionScope);
} else {
  // Link the anonymous namespace into its parent.
  DeclContext *Parent = CurContext->getRedeclContext();
  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
    TU->setAnonymousNamespace(Namespc);
  } else {
    cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
  }

  CurContext->addDecl(Namespc);

  // C++ [namespace.unnamed]p1.  An unnamed-namespace-definition
  //   behaves as if it were replaced by
  //     namespace unique { /* empty body */ }
  //     using namespace unique;
  //     namespace unique { namespace-body }
  //   where all occurrences of 'unique' in a translation unit are
  //   replaced by the same identifier and this identifier differs
  //   from all other identifiers in the entire program.

  // We just create the namespace with an empty name and then add an
  // implicit using declaration, just like the standard suggests.
  //
  // CodeGen enforces the "universally unique" aspect by giving all
  // declarations semantically contained within an anonymous
  // namespace internal linkage.

  if (!PrevNS) {
    UD = UsingDirectiveDecl::Create(Context, Parent,
                                    /* 'using' */ LBrace,
                                    /* 'namespace' */ SourceLocation(),
                                    /* qualifier */ NestedNameSpecifierLoc(),
                                    /* identifier */ SourceLocation(),
                                    Namespc,
                                    /* Ancestor */ Parent);
    UD->setImplicit();
    Parent->addDecl(UD);
  }
}

ActOnDocumentableDecl(Namespc);

// Although we could have an invalid decl (i.e. the namespace name is a
// redefinition), push it as current DeclContext and try to continue parsing.
// FIXME: We should be able to push Namespc here, so that the each DeclContext
// for the namespace has the declarations that showed up in that particular
// namespace definition.
PushDeclContext(NamespcScope, Namespc);
return Namespc;
8731}

8733/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
8734/// is a namespace alias, returns the namespace it points to.
8735static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
  return AD->getNamespace();
return dyn_cast_or_null<NamespaceDecl>(D);
8739}

8741/// ActOnFinishNamespaceDef - This callback is called after a namespace is
8742/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
8743void Sema::ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) {
NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
assert(Namespc && "Invalid parameter, expected NamespaceDecl")(static_cast <bool> (Namespc && "Invalid parameter, expected NamespaceDecl"
) ? void (0) : __assert_fail ("Namespc && \"Invalid parameter, expected NamespaceDecl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8745, __extension__ __PRETTY_FUNCTION__));
Namespc->setRBraceLoc(RBrace);
PopDeclContext();
if (Namespc->hasAttr<VisibilityAttr>())
  PopPragmaVisibility(true, RBrace);
8750}

8752CXXRecordDecl *Sema::getStdBadAlloc() const {
return cast_or_null<CXXRecordDecl>(
                                StdBadAlloc.get(Context.getExternalSource()));
8755}

8757EnumDecl *Sema::getStdAlignValT() const {
return cast_or_null<EnumDecl>(StdAlignValT.get(Context.getExternalSource()));
8759}

8761NamespaceDecl *Sema::getStdNamespace() const {
return cast_or_null<NamespaceDecl>(
                               StdNamespace.get(Context.getExternalSource()));
8764}

8766NamespaceDecl *Sema::lookupStdExperimentalNamespace() {
if (!StdExperimentalNamespaceCache) {
  if (auto Std = getStdNamespace()) {
    LookupResult Result(*this, &PP.getIdentifierTable().get("experimental"),
                        SourceLocation(), LookupNamespaceName);
    if (!LookupQualifiedName(Result, Std) ||
        !(StdExperimentalNamespaceCache =
              Result.getAsSingle<NamespaceDecl>()))
      Result.suppressDiagnostics();
  }
}
return StdExperimentalNamespaceCache;
8778}

8780/// \brief Retrieve the special "std" namespace, which may require us to
8781/// implicitly define the namespace.
8782NamespaceDecl *Sema::getOrCreateStdNamespace() {
if (!StdNamespace) {
  // The "std" namespace has not yet been defined, so build one implicitly.
  StdNamespace = NamespaceDecl::Create(Context,
                                       Context.getTranslationUnitDecl(),
                                       /*Inline=*/false,
                                       SourceLocation(), SourceLocation(),
                                       &PP.getIdentifierTable().get("std"),
                                       /*PrevDecl=*/nullptr);
  getStdNamespace()->setImplicit(true);
}

return getStdNamespace();
8795}

8797bool Sema::isStdInitializerList(QualType Ty, QualType *Element) {
assert(getLangOpts().CPlusPlus &&(static_cast <bool> (getLangOpts().CPlusPlus &&
 "Looking for std::initializer_list outside of C++.") ? void (
0) : __assert_fail ("getLangOpts().CPlusPlus && \"Looking for std::initializer_list outside of C++.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8799, __extension__ __PRETTY_FUNCTION__))
       "Looking for std::initializer_list outside of C++.")(static_cast <bool> (getLangOpts().CPlusPlus &&
 "Looking for std::initializer_list outside of C++.") ? void (
0) : __assert_fail ("getLangOpts().CPlusPlus && \"Looking for std::initializer_list outside of C++.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8799, __extension__ __PRETTY_FUNCTION__));

// We're looking for implicit instantiations of
// template <typename E> class std::initializer_list.

if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
  return false;

ClassTemplateDecl *Template = nullptr;
const TemplateArgument *Arguments = nullptr;

if (const RecordType *RT = Ty->getAs<RecordType>()) {

  ClassTemplateSpecializationDecl *Specialization =
      dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
  if (!Specialization)
    return false;

  Template = Specialization->getSpecializedTemplate();
  Arguments = Specialization->getTemplateArgs().data();
} else if (const TemplateSpecializationType *TST =
               Ty->getAs<TemplateSpecializationType>()) {
  Template = dyn_cast_or_null<ClassTemplateDecl>(
      TST->getTemplateName().getAsTemplateDecl());
  Arguments = TST->getArgs();
}
if (!Template)
  return false;

if (!StdInitializerList) {
  // Haven't recognized std::initializer_list yet, maybe this is it.
  CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
  if (TemplateClass->getIdentifier() !=
          &PP.getIdentifierTable().get("initializer_list") ||
      !getStdNamespace()->InEnclosingNamespaceSetOf(
          TemplateClass->getDeclContext()))
    return false;
  // This is a template called std::initializer_list, but is it the right
  // template?
  TemplateParameterList *Params = Template->getTemplateParameters();
  if (Params->getMinRequiredArguments() != 1)
    return false;
  if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
    return false;

  // It's the right template.
  StdInitializerList = Template;
}

if (Template->getCanonicalDecl() != StdInitializerList->getCanonicalDecl())
  return false;

// This is an instance of std::initializer_list. Find the argument type.
if (Element)
  *Element = Arguments[0].getAsType();
return true;
8855}

8857static ClassTemplateDecl *LookupStdInitializerList(Sema &S, SourceLocation Loc){
NamespaceDecl *Std = S.getStdNamespace();
if (!Std) {
  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
  return nullptr;
}

LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
                    Loc, Sema::LookupOrdinaryName);
if (!S.LookupQualifiedName(Result, Std)) {
  S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
  return nullptr;
}
ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
if (!Template) {
  Result.suppressDiagnostics();
  // We found something weird. Complain about the first thing we found.
  NamedDecl *Found = *Result.begin();
  S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
  return nullptr;
}

// We found some template called std::initializer_list. Now verify that it's
// correct.
TemplateParameterList *Params = Template->getTemplateParameters();
if (Params->getMinRequiredArguments() != 1 ||
    !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
  S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
  return nullptr;
}

return Template;
8889}

8891QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
if (!StdInitializerList) {
  StdInitializerList = LookupStdInitializerList(*this, Loc);
  if (!StdInitializerList)
    return QualType();
}

TemplateArgumentListInfo Args(Loc, Loc);
Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
                                     Context.getTrivialTypeSourceInfo(Element,
                                                                      Loc)));
return Context.getCanonicalType(
    CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
8904}

8906bool Sema::isInitListConstructor(const FunctionDecl *Ctor) {
// C++ [dcl.init.list]p2:
//   A constructor is an initializer-list constructor if its first parameter
//   is of type std::initializer_list<E> or reference to possibly cv-qualified
//   std::initializer_list<E> for some type E, and either there are no other
//   parameters or else all other parameters have default arguments.
if (Ctor->getNumParams() < 1 ||
    (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
  return false;

QualType ArgType = Ctor->getParamDecl(0)->getType();
if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
  ArgType = RT->getPointeeType().getUnqualifiedType();

return isStdInitializerList(ArgType, nullptr);
8921}

8923/// \brief Determine whether a using statement is in a context where it will be
8924/// apply in all contexts.
8925static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) {
switch (CurContext->getDeclKind()) {
  case Decl::TranslationUnit:
    return true;
  case Decl::LinkageSpec:
    return IsUsingDirectiveInToplevelContext(CurContext->getParent());
  default:
    return false;
}
8934}

8936namespace {

8938// Callback to only accept typo corrections that are namespaces.
8939class NamespaceValidatorCCC : public CorrectionCandidateCallback {
8940public:
bool ValidateCandidate(const TypoCorrection &candidate) override {
  if (NamedDecl *ND = candidate.getCorrectionDecl())
    return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
  return false;
}
8946};

8948}

8950static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
                                     CXXScopeSpec &SS,
                                     SourceLocation IdentLoc,
                                     IdentifierInfo *Ident) {
R.clear();
if (TypoCorrection Corrected =
        S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS,
                      llvm::make_unique<NamespaceValidatorCCC>(),
                      Sema::CTK_ErrorRecovery)) {
  if (DeclContext *DC = S.computeDeclContext(SS, false)) {
    std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
    bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
                            Ident->getName().equals(CorrectedStr);
    S.diagnoseTypo(Corrected,
                   S.PDiag(diag::err_using_directive_member_suggest)
                     << Ident << DC << DroppedSpecifier << SS.getRange(),
                   S.PDiag(diag::note_namespace_defined_here));
  } else {
    S.diagnoseTypo(Corrected,
                   S.PDiag(diag::err_using_directive_suggest) << Ident,
                   S.PDiag(diag::note_namespace_defined_here));
  }
  R.addDecl(Corrected.getFoundDecl());
  return true;
}
return false;
8976}

8978Decl *Sema::ActOnUsingDirective(Scope *S,
                                        SourceLocation UsingLoc,
                                        SourceLocation NamespcLoc,
                                        CXXScopeSpec &SS,
                                        SourceLocation IdentLoc,
                                        IdentifierInfo *NamespcName,
                                        AttributeList *AttrList) {
assert(!SS.isInvalid() && "Invalid CXXScopeSpec.")(static_cast <bool> (!SS.isInvalid() && "Invalid CXXScopeSpec."
) ? void (0) : __assert_fail ("!SS.isInvalid() && \"Invalid CXXScopeSpec.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8985, __extension__ __PRETTY_FUNCTION__));
assert(NamespcName && "Invalid NamespcName.")(static_cast <bool> (NamespcName && "Invalid NamespcName."
) ? void (0) : __assert_fail ("NamespcName && \"Invalid NamespcName.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8986, __extension__ __PRETTY_FUNCTION__));
assert(IdentLoc.isValid() && "Invalid NamespceName location.")(static_cast <bool> (IdentLoc.isValid() && "Invalid NamespceName location."
) ? void (0) : __assert_fail ("IdentLoc.isValid() && \"Invalid NamespceName location.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8987, __extension__ __PRETTY_FUNCTION__));

// This can only happen along a recovery path.
while (S->isTemplateParamScope())
  S = S->getParent();
assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.")(static_cast <bool> (S->getFlags() & Scope::DeclScope
 && "Invalid Scope.") ? void (0) : __assert_fail ("S->getFlags() & Scope::DeclScope && \"Invalid Scope.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 8992, __extension__ __PRETTY_FUNCTION__));

UsingDirectiveDecl *UDir = nullptr;
NestedNameSpecifier *Qualifier = nullptr;
if (SS.isSet())
  Qualifier = SS.getScopeRep();

// Lookup namespace name.
LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
LookupParsedName(R, S, &SS);
if (R.isAmbiguous())
  return nullptr;

if (R.empty()) {
  R.clear();
  // Allow "using namespace std;" or "using namespace ::std;" even if
  // "std" hasn't been defined yet, for GCC compatibility.
  if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
      NamespcName->isStr("std")) {
    Diag(IdentLoc, diag::ext_using_undefined_std);
    R.addDecl(getOrCreateStdNamespace());
    R.resolveKind();
  }
  // Otherwise, attempt typo correction.
  else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
}

if (!R.empty()) {
  NamedDecl *Named = R.getRepresentativeDecl();
  NamespaceDecl *NS = R.getAsSingle<NamespaceDecl>();
  assert(NS && "expected namespace decl")(static_cast <bool> (NS && "expected namespace decl"
) ? void (0) : __assert_fail ("NS && \"expected namespace decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9022, __extension__ __PRETTY_FUNCTION__));

  // The use of a nested name specifier may trigger deprecation warnings.
  DiagnoseUseOfDecl(Named, IdentLoc);

  // C++ [namespace.udir]p1:
  //   A using-directive specifies that the names in the nominated
  //   namespace can be used in the scope in which the
  //   using-directive appears after the using-directive. During
  //   unqualified name lookup (3.4.1), the names appear as if they
  //   were declared in the nearest enclosing namespace which
  //   contains both the using-directive and the nominated
  //   namespace. [Note: in this context, "contains" means "contains
  //   directly or indirectly". ]

  // Find enclosing context containing both using-directive and
  // nominated namespace.
  DeclContext *CommonAncestor = cast<DeclContext>(NS);
  while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
    CommonAncestor = CommonAncestor->getParent();

  UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
                                    SS.getWithLocInContext(Context),
                                    IdentLoc, Named, CommonAncestor);

  if (IsUsingDirectiveInToplevelContext(CurContext) &&
      !SourceMgr.isInMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
    Diag(IdentLoc, diag::warn_using_directive_in_header);
  }

  PushUsingDirective(S, UDir);
} else {
  Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
}

if (UDir)
  ProcessDeclAttributeList(S, UDir, AttrList);

return UDir;
9061}

9063void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
// If the scope has an associated entity and the using directive is at
// namespace or translation unit scope, add the UsingDirectiveDecl into
// its lookup structure so qualified name lookup can find it.
DeclContext *Ctx = S->getEntity();
if (Ctx && !Ctx->isFunctionOrMethod())
  Ctx->addDecl(UDir);
else
  // Otherwise, it is at block scope. The using-directives will affect lookup
  // only to the end of the scope.
  S->PushUsingDirective(UDir);
9074}


9077Decl *Sema::ActOnUsingDeclaration(Scope *S,
                                AccessSpecifier AS,
                                SourceLocation UsingLoc,
                                SourceLocation TypenameLoc,
                                CXXScopeSpec &SS,
                                UnqualifiedId &Name,
                                SourceLocation EllipsisLoc,
                                AttributeList *AttrList) {
assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.")(static_cast <bool> (S->getFlags() & Scope::DeclScope
 && "Invalid Scope.") ? void (0) : __assert_fail ("S->getFlags() & Scope::DeclScope && \"Invalid Scope.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9085, __extension__ __PRETTY_FUNCTION__));

if (SS.isEmpty()) {
  Diag(Name.getLocStart(), diag::err_using_requires_qualname);
  return nullptr;
}

switch (Name.getKind()) {
case UnqualifiedIdKind::IK_ImplicitSelfParam:
case UnqualifiedIdKind::IK_Identifier:
case UnqualifiedIdKind::IK_OperatorFunctionId:
case UnqualifiedIdKind::IK_LiteralOperatorId:
case UnqualifiedIdKind::IK_ConversionFunctionId:
  break;

case UnqualifiedIdKind::IK_ConstructorName:
case UnqualifiedIdKind::IK_ConstructorTemplateId:
  // C++11 inheriting constructors.
  Diag(Name.getLocStart(),
       getLangOpts().CPlusPlus11 ?
         diag::warn_cxx98_compat_using_decl_constructor :
         diag::err_using_decl_constructor)
    << SS.getRange();

  if (getLangOpts().CPlusPlus11) break;

  return nullptr;

case UnqualifiedIdKind::IK_DestructorName:
  Diag(Name.getLocStart(), diag::err_using_decl_destructor)
    << SS.getRange();
  return nullptr;

case UnqualifiedIdKind::IK_TemplateId:
  Diag(Name.getLocStart(), diag::err_using_decl_template_id)
    << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
  return nullptr;

case UnqualifiedIdKind::IK_DeductionGuideName:
  llvm_unreachable("cannot parse qualified deduction guide name")::llvm::llvm_unreachable_internal("cannot parse qualified deduction guide name"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9124);
}

DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
DeclarationName TargetName = TargetNameInfo.getName();
if (!TargetName)
  return nullptr;

// Warn about access declarations.
if (UsingLoc.isInvalid()) {
  Diag(Name.getLocStart(),
       getLangOpts().CPlusPlus11 ? diag::err_access_decl
                                 : diag::warn_access_decl_deprecated)
    << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
}

if (EllipsisLoc.isInvalid()) {
  if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
      DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
    return nullptr;
} else {
  if (!SS.getScopeRep()->containsUnexpandedParameterPack() &&
      !TargetNameInfo.containsUnexpandedParameterPack()) {
    Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
      << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
    EllipsisLoc = SourceLocation();
  }
}

NamedDecl *UD =
    BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
                          SS, TargetNameInfo, EllipsisLoc, AttrList,
                          /*IsInstantiation*/false);
if (UD)
  PushOnScopeChains(UD, S, /*AddToContext*/ false);

return UD;
9161}

9163/// \brief Determine whether a using declaration considers the given
9164/// declarations as "equivalent", e.g., if they are redeclarations of
9165/// the same entity or are both typedefs of the same type.
9166static bool
9167IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2) {
if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
  return true;

if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
  if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
    return Context.hasSameType(TD1->getUnderlyingType(),
                               TD2->getUnderlyingType());

return false;
9177}


9180/// Determines whether to create a using shadow decl for a particular
9181/// decl, given the set of decls existing prior to this using lookup.
9182bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
                              const LookupResult &Previous,
                              UsingShadowDecl *&PrevShadow) {
// Diagnose finding a decl which is not from a base class of the
// current class.  We do this now because there are cases where this
// function will silently decide not to build a shadow decl, which
// will pre-empt further diagnostics.
//
// We don't need to do this in C++11 because we do the check once on
// the qualifier.
//
// FIXME: diagnose the following if we care enough:
//   struct A { int foo; };
//   struct B : A { using A::foo; };
//   template <class T> struct C : A {};
//   template <class T> struct D : C<T> { using B::foo; } // <---
// This is invalid (during instantiation) in C++03 because B::foo
// resolves to the using decl in B, which is not a base class of D<T>.
// We can't diagnose it immediately because C<T> is an unknown
// specialization.  The UsingShadowDecl in D<T> then points directly
// to A::foo, which will look well-formed when we instantiate.
// The right solution is to not collapse the shadow-decl chain.
if (!getLangOpts().CPlusPlus11 && CurContext->isRecord()) {
  DeclContext *OrigDC = Orig->getDeclContext();

  // Handle enums and anonymous structs.
  if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
  CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
  while (OrigRec->isAnonymousStructOrUnion())
    OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());

  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
    if (OrigDC == CurContext) {
      Diag(Using->getLocation(),
           diag::err_using_decl_nested_name_specifier_is_current_class)
        << Using->getQualifierLoc().getSourceRange();
      Diag(Orig->getLocation(), diag::note_using_decl_target);
      Using->setInvalidDecl();
      return true;
    }

    Diag(Using->getQualifierLoc().getBeginLoc(),
         diag::err_using_decl_nested_name_specifier_is_not_base_class)
      << Using->getQualifier()
      << cast<CXXRecordDecl>(CurContext)
      << Using->getQualifierLoc().getSourceRange();
    Diag(Orig->getLocation(), diag::note_using_decl_target);
    Using->setInvalidDecl();
    return true;
  }
}

if (Previous.empty()) return false;

NamedDecl *Target = Orig;
if (isa<UsingShadowDecl>(Target))
  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();

// If the target happens to be one of the previous declarations, we
// don't have a conflict.
//
// FIXME: but we might be increasing its access, in which case we
// should redeclare it.
NamedDecl *NonTag = nullptr, *Tag = nullptr;
bool FoundEquivalentDecl = false;
for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
       I != E; ++I) {
  NamedDecl *D = (*I)->getUnderlyingDecl();
  // We can have UsingDecls in our Previous results because we use the same
  // LookupResult for checking whether the UsingDecl itself is a valid
  // redeclaration.
  if (isa<UsingDecl>(D) || isa<UsingPackDecl>(D))
    continue;

  if (IsEquivalentForUsingDecl(Context, D, Target)) {
    if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
      PrevShadow = Shadow;
    FoundEquivalentDecl = true;
  } else if (isEquivalentInternalLinkageDeclaration(D, Target)) {
    // We don't conflict with an existing using shadow decl of an equivalent
    // declaration, but we're not a redeclaration of it.
    FoundEquivalentDecl = true;
  }

  if (isVisible(D))
    (isa<TagDecl>(D) ? Tag : NonTag) = D;
}

if (FoundEquivalentDecl)
  return false;

if (FunctionDecl *FD = Target->getAsFunction()) {
  NamedDecl *OldDecl = nullptr;
  switch (CheckOverload(nullptr, FD, Previous, OldDecl,
                        /*IsForUsingDecl*/ true)) {
  case Ovl_Overload:
    return false;

  case Ovl_NonFunction:
    Diag(Using->getLocation(), diag::err_using_decl_conflict);
    break;

  // We found a decl with the exact signature.
  case Ovl_Match:
    // If we're in a record, we want to hide the target, so we
    // return true (without a diagnostic) to tell the caller not to
    // build a shadow decl.
    if (CurContext->isRecord())
      return true;

    // If we're not in a record, this is an error.
    Diag(Using->getLocation(), diag::err_using_decl_conflict);
    break;
  }

  Diag(Target->getLocation(), diag::note_using_decl_target);
  Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
  Using->setInvalidDecl();
  return true;
}

// Target is not a function.

if (isa<TagDecl>(Target)) {
  // No conflict between a tag and a non-tag.
  if (!Tag) return false;

  Diag(Using->getLocation(), diag::err_using_decl_conflict);
  Diag(Target->getLocation(), diag::note_using_decl_target);
  Diag(Tag->getLocation(), diag::note_using_decl_conflict);
  Using->setInvalidDecl();
  return true;
}

// No conflict between a tag and a non-tag.
if (!NonTag) return false;

Diag(Using->getLocation(), diag::err_using_decl_conflict);
Diag(Target->getLocation(), diag::note_using_decl_target);
Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
Using->setInvalidDecl();
return true;
9324}

9326/// Determine whether a direct base class is a virtual base class.
9327static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
if (!Derived->getNumVBases())
  return false;
for (auto &B : Derived->bases())
  if (B.getType()->getAsCXXRecordDecl() == Base)
    return B.isVirtual();
llvm_unreachable("not a direct base class")::llvm::llvm_unreachable_internal("not a direct base class", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9333);
9334}

9336/// Builds a shadow declaration corresponding to a 'using' declaration.
9337UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
                                          UsingDecl *UD,
                                          NamedDecl *Orig,
                                          UsingShadowDecl *PrevDecl) {
// If we resolved to another shadow declaration, just coalesce them.
NamedDecl *Target = Orig;
if (isa<UsingShadowDecl>(Target)) {
  Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
  assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration")(static_cast <bool> (!isa<UsingShadowDecl>(Target
) && "nested shadow declaration") ? void (0) : __assert_fail
 ("!isa<UsingShadowDecl>(Target) && \"nested shadow declaration\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9345, __extension__ __PRETTY_FUNCTION__));
}

NamedDecl *NonTemplateTarget = Target;
if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
  NonTemplateTarget = TargetTD->getTemplatedDecl();

UsingShadowDecl *Shadow;
if (isa<CXXConstructorDecl>(NonTemplateTarget)) {
  bool IsVirtualBase =
      isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
                          UD->getQualifier()->getAsRecordDecl());
  Shadow = ConstructorUsingShadowDecl::Create(
      Context, CurContext, UD->getLocation(), UD, Orig, IsVirtualBase);
} else {
  Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
                                   Target);
}
UD->addShadowDecl(Shadow);

Shadow->setAccess(UD->getAccess());
if (Orig->isInvalidDecl() || UD->isInvalidDecl())
  Shadow->setInvalidDecl();

Shadow->setPreviousDecl(PrevDecl);

if (S)
  PushOnScopeChains(Shadow, S);
else
  CurContext->addDecl(Shadow);


return Shadow;
9378}

9380/// Hides a using shadow declaration.  This is required by the current
9381/// using-decl implementation when a resolvable using declaration in a
9382/// class is followed by a declaration which would hide or override
9383/// one or more of the using decl's targets; for example:
9384///
9385///   struct Base { void foo(int); };
9386///   struct Derived : Base {
9387///     using Base::foo;
9388///     void foo(int);
9389///   };
9390///
9391/// The governing language is C++03 [namespace.udecl]p12:
9392///
9393///   When a using-declaration brings names from a base class into a
9394///   derived class scope, member functions in the derived class
9395///   override and/or hide member functions with the same name and
9396///   parameter types in a base class (rather than conflicting).
9397///
9398/// There are two ways to implement this:
9399///   (1) optimistically create shadow decls when they're not hidden
9400///       by existing declarations, or
9401///   (2) don't create any shadow decls (or at least don't make them
9402///       visible) until we've fully parsed/instantiated the class.
9403/// The problem with (1) is that we might have to retroactively remove
9404/// a shadow decl, which requires several O(n) operations because the
9405/// decl structures are (very reasonably) not designed for removal.
9406/// (2) avoids this but is very fiddly and phase-dependent.
9407void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
if (Shadow->getDeclName().getNameKind() ==
      DeclarationName::CXXConversionFunctionName)
  cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);

// Remove it from the DeclContext...
Shadow->getDeclContext()->removeDecl(Shadow);

// ...and the scope, if applicable...
if (S) {
  S->RemoveDecl(Shadow);
  IdResolver.RemoveDecl(Shadow);
}

// ...and the using decl.
Shadow->getUsingDecl()->removeShadowDecl(Shadow);

// TODO: complain somehow if Shadow was used.  It shouldn't
// be possible for this to happen, because...?
9426}

9428/// Find the base specifier for a base class with the given type.
9429static CXXBaseSpecifier *findDirectBaseWithType(CXXRecordDecl *Derived,
                                              QualType DesiredBase,
                                              bool &AnyDependentBases) {
// Check whether the named type is a direct base class.
CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
for (auto &Base : Derived->bases()) {
  CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
  if (CanonicalDesiredBase == BaseType)
    return &Base;
  if (BaseType->isDependentType())
    AnyDependentBases = true;
}
return nullptr;
9442}

9444namespace {
9445class UsingValidatorCCC : public CorrectionCandidateCallback {
9446public:
UsingValidatorCCC(bool HasTypenameKeyword, bool IsInstantiation,
                  NestedNameSpecifier *NNS, CXXRecordDecl *RequireMemberOf)
    : HasTypenameKeyword(HasTypenameKeyword),
      IsInstantiation(IsInstantiation), OldNNS(NNS),
      RequireMemberOf(RequireMemberOf) {}

bool ValidateCandidate(const TypoCorrection &Candidate) override {
  NamedDecl *ND = Candidate.getCorrectionDecl();

  // Keywords are not valid here.
  if (!ND || isa<NamespaceDecl>(ND))
    return false;

  // Completely unqualified names are invalid for a 'using' declaration.
  if (Candidate.WillReplaceSpecifier() && !Candidate.getCorrectionSpecifier())
    return false;

  // FIXME: Don't correct to a name that CheckUsingDeclRedeclaration would
  // reject.

  if (RequireMemberOf) {
    auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
    if (FoundRecord && FoundRecord->isInjectedClassName()) {
      // No-one ever wants a using-declaration to name an injected-class-name
      // of a base class, unless they're declaring an inheriting constructor.
      ASTContext &Ctx = ND->getASTContext();
      if (!Ctx.getLangOpts().CPlusPlus11)
        return false;
      QualType FoundType = Ctx.getRecordType(FoundRecord);

      // Check that the injected-class-name is named as a member of its own
      // type; we don't want to suggest 'using Derived::Base;', since that
      // means something else.
      NestedNameSpecifier *Specifier =
          Candidate.WillReplaceSpecifier()
              ? Candidate.getCorrectionSpecifier()
              : OldNNS;
      if (!Specifier->getAsType() ||
          !Ctx.hasSameType(QualType(Specifier->getAsType(), 0), FoundType))
        return false;

      // Check that this inheriting constructor declaration actually names a
      // direct base class of the current class.
      bool AnyDependentBases = false;
      if (!findDirectBaseWithType(RequireMemberOf,
                                  Ctx.getRecordType(FoundRecord),
                                  AnyDependentBases) &&
          !AnyDependentBases)
        return false;
    } else {
      auto *RD = dyn_cast<CXXRecordDecl>(ND->getDeclContext());
      if (!RD || RequireMemberOf->isProvablyNotDerivedFrom(RD))
        return false;

      // FIXME: Check that the base class member is accessible?
    }
  } else {
    auto *FoundRecord = dyn_cast<CXXRecordDecl>(ND);
    if (FoundRecord && FoundRecord->isInjectedClassName())
      return false;
  }

  if (isa<TypeDecl>(ND))
    return HasTypenameKeyword || !IsInstantiation;

  return !HasTypenameKeyword;
}

9515private:
bool HasTypenameKeyword;
bool IsInstantiation;
NestedNameSpecifier *OldNNS;
CXXRecordDecl *RequireMemberOf;
9520};
9521} // end anonymous namespace

9523/// Builds a using declaration.
9524///
9525/// \param IsInstantiation - Whether this call arises from an
9526///   instantiation of an unresolved using declaration.  We treat
9527///   the lookup differently for these declarations.
9528NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
                                     SourceLocation UsingLoc,
                                     bool HasTypenameKeyword,
                                     SourceLocation TypenameLoc,
                                     CXXScopeSpec &SS,
                                     DeclarationNameInfo NameInfo,
                                     SourceLocation EllipsisLoc,
                                     AttributeList *AttrList,
                                     bool IsInstantiation) {
assert(!SS.isInvalid() && "Invalid CXXScopeSpec.")(static_cast <bool> (!SS.isInvalid() && "Invalid CXXScopeSpec."
) ? void (0) : __assert_fail ("!SS.isInvalid() && \"Invalid CXXScopeSpec.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9537, __extension__ __PRETTY_FUNCTION__));
SourceLocation IdentLoc = NameInfo.getLoc();
assert(IdentLoc.isValid() && "Invalid TargetName location.")(static_cast <bool> (IdentLoc.isValid() && "Invalid TargetName location."
) ? void (0) : __assert_fail ("IdentLoc.isValid() && \"Invalid TargetName location.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9539, __extension__ __PRETTY_FUNCTION__));

// FIXME: We ignore attributes for now.

// For an inheriting constructor declaration, the name of the using
// declaration is the name of a constructor in this class, not in the
// base class.
DeclarationNameInfo UsingName = NameInfo;
if (UsingName.getName().getNameKind() == DeclarationName::CXXConstructorName)
  if (auto *RD = dyn_cast<CXXRecordDecl>(CurContext))
    UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
        Context.getCanonicalType(Context.getRecordType(RD))));

// Do the redeclaration lookup in the current scope.
LookupResult Previous(*this, UsingName, LookupUsingDeclName,
                      ForVisibleRedeclaration);
Previous.setHideTags(false);
if (S) {
  LookupName(Previous, S);

  // It is really dumb that we have to do this.
  LookupResult::Filter F = Previous.makeFilter();
  while (F.hasNext()) {
    NamedDecl *D = F.next();
    if (!isDeclInScope(D, CurContext, S))
      F.erase();
    // If we found a local extern declaration that's not ordinarily visible,
    // and this declaration is being added to a non-block scope, ignore it.
    // We're only checking for scope conflicts here, not also for violations
    // of the linkage rules.
    else if (!CurContext->isFunctionOrMethod() && D->isLocalExternDecl() &&
             !(D->getIdentifierNamespace() & Decl::IDNS_Ordinary))
      F.erase();
  }
  F.done();
} else {
  assert(IsInstantiation && "no scope in non-instantiation")(static_cast <bool> (IsInstantiation && "no scope in non-instantiation"
) ? void (0) : __assert_fail ("IsInstantiation && \"no scope in non-instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9575, __extension__ __PRETTY_FUNCTION__));
  if (CurContext->isRecord())
    LookupQualifiedName(Previous, CurContext);
  else {
    // No redeclaration check is needed here; in non-member contexts we
    // diagnosed all possible conflicts with other using-declarations when
    // building the template:
    //
    // For a dependent non-type using declaration, the only valid case is
    // if we instantiate to a single enumerator. We check for conflicts
    // between shadow declarations we introduce, and we check in the template
    // definition for conflicts between a non-type using declaration and any
    // other declaration, which together covers all cases.
    //
    // A dependent typename using declaration will never successfully
    // instantiate, since it will always name a class member, so we reject
    // that in the template definition.
  }
}

// Check for invalid redeclarations.
if (CheckUsingDeclRedeclaration(UsingLoc, HasTypenameKeyword,
                                SS, IdentLoc, Previous))
  return nullptr;

// Check for bad qualifiers.
if (CheckUsingDeclQualifier(UsingLoc, HasTypenameKeyword, SS, NameInfo,
                            IdentLoc))
  return nullptr;

DeclContext *LookupContext = computeDeclContext(SS);
NamedDecl *D;
NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
if (!LookupContext || EllipsisLoc.isValid()) {
  if (HasTypenameKeyword) {
    // FIXME: not all declaration name kinds are legal here
    D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
                                            UsingLoc, TypenameLoc,
                                            QualifierLoc,
                                            IdentLoc, NameInfo.getName(),
                                            EllipsisLoc);
  } else {
    D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
                                         QualifierLoc, NameInfo, EllipsisLoc);
  }
  D->setAccess(AS);
  CurContext->addDecl(D);
  return D;
}

auto Build = [&](bool Invalid) {
  UsingDecl *UD =
      UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
                        UsingName, HasTypenameKeyword);
  UD->setAccess(AS);
  CurContext->addDecl(UD);
  UD->setInvalidDecl(Invalid);
  return UD;
};
auto BuildInvalid = [&]{ return Build(true); };
auto BuildValid = [&]{ return Build(false); };

if (RequireCompleteDeclContext(SS, LookupContext))
  return BuildInvalid();

// Look up the target name.
LookupResult R(*this, NameInfo, LookupOrdinaryName);

// Unlike most lookups, we don't always want to hide tag
// declarations: tag names are visible through the using declaration
// even if hidden by ordinary names, *except* in a dependent context
// where it's important for the sanity of two-phase lookup.
if (!IsInstantiation)
  R.setHideTags(false);

// For the purposes of this lookup, we have a base object type
// equal to that of the current context.
if (CurContext->isRecord()) {
  R.setBaseObjectType(
                 Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
}

LookupQualifiedName(R, LookupContext);

// Try to correct typos if possible. If constructor name lookup finds no
// results, that means the named class has no explicit constructors, and we
// suppressed declaring implicit ones (probably because it's dependent or
// invalid).
if (R.empty() &&
    NameInfo.getName().getNameKind() != DeclarationName::CXXConstructorName) {
  // HACK: Work around a bug in libstdc++'s detection of ::gets. Sometimes
  // it will believe that glibc provides a ::gets in cases where it does not,
  // and will try to pull it into namespace std with a using-declaration.
  // Just ignore the using-declaration in that case.
  auto *II = NameInfo.getName().getAsIdentifierInfo();
  if (getLangOpts().CPlusPlus14 && II && II->isStr("gets") &&
      CurContext->isStdNamespace() &&
      isa<TranslationUnitDecl>(LookupContext) &&
      getSourceManager().isInSystemHeader(UsingLoc))
    return nullptr;
  if (TypoCorrection Corrected = CorrectTypo(
          R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
          llvm::make_unique<UsingValidatorCCC>(
              HasTypenameKeyword, IsInstantiation, SS.getScopeRep(),
              dyn_cast<CXXRecordDecl>(CurContext)),
          CTK_ErrorRecovery)) {
    // We reject candidates where DroppedSpecifier == true, hence the
    // literal '0' below.
    diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
                              << NameInfo.getName() << LookupContext << 0
                              << SS.getRange());

    // If we picked a correction with no attached Decl we can't do anything
    // useful with it, bail out.
    NamedDecl *ND = Corrected.getCorrectionDecl();
    if (!ND)
      return BuildInvalid();

    // If we corrected to an inheriting constructor, handle it as one.
    auto *RD = dyn_cast<CXXRecordDecl>(ND);
    if (RD && RD->isInjectedClassName()) {
      // The parent of the injected class name is the class itself.
      RD = cast<CXXRecordDecl>(RD->getParent());

      // Fix up the information we'll use to build the using declaration.
      if (Corrected.WillReplaceSpecifier()) {
        NestedNameSpecifierLocBuilder Builder;
        Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
                            QualifierLoc.getSourceRange());
        QualifierLoc = Builder.getWithLocInContext(Context);
      }

      // In this case, the name we introduce is the name of a derived class
      // constructor.
      auto *CurClass = cast<CXXRecordDecl>(CurContext);
      UsingName.setName(Context.DeclarationNames.getCXXConstructorName(
          Context.getCanonicalType(Context.getRecordType(CurClass))));
      UsingName.setNamedTypeInfo(nullptr);
      for (auto *Ctor : LookupConstructors(RD))
        R.addDecl(Ctor);
      R.resolveKind();
    } else {
      // FIXME: Pick up all the declarations if we found an overloaded
      // function.
      UsingName.setName(ND->getDeclName());
      R.addDecl(ND);
    }
  } else {
    Diag(IdentLoc, diag::err_no_member)
      << NameInfo.getName() << LookupContext << SS.getRange();
    return BuildInvalid();
  }
}

if (R.isAmbiguous())
  return BuildInvalid();

if (HasTypenameKeyword) {
  // If we asked for a typename and got a non-type decl, error out.
  if (!R.getAsSingle<TypeDecl>()) {
    Diag(IdentLoc, diag::err_using_typename_non_type);
    for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
      Diag((*I)->getUnderlyingDecl()->getLocation(),
           diag::note_using_decl_target);
    return BuildInvalid();
  }
} else {
  // If we asked for a non-typename and we got a type, error out,
  // but only if this is an instantiation of an unresolved using
  // decl.  Otherwise just silently find the type name.
  if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
    Diag(IdentLoc, diag::err_using_dependent_value_is_type);
    Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
    return BuildInvalid();
  }
}

// C++14 [namespace.udecl]p6:
// A using-declaration shall not name a namespace.
if (R.getAsSingle<NamespaceDecl>()) {
  Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
    << SS.getRange();
  return BuildInvalid();
}

// C++14 [namespace.udecl]p7:
// A using-declaration shall not name a scoped enumerator.
if (auto *ED = R.getAsSingle<EnumConstantDecl>()) {
  if (cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
    Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_scoped_enum)
      << SS.getRange();
    return BuildInvalid();
  }
}

UsingDecl *UD = BuildValid();

// Some additional rules apply to inheriting constructors.
if (UsingName.getName().getNameKind() ==
      DeclarationName::CXXConstructorName) {
  // Suppress access diagnostics; the access check is instead performed at the
  // point of use for an inheriting constructor.
  R.suppressDiagnostics();
  if (CheckInheritingConstructorUsingDecl(UD))
    return UD;
}

for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
  UsingShadowDecl *PrevDecl = nullptr;
  if (!CheckUsingShadowDecl(UD, *I, Previous, PrevDecl))
    BuildUsingShadowDecl(S, UD, *I, PrevDecl);
}

return UD;
9789}

9791NamedDecl *Sema::BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
                                  ArrayRef<NamedDecl *> Expansions) {
assert(isa<UnresolvedUsingValueDecl>(InstantiatedFrom) ||(static_cast <bool> (isa<UnresolvedUsingValueDecl>
(InstantiatedFrom) || isa<UnresolvedUsingTypenameDecl>(
InstantiatedFrom) || isa<UsingPackDecl>(InstantiatedFrom
)) ? void (0) : __assert_fail ("isa<UnresolvedUsingValueDecl>(InstantiatedFrom) || isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) || isa<UsingPackDecl>(InstantiatedFrom)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9795, __extension__ __PRETTY_FUNCTION__))
       isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) ||(static_cast <bool> (isa<UnresolvedUsingValueDecl>
(InstantiatedFrom) || isa<UnresolvedUsingTypenameDecl>(
InstantiatedFrom) || isa<UsingPackDecl>(InstantiatedFrom
)) ? void (0) : __assert_fail ("isa<UnresolvedUsingValueDecl>(InstantiatedFrom) || isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) || isa<UsingPackDecl>(InstantiatedFrom)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9795, __extension__ __PRETTY_FUNCTION__))
       isa<UsingPackDecl>(InstantiatedFrom))(static_cast <bool> (isa<UnresolvedUsingValueDecl>
(InstantiatedFrom) || isa<UnresolvedUsingTypenameDecl>(
InstantiatedFrom) || isa<UsingPackDecl>(InstantiatedFrom
)) ? void (0) : __assert_fail ("isa<UnresolvedUsingValueDecl>(InstantiatedFrom) || isa<UnresolvedUsingTypenameDecl>(InstantiatedFrom) || isa<UsingPackDecl>(InstantiatedFrom)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9795, __extension__ __PRETTY_FUNCTION__));

auto *UPD =
    UsingPackDecl::Create(Context, CurContext, InstantiatedFrom, Expansions);
UPD->setAccess(InstantiatedFrom->getAccess());
CurContext->addDecl(UPD);
return UPD;
9802}

9804/// Additional checks for a using declaration referring to a constructor name.
9805bool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) {
assert(!UD->hasTypename() && "expecting a constructor name")(static_cast <bool> (!UD->hasTypename() && "expecting a constructor name"
) ? void (0) : __assert_fail ("!UD->hasTypename() && \"expecting a constructor name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9806, __extension__ __PRETTY_FUNCTION__));

const Type *SourceType = UD->getQualifier()->getAsType();
assert(SourceType &&(static_cast <bool> (SourceType && "Using decl naming constructor doesn't have type in scope spec."
) ? void (0) : __assert_fail ("SourceType && \"Using decl naming constructor doesn't have type in scope spec.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9810, __extension__ __PRETTY_FUNCTION__))
       "Using decl naming constructor doesn't have type in scope spec.")(static_cast <bool> (SourceType && "Using decl naming constructor doesn't have type in scope spec."
) ? void (0) : __assert_fail ("SourceType && \"Using decl naming constructor doesn't have type in scope spec.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 9810, __extension__ __PRETTY_FUNCTION__));
CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);

// Check whether the named type is a direct base class.
bool AnyDependentBases = false;
auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
                                    AnyDependentBases);
if (!Base && !AnyDependentBases) {
  Diag(UD->getUsingLoc(),
       diag::err_using_decl_constructor_not_in_direct_base)
    << UD->getNameInfo().getSourceRange()
    << QualType(SourceType, 0) << TargetClass;
  UD->setInvalidDecl();
  return true;
}

if (Base)
  Base->setInheritConstructors();

return false;
9830}

9832/// Checks that the given using declaration is not an invalid
9833/// redeclaration.  Note that this is checking only for the using decl
9834/// itself, not for any ill-formedness among the UsingShadowDecls.
9835bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
                                     bool HasTypenameKeyword,
                                     const CXXScopeSpec &SS,
                                     SourceLocation NameLoc,
                                     const LookupResult &Prev) {
NestedNameSpecifier *Qual = SS.getScopeRep();

// C++03 [namespace.udecl]p8:
// C++0x [namespace.udecl]p10:
//   A using-declaration is a declaration and can therefore be used
//   repeatedly where (and only where) multiple declarations are
//   allowed.
//
// That's in non-member contexts.
if (!CurContext->getRedeclContext()->isRecord()) {
  // A dependent qualifier outside a class can only ever resolve to an
  // enumeration type. Therefore it conflicts with any other non-type
  // declaration in the same scope.
  // FIXME: How should we check for dependent type-type conflicts at block
  // scope?
  if (Qual->isDependent() && !HasTypenameKeyword) {
    for (auto *D : Prev) {
      if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {
        bool OldCouldBeEnumerator =
            isa<UnresolvedUsingValueDecl>(D) || isa<EnumConstantDecl>(D);
        Diag(NameLoc,
             OldCouldBeEnumerator ? diag::err_redefinition
                                  : diag::err_redefinition_different_kind)
            << Prev.getLookupName();
        Diag(D->getLocation(), diag::note_previous_definition);
        return true;
      }
    }
  }
  return false;
}

for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
  NamedDecl *D = *I;

  bool DTypename;
  NestedNameSpecifier *DQual;
  if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
    DTypename = UD->hasTypename();
    DQual = UD->getQualifier();
  } else if (UnresolvedUsingValueDecl *UD
               = dyn_cast<UnresolvedUsingValueDecl>(D)) {
    DTypename = false;
    DQual = UD->getQualifier();
  } else if (UnresolvedUsingTypenameDecl *UD
               = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
    DTypename = true;
    DQual = UD->getQualifier();
  } else continue;

  // using decls differ if one says 'typename' and the other doesn't.
  // FIXME: non-dependent using decls?
  if (HasTypenameKeyword != DTypename) continue;

  // using decls differ if they name different scopes (but note that
  // template instantiation can cause this check to trigger when it
  // didn't before instantiation).
  if (Context.getCanonicalNestedNameSpecifier(Qual) !=
      Context.getCanonicalNestedNameSpecifier(DQual))
    continue;

  Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
  Diag(D->getLocation(), diag::note_using_decl) << 1;
  return true;
}

return false;
9907}


9910/// Checks that the given nested-name qualifier used in a using decl
9911/// in the current context is appropriately related to the current
9912/// scope.  If an error is found, diagnoses it and returns true.
9913bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
                                 bool HasTypename,
                                 const CXXScopeSpec &SS,
                                 const DeclarationNameInfo &NameInfo,
                                 SourceLocation NameLoc) {
DeclContext *NamedContext = computeDeclContext(SS);

if (!CurContext->isRecord()) {
  // C++03 [namespace.udecl]p3:
  // C++0x [namespace.udecl]p8:
  //   A using-declaration for a class member shall be a member-declaration.

  // If we weren't able to compute a valid scope, it might validly be a
  // dependent class scope or a dependent enumeration unscoped scope. If
  // we have a 'typename' keyword, the scope must resolve to a class type.
  if ((HasTypename && !NamedContext) ||
      (NamedContext && NamedContext->getRedeclContext()->isRecord())) {
    auto *RD = NamedContext
                   ? cast<CXXRecordDecl>(NamedContext->getRedeclContext())
                   : nullptr;
    if (RD && RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), RD))
      RD = nullptr;

    Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
      << SS.getRange();

    // If we have a complete, non-dependent source type, try to suggest a
    // way to get the same effect.
    if (!RD)
      return true;

    // Find what this using-declaration was referring to.
    LookupResult R(*this, NameInfo, LookupOrdinaryName);
    R.setHideTags(false);
    R.suppressDiagnostics();
    LookupQualifiedName(R, RD);

    if (R.getAsSingle<TypeDecl>()) {
      if (getLangOpts().CPlusPlus11) {
        // Convert 'using X::Y;' to 'using Y = X::Y;'.
        Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround)
          << 0 // alias declaration
          << FixItHint::CreateInsertion(SS.getBeginLoc(),
                                        NameInfo.getName().getAsString() +
                                            " = ");
      } else {
        // Convert 'using X::Y;' to 'typedef X::Y Y;'.
        SourceLocation InsertLoc =
            getLocForEndOfToken(NameInfo.getLocEnd());
        Diag(InsertLoc, diag::note_using_decl_class_member_workaround)
          << 1 // typedef declaration
          << FixItHint::CreateReplacement(UsingLoc, "typedef")
          << FixItHint::CreateInsertion(
                 InsertLoc, " " + NameInfo.getName().getAsString());
      }
    } else if (R.getAsSingle<VarDecl>()) {
      // Don't provide a fixit outside C++11 mode; we don't want to suggest
      // repeating the type of the static data member here.
      FixItHint FixIt;
      if (getLangOpts().CPlusPlus11) {
        // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
        FixIt = FixItHint::CreateReplacement(
            UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
      }

      Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
        << 2 // reference declaration
        << FixIt;
    } else if (R.getAsSingle<EnumConstantDecl>()) {
      // Don't provide a fixit outside C++11 mode; we don't want to suggest
      // repeating the type of the enumeration here, and we can't do so if
      // the type is anonymous.
      FixItHint FixIt;
      if (getLangOpts().CPlusPlus11) {
        // Convert 'using X::Y;' to 'auto &Y = X::Y;'.
        FixIt = FixItHint::CreateReplacement(
            UsingLoc,
            "constexpr auto " + NameInfo.getName().getAsString() + " = ");
      }

      Diag(UsingLoc, diag::note_using_decl_class_member_workaround)
        << (getLangOpts().CPlusPlus11 ? 4 : 3) // const[expr] variable
        << FixIt;
    }
    return true;
  }

  // Otherwise, this might be valid.
  return false;
}

// The current scope is a record.

// If the named context is dependent, we can't decide much.
if (!NamedContext) {
  // FIXME: in C++0x, we can diagnose if we can prove that the
  // nested-name-specifier does not refer to a base class, which is
  // still possible in some cases.

  // Otherwise we have to conservatively report that things might be
  // okay.
  return false;
}

if (!NamedContext->isRecord()) {
  // Ideally this would point at the last name in the specifier,
  // but we don't have that level of source info.
  Diag(SS.getRange().getBegin(),
       diag::err_using_decl_nested_name_specifier_is_not_class)
    << SS.getScopeRep() << SS.getRange();
  return true;
}

if (!NamedContext->isDependentContext() &&
    RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
  return true;

if (getLangOpts().CPlusPlus11) {
  // C++11 [namespace.udecl]p3:
  //   In a using-declaration used as a member-declaration, the
  //   nested-name-specifier shall name a base class of the class
  //   being defined.

  if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
                               cast<CXXRecordDecl>(NamedContext))) {
    if (CurContext == NamedContext) {
      Diag(NameLoc,
           diag::err_using_decl_nested_name_specifier_is_current_class)
        << SS.getRange();
      return true;
    }

    if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {
      Diag(SS.getRange().getBegin(),
           diag::err_using_decl_nested_name_specifier_is_not_base_class)
        << SS.getScopeRep()
        << cast<CXXRecordDecl>(CurContext)
        << SS.getRange();
    }
    return true;
  }

  return false;
}

// C++03 [namespace.udecl]p4:
//   A using-declaration used as a member-declaration shall refer
//   to a member of a base class of the class being defined [etc.].

// Salient point: SS doesn't have to name a base class as long as
// lookup only finds members from base classes.  Therefore we can
// diagnose here only if we can prove that that can't happen,
// i.e. if the class hierarchies provably don't intersect.

// TODO: it would be nice if "definitely valid" results were cached
// in the UsingDecl and UsingShadowDecl so that these checks didn't
// need to be repeated.

llvm::SmallPtrSet<const CXXRecordDecl *, 4> Bases;
auto Collect = [&Bases](const CXXRecordDecl *Base) {
  Bases.insert(Base);
  return true;
};

// Collect all bases. Return false if we find a dependent base.
if (!cast<CXXRecordDecl>(CurContext)->forallBases(Collect))
  return false;

// Returns true if the base is dependent or is one of the accumulated base
// classes.
auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
  return !Bases.count(Base);
};

// Return false if the class has a dependent base or if it or one
// of its bases is present in the base set of the current context.
if (Bases.count(cast<CXXRecordDecl>(NamedContext)) ||
    !cast<CXXRecordDecl>(NamedContext)->forallBases(IsNotBase))
  return false;

Diag(SS.getRange().getBegin(),
     diag::err_using_decl_nested_name_specifier_is_not_base_class)
  << SS.getScopeRep()
  << cast<CXXRecordDecl>(CurContext)
  << SS.getRange();

return true;
10100}

10102Decl *Sema::ActOnAliasDeclaration(Scope *S,
                                AccessSpecifier AS,
                                MultiTemplateParamsArg TemplateParamLists,
                                SourceLocation UsingLoc,
                                UnqualifiedId &Name,
                                AttributeList *AttrList,
                                TypeResult Type,
                                Decl *DeclFromDeclSpec) {
// Skip up to the relevant declaration scope.
while (S->isTemplateParamScope())
  S = S->getParent();
assert((S->getFlags() & Scope::DeclScope) &&(static_cast <bool> ((S->getFlags() & Scope::DeclScope
) && "got alias-declaration outside of declaration scope"
) ? void (0) : __assert_fail ("(S->getFlags() & Scope::DeclScope) && \"got alias-declaration outside of declaration scope\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10114, __extension__ __PRETTY_FUNCTION__))
       "got alias-declaration outside of declaration scope")(static_cast <bool> ((S->getFlags() & Scope::DeclScope
) && "got alias-declaration outside of declaration scope"
) ? void (0) : __assert_fail ("(S->getFlags() & Scope::DeclScope) && \"got alias-declaration outside of declaration scope\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10114, __extension__ __PRETTY_FUNCTION__));

if (Type.isInvalid())
  return nullptr;

bool Invalid = false;
DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
TypeSourceInfo *TInfo = nullptr;
GetTypeFromParser(Type.get(), &TInfo);

if (DiagnoseClassNameShadow(CurContext, NameInfo))
  return nullptr;

if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
                                    UPPC_DeclarationType)) {
  Invalid = true;
  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
                                           TInfo->getTypeLoc().getBeginLoc());
}

LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                      TemplateParamLists.size()
                          ? forRedeclarationInCurContext()
                          : ForVisibleRedeclaration);
LookupName(Previous, S);

// Warn about shadowing the name of a template parameter.
if (Previous.isSingleResult() &&
    Previous.getFoundDecl()->isTemplateParameter()) {
  DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
  Previous.clear();
}

assert(Name.Kind == UnqualifiedIdKind::IK_Identifier &&(static_cast <bool> (Name.Kind == UnqualifiedIdKind::IK_Identifier
 && "name in alias declaration must be an identifier"
) ? void (0) : __assert_fail ("Name.Kind == UnqualifiedIdKind::IK_Identifier && \"name in alias declaration must be an identifier\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10148, __extension__ __PRETTY_FUNCTION__))
       "name in alias declaration must be an identifier")(static_cast <bool> (Name.Kind == UnqualifiedIdKind::IK_Identifier
 && "name in alias declaration must be an identifier"
) ? void (0) : __assert_fail ("Name.Kind == UnqualifiedIdKind::IK_Identifier && \"name in alias declaration must be an identifier\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10148, __extension__ __PRETTY_FUNCTION__));
TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
                                             Name.StartLocation,
                                             Name.Identifier, TInfo);

NewTD->setAccess(AS);

if (Invalid)
  NewTD->setInvalidDecl();

ProcessDeclAttributeList(S, NewTD, AttrList);
AddPragmaAttributes(S, NewTD);

CheckTypedefForVariablyModifiedType(S, NewTD);
Invalid |= NewTD->isInvalidDecl();

bool Redeclaration = false;

NamedDecl *NewND;
if (TemplateParamLists.size()) {
  TypeAliasTemplateDecl *OldDecl = nullptr;
  TemplateParameterList *OldTemplateParams = nullptr;

  if (TemplateParamLists.size() != 1) {
    Diag(UsingLoc, diag::err_alias_template_extra_headers)
      << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
       TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
  }
  TemplateParameterList *TemplateParams = TemplateParamLists[0];

  // Check that we can declare a template here.
  if (CheckTemplateDeclScope(S, TemplateParams))
    return nullptr;

  // Only consider previous declarations in the same scope.
  FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
                       /*ExplicitInstantiationOrSpecialization*/false);
  if (!Previous.empty()) {
    Redeclaration = true;

    OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
    if (!OldDecl && !Invalid) {
      Diag(UsingLoc, diag::err_redefinition_different_kind)
        << Name.Identifier;

      NamedDecl *OldD = Previous.getRepresentativeDecl();
      if (OldD->getLocation().isValid())
        Diag(OldD->getLocation(), diag::note_previous_definition);

      Invalid = true;
    }

    if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
      if (TemplateParameterListsAreEqual(TemplateParams,
                                         OldDecl->getTemplateParameters(),
                                         /*Complain=*/true,
                                         TPL_TemplateMatch))
        OldTemplateParams = OldDecl->getTemplateParameters();
      else
        Invalid = true;

      TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
      if (!Invalid &&
          !Context.hasSameType(OldTD->getUnderlyingType(),
                               NewTD->getUnderlyingType())) {
        // FIXME: The C++0x standard does not clearly say this is ill-formed,
        // but we can't reasonably accept it.
        Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
          << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
        if (OldTD->getLocation().isValid())
          Diag(OldTD->getLocation(), diag::note_previous_definition);
        Invalid = true;
      }
    }
  }

  // Merge any previous default template arguments into our parameters,
  // and check the parameter list.
  if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
                                 TPC_TypeAliasTemplate))
    return nullptr;

  TypeAliasTemplateDecl *NewDecl =
    TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
                                  Name.Identifier, TemplateParams,
                                  NewTD);
  NewTD->setDescribedAliasTemplate(NewDecl);

  NewDecl->setAccess(AS);

  if (Invalid)
    NewDecl->setInvalidDecl();
  else if (OldDecl) {
    NewDecl->setPreviousDecl(OldDecl);
    CheckRedeclarationModuleOwnership(NewDecl, OldDecl);
  }

  NewND = NewDecl;
} else {
  if (auto *TD = dyn_cast_or_null<TagDecl>(DeclFromDeclSpec)) {
    setTagNameForLinkagePurposes(TD, NewTD);
    handleTagNumbering(TD, S);
  }
  ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
  NewND = NewTD;
}

PushOnScopeChains(NewND, S);
ActOnDocumentableDecl(NewND);
return NewND;
10258}

10260Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc,
                                 SourceLocation AliasLoc,
                                 IdentifierInfo *Alias, CXXScopeSpec &SS,
                                 SourceLocation IdentLoc,
                                 IdentifierInfo *Ident) {

// Lookup the namespace name.
LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
LookupParsedName(R, S, &SS);

if (R.isAmbiguous())
  return nullptr;

if (R.empty()) {
  if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
    Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
    return nullptr;
  }
}
assert(!R.isAmbiguous() && !R.empty())(static_cast <bool> (!R.isAmbiguous() && !R.empty
()) ? void (0) : __assert_fail ("!R.isAmbiguous() && !R.empty()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10279, __extension__ __PRETTY_FUNCTION__));
NamedDecl *ND = R.getRepresentativeDecl();

// Check if we have a previous declaration with the same name.
LookupResult PrevR(*this, Alias, AliasLoc, LookupOrdinaryName,
                   ForVisibleRedeclaration);
LookupName(PrevR, S);

// Check we're not shadowing a template parameter.
if (PrevR.isSingleResult() && PrevR.getFoundDecl()->isTemplateParameter()) {
  DiagnoseTemplateParameterShadow(AliasLoc, PrevR.getFoundDecl());
  PrevR.clear();
}

// Filter out any other lookup result from an enclosing scope.
FilterLookupForScope(PrevR, CurContext, S, /*ConsiderLinkage*/false,
                     /*AllowInlineNamespace*/false);

// Find the previous declaration and check that we can redeclare it.
NamespaceAliasDecl *Prev = nullptr;
if (PrevR.isSingleResult()) {
  NamedDecl *PrevDecl = PrevR.getRepresentativeDecl();
  if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
    // We already have an alias with the same name that points to the same
    // namespace; check that it matches.
    if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {
      Prev = AD;
    } else if (isVisible(PrevDecl)) {
      Diag(AliasLoc, diag::err_redefinition_different_namespace_alias)
        << Alias;
      Diag(AD->getLocation(), diag::note_previous_namespace_alias)
        << AD->getNamespace();
      return nullptr;
    }
  } else if (isVisible(PrevDecl)) {
    unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl())
                          ? diag::err_redefinition
                          : diag::err_redefinition_different_kind;
    Diag(AliasLoc, DiagID) << Alias;
    Diag(PrevDecl->getLocation(), diag::note_previous_definition);
    return nullptr;
  }
}

// The use of a nested name specifier may trigger deprecation warnings.
DiagnoseUseOfDecl(ND, IdentLoc);

NamespaceAliasDecl *AliasDecl =
  NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
                             Alias, SS.getWithLocInContext(Context),
                             IdentLoc, ND);
if (Prev)
  AliasDecl->setPreviousDecl(Prev);

PushOnScopeChains(AliasDecl, S);
return AliasDecl;
10335}

10337namespace {
10338struct SpecialMemberExceptionSpecInfo
  : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
SourceLocation Loc;
Sema::ImplicitExceptionSpecification ExceptSpec;

SpecialMemberExceptionSpecInfo(Sema &S, CXXMethodDecl *MD,
                               Sema::CXXSpecialMember CSM,
                               Sema::InheritedConstructorInfo *ICI,
                               SourceLocation Loc)
    : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}

bool visitBase(CXXBaseSpecifier *Base);
bool visitField(FieldDecl *FD);

void visitClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
                         unsigned Quals);

void visitSubobjectCall(Subobject Subobj,
                        Sema::SpecialMemberOverloadResult SMOR);
10357};
10358}

10360bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
auto *RT = Base->getType()->getAs<RecordType>();
if (!RT)
  return false;

auto *BaseClass = cast<CXXRecordDecl>(RT->getDecl());
Sema::SpecialMemberOverloadResult SMOR = lookupInheritedCtor(BaseClass);
if (auto *BaseCtor = SMOR.getMethod()) {
  visitSubobjectCall(Base, BaseCtor);
  return false;
}

visitClassSubobject(BaseClass, Base, 0);
return false;
10374}

10376bool SpecialMemberExceptionSpecInfo::visitField(FieldDecl *FD) {
if (CSM == Sema::CXXDefaultConstructor && FD->hasInClassInitializer()) {
  Expr *E = FD->getInClassInitializer();
  if (!E)
    // FIXME: It's a little wasteful to build and throw away a
    // CXXDefaultInitExpr here.
    // FIXME: We should have a single context note pointing at Loc, and
    // this location should be MD->getLocation() instead, since that's
    // the location where we actually use the default init expression.
    E = S.BuildCXXDefaultInitExpr(Loc, FD).get();
  if (E)
    ExceptSpec.CalledExpr(E);
} else if (auto *RT = S.Context.getBaseElementType(FD->getType())
                          ->getAs<RecordType>()) {
  visitClassSubobject(cast<CXXRecordDecl>(RT->getDecl()), FD,
                      FD->getType().getCVRQualifiers());
}
return false;
10394}

10396void SpecialMemberExceptionSpecInfo::visitClassSubobject(CXXRecordDecl *Class,
                                                       Subobject Subobj,
                                                       unsigned Quals) {
FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
bool IsMutable = Field && Field->isMutable();
visitSubobjectCall(Subobj, lookupIn(Class, Quals, IsMutable));
10402}

10404void SpecialMemberExceptionSpecInfo::visitSubobjectCall(
  Subobject Subobj, Sema::SpecialMemberOverloadResult SMOR) {
// Note, if lookup fails, it doesn't matter what exception specification we
// choose because the special member will be deleted.
if (CXXMethodDecl *MD = SMOR.getMethod())
  ExceptSpec.CalledDecl(getSubobjectLoc(Subobj), MD);
10410}

10412static Sema::ImplicitExceptionSpecification
10413ComputeDefaultedSpecialMemberExceptionSpec(
  Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
  Sema::InheritedConstructorInfo *ICI) {
CXXRecordDecl *ClassDecl = MD->getParent();

// C++ [except.spec]p14:
//   An implicitly declared special member function (Clause 12) shall have an
//   exception-specification. [...]
SpecialMemberExceptionSpecInfo Info(S, MD, CSM, ICI, Loc);
if (ClassDecl->isInvalidDecl())
  return Info.ExceptSpec;

// C++1z [except.spec]p7:
//   [Look for exceptions thrown by] a constructor selected [...] to
//   initialize a potentially constructed subobject,
// C++1z [except.spec]p8:
//   The exception specification for an implicitly-declared destructor, or a
//   destructor without a noexcept-specifier, is potentially-throwing if and
//   only if any of the destructors for any of its potentially constructed
//   subojects is potentially throwing.
// FIXME: We respect the first rule but ignore the "potentially constructed"
// in the second rule to resolve a core issue (no number yet) that would have
// us reject:
//   struct A { virtual void f() = 0; virtual ~A() noexcept(false) = 0; };
//   struct B : A {};
//   struct C : B { void f(); };
// ... due to giving B::~B() a non-throwing exception specification.
Info.visit(Info.IsConstructor ? Info.VisitPotentiallyConstructedBases
                              : Info.VisitAllBases);

return Info.ExceptSpec;
10444}

10446namespace {
10447/// RAII object to register a special member as being currently declared.
10448struct DeclaringSpecialMember {
Sema &S;
Sema::SpecialMemberDecl D;
Sema::ContextRAII SavedContext;
bool WasAlreadyBeingDeclared;

DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
    : S(S), D(RD, CSM), SavedContext(S, RD) {
  WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
  if (WasAlreadyBeingDeclared)
    // This almost never happens, but if it does, ensure that our cache
    // doesn't contain a stale result.
    S.SpecialMemberCache.clear();
  else {
    // Register a note to be produced if we encounter an error while
    // declaring the special member.
    Sema::CodeSynthesisContext Ctx;
    Ctx.Kind = Sema::CodeSynthesisContext::DeclaringSpecialMember;
    // FIXME: We don't have a location to use here. Using the class's
    // location maintains the fiction that we declare all special members
    // with the class, but (1) it's not clear that lying about that helps our
    // users understand what's going on, and (2) there may be outer contexts
    // on the stack (some of which are relevant) and printing them exposes
    // our lies.
    Ctx.PointOfInstantiation = RD->getLocation();
    Ctx.Entity = RD;
    Ctx.SpecialMember = CSM;
    S.pushCodeSynthesisContext(Ctx);
  }
}
~DeclaringSpecialMember() {
  if (!WasAlreadyBeingDeclared) {
    S.SpecialMembersBeingDeclared.erase(D);
    S.popCodeSynthesisContext();
  }
}

/// \brief Are we already trying to declare this special member?
bool isAlreadyBeingDeclared() const {
  return WasAlreadyBeingDeclared;
}
10489};
10490}

10492void Sema::CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD) {
// Look up any existing declarations, but don't trigger declaration of all
// implicit special members with this name.
DeclarationName Name = FD->getDeclName();
LookupResult R(*this, Name, SourceLocation(), LookupOrdinaryName,
               ForExternalRedeclaration);
for (auto *D : FD->getParent()->lookup(Name))
  if (auto *Acceptable = R.getAcceptableDecl(D))
    R.addDecl(Acceptable);
R.resolveKind();
R.suppressDiagnostics();

CheckFunctionDeclaration(S, FD, R, /*IsMemberSpecialization*/false);
10505}

10507CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
                                                   CXXRecordDecl *ClassDecl) {
// C++ [class.ctor]p5:
//   A default constructor for a class X is a constructor of class X
//   that can be called without an argument. If there is no
//   user-declared constructor for class X, a default constructor is
//   implicitly declared. An implicitly-declared default constructor
//   is an inline public member of its class.
assert(ClassDecl->needsImplicitDefaultConstructor() &&(static_cast <bool> (ClassDecl->needsImplicitDefaultConstructor
() && "Should not build implicit default constructor!"
) ? void (0) : __assert_fail ("ClassDecl->needsImplicitDefaultConstructor() && \"Should not build implicit default constructor!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10516, __extension__ __PRETTY_FUNCTION__))
       "Should not build implicit default constructor!")(static_cast <bool> (ClassDecl->needsImplicitDefaultConstructor
() && "Should not build implicit default constructor!"
) ? void (0) : __assert_fail ("ClassDecl->needsImplicitDefaultConstructor() && \"Should not build implicit default constructor!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10516, __extension__ __PRETTY_FUNCTION__));

DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
if (DSM.isAlreadyBeingDeclared())
  return nullptr;

bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                   CXXDefaultConstructor,
                                                   false);

// Create the actual constructor declaration.
CanQualType ClassType
  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
SourceLocation ClassLoc = ClassDecl->getLocation();
DeclarationName Name
  = Context.DeclarationNames.getCXXConstructorName(ClassType);
DeclarationNameInfo NameInfo(Name, ClassLoc);
CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
    Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(),
    /*TInfo=*/nullptr, /*isExplicit=*/false, /*isInline=*/true,
    /*isImplicitlyDeclared=*/true, Constexpr);
DefaultCon->setAccess(AS_public);
DefaultCon->setDefaulted();

if (getLangOpts().CUDA) {
  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
                                          DefaultCon,
                                          /* ConstRHS */ false,
                                          /* Diagnose */ false);
}

// Build an exception specification pointing back at this constructor.
FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, DefaultCon);
DefaultCon->setType(Context.getFunctionType(Context.VoidTy, None, EPI));

// We don't need to use SpecialMemberIsTrivial here; triviality for default
// constructors is easy to compute.
DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());

// Note that we have declared this constructor.
++ASTContext::NumImplicitDefaultConstructorsDeclared;

Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, DefaultCon);

if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
  SetDeclDeleted(DefaultCon, ClassLoc);

if (S)
  PushOnScopeChains(DefaultCon, S, false);
ClassDecl->addDecl(DefaultCon);

return DefaultCon;
10569}

10571void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
                                          CXXConstructorDecl *Constructor) {
assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&(static_cast <bool> ((Constructor->isDefaulted() &&
 Constructor->isDefaultConstructor() && !Constructor
->doesThisDeclarationHaveABody() && !Constructor->
isDeleted()) && "DefineImplicitDefaultConstructor - call it for implicit default ctor"
) ? void (0) : __assert_fail ("(Constructor->isDefaulted() && Constructor->isDefaultConstructor() && !Constructor->doesThisDeclarationHaveABody() && !Constructor->isDeleted()) && \"DefineImplicitDefaultConstructor - call it for implicit default ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10576, __extension__ __PRETTY_FUNCTION__))
        !Constructor->doesThisDeclarationHaveABody() &&(static_cast <bool> ((Constructor->isDefaulted() &&
 Constructor->isDefaultConstructor() && !Constructor
->doesThisDeclarationHaveABody() && !Constructor->
isDeleted()) && "DefineImplicitDefaultConstructor - call it for implicit default ctor"
) ? void (0) : __assert_fail ("(Constructor->isDefaulted() && Constructor->isDefaultConstructor() && !Constructor->doesThisDeclarationHaveABody() && !Constructor->isDeleted()) && \"DefineImplicitDefaultConstructor - call it for implicit default ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10576, __extension__ __PRETTY_FUNCTION__))
        !Constructor->isDeleted()) &&(static_cast <bool> ((Constructor->isDefaulted() &&
 Constructor->isDefaultConstructor() && !Constructor
->doesThisDeclarationHaveABody() && !Constructor->
isDeleted()) && "DefineImplicitDefaultConstructor - call it for implicit default ctor"
) ? void (0) : __assert_fail ("(Constructor->isDefaulted() && Constructor->isDefaultConstructor() && !Constructor->doesThisDeclarationHaveABody() && !Constructor->isDeleted()) && \"DefineImplicitDefaultConstructor - call it for implicit default ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10576, __extension__ __PRETTY_FUNCTION__))
  "DefineImplicitDefaultConstructor - call it for implicit default ctor")(static_cast <bool> ((Constructor->isDefaulted() &&
 Constructor->isDefaultConstructor() && !Constructor
->doesThisDeclarationHaveABody() && !Constructor->
isDeleted()) && "DefineImplicitDefaultConstructor - call it for implicit default ctor"
) ? void (0) : __assert_fail ("(Constructor->isDefaulted() && Constructor->isDefaultConstructor() && !Constructor->doesThisDeclarationHaveABody() && !Constructor->isDeleted()) && \"DefineImplicitDefaultConstructor - call it for implicit default ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10576, __extension__ __PRETTY_FUNCTION__));
if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
  return;

CXXRecordDecl *ClassDecl = Constructor->getParent();
assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor")(static_cast <bool> (ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor"
) ? void (0) : __assert_fail ("ClassDecl && \"DefineImplicitDefaultConstructor - invalid constructor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10581, __extension__ __PRETTY_FUNCTION__));

SynthesizedFunctionScope Scope(*this, Constructor);

// The exception specification is needed because we are defining the
// function.
ResolveExceptionSpec(CurrentLocation,
                     Constructor->getType()->castAs<FunctionProtoType>());
MarkVTableUsed(CurrentLocation, ClassDecl);

// Add a context note for diagnostics produced after this point.
Scope.addContextNote(CurrentLocation);

if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
  Constructor->setInvalidDecl();
  return;
}

SourceLocation Loc = Constructor->getLocEnd().isValid()
                         ? Constructor->getLocEnd()
                         : Constructor->getLocation();
Constructor->setBody(new (Context) CompoundStmt(Loc));
Constructor->markUsed(Context);

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(Constructor);
}

DiagnoseUninitializedFields(*this, Constructor);
10610}

10612void Sema::ActOnFinishDelayedMemberInitializers(Decl *D) {
// Perform any delayed checks on exception specifications.
CheckDelayedMemberExceptionSpecs();
10615}

10617/// Find or create the fake constructor we synthesize to model constructing an
10618/// object of a derived class via a constructor of a base class.
10619CXXConstructorDecl *
10620Sema::findInheritingConstructor(SourceLocation Loc,
                              CXXConstructorDecl *BaseCtor,
                              ConstructorUsingShadowDecl *Shadow) {
CXXRecordDecl *Derived = Shadow->getParent();
SourceLocation UsingLoc = Shadow->getLocation();

// FIXME: Add a new kind of DeclarationName for an inherited constructor.
// For now we use the name of the base class constructor as a member of the
// derived class to indicate a (fake) inherited constructor name.
DeclarationName Name = BaseCtor->getDeclName();

// Check to see if we already have a fake constructor for this inherited
// constructor call.
for (NamedDecl *Ctor : Derived->lookup(Name))
  if (declaresSameEntity(cast<CXXConstructorDecl>(Ctor)
                             ->getInheritedConstructor()
                             .getConstructor(),
                         BaseCtor))
    return cast<CXXConstructorDecl>(Ctor);

DeclarationNameInfo NameInfo(Name, UsingLoc);
TypeSourceInfo *TInfo =
    Context.getTrivialTypeSourceInfo(BaseCtor->getType(), UsingLoc);
FunctionProtoTypeLoc ProtoLoc =
    TInfo->getTypeLoc().IgnoreParens().castAs<FunctionProtoTypeLoc>();

// Check the inherited constructor is valid and find the list of base classes
// from which it was inherited.
InheritedConstructorInfo ICI(*this, Loc, Shadow);

bool Constexpr =
    BaseCtor->isConstexpr() &&
    defaultedSpecialMemberIsConstexpr(*this, Derived, CXXDefaultConstructor,
                                      false, BaseCtor, &ICI);

CXXConstructorDecl *DerivedCtor = CXXConstructorDecl::Create(
    Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
    BaseCtor->isExplicit(), /*Inline=*/true,
    /*ImplicitlyDeclared=*/true, Constexpr,
    InheritedConstructor(Shadow, BaseCtor));
if (Shadow->isInvalidDecl())
  DerivedCtor->setInvalidDecl();

// Build an unevaluated exception specification for this fake constructor.
const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
EPI.ExceptionSpec.Type = EST_Unevaluated;
EPI.ExceptionSpec.SourceDecl = DerivedCtor;
DerivedCtor->setType(Context.getFunctionType(FPT->getReturnType(),
                                             FPT->getParamTypes(), EPI));

// Build the parameter declarations.
SmallVector<ParmVarDecl *, 16> ParamDecls;
for (unsigned I = 0, N = FPT->getNumParams(); I != N; ++I) {
  TypeSourceInfo *TInfo =
      Context.getTrivialTypeSourceInfo(FPT->getParamType(I), UsingLoc);
  ParmVarDecl *PD = ParmVarDecl::Create(
      Context, DerivedCtor, UsingLoc, UsingLoc, /*IdentifierInfo=*/nullptr,
      FPT->getParamType(I), TInfo, SC_None, /*DefaultArg=*/nullptr);
  PD->setScopeInfo(0, I);
  PD->setImplicit();
  // Ensure attributes are propagated onto parameters (this matters for
  // format, pass_object_size, ...).
  mergeDeclAttributes(PD, BaseCtor->getParamDecl(I));
  ParamDecls.push_back(PD);
  ProtoLoc.setParam(I, PD);
}

// Set up the new constructor.
assert(!BaseCtor->isDeleted() && "should not use deleted constructor")(static_cast <bool> (!BaseCtor->isDeleted() &&
 "should not use deleted constructor") ? void (0) : __assert_fail
 ("!BaseCtor->isDeleted() && \"should not use deleted constructor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10689, __extension__ __PRETTY_FUNCTION__));
DerivedCtor->setAccess(BaseCtor->getAccess());
DerivedCtor->setParams(ParamDecls);
Derived->addDecl(DerivedCtor);

if (ShouldDeleteSpecialMember(DerivedCtor, CXXDefaultConstructor, &ICI))
  SetDeclDeleted(DerivedCtor, UsingLoc);

return DerivedCtor;
10698}

10700void Sema::NoteDeletedInheritingConstructor(CXXConstructorDecl *Ctor) {
InheritedConstructorInfo ICI(*this, Ctor->getLocation(),
                             Ctor->getInheritedConstructor().getShadowDecl());
ShouldDeleteSpecialMember(Ctor, CXXDefaultConstructor, &ICI,
                          /*Diagnose*/true);
10705}

10707void Sema::DefineInheritingConstructor(SourceLocation CurrentLocation,
                                     CXXConstructorDecl *Constructor) {
CXXRecordDecl *ClassDecl = Constructor->getParent();
assert(Constructor->getInheritedConstructor() &&(static_cast <bool> (Constructor->getInheritedConstructor
() && !Constructor->doesThisDeclarationHaveABody()
 && !Constructor->isDeleted()) ? void (0) : __assert_fail
 ("Constructor->getInheritedConstructor() && !Constructor->doesThisDeclarationHaveABody() && !Constructor->isDeleted()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10712, __extension__ __PRETTY_FUNCTION__))
       !Constructor->doesThisDeclarationHaveABody() &&(static_cast <bool> (Constructor->getInheritedConstructor
() && !Constructor->doesThisDeclarationHaveABody()
 && !Constructor->isDeleted()) ? void (0) : __assert_fail
 ("Constructor->getInheritedConstructor() && !Constructor->doesThisDeclarationHaveABody() && !Constructor->isDeleted()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10712, __extension__ __PRETTY_FUNCTION__))
       !Constructor->isDeleted())(static_cast <bool> (Constructor->getInheritedConstructor
() && !Constructor->doesThisDeclarationHaveABody()
 && !Constructor->isDeleted()) ? void (0) : __assert_fail
 ("Constructor->getInheritedConstructor() && !Constructor->doesThisDeclarationHaveABody() && !Constructor->isDeleted()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10712, __extension__ __PRETTY_FUNCTION__));
if (Constructor->willHaveBody() || Constructor->isInvalidDecl())
  return;

// Initializations are performed "as if by a defaulted default constructor",
// so enter the appropriate scope.
SynthesizedFunctionScope Scope(*this, Constructor);

// The exception specification is needed because we are defining the
// function.
ResolveExceptionSpec(CurrentLocation,
                     Constructor->getType()->castAs<FunctionProtoType>());
MarkVTableUsed(CurrentLocation, ClassDecl);

// Add a context note for diagnostics produced after this point.
Scope.addContextNote(CurrentLocation);

ConstructorUsingShadowDecl *Shadow =
    Constructor->getInheritedConstructor().getShadowDecl();
CXXConstructorDecl *InheritedCtor =
    Constructor->getInheritedConstructor().getConstructor();

// [class.inhctor.init]p1:
//   initialization proceeds as if a defaulted default constructor is used to
//   initialize the D object and each base class subobject from which the
//   constructor was inherited

InheritedConstructorInfo ICI(*this, CurrentLocation, Shadow);
CXXRecordDecl *RD = Shadow->getParent();
SourceLocation InitLoc = Shadow->getLocation();

// Build explicit initializers for all base classes from which the
// constructor was inherited.
SmallVector<CXXCtorInitializer*, 8> Inits;
for (bool VBase : {false, true}) {
  for (CXXBaseSpecifier &B : VBase ? RD->vbases() : RD->bases()) {
    if (B.isVirtual() != VBase)
      continue;

    auto *BaseRD = B.getType()->getAsCXXRecordDecl();
    if (!BaseRD)
      continue;

    auto BaseCtor = ICI.findConstructorForBase(BaseRD, InheritedCtor);
    if (!BaseCtor.first)
      continue;

    MarkFunctionReferenced(CurrentLocation, BaseCtor.first);
    ExprResult Init = new (Context) CXXInheritedCtorInitExpr(
        InitLoc, B.getType(), BaseCtor.first, VBase, BaseCtor.second);

    auto *TInfo = Context.getTrivialTypeSourceInfo(B.getType(), InitLoc);
    Inits.push_back(new (Context) CXXCtorInitializer(
        Context, TInfo, VBase, InitLoc, Init.get(), InitLoc,
        SourceLocation()));
  }
}

// We now proceed as if for a defaulted default constructor, with the relevant
// initializers replaced.

if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits)) {
  Constructor->setInvalidDecl();
  return;
}

Constructor->setBody(new (Context) CompoundStmt(InitLoc));
Constructor->markUsed(Context);

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(Constructor);
}

DiagnoseUninitializedFields(*this, Constructor);
10786}

10788CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) {
// C++ [class.dtor]p2:
//   If a class has no user-declared destructor, a destructor is
//   declared implicitly. An implicitly-declared destructor is an
//   inline public member of its class.
assert(ClassDecl->needsImplicitDestructor())(static_cast <bool> (ClassDecl->needsImplicitDestructor
()) ? void (0) : __assert_fail ("ClassDecl->needsImplicitDestructor()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10793, __extension__ __PRETTY_FUNCTION__));

DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
if (DSM.isAlreadyBeingDeclared())
  return nullptr;

// Create the actual destructor declaration.
CanQualType ClassType
  = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
SourceLocation ClassLoc = ClassDecl->getLocation();
DeclarationName Name
  = Context.DeclarationNames.getCXXDestructorName(ClassType);
DeclarationNameInfo NameInfo(Name, ClassLoc);
CXXDestructorDecl *Destructor
    = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
                                QualType(), nullptr, /*isInline=*/true,
                                /*isImplicitlyDeclared=*/true);
Destructor->setAccess(AS_public);
Destructor->setDefaulted();

if (getLangOpts().CUDA) {
  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDestructor,
                                          Destructor,
                                          /* ConstRHS */ false,
                                          /* Diagnose */ false);
}

// Build an exception specification pointing back at this destructor.
FunctionProtoType::ExtProtoInfo EPI = getImplicitMethodEPI(*this, Destructor);
Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));

// We don't need to use SpecialMemberIsTrivial here; triviality for
// destructors is easy to compute.
Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
Destructor->setTrivialForCall(ClassDecl->hasAttr<TrivialABIAttr>() ||
                              ClassDecl->hasTrivialDestructorForCall());

// Note that we have declared this destructor.
++ASTContext::NumImplicitDestructorsDeclared;

Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, Destructor);

// We can't check whether an implicit destructor is deleted before we complete
// the definition of the class, because its validity depends on the alignment
// of the class. We'll check this from ActOnFields once the class is complete.
if (ClassDecl->isCompleteDefinition() &&
    ShouldDeleteSpecialMember(Destructor, CXXDestructor))
  SetDeclDeleted(Destructor, ClassLoc);

// Introduce this destructor into its scope.
if (S)
  PushOnScopeChains(Destructor, S, false);
ClassDecl->addDecl(Destructor);

return Destructor;
10849}

10851void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
                                  CXXDestructorDecl *Destructor) {
assert((Destructor->isDefaulted() &&(static_cast <bool> ((Destructor->isDefaulted() &&
 !Destructor->doesThisDeclarationHaveABody() && !Destructor
->isDeleted()) && "DefineImplicitDestructor - call it for implicit default dtor"
) ? void (0) : __assert_fail ("(Destructor->isDefaulted() && !Destructor->doesThisDeclarationHaveABody() && !Destructor->isDeleted()) && \"DefineImplicitDestructor - call it for implicit default dtor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10856, __extension__ __PRETTY_FUNCTION__))
        !Destructor->doesThisDeclarationHaveABody() &&(static_cast <bool> ((Destructor->isDefaulted() &&
 !Destructor->doesThisDeclarationHaveABody() && !Destructor
->isDeleted()) && "DefineImplicitDestructor - call it for implicit default dtor"
) ? void (0) : __assert_fail ("(Destructor->isDefaulted() && !Destructor->doesThisDeclarationHaveABody() && !Destructor->isDeleted()) && \"DefineImplicitDestructor - call it for implicit default dtor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10856, __extension__ __PRETTY_FUNCTION__))
        !Destructor->isDeleted()) &&(static_cast <bool> ((Destructor->isDefaulted() &&
 !Destructor->doesThisDeclarationHaveABody() && !Destructor
->isDeleted()) && "DefineImplicitDestructor - call it for implicit default dtor"
) ? void (0) : __assert_fail ("(Destructor->isDefaulted() && !Destructor->doesThisDeclarationHaveABody() && !Destructor->isDeleted()) && \"DefineImplicitDestructor - call it for implicit default dtor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10856, __extension__ __PRETTY_FUNCTION__))
       "DefineImplicitDestructor - call it for implicit default dtor")(static_cast <bool> ((Destructor->isDefaulted() &&
 !Destructor->doesThisDeclarationHaveABody() && !Destructor
->isDeleted()) && "DefineImplicitDestructor - call it for implicit default dtor"
) ? void (0) : __assert_fail ("(Destructor->isDefaulted() && !Destructor->doesThisDeclarationHaveABody() && !Destructor->isDeleted()) && \"DefineImplicitDestructor - call it for implicit default dtor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10856, __extension__ __PRETTY_FUNCTION__));
if (Destructor->willHaveBody() || Destructor->isInvalidDecl())
  return;

CXXRecordDecl *ClassDecl = Destructor->getParent();
assert(ClassDecl && "DefineImplicitDestructor - invalid destructor")(static_cast <bool> (ClassDecl && "DefineImplicitDestructor - invalid destructor"
) ? void (0) : __assert_fail ("ClassDecl && \"DefineImplicitDestructor - invalid destructor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10861, __extension__ __PRETTY_FUNCTION__));

SynthesizedFunctionScope Scope(*this, Destructor);

// The exception specification is needed because we are defining the
// function.
ResolveExceptionSpec(CurrentLocation,
                     Destructor->getType()->castAs<FunctionProtoType>());
MarkVTableUsed(CurrentLocation, ClassDecl);

// Add a context note for diagnostics produced after this point.
Scope.addContextNote(CurrentLocation);

MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
                                       Destructor->getParent());

if (CheckDestructor(Destructor)) {
  Destructor->setInvalidDecl();
  return;
}

SourceLocation Loc = Destructor->getLocEnd().isValid()
                         ? Destructor->getLocEnd()
                         : Destructor->getLocation();
Destructor->setBody(new (Context) CompoundStmt(Loc));
Destructor->markUsed(Context);

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(Destructor);
}
10891}

10893/// \brief Perform any semantic analysis which needs to be delayed until all
10894/// pending class member declarations have been parsed.
10895void Sema::ActOnFinishCXXMemberDecls() {
// If the context is an invalid C++ class, just suppress these checks.
if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(CurContext)) {
  if (Record->isInvalidDecl()) {
    DelayedDefaultedMemberExceptionSpecs.clear();
    DelayedExceptionSpecChecks.clear();
    return;
  }
  checkForMultipleExportedDefaultConstructors(*this, Record);
}
10905}

10907void Sema::ActOnFinishCXXNonNestedClass(Decl *D) {
referenceDLLExportedClassMethods();
10909}

10911void Sema::referenceDLLExportedClassMethods() {
if (!DelayedDllExportClasses.empty()) {
  // Calling ReferenceDllExportedMembers might cause the current function to
  // be called again, so use a local copy of DelayedDllExportClasses.
  SmallVector<CXXRecordDecl *, 4> WorkList;
  std::swap(DelayedDllExportClasses, WorkList);
  for (CXXRecordDecl *Class : WorkList)
    ReferenceDllExportedMembers(*this, Class);
}
10920}

10922void Sema::AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl,
                                       CXXDestructorDecl *Destructor) {
assert(getLangOpts().CPlusPlus11 &&(static_cast <bool> (getLangOpts().CPlusPlus11 &&
 "adjusting dtor exception specs was introduced in c++11") ? void
 (0) : __assert_fail ("getLangOpts().CPlusPlus11 && \"adjusting dtor exception specs was introduced in c++11\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10925, __extension__ __PRETTY_FUNCTION__))
       "adjusting dtor exception specs was introduced in c++11")(static_cast <bool> (getLangOpts().CPlusPlus11 &&
 "adjusting dtor exception specs was introduced in c++11") ? void
 (0) : __assert_fail ("getLangOpts().CPlusPlus11 && \"adjusting dtor exception specs was introduced in c++11\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10925, __extension__ __PRETTY_FUNCTION__));

// C++11 [class.dtor]p3:
//   A declaration of a destructor that does not have an exception-
//   specification is implicitly considered to have the same exception-
//   specification as an implicit declaration.
const FunctionProtoType *DtorType = Destructor->getType()->
                                      getAs<FunctionProtoType>();
if (DtorType->hasExceptionSpec())
  return;

// Replace the destructor's type, building off the existing one. Fortunately,
// the only thing of interest in the destructor type is its extended info.
// The return and arguments are fixed.
FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
EPI.ExceptionSpec.Type = EST_Unevaluated;
EPI.ExceptionSpec.SourceDecl = Destructor;
Destructor->setType(Context.getFunctionType(Context.VoidTy, None, EPI));

// FIXME: If the destructor has a body that could throw, and the newly created
// spec doesn't allow exceptions, we should emit a warning, because this
// change in behavior can break conforming C++03 programs at runtime.
// However, we don't have a body or an exception specification yet, so it
// needs to be done somewhere else.
10949}

10951namespace {
10952/// \brief An abstract base class for all helper classes used in building the
10953//  copy/move operators. These classes serve as factory functions and help us
10954//  avoid using the same Expr* in the AST twice.
10955class ExprBuilder {
ExprBuilder(const ExprBuilder&) = delete;
ExprBuilder &operator=(const ExprBuilder&) = delete;

10959protected:
static Expr *assertNotNull(Expr *E) {
  assert(E && "Expression construction must not fail.")(static_cast <bool> (E && "Expression construction must not fail."
) ? void (0) : __assert_fail ("E && \"Expression construction must not fail.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 10961, __extension__ __PRETTY_FUNCTION__));
  return E;
}

10965public:
ExprBuilder() {}
virtual ~ExprBuilder() {}

virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
10970};

10972class RefBuilder: public ExprBuilder {
VarDecl *Var;
QualType VarType;

10976public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc).get());
}

RefBuilder(VarDecl *Var, QualType VarType)
    : Var(Var), VarType(VarType) {}
10983};

10985class ThisBuilder: public ExprBuilder {
10986public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
}
10990};

10992class CastBuilder: public ExprBuilder {
const ExprBuilder &Builder;
QualType Type;
ExprValueKind Kind;
const CXXCastPath &Path;

10998public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
                                           CK_UncheckedDerivedToBase, Kind,
                                           &Path).get());
}

CastBuilder(const ExprBuilder &Builder, QualType Type, ExprValueKind Kind,
            const CXXCastPath &Path)
    : Builder(Builder), Type(Type), Kind(Kind), Path(Path) {}
11008};

11010class DerefBuilder: public ExprBuilder {
const ExprBuilder &Builder;

11013public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(
      S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
}

DerefBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
11020};

11022class MemberBuilder: public ExprBuilder {
const ExprBuilder &Builder;
QualType Type;
CXXScopeSpec SS;
bool IsArrow;
LookupResult &MemberLookup;

11029public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(S.BuildMemberReferenceExpr(
      Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
      nullptr, MemberLookup, nullptr, nullptr).get());
}

MemberBuilder(const ExprBuilder &Builder, QualType Type, bool IsArrow,
              LookupResult &MemberLookup)
    : Builder(Builder), Type(Type), IsArrow(IsArrow),
      MemberLookup(MemberLookup) {}
11040};

11042class MoveCastBuilder: public ExprBuilder {
const ExprBuilder &Builder;

11045public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
}

MoveCastBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
11051};

11053class LvalueConvBuilder: public ExprBuilder {
const ExprBuilder &Builder;

11056public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(
      S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
}

LvalueConvBuilder(const ExprBuilder &Builder) : Builder(Builder) {}
11063};

11065class SubscriptBuilder: public ExprBuilder {
const ExprBuilder &Base;
const ExprBuilder &Index;

11069public:
Expr *build(Sema &S, SourceLocation Loc) const override {
  return assertNotNull(S.CreateBuiltinArraySubscriptExpr(
      Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
}

SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
    : Base(Base), Index(Index) {}
11077};

11079} // end anonymous namespace

11081/// When generating a defaulted copy or move assignment operator, if a field
11082/// should be copied with __builtin_memcpy rather than via explicit assignments,
11083/// do so. This optimization only applies for arrays of scalars, and for arrays
11084/// of class type where the selected copy/move-assignment operator is trivial.
11085static StmtResult
11086buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T,
                         const ExprBuilder &ToB, const ExprBuilder &FromB) {
// Compute the size of the memory buffer to be copied.
QualType SizeType = S.Context.getSizeType();
llvm::APInt Size(S.Context.getTypeSize(SizeType),
                 S.Context.getTypeSizeInChars(T).getQuantity());

// Take the address of the field references for "from" and "to". We
// directly construct UnaryOperators here because semantic analysis
// does not permit us to take the address of an xvalue.
Expr *From = FromB.build(S, Loc);
From = new (S.Context) UnaryOperator(From, UO_AddrOf,
                       S.Context.getPointerType(From->getType()),
                       VK_RValue, OK_Ordinary, Loc, false);
Expr *To = ToB.build(S, Loc);
To = new (S.Context) UnaryOperator(To, UO_AddrOf,
                     S.Context.getPointerType(To->getType()),
                     VK_RValue, OK_Ordinary, Loc, false);

const Type *E = T->getBaseElementTypeUnsafe();
bool NeedsCollectableMemCpy =
  E->isRecordType() && E->getAs<RecordType>()->getDecl()->hasObjectMember();

// Create a reference to the __builtin_objc_memmove_collectable function
StringRef MemCpyName = NeedsCollectableMemCpy ?
  "__builtin_objc_memmove_collectable" :
  "__builtin_memcpy";
LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
               Sema::LookupOrdinaryName);
S.LookupName(R, S.TUScope, true);

FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
if (!MemCpy)
  // Something went horribly wrong earlier, and we will have complained
  // about it.
  return StmtError();

ExprResult MemCpyRef = S.BuildDeclRefExpr(MemCpy, S.Context.BuiltinFnTy,
                                          VK_RValue, Loc, nullptr);
assert(MemCpyRef.isUsable() && "Builtin reference cannot fail")(static_cast <bool> (MemCpyRef.isUsable() && "Builtin reference cannot fail"
) ? void (0) : __assert_fail ("MemCpyRef.isUsable() && \"Builtin reference cannot fail\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11125, __extension__ __PRETTY_FUNCTION__));

Expr *CallArgs[] = {
  To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
};
ExprResult Call = S.ActOnCallExpr(/*Scope=*/nullptr, MemCpyRef.get(),
                                  Loc, CallArgs, Loc);

assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!")(static_cast <bool> (!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!"
) ? void (0) : __assert_fail ("!Call.isInvalid() && \"Call to __builtin_memcpy cannot fail!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11133, __extension__ __PRETTY_FUNCTION__));
return Call.getAs<Stmt>();
11135}

11137/// \brief Builds a statement that copies/moves the given entity from \p From to
11138/// \c To.
11139///
11140/// This routine is used to copy/move the members of a class with an
11141/// implicitly-declared copy/move assignment operator. When the entities being
11142/// copied are arrays, this routine builds for loops to copy them.
11143///
11144/// \param S The Sema object used for type-checking.
11145///
11146/// \param Loc The location where the implicit copy/move is being generated.
11147///
11148/// \param T The type of the expressions being copied/moved. Both expressions
11149/// must have this type.
11150///
11151/// \param To The expression we are copying/moving to.
11152///
11153/// \param From The expression we are copying/moving from.
11154///
11155/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
11156/// Otherwise, it's a non-static member subobject.
11157///
11158/// \param Copying Whether we're copying or moving.
11159///
11160/// \param Depth Internal parameter recording the depth of the recursion.
11161///
11162/// \returns A statement or a loop that copies the expressions, or StmtResult(0)
11163/// if a memcpy should be used instead.
11164static StmtResult
11165buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
                               const ExprBuilder &To, const ExprBuilder &From,
                               bool CopyingBaseSubobject, bool Copying,
                               unsigned Depth = 0) {
// C++11 [class.copy]p28:
//   Each subobject is assigned in the manner appropriate to its type:
//
//     - if the subobject is of class type, as if by a call to operator= with
//       the subobject as the object expression and the corresponding
//       subobject of x as a single function argument (as if by explicit
//       qualification; that is, ignoring any possible virtual overriding
//       functions in more derived classes);
//
// C++03 [class.copy]p13:
//     - if the subobject is of class type, the copy assignment operator for
//       the class is used (as if by explicit qualification; that is,
//       ignoring any possible virtual overriding functions in more derived
//       classes);
if (const RecordType *RecordTy = T->getAs<RecordType>()) {
  CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());

  // Look for operator=.
  DeclarationName Name
    = S.Context.DeclarationNames.getCXXOperatorName(OO_Equal);
  LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
  S.LookupQualifiedName(OpLookup, ClassDecl, false);

  // Prior to C++11, filter out any result that isn't a copy/move-assignment
  // operator.
  if (!S.getLangOpts().CPlusPlus11) {
    LookupResult::Filter F = OpLookup.makeFilter();
    while (F.hasNext()) {
      NamedDecl *D = F.next();
      if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
        if (Method->isCopyAssignmentOperator() ||
            (!Copying && Method->isMoveAssignmentOperator()))
          continue;

      F.erase();
    }
    F.done();
  }

  // Suppress the protected check (C++ [class.protected]) for each of the
  // assignment operators we found. This strange dance is required when
  // we're assigning via a base classes's copy-assignment operator. To
  // ensure that we're getting the right base class subobject (without
  // ambiguities), we need to cast "this" to that subobject type; to
  // ensure that we don't go through the virtual call mechanism, we need
  // to qualify the operator= name with the base class (see below). However,
  // this means that if the base class has a protected copy assignment
  // operator, the protected member access check will fail. So, we
  // rewrite "protected" access to "public" access in this case, since we
  // know by construction that we're calling from a derived class.
  if (CopyingBaseSubobject) {
    for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
         L != LEnd; ++L) {
      if (L.getAccess() == AS_protected)
        L.setAccess(AS_public);
    }
  }

  // Create the nested-name-specifier that will be used to qualify the
  // reference to operator=; this is required to suppress the virtual
  // call mechanism.
  CXXScopeSpec SS;
  const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
  SS.MakeTrivial(S.Context,
                 NestedNameSpecifier::Create(S.Context, nullptr, false,
                                             CanonicalT),
                 Loc);

  // Create the reference to operator=.
  ExprResult OpEqualRef
    = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*isArrow=*/false,
                                 SS, /*TemplateKWLoc=*/SourceLocation(),
                                 /*FirstQualifierInScope=*/nullptr,
                                 OpLookup,
                                 /*TemplateArgs=*/nullptr, /*S*/nullptr,
                                 /*SuppressQualifierCheck=*/true);
  if (OpEqualRef.isInvalid())
    return StmtError();

  // Build the call to the assignment operator.

  Expr *FromInst = From.build(S, Loc);
  ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/nullptr,
                                                OpEqualRef.getAs<Expr>(),
                                                Loc, FromInst, Loc);
  if (Call.isInvalid())
    return StmtError();

  // If we built a call to a trivial 'operator=' while copying an array,
  // bail out. We'll replace the whole shebang with a memcpy.
  CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Call.get());
  if (CE && CE->getMethodDecl()->isTrivial() && Depth)
    return StmtResult((Stmt*)nullptr);

  // Convert to an expression-statement, and clean up any produced
  // temporaries.
  return S.ActOnExprStmt(Call);
}

//     - if the subobject is of scalar type, the built-in assignment
//       operator is used.
const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
if (!ArrayTy) {
  ExprResult Assignment = S.CreateBuiltinBinOp(
      Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
  if (Assignment.isInvalid())
    return StmtError();
  return S.ActOnExprStmt(Assignment);
}

//     - if the subobject is an array, each element is assigned, in the
//       manner appropriate to the element type;

// Construct a loop over the array bounds, e.g.,
//
//   for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
//
// that will copy each of the array elements.
QualType SizeType = S.Context.getSizeType();

// Create the iteration variable.
IdentifierInfo *IterationVarName = nullptr;
{
  SmallString<8> Str;
  llvm::raw_svector_ostream OS(Str);
  OS << "__i" << Depth;
  IterationVarName = &S.Context.Idents.get(OS.str());
}
VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
                                        IterationVarName, SizeType,
                          S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
                                        SC_None);

// Initialize the iteration variable to zero.
llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));

// Creates a reference to the iteration variable.
RefBuilder IterationVarRef(IterationVar, SizeType);
LvalueConvBuilder IterationVarRefRVal(IterationVarRef);

// Create the DeclStmt that holds the iteration variable.
Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);

// Subscript the "from" and "to" expressions with the iteration variable.
SubscriptBuilder FromIndexCopy(From, IterationVarRefRVal);
MoveCastBuilder FromIndexMove(FromIndexCopy);
const ExprBuilder *FromIndex;
if (Copying)
  FromIndex = &FromIndexCopy;
else
  FromIndex = &FromIndexMove;

SubscriptBuilder ToIndex(To, IterationVarRefRVal);

// Build the copy/move for an individual element of the array.
StmtResult Copy =
  buildSingleCopyAssignRecursively(S, Loc, ArrayTy->getElementType(),
                                   ToIndex, *FromIndex, CopyingBaseSubobject,
                                   Copying, Depth + 1);
// Bail out if copying fails or if we determined that we should use memcpy.
if (Copy.isInvalid() || !Copy.get())
  return Copy;

// Create the comparison against the array bound.
llvm::APInt Upper
  = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
Expr *Comparison
  = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
                   IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
                                   BO_NE, S.Context.BoolTy,
                                   VK_RValue, OK_Ordinary, Loc, FPOptions());
11341
// Create the pre-increment of the iteration variable. We can determine
// whether the increment will overflow based on the value of the array
// bound.
Expr *Increment = new (S.Context)
    UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc, SizeType,
                  VK_LValue, OK_Ordinary, Loc, Upper.isMaxValue());
11348
// Construct the loop that copies all elements of this array.
return S.ActOnForStmt(
    Loc, Loc, InitStmt,
    S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
    S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
11354}

11356static StmtResult
11357buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T,
                    const ExprBuilder &To, const ExprBuilder &From,
                    bool CopyingBaseSubobject, bool Copying) {
// Maybe we should use a memcpy?
if (T->isArrayType() && !T.isConstQualified() && !T.isVolatileQualified() &&
    T.isTriviallyCopyableType(S.Context))
  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);

StmtResult Result(buildSingleCopyAssignRecursively(S, Loc, T, To, From,
                                                   CopyingBaseSubobject,
                                                   Copying, 0));

// If we ended up picking a trivial assignment operator for an array of a
// non-trivially-copyable class type, just emit a memcpy.
if (!Result.isInvalid() && !Result.get())
  return buildMemcpyForAssignmentOp(S, Loc, T, To, From);

return Result;
11375}

11377CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
// Note: The following rules are largely analoguous to the copy
// constructor rules. Note that virtual bases are not taken into account
// for determining the argument type of the operator. Note also that
// operators taking an object instead of a reference are allowed.
assert(ClassDecl->needsImplicitCopyAssignment())(static_cast <bool> (ClassDecl->needsImplicitCopyAssignment
()) ? void (0) : __assert_fail ("ClassDecl->needsImplicitCopyAssignment()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11382, __extension__ __PRETTY_FUNCTION__));

DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
if (DSM.isAlreadyBeingDeclared())
  return nullptr;

QualType ArgType = Context.getTypeDeclType(ClassDecl);
QualType RetType = Context.getLValueReferenceType(ArgType);
bool Const = ClassDecl->implicitCopyAssignmentHasConstParam();
if (Const)
  ArgType = ArgType.withConst();
ArgType = Context.getLValueReferenceType(ArgType);

bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                   CXXCopyAssignment,
                                                   Const);

//   An implicitly-declared copy assignment operator is an inline public
//   member of its class.
DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
SourceLocation ClassLoc = ClassDecl->getLocation();
DeclarationNameInfo NameInfo(Name, ClassLoc);
CXXMethodDecl *CopyAssignment =
    CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
                          /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
                          /*isInline=*/true, Constexpr, SourceLocation());
CopyAssignment->setAccess(AS_public);
CopyAssignment->setDefaulted();
CopyAssignment->setImplicit();

if (getLangOpts().CUDA) {
  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
                                          CopyAssignment,
                                          /* ConstRHS */ Const,
                                          /* Diagnose */ false);
}

// Build an exception specification pointing back at this member.
FunctionProtoType::ExtProtoInfo EPI =
    getImplicitMethodEPI(*this, CopyAssignment);
CopyAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));

// Add the parameter to the operator.
ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
                                             ClassLoc, ClassLoc,
                                             /*Id=*/nullptr, ArgType,
                                             /*TInfo=*/nullptr, SC_None,
                                             nullptr);
CopyAssignment->setParams(FromParam);

CopyAssignment->setTrivial(
  ClassDecl->needsOverloadResolutionForCopyAssignment()
    ? SpecialMemberIsTrivial(CopyAssignment, CXXCopyAssignment)
    : ClassDecl->hasTrivialCopyAssignment());

// Note that we have added this copy-assignment operator.
++ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;

Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, CopyAssignment);

if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
  SetDeclDeleted(CopyAssignment, ClassLoc);

if (S)
  PushOnScopeChains(CopyAssignment, S, false);
ClassDecl->addDecl(CopyAssignment);

return CopyAssignment;
11451}

11453/// Diagnose an implicit copy operation for a class which is odr-used, but
11454/// which is deprecated because the class has a user-declared copy constructor,
11455/// copy assignment operator, or destructor.
11456static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp) {
assert(CopyOp->isImplicit())(static_cast <bool> (CopyOp->isImplicit()) ? void (0
) : __assert_fail ("CopyOp->isImplicit()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11457, __extension__ __PRETTY_FUNCTION__));

CXXRecordDecl *RD = CopyOp->getParent();
CXXMethodDecl *UserDeclaredOperation = nullptr;

// In Microsoft mode, assignment operations don't affect constructors and
// vice versa.
if (RD->hasUserDeclaredDestructor()) {
  UserDeclaredOperation = RD->getDestructor();
} else if (!isa<CXXConstructorDecl>(CopyOp) &&
           RD->hasUserDeclaredCopyConstructor() &&
           !S.getLangOpts().MSVCCompat) {
  // Find any user-declared copy constructor.
  for (auto *I : RD->ctors()) {
    if (I->isCopyConstructor()) {
      UserDeclaredOperation = I;
      break;
    }
  }
  assert(UserDeclaredOperation)(static_cast <bool> (UserDeclaredOperation) ? void (0) :
 __assert_fail ("UserDeclaredOperation", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11476, __extension__ __PRETTY_FUNCTION__));
} else if (isa<CXXConstructorDecl>(CopyOp) &&
           RD->hasUserDeclaredCopyAssignment() &&
           !S.getLangOpts().MSVCCompat) {
  // Find any user-declared move assignment operator.
  for (auto *I : RD->methods()) {
    if (I->isCopyAssignmentOperator()) {
      UserDeclaredOperation = I;
      break;
    }
  }
  assert(UserDeclaredOperation)(static_cast <bool> (UserDeclaredOperation) ? void (0) :
 __assert_fail ("UserDeclaredOperation", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11487, __extension__ __PRETTY_FUNCTION__));
}

if (UserDeclaredOperation) {
  S.Diag(UserDeclaredOperation->getLocation(),
       diag::warn_deprecated_copy_operation)
    << RD << /*copy assignment*/!isa<CXXConstructorDecl>(CopyOp)
    << /*destructor*/isa<CXXDestructorDecl>(UserDeclaredOperation);
}
11496}

11498void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
                                      CXXMethodDecl *CopyAssignOperator) {
assert((CopyAssignOperator->isDefaulted() &&(static_cast <bool> ((CopyAssignOperator->isDefaulted
() && CopyAssignOperator->isOverloadedOperator() &&
 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
 !CopyAssignOperator->isDeleted()) && "DefineImplicitCopyAssignment called for wrong function"
) ? void (0) : __assert_fail ("(CopyAssignOperator->isDefaulted() && CopyAssignOperator->isOverloadedOperator() && CopyAssignOperator->getOverloadedOperator() == OO_Equal && !CopyAssignOperator->doesThisDeclarationHaveABody() && !CopyAssignOperator->isDeleted()) && \"DefineImplicitCopyAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11505, __extension__ __PRETTY_FUNCTION__))
        CopyAssignOperator->isOverloadedOperator() &&(static_cast <bool> ((CopyAssignOperator->isDefaulted
() && CopyAssignOperator->isOverloadedOperator() &&
 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
 !CopyAssignOperator->isDeleted()) && "DefineImplicitCopyAssignment called for wrong function"
) ? void (0) : __assert_fail ("(CopyAssignOperator->isDefaulted() && CopyAssignOperator->isOverloadedOperator() && CopyAssignOperator->getOverloadedOperator() == OO_Equal && !CopyAssignOperator->doesThisDeclarationHaveABody() && !CopyAssignOperator->isDeleted()) && \"DefineImplicitCopyAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11505, __extension__ __PRETTY_FUNCTION__))
        CopyAssignOperator->getOverloadedOperator() == OO_Equal &&(static_cast <bool> ((CopyAssignOperator->isDefaulted
() && CopyAssignOperator->isOverloadedOperator() &&
 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
 !CopyAssignOperator->isDeleted()) && "DefineImplicitCopyAssignment called for wrong function"
) ? void (0) : __assert_fail ("(CopyAssignOperator->isDefaulted() && CopyAssignOperator->isOverloadedOperator() && CopyAssignOperator->getOverloadedOperator() == OO_Equal && !CopyAssignOperator->doesThisDeclarationHaveABody() && !CopyAssignOperator->isDeleted()) && \"DefineImplicitCopyAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11505, __extension__ __PRETTY_FUNCTION__))
        !CopyAssignOperator->doesThisDeclarationHaveABody() &&(static_cast <bool> ((CopyAssignOperator->isDefaulted
() && CopyAssignOperator->isOverloadedOperator() &&
 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
 !CopyAssignOperator->isDeleted()) && "DefineImplicitCopyAssignment called for wrong function"
) ? void (0) : __assert_fail ("(CopyAssignOperator->isDefaulted() && CopyAssignOperator->isOverloadedOperator() && CopyAssignOperator->getOverloadedOperator() == OO_Equal && !CopyAssignOperator->doesThisDeclarationHaveABody() && !CopyAssignOperator->isDeleted()) && \"DefineImplicitCopyAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11505, __extension__ __PRETTY_FUNCTION__))
        !CopyAssignOperator->isDeleted()) &&(static_cast <bool> ((CopyAssignOperator->isDefaulted
() && CopyAssignOperator->isOverloadedOperator() &&
 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
 !CopyAssignOperator->isDeleted()) && "DefineImplicitCopyAssignment called for wrong function"
) ? void (0) : __assert_fail ("(CopyAssignOperator->isDefaulted() && CopyAssignOperator->isOverloadedOperator() && CopyAssignOperator->getOverloadedOperator() == OO_Equal && !CopyAssignOperator->doesThisDeclarationHaveABody() && !CopyAssignOperator->isDeleted()) && \"DefineImplicitCopyAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11505, __extension__ __PRETTY_FUNCTION__))
       "DefineImplicitCopyAssignment called for wrong function")(static_cast <bool> ((CopyAssignOperator->isDefaulted
() && CopyAssignOperator->isOverloadedOperator() &&
 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
 !CopyAssignOperator->isDeleted()) && "DefineImplicitCopyAssignment called for wrong function"
) ? void (0) : __assert_fail ("(CopyAssignOperator->isDefaulted() && CopyAssignOperator->isOverloadedOperator() && CopyAssignOperator->getOverloadedOperator() == OO_Equal && !CopyAssignOperator->doesThisDeclarationHaveABody() && !CopyAssignOperator->isDeleted()) && \"DefineImplicitCopyAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11505, __extension__ __PRETTY_FUNCTION__));
if (CopyAssignOperator->willHaveBody() || CopyAssignOperator->isInvalidDecl())
  return;

CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
if (ClassDecl->isInvalidDecl()) {
  CopyAssignOperator->setInvalidDecl();
  return;
}

SynthesizedFunctionScope Scope(*this, CopyAssignOperator);

// The exception specification is needed because we are defining the
// function.
ResolveExceptionSpec(CurrentLocation,
                     CopyAssignOperator->getType()->castAs<FunctionProtoType>());

// Add a context note for diagnostics produced after this point.
Scope.addContextNote(CurrentLocation);

// C++11 [class.copy]p18:
//   The [definition of an implicitly declared copy assignment operator] is
//   deprecated if the class has a user-declared copy constructor or a
//   user-declared destructor.
if (getLangOpts().CPlusPlus11 && CopyAssignOperator->isImplicit())
  diagnoseDeprecatedCopyOperation(*this, CopyAssignOperator);

// C++0x [class.copy]p30:
//   The implicitly-defined or explicitly-defaulted copy assignment operator
//   for a non-union class X performs memberwise copy assignment of its
//   subobjects. The direct base classes of X are assigned first, in the
//   order of their declaration in the base-specifier-list, and then the
//   immediate non-static data members of X are assigned, in the order in
//   which they were declared in the class definition.

// The statements that form the synthesized function body.
SmallVector<Stmt*, 8> Statements;

// The parameter for the "other" object, which we are copying from.
ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
Qualifiers OtherQuals = Other->getType().getQualifiers();
QualType OtherRefType = Other->getType();
if (const LValueReferenceType *OtherRef
                              = OtherRefType->getAs<LValueReferenceType>()) {
  OtherRefType = OtherRef->getPointeeType();
  OtherQuals = OtherRefType.getQualifiers();
}

// Our location for everything implicitly-generated.
SourceLocation Loc = CopyAssignOperator->getLocEnd().isValid()
                         ? CopyAssignOperator->getLocEnd()
                         : CopyAssignOperator->getLocation();

// Builds a DeclRefExpr for the "other" object.
RefBuilder OtherRef(Other, OtherRefType);

// Builds the "this" pointer.
ThisBuilder This;

// Assign base classes.
bool Invalid = false;
for (auto &Base : ClassDecl->bases()) {
  // Form the assignment:
  //   static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
  QualType BaseType = Base.getType().getUnqualifiedType();
  if (!BaseType->isRecordType()) {
    Invalid = true;
    continue;
  }

  CXXCastPath BasePath;
  BasePath.push_back(&Base);

  // Construct the "from" expression, which is an implicit cast to the
  // appropriately-qualified base type.
  CastBuilder From(OtherRef, Context.getQualifiedType(BaseType, OtherQuals),
                   VK_LValue, BasePath);

  // Dereference "this".
  DerefBuilder DerefThis(This);
  CastBuilder To(DerefThis,
                 Context.getCVRQualifiedType(
                     BaseType, CopyAssignOperator->getTypeQualifiers()),
                 VK_LValue, BasePath);

  // Build the copy.
  StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
                                          To, From,
                                          /*CopyingBaseSubobject=*/true,
                                          /*Copying=*/true);
  if (Copy.isInvalid()) {
    CopyAssignOperator->setInvalidDecl();
    return;
  }

  // Success! Record the copy.
  Statements.push_back(Copy.getAs<Expr>());
}

// Assign non-static members.
for (auto *Field : ClassDecl->fields()) {
  // FIXME: We should form some kind of AST representation for the implied
  // memcpy in a union copy operation.
  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
    continue;

  if (Field->isInvalidDecl()) {
    Invalid = true;
    continue;
  }

  // Check for members of reference type; we can't copy those.
  if (Field->getType()->isReferenceType()) {
    Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
      << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
    Diag(Field->getLocation(), diag::note_declared_at);
    Invalid = true;
    continue;
  }

  // Check for members of const-qualified, non-class type.
  QualType BaseType = Context.getBaseElementType(Field->getType());
  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
    Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
      << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
    Diag(Field->getLocation(), diag::note_declared_at);
    Invalid = true;
    continue;
  }

  // Suppress assigning zero-width bitfields.
  if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
    continue;

  QualType FieldType = Field->getType().getNonReferenceType();
  if (FieldType->isIncompleteArrayType()) {
    assert(ClassDecl->hasFlexibleArrayMember() &&(static_cast <bool> (ClassDecl->hasFlexibleArrayMember
() && "Incomplete array type is not valid") ? void (0
) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11642, __extension__ __PRETTY_FUNCTION__))
           "Incomplete array type is not valid")(static_cast <bool> (ClassDecl->hasFlexibleArrayMember
() && "Incomplete array type is not valid") ? void (0
) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11642, __extension__ __PRETTY_FUNCTION__));
    continue;
  }

  // Build references to the field in the object we're copying from and to.
  CXXScopeSpec SS; // Intentionally empty
  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
                            LookupMemberName);
  MemberLookup.addDecl(Field);
  MemberLookup.resolveKind();

  MemberBuilder From(OtherRef, OtherRefType, /*IsArrow=*/false, MemberLookup);

  MemberBuilder To(This, getCurrentThisType(), /*IsArrow=*/true, MemberLookup);

  // Build the copy of this field.
  StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
                                          To, From,
                                          /*CopyingBaseSubobject=*/false,
                                          /*Copying=*/true);
  if (Copy.isInvalid()) {
    CopyAssignOperator->setInvalidDecl();
    return;
  }

  // Success! Record the copy.
  Statements.push_back(Copy.getAs<Stmt>());
}

if (!Invalid) {
  // Add a "return *this;"
  ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));

  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
  if (Return.isInvalid())
    Invalid = true;
  else
    Statements.push_back(Return.getAs<Stmt>());
}

if (Invalid) {
  CopyAssignOperator->setInvalidDecl();
  return;
}

StmtResult Body;
{
  CompoundScopeRAII CompoundScope(*this);
  Body = ActOnCompoundStmt(Loc, Loc, Statements,
                           /*isStmtExpr=*/false);
  assert(!Body.isInvalid() && "Compound statement creation cannot fail")(static_cast <bool> (!Body.isInvalid() && "Compound statement creation cannot fail"
) ? void (0) : __assert_fail ("!Body.isInvalid() && \"Compound statement creation cannot fail\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11692, __extension__ __PRETTY_FUNCTION__));
}
CopyAssignOperator->setBody(Body.getAs<Stmt>());
CopyAssignOperator->markUsed(Context);

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(CopyAssignOperator);
}
11700}

11702CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
assert(ClassDecl->needsImplicitMoveAssignment())(static_cast <bool> (ClassDecl->needsImplicitMoveAssignment
()) ? void (0) : __assert_fail ("ClassDecl->needsImplicitMoveAssignment()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11703, __extension__ __PRETTY_FUNCTION__));

DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
if (DSM.isAlreadyBeingDeclared())
  return nullptr;

// Note: The following rules are largely analoguous to the move
// constructor rules.

QualType ArgType = Context.getTypeDeclType(ClassDecl);
QualType RetType = Context.getLValueReferenceType(ArgType);
ArgType = Context.getRValueReferenceType(ArgType);

bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                   CXXMoveAssignment,
                                                   false);

//   An implicitly-declared move assignment operator is an inline public
//   member of its class.
DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
SourceLocation ClassLoc = ClassDecl->getLocation();
DeclarationNameInfo NameInfo(Name, ClassLoc);
CXXMethodDecl *MoveAssignment =
    CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
                          /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
                          /*isInline=*/true, Constexpr, SourceLocation());
MoveAssignment->setAccess(AS_public);
MoveAssignment->setDefaulted();
MoveAssignment->setImplicit();

if (getLangOpts().CUDA) {
  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
                                          MoveAssignment,
                                          /* ConstRHS */ false,
                                          /* Diagnose */ false);
}

// Build an exception specification pointing back at this member.
FunctionProtoType::ExtProtoInfo EPI =
    getImplicitMethodEPI(*this, MoveAssignment);
MoveAssignment->setType(Context.getFunctionType(RetType, ArgType, EPI));

// Add the parameter to the operator.
ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
                                             ClassLoc, ClassLoc,
                                             /*Id=*/nullptr, ArgType,
                                             /*TInfo=*/nullptr, SC_None,
                                             nullptr);
MoveAssignment->setParams(FromParam);

MoveAssignment->setTrivial(
  ClassDecl->needsOverloadResolutionForMoveAssignment()
    ? SpecialMemberIsTrivial(MoveAssignment, CXXMoveAssignment)
    : ClassDecl->hasTrivialMoveAssignment());

// Note that we have added this copy-assignment operator.
++ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;

Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, MoveAssignment);

if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
  ClassDecl->setImplicitMoveAssignmentIsDeleted();
  SetDeclDeleted(MoveAssignment, ClassLoc);
}

if (S)
  PushOnScopeChains(MoveAssignment, S, false);
ClassDecl->addDecl(MoveAssignment);

return MoveAssignment;
11774}

11776/// Check if we're implicitly defining a move assignment operator for a class
11777/// with virtual bases. Such a move assignment might move-assign the virtual
11778/// base multiple times.
11779static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class,
                                             SourceLocation CurrentLocation) {
assert(!Class->isDependentContext() && "should not define dependent move")(static_cast <bool> (!Class->isDependentContext() &&
 "should not define dependent move") ? void (0) : __assert_fail
 ("!Class->isDependentContext() && \"should not define dependent move\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11781, __extension__ __PRETTY_FUNCTION__));

// Only a virtual base could get implicitly move-assigned multiple times.
// Only a non-trivial move assignment can observe this. We only want to
// diagnose if we implicitly define an assignment operator that assigns
// two base classes, both of which move-assign the same virtual base.
if (Class->getNumVBases() == 0 || Class->hasTrivialMoveAssignment() ||
    Class->getNumBases() < 2)
  return;

llvm::SmallVector<CXXBaseSpecifier *, 16> Worklist;
typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
VBaseMap VBases;

for (auto &BI : Class->bases()) {
  Worklist.push_back(&BI);
  while (!Worklist.empty()) {
    CXXBaseSpecifier *BaseSpec = Worklist.pop_back_val();
    CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();

    // If the base has no non-trivial move assignment operators,
    // we don't care about moves from it.
    if (!Base->hasNonTrivialMoveAssignment())
      continue;

    // If there's nothing virtual here, skip it.
    if (!BaseSpec->isVirtual() && !Base->getNumVBases())
      continue;

    // If we're not actually going to call a move assignment for this base,
    // or the selected move assignment is trivial, skip it.
    Sema::SpecialMemberOverloadResult SMOR =
      S.LookupSpecialMember(Base, Sema::CXXMoveAssignment,
                            /*ConstArg*/false, /*VolatileArg*/false,
                            /*RValueThis*/true, /*ConstThis*/false,
                            /*VolatileThis*/false);
    if (!SMOR.getMethod() || SMOR.getMethod()->isTrivial() ||
        !SMOR.getMethod()->isMoveAssignmentOperator())
      continue;

    if (BaseSpec->isVirtual()) {
      // We're going to move-assign this virtual base, and its move
      // assignment operator is not trivial. If this can happen for
      // multiple distinct direct bases of Class, diagnose it. (If it
      // only happens in one base, we'll diagnose it when synthesizing
      // that base class's move assignment operator.)
      CXXBaseSpecifier *&Existing =
          VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
              .first->second;
      if (Existing && Existing != &BI) {
        S.Diag(CurrentLocation, diag::warn_vbase_moved_multiple_times)
          << Class << Base;
        S.Diag(Existing->getLocStart(), diag::note_vbase_moved_here)
          << (Base->getCanonicalDecl() ==
              Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl())
          << Base << Existing->getType() << Existing->getSourceRange();
        S.Diag(BI.getLocStart(), diag::note_vbase_moved_here)
          << (Base->getCanonicalDecl() ==
              BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl())
          << Base << BI.getType() << BaseSpec->getSourceRange();

        // Only diagnose each vbase once.
        Existing = nullptr;
      }
    } else {
      // Only walk over bases that have defaulted move assignment operators.
      // We assume that any user-provided move assignment operator handles
      // the multiple-moves-of-vbase case itself somehow.
      if (!SMOR.getMethod()->isDefaulted())
        continue;

      // We're going to move the base classes of Base. Add them to the list.
      for (auto &BI : Base->bases())
        Worklist.push_back(&BI);
    }
  }
}
11858}

11860void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
                                      CXXMethodDecl *MoveAssignOperator) {
assert((MoveAssignOperator->isDefaulted() &&(static_cast <bool> ((MoveAssignOperator->isDefaulted
() && MoveAssignOperator->isOverloadedOperator() &&
 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
 !MoveAssignOperator->isDeleted()) && "DefineImplicitMoveAssignment called for wrong function"
) ? void (0) : __assert_fail ("(MoveAssignOperator->isDefaulted() && MoveAssignOperator->isOverloadedOperator() && MoveAssignOperator->getOverloadedOperator() == OO_Equal && !MoveAssignOperator->doesThisDeclarationHaveABody() && !MoveAssignOperator->isDeleted()) && \"DefineImplicitMoveAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11867, __extension__ __PRETTY_FUNCTION__))
        MoveAssignOperator->isOverloadedOperator() &&(static_cast <bool> ((MoveAssignOperator->isDefaulted
() && MoveAssignOperator->isOverloadedOperator() &&
 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
 !MoveAssignOperator->isDeleted()) && "DefineImplicitMoveAssignment called for wrong function"
) ? void (0) : __assert_fail ("(MoveAssignOperator->isDefaulted() && MoveAssignOperator->isOverloadedOperator() && MoveAssignOperator->getOverloadedOperator() == OO_Equal && !MoveAssignOperator->doesThisDeclarationHaveABody() && !MoveAssignOperator->isDeleted()) && \"DefineImplicitMoveAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11867, __extension__ __PRETTY_FUNCTION__))
        MoveAssignOperator->getOverloadedOperator() == OO_Equal &&(static_cast <bool> ((MoveAssignOperator->isDefaulted
() && MoveAssignOperator->isOverloadedOperator() &&
 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
 !MoveAssignOperator->isDeleted()) && "DefineImplicitMoveAssignment called for wrong function"
) ? void (0) : __assert_fail ("(MoveAssignOperator->isDefaulted() && MoveAssignOperator->isOverloadedOperator() && MoveAssignOperator->getOverloadedOperator() == OO_Equal && !MoveAssignOperator->doesThisDeclarationHaveABody() && !MoveAssignOperator->isDeleted()) && \"DefineImplicitMoveAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11867, __extension__ __PRETTY_FUNCTION__))
        !MoveAssignOperator->doesThisDeclarationHaveABody() &&(static_cast <bool> ((MoveAssignOperator->isDefaulted
() && MoveAssignOperator->isOverloadedOperator() &&
 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
 !MoveAssignOperator->isDeleted()) && "DefineImplicitMoveAssignment called for wrong function"
) ? void (0) : __assert_fail ("(MoveAssignOperator->isDefaulted() && MoveAssignOperator->isOverloadedOperator() && MoveAssignOperator->getOverloadedOperator() == OO_Equal && !MoveAssignOperator->doesThisDeclarationHaveABody() && !MoveAssignOperator->isDeleted()) && \"DefineImplicitMoveAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11867, __extension__ __PRETTY_FUNCTION__))
        !MoveAssignOperator->isDeleted()) &&(static_cast <bool> ((MoveAssignOperator->isDefaulted
() && MoveAssignOperator->isOverloadedOperator() &&
 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
 !MoveAssignOperator->isDeleted()) && "DefineImplicitMoveAssignment called for wrong function"
) ? void (0) : __assert_fail ("(MoveAssignOperator->isDefaulted() && MoveAssignOperator->isOverloadedOperator() && MoveAssignOperator->getOverloadedOperator() == OO_Equal && !MoveAssignOperator->doesThisDeclarationHaveABody() && !MoveAssignOperator->isDeleted()) && \"DefineImplicitMoveAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11867, __extension__ __PRETTY_FUNCTION__))
       "DefineImplicitMoveAssignment called for wrong function")(static_cast <bool> ((MoveAssignOperator->isDefaulted
() && MoveAssignOperator->isOverloadedOperator() &&
 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
 !MoveAssignOperator->isDeleted()) && "DefineImplicitMoveAssignment called for wrong function"
) ? void (0) : __assert_fail ("(MoveAssignOperator->isDefaulted() && MoveAssignOperator->isOverloadedOperator() && MoveAssignOperator->getOverloadedOperator() == OO_Equal && !MoveAssignOperator->doesThisDeclarationHaveABody() && !MoveAssignOperator->isDeleted()) && \"DefineImplicitMoveAssignment called for wrong function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11867, __extension__ __PRETTY_FUNCTION__));
if (MoveAssignOperator->willHaveBody() || MoveAssignOperator->isInvalidDecl())
  return;

CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
if (ClassDecl->isInvalidDecl()) {
  MoveAssignOperator->setInvalidDecl();
  return;
}

// C++0x [class.copy]p28:
//   The implicitly-defined or move assignment operator for a non-union class
//   X performs memberwise move assignment of its subobjects. The direct base
//   classes of X are assigned first, in the order of their declaration in the
//   base-specifier-list, and then the immediate non-static data members of X
//   are assigned, in the order in which they were declared in the class
//   definition.

// Issue a warning if our implicit move assignment operator will move
// from a virtual base more than once.
checkMoveAssignmentForRepeatedMove(*this, ClassDecl, CurrentLocation);

SynthesizedFunctionScope Scope(*this, MoveAssignOperator);

// The exception specification is needed because we are defining the
// function.
ResolveExceptionSpec(CurrentLocation,
                     MoveAssignOperator->getType()->castAs<FunctionProtoType>());

// Add a context note for diagnostics produced after this point.
Scope.addContextNote(CurrentLocation);

// The statements that form the synthesized function body.
SmallVector<Stmt*, 8> Statements;

// The parameter for the "other" object, which we are move from.
ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
QualType OtherRefType = Other->getType()->
    getAs<RValueReferenceType>()->getPointeeType();
assert(!OtherRefType.getQualifiers() &&(static_cast <bool> (!OtherRefType.getQualifiers() &&
 "Bad argument type of defaulted move assignment") ? void (0)
 : __assert_fail ("!OtherRefType.getQualifiers() && \"Bad argument type of defaulted move assignment\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11907, __extension__ __PRETTY_FUNCTION__))
       "Bad argument type of defaulted move assignment")(static_cast <bool> (!OtherRefType.getQualifiers() &&
 "Bad argument type of defaulted move assignment") ? void (0)
 : __assert_fail ("!OtherRefType.getQualifiers() && \"Bad argument type of defaulted move assignment\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 11907, __extension__ __PRETTY_FUNCTION__));

// Our location for everything implicitly-generated.
SourceLocation Loc = MoveAssignOperator->getLocEnd().isValid()
                         ? MoveAssignOperator->getLocEnd()
                         : MoveAssignOperator->getLocation();

// Builds a reference to the "other" object.
RefBuilder OtherRef(Other, OtherRefType);
// Cast to rvalue.
MoveCastBuilder MoveOther(OtherRef);

// Builds the "this" pointer.
ThisBuilder This;

// Assign base classes.
bool Invalid = false;
for (auto &Base : ClassDecl->bases()) {
  // C++11 [class.copy]p28:
  //   It is unspecified whether subobjects representing virtual base classes
  //   are assigned more than once by the implicitly-defined copy assignment
  //   operator.
  // FIXME: Do not assign to a vbase that will be assigned by some other base
  // class. For a move-assignment, this can result in the vbase being moved
  // multiple times.

  // Form the assignment:
  //   static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
  QualType BaseType = Base.getType().getUnqualifiedType();
  if (!BaseType->isRecordType()) {
    Invalid = true;
    continue;
  }

  CXXCastPath BasePath;
  BasePath.push_back(&Base);

  // Construct the "from" expression, which is an implicit cast to the
  // appropriately-qualified base type.
  CastBuilder From(OtherRef, BaseType, VK_XValue, BasePath);

  // Dereference "this".
  DerefBuilder DerefThis(This);

  // Implicitly cast "this" to the appropriately-qualified base type.
  CastBuilder To(DerefThis,
                 Context.getCVRQualifiedType(
                     BaseType, MoveAssignOperator->getTypeQualifiers()),
                 VK_LValue, BasePath);

  // Build the move.
  StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
                                          To, From,
                                          /*CopyingBaseSubobject=*/true,
                                          /*Copying=*/false);
  if (Move.isInvalid()) {
    MoveAssignOperator->setInvalidDecl();
    return;
  }

  // Success! Record the move.
  Statements.push_back(Move.getAs<Expr>());
}

// Assign non-static members.
for (auto *Field : ClassDecl->fields()) {
  // FIXME: We should form some kind of AST representation for the implied
  // memcpy in a union copy operation.
  if (Field->isUnnamedBitfield() || Field->getParent()->isUnion())
    continue;

  if (Field->isInvalidDecl()) {
    Invalid = true;
    continue;
  }

  // Check for members of reference type; we can't move those.
  if (Field->getType()->isReferenceType()) {
    Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
      << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
    Diag(Field->getLocation(), diag::note_declared_at);
    Invalid = true;
    continue;
  }

  // Check for members of const-qualified, non-class type.
  QualType BaseType = Context.getBaseElementType(Field->getType());
  if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
    Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
      << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
    Diag(Field->getLocation(), diag::note_declared_at);
    Invalid = true;
    continue;
  }

  // Suppress assigning zero-width bitfields.
  if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
    continue;

  QualType FieldType = Field->getType().getNonReferenceType();
  if (FieldType->isIncompleteArrayType()) {
    assert(ClassDecl->hasFlexibleArrayMember() &&(static_cast <bool> (ClassDecl->hasFlexibleArrayMember
() && "Incomplete array type is not valid") ? void (0
) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12009, __extension__ __PRETTY_FUNCTION__))
           "Incomplete array type is not valid")(static_cast <bool> (ClassDecl->hasFlexibleArrayMember
() && "Incomplete array type is not valid") ? void (0
) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12009, __extension__ __PRETTY_FUNCTION__));
    continue;
  }

  // Build references to the field in the object we're copying from and to.
  LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
                            LookupMemberName);
  MemberLookup.addDecl(Field);
  MemberLookup.resolveKind();
  MemberBuilder From(MoveOther, OtherRefType,
                     /*IsArrow=*/false, MemberLookup);
  MemberBuilder To(This, getCurrentThisType(),
                   /*IsArrow=*/true, MemberLookup);

  assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue(static_cast <bool> (!From.build(*this, Loc)->isLValue
() && "Member reference with rvalue base must be rvalue except for reference "
 "members, which aren't allowed for move assignment.") ? void
 (0) : __assert_fail ("!From.build(*this, Loc)->isLValue() && \"Member reference with rvalue base must be rvalue except for reference \" \"members, which aren't allowed for move assignment.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12025, __extension__ __PRETTY_FUNCTION__))
      "Member reference with rvalue base must be rvalue except for reference "(static_cast <bool> (!From.build(*this, Loc)->isLValue
() && "Member reference with rvalue base must be rvalue except for reference "
 "members, which aren't allowed for move assignment.") ? void
 (0) : __assert_fail ("!From.build(*this, Loc)->isLValue() && \"Member reference with rvalue base must be rvalue except for reference \" \"members, which aren't allowed for move assignment.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12025, __extension__ __PRETTY_FUNCTION__))
      "members, which aren't allowed for move assignment.")(static_cast <bool> (!From.build(*this, Loc)->isLValue
() && "Member reference with rvalue base must be rvalue except for reference "
 "members, which aren't allowed for move assignment.") ? void
 (0) : __assert_fail ("!From.build(*this, Loc)->isLValue() && \"Member reference with rvalue base must be rvalue except for reference \" \"members, which aren't allowed for move assignment.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12025, __extension__ __PRETTY_FUNCTION__));

  // Build the move of this field.
  StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
                                          To, From,
                                          /*CopyingBaseSubobject=*/false,
                                          /*Copying=*/false);
  if (Move.isInvalid()) {
    MoveAssignOperator->setInvalidDecl();
    return;
  }

  // Success! Record the copy.
  Statements.push_back(Move.getAs<Stmt>());
}

if (!Invalid) {
  // Add a "return *this;"
  ExprResult ThisObj =
      CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));

  StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
  if (Return.isInvalid())
    Invalid = true;
  else
    Statements.push_back(Return.getAs<Stmt>());
}

if (Invalid) {
  MoveAssignOperator->setInvalidDecl();
  return;
}

StmtResult Body;
{
  CompoundScopeRAII CompoundScope(*this);
  Body = ActOnCompoundStmt(Loc, Loc, Statements,
                           /*isStmtExpr=*/false);
  assert(!Body.isInvalid() && "Compound statement creation cannot fail")(static_cast <bool> (!Body.isInvalid() && "Compound statement creation cannot fail"
) ? void (0) : __assert_fail ("!Body.isInvalid() && \"Compound statement creation cannot fail\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12063, __extension__ __PRETTY_FUNCTION__));
}
MoveAssignOperator->setBody(Body.getAs<Stmt>());
MoveAssignOperator->markUsed(Context);

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(MoveAssignOperator);
}
12071}

12073CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
                                                  CXXRecordDecl *ClassDecl) {
// C++ [class.copy]p4:
//   If the class definition does not explicitly declare a copy
//   constructor, one is declared implicitly.
assert(ClassDecl->needsImplicitCopyConstructor())(static_cast <bool> (ClassDecl->needsImplicitCopyConstructor
()) ? void (0) : __assert_fail ("ClassDecl->needsImplicitCopyConstructor()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12078, __extension__ __PRETTY_FUNCTION__));

DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
if (DSM.isAlreadyBeingDeclared())
  return nullptr;

QualType ClassType = Context.getTypeDeclType(ClassDecl);
QualType ArgType = ClassType;
bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
if (Const)
  ArgType = ArgType.withConst();
ArgType = Context.getLValueReferenceType(ArgType);

bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                   CXXCopyConstructor,
                                                   Const);

DeclarationName Name
  = Context.DeclarationNames.getCXXConstructorName(
                                         Context.getCanonicalType(ClassType));
SourceLocation ClassLoc = ClassDecl->getLocation();
DeclarationNameInfo NameInfo(Name, ClassLoc);

//   An implicitly-declared copy constructor is an inline public
//   member of its class.
CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
    Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
    /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
    Constexpr);
CopyConstructor->setAccess(AS_public);
CopyConstructor->setDefaulted();

if (getLangOpts().CUDA) {
  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
                                          CopyConstructor,
                                          /* ConstRHS */ Const,
                                          /* Diagnose */ false);
}

// Build an exception specification pointing back at this member.
FunctionProtoType::ExtProtoInfo EPI =
    getImplicitMethodEPI(*this, CopyConstructor);
CopyConstructor->setType(
    Context.getFunctionType(Context.VoidTy, ArgType, EPI));

// Add the parameter to the constructor.
ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
                                             ClassLoc, ClassLoc,
                                             /*IdentifierInfo=*/nullptr,
                                             ArgType, /*TInfo=*/nullptr,
                                             SC_None, nullptr);
CopyConstructor->setParams(FromParam);

CopyConstructor->setTrivial(
    ClassDecl->needsOverloadResolutionForCopyConstructor()
        ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor)
        : ClassDecl->hasTrivialCopyConstructor());

CopyConstructor->setTrivialForCall(
    ClassDecl->hasAttr<TrivialABIAttr>() ||
    (ClassDecl->needsOverloadResolutionForCopyConstructor()
         ? SpecialMemberIsTrivial(CopyConstructor, CXXCopyConstructor,
           TAH_ConsiderTrivialABI)
         : ClassDecl->hasTrivialCopyConstructorForCall()));

// Note that we have declared this constructor.
++ASTContext::NumImplicitCopyConstructorsDeclared;

Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, CopyConstructor);

if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor)) {
  ClassDecl->setImplicitCopyConstructorIsDeleted();
  SetDeclDeleted(CopyConstructor, ClassLoc);
}

if (S)
  PushOnScopeChains(CopyConstructor, S, false);
ClassDecl->addDecl(CopyConstructor);

return CopyConstructor;
12159}

12161void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
                                       CXXConstructorDecl *CopyConstructor) {
assert((CopyConstructor->isDefaulted() &&(static_cast <bool> ((CopyConstructor->isDefaulted()
 && CopyConstructor->isCopyConstructor() &&
 !CopyConstructor->doesThisDeclarationHaveABody() &&
 !CopyConstructor->isDeleted()) && "DefineImplicitCopyConstructor - call it for implicit copy ctor"
) ? void (0) : __assert_fail ("(CopyConstructor->isDefaulted() && CopyConstructor->isCopyConstructor() && !CopyConstructor->doesThisDeclarationHaveABody() && !CopyConstructor->isDeleted()) && \"DefineImplicitCopyConstructor - call it for implicit copy ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12167, __extension__ __PRETTY_FUNCTION__))
        CopyConstructor->isCopyConstructor() &&(static_cast <bool> ((CopyConstructor->isDefaulted()
 && CopyConstructor->isCopyConstructor() &&
 !CopyConstructor->doesThisDeclarationHaveABody() &&
 !CopyConstructor->isDeleted()) && "DefineImplicitCopyConstructor - call it for implicit copy ctor"
) ? void (0) : __assert_fail ("(CopyConstructor->isDefaulted() && CopyConstructor->isCopyConstructor() && !CopyConstructor->doesThisDeclarationHaveABody() && !CopyConstructor->isDeleted()) && \"DefineImplicitCopyConstructor - call it for implicit copy ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12167, __extension__ __PRETTY_FUNCTION__))
        !CopyConstructor->doesThisDeclarationHaveABody() &&(static_cast <bool> ((CopyConstructor->isDefaulted()
 && CopyConstructor->isCopyConstructor() &&
 !CopyConstructor->doesThisDeclarationHaveABody() &&
 !CopyConstructor->isDeleted()) && "DefineImplicitCopyConstructor - call it for implicit copy ctor"
) ? void (0) : __assert_fail ("(CopyConstructor->isDefaulted() && CopyConstructor->isCopyConstructor() && !CopyConstructor->doesThisDeclarationHaveABody() && !CopyConstructor->isDeleted()) && \"DefineImplicitCopyConstructor - call it for implicit copy ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12167, __extension__ __PRETTY_FUNCTION__))
        !CopyConstructor->isDeleted()) &&(static_cast <bool> ((CopyConstructor->isDefaulted()
 && CopyConstructor->isCopyConstructor() &&
 !CopyConstructor->doesThisDeclarationHaveABody() &&
 !CopyConstructor->isDeleted()) && "DefineImplicitCopyConstructor - call it for implicit copy ctor"
) ? void (0) : __assert_fail ("(CopyConstructor->isDefaulted() && CopyConstructor->isCopyConstructor() && !CopyConstructor->doesThisDeclarationHaveABody() && !CopyConstructor->isDeleted()) && \"DefineImplicitCopyConstructor - call it for implicit copy ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12167, __extension__ __PRETTY_FUNCTION__))
       "DefineImplicitCopyConstructor - call it for implicit copy ctor")(static_cast <bool> ((CopyConstructor->isDefaulted()
 && CopyConstructor->isCopyConstructor() &&
 !CopyConstructor->doesThisDeclarationHaveABody() &&
 !CopyConstructor->isDeleted()) && "DefineImplicitCopyConstructor - call it for implicit copy ctor"
) ? void (0) : __assert_fail ("(CopyConstructor->isDefaulted() && CopyConstructor->isCopyConstructor() && !CopyConstructor->doesThisDeclarationHaveABody() && !CopyConstructor->isDeleted()) && \"DefineImplicitCopyConstructor - call it for implicit copy ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12167, __extension__ __PRETTY_FUNCTION__));
if (CopyConstructor->willHaveBody() || CopyConstructor->isInvalidDecl())
  return;

CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor")(static_cast <bool> (ClassDecl && "DefineImplicitCopyConstructor - invalid constructor"
) ? void (0) : __assert_fail ("ClassDecl && \"DefineImplicitCopyConstructor - invalid constructor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12172, __extension__ __PRETTY_FUNCTION__));

SynthesizedFunctionScope Scope(*this, CopyConstructor);

// The exception specification is needed because we are defining the
// function.
ResolveExceptionSpec(CurrentLocation,
                     CopyConstructor->getType()->castAs<FunctionProtoType>());
MarkVTableUsed(CurrentLocation, ClassDecl);

// Add a context note for diagnostics produced after this point.
Scope.addContextNote(CurrentLocation);

// C++11 [class.copy]p7:
//   The [definition of an implicitly declared copy constructor] is
//   deprecated if the class has a user-declared copy assignment operator
//   or a user-declared destructor.
if (getLangOpts().CPlusPlus11 && CopyConstructor->isImplicit())
  diagnoseDeprecatedCopyOperation(*this, CopyConstructor);

if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false)) {
  CopyConstructor->setInvalidDecl();
}  else {
  SourceLocation Loc = CopyConstructor->getLocEnd().isValid()
                           ? CopyConstructor->getLocEnd()
                           : CopyConstructor->getLocation();
  Sema::CompoundScopeRAII CompoundScope(*this);
  CopyConstructor->setBody(
      ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
  CopyConstructor->markUsed(Context);
}

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(CopyConstructor);
}
12207}

12209CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
                                                  CXXRecordDecl *ClassDecl) {
assert(ClassDecl->needsImplicitMoveConstructor())(static_cast <bool> (ClassDecl->needsImplicitMoveConstructor
()) ? void (0) : __assert_fail ("ClassDecl->needsImplicitMoveConstructor()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12211, __extension__ __PRETTY_FUNCTION__));

DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
if (DSM.isAlreadyBeingDeclared())
  return nullptr;

QualType ClassType = Context.getTypeDeclType(ClassDecl);
QualType ArgType = Context.getRValueReferenceType(ClassType);

bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                   CXXMoveConstructor,
                                                   false);

DeclarationName Name
  = Context.DeclarationNames.getCXXConstructorName(
                                         Context.getCanonicalType(ClassType));
SourceLocation ClassLoc = ClassDecl->getLocation();
DeclarationNameInfo NameInfo(Name, ClassLoc);

// C++11 [class.copy]p11:
//   An implicitly-declared copy/move constructor is an inline public
//   member of its class.
CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
    Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
    /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
    Constexpr);
MoveConstructor->setAccess(AS_public);
MoveConstructor->setDefaulted();

if (getLangOpts().CUDA) {
  inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
                                          MoveConstructor,
                                          /* ConstRHS */ false,
                                          /* Diagnose */ false);
}

// Build an exception specification pointing back at this member.
FunctionProtoType::ExtProtoInfo EPI =
    getImplicitMethodEPI(*this, MoveConstructor);
MoveConstructor->setType(
    Context.getFunctionType(Context.VoidTy, ArgType, EPI));

// Add the parameter to the constructor.
ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
                                             ClassLoc, ClassLoc,
                                             /*IdentifierInfo=*/nullptr,
                                             ArgType, /*TInfo=*/nullptr,
                                             SC_None, nullptr);
MoveConstructor->setParams(FromParam);

MoveConstructor->setTrivial(
    ClassDecl->needsOverloadResolutionForMoveConstructor()
        ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor)
        : ClassDecl->hasTrivialMoveConstructor());

MoveConstructor->setTrivialForCall(
    ClassDecl->hasAttr<TrivialABIAttr>() ||
    (ClassDecl->needsOverloadResolutionForMoveConstructor()
         ? SpecialMemberIsTrivial(MoveConstructor, CXXMoveConstructor,
                                  TAH_ConsiderTrivialABI)
         : ClassDecl->hasTrivialMoveConstructorForCall()));

// Note that we have declared this constructor.
++ASTContext::NumImplicitMoveConstructorsDeclared;

Scope *S = getScopeForContext(ClassDecl);
CheckImplicitSpecialMemberDeclaration(S, MoveConstructor);

if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
  ClassDecl->setImplicitMoveConstructorIsDeleted();
  SetDeclDeleted(MoveConstructor, ClassLoc);
}

if (S)
  PushOnScopeChains(MoveConstructor, S, false);
ClassDecl->addDecl(MoveConstructor);

return MoveConstructor;
12289}

12291void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
                                       CXXConstructorDecl *MoveConstructor) {
assert((MoveConstructor->isDefaulted() &&(static_cast <bool> ((MoveConstructor->isDefaulted()
 && MoveConstructor->isMoveConstructor() &&
 !MoveConstructor->doesThisDeclarationHaveABody() &&
 !MoveConstructor->isDeleted()) && "DefineImplicitMoveConstructor - call it for implicit move ctor"
) ? void (0) : __assert_fail ("(MoveConstructor->isDefaulted() && MoveConstructor->isMoveConstructor() && !MoveConstructor->doesThisDeclarationHaveABody() && !MoveConstructor->isDeleted()) && \"DefineImplicitMoveConstructor - call it for implicit move ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12297, __extension__ __PRETTY_FUNCTION__))
        MoveConstructor->isMoveConstructor() &&(static_cast <bool> ((MoveConstructor->isDefaulted()
 && MoveConstructor->isMoveConstructor() &&
 !MoveConstructor->doesThisDeclarationHaveABody() &&
 !MoveConstructor->isDeleted()) && "DefineImplicitMoveConstructor - call it for implicit move ctor"
) ? void (0) : __assert_fail ("(MoveConstructor->isDefaulted() && MoveConstructor->isMoveConstructor() && !MoveConstructor->doesThisDeclarationHaveABody() && !MoveConstructor->isDeleted()) && \"DefineImplicitMoveConstructor - call it for implicit move ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12297, __extension__ __PRETTY_FUNCTION__))
        !MoveConstructor->doesThisDeclarationHaveABody() &&(static_cast <bool> ((MoveConstructor->isDefaulted()
 && MoveConstructor->isMoveConstructor() &&
 !MoveConstructor->doesThisDeclarationHaveABody() &&
 !MoveConstructor->isDeleted()) && "DefineImplicitMoveConstructor - call it for implicit move ctor"
) ? void (0) : __assert_fail ("(MoveConstructor->isDefaulted() && MoveConstructor->isMoveConstructor() && !MoveConstructor->doesThisDeclarationHaveABody() && !MoveConstructor->isDeleted()) && \"DefineImplicitMoveConstructor - call it for implicit move ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12297, __extension__ __PRETTY_FUNCTION__))
        !MoveConstructor->isDeleted()) &&(static_cast <bool> ((MoveConstructor->isDefaulted()
 && MoveConstructor->isMoveConstructor() &&
 !MoveConstructor->doesThisDeclarationHaveABody() &&
 !MoveConstructor->isDeleted()) && "DefineImplicitMoveConstructor - call it for implicit move ctor"
) ? void (0) : __assert_fail ("(MoveConstructor->isDefaulted() && MoveConstructor->isMoveConstructor() && !MoveConstructor->doesThisDeclarationHaveABody() && !MoveConstructor->isDeleted()) && \"DefineImplicitMoveConstructor - call it for implicit move ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12297, __extension__ __PRETTY_FUNCTION__))
       "DefineImplicitMoveConstructor - call it for implicit move ctor")(static_cast <bool> ((MoveConstructor->isDefaulted()
 && MoveConstructor->isMoveConstructor() &&
 !MoveConstructor->doesThisDeclarationHaveABody() &&
 !MoveConstructor->isDeleted()) && "DefineImplicitMoveConstructor - call it for implicit move ctor"
) ? void (0) : __assert_fail ("(MoveConstructor->isDefaulted() && MoveConstructor->isMoveConstructor() && !MoveConstructor->doesThisDeclarationHaveABody() && !MoveConstructor->isDeleted()) && \"DefineImplicitMoveConstructor - call it for implicit move ctor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12297, __extension__ __PRETTY_FUNCTION__));
if (MoveConstructor->willHaveBody() || MoveConstructor->isInvalidDecl())
  return;

CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor")(static_cast <bool> (ClassDecl && "DefineImplicitMoveConstructor - invalid constructor"
) ? void (0) : __assert_fail ("ClassDecl && \"DefineImplicitMoveConstructor - invalid constructor\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12302, __extension__ __PRETTY_FUNCTION__));

SynthesizedFunctionScope Scope(*this, MoveConstructor);

// The exception specification is needed because we are defining the
// function.
ResolveExceptionSpec(CurrentLocation,
                     MoveConstructor->getType()->castAs<FunctionProtoType>());
MarkVTableUsed(CurrentLocation, ClassDecl);

// Add a context note for diagnostics produced after this point.
Scope.addContextNote(CurrentLocation);

if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false)) {
  MoveConstructor->setInvalidDecl();
} else {
  SourceLocation Loc = MoveConstructor->getLocEnd().isValid()
                           ? MoveConstructor->getLocEnd()
                           : MoveConstructor->getLocation();
  Sema::CompoundScopeRAII CompoundScope(*this);
  MoveConstructor->setBody(ActOnCompoundStmt(
      Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
  MoveConstructor->markUsed(Context);
}

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(MoveConstructor);
}
12330}

12332bool Sema::isImplicitlyDeleted(FunctionDecl *FD) {
return FD->isDeleted() && FD->isDefaulted() && isa<CXXMethodDecl>(FD);
12334}

12336void Sema::DefineImplicitLambdaToFunctionPointerConversion(
                          SourceLocation CurrentLocation,
                          CXXConversionDecl *Conv) {
SynthesizedFunctionScope Scope(*this, Conv);
assert(!Conv->getReturnType()->isUndeducedType())(static_cast <bool> (!Conv->getReturnType()->isUndeducedType
()) ? void (0) : __assert_fail ("!Conv->getReturnType()->isUndeducedType()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12340, __extension__ __PRETTY_FUNCTION__));

CXXRecordDecl *Lambda = Conv->getParent();
FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
FunctionDecl *Invoker = Lambda->getLambdaStaticInvoker();

if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
  CallOp = InstantiateFunctionDeclaration(
      CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
  if (!CallOp)
    return;

  Invoker = InstantiateFunctionDeclaration(
      Invoker->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
  if (!Invoker)
    return;
}

if (CallOp->isInvalidDecl())
  return;

// Mark the call operator referenced (and add to pending instantiations
// if necessary).
// For both the conversion and static-invoker template specializations
// we construct their body's in this function, so no need to add them
// to the PendingInstantiations.
MarkFunctionReferenced(CurrentLocation, CallOp);

// Fill in the __invoke function with a dummy implementation. IR generation
// will fill in the actual details. Update its type in case it contained
// an 'auto'.
Invoker->markUsed(Context);
Invoker->setReferenced();
Invoker->setType(Conv->getReturnType()->getPointeeType());
Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));

// Construct the body of the conversion function { return __invoke; }.
Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
                                     VK_LValue, Conv->getLocation()).get();
assert(FunctionRef && "Can't refer to __invoke function?")(static_cast <bool> (FunctionRef && "Can't refer to __invoke function?"
) ? void (0) : __assert_fail ("FunctionRef && \"Can't refer to __invoke function?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12379, __extension__ __PRETTY_FUNCTION__));
Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
Conv->setBody(CompoundStmt::Create(Context, Return, Conv->getLocation(),
                                   Conv->getLocation()));
Conv->markUsed(Context);
Conv->setReferenced();

if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(Conv);
  L->CompletedImplicitDefinition(Invoker);
}
12390}



12394void Sema::DefineImplicitLambdaToBlockPointerConversion(
     SourceLocation CurrentLocation,
     CXXConversionDecl *Conv)
12397{
assert(!Conv->getParent()->isGenericLambda())(static_cast <bool> (!Conv->getParent()->isGenericLambda
()) ? void (0) : __assert_fail ("!Conv->getParent()->isGenericLambda()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12398, __extension__ __PRETTY_FUNCTION__));

SynthesizedFunctionScope Scope(*this, Conv);

// Copy-initialize the lambda object as needed to capture it.
Expr *This = ActOnCXXThis(CurrentLocation).get();
Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();

ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
                                                      Conv->getLocation(),
                                                      Conv, DerefThis);

// If we're not under ARC, make sure we still get the _Block_copy/autorelease
// behavior.  Note that only the general conversion function does this
// (since it's unusable otherwise); in the case where we inline the
// block literal, it has block literal lifetime semantics.
if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
  BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
                                        CK_CopyAndAutoreleaseBlockObject,
                                        BuildBlock.get(), nullptr, VK_RValue);

if (BuildBlock.isInvalid()) {
  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
  Conv->setInvalidDecl();
  return;
}

// Create the return statement that returns the block from the conversion
// function.
StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
if (Return.isInvalid()) {
  Diag(CurrentLocation, diag::note_lambda_to_block_conv);
  Conv->setInvalidDecl();
  return;
}

// Set the body of the conversion function.
Stmt *ReturnS = Return.get();
Conv->setBody(CompoundStmt::Create(Context, ReturnS, Conv->getLocation(),
                                   Conv->getLocation()));
Conv->markUsed(Context);

// We're done; notify the mutation listener, if any.
if (ASTMutationListener *L = getASTMutationListener()) {
  L->CompletedImplicitDefinition(Conv);
}
12444}

12446/// \brief Determine whether the given list arguments contains exactly one
12447/// "real" (non-default) argument.
12448static bool hasOneRealArgument(MultiExprArg Args) {
switch (Args.size()) {
case 0:
  return false;

default:
  if (!Args[1]->isDefaultArgument())
    return false;

  LLVM_FALLTHROUGH[[clang::fallthrough]];
case 1:
  return !Args[0]->isDefaultArgument();
}

return false;
12463}

12465ExprResult
12466Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
                          NamedDecl *FoundDecl,
                          CXXConstructorDecl *Constructor,
                          MultiExprArg ExprArgs,
                          bool HadMultipleCandidates,
                          bool IsListInitialization,
                          bool IsStdInitListInitialization,
                          bool RequiresZeroInit,
                          unsigned ConstructKind,
                          SourceRange ParenRange) {
bool Elidable = false;

// C++0x [class.copy]p34:
//   When certain criteria are met, an implementation is allowed to
//   omit the copy/move construction of a class object, even if the
//   copy/move constructor and/or destructor for the object have
//   side effects. [...]
//     - when a temporary class object that has not been bound to a
//       reference (12.2) would be copied/moved to a class object
//       with the same cv-unqualified type, the copy/move operation
//       can be omitted by constructing the temporary object
//       directly into the target of the omitted copy/move
if (ConstructKind == CXXConstructExpr::CK_Complete && Constructor &&
    Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
  Expr *SubExpr = ExprArgs[0];
  Elidable = SubExpr->isTemporaryObject(
      Context, cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
}

return BuildCXXConstructExpr(ConstructLoc, DeclInitType,
                             FoundDecl, Constructor,
                             Elidable, ExprArgs, HadMultipleCandidates,
                             IsListInitialization,
                             IsStdInitListInitialization, RequiresZeroInit,
                             ConstructKind, ParenRange);
12501}

12503ExprResult
12504Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
                          NamedDecl *FoundDecl,
                          CXXConstructorDecl *Constructor,
                          bool Elidable,
                          MultiExprArg ExprArgs,
                          bool HadMultipleCandidates,
                          bool IsListInitialization,
                          bool IsStdInitListInitialization,
                          bool RequiresZeroInit,
                          unsigned ConstructKind,
                          SourceRange ParenRange) {
if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl)) {
  Constructor = findInheritingConstructor(ConstructLoc, Constructor, Shadow);
  if (DiagnoseUseOfDecl(Constructor, ConstructLoc))
    return ExprError();
}

return BuildCXXConstructExpr(
    ConstructLoc, DeclInitType, Constructor, Elidable, ExprArgs,
    HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
    RequiresZeroInit, ConstructKind, ParenRange);
12525}

12527/// BuildCXXConstructExpr - Creates a complete call to a constructor,
12528/// including handling of its default argument expressions.
12529ExprResult
12530Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
                          CXXConstructorDecl *Constructor,
                          bool Elidable,
                          MultiExprArg ExprArgs,
                          bool HadMultipleCandidates,
                          bool IsListInitialization,
                          bool IsStdInitListInitialization,
                          bool RequiresZeroInit,
                          unsigned ConstructKind,
                          SourceRange ParenRange) {
assert(declaresSameEntity((static_cast <bool> (declaresSameEntity( Constructor->
getParent(), DeclInitType->getBaseElementTypeUnsafe()->
getAsCXXRecordDecl()) && "given constructor for wrong type"
) ? void (0) : __assert_fail ("declaresSameEntity( Constructor->getParent(), DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) && \"given constructor for wrong type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12543, __extension__ __PRETTY_FUNCTION__))
           Constructor->getParent(),(static_cast <bool> (declaresSameEntity( Constructor->
getParent(), DeclInitType->getBaseElementTypeUnsafe()->
getAsCXXRecordDecl()) && "given constructor for wrong type"
) ? void (0) : __assert_fail ("declaresSameEntity( Constructor->getParent(), DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) && \"given constructor for wrong type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12543, __extension__ __PRETTY_FUNCTION__))
           DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&(static_cast <bool> (declaresSameEntity( Constructor->
getParent(), DeclInitType->getBaseElementTypeUnsafe()->
getAsCXXRecordDecl()) && "given constructor for wrong type"
) ? void (0) : __assert_fail ("declaresSameEntity( Constructor->getParent(), DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) && \"given constructor for wrong type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12543, __extension__ __PRETTY_FUNCTION__))
       "given constructor for wrong type")(static_cast <bool> (declaresSameEntity( Constructor->
getParent(), DeclInitType->getBaseElementTypeUnsafe()->
getAsCXXRecordDecl()) && "given constructor for wrong type"
) ? void (0) : __assert_fail ("declaresSameEntity( Constructor->getParent(), DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) && \"given constructor for wrong type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12543, __extension__ __PRETTY_FUNCTION__));
MarkFunctionReferenced(ConstructLoc, Constructor);
if (getLangOpts().CUDA && !CheckCUDACall(ConstructLoc, Constructor))
  return ExprError();

return CXXConstructExpr::Create(
    Context, DeclInitType, ConstructLoc, Constructor, Elidable,
    ExprArgs, HadMultipleCandidates, IsListInitialization,
    IsStdInitListInitialization, RequiresZeroInit,
    static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
    ParenRange);
12554}

12556ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
assert(Field->hasInClassInitializer())(static_cast <bool> (Field->hasInClassInitializer())
 ? void (0) : __assert_fail ("Field->hasInClassInitializer()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12557, __extension__ __PRETTY_FUNCTION__));

// If we already have the in-class initializer nothing needs to be done.
if (Field->getInClassInitializer())
  return CXXDefaultInitExpr::Create(Context, Loc, Field);

// If we might have already tried and failed to instantiate, don't try again.
if (Field->isInvalidDecl())
  return ExprError();

// Maybe we haven't instantiated the in-class initializer. Go check the
// pattern FieldDecl to see if it has one.
CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(Field->getParent());

if (isTemplateInstantiation(ParentRD->getTemplateSpecializationKind())) {
  CXXRecordDecl *ClassPattern = ParentRD->getTemplateInstantiationPattern();
  DeclContext::lookup_result Lookup =
      ClassPattern->lookup(Field->getDeclName());

  // Lookup can return at most two results: the pattern for the field, or the
  // injected class name of the parent record. No other member can have the
  // same name as the field.
  // In modules mode, lookup can return multiple results (coming from
  // different modules).
  assert((getLangOpts().Modules || (!Lookup.empty() && Lookup.size() <= 2)) &&(static_cast <bool> ((getLangOpts().Modules || (!Lookup
.empty() && Lookup.size() <= 2)) && "more than two lookup results for field name"
) ? void (0) : __assert_fail ("(getLangOpts().Modules || (!Lookup.empty() && Lookup.size() <= 2)) && \"more than two lookup results for field name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12582, __extension__ __PRETTY_FUNCTION__))
         "more than two lookup results for field name")(static_cast <bool> ((getLangOpts().Modules || (!Lookup
.empty() && Lookup.size() <= 2)) && "more than two lookup results for field name"
) ? void (0) : __assert_fail ("(getLangOpts().Modules || (!Lookup.empty() && Lookup.size() <= 2)) && \"more than two lookup results for field name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12582, __extension__ __PRETTY_FUNCTION__));
  FieldDecl *Pattern = dyn_cast<FieldDecl>(Lookup[0]);
  if (!Pattern) {
    assert(isa<CXXRecordDecl>(Lookup[0]) &&(static_cast <bool> (isa<CXXRecordDecl>(Lookup[0]
) && "cannot have other non-field member with same name"
) ? void (0) : __assert_fail ("isa<CXXRecordDecl>(Lookup[0]) && \"cannot have other non-field member with same name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12586, __extension__ __PRETTY_FUNCTION__))
           "cannot have other non-field member with same name")(static_cast <bool> (isa<CXXRecordDecl>(Lookup[0]
) && "cannot have other non-field member with same name"
) ? void (0) : __assert_fail ("isa<CXXRecordDecl>(Lookup[0]) && \"cannot have other non-field member with same name\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12586, __extension__ __PRETTY_FUNCTION__));
    for (auto L : Lookup)
      if (isa<FieldDecl>(L)) {
        Pattern = cast<FieldDecl>(L);
        break;
      }
    assert(Pattern && "We must have set the Pattern!")(static_cast <bool> (Pattern && "We must have set the Pattern!"
) ? void (0) : __assert_fail ("Pattern && \"We must have set the Pattern!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12592, __extension__ __PRETTY_FUNCTION__));
  }

  if (!Pattern->hasInClassInitializer() ||
      InstantiateInClassInitializer(Loc, Field, Pattern,
                                    getTemplateInstantiationArgs(Field))) {
    // Don't diagnose this again.
    Field->setInvalidDecl();
    return ExprError();
  }
  return CXXDefaultInitExpr::Create(Context, Loc, Field);
}

// DR1351:
//   If the brace-or-equal-initializer of a non-static data member
//   invokes a defaulted default constructor of its class or of an
//   enclosing class in a potentially evaluated subexpression, the
//   program is ill-formed.
//
// This resolution is unworkable: the exception specification of the
// default constructor can be needed in an unevaluated context, in
// particular, in the operand of a noexcept-expression, and we can be
// unable to compute an exception specification for an enclosed class.
//
// Any attempt to resolve the exception specification of a defaulted default
// constructor before the initializer is lexically complete will ultimately
// come here at which point we can diagnose it.
RecordDecl *OutermostClass = ParentRD->getOuterLexicalRecordContext();
Diag(Loc, diag::err_in_class_initializer_not_yet_parsed)
    << OutermostClass << Field;
Diag(Field->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
// Recover by marking the field invalid, unless we're in a SFINAE context.
if (!isSFINAEContext())
  Field->setInvalidDecl();
return ExprError();
12627}

12629void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
if (VD->isInvalidDecl()) return;

CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
if (ClassDecl->isInvalidDecl()) return;
if (ClassDecl->hasIrrelevantDestructor()) return;
if (ClassDecl->isDependentContext()) return;

CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
MarkFunctionReferenced(VD->getLocation(), Destructor);
CheckDestructorAccess(VD->getLocation(), Destructor,
                      PDiag(diag::err_access_dtor_var)
                      << VD->getDeclName()
                      << VD->getType());
DiagnoseUseOfDecl(Destructor, VD->getLocation());

if (Destructor->isTrivial()) return;
if (!VD->hasGlobalStorage()) return;

// Emit warning for non-trivial dtor in global scope (a real global,
// class-static, function-static).
Diag(VD->getLocation(), diag::warn_exit_time_destructor);

// TODO: this should be re-enabled for static locals by !CXAAtExit
if (!VD->isStaticLocal())
  Diag(VD->getLocation(), diag::warn_global_destructor);
12655}

12657/// \brief Given a constructor and the set of arguments provided for the
12658/// constructor, convert the arguments and add any required default arguments
12659/// to form a proper call to this constructor.
12660///
12661/// \returns true if an error occurred, false otherwise.
12662bool
12663Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
                            MultiExprArg ArgsPtr,
                            SourceLocation Loc,
                            SmallVectorImpl<Expr*> &ConvertedArgs,
                            bool AllowExplicit,
                            bool IsListInitialization) {
// FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
unsigned NumArgs = ArgsPtr.size();
Expr **Args = ArgsPtr.data();

const FunctionProtoType *Proto
  = Constructor->getType()->getAs<FunctionProtoType>();
assert(Proto && "Constructor without a prototype?")(static_cast <bool> (Proto && "Constructor without a prototype?"
) ? void (0) : __assert_fail ("Proto && \"Constructor without a prototype?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12675, __extension__ __PRETTY_FUNCTION__));
unsigned NumParams = Proto->getNumParams();

// If too few arguments are available, we'll fill in the rest with defaults.
if (NumArgs < NumParams)
  ConvertedArgs.reserve(NumParams);
else
  ConvertedArgs.reserve(NumArgs);

VariadicCallType CallType =
  Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
SmallVector<Expr *, 8> AllArgs;
bool Invalid = GatherArgumentsForCall(Loc, Constructor,
                                      Proto, 0,
                                      llvm::makeArrayRef(Args, NumArgs),
                                      AllArgs,
                                      CallType, AllowExplicit,
                                      IsListInitialization);
ConvertedArgs.append(AllArgs.begin(), AllArgs.end());

DiagnoseSentinelCalls(Constructor, Loc, AllArgs);

CheckConstructorCall(Constructor,
                     llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
                     Proto, Loc);

return Invalid;
12702}

12704static inline bool
12705CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
                                     const FunctionDecl *FnDecl) {
const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
if (isa<NamespaceDecl>(DC)) {
  return SemaRef.Diag(FnDecl->getLocation(),
                      diag::err_operator_new_delete_declared_in_namespace)
    << FnDecl->getDeclName();
}

if (isa<TranslationUnitDecl>(DC) &&
    FnDecl->getStorageClass() == SC_Static) {
  return SemaRef.Diag(FnDecl->getLocation(),
                      diag::err_operator_new_delete_declared_static)
    << FnDecl->getDeclName();
}

return false;
12722}

12724static inline bool
12725CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
                          CanQualType ExpectedResultType,
                          CanQualType ExpectedFirstParamType,
                          unsigned DependentParamTypeDiag,
                          unsigned InvalidParamTypeDiag) {
QualType ResultType =
    FnDecl->getType()->getAs<FunctionType>()->getReturnType();

// Check that the result type is not dependent.
if (ResultType->isDependentType())
  return SemaRef.Diag(FnDecl->getLocation(),
                      diag::err_operator_new_delete_dependent_result_type)
  << FnDecl->getDeclName() << ExpectedResultType;

// Check that the result type is what we expect.
if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
  return SemaRef.Diag(FnDecl->getLocation(),
                      diag::err_operator_new_delete_invalid_result_type)
  << FnDecl->getDeclName() << ExpectedResultType;

// A function template must have at least 2 parameters.
if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
  return SemaRef.Diag(FnDecl->getLocation(),
                    diag::err_operator_new_delete_template_too_few_parameters)
      << FnDecl->getDeclName();

// The function decl must have at least 1 parameter.
if (FnDecl->getNumParams() == 0)
  return SemaRef.Diag(FnDecl->getLocation(),
                      diag::err_operator_new_delete_too_few_parameters)
    << FnDecl->getDeclName();

// Check the first parameter type is not dependent.
QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
if (FirstParamType->isDependentType())
  return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
    << FnDecl->getDeclName() << ExpectedFirstParamType;

// Check that the first parameter type is what we expect.
if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
    ExpectedFirstParamType)
  return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
  << FnDecl->getDeclName() << ExpectedFirstParamType;

return false;
12770}

12772static bool
12773CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
// C++ [basic.stc.dynamic.allocation]p1:
//   A program is ill-formed if an allocation function is declared in a
//   namespace scope other than global scope or declared static in global
//   scope.
if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
  return true;

CanQualType SizeTy =
  SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());

// C++ [basic.stc.dynamic.allocation]p1:
//  The return type shall be void*. The first parameter shall have type
//  std::size_t.
if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
                                SizeTy,
                                diag::err_operator_new_dependent_param_type,
                                diag::err_operator_new_param_type))
  return true;

// C++ [basic.stc.dynamic.allocation]p1:
//  The first parameter shall not have an associated default argument.
if (FnDecl->getParamDecl(0)->hasDefaultArg())
  return SemaRef.Diag(FnDecl->getLocation(),
                      diag::err_operator_new_default_arg)
    << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();

return false;
12801}

12803static bool
12804CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {
// C++ [basic.stc.dynamic.deallocation]p1:
//   A program is ill-formed if deallocation functions are declared in a
//   namespace scope other than global scope or declared static in global
//   scope.
if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
  return true;

auto *MD = dyn_cast<CXXMethodDecl>(FnDecl);

// C++ P0722:
//   Within a class C, the first parameter of a destroying operator delete
//   shall be of type C *. The first parameter of any other deallocation
//   function shall be of type void *.
CanQualType ExpectedFirstParamType =
    MD && MD->isDestroyingOperatorDelete()
        ? SemaRef.Context.getCanonicalType(SemaRef.Context.getPointerType(
              SemaRef.Context.getRecordType(MD->getParent())))
        : SemaRef.Context.VoidPtrTy;

// C++ [basic.stc.dynamic.deallocation]p2:
//   Each deallocation function shall return void
if (CheckOperatorNewDeleteTypes(
        SemaRef, FnDecl, SemaRef.Context.VoidTy, ExpectedFirstParamType,
        diag::err_operator_delete_dependent_param_type,
        diag::err_operator_delete_param_type))
  return true;

// C++ P0722:
//   A destroying operator delete shall be a usual deallocation function.
if (MD && !MD->getParent()->isDependentContext() &&
    MD->isDestroyingOperatorDelete() && !MD->isUsualDeallocationFunction()) {
  SemaRef.Diag(MD->getLocation(),
               diag::err_destroying_operator_delete_not_usual);
  return true;
}

return false;
12842}

12844/// CheckOverloadedOperatorDeclaration - Check whether the declaration
12845/// of this overloaded operator is well-formed. If so, returns false;
12846/// otherwise, emits appropriate diagnostics and returns true.
12847bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
assert(FnDecl && FnDecl->isOverloadedOperator() &&(static_cast <bool> (FnDecl && FnDecl->isOverloadedOperator
() && "Expected an overloaded operator declaration") ?
 void (0) : __assert_fail ("FnDecl && FnDecl->isOverloadedOperator() && \"Expected an overloaded operator declaration\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12849, __extension__ __PRETTY_FUNCTION__))
       "Expected an overloaded operator declaration")(static_cast <bool> (FnDecl && FnDecl->isOverloadedOperator
() && "Expected an overloaded operator declaration") ?
 void (0) : __assert_fail ("FnDecl && FnDecl->isOverloadedOperator() && \"Expected an overloaded operator declaration\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12849, __extension__ __PRETTY_FUNCTION__));

OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();

// C++ [over.oper]p5:
//   The allocation and deallocation functions, operator new,
//   operator new[], operator delete and operator delete[], are
//   described completely in 3.7.3. The attributes and restrictions
//   found in the rest of this subclause do not apply to them unless
//   explicitly stated in 3.7.3.
if (Op == OO_Delete || Op == OO_Array_Delete)
  return CheckOperatorDeleteDeclaration(*this, FnDecl);

if (Op == OO_New || Op == OO_Array_New)
  return CheckOperatorNewDeclaration(*this, FnDecl);

// C++ [over.oper]p6:
//   An operator function shall either be a non-static member
//   function or be a non-member function and have at least one
//   parameter whose type is a class, a reference to a class, an
//   enumeration, or a reference to an enumeration.
if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
  if (MethodDecl->isStatic())
    return Diag(FnDecl->getLocation(),
                diag::err_operator_overload_static) << FnDecl->getDeclName();
} else {
  bool ClassOrEnumParam = false;
  for (auto Param : FnDecl->parameters()) {
    QualType ParamType = Param->getType().getNonReferenceType();
    if (ParamType->isDependentType() || ParamType->isRecordType() ||
        ParamType->isEnumeralType()) {
      ClassOrEnumParam = true;
      break;
    }
  }

  if (!ClassOrEnumParam)
    return Diag(FnDecl->getLocation(),
                diag::err_operator_overload_needs_class_or_enum)
      << FnDecl->getDeclName();
}

// C++ [over.oper]p8:
//   An operator function cannot have default arguments (8.3.6),
//   except where explicitly stated below.
//
// Only the function-call operator allows default arguments
// (C++ [over.call]p1).
if (Op != OO_Call) {
  for (auto Param : FnDecl->parameters()) {
    if (Param->hasDefaultArg())
      return Diag(Param->getLocation(),
                  diag::err_operator_overload_default_arg)
        << FnDecl->getDeclName() << Param->getDefaultArgRange();
  }
}

static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
  { false, false, false }
12908#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
  , { Unary, Binary, MemberOnly }
12910#include "clang/Basic/OperatorKinds.def"
};

bool CanBeUnaryOperator = OperatorUses[Op][0];
bool CanBeBinaryOperator = OperatorUses[Op][1];
bool MustBeMemberOperator = OperatorUses[Op][2];

// C++ [over.oper]p8:
//   [...] Operator functions cannot have more or fewer parameters
//   than the number required for the corresponding operator, as
//   described in the rest of this subclause.
unsigned NumParams = FnDecl->getNumParams()
                   + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
if (Op != OO_Call &&
    ((NumParams == 1 && !CanBeUnaryOperator) ||
     (NumParams == 2 && !CanBeBinaryOperator) ||
     (NumParams < 1) || (NumParams > 2))) {
  // We have the wrong number of parameters.
  unsigned ErrorKind;
  if (CanBeUnaryOperator && CanBeBinaryOperator) {
    ErrorKind = 2;  // 2 -> unary or binary.
  } else if (CanBeUnaryOperator) {
    ErrorKind = 0;  // 0 -> unary
  } else {
    assert(CanBeBinaryOperator &&(static_cast <bool> (CanBeBinaryOperator && "All non-call overloaded operators are unary or binary!"
) ? void (0) : __assert_fail ("CanBeBinaryOperator && \"All non-call overloaded operators are unary or binary!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12935, __extension__ __PRETTY_FUNCTION__))
           "All non-call overloaded operators are unary or binary!")(static_cast <bool> (CanBeBinaryOperator && "All non-call overloaded operators are unary or binary!"
) ? void (0) : __assert_fail ("CanBeBinaryOperator && \"All non-call overloaded operators are unary or binary!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 12935, __extension__ __PRETTY_FUNCTION__));
    ErrorKind = 1;  // 1 -> binary
  }

  return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
    << FnDecl->getDeclName() << NumParams << ErrorKind;
}

// Overloaded operators other than operator() cannot be variadic.
if (Op != OO_Call &&
    FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
  return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
    << FnDecl->getDeclName();
}

// Some operators must be non-static member functions.
if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
  return Diag(FnDecl->getLocation(),
              diag::err_operator_overload_must_be_member)
    << FnDecl->getDeclName();
}

// C++ [over.inc]p1:
//   The user-defined function called operator++ implements the
//   prefix and postfix ++ operator. If this function is a member
//   function with no parameters, or a non-member function with one
//   parameter of class or enumeration type, it defines the prefix
//   increment operator ++ for objects of that type. If the function
//   is a member function with one parameter (which shall be of type
//   int) or a non-member function with two parameters (the second
//   of which shall be of type int), it defines the postfix
//   increment operator ++ for objects of that type.
if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
  ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
  QualType ParamType = LastParam->getType();

  if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) &&
      !ParamType->isDependentType())
    return Diag(LastParam->getLocation(),
                diag::err_operator_overload_post_incdec_must_be_int)
      << LastParam->getType() << (Op == OO_MinusMinus);
}

return false;
12979}

12981static bool
12982checkLiteralOperatorTemplateParameterList(Sema &SemaRef,
                                        FunctionTemplateDecl *TpDecl) {
TemplateParameterList *TemplateParams = TpDecl->getTemplateParameters();

// Must have one or two template parameters.
if (TemplateParams->size() == 1) {
  NonTypeTemplateParmDecl *PmDecl =
      dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(0));

  // The template parameter must be a char parameter pack.
  if (PmDecl && PmDecl->isTemplateParameterPack() &&
      SemaRef.Context.hasSameType(PmDecl->getType(), SemaRef.Context.CharTy))
    return false;

} else if (TemplateParams->size() == 2) {
  TemplateTypeParmDecl *PmType =
      dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(0));
  NonTypeTemplateParmDecl *PmArgs =
      dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(1));

  // The second template parameter must be a parameter pack with the
  // first template parameter as its type.
  if (PmType && PmArgs && !PmType->isTemplateParameterPack() &&
      PmArgs->isTemplateParameterPack()) {
    const TemplateTypeParmType *TArgs =
        PmArgs->getType()->getAs<TemplateTypeParmType>();
    if (TArgs && TArgs->getDepth() == PmType->getDepth() &&
        TArgs->getIndex() == PmType->getIndex()) {
      if (!SemaRef.inTemplateInstantiation())
        SemaRef.Diag(TpDecl->getLocation(),
                     diag::ext_string_literal_operator_template);
      return false;
    }
  }
}

SemaRef.Diag(TpDecl->getTemplateParameters()->getSourceRange().getBegin(),
             diag::err_literal_operator_template)
    << TpDecl->getTemplateParameters()->getSourceRange();
return true;
13022}

13024/// CheckLiteralOperatorDeclaration - Check whether the declaration
13025/// of this literal operator function is well-formed. If so, returns
13026/// false; otherwise, emits appropriate diagnostics and returns true.
13027bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
if (isa<CXXMethodDecl>(FnDecl)) {
  Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
    << FnDecl->getDeclName();
  return true;
}

if (FnDecl->isExternC()) {
  Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
  if (const LinkageSpecDecl *LSD =
          FnDecl->getDeclContext()->getExternCContext())
    Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
  return true;
}

// This might be the definition of a literal operator template.
FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate();

// This might be a specialization of a literal operator template.
if (!TpDecl)
  TpDecl = FnDecl->getPrimaryTemplate();

// template <char...> type operator "" name() and
// template <class T, T...> type operator "" name() are the only valid
// template signatures, and the only valid signatures with no parameters.
if (TpDecl) {
  if (FnDecl->param_size() != 0) {
    Diag(FnDecl->getLocation(),
         diag::err_literal_operator_template_with_params);
    return true;
  }

  if (checkLiteralOperatorTemplateParameterList(*this, TpDecl))
    return true;

} else if (FnDecl->param_size() == 1) {
  const ParmVarDecl *Param = FnDecl->getParamDecl(0);

  QualType ParamType = Param->getType().getUnqualifiedType();

  // Only unsigned long long int, long double, any character type, and const
  // char * are allowed as the only parameters.
  if (ParamType->isSpecificBuiltinType(BuiltinType::ULongLong) ||
      ParamType->isSpecificBuiltinType(BuiltinType::LongDouble) ||
      Context.hasSameType(ParamType, Context.CharTy) ||
      Context.hasSameType(ParamType, Context.WideCharTy) ||
      Context.hasSameType(ParamType, Context.Char16Ty) ||
      Context.hasSameType(ParamType, Context.Char32Ty)) {
  } else if (const PointerType *Ptr = ParamType->getAs<PointerType>()) {
    QualType InnerType = Ptr->getPointeeType();

    // Pointer parameter must be a const char *.
    if (!(Context.hasSameType(InnerType.getUnqualifiedType(),
                              Context.CharTy) &&
          InnerType.isConstQualified() && !InnerType.isVolatileQualified())) {
      Diag(Param->getSourceRange().getBegin(),
           diag::err_literal_operator_param)
          << ParamType << "'const char *'" << Param->getSourceRange();
      return true;
    }

  } else if (ParamType->isRealFloatingType()) {
    Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
        << ParamType << Context.LongDoubleTy << Param->getSourceRange();
    return true;

  } else if (ParamType->isIntegerType()) {
    Diag(Param->getSourceRange().getBegin(), diag::err_literal_operator_param)
        << ParamType << Context.UnsignedLongLongTy << Param->getSourceRange();
    return true;

  } else {
    Diag(Param->getSourceRange().getBegin(),
         diag::err_literal_operator_invalid_param)
        << ParamType << Param->getSourceRange();
    return true;
  }

} else if (FnDecl->param_size() == 2) {
  FunctionDecl::param_iterator Param = FnDecl->param_begin();

  // First, verify that the first parameter is correct.

  QualType FirstParamType = (*Param)->getType().getUnqualifiedType();

  // Two parameter function must have a pointer to const as a
  // first parameter; let's strip those qualifiers.
  const PointerType *PT = FirstParamType->getAs<PointerType>();

  if (!PT) {
    Diag((*Param)->getSourceRange().getBegin(),
         diag::err_literal_operator_param)
        << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
    return true;
  }

  QualType PointeeType = PT->getPointeeType();
  // First parameter must be const
  if (!PointeeType.isConstQualified() || PointeeType.isVolatileQualified()) {
    Diag((*Param)->getSourceRange().getBegin(),
         diag::err_literal_operator_param)
        << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
    return true;
  }

  QualType InnerType = PointeeType.getUnqualifiedType();
  // Only const char *, const wchar_t*, const char16_t*, and const char32_t*
  // are allowed as the first parameter to a two-parameter function
  if (!(Context.hasSameType(InnerType, Context.CharTy) ||
        Context.hasSameType(InnerType, Context.WideCharTy) ||
        Context.hasSameType(InnerType, Context.Char16Ty) ||
        Context.hasSameType(InnerType, Context.Char32Ty))) {
    Diag((*Param)->getSourceRange().getBegin(),
         diag::err_literal_operator_param)
        << FirstParamType << "'const char *'" << (*Param)->getSourceRange();
    return true;
  }

  // Move on to the second and final parameter.
  ++Param;

  // The second parameter must be a std::size_t.
  QualType SecondParamType = (*Param)->getType().getUnqualifiedType();
  if (!Context.hasSameType(SecondParamType, Context.getSizeType())) {
    Diag((*Param)->getSourceRange().getBegin(),
         diag::err_literal_operator_param)
        << SecondParamType << Context.getSizeType()
        << (*Param)->getSourceRange();
    return true;
  }
} else {
  Diag(FnDecl->getLocation(), diag::err_literal_operator_bad_param_count);
  return true;
}

// Parameters are good.

// A parameter-declaration-clause containing a default argument is not
// equivalent to any of the permitted forms.
for (auto Param : FnDecl->parameters()) {
  if (Param->hasDefaultArg()) {
    Diag(Param->getDefaultArgRange().getBegin(),
         diag::err_literal_operator_default_argument)
      << Param->getDefaultArgRange();
    break;
  }
}

StringRef LiteralName
  = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
if (LiteralName[0] != '_' &&
    !getSourceManager().isInSystemHeader(FnDecl->getLocation())) {
  // C++11 [usrlit.suffix]p1:
  //   Literal suffix identifiers that do not start with an underscore
  //   are reserved for future standardization.
  Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved)
    << StringLiteralParser::isValidUDSuffix(getLangOpts(), LiteralName);
}

return false;
13187}

13189/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
13190/// linkage specification, including the language and (if present)
13191/// the '{'. ExternLoc is the location of the 'extern', Lang is the
13192/// language string literal. LBraceLoc, if valid, provides the location of
13193/// the '{' brace. Otherwise, this linkage specification does not
13194/// have any braces.
13195Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
                                         Expr *LangStr,
                                         SourceLocation LBraceLoc) {
StringLiteral *Lit = cast<StringLiteral>(LangStr);
if (!Lit->isAscii()) {
  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_not_ascii)
    << LangStr->getSourceRange();
  return nullptr;
}

StringRef Lang = Lit->getString();
LinkageSpecDecl::LanguageIDs Language;
if (Lang == "C")
  Language = LinkageSpecDecl::lang_c;
else if (Lang == "C++")
  Language = LinkageSpecDecl::lang_cxx;
else {
  Diag(LangStr->getExprLoc(), diag::err_language_linkage_spec_unknown)
    << LangStr->getSourceRange();
  return nullptr;
}

// FIXME: Add all the various semantics of linkage specifications

LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext, ExternLoc,
                                             LangStr->getExprLoc(), Language,
                                             LBraceLoc.isValid());
CurContext->addDecl(D);
PushDeclContext(S, D);
return D;
13225}

13227/// ActOnFinishLinkageSpecification - Complete the definition of
13228/// the C++ linkage specification LinkageSpec. If RBraceLoc is
13229/// valid, it's the position of the closing '}' brace in a linkage
13230/// specification that uses braces.
13231Decl *Sema::ActOnFinishLinkageSpecification(Scope *S,
                                          Decl *LinkageSpec,
                                          SourceLocation RBraceLoc) {
if (RBraceLoc.isValid()) {
  LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
  LSDecl->setRBraceLoc(RBraceLoc);
}
PopDeclContext();
return LinkageSpec;
13240}

13242Decl *Sema::ActOnEmptyDeclaration(Scope *S,
                                AttributeList *AttrList,
                                SourceLocation SemiLoc) {
Decl *ED = EmptyDecl::Create(Context, CurContext, SemiLoc);
// Attribute declarations appertain to empty declaration so we handle
// them here.
if (AttrList)
  ProcessDeclAttributeList(S, ED, AttrList);

CurContext->addDecl(ED);
return ED;
13253}

13255/// \brief Perform semantic analysis for the variable declaration that
13256/// occurs within a C++ catch clause, returning the newly-created
13257/// variable.
13258VarDecl *Sema::BuildExceptionDeclaration(Scope *S,
                                       TypeSourceInfo *TInfo,
                                       SourceLocation StartLoc,
                                       SourceLocation Loc,
                                       IdentifierInfo *Name) {
bool Invalid = false;
QualType ExDeclType = TInfo->getType();

// Arrays and functions decay.
if (ExDeclType->isArrayType())
  ExDeclType = Context.getArrayDecayedType(ExDeclType);
else if (ExDeclType->isFunctionType())
  ExDeclType = Context.getPointerType(ExDeclType);

// C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
// The exception-declaration shall not denote a pointer or reference to an
// incomplete type, other than [cv] void*.
// N2844 forbids rvalue references.
if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
  Diag(Loc, diag::err_catch_rvalue_ref);
  Invalid = true;
}

if (ExDeclType->isVariablyModifiedType()) {
  Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
  Invalid = true;
}

QualType BaseType = ExDeclType;
int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
unsigned DK = diag::err_catch_incomplete;
if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
  BaseType = Ptr->getPointeeType();
  Mode = 1;
  DK = diag::err_catch_incomplete_ptr;
} else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
  // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
  BaseType = Ref->getPointeeType();
  Mode = 2;
  DK = diag::err_catch_incomplete_ref;
}
if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
    !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
  Invalid = true;

if (!Invalid && !ExDeclType->isDependentType() &&
    RequireNonAbstractType(Loc, ExDeclType,
                           diag::err_abstract_type_in_decl,
                           AbstractVariableType))
  Invalid = true;

// Only the non-fragile NeXT runtime currently supports C++ catches
// of ObjC types, and no runtime supports catching ObjC types by value.
if (!Invalid && getLangOpts().ObjC1) {
  QualType T = ExDeclType;
  if (const ReferenceType *RT = T->getAs<ReferenceType>())
    T = RT->getPointeeType();

  if (T->isObjCObjectType()) {
    Diag(Loc, diag::err_objc_object_catch);
    Invalid = true;
  } else if (T->isObjCObjectPointerType()) {
    // FIXME: should this be a test for macosx-fragile specifically?
    if (getLangOpts().ObjCRuntime.isFragile())
      Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
  }
}

VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
                                  ExDeclType, TInfo, SC_None);
ExDecl->setExceptionVariable(true);

// In ARC, infer 'retaining' for variables of retainable type.
if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
  Invalid = true;

if (!Invalid && !ExDeclType->isDependentType()) {
  if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
    // Insulate this from anything else we might currently be parsing.
    EnterExpressionEvaluationContext scope(
        *this, ExpressionEvaluationContext::PotentiallyEvaluated);

    // C++ [except.handle]p16:
    //   The object declared in an exception-declaration or, if the
    //   exception-declaration does not specify a name, a temporary (12.2) is
    //   copy-initialized (8.5) from the exception object. [...]
    //   The object is destroyed when the handler exits, after the destruction
    //   of any automatic objects initialized within the handler.
    //
    // We just pretend to initialize the object with itself, then make sure
    // it can be destroyed later.
    QualType initType = Context.getExceptionObjectType(ExDeclType);

    InitializedEntity entity =
      InitializedEntity::InitializeVariable(ExDecl);
    InitializationKind initKind =
      InitializationKind::CreateCopy(Loc, SourceLocation());

    Expr *opaqueValue =
      new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
    InitializationSequence sequence(*this, entity, initKind, opaqueValue);
    ExprResult result = sequence.Perform(*this, entity, initKind, opaqueValue);
    if (result.isInvalid())
      Invalid = true;
    else {
      // If the constructor used was non-trivial, set this as the
      // "initializer".
      CXXConstructExpr *construct = result.getAs<CXXConstructExpr>();
      if (!construct->getConstructor()->isTrivial()) {
        Expr *init = MaybeCreateExprWithCleanups(construct);
        ExDecl->setInit(init);
      }

      // And make sure it's destructable.
      FinalizeVarWithDestructor(ExDecl, recordType);
    }
  }
}

if (Invalid)
  ExDecl->setInvalidDecl();

return ExDecl;
13381}

13383/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
13384/// handler.
13385Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
bool Invalid = D.isInvalidType();

// Check for unexpanded parameter packs.
if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
                                    UPPC_ExceptionType)) {
  TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
                                           D.getIdentifierLoc());
  Invalid = true;
}

IdentifierInfo *II = D.getIdentifier();
if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
                                           LookupOrdinaryName,
                                           ForVisibleRedeclaration)) {
  // The scope should be freshly made just for us. There is just no way
  // it contains any previous declaration, except for function parameters in
  // a function-try-block's catch statement.
  assert(!S->isDeclScope(PrevDecl))(static_cast <bool> (!S->isDeclScope(PrevDecl)) ? void
 (0) : __assert_fail ("!S->isDeclScope(PrevDecl)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13404, __extension__ __PRETTY_FUNCTION__));
  if (isDeclInScope(PrevDecl, CurContext, S)) {
    Diag(D.getIdentifierLoc(), diag::err_redefinition)
      << D.getIdentifier();
    Diag(PrevDecl->getLocation(), diag::note_previous_definition);
    Invalid = true;
  } else if (PrevDecl->isTemplateParameter())
    // Maybe we will complain about the shadowed template parameter.
    DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
}

if (D.getCXXScopeSpec().isSet() && !Invalid) {
  Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
    << D.getCXXScopeSpec().getRange();
  Invalid = true;
}

VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo,
                                            D.getLocStart(),
                                            D.getIdentifierLoc(),
                                            D.getIdentifier());
if (Invalid)
  ExDecl->setInvalidDecl();

// Add the exception declaration into this scope.
if (II)
  PushOnScopeChains(ExDecl, S);
else
  CurContext->addDecl(ExDecl);

ProcessDeclAttributes(S, ExDecl, D);
return ExDecl;
13436}

13438Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
                                       Expr *AssertExpr,
                                       Expr *AssertMessageExpr,
                                       SourceLocation RParenLoc) {
StringLiteral *AssertMessage =
    AssertMessageExpr ? cast<StringLiteral>(AssertMessageExpr) : nullptr;

if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
  return nullptr;

return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
                                    AssertMessage, RParenLoc, false);
13450}

13452Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
                                       Expr *AssertExpr,
                                       StringLiteral *AssertMessage,
                                       SourceLocation RParenLoc,
                                       bool Failed) {
assert(AssertExpr != nullptr && "Expected non-null condition")(static_cast <bool> (AssertExpr != nullptr && "Expected non-null condition"
) ? void (0) : __assert_fail ("AssertExpr != nullptr && \"Expected non-null condition\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13457, __extension__ __PRETTY_FUNCTION__));
if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
    !Failed) {
  // In a static_assert-declaration, the constant-expression shall be a
  // constant expression that can be contextually converted to bool.
  ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
  if (Converted.isInvalid())
    Failed = true;

  llvm::APSInt Cond;
  if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
        diag::err_static_assert_expression_is_not_constant,
        /*AllowFold=*/false).isInvalid())
    Failed = true;

  if (!Failed && !Cond) {
    SmallString<256> MsgBuffer;
    llvm::raw_svector_ostream Msg(MsgBuffer);
    if (AssertMessage)
      AssertMessage->printPretty(Msg, nullptr, getPrintingPolicy());

    Expr *InnerCond = nullptr;
    std::string InnerCondDescription;
    std::tie(InnerCond, InnerCondDescription) =
      findFailedBooleanCondition(Converted.get(),
                                 /*AllowTopLevelCond=*/false);
    if (InnerCond) {
      Diag(StaticAssertLoc, diag::err_static_assert_requirement_failed)
        << InnerCondDescription << !AssertMessage
        << Msg.str() << InnerCond->getSourceRange();
    } else {
      Diag(StaticAssertLoc, diag::err_static_assert_failed)
        << !AssertMessage << Msg.str() << AssertExpr->getSourceRange();
    }
    Failed = true;
  }
}

ExprResult FullAssertExpr = ActOnFinishFullExpr(AssertExpr, StaticAssertLoc,
                                                /*DiscardedValue*/false,
                                                /*IsConstexpr*/true);
if (FullAssertExpr.isInvalid())
  Failed = true;
else
  AssertExpr = FullAssertExpr.get();

Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
                                      AssertExpr, AssertMessage, RParenLoc,
                                      Failed);

CurContext->addDecl(Decl);
return Decl;
13509}

13511/// \brief Perform semantic analysis of the given friend type declaration.
13512///
13513/// \returns A friend declaration that.
13514FriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart,
                                    SourceLocation FriendLoc,
                                    TypeSourceInfo *TSInfo) {
assert(TSInfo && "NULL TypeSourceInfo for friend type declaration")(static_cast <bool> (TSInfo && "NULL TypeSourceInfo for friend type declaration"
) ? void (0) : __assert_fail ("TSInfo && \"NULL TypeSourceInfo for friend type declaration\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13517, __extension__ __PRETTY_FUNCTION__));

QualType T = TSInfo->getType();
SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();

// C++03 [class.friend]p2:
//   An elaborated-type-specifier shall be used in a friend declaration
//   for a class.*
//
//   * The class-key of the elaborated-type-specifier is required.
if (!CodeSynthesisContexts.empty()) {
  // Do not complain about the form of friend template types during any kind
  // of code synthesis. For template instantiation, we will have complained
  // when the template was defined.
} else {
  if (!T->isElaboratedTypeSpecifier()) {
    // If we evaluated the type to a record type, suggest putting
    // a tag in front.
    if (const RecordType *RT = T->getAs<RecordType>()) {
      RecordDecl *RD = RT->getDecl();

      SmallString<16> InsertionText(" ");
      InsertionText += RD->getKindName();

      Diag(TypeRange.getBegin(),
           getLangOpts().CPlusPlus11 ?
             diag::warn_cxx98_compat_unelaborated_friend_type :
             diag::ext_unelaborated_friend_type)
        << (unsigned) RD->getTagKind()
        << T
        << FixItHint::CreateInsertion(getLocForEndOfToken(FriendLoc),
                                      InsertionText);
    } else {
      Diag(FriendLoc,
           getLangOpts().CPlusPlus11 ?
             diag::warn_cxx98_compat_nonclass_type_friend :
             diag::ext_nonclass_type_friend)
        << T
        << TypeRange;
    }
  } else if (T->getAs<EnumType>()) {
    Diag(FriendLoc,
         getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_enum_friend :
           diag::ext_enum_friend)
      << T
      << TypeRange;
  }

  // C++11 [class.friend]p3:
  //   A friend declaration that does not declare a function shall have one
  //   of the following forms:
  //     friend elaborated-type-specifier ;
  //     friend simple-type-specifier ;
  //     friend typename-specifier ;
  if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)
    Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
}

//   If the type specifier in a friend declaration designates a (possibly
//   cv-qualified) class type, that class is declared as a friend; otherwise,
//   the friend declaration is ignored.
return FriendDecl::Create(Context, CurContext,
                          TSInfo->getTypeLoc().getLocStart(), TSInfo,
                          FriendLoc);
13582}

13584/// Handle a friend tag declaration where the scope specifier was
13585/// templated.
13586Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
                                  unsigned TagSpec, SourceLocation TagLoc,
                                  CXXScopeSpec &SS,
                                  IdentifierInfo *Name,
                                  SourceLocation NameLoc,
                                  AttributeList *Attr,
                                  MultiTemplateParamsArg TempParamLists) {
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);

bool IsMemberSpecialization = false;
bool Invalid = false;

if (TemplateParameterList *TemplateParams =
        MatchTemplateParametersToScopeSpecifier(
            TagLoc, NameLoc, SS, nullptr, TempParamLists, /*friend*/ true,
            IsMemberSpecialization, Invalid)) {
  if (TemplateParams->size() > 0) {
    // This is a declaration of a class template.
    if (Invalid)
      return nullptr;

    return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc, SS, Name,
                              NameLoc, Attr, TemplateParams, AS_public,
                              /*ModulePrivateLoc=*/SourceLocation(),
                              FriendLoc, TempParamLists.size() - 1,
                              TempParamLists.data()).get();
  } else {
    // The "template<>" header is extraneous.
    Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
      << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
    IsMemberSpecialization = true;
  }
}

if (Invalid) return nullptr;

bool isAllExplicitSpecializations = true;
for (unsigned I = TempParamLists.size(); I-- > 0; ) {
  if (TempParamLists[I]->size()) {
    isAllExplicitSpecializations = false;
    break;
  }
}

// FIXME: don't ignore attributes.

// If it's explicit specializations all the way down, just forget
// about the template header and build an appropriate non-templated
// friend.  TODO: for source fidelity, remember the headers.
if (isAllExplicitSpecializations) {
  if (SS.isEmpty()) {
    bool Owned = false;
    bool IsDependent = false;
    return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
                    Attr, AS_public,
                    /*ModulePrivateLoc=*/SourceLocation(),
                    MultiTemplateParamsArg(), Owned, IsDependent,
                    /*ScopedEnumKWLoc=*/SourceLocation(),
                    /*ScopedEnumUsesClassTag=*/false,
                    /*UnderlyingType=*/TypeResult(),
                    /*IsTypeSpecifier=*/false,
                    /*IsTemplateParamOrArg=*/false);
  }

  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
  ElaboratedTypeKeyword Keyword
    = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
  QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
                                 *Name, NameLoc);
  if (T.isNull())
    return nullptr;

  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
  if (isa<DependentNameType>(T)) {
    DependentNameTypeLoc TL =
        TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
    TL.setElaboratedKeywordLoc(TagLoc);
    TL.setQualifierLoc(QualifierLoc);
    TL.setNameLoc(NameLoc);
  } else {
    ElaboratedTypeLoc TL = TSI->getTypeLoc().castAs<ElaboratedTypeLoc>();
    TL.setElaboratedKeywordLoc(TagLoc);
    TL.setQualifierLoc(QualifierLoc);
    TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(NameLoc);
  }

  FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
                                          TSI, FriendLoc, TempParamLists);
  Friend->setAccess(AS_public);
  CurContext->addDecl(Friend);
  return Friend;
}

assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?")(static_cast <bool> (SS.isNotEmpty() && "valid templated tag with no SS and no direct?"
) ? void (0) : __assert_fail ("SS.isNotEmpty() && \"valid templated tag with no SS and no direct?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13679, __extension__ __PRETTY_FUNCTION__));



// Handle the case of a templated-scope friend class.  e.g.
//   template <class T> class A<T>::B;
// FIXME: we don't support these right now.
Diag(NameLoc, diag::warn_template_qualified_friend_unsupported)
  << SS.getScopeRep() << SS.getRange() << cast<CXXRecordDecl>(CurContext);
ElaboratedTypeKeyword ETK = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
TL.setElaboratedKeywordLoc(TagLoc);
TL.setQualifierLoc(SS.getWithLocInContext(Context));
TL.setNameLoc(NameLoc);

FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
                                        TSI, FriendLoc, TempParamLists);
Friend->setAccess(AS_public);
Friend->setUnsupportedFriend(true);
CurContext->addDecl(Friend);
return Friend;
13702}


13705/// Handle a friend type declaration.  This works in tandem with
13706/// ActOnTag.
13707///
13708/// Notes on friend class templates:
13709///
13710/// We generally treat friend class declarations as if they were
13711/// declaring a class.  So, for example, the elaborated type specifier
13712/// in a friend declaration is required to obey the restrictions of a
13713/// class-head (i.e. no typedefs in the scope chain), template
13714/// parameters are required to match up with simple template-ids, &c.
13715/// However, unlike when declaring a template specialization, it's
13716/// okay to refer to a template specialization without an empty
13717/// template parameter declaration, e.g.
13718///   friend class A<T>::B<unsigned>;
13719/// We permit this as a special case; if there are any template
13720/// parameters present at all, require proper matching, i.e.
13721///   template <> template \<class T> friend class A<int>::B;
13722Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
                              MultiTemplateParamsArg TempParams) {
SourceLocation Loc = DS.getLocStart();

assert(DS.isFriendSpecified())(static_cast <bool> (DS.isFriendSpecified()) ? void (0)
 : __assert_fail ("DS.isFriendSpecified()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13726, __extension__ __PRETTY_FUNCTION__));
assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified)(static_cast <bool> (DS.getStorageClassSpec() == DeclSpec
::SCS_unspecified) ? void (0) : __assert_fail ("DS.getStorageClassSpec() == DeclSpec::SCS_unspecified"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13727, __extension__ __PRETTY_FUNCTION__));

// Try to convert the decl specifier to a type.  This works for
// friend templates because ActOnTag never produces a ClassTemplateDecl
// for a TUK_Friend.
Declarator TheDeclarator(DS, DeclaratorContext::MemberContext);
TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
QualType T = TSI->getType();
if (TheDeclarator.isInvalidType())
  return nullptr;

if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
  return nullptr;

// This is definitely an error in C++98.  It's probably meant to
// be forbidden in C++0x, too, but the specification is just
// poorly written.
//
// The problem is with declarations like the following:
//   template <T> friend A<T>::foo;
// where deciding whether a class C is a friend or not now hinges
// on whether there exists an instantiation of A that causes
// 'foo' to equal C.  There are restrictions on class-heads
// (which we declare (by fiat) elaborated friend declarations to
// be) that makes this tractable.
//
// FIXME: handle "template <> friend class A<T>;", which
// is possibly well-formed?  Who even knows?
if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
  Diag(Loc, diag::err_tagless_friend_type_template)
    << DS.getSourceRange();
  return nullptr;
}

// C++98 [class.friend]p1: A friend of a class is a function
//   or class that is not a member of the class . . .
// This is fixed in DR77, which just barely didn't make the C++03
// deadline.  It's also a very silly restriction that seriously
// affects inner classes and which nobody else seems to implement;
// thus we never diagnose it, not even in -pedantic.
//
// But note that we could warn about it: it's always useless to
// friend one of your own members (it's not, however, worthless to
// friend a member of an arbitrary specialization of your template).

Decl *D;
if (!TempParams.empty())
  D = FriendTemplateDecl::Create(Context, CurContext, Loc,
                                 TempParams,
                                 TSI,
                                 DS.getFriendSpecLoc());
else
  D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);

if (!D)
  return nullptr;

D->setAccess(AS_public);
CurContext->addDecl(D);

return D;
13788}

13790NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
                                      MultiTemplateParamsArg TemplateParams) {
const DeclSpec &DS = D.getDeclSpec();

assert(DS.isFriendSpecified())(static_cast <bool> (DS.isFriendSpecified()) ? void (0)
 : __assert_fail ("DS.isFriendSpecified()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13794, __extension__ __PRETTY_FUNCTION__));
assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified)(static_cast <bool> (DS.getStorageClassSpec() == DeclSpec
::SCS_unspecified) ? void (0) : __assert_fail ("DS.getStorageClassSpec() == DeclSpec::SCS_unspecified"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13795, __extension__ __PRETTY_FUNCTION__));

SourceLocation Loc = D.getIdentifierLoc();
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);

// C++ [class.friend]p1
//   A friend of a class is a function or class....
// Note that this sees through typedefs, which is intended.
// It *doesn't* see through dependent types, which is correct
// according to [temp.arg.type]p3:
//   If a declaration acquires a function type through a
//   type dependent on a template-parameter and this causes
//   a declaration that does not use the syntactic form of a
//   function declarator to have a function type, the program
//   is ill-formed.
if (!TInfo->getType()->isFunctionType()) {
  Diag(Loc, diag::err_unexpected_friend);

  // It might be worthwhile to try to recover by creating an
  // appropriate declaration.
  return nullptr;
}

// C++ [namespace.memdef]p3
//  - If a friend declaration in a non-local class first declares a
//    class or function, the friend class or function is a member
//    of the innermost enclosing namespace.
//  - The name of the friend is not found by simple name lookup
//    until a matching declaration is provided in that namespace
//    scope (either before or after the class declaration granting
//    friendship).
//  - If a friend function is called, its name may be found by the
//    name lookup that considers functions from namespaces and
//    classes associated with the types of the function arguments.
//  - When looking for a prior declaration of a class or a function
//    declared as a friend, scopes outside the innermost enclosing
//    namespace scope are not considered.

CXXScopeSpec &SS = D.getCXXScopeSpec();
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
assert(Name)(static_cast <bool> (Name) ? void (0) : __assert_fail (
"Name", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 13836, __extension__ __PRETTY_FUNCTION__));

// Check for unexpanded parameter packs.
if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
    DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
    DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
  return nullptr;

// The context we found the declaration in, or in which we should
// create the declaration.
DeclContext *DC;
Scope *DCScope = S;
LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
                      ForExternalRedeclaration);

// There are five cases here.
//   - There's no scope specifier and we're in a local class. Only look
//     for functions declared in the immediately-enclosing block scope.
// We recover from invalid scope qualifiers as if they just weren't there.
FunctionDecl *FunctionContainingLocalClass = nullptr;
if ((SS.isInvalid() || !SS.isSet()) &&
    (FunctionContainingLocalClass =
         cast<CXXRecordDecl>(CurContext)->isLocalClass())) {
  // C++11 [class.friend]p11:
  //   If a friend declaration appears in a local class and the name
  //   specified is an unqualified name, a prior declaration is
  //   looked up without considering scopes that are outside the
  //   innermost enclosing non-class scope. For a friend function
  //   declaration, if there is no prior declaration, the program is
  //   ill-formed.

  // Find the innermost enclosing non-class scope. This is the block
  // scope containing the local class definition (or for a nested class,
  // the outer local class).
  DCScope = S->getFnParent();

  // Look up the function name in the scope.
  Previous.clear(LookupLocalFriendName);
  LookupName(Previous, S, /*AllowBuiltinCreation*/false);

  if (!Previous.empty()) {
    // All possible previous declarations must have the same context:
    // either they were declared at block scope or they are members of
    // one of the enclosing local classes.
    DC = Previous.getRepresentativeDecl()->getDeclContext();
  } else {
    // This is ill-formed, but provide the context that we would have
    // declared the function in, if we were permitted to, for error recovery.
    DC = FunctionContainingLocalClass;
  }
  adjustContextForLocalExternDecl(DC);

  // C++ [class.friend]p6:
  //   A function can be defined in a friend declaration of a class if and
  //   only if the class is a non-local class (9.8), the function name is
  //   unqualified, and the function has namespace scope.
  if (D.isFunctionDefinition()) {
    Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
  }

//   - There's no scope specifier, in which case we just go to the
//     appropriate scope and look for a function or function template
//     there as appropriate.
} else if (SS.isInvalid() || !SS.isSet()) {
  // C++11 [namespace.memdef]p3:
  //   If the name in a friend declaration is neither qualified nor
  //   a template-id and the declaration is a function or an
  //   elaborated-type-specifier, the lookup to determine whether
  //   the entity has been previously declared shall not consider
  //   any scopes outside the innermost enclosing namespace.
  bool isTemplateId =
      D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId;

  // Find the appropriate context according to the above.
  DC = CurContext;

  // Skip class contexts.  If someone can cite chapter and verse
  // for this behavior, that would be nice --- it's what GCC and
  // EDG do, and it seems like a reasonable intent, but the spec
  // really only says that checks for unqualified existing
  // declarations should stop at the nearest enclosing namespace,
  // not that they should only consider the nearest enclosing
  // namespace.
  while (DC->isRecord())
    DC = DC->getParent();

  DeclContext *LookupDC = DC;
  while (LookupDC->isTransparentContext())
    LookupDC = LookupDC->getParent();

  while (true) {
    LookupQualifiedName(Previous, LookupDC);

    if (!Previous.empty()) {
      DC = LookupDC;
      break;
    }

    if (isTemplateId) {
      if (isa<TranslationUnitDecl>(LookupDC)) break;
    } else {
      if (LookupDC->isFileContext()) break;
    }
    LookupDC = LookupDC->getParent();
  }

  DCScope = getScopeForDeclContext(S, DC);

//   - There's a non-dependent scope specifier, in which case we
//     compute it and do a previous lookup there for a function
//     or function template.
} else if (!SS.getScopeRep()->isDependent()) {
  DC = computeDeclContext(SS);
  if (!DC) return nullptr;

  if (RequireCompleteDeclContext(SS, DC)) return nullptr;

  LookupQualifiedName(Previous, DC);

  // Ignore things found implicitly in the wrong scope.
  // TODO: better diagnostics for this case.  Suggesting the right
  // qualified scope would be nice...
  LookupResult::Filter F = Previous.makeFilter();
  while (F.hasNext()) {
    NamedDecl *D = F.next();
    if (!DC->InEnclosingNamespaceSetOf(
            D->getDeclContext()->getRedeclContext()))
      F.erase();
  }
  F.done();

  if (Previous.empty()) {
    D.setInvalidType();
    Diag(Loc, diag::err_qualified_friend_not_found)
        << Name << TInfo->getType();
    return nullptr;
  }

  // C++ [class.friend]p1: A friend of a class is a function or
  //   class that is not a member of the class . . .
  if (DC->Equals(CurContext))
    Diag(DS.getFriendSpecLoc(),
         getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_friend_is_member :
           diag::err_friend_is_member);

  if (D.isFunctionDefinition()) {
    // C++ [class.friend]p6:
    //   A function can be defined in a friend declaration of a class if and
    //   only if the class is a non-local class (9.8), the function name is
    //   unqualified, and the function has namespace scope.
    SemaDiagnosticBuilder DB
      = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);

    DB << SS.getScopeRep();
    if (DC->isFileContext())
      DB << FixItHint::CreateRemoval(SS.getRange());
    SS.clear();
  }

//   - There's a scope specifier that does not match any template
//     parameter lists, in which case we use some arbitrary context,
//     create a method or method template, and wait for instantiation.
//   - There's a scope specifier that does match some template
//     parameter lists, which we don't handle right now.
} else {
  if (D.isFunctionDefinition()) {
    // C++ [class.friend]p6:
    //   A function can be defined in a friend declaration of a class if and
    //   only if the class is a non-local class (9.8), the function name is
    //   unqualified, and the function has namespace scope.
    Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
      << SS.getScopeRep();
  }

  DC = CurContext;
  assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?")(static_cast <bool> (isa<CXXRecordDecl>(DC) &&
 "friend declaration not in class?") ? void (0) : __assert_fail
 ("isa<CXXRecordDecl>(DC) && \"friend declaration not in class?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14012, __extension__ __PRETTY_FUNCTION__));
}

if (!DC->isRecord()) {
  int DiagArg = -1;
  switch (D.getName().getKind()) {
  case UnqualifiedIdKind::IK_ConstructorTemplateId:
  case UnqualifiedIdKind::IK_ConstructorName:
    DiagArg = 0;
    break;
  case UnqualifiedIdKind::IK_DestructorName:
    DiagArg = 1;
    break;
  case UnqualifiedIdKind::IK_ConversionFunctionId:
    DiagArg = 2;
    break;
  case UnqualifiedIdKind::IK_DeductionGuideName:
    DiagArg = 3;
    break;
  case UnqualifiedIdKind::IK_Identifier:
  case UnqualifiedIdKind::IK_ImplicitSelfParam:
  case UnqualifiedIdKind::IK_LiteralOperatorId:
  case UnqualifiedIdKind::IK_OperatorFunctionId:
  case UnqualifiedIdKind::IK_TemplateId:
    break;
  }
  // This implies that it has to be an operator or function.
  if (DiagArg >= 0) {
    Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
    return nullptr;
  }
}

// FIXME: This is an egregious hack to cope with cases where the scope stack
// does not contain the declaration context, i.e., in an out-of-line
// definition of a class.
Scope FakeDCScope(S, Scope::DeclScope, Diags);
if (!DCScope) {
  FakeDCScope.setEntity(DC);
  DCScope = &FakeDCScope;
}

bool AddToScope = true;
NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
                                        TemplateParams, AddToScope);
if (!ND) return nullptr;

assert(ND->getLexicalDeclContext() == CurContext)(static_cast <bool> (ND->getLexicalDeclContext() == CurContext
) ? void (0) : __assert_fail ("ND->getLexicalDeclContext() == CurContext"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14059, __extension__ __PRETTY_FUNCTION__));

// If we performed typo correction, we might have added a scope specifier
// and changed the decl context.
DC = ND->getDeclContext();

// Add the function declaration to the appropriate lookup tables,
// adjusting the redeclarations list as necessary.  We don't
// want to do this yet if the friending class is dependent.
//
// Also update the scope-based lookup if the target context's
// lookup context is in lexical scope.
if (!CurContext->isDependentContext()) {
  DC = DC->getRedeclContext();
  DC->makeDeclVisibleInContext(ND);
  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
    PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
}

FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
                                     D.getIdentifierLoc(), ND,
                                     DS.getFriendSpecLoc());
FrD->setAccess(AS_public);
CurContext->addDecl(FrD);

if (ND->isInvalidDecl()) {
  FrD->setInvalidDecl();
} else {
  if (DC->isRecord()) CheckFriendAccess(ND);

  FunctionDecl *FD;
  if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
    FD = FTD->getTemplatedDecl();
  else
    FD = cast<FunctionDecl>(ND);

  // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
  // default argument expression, that declaration shall be a definition
  // and shall be the only declaration of the function or function
  // template in the translation unit.
  if (functionDeclHasDefaultArgument(FD)) {
    // We can't look at FD->getPreviousDecl() because it may not have been set
    // if we're in a dependent context. If the function is known to be a
    // redeclaration, we will have narrowed Previous down to the right decl.
    if (D.isRedeclaration()) {
      Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_redeclared);
      Diag(Previous.getRepresentativeDecl()->getLocation(),
           diag::note_previous_declaration);
    } else if (!D.isFunctionDefinition())
      Diag(FD->getLocation(), diag::err_friend_decl_with_def_arg_must_be_def);
  }

  // Mark templated-scope function declarations as unsupported.
  if (FD->getNumTemplateParameterLists() && SS.isValid()) {
    Diag(FD->getLocation(), diag::warn_template_qualified_friend_unsupported)
      << SS.getScopeRep() << SS.getRange()
      << cast<CXXRecordDecl>(CurContext);
    FrD->setUnsupportedFriend(true);
  }
}

return ND;
14121}

14123void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
AdjustDeclIfTemplate(Dcl);

FunctionDecl *Fn = dyn_cast_or_null<FunctionDecl>(Dcl);
if (!Fn) {
  Diag(DelLoc, diag::err_deleted_non_function);
  return;
}

// Deleted function does not have a body.
Fn->setWillHaveBody(false);

if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
  // Don't consider the implicit declaration we generate for explicit
  // specializations. FIXME: Do not generate these implicit declarations.
  if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization ||
       Prev->getPreviousDecl()) &&
      !Prev->isDefined()) {
    Diag(DelLoc, diag::err_deleted_decl_not_first);
    Diag(Prev->getLocation().isInvalid() ? DelLoc : Prev->getLocation(),
         Prev->isImplicit() ? diag::note_previous_implicit_declaration
                            : diag::note_previous_declaration);
  }
  // If the declaration wasn't the first, we delete the function anyway for
  // recovery.
  Fn = Fn->getCanonicalDecl();
}

// dllimport/dllexport cannot be deleted.
if (const InheritableAttr *DLLAttr = getDLLAttr(Fn)) {
  Diag(Fn->getLocation(), diag::err_attribute_dll_deleted) << DLLAttr;
  Fn->setInvalidDecl();
}

if (Fn->isDeleted())
  return;

// See if we're deleting a function which is already known to override a
// non-deleted virtual function.
if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Fn)) {
  bool IssuedDiagnostic = false;
  for (const CXXMethodDecl *O : MD->overridden_methods()) {
    if (!(*MD->begin_overridden_methods())->isDeleted()) {
      if (!IssuedDiagnostic) {
        Diag(DelLoc, diag::err_deleted_override) << MD->getDeclName();
        IssuedDiagnostic = true;
      }
      Diag(O->getLocation(), diag::note_overridden_virtual_function);
    }
  }
  // If this function was implicitly deleted because it was defaulted,
  // explain why it was deleted.
  if (IssuedDiagnostic && MD->isDefaulted())
    ShouldDeleteSpecialMember(MD, getSpecialMember(MD), nullptr,
                              /*Diagnose*/true);
}

// C++11 [basic.start.main]p3:
//   A program that defines main as deleted [...] is ill-formed.
if (Fn->isMain())
  Diag(DelLoc, diag::err_deleted_main);

// C++11 [dcl.fct.def.delete]p4:
//  A deleted function is implicitly inline.
Fn->setImplicitlyInline();
Fn->setDeletedAsWritten();
14189}

14191void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Dcl);

if (MD) {
  if (MD->getParent()->isDependentType()) {
    MD->setDefaulted();
    MD->setExplicitlyDefaulted();
    return;
  }

  CXXSpecialMember Member = getSpecialMember(MD);
  if (Member == CXXInvalid) {
    if (!MD->isInvalidDecl())
      Diag(DefaultLoc, diag::err_default_special_members);
    return;
  }

  MD->setDefaulted();
  MD->setExplicitlyDefaulted();

  // Unset that we will have a body for this function. We might not,
  // if it turns out to be trivial, and we don't need this marking now
  // that we've marked it as defaulted.
  MD->setWillHaveBody(false);

  // If this definition appears within the record, do the checking when
  // the record is complete.
  const FunctionDecl *Primary = MD;
  if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
    // Ask the template instantiation pattern that actually had the
    // '= default' on it.
    Primary = Pattern;

  // If the method was defaulted on its first declaration, we will have
  // already performed the checking in CheckCompletedCXXClass. Such a
  // declaration doesn't trigger an implicit definition.
  if (Primary->getCanonicalDecl()->isDefaulted())
    return;

  CheckExplicitlyDefaultedSpecialMember(MD);

  if (!MD->isInvalidDecl())
    DefineImplicitSpecialMember(*this, MD, DefaultLoc);
} else {
  Diag(DefaultLoc, diag::err_default_special_members);
}
14237}

14239static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
for (Stmt *SubStmt : S->children()) {
  if (!SubStmt)
    continue;
  if (isa<ReturnStmt>(SubStmt))
    Self.Diag(SubStmt->getLocStart(),
         diag::err_return_in_constructor_handler);
  if (!isa<Expr>(SubStmt))
    SearchForReturnInStmt(Self, SubStmt);
}
14249}

14251void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
  CXXCatchStmt *Handler = TryBlock->getHandler(I);
  SearchForReturnInStmt(*this, Handler);
}
14256}

14258bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
                                           const CXXMethodDecl *Old) {
const auto *NewFT = New->getType()->getAs<FunctionProtoType>();
const auto *OldFT = Old->getType()->getAs<FunctionProtoType>();

if (OldFT->hasExtParameterInfos()) {
  for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
    // A parameter of the overriding method should be annotated with noescape
    // if the corresponding parameter of the overridden method is annotated.
    if (OldFT->getExtParameterInfo(I).isNoEscape() &&
        !NewFT->getExtParameterInfo(I).isNoEscape()) {
      Diag(New->getParamDecl(I)->getLocation(),
           diag::warn_overriding_method_missing_noescape);
      Diag(Old->getParamDecl(I)->getLocation(),
           diag::note_overridden_marked_noescape);
    }
}

CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();

// If the calling conventions match, everything is fine
if (NewCC == OldCC)
  return false;

// If the calling conventions mismatch because the new function is static,
// suppress the calling convention mismatch error; the error about static
// function override (err_static_overrides_virtual from
// Sema::CheckFunctionDeclaration) is more clear.
if (New->getStorageClass() == SC_Static)
  return false;

Diag(New->getLocation(),
     diag::err_conflicting_overriding_cc_attributes)
  << New->getDeclName() << New->getType() << Old->getType();
Diag(Old->getLocation(), diag::note_overridden_virtual_function);
return true;
14294}

14296bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
                                           const CXXMethodDecl *Old) {
QualType NewTy = New->getType()->getAs<FunctionType>()->getReturnType();
QualType OldTy = Old->getType()->getAs<FunctionType>()->getReturnType();

if (Context.hasSameType(NewTy, OldTy) ||
    NewTy->isDependentType() || OldTy->isDependentType())
  return false;

// Check if the return types are covariant
QualType NewClassTy, OldClassTy;

/// Both types must be pointers or references to classes.
if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
  if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
    NewClassTy = NewPT->getPointeeType();
    OldClassTy = OldPT->getPointeeType();
  }
} else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
  if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
    if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
      NewClassTy = NewRT->getPointeeType();
      OldClassTy = OldRT->getPointeeType();
    }
  }
}

// The return types aren't either both pointers or references to a class type.
if (NewClassTy.isNull()) {
  Diag(New->getLocation(),
       diag::err_different_return_type_for_overriding_virtual_function)
      << New->getDeclName() << NewTy << OldTy
      << New->getReturnTypeSourceRange();
  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
      << Old->getReturnTypeSourceRange();

  return true;
}

if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
  // C++14 [class.virtual]p8:
  //   If the class type in the covariant return type of D::f differs from
  //   that of B::f, the class type in the return type of D::f shall be
  //   complete at the point of declaration of D::f or shall be the class
  //   type D.
  if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
    if (!RT->isBeingDefined() &&
        RequireCompleteType(New->getLocation(), NewClassTy,
                            diag::err_covariant_return_incomplete,
                            New->getDeclName()))
      return true;
  }

  // Check if the new class derives from the old class.
  if (!IsDerivedFrom(New->getLocation(), NewClassTy, OldClassTy)) {
    Diag(New->getLocation(), diag::err_covariant_return_not_derived)
        << New->getDeclName() << NewTy << OldTy
        << New->getReturnTypeSourceRange();
    Diag(Old->getLocation(), diag::note_overridden_virtual_function)
        << Old->getReturnTypeSourceRange();
    return true;
  }

  // Check if we the conversion from derived to base is valid.
  if (CheckDerivedToBaseConversion(
          NewClassTy, OldClassTy,
          diag::err_covariant_return_inaccessible_base,
          diag::err_covariant_return_ambiguous_derived_to_base_conv,
          New->getLocation(), New->getReturnTypeSourceRange(),
          New->getDeclName(), nullptr)) {
    // FIXME: this note won't trigger for delayed access control
    // diagnostics, and it's impossible to get an undelayed error
    // here from access control during the original parse because
    // the ParsingDeclSpec/ParsingDeclarator are still in scope.
    Diag(Old->getLocation(), diag::note_overridden_virtual_function)
        << Old->getReturnTypeSourceRange();
    return true;
  }
}

// The qualifiers of the return types must be the same.
if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
  Diag(New->getLocation(),
       diag::err_covariant_return_type_different_qualifications)
      << New->getDeclName() << NewTy << OldTy
      << New->getReturnTypeSourceRange();
  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
      << Old->getReturnTypeSourceRange();
  return true;
}


// The new class type must have the same or less qualifiers as the old type.
if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
  Diag(New->getLocation(),
       diag::err_covariant_return_type_class_type_more_qualified)
      << New->getDeclName() << NewTy << OldTy
      << New->getReturnTypeSourceRange();
  Diag(Old->getLocation(), diag::note_overridden_virtual_function)
      << Old->getReturnTypeSourceRange();
  return true;
}

return false;
14400}

14402/// \brief Mark the given method pure.
14403///
14404/// \param Method the method to be marked pure.
14405///
14406/// \param InitRange the source range that covers the "0" initializer.
14407bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
SourceLocation EndLoc = InitRange.getEnd();
if (EndLoc.isValid())
  Method->setRangeEnd(EndLoc);

if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
  Method->setPure();
  return false;
}

if (!Method->isInvalidDecl())
  Diag(Method->getLocation(), diag::err_non_virtual_pure)
    << Method->getDeclName() << InitRange;
return true;
14421}

14423void Sema::ActOnPureSpecifier(Decl *D, SourceLocation ZeroLoc) {
if (D->getFriendObjectKind())
  Diag(D->getLocation(), diag::err_pure_friend);
else if (auto *M = dyn_cast<CXXMethodDecl>(D))
  CheckPureMethod(M, ZeroLoc);
else
  Diag(D->getLocation(), diag::err_illegal_initializer);
14430}

14432/// \brief Determine whether the given declaration is a global variable or
14433/// static data member.
14434static bool isNonlocalVariable(const Decl *D) {
if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D))
  return Var->hasGlobalStorage();

return false;
14439}

14441/// Invoked when we are about to parse an initializer for the declaration
14442/// 'Dcl'.
14443///
14444/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
14445/// static data member of class X, names should be looked up in the scope of
14446/// class X. If the declaration had a scope specifier, a scope will have
14447/// been created and passed in for this purpose. Otherwise, S will be null.
14448void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
// If there is no declaration, there was an error parsing it.
if (!D || D->isInvalidDecl())
  return;

// We will always have a nested name specifier here, but this declaration
// might not be out of line if the specifier names the current namespace:
//   extern int n;
//   int ::n = 0;
if (S && D->isOutOfLine())
  EnterDeclaratorContext(S, D->getDeclContext());

// If we are parsing the initializer for a static data member, push a
// new expression evaluation context that is associated with this static
// data member.
if (isNonlocalVariable(D))
  PushExpressionEvaluationContext(
      ExpressionEvaluationContext::PotentiallyEvaluated, D);
14466}

14468/// Invoked after we are finished parsing an initializer for the declaration D.
14469void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
// If there is no declaration, there was an error parsing it.
if (!D || D->isInvalidDecl())
  return;

if (isNonlocalVariable(D))
  PopExpressionEvaluationContext();

if (S && D->isOutOfLine())
  ExitDeclaratorContext(S);
14479}

14481/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
14482/// C++ if/switch/while/for statement.
14483/// e.g: "if (int x = f()) {...}"
14484DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
// C++ 6.4p2:
// The declarator shall not specify a function or an array.
// The type-specifier-seq shall not contain typedef and shall not declare a
// new class or enumeration.
assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&(static_cast <bool> (D.getDeclSpec().getStorageClassSpec
() != DeclSpec::SCS_typedef && "Parser allowed 'typedef' as storage class of condition decl."
) ? void (0) : __assert_fail ("D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && \"Parser allowed 'typedef' as storage class of condition decl.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14490, __extension__ __PRETTY_FUNCTION__))
       "Parser allowed 'typedef' as storage class of condition decl.")(static_cast <bool> (D.getDeclSpec().getStorageClassSpec
() != DeclSpec::SCS_typedef && "Parser allowed 'typedef' as storage class of condition decl."
) ? void (0) : __assert_fail ("D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && \"Parser allowed 'typedef' as storage class of condition decl.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14490, __extension__ __PRETTY_FUNCTION__));

Decl *Dcl = ActOnDeclarator(S, D);
if (!Dcl)
  return true;

if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
  Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
    << D.getSourceRange();
  return true;
}

return Dcl;
14503}

14505void Sema::LoadExternalVTableUses() {
if (!ExternalSource)
  return;

SmallVector<ExternalVTableUse, 4> VTables;
ExternalSource->ReadUsedVTables(VTables);
SmallVector<VTableUse, 4> NewUses;
for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
  llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
    = VTablesUsed.find(VTables[I].Record);
  // Even if a definition wasn't required before, it may be required now.
  if (Pos != VTablesUsed.end()) {
    if (!Pos->second && VTables[I].DefinitionRequired)
      Pos->second = true;
    continue;
  }

  VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
  NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
}

VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
14527}

14529void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
                        bool DefinitionRequired) {
// Ignore any vtable uses in unevaluated operands or for classes that do
// not have a vtable.
if (!Class->isDynamicClass() || Class->isDependentContext() ||
    CurContext->isDependentContext() || isUnevaluatedContext())
  return;

// Try to insert this class into the map.
LoadExternalVTableUses();
Class = cast<CXXRecordDecl>(Class->getCanonicalDecl());
std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
  Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
if (!Pos.second) {
  // If we already had an entry, check to see if we are promoting this vtable
  // to require a definition. If so, we need to reappend to the VTableUses
  // list, since we may have already processed the first entry.
  if (DefinitionRequired && !Pos.first->second) {
    Pos.first->second = true;
  } else {
    // Otherwise, we can early exit.
    return;
  }
} else {
  // The Microsoft ABI requires that we perform the destructor body
  // checks (i.e. operator delete() lookup) when the vtable is marked used, as
  // the deleting destructor is emitted with the vtable, not with the
  // destructor definition as in the Itanium ABI.
  if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
    CXXDestructorDecl *DD = Class->getDestructor();
    if (DD && DD->isVirtual() && !DD->isDeleted()) {
      if (Class->hasUserDeclaredDestructor() && !DD->isDefined()) {
        // If this is an out-of-line declaration, marking it referenced will
        // not do anything. Manually call CheckDestructor to look up operator
        // delete().
        ContextRAII SavedContext(*this, DD);
        CheckDestructor(DD);
      } else {
        MarkFunctionReferenced(Loc, Class->getDestructor());
      }
    }
  }
}

// Local classes need to have their virtual members marked
// immediately. For all other classes, we mark their virtual members
// at the end of the translation unit.
if (Class->isLocalClass())
  MarkVirtualMembersReferenced(Loc, Class);
else
  VTableUses.push_back(std::make_pair(Class, Loc));
14580}

14582bool Sema::DefineUsedVTables() {
LoadExternalVTableUses();
if (VTableUses.empty())
  return false;

// Note: The VTableUses vector could grow as a result of marking
// the members of a class as "used", so we check the size each
// time through the loop and prefer indices (which are stable) to
// iterators (which are not).
bool DefinedAnything = false;
for (unsigned I = 0; I != VTableUses.size(); ++I) {
  CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
  if (!Class)
    continue;
  TemplateSpecializationKind ClassTSK =
      Class->getTemplateSpecializationKind();

  SourceLocation Loc = VTableUses[I].second;

  bool DefineVTable = true;

  // If this class has a key function, but that key function is
  // defined in another translation unit, we don't need to emit the
  // vtable even though we're using it.
  const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(Class);
  if (KeyFunction && !KeyFunction->hasBody()) {
    // The key function is in another translation unit.
    DefineVTable = false;
    TemplateSpecializationKind TSK =
        KeyFunction->getTemplateSpecializationKind();
    assert(TSK != TSK_ExplicitInstantiationDefinition &&(static_cast <bool> (TSK != TSK_ExplicitInstantiationDefinition
 && TSK != TSK_ImplicitInstantiation && "Instantiations don't have key functions"
) ? void (0) : __assert_fail ("TSK != TSK_ExplicitInstantiationDefinition && TSK != TSK_ImplicitInstantiation && \"Instantiations don't have key functions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14614, __extension__ __PRETTY_FUNCTION__))
           TSK != TSK_ImplicitInstantiation &&(static_cast <bool> (TSK != TSK_ExplicitInstantiationDefinition
 && TSK != TSK_ImplicitInstantiation && "Instantiations don't have key functions"
) ? void (0) : __assert_fail ("TSK != TSK_ExplicitInstantiationDefinition && TSK != TSK_ImplicitInstantiation && \"Instantiations don't have key functions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14614, __extension__ __PRETTY_FUNCTION__))
           "Instantiations don't have key functions")(static_cast <bool> (TSK != TSK_ExplicitInstantiationDefinition
 && TSK != TSK_ImplicitInstantiation && "Instantiations don't have key functions"
) ? void (0) : __assert_fail ("TSK != TSK_ExplicitInstantiationDefinition && TSK != TSK_ImplicitInstantiation && \"Instantiations don't have key functions\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14614, __extension__ __PRETTY_FUNCTION__));
    (void)TSK;
  } else if (!KeyFunction) {
    // If we have a class with no key function that is the subject
    // of an explicit instantiation declaration, suppress the
    // vtable; it will live with the explicit instantiation
    // definition.
    bool IsExplicitInstantiationDeclaration =
        ClassTSK == TSK_ExplicitInstantiationDeclaration;
    for (auto R : Class->redecls()) {
      TemplateSpecializationKind TSK
        = cast<CXXRecordDecl>(R)->getTemplateSpecializationKind();
      if (TSK == TSK_ExplicitInstantiationDeclaration)
        IsExplicitInstantiationDeclaration = true;
      else if (TSK == TSK_ExplicitInstantiationDefinition) {
        IsExplicitInstantiationDeclaration = false;
        break;
      }
    }

    if (IsExplicitInstantiationDeclaration)
      DefineVTable = false;
  }

  // The exception specifications for all virtual members may be needed even
  // if we are not providing an authoritative form of the vtable in this TU.
  // We may choose to emit it available_externally anyway.
  if (!DefineVTable) {
    MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
    continue;
  }

  // Mark all of the virtual members of this class as referenced, so
  // that we can build a vtable. Then, tell the AST consumer that a
  // vtable for this class is required.
  DefinedAnything = true;
  MarkVirtualMembersReferenced(Loc, Class);
  CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl());
  if (VTablesUsed[Canonical])
    Consumer.HandleVTable(Class);

  // Warn if we're emitting a weak vtable. The vtable will be weak if there is
  // no key function or the key function is inlined. Don't warn in C++ ABIs
  // that lack key functions, since the user won't be able to make one.
  if (Context.getTargetInfo().getCXXABI().hasKeyFunctions() &&
      Class->isExternallyVisible() && ClassTSK != TSK_ImplicitInstantiation) {
    const FunctionDecl *KeyFunctionDef = nullptr;
    if (!KeyFunction || (KeyFunction->hasBody(KeyFunctionDef) &&
                         KeyFunctionDef->isInlined())) {
      Diag(Class->getLocation(),
           ClassTSK == TSK_ExplicitInstantiationDefinition
               ? diag::warn_weak_template_vtable
               : diag::warn_weak_vtable)
          << Class;
    }
  }
}
VTableUses.clear();

return DefinedAnything;
14674}

14676void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
                                               const CXXRecordDecl *RD) {
for (const auto *I : RD->methods())
  if (I->isVirtual() && !I->isPure())
    ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
14681}

14683void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
                                      const CXXRecordDecl *RD) {
// Mark all functions which will appear in RD's vtable as used.
CXXFinalOverriderMap FinalOverriders;
RD->getFinalOverriders(FinalOverriders);
for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
                                          E = FinalOverriders.end();
     I != E; ++I) {
  for (OverridingMethods::const_iterator OI = I->second.begin(),
                                         OE = I->second.end();
       OI != OE; ++OI) {
    assert(OI->second.size() > 0 && "no final overrider")(static_cast <bool> (OI->second.size() > 0 &&
 "no final overrider") ? void (0) : __assert_fail ("OI->second.size() > 0 && \"no final overrider\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14694, __extension__ __PRETTY_FUNCTION__));
    CXXMethodDecl *Overrider = OI->second.front().Method;

    // C++ [basic.def.odr]p2:
    //   [...] A virtual member function is used if it is not pure. [...]
    if (!Overrider->isPure())
      MarkFunctionReferenced(Loc, Overrider);
  }
}

// Only classes that have virtual bases need a VTT.
if (RD->getNumVBases() == 0)
  return;

for (const auto &I : RD->bases()) {
  const CXXRecordDecl *Base =
      cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
  if (Base->getNumVBases() == 0)
    continue;
  MarkVirtualMembersReferenced(Loc, Base);
}
14715}

14717/// SetIvarInitializers - This routine builds initialization ASTs for the
14718/// Objective-C implementation whose ivars need be initialized.
14719void Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {
if (!getLangOpts().CPlusPlus)
  return;
if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
  SmallVector<ObjCIvarDecl*, 8> ivars;
  CollectIvarsToConstructOrDestruct(OID, ivars);
  if (ivars.empty())
    return;
  SmallVector<CXXCtorInitializer*, 32> AllToInit;
  for (unsigned i = 0; i < ivars.size(); i++) {
    FieldDecl *Field = ivars[i];
    if (Field->isInvalidDecl())
      continue;

    CXXCtorInitializer *Member;
    InitializedEntity InitEntity = InitializedEntity::InitializeMember(Field);
    InitializationKind InitKind =
      InitializationKind::CreateDefault(ObjCImplementation->getLocation());

    InitializationSequence InitSeq(*this, InitEntity, InitKind, None);
    ExprResult MemberInit =
      InitSeq.Perform(*this, InitEntity, InitKind, None);
    MemberInit = MaybeCreateExprWithCleanups(MemberInit);
    // Note, MemberInit could actually come back empty if no initialization
    // is required (e.g., because it would call a trivial default constructor)
    if (!MemberInit.get() || MemberInit.isInvalid())
      continue;

    Member =
      new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
                                       SourceLocation(),
                                       MemberInit.getAs<Expr>(),
                                       SourceLocation());
    AllToInit.push_back(Member);

    // Be sure that the destructor is accessible and is marked as referenced.
    if (const RecordType *RecordTy =
            Context.getBaseElementType(Field->getType())
                ->getAs<RecordType>()) {
      CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
      if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
        MarkFunctionReferenced(Field->getLocation(), Destructor);
        CheckDestructorAccess(Field->getLocation(), Destructor,
                          PDiag(diag::err_access_dtor_ivar)
                            << Context.getBaseElementType(Field->getType()));
      }
    }
  }
  ObjCImplementation->setIvarInitializers(Context,
                                          AllToInit.data(), AllToInit.size());
}
14770}

14772static
14773void DelegatingCycleHelper(CXXConstructorDecl* Ctor,
                         llvm::SmallSet<CXXConstructorDecl*, 4> &Valid,
                         llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid,
                         llvm::SmallSet<CXXConstructorDecl*, 4> &Current,
                         Sema &S) {
if (Ctor->isInvalidDecl())
  return;

CXXConstructorDecl *Target = Ctor->getTargetConstructor();

// Target may not be determinable yet, for instance if this is a dependent
// call in an uninstantiated template.
if (Target) {
  const FunctionDecl *FNTarget = nullptr;
  (void)Target->hasBody(FNTarget);
  Target = const_cast<CXXConstructorDecl*>(
    cast_or_null<CXXConstructorDecl>(FNTarget));
}

CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
                   // Avoid dereferencing a null pointer here.
                   *TCanonical = Target? Target->getCanonicalDecl() : nullptr;

if (!Current.insert(Canonical).second)
  return;

// We know that beyond here, we aren't chaining into a cycle.
if (!Target || !Target->isDelegatingConstructor() ||
    Target->isInvalidDecl() || Valid.count(TCanonical)) {
  Valid.insert(Current.begin(), Current.end());
  Current.clear();
// We've hit a cycle.
} else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
           Current.count(TCanonical)) {
  // If we haven't diagnosed this cycle yet, do so now.
  if (!Invalid.count(TCanonical)) {
    S.Diag((*Ctor->init_begin())->getSourceLocation(),
           diag::warn_delegating_ctor_cycle)
      << Ctor;

    // Don't add a note for a function delegating directly to itself.
    if (TCanonical != Canonical)
      S.Diag(Target->getLocation(), diag::note_it_delegates_to);

    CXXConstructorDecl *C = Target;
    while (C->getCanonicalDecl() != Canonical) {
      const FunctionDecl *FNTarget = nullptr;
      (void)C->getTargetConstructor()->hasBody(FNTarget);
      assert(FNTarget && "Ctor cycle through bodiless function")(static_cast <bool> (FNTarget && "Ctor cycle through bodiless function"
) ? void (0) : __assert_fail ("FNTarget && \"Ctor cycle through bodiless function\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 14821, __extension__ __PRETTY_FUNCTION__));

      C = const_cast<CXXConstructorDecl*>(
        cast<CXXConstructorDecl>(FNTarget));
      S.Diag(C->getLocation(), diag::note_which_delegates_to);
    }
  }

  Invalid.insert(Current.begin(), Current.end());
  Current.clear();
} else {
  DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
}
14834}


14837void Sema::CheckDelegatingCtorCycles() {
llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;

for (DelegatingCtorDeclsType::iterator
       I = DelegatingCtorDecls.begin(ExternalSource),
       E = DelegatingCtorDecls.end();
     I != E; ++I)
  DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);

for (llvm::SmallSet<CXXConstructorDecl *, 4>::iterator CI = Invalid.begin(),
                                                       CE = Invalid.end();
     CI != CE; ++CI)
  (*CI)->setInvalidDecl();
14850}

14852namespace {
/// \brief AST visitor that finds references to the 'this' expression.
class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
  Sema &S;

public:
  explicit FindCXXThisExpr(Sema &S) : S(S) { }

  bool VisitCXXThisExpr(CXXThisExpr *E) {
    S.Diag(E->getLocation(), diag::err_this_static_member_func)
      << E->isImplicit();
    return false;
  }
};
14866}

14868bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) {
TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
if (!TSInfo)
  return false;

TypeLoc TL = TSInfo->getTypeLoc();
FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
if (!ProtoTL)
  return false;

// C++11 [expr.prim.general]p3:
//   [The expression this] shall not appear before the optional
//   cv-qualifier-seq and it shall not appear within the declaration of a
//   static member function (although its type and value category are defined
//   within a static member function as they are within a non-static member
//   function). [ Note: this is because declaration matching does not occur
//  until the complete declarator is known. - end note ]
const FunctionProtoType *Proto = ProtoTL.getTypePtr();
FindCXXThisExpr Finder(*this);

// If the return type came after the cv-qualifier-seq, check it now.
if (Proto->hasTrailingReturn() &&
    !Finder.TraverseTypeLoc(ProtoTL.getReturnLoc()))
  return true;

// Check the exception specification.
if (checkThisInStaticMemberFunctionExceptionSpec(Method))
  return true;

return checkThisInStaticMemberFunctionAttributes(Method);
14898}

14900bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) {
TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
if (!TSInfo)
  return false;

TypeLoc TL = TSInfo->getTypeLoc();
FunctionProtoTypeLoc ProtoTL = TL.getAs<FunctionProtoTypeLoc>();
if (!ProtoTL)
  return false;

const FunctionProtoType *Proto = ProtoTL.getTypePtr();
FindCXXThisExpr Finder(*this);

switch (Proto->getExceptionSpecType()) {
case EST_Unparsed:
case EST_Uninstantiated:
case EST_Unevaluated:
case EST_BasicNoexcept:
case EST_DynamicNone:
case EST_MSAny:
case EST_None:
  break;

case EST_ComputedNoexcept:
  if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
    return true;
  LLVM_FALLTHROUGH[[clang::fallthrough]];

case EST_Dynamic:
  for (const auto &E : Proto->exceptions()) {
    if (!Finder.TraverseType(E))
      return true;
  }
  break;
}

return false;
14937}

14939bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) {
FindCXXThisExpr Finder(*this);

// Check attributes.
for (const auto *A : Method->attrs()) {
  // FIXME: This should be emitted by tblgen.
  Expr *Arg = nullptr;
  ArrayRef<Expr *> Args;
  if (const auto *G = dyn_cast<GuardedByAttr>(A))
    Arg = G->getArg();
  else if (const auto *G = dyn_cast<PtGuardedByAttr>(A))
    Arg = G->getArg();
  else if (const auto *AA = dyn_cast<AcquiredAfterAttr>(A))
    Args = llvm::makeArrayRef(AA->args_begin(), AA->args_size());
  else if (const auto *AB = dyn_cast<AcquiredBeforeAttr>(A))
    Args = llvm::makeArrayRef(AB->args_begin(), AB->args_size());
  else if (const auto *ETLF = dyn_cast<ExclusiveTrylockFunctionAttr>(A)) {
    Arg = ETLF->getSuccessValue();
    Args = llvm::makeArrayRef(ETLF->args_begin(), ETLF->args_size());
  } else if (const auto *STLF = dyn_cast<SharedTrylockFunctionAttr>(A)) {
    Arg = STLF->getSuccessValue();
    Args = llvm::makeArrayRef(STLF->args_begin(), STLF->args_size());
  } else if (const auto *LR = dyn_cast<LockReturnedAttr>(A))
    Arg = LR->getArg();
  else if (const auto *LE = dyn_cast<LocksExcludedAttr>(A))
    Args = llvm::makeArrayRef(LE->args_begin(), LE->args_size());
  else if (const auto *RC = dyn_cast<RequiresCapabilityAttr>(A))
    Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());
  else if (const auto *AC = dyn_cast<AcquireCapabilityAttr>(A))
    Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
  else if (const auto *AC = dyn_cast<TryAcquireCapabilityAttr>(A))
    Args = llvm::makeArrayRef(AC->args_begin(), AC->args_size());
  else if (const auto *RC = dyn_cast<ReleaseCapabilityAttr>(A))
    Args = llvm::makeArrayRef(RC->args_begin(), RC->args_size());

  if (Arg && !Finder.TraverseStmt(Arg))
    return true;

  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
    if (!Finder.TraverseStmt(Args[I]))
      return true;
  }
}

return false;
14984}

14986void Sema::checkExceptionSpecification(
  bool IsTopLevel, ExceptionSpecificationType EST,
  ArrayRef<ParsedType> DynamicExceptions,
  ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr,
  SmallVectorImpl<QualType> &Exceptions,
  FunctionProtoType::ExceptionSpecInfo &ESI) {
Exceptions.clear();
ESI.Type = EST;
if (EST == EST_Dynamic) {
  Exceptions.reserve(DynamicExceptions.size());
  for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
    // FIXME: Preserve type source info.
    QualType ET = GetTypeFromParser(DynamicExceptions[ei]);

    if (IsTopLevel) {
      SmallVector<UnexpandedParameterPack, 2> Unexpanded;
      collectUnexpandedParameterPacks(ET, Unexpanded);
      if (!Unexpanded.empty()) {
        DiagnoseUnexpandedParameterPacks(
            DynamicExceptionRanges[ei].getBegin(), UPPC_ExceptionType,
            Unexpanded);
        continue;
      }
    }

    // Check that the type is valid for an exception spec, and
    // drop it if not.
    if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
      Exceptions.push_back(ET);
  }
  ESI.Exceptions = Exceptions;
  return;
}

if (EST == EST_ComputedNoexcept) {
  // If an error occurred, there's no expression here.
  if (NoexceptExpr) {
    assert((NoexceptExpr->isTypeDependent() ||(static_cast <bool> ((NoexceptExpr->isTypeDependent(
) || NoexceptExpr->getType()->getCanonicalTypeUnqualified
() == Context.BoolTy) && "Parser should have made sure that the expression is boolean"
) ? void (0) : __assert_fail ("(NoexceptExpr->isTypeDependent() || NoexceptExpr->getType()->getCanonicalTypeUnqualified() == Context.BoolTy) && \"Parser should have made sure that the expression is boolean\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 15026, __extension__ __PRETTY_FUNCTION__))
            NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==(static_cast <bool> ((NoexceptExpr->isTypeDependent(
) || NoexceptExpr->getType()->getCanonicalTypeUnqualified
() == Context.BoolTy) && "Parser should have made sure that the expression is boolean"
) ? void (0) : __assert_fail ("(NoexceptExpr->isTypeDependent() || NoexceptExpr->getType()->getCanonicalTypeUnqualified() == Context.BoolTy) && \"Parser should have made sure that the expression is boolean\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 15026, __extension__ __PRETTY_FUNCTION__))
            Context.BoolTy) &&(static_cast <bool> ((NoexceptExpr->isTypeDependent(
) || NoexceptExpr->getType()->getCanonicalTypeUnqualified
() == Context.BoolTy) && "Parser should have made sure that the expression is boolean"
) ? void (0) : __assert_fail ("(NoexceptExpr->isTypeDependent() || NoexceptExpr->getType()->getCanonicalTypeUnqualified() == Context.BoolTy) && \"Parser should have made sure that the expression is boolean\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 15026, __extension__ __PRETTY_FUNCTION__))
           "Parser should have made sure that the expression is boolean")(static_cast <bool> ((NoexceptExpr->isTypeDependent(
) || NoexceptExpr->getType()->getCanonicalTypeUnqualified
() == Context.BoolTy) && "Parser should have made sure that the expression is boolean"
) ? void (0) : __assert_fail ("(NoexceptExpr->isTypeDependent() || NoexceptExpr->getType()->getCanonicalTypeUnqualified() == Context.BoolTy) && \"Parser should have made sure that the expression is boolean\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 15026, __extension__ __PRETTY_FUNCTION__));
    if (IsTopLevel && NoexceptExpr &&
        DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
      ESI.Type = EST_BasicNoexcept;
      return;
    }

    if (!NoexceptExpr->isValueDependent()) {
      ExprResult Result = VerifyIntegerConstantExpression(
          NoexceptExpr, nullptr, diag::err_noexcept_needs_constant_expression,
          /*AllowFold*/ false);
      if (Result.isInvalid()) {
        ESI.Type = EST_BasicNoexcept;
        return;
      }
      NoexceptExpr = Result.get();
    }
    ESI.NoexceptExpr = NoexceptExpr;
  }
  return;
}
15047}

15049void Sema::actOnDelayedExceptionSpecification(Decl *MethodD,
           ExceptionSpecificationType EST,
           SourceRange SpecificationRange,
           ArrayRef<ParsedType> DynamicExceptions,
           ArrayRef<SourceRange> DynamicExceptionRanges,
           Expr *NoexceptExpr) {
if (!MethodD)
  return;

// Dig out the method we're referring to.
if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(MethodD))
  MethodD = FunTmpl->getTemplatedDecl();

CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(MethodD);
if (!Method)
  return;

// Check the exception specification.
llvm::SmallVector<QualType, 4> Exceptions;
FunctionProtoType::ExceptionSpecInfo ESI;
checkExceptionSpecification(/*IsTopLevel*/true, EST, DynamicExceptions,
                            DynamicExceptionRanges, NoexceptExpr, Exceptions,
                            ESI);

// Update the exception specification on the function type.
Context.adjustExceptionSpec(Method, ESI, /*AsWritten*/true);

if (Method->isStatic())
  checkThisInStaticMemberFunctionExceptionSpec(Method);

if (Method->isVirtual()) {
  // Check overrides, which we previously had to delay.
  for (const CXXMethodDecl *O : Method->overridden_methods())
    CheckOverridingFunctionExceptionSpec(Method, O);
}
15084}

15086/// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.
15087///
15088MSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record,
                                     SourceLocation DeclStart,
                                     Declarator &D, Expr *BitWidth,
                                     InClassInitStyle InitStyle,
                                     AccessSpecifier AS,
                                     AttributeList *MSPropertyAttr) {
IdentifierInfo *II = D.getIdentifier();
if (!II) {
  Diag(DeclStart, diag::err_anonymous_property);
  return nullptr;
}
SourceLocation Loc = D.getIdentifierLoc();

TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType T = TInfo->getType();
if (getLangOpts().CPlusPlus) {
  CheckExtraCXXDefaultArguments(D);

  if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
                                      UPPC_DataMemberType)) {
    D.setInvalidType();
    T = Context.IntTy;
    TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
  }
}

DiagnoseFunctionSpecifiers(D.getDeclSpec());

if (D.getDeclSpec().isInlineSpecified())
  Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
      << getLangOpts().CPlusPlus17;
if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
  Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
       diag::err_invalid_thread)
    << DeclSpec::getSpecifierName(TSCS);

// Check to see if this name was declared as a member previously
NamedDecl *PrevDecl = nullptr;
LookupResult Previous(*this, II, Loc, LookupMemberName,
                      ForVisibleRedeclaration);
LookupName(Previous, S);
switch (Previous.getResultKind()) {
case LookupResult::Found:
case LookupResult::FoundUnresolvedValue:
  PrevDecl = Previous.getAsSingle<NamedDecl>();
  break;

case LookupResult::FoundOverloaded:
  PrevDecl = Previous.getRepresentativeDecl();
  break;

case LookupResult::NotFound:
case LookupResult::NotFoundInCurrentInstantiation:
case LookupResult::Ambiguous:
  break;
}

if (PrevDecl && PrevDecl->isTemplateParameter()) {
  // Maybe we will complain about the shadowed template parameter.
  DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
  // Just pretend that we didn't see the previous declaration.
  PrevDecl = nullptr;
}

if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
  PrevDecl = nullptr;

SourceLocation TSSL = D.getLocStart();
const AttributeList::PropertyData &Data = MSPropertyAttr->getPropertyData();
MSPropertyDecl *NewPD = MSPropertyDecl::Create(
    Context, Record, Loc, II, T, TInfo, TSSL, Data.GetterId, Data.SetterId);
ProcessDeclAttributes(TUScope, NewPD, D);
NewPD->setAccess(AS);

if (NewPD->isInvalidDecl())
  Record->setInvalidDecl();

if (D.getDeclSpec().isModulePrivateSpecified())
  NewPD->setModulePrivate();

if (NewPD->isInvalidDecl() && PrevDecl) {
  // Don't introduce NewFD into scope; there's already something
  // with the same name in the same scope.
} else if (II) {
  PushOnScopeChains(NewPD, S);
} else
  Record->addDecl(NewPD);

return NewPD;
15177}

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h

→

1//===- DeclCXX.h - Classes for representing C++ declarations --*- C++ -*-=====//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10/// \file
11/// \brief Defines the C++ Decl subclasses, other than those for templates
12/// (found in DeclTemplate.h) and friends (in DeclFriend.h).
13//
14//===----------------------------------------------------------------------===//

16#ifndef LLVM_CLANG_AST_DECLCXX_H
17#define LLVM_CLANG_AST_DECLCXX_H

19#include "clang/AST/ASTContext.h"
20#include "clang/AST/ASTUnresolvedSet.h"
21#include "clang/AST/Attr.h"
22#include "clang/AST/Decl.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/ExternalASTSource.h"
26#include "clang/AST/LambdaCapture.h"
27#include "clang/AST/NestedNameSpecifier.h"
28#include "clang/AST/Redeclarable.h"
29#include "clang/AST/Stmt.h"
30#include "clang/AST/Type.h"
31#include "clang/AST/TypeLoc.h"
32#include "clang/AST/UnresolvedSet.h"
33#include "clang/Basic/LLVM.h"
34#include "clang/Basic/Lambda.h"
35#include "clang/Basic/LangOptions.h"
36#include "clang/Basic/OperatorKinds.h"
37#include "clang/Basic/SourceLocation.h"
38#include "clang/Basic/Specifiers.h"
39#include "llvm/ADT/ArrayRef.h"
40#include "llvm/ADT/DenseMap.h"
41#include "llvm/ADT/PointerIntPair.h"
42#include "llvm/ADT/PointerUnion.h"
43#include "llvm/ADT/STLExtras.h"
44#include "llvm/ADT/iterator_range.h"
45#include "llvm/Support/Casting.h"
46#include "llvm/Support/Compiler.h"
47#include "llvm/Support/PointerLikeTypeTraits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include <cassert>
50#include <cstddef>
51#include <iterator>
52#include <memory>
53#include <vector>

55namespace clang {

57class ClassTemplateDecl;
58class ConstructorUsingShadowDecl;
59class CXXBasePath;
60class CXXBasePaths;
61class CXXConstructorDecl;
62class CXXDestructorDecl;
63class CXXFinalOverriderMap;
64class CXXIndirectPrimaryBaseSet;
65class CXXMethodDecl;
66class DiagnosticBuilder;
67class FriendDecl;
68class FunctionTemplateDecl;
69class IdentifierInfo;
70class MemberSpecializationInfo;
71class TemplateDecl;
72class TemplateParameterList;
73class UsingDecl;

75/// \brief Represents any kind of function declaration, whether it is a
76/// concrete function or a function template.
77class AnyFunctionDecl {
NamedDecl *Function;

AnyFunctionDecl(NamedDecl *ND) : Function(ND) {}

82public:
AnyFunctionDecl(FunctionDecl *FD) : Function(FD) {}
AnyFunctionDecl(FunctionTemplateDecl *FTD);

/// \brief Implicily converts any function or function template into a
/// named declaration.
operator NamedDecl *() const { return Function; }

/// \brief Retrieve the underlying function or function template.
NamedDecl *get() const { return Function; }

static AnyFunctionDecl getFromNamedDecl(NamedDecl *ND) {
  return AnyFunctionDecl(ND);
}
96};

98} // namespace clang

100namespace llvm {

// Provide PointerLikeTypeTraits for non-cvr pointers.
template<>
struct PointerLikeTypeTraits< ::clang::AnyFunctionDecl> {
  static void *getAsVoidPointer(::clang::AnyFunctionDecl F) {
    return F.get();
  }

  static ::clang::AnyFunctionDecl getFromVoidPointer(void *P) {
    return ::clang::AnyFunctionDecl::getFromNamedDecl(
                                    static_cast< ::clang::NamedDecl*>(P));
  }

  enum { NumLowBitsAvailable = 2 };
};

117} // namespace llvm

119namespace clang {

121/// \brief Represents an access specifier followed by colon ':'.
122///
123/// An objects of this class represents sugar for the syntactic occurrence
124/// of an access specifier followed by a colon in the list of member
125/// specifiers of a C++ class definition.
126///
127/// Note that they do not represent other uses of access specifiers,
128/// such as those occurring in a list of base specifiers.
129/// Also note that this class has nothing to do with so-called
130/// "access declarations" (C++98 11.3 [class.access.dcl]).
131class AccessSpecDecl : public Decl {
/// \brief The location of the ':'.
SourceLocation ColonLoc;

AccessSpecDecl(AccessSpecifier AS, DeclContext *DC,
               SourceLocation ASLoc, SourceLocation ColonLoc)
  : Decl(AccessSpec, DC, ASLoc), ColonLoc(ColonLoc) {
  setAccess(AS);
}

AccessSpecDecl(EmptyShell Empty) : Decl(AccessSpec, Empty) {}

virtual void anchor();

145public:
/// \brief The location of the access specifier.
SourceLocation getAccessSpecifierLoc() const { return getLocation(); }

/// \brief Sets the location of the access specifier.
void setAccessSpecifierLoc(SourceLocation ASLoc) { setLocation(ASLoc); }

/// \brief The location of the colon following the access specifier.
SourceLocation getColonLoc() const { return ColonLoc; }

/// \brief Sets the location of the colon.
void setColonLoc(SourceLocation CLoc) { ColonLoc = CLoc; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getAccessSpecifierLoc(), getColonLoc());
}

static AccessSpecDecl *Create(ASTContext &C, AccessSpecifier AS,
                              DeclContext *DC, SourceLocation ASLoc,
                              SourceLocation ColonLoc) {
  return new (C, DC) AccessSpecDecl(AS, DC, ASLoc, ColonLoc);
}

static AccessSpecDecl *CreateDeserialized(ASTContext &C, unsigned ID);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == AccessSpec; }
173};

175/// \brief Represents a base class of a C++ class.
176///
177/// Each CXXBaseSpecifier represents a single, direct base class (or
178/// struct) of a C++ class (or struct). It specifies the type of that
179/// base class, whether it is a virtual or non-virtual base, and what
180/// level of access (public, protected, private) is used for the
181/// derivation. For example:
182///
183/// \code
184///   class A { };
185///   class B { };
186///   class C : public virtual A, protected B { };
187/// \endcode
188///
189/// In this code, C will have two CXXBaseSpecifiers, one for "public
190/// virtual A" and the other for "protected B".
191class CXXBaseSpecifier {
/// \brief The source code range that covers the full base
/// specifier, including the "virtual" (if present) and access
/// specifier (if present).
SourceRange Range;

/// \brief The source location of the ellipsis, if this is a pack
/// expansion.
SourceLocation EllipsisLoc;

/// \brief Whether this is a virtual base class or not.
unsigned Virtual : 1;

/// \brief Whether this is the base of a class (true) or of a struct (false).
///
/// This determines the mapping from the access specifier as written in the
/// source code to the access specifier used for semantic analysis.
unsigned BaseOfClass : 1;

/// \brief Access specifier as written in the source code (may be AS_none).
///
/// The actual type of data stored here is an AccessSpecifier, but we use
/// "unsigned" here to work around a VC++ bug.
unsigned Access : 2;

/// \brief Whether the class contains a using declaration
/// to inherit the named class's constructors.
unsigned InheritConstructors : 1;

/// \brief The type of the base class.
///
/// This will be a class or struct (or a typedef of such). The source code
/// range does not include the \c virtual or the access specifier.
TypeSourceInfo *BaseTypeInfo;

226public:
CXXBaseSpecifier() = default;
CXXBaseSpecifier(SourceRange R, bool V, bool BC, AccessSpecifier A,
                 TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
  : Range(R), EllipsisLoc(EllipsisLoc), Virtual(V), BaseOfClass(BC),
    Access(A), InheritConstructors(false), BaseTypeInfo(TInfo) {}

/// \brief Retrieves the source range that contains the entire base specifier.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }

/// \brief Get the location at which the base class type was written.
SourceLocation getBaseTypeLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return BaseTypeInfo->getTypeLoc().getLocStart();
}

/// \brief Determines whether the base class is a virtual base class (or not).
bool isVirtual() const { return Virtual; }

/// \brief Determine whether this base class is a base of a class declared
/// with the 'class' keyword (vs. one declared with the 'struct' keyword).
bool isBaseOfClass() const { return BaseOfClass; }

/// \brief Determine whether this base specifier is a pack expansion.
bool isPackExpansion() const { return EllipsisLoc.isValid(); }

/// \brief Determine whether this base class's constructors get inherited.
bool getInheritConstructors() const { return InheritConstructors; }

/// \brief Set that this base class's constructors should be inherited.
void setInheritConstructors(bool Inherit = true) {
  InheritConstructors = Inherit;
}

/// \brief For a pack expansion, determine the location of the ellipsis.
SourceLocation getEllipsisLoc() const {
  return EllipsisLoc;
}

/// \brief Returns the access specifier for this base specifier. 
///
/// This is the actual base specifier as used for semantic analysis, so
/// the result can never be AS_none. To retrieve the access specifier as
/// written in the source code, use getAccessSpecifierAsWritten().
AccessSpecifier getAccessSpecifier() const {
  if ((AccessSpecifier)Access == AS_none)
    return BaseOfClass? AS_private : AS_public;
  else
    return (AccessSpecifier)Access;
}

/// \brief Retrieves the access specifier as written in the source code
/// (which may mean that no access specifier was explicitly written).
///
/// Use getAccessSpecifier() to retrieve the access specifier for use in
/// semantic analysis.
AccessSpecifier getAccessSpecifierAsWritten() const {
  return (AccessSpecifier)Access;
}

/// \brief Retrieves the type of the base class.
///
/// This type will always be an unqualified class type.
QualType getType() const {
  return BaseTypeInfo->getType().getUnqualifiedType();
207
←
Calling 'TypeSourceInfo::getType'→
208
←
Returning from 'TypeSourceInfo::getType'→
209
←
Calling 'QualType::getUnqualifiedType'→
293
←
Returning from 'QualType::getUnqualifiedType'→
536
←
Calling 'TypeSourceInfo::getType'→
537
←
Returning from 'TypeSourceInfo::getType'→
538
←
Calling 'QualType::getUnqualifiedType'→
621
←
Returning from 'QualType::getUnqualifiedType'→
}

/// \brief Retrieves the type and source location of the base class.
TypeSourceInfo *getTypeSourceInfo() const { return BaseTypeInfo; }
296};

298/// \brief Represents a C++ struct/union/class.
299class CXXRecordDecl : public RecordDecl {
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend class ASTNodeImporter;
friend class ASTReader;
friend class ASTRecordWriter;
friend class ASTWriter;
friend class DeclContext;
friend class LambdaExpr;

friend void FunctionDecl::setPure(bool);
friend void TagDecl::startDefinition();

/// Values used in DefinitionData fields to represent special members.
enum SpecialMemberFlags {
  SMF_DefaultConstructor = 0x1,
  SMF_CopyConstructor = 0x2,
  SMF_MoveConstructor = 0x4,
  SMF_CopyAssignment = 0x8,
  SMF_MoveAssignment = 0x10,
  SMF_Destructor = 0x20,
  SMF_All = 0x3f
};

struct DefinitionData {
  /// \brief True if this class has any user-declared constructors.
  unsigned UserDeclaredConstructor : 1;

  /// \brief The user-declared special members which this class has.
  unsigned UserDeclaredSpecialMembers : 6;

  /// \brief True when this class is an aggregate.
  unsigned Aggregate : 1;

  /// \brief True when this class is a POD-type.
  unsigned PlainOldData : 1;

  /// true when this class is empty for traits purposes,
  /// i.e. has no data members other than 0-width bit-fields, has no
  /// virtual function/base, and doesn't inherit from a non-empty
  /// class. Doesn't take union-ness into account.
  unsigned Empty : 1;

  /// \brief True when this class is polymorphic, i.e., has at
  /// least one virtual member or derives from a polymorphic class.
  unsigned Polymorphic : 1;

  /// \brief True when this class is abstract, i.e., has at least
  /// one pure virtual function, (that can come from a base class).
  unsigned Abstract : 1;

  /// \brief True when this class has standard layout.
  ///
  /// C++11 [class]p7.  A standard-layout class is a class that:
  /// * has no non-static data members of type non-standard-layout class (or
  ///   array of such types) or reference,
  /// * has no virtual functions (10.3) and no virtual base classes (10.1),
  /// * has the same access control (Clause 11) for all non-static data
  ///   members
  /// * has no non-standard-layout base classes,
  /// * either has no non-static data members in the most derived class and at
  ///   most one base class with non-static data members, or has no base
  ///   classes with non-static data members, and
  /// * has no base classes of the same type as the first non-static data
  ///   member.
  unsigned IsStandardLayout : 1;

  /// \brief True when there are no non-empty base classes.
  ///
  /// This is a helper bit of state used to implement IsStandardLayout more
  /// efficiently.
  unsigned HasNoNonEmptyBases : 1;

  /// \brief True when there are private non-static data members.
  unsigned HasPrivateFields : 1;

  /// \brief True when there are protected non-static data members.
  unsigned HasProtectedFields : 1;

  /// \brief True when there are private non-static data members.
  unsigned HasPublicFields : 1;

  /// \brief True if this class (or any subobject) has mutable fields.
  unsigned HasMutableFields : 1;

  /// \brief True if this class (or any nested anonymous struct or union)
  /// has variant members.
  unsigned HasVariantMembers : 1;

  /// \brief True if there no non-field members declared by the user.
  unsigned HasOnlyCMembers : 1;

  /// \brief True if any field has an in-class initializer, including those
  /// within anonymous unions or structs.
  unsigned HasInClassInitializer : 1;

  /// \brief True if any field is of reference type, and does not have an
  /// in-class initializer.
  ///
  /// In this case, value-initialization of this class is illegal in C++98
  /// even if the class has a trivial default constructor.
  unsigned HasUninitializedReferenceMember : 1;

  /// \brief True if any non-mutable field whose type doesn't have a user-
  /// provided default ctor also doesn't have an in-class initializer.
  unsigned HasUninitializedFields : 1;

  /// \brief True if there are any member using-declarations that inherit
  /// constructors from a base class.
  unsigned HasInheritedConstructor : 1;

  /// \brief True if there are any member using-declarations named
  /// 'operator='.
  unsigned HasInheritedAssignment : 1;

  /// \brief These flags are \c true if a defaulted corresponding special
  /// member can't be fully analyzed without performing overload resolution.
  /// @{
  unsigned NeedOverloadResolutionForCopyConstructor : 1;
  unsigned NeedOverloadResolutionForMoveConstructor : 1;
  unsigned NeedOverloadResolutionForMoveAssignment : 1;
  unsigned NeedOverloadResolutionForDestructor : 1;
  /// @}

  /// \brief These flags are \c true if an implicit defaulted corresponding
  /// special member would be defined as deleted.
  /// @{
  unsigned DefaultedCopyConstructorIsDeleted : 1;
  unsigned DefaultedMoveConstructorIsDeleted : 1;
  unsigned DefaultedMoveAssignmentIsDeleted : 1;
  unsigned DefaultedDestructorIsDeleted : 1;
  /// @}

  /// \brief The trivial special members which this class has, per
  /// C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25,
  /// C++11 [class.dtor]p5, or would have if the member were not suppressed.
  ///
  /// This excludes any user-declared but not user-provided special members
  /// which have been declared but not yet defined.
  unsigned HasTrivialSpecialMembers : 6;

  /// These bits keep track of the triviality of special functions for the
  /// purpose of calls. Only the bits corresponding to SMF_CopyConstructor,
  /// SMF_MoveConstructor, and SMF_Destructor are meaningful here.
  unsigned HasTrivialSpecialMembersForCall : 6;

  /// \brief The declared special members of this class which are known to be
  /// non-trivial.
  ///
  /// This excludes any user-declared but not user-provided special members
  /// which have been declared but not yet defined, and any implicit special
  /// members which have not yet been declared.
  unsigned DeclaredNonTrivialSpecialMembers : 6;

  /// These bits keep track of the declared special members that are
  /// non-trivial for the purpose of calls.
  /// Only the bits corresponding to SMF_CopyConstructor,
  /// SMF_MoveConstructor, and SMF_Destructor are meaningful here.
  unsigned DeclaredNonTrivialSpecialMembersForCall : 6;

  /// \brief True when this class has a destructor with no semantic effect.
  unsigned HasIrrelevantDestructor : 1;

  /// \brief True when this class has at least one user-declared constexpr
  /// constructor which is neither the copy nor move constructor.
  unsigned HasConstexprNonCopyMoveConstructor : 1;

  /// \brief True if this class has a (possibly implicit) defaulted default
  /// constructor.
  unsigned HasDefaultedDefaultConstructor : 1;

  /// \brief True if this class can be passed in a non-address-preserving
  /// fashion (such as in registers) according to the C++ language rules.
  /// This does not imply anything about how the ABI in use will actually
  /// pass an object of this class.
  unsigned CanPassInRegisters : 1;

  /// \brief True if a defaulted default constructor for this class would
  /// be constexpr.
  unsigned DefaultedDefaultConstructorIsConstexpr : 1;

  /// \brief True if this class has a constexpr default constructor.
  ///
  /// This is true for either a user-declared constexpr default constructor
  /// or an implicitly declared constexpr default constructor.
  unsigned HasConstexprDefaultConstructor : 1;

  /// \brief True when this class contains at least one non-static data
  /// member or base class of non-literal or volatile type.
  unsigned HasNonLiteralTypeFieldsOrBases : 1;

  /// \brief True when visible conversion functions are already computed
  /// and are available.
  unsigned ComputedVisibleConversions : 1;

  /// \brief Whether we have a C++11 user-provided default constructor (not
  /// explicitly deleted or defaulted).
  unsigned UserProvidedDefaultConstructor : 1;

  /// \brief The special members which have been declared for this class,
  /// either by the user or implicitly.
  unsigned DeclaredSpecialMembers : 6;

  /// \brief Whether an implicit copy constructor could have a const-qualified
  /// parameter, for initializing virtual bases and for other subobjects.
  unsigned ImplicitCopyConstructorCanHaveConstParamForVBase : 1;
  unsigned ImplicitCopyConstructorCanHaveConstParamForNonVBase : 1;

  /// \brief Whether an implicit copy assignment operator would have a
  /// const-qualified parameter.
  unsigned ImplicitCopyAssignmentHasConstParam : 1;

  /// \brief Whether any declared copy constructor has a const-qualified
  /// parameter.
  unsigned HasDeclaredCopyConstructorWithConstParam : 1;

  /// \brief Whether any declared copy assignment operator has either a
  /// const-qualified reference parameter or a non-reference parameter.
  unsigned HasDeclaredCopyAssignmentWithConstParam : 1;

  /// \brief Whether this class describes a C++ lambda.
  unsigned IsLambda : 1;

  /// \brief Whether we are currently parsing base specifiers.
  unsigned IsParsingBaseSpecifiers : 1;

  unsigned HasODRHash : 1;

  /// \brief A hash of parts of the class to help in ODR checking.
  unsigned ODRHash = 0;

  /// \brief The number of base class specifiers in Bases.
  unsigned NumBases = 0;

  /// \brief The number of virtual base class specifiers in VBases.
  unsigned NumVBases = 0;

  /// \brief Base classes of this class.
  ///
  /// FIXME: This is wasted space for a union.
  LazyCXXBaseSpecifiersPtr Bases;

  /// \brief direct and indirect virtual base classes of this class.
  LazyCXXBaseSpecifiersPtr VBases;

  /// \brief The conversion functions of this C++ class (but not its
  /// inherited conversion functions).
  ///
  /// Each of the entries in this overload set is a CXXConversionDecl.
  LazyASTUnresolvedSet Conversions;

  /// \brief The conversion functions of this C++ class and all those
  /// inherited conversion functions that are visible in this class.
  ///
  /// Each of the entries in this overload set is a CXXConversionDecl or a
  /// FunctionTemplateDecl.
  LazyASTUnresolvedSet VisibleConversions;

  /// \brief The declaration which defines this record.
  CXXRecordDecl *Definition;

  /// \brief The first friend declaration in this class, or null if there
  /// aren't any. 
  ///
  /// This is actually currently stored in reverse order.
  LazyDeclPtr FirstFriend;

  DefinitionData(CXXRecordDecl *D);

  /// \brief Retrieve the set of direct base classes.
  CXXBaseSpecifier *getBases() const {
    if (!Bases.isOffset())
84
←
Calling 'LazyOffsetPtr::isOffset'→
85
←
Returning from 'LazyOffsetPtr::isOffset'→
86
←
Assuming the condition is false→
87
←
Taking false branch→
145
←
Calling 'LazyOffsetPtr::isOffset'→
146
←
Returning from 'LazyOffsetPtr::isOffset'→
147
←
Assuming the condition is false→
148
←
Taking false branch→
      return Bases.get(nullptr);
    return getBasesSlowCase();
  }

  /// \brief Retrieve the set of virtual base classes.
  CXXBaseSpecifier *getVBases() const {
    if (!VBases.isOffset())
      return VBases.get(nullptr);
    return getVBasesSlowCase();
  }

  ArrayRef<CXXBaseSpecifier> bases() const {
    return llvm::makeArrayRef(getBases(), NumBases);
  }

  ArrayRef<CXXBaseSpecifier> vbases() const {
    return llvm::makeArrayRef(getVBases(), NumVBases);
  }

private:
  CXXBaseSpecifier *getBasesSlowCase() const;
  CXXBaseSpecifier *getVBasesSlowCase() const;
};

struct DefinitionData *DefinitionData;

/// \brief Describes a C++ closure type (generated by a lambda expression).
struct LambdaDefinitionData : public DefinitionData {
  using Capture = LambdaCapture;

  /// \brief Whether this lambda is known to be dependent, even if its
  /// context isn't dependent.
  /// 
  /// A lambda with a non-dependent context can be dependent if it occurs
  /// within the default argument of a function template, because the
  /// lambda will have been created with the enclosing context as its
  /// declaration context, rather than function. This is an unfortunate
  /// artifact of having to parse the default arguments before. 
  unsigned Dependent : 1;
  
  /// \brief Whether this lambda is a generic lambda.
  unsigned IsGenericLambda : 1;

  /// \brief The Default Capture.
  unsigned CaptureDefault : 2;

  /// \brief The number of captures in this lambda is limited 2^NumCaptures.
  unsigned NumCaptures : 15;

  /// \brief The number of explicit captures in this lambda.
  unsigned NumExplicitCaptures : 13;

  /// \brief The number used to indicate this lambda expression for name 
  /// mangling in the Itanium C++ ABI.
  unsigned ManglingNumber = 0;
  
  /// \brief The declaration that provides context for this lambda, if the
  /// actual DeclContext does not suffice. This is used for lambdas that
  /// occur within default arguments of function parameters within the class
  /// or within a data member initializer.
  LazyDeclPtr ContextDecl;
  
  /// \brief The list of captures, both explicit and implicit, for this 
  /// lambda.
  Capture *Captures = nullptr;

  /// \brief The type of the call method.
  TypeSourceInfo *MethodTyInfo;

  LambdaDefinitionData(CXXRecordDecl *D, TypeSourceInfo *Info, 
                       bool Dependent, bool IsGeneric, 
                       LambdaCaptureDefault CaptureDefault) 
    : DefinitionData(D), Dependent(Dependent), IsGenericLambda(IsGeneric), 
      CaptureDefault(CaptureDefault), NumCaptures(0), NumExplicitCaptures(0), 
      MethodTyInfo(Info) {
    IsLambda = true;

    // C++1z [expr.prim.lambda]p4:
    //   This class type is not an aggregate type.
    Aggregate = false;
    PlainOldData = false;
  }
};

struct DefinitionData *dataPtr() const {
  // Complete the redecl chain (if necessary).
  getMostRecentDecl();
32
←
Calling 'CXXRecordDecl::getMostRecentDecl'→
79
←
Returning from 'CXXRecordDecl::getMostRecentDecl'→
94
←
Calling 'CXXRecordDecl::getMostRecentDecl'→
140
←
Returning from 'CXXRecordDecl::getMostRecentDecl'→
153
←
Calling 'CXXRecordDecl::getMostRecentDecl'→
199
←
Returning from 'CXXRecordDecl::getMostRecentDecl'→
  return DefinitionData;
}

struct DefinitionData &data() const {
  auto *DD = dataPtr();
31
←
Calling 'CXXRecordDecl::dataPtr'→
80
←
Returning from 'CXXRecordDecl::dataPtr'→
93
←
Calling 'CXXRecordDecl::dataPtr'→
141
←
Returning from 'CXXRecordDecl::dataPtr'→
152
←
Calling 'CXXRecordDecl::dataPtr'→
200
←
Returning from 'CXXRecordDecl::dataPtr'→
  assert(DD && "queried property of class with no definition")(static_cast <bool> (DD && "queried property of class with no definition"
) ? void (0) : __assert_fail ("DD && \"queried property of class with no definition\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 663, __extension__ __PRETTY_FUNCTION__));
81
←
Within the expansion of the macro 'assert':
→
a
Assuming 'DD' is non-null
142
←
Within the expansion of the macro 'assert':
→
201
←
Within the expansion of the macro 'assert':
→
  return *DD;
}

struct LambdaDefinitionData &getLambdaData() const {
  // No update required: a merged definition cannot change any lambda
  // properties.
  auto *DD = DefinitionData;
  assert(DD && DD->IsLambda && "queried lambda property of non-lambda class")(static_cast <bool> (DD && DD->IsLambda &&
 "queried lambda property of non-lambda class") ? void (0) : __assert_fail
 ("DD && DD->IsLambda && \"queried lambda property of non-lambda class\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 671, __extension__ __PRETTY_FUNCTION__));
  return static_cast<LambdaDefinitionData&>(*DD);
}

/// \brief The template or declaration that this declaration
/// describes or was instantiated from, respectively.
///
/// For non-templates, this value will be null. For record
/// declarations that describe a class template, this will be a
/// pointer to a ClassTemplateDecl. For member
/// classes of class template specializations, this will be the
/// MemberSpecializationInfo referring to the member class that was
/// instantiated or specialized.
llvm::PointerUnion<ClassTemplateDecl *, MemberSpecializationInfo *>
    TemplateOrInstantiation;

/// \brief Called from setBases and addedMember to notify the class that a
/// direct or virtual base class or a member of class type has been added.
void addedClassSubobject(CXXRecordDecl *Base);

/// \brief Notify the class that member has been added.
///
/// This routine helps maintain information about the class based on which
/// members have been added. It will be invoked by DeclContext::addDecl()
/// whenever a member is added to this record.
void addedMember(Decl *D);

void markedVirtualFunctionPure();

/// \brief Get the head of our list of friend declarations, possibly
/// deserializing the friends from an external AST source.
FriendDecl *getFirstFriend() const;

704protected:
CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C, DeclContext *DC,
              SourceLocation StartLoc, SourceLocation IdLoc,
              IdentifierInfo *Id, CXXRecordDecl *PrevDecl);

709public:
/// \brief Iterator that traverses the base classes of a class.
using base_class_iterator = CXXBaseSpecifier *;

/// \brief Iterator that traverses the base classes of a class.
using base_class_const_iterator = const CXXBaseSpecifier *;

CXXRecordDecl *getCanonicalDecl() override {
  return cast<CXXRecordDecl>(RecordDecl::getCanonicalDecl());
}

const CXXRecordDecl *getCanonicalDecl() const {
  return const_cast<CXXRecordDecl*>(this)->getCanonicalDecl();
}

CXXRecordDecl *getPreviousDecl() {
  return cast_or_null<CXXRecordDecl>(
          static_cast<RecordDecl *>(this)->getPreviousDecl());
}

const CXXRecordDecl *getPreviousDecl() const {
  return const_cast<CXXRecordDecl*>(this)->getPreviousDecl();
}

CXXRecordDecl *getMostRecentDecl() {
  return cast<CXXRecordDecl>(
65
←
Calling 'cast'→
77
←
Returning from 'cast'→
126
←
Calling 'cast'→
138
←
Returning from 'cast'→
185
←
Calling 'cast'→
197
←
Returning from 'cast'→
          static_cast<RecordDecl *>(this)->getMostRecentDecl());
34
←
Calling 'RecordDecl::getMostRecentDecl'→
64
←
Returning from 'RecordDecl::getMostRecentDecl'→
96
←
Calling 'RecordDecl::getMostRecentDecl'→
125
←
Returning from 'RecordDecl::getMostRecentDecl'→
155
←
Calling 'RecordDecl::getMostRecentDecl'→
184
←
Returning from 'RecordDecl::getMostRecentDecl'→
}

const CXXRecordDecl *getMostRecentDecl() const {
  return const_cast<CXXRecordDecl*>(this)->getMostRecentDecl();
33
←
Calling 'CXXRecordDecl::getMostRecentDecl'→
78
←
Returning from 'CXXRecordDecl::getMostRecentDecl'→
95
←
Calling 'CXXRecordDecl::getMostRecentDecl'→
139
←
Returning from 'CXXRecordDecl::getMostRecentDecl'→
154
←
Calling 'CXXRecordDecl::getMostRecentDecl'→
198
←
Returning from 'CXXRecordDecl::getMostRecentDecl'→
}

CXXRecordDecl *getDefinition() const {
  // We only need an update if we don't already know which
  // declaration is the definition.
  auto *DD = DefinitionData ? DefinitionData : dataPtr();
  return DD ? DD->Definition : nullptr;
}

bool hasDefinition() const { return DefinitionData || dataPtr(); }

static CXXRecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
                             SourceLocation StartLoc, SourceLocation IdLoc,
                             IdentifierInfo *Id,
                             CXXRecordDecl *PrevDecl = nullptr,
                             bool DelayTypeCreation = false);
static CXXRecordDecl *CreateLambda(const ASTContext &C, DeclContext *DC,
                                   TypeSourceInfo *Info, SourceLocation Loc,
                                   bool DependentLambda, bool IsGeneric,
                                   LambdaCaptureDefault CaptureDefault);
static CXXRecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);

bool isDynamicClass() const {
  return data().Polymorphic || data().NumVBases != 0;
}

void setIsParsingBaseSpecifiers() { data().IsParsingBaseSpecifiers = true; }

bool isParsingBaseSpecifiers() const {
  return data().IsParsingBaseSpecifiers;
}

unsigned getODRHash() const;

/// \brief Sets the base classes of this struct or class.
void setBases(CXXBaseSpecifier const * const *Bases, unsigned NumBases);

/// \brief Retrieves the number of base classes of this class.
unsigned getNumBases() const { return data().NumBases; }

using base_class_range = llvm::iterator_range<base_class_iterator>;
using base_class_const_range =
    llvm::iterator_range<base_class_const_iterator>;

base_class_range bases() {
  return base_class_range(bases_begin(), bases_end());
29
←
Calling 'CXXRecordDecl::bases_begin'→
89
←
Returning from 'CXXRecordDecl::bases_begin'→
90
←
Calling 'CXXRecordDecl::bases_end'→
203
←
Returning from 'CXXRecordDecl::bases_end'→
}
base_class_const_range bases() const {
  return base_class_const_range(bases_begin(), bases_end());
}

base_class_iterator bases_begin() { return data().getBases(); }
30
←
Calling 'CXXRecordDecl::data'→
82
←
Returning from 'CXXRecordDecl::data'→
83
←
Calling 'DefinitionData::getBases'→
88
←
Returning from 'DefinitionData::getBases'→
92
←
Calling 'CXXRecordDecl::data'→
143
←
Returning from 'CXXRecordDecl::data'→
144
←
Calling 'DefinitionData::getBases'→
149
←
Returning from 'DefinitionData::getBases'→
base_class_const_iterator bases_begin() const { return data().getBases(); }
base_class_iterator bases_end() { return bases_begin() + data().NumBases; }
91
←
Calling 'CXXRecordDecl::bases_begin'→
150
←
Returning from 'CXXRecordDecl::bases_begin'→
151
←
Calling 'CXXRecordDecl::data'→
202
←
Returning from 'CXXRecordDecl::data'→
base_class_const_iterator bases_end() const {
  return bases_begin() + data().NumBases;
}

/// \brief Retrieves the number of virtual base classes of this class.
unsigned getNumVBases() const { return data().NumVBases; }

base_class_range vbases() {
  return base_class_range(vbases_begin(), vbases_end());
}
base_class_const_range vbases() const {
  return base_class_const_range(vbases_begin(), vbases_end());
}

base_class_iterator vbases_begin() { return data().getVBases(); }
base_class_const_iterator vbases_begin() const { return data().getVBases(); }
base_class_iterator vbases_end() { return vbases_begin() + data().NumVBases; }
base_class_const_iterator vbases_end() const {
  return vbases_begin() + data().NumVBases;
}

/// \brief Determine whether this class has any dependent base classes which
/// are not the current instantiation.
bool hasAnyDependentBases() const;

/// Iterator access to method members.  The method iterator visits
/// all method members of the class, including non-instance methods,
/// special methods, etc.
using method_iterator = specific_decl_iterator<CXXMethodDecl>;
using method_range =
    llvm::iterator_range<specific_decl_iterator<CXXMethodDecl>>;

method_range methods() const {
  return method_range(method_begin(), method_end());
}

/// \brief Method begin iterator.  Iterates in the order the methods
/// were declared.
method_iterator method_begin() const {
  return method_iterator(decls_begin());
}

/// \brief Method past-the-end iterator.
method_iterator method_end() const {
  return method_iterator(decls_end());
}

/// Iterator access to constructor members.
using ctor_iterator = specific_decl_iterator<CXXConstructorDecl>;
using ctor_range =
    llvm::iterator_range<specific_decl_iterator<CXXConstructorDecl>>;

ctor_range ctors() const { return ctor_range(ctor_begin(), ctor_end()); }

ctor_iterator ctor_begin() const {
  return ctor_iterator(decls_begin());
}

ctor_iterator ctor_end() const {
  return ctor_iterator(decls_end());
}

/// An iterator over friend declarations.  All of these are defined
/// in DeclFriend.h.
class friend_iterator;
using friend_range = llvm::iterator_range<friend_iterator>;

friend_range friends() const;
friend_iterator friend_begin() const;
friend_iterator friend_end() const;
void pushFriendDecl(FriendDecl *FD);

/// Determines whether this record has any friends.
bool hasFriends() const {
  return data().FirstFriend.isValid();
}

/// \brief \c true if a defaulted copy constructor for this class would be
/// deleted.
bool defaultedCopyConstructorIsDeleted() const {
  assert((!needsOverloadResolutionForCopyConstructor() ||(static_cast <bool> ((!needsOverloadResolutionForCopyConstructor
() || (data().DeclaredSpecialMembers & SMF_CopyConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForCopyConstructor() || (data().DeclaredSpecialMembers & SMF_CopyConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 876, __extension__ __PRETTY_FUNCTION__))
          (data().DeclaredSpecialMembers & SMF_CopyConstructor)) &&(static_cast <bool> ((!needsOverloadResolutionForCopyConstructor
() || (data().DeclaredSpecialMembers & SMF_CopyConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForCopyConstructor() || (data().DeclaredSpecialMembers & SMF_CopyConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 876, __extension__ __PRETTY_FUNCTION__))
         "this property has not yet been computed by Sema")(static_cast <bool> ((!needsOverloadResolutionForCopyConstructor
() || (data().DeclaredSpecialMembers & SMF_CopyConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForCopyConstructor() || (data().DeclaredSpecialMembers & SMF_CopyConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 876, __extension__ __PRETTY_FUNCTION__));
  return data().DefaultedCopyConstructorIsDeleted;
}

/// \brief \c true if a defaulted move constructor for this class would be
/// deleted.
bool defaultedMoveConstructorIsDeleted() const {
  assert((!needsOverloadResolutionForMoveConstructor() ||(static_cast <bool> ((!needsOverloadResolutionForMoveConstructor
() || (data().DeclaredSpecialMembers & SMF_MoveConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForMoveConstructor() || (data().DeclaredSpecialMembers & SMF_MoveConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 885, __extension__ __PRETTY_FUNCTION__))
          (data().DeclaredSpecialMembers & SMF_MoveConstructor)) &&(static_cast <bool> ((!needsOverloadResolutionForMoveConstructor
() || (data().DeclaredSpecialMembers & SMF_MoveConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForMoveConstructor() || (data().DeclaredSpecialMembers & SMF_MoveConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 885, __extension__ __PRETTY_FUNCTION__))
         "this property has not yet been computed by Sema")(static_cast <bool> ((!needsOverloadResolutionForMoveConstructor
() || (data().DeclaredSpecialMembers & SMF_MoveConstructor
)) && "this property has not yet been computed by Sema"
) ? void (0) : __assert_fail ("(!needsOverloadResolutionForMoveConstructor() || (data().DeclaredSpecialMembers & SMF_MoveConstructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 885, __extension__ __PRETTY_FUNCTION__));
  return data().DefaultedMoveConstructorIsDeleted;
}

/// \brief \c true if a defaulted destructor for this class would be deleted.
bool defaultedDestructorIsDeleted() const {
  assert((!needsOverloadResolutionForDestructor() ||(static_cast <bool> ((!needsOverloadResolutionForDestructor
() || (data().DeclaredSpecialMembers & SMF_Destructor)) &&
 "this property has not yet been computed by Sema") ? void (0
) : __assert_fail ("(!needsOverloadResolutionForDestructor() || (data().DeclaredSpecialMembers & SMF_Destructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 893, __extension__ __PRETTY_FUNCTION__))
          (data().DeclaredSpecialMembers & SMF_Destructor)) &&(static_cast <bool> ((!needsOverloadResolutionForDestructor
() || (data().DeclaredSpecialMembers & SMF_Destructor)) &&
 "this property has not yet been computed by Sema") ? void (0
) : __assert_fail ("(!needsOverloadResolutionForDestructor() || (data().DeclaredSpecialMembers & SMF_Destructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 893, __extension__ __PRETTY_FUNCTION__))
         "this property has not yet been computed by Sema")(static_cast <bool> ((!needsOverloadResolutionForDestructor
() || (data().DeclaredSpecialMembers & SMF_Destructor)) &&
 "this property has not yet been computed by Sema") ? void (0
) : __assert_fail ("(!needsOverloadResolutionForDestructor() || (data().DeclaredSpecialMembers & SMF_Destructor)) && \"this property has not yet been computed by Sema\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 893, __extension__ __PRETTY_FUNCTION__));
  return data().DefaultedDestructorIsDeleted;
}

/// \brief \c true if we know for sure that this class has a single,
/// accessible, unambiguous copy constructor that is not deleted.
bool hasSimpleCopyConstructor() const {
  return !hasUserDeclaredCopyConstructor() &&
         !data().DefaultedCopyConstructorIsDeleted;
}

/// \brief \c true if we know for sure that this class has a single,
/// accessible, unambiguous move constructor that is not deleted.
bool hasSimpleMoveConstructor() const {
  return !hasUserDeclaredMoveConstructor() && hasMoveConstructor() &&
         !data().DefaultedMoveConstructorIsDeleted;
}

/// \brief \c true if we know for sure that this class has a single,
/// accessible, unambiguous move assignment operator that is not deleted.
bool hasSimpleMoveAssignment() const {
  return !hasUserDeclaredMoveAssignment() && hasMoveAssignment() &&
         !data().DefaultedMoveAssignmentIsDeleted;
}

/// \brief \c true if we know for sure that this class has an accessible
/// destructor that is not deleted.
bool hasSimpleDestructor() const {
  return !hasUserDeclaredDestructor() &&
         !data().DefaultedDestructorIsDeleted;
}

/// \brief Determine whether this class has any default constructors.
bool hasDefaultConstructor() const {
  return (data().DeclaredSpecialMembers & SMF_DefaultConstructor) ||
         needsImplicitDefaultConstructor();
}

/// \brief Determine if we need to declare a default constructor for
/// this class.
///
/// This value is used for lazy creation of default constructors.
bool needsImplicitDefaultConstructor() const {
  return !data().UserDeclaredConstructor &&
         !(data().DeclaredSpecialMembers & SMF_DefaultConstructor) &&
         // C++14 [expr.prim.lambda]p20:
         //   The closure type associated with a lambda-expression has no
         //   default constructor.
         !isLambda();
}

/// \brief Determine whether this class has any user-declared constructors.
///
/// When true, a default constructor will not be implicitly declared.
bool hasUserDeclaredConstructor() const {
  return data().UserDeclaredConstructor;
}

/// \brief Whether this class has a user-provided default constructor
/// per C++11.
bool hasUserProvidedDefaultConstructor() const {
  return data().UserProvidedDefaultConstructor;
}

/// \brief Determine whether this class has a user-declared copy constructor.
///
/// When false, a copy constructor will be implicitly declared.
bool hasUserDeclaredCopyConstructor() const {
  return data().UserDeclaredSpecialMembers & SMF_CopyConstructor;
}

/// \brief Determine whether this class needs an implicit copy
/// constructor to be lazily declared.
bool needsImplicitCopyConstructor() const {
  return !(data().DeclaredSpecialMembers & SMF_CopyConstructor);
}

/// \brief Determine whether we need to eagerly declare a defaulted copy
/// constructor for this class.
bool needsOverloadResolutionForCopyConstructor() const {
  // C++17 [class.copy.ctor]p6:
  //   If the class definition declares a move constructor or move assignment
  //   operator, the implicitly declared copy constructor is defined as
  //   deleted.
  // In MSVC mode, sometimes a declared move assignment does not delete an
  // implicit copy constructor, so defer this choice to Sema.
  if (data().UserDeclaredSpecialMembers &
      (SMF_MoveConstructor | SMF_MoveAssignment))
    return true;
  return data().NeedOverloadResolutionForCopyConstructor;
}

/// \brief Determine whether an implicit copy constructor for this type
/// would have a parameter with a const-qualified reference type.
bool implicitCopyConstructorHasConstParam() const {
  return data().ImplicitCopyConstructorCanHaveConstParamForNonVBase &&
         (isAbstract() ||
          data().ImplicitCopyConstructorCanHaveConstParamForVBase);
}

/// \brief Determine whether this class has a copy constructor with
/// a parameter type which is a reference to a const-qualified type.
bool hasCopyConstructorWithConstParam() const {
  return data().HasDeclaredCopyConstructorWithConstParam ||
         (needsImplicitCopyConstructor() &&
          implicitCopyConstructorHasConstParam());
}

/// \brief Whether this class has a user-declared move constructor or
/// assignment operator.
///
/// When false, a move constructor and assignment operator may be
/// implicitly declared.
bool hasUserDeclaredMoveOperation() const {
  return data().UserDeclaredSpecialMembers &
           (SMF_MoveConstructor | SMF_MoveAssignment);
}

/// \brief Determine whether this class has had a move constructor
/// declared by the user.
bool hasUserDeclaredMoveConstructor() const {
  return data().UserDeclaredSpecialMembers & SMF_MoveConstructor;
}

/// \brief Determine whether this class has a move constructor.
bool hasMoveConstructor() const {
  return (data().DeclaredSpecialMembers & SMF_MoveConstructor) ||
         needsImplicitMoveConstructor();
}

/// \brief Set that we attempted to declare an implicit copy
/// constructor, but overload resolution failed so we deleted it.
void setImplicitCopyConstructorIsDeleted() {
  assert((data().DefaultedCopyConstructorIsDeleted ||(static_cast <bool> ((data().DefaultedCopyConstructorIsDeleted
 || needsOverloadResolutionForCopyConstructor()) && "Copy constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyConstructorIsDeleted || needsOverloadResolutionForCopyConstructor()) && \"Copy constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1028, __extension__ __PRETTY_FUNCTION__))
          needsOverloadResolutionForCopyConstructor()) &&(static_cast <bool> ((data().DefaultedCopyConstructorIsDeleted
 || needsOverloadResolutionForCopyConstructor()) && "Copy constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyConstructorIsDeleted || needsOverloadResolutionForCopyConstructor()) && \"Copy constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1028, __extension__ __PRETTY_FUNCTION__))
         "Copy constructor should not be deleted")(static_cast <bool> ((data().DefaultedCopyConstructorIsDeleted
 || needsOverloadResolutionForCopyConstructor()) && "Copy constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedCopyConstructorIsDeleted || needsOverloadResolutionForCopyConstructor()) && \"Copy constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1028, __extension__ __PRETTY_FUNCTION__));
  data().DefaultedCopyConstructorIsDeleted = true;
}

/// \brief Set that we attempted to declare an implicit move
/// constructor, but overload resolution failed so we deleted it.
void setImplicitMoveConstructorIsDeleted() {
  assert((data().DefaultedMoveConstructorIsDeleted ||(static_cast <bool> ((data().DefaultedMoveConstructorIsDeleted
 || needsOverloadResolutionForMoveConstructor()) && "move constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveConstructorIsDeleted || needsOverloadResolutionForMoveConstructor()) && \"move constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1037, __extension__ __PRETTY_FUNCTION__))
          needsOverloadResolutionForMoveConstructor()) &&(static_cast <bool> ((data().DefaultedMoveConstructorIsDeleted
 || needsOverloadResolutionForMoveConstructor()) && "move constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveConstructorIsDeleted || needsOverloadResolutionForMoveConstructor()) && \"move constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1037, __extension__ __PRETTY_FUNCTION__))
         "move constructor should not be deleted")(static_cast <bool> ((data().DefaultedMoveConstructorIsDeleted
 || needsOverloadResolutionForMoveConstructor()) && "move constructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveConstructorIsDeleted || needsOverloadResolutionForMoveConstructor()) && \"move constructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1037, __extension__ __PRETTY_FUNCTION__));
  data().DefaultedMoveConstructorIsDeleted = true;
}

/// \brief Set that we attempted to declare an implicit destructor,
/// but overload resolution failed so we deleted it.
void setImplicitDestructorIsDeleted() {
  assert((data().DefaultedDestructorIsDeleted ||(static_cast <bool> ((data().DefaultedDestructorIsDeleted
 || needsOverloadResolutionForDestructor()) && "destructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedDestructorIsDeleted || needsOverloadResolutionForDestructor()) && \"destructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1046, __extension__ __PRETTY_FUNCTION__))
          needsOverloadResolutionForDestructor()) &&(static_cast <bool> ((data().DefaultedDestructorIsDeleted
 || needsOverloadResolutionForDestructor()) && "destructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedDestructorIsDeleted || needsOverloadResolutionForDestructor()) && \"destructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1046, __extension__ __PRETTY_FUNCTION__))
         "destructor should not be deleted")(static_cast <bool> ((data().DefaultedDestructorIsDeleted
 || needsOverloadResolutionForDestructor()) && "destructor should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedDestructorIsDeleted || needsOverloadResolutionForDestructor()) && \"destructor should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1046, __extension__ __PRETTY_FUNCTION__));
  data().DefaultedDestructorIsDeleted = true;
}

/// \brief Determine whether this class should get an implicit move
/// constructor or if any existing special member function inhibits this.
bool needsImplicitMoveConstructor() const {
  return !(data().DeclaredSpecialMembers & SMF_MoveConstructor) &&
         !hasUserDeclaredCopyConstructor() &&
         !hasUserDeclaredCopyAssignment() &&
         !hasUserDeclaredMoveAssignment() &&
         !hasUserDeclaredDestructor();
}

/// \brief Determine whether we need to eagerly declare a defaulted move
/// constructor for this class.
bool needsOverloadResolutionForMoveConstructor() const {
  return data().NeedOverloadResolutionForMoveConstructor;
}

/// \brief Determine whether this class has a user-declared copy assignment
/// operator.
///
/// When false, a copy assigment operator will be implicitly declared.
bool hasUserDeclaredCopyAssignment() const {
  return data().UserDeclaredSpecialMembers & SMF_CopyAssignment;
}

/// \brief Determine whether this class needs an implicit copy
/// assignment operator to be lazily declared.
bool needsImplicitCopyAssignment() const {
  return !(data().DeclaredSpecialMembers & SMF_CopyAssignment);
}

/// \brief Determine whether we need to eagerly declare a defaulted copy
/// assignment operator for this class.
bool needsOverloadResolutionForCopyAssignment() const {
  return data().HasMutableFields;
}

/// \brief Determine whether an implicit copy assignment operator for this
/// type would have a parameter with a const-qualified reference type.
bool implicitCopyAssignmentHasConstParam() const {
  return data().ImplicitCopyAssignmentHasConstParam;
}

/// \brief Determine whether this class has a copy assignment operator with
/// a parameter type which is a reference to a const-qualified type or is not
/// a reference.
bool hasCopyAssignmentWithConstParam() const {
  return data().HasDeclaredCopyAssignmentWithConstParam ||
         (needsImplicitCopyAssignment() &&
          implicitCopyAssignmentHasConstParam());
}

/// \brief Determine whether this class has had a move assignment
/// declared by the user.
bool hasUserDeclaredMoveAssignment() const {
  return data().UserDeclaredSpecialMembers & SMF_MoveAssignment;
}

/// \brief Determine whether this class has a move assignment operator.
bool hasMoveAssignment() const {
  return (data().DeclaredSpecialMembers & SMF_MoveAssignment) ||
         needsImplicitMoveAssignment();
}

/// \brief Set that we attempted to declare an implicit move assignment
/// operator, but overload resolution failed so we deleted it.
void setImplicitMoveAssignmentIsDeleted() {
  assert((data().DefaultedMoveAssignmentIsDeleted ||(static_cast <bool> ((data().DefaultedMoveAssignmentIsDeleted
 || needsOverloadResolutionForMoveAssignment()) && "move assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveAssignmentIsDeleted || needsOverloadResolutionForMoveAssignment()) && \"move assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1118, __extension__ __PRETTY_FUNCTION__))
          needsOverloadResolutionForMoveAssignment()) &&(static_cast <bool> ((data().DefaultedMoveAssignmentIsDeleted
 || needsOverloadResolutionForMoveAssignment()) && "move assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveAssignmentIsDeleted || needsOverloadResolutionForMoveAssignment()) && \"move assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1118, __extension__ __PRETTY_FUNCTION__))
         "move assignment should not be deleted")(static_cast <bool> ((data().DefaultedMoveAssignmentIsDeleted
 || needsOverloadResolutionForMoveAssignment()) && "move assignment should not be deleted"
) ? void (0) : __assert_fail ("(data().DefaultedMoveAssignmentIsDeleted || needsOverloadResolutionForMoveAssignment()) && \"move assignment should not be deleted\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1118, __extension__ __PRETTY_FUNCTION__));
  data().DefaultedMoveAssignmentIsDeleted = true;
}

/// \brief Determine whether this class should get an implicit move
/// assignment operator or if any existing special member function inhibits
/// this.
bool needsImplicitMoveAssignment() const {
  return !(data().DeclaredSpecialMembers & SMF_MoveAssignment) &&
         !hasUserDeclaredCopyConstructor() &&
         !hasUserDeclaredCopyAssignment() &&
         !hasUserDeclaredMoveConstructor() &&
         !hasUserDeclaredDestructor() &&
         // C++1z [expr.prim.lambda]p21: "the closure type has a deleted copy
         // assignment operator". The intent is that this counts as a user
         // declared copy assignment, but we do not model it that way.
         !isLambda();
}

/// \brief Determine whether we need to eagerly declare a move assignment
/// operator for this class.
bool needsOverloadResolutionForMoveAssignment() const {
  return data().NeedOverloadResolutionForMoveAssignment;
}

/// \brief Determine whether this class has a user-declared destructor.
///
/// When false, a destructor will be implicitly declared.
bool hasUserDeclaredDestructor() const {
  return data().UserDeclaredSpecialMembers & SMF_Destructor;
}

/// \brief Determine whether this class needs an implicit destructor to
/// be lazily declared.
bool needsImplicitDestructor() const {
  return !(data().DeclaredSpecialMembers & SMF_Destructor);
}

/// \brief Determine whether we need to eagerly declare a destructor for this
/// class.
bool needsOverloadResolutionForDestructor() const {
  return data().NeedOverloadResolutionForDestructor;
}

/// \brief Determine whether this class describes a lambda function object.
bool isLambda() const {
  // An update record can't turn a non-lambda into a lambda.
  auto *DD = DefinitionData;
  return DD && DD->IsLambda;
}

/// \brief Determine whether this class describes a generic 
/// lambda function object (i.e. function call operator is
/// a template). 
bool isGenericLambda() const; 

/// \brief Retrieve the lambda call operator of the closure type
/// if this is a closure type.
CXXMethodDecl *getLambdaCallOperator() const; 

/// \brief Retrieve the lambda static invoker, the address of which
/// is returned by the conversion operator, and the body of which
/// is forwarded to the lambda call operator. 
CXXMethodDecl *getLambdaStaticInvoker() const; 

/// \brief Retrieve the generic lambda's template parameter list.
/// Returns null if the class does not represent a lambda or a generic 
/// lambda.
TemplateParameterList *getGenericLambdaTemplateParameterList() const;

LambdaCaptureDefault getLambdaCaptureDefault() const {
  assert(isLambda())(static_cast <bool> (isLambda()) ? void (0) : __assert_fail
 ("isLambda()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1189, __extension__ __PRETTY_FUNCTION__));
  return static_cast<LambdaCaptureDefault>(getLambdaData().CaptureDefault);
}

/// \brief For a closure type, retrieve the mapping from captured
/// variables and \c this to the non-static data members that store the
/// values or references of the captures.
///
/// \param Captures Will be populated with the mapping from captured
/// variables to the corresponding fields.
///
/// \param ThisCapture Will be set to the field declaration for the
/// \c this capture.
///
/// \note No entries will be added for init-captures, as they do not capture
/// variables.
void getCaptureFields(llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
                      FieldDecl *&ThisCapture) const;

using capture_const_iterator = const LambdaCapture *;
using capture_const_range = llvm::iterator_range<capture_const_iterator>;

capture_const_range captures() const {
  return capture_const_range(captures_begin(), captures_end());
}

capture_const_iterator captures_begin() const {
  return isLambda() ? getLambdaData().Captures : nullptr;
}

capture_const_iterator captures_end() const {
  return isLambda() ? captures_begin() + getLambdaData().NumCaptures
                    : nullptr;
}

using conversion_iterator = UnresolvedSetIterator;

conversion_iterator conversion_begin() const {
  return data().Conversions.get(getASTContext()).begin();
}

conversion_iterator conversion_end() const {
  return data().Conversions.get(getASTContext()).end();
}

/// Removes a conversion function from this class.  The conversion
/// function must currently be a member of this class.  Furthermore,
/// this class must currently be in the process of being defined.
void removeConversion(const NamedDecl *Old);

/// \brief Get all conversion functions visible in current class,
/// including conversion function templates.
llvm::iterator_range<conversion_iterator> getVisibleConversionFunctions();

/// Determine whether this class is an aggregate (C++ [dcl.init.aggr]),
/// which is a class with no user-declared constructors, no private
/// or protected non-static data members, no base classes, and no virtual
/// functions (C++ [dcl.init.aggr]p1).
bool isAggregate() const { return data().Aggregate; }

/// \brief Whether this class has any in-class initializers
/// for non-static data members (including those in anonymous unions or
/// structs).
bool hasInClassInitializer() const { return data().HasInClassInitializer; }

/// \brief Whether this class or any of its subobjects has any members of
/// reference type which would make value-initialization ill-formed.
///
/// Per C++03 [dcl.init]p5:
///  - if T is a non-union class type without a user-declared constructor,
///    then every non-static data member and base-class component of T is
///    value-initialized [...] A program that calls for [...]
///    value-initialization of an entity of reference type is ill-formed.
bool hasUninitializedReferenceMember() const {
  return !isUnion() && !hasUserDeclaredConstructor() &&
         data().HasUninitializedReferenceMember;
}

/// \brief Whether this class is a POD-type (C++ [class]p4)
///
/// For purposes of this function a class is POD if it is an aggregate
/// that has no non-static non-POD data members, no reference data
/// members, no user-defined copy assignment operator and no
/// user-defined destructor.
///
/// Note that this is the C++ TR1 definition of POD.
bool isPOD() const { return data().PlainOldData; }

/// \brief True if this class is C-like, without C++-specific features, e.g.
/// it contains only public fields, no bases, tag kind is not 'class', etc.
bool isCLike() const;

/// \brief Determine whether this is an empty class in the sense of
/// (C++11 [meta.unary.prop]).
///
/// The CXXRecordDecl is a class type, but not a union type,
/// with no non-static data members other than bit-fields of length 0,
/// no virtual member functions, no virtual base classes,
/// and no base class B for which is_empty<B>::value is false.
///
/// \note This does NOT include a check for union-ness.
bool isEmpty() const { return data().Empty; }

/// \brief Determine whether this class has direct non-static data members.
bool hasDirectFields() const {
  auto &D = data();
  return D.HasPublicFields || D.HasProtectedFields || D.HasPrivateFields;
}

/// Whether this class is polymorphic (C++ [class.virtual]),
/// which means that the class contains or inherits a virtual function.
bool isPolymorphic() const { return data().Polymorphic; }

/// \brief Determine whether this class has a pure virtual function.
///
/// The class is is abstract per (C++ [class.abstract]p2) if it declares
/// a pure virtual function or inherits a pure virtual function that is
/// not overridden.
bool isAbstract() const { return data().Abstract; }

/// \brief Determine whether this class has standard layout per 
/// (C++ [class]p7)
bool isStandardLayout() const { return data().IsStandardLayout; }

/// \brief Determine whether this class, or any of its class subobjects,
/// contains a mutable field.
bool hasMutableFields() const { return data().HasMutableFields; }

/// \brief Determine whether this class has any variant members.
bool hasVariantMembers() const { return data().HasVariantMembers; }

/// \brief Determine whether this class has a trivial default constructor
/// (C++11 [class.ctor]p5).
bool hasTrivialDefaultConstructor() const {
  return hasDefaultConstructor() &&
         (data().HasTrivialSpecialMembers & SMF_DefaultConstructor);
}

/// \brief Determine whether this class has a non-trivial default constructor
/// (C++11 [class.ctor]p5).
bool hasNonTrivialDefaultConstructor() const {
  return (data().DeclaredNonTrivialSpecialMembers & SMF_DefaultConstructor) ||
         (needsImplicitDefaultConstructor() &&
          !(data().HasTrivialSpecialMembers & SMF_DefaultConstructor));
}

/// \brief Determine whether this class has at least one constexpr constructor
/// other than the copy or move constructors.
bool hasConstexprNonCopyMoveConstructor() const {
  return data().HasConstexprNonCopyMoveConstructor ||
         (needsImplicitDefaultConstructor() &&
          defaultedDefaultConstructorIsConstexpr());
}

/// \brief Determine whether a defaulted default constructor for this class
/// would be constexpr.
bool defaultedDefaultConstructorIsConstexpr() const {
  return data().DefaultedDefaultConstructorIsConstexpr &&
         (!isUnion() || hasInClassInitializer() || !hasVariantMembers());
}

/// \brief Determine whether this class has a constexpr default constructor.
bool hasConstexprDefaultConstructor() const {
  return data().HasConstexprDefaultConstructor ||
         (needsImplicitDefaultConstructor() &&
          defaultedDefaultConstructorIsConstexpr());
}

/// \brief Determine whether this class has a trivial copy constructor
/// (C++ [class.copy]p6, C++11 [class.copy]p12)
bool hasTrivialCopyConstructor() const {
  return data().HasTrivialSpecialMembers & SMF_CopyConstructor;
}

bool hasTrivialCopyConstructorForCall() const {
  return data().HasTrivialSpecialMembersForCall & SMF_CopyConstructor;
}

/// \brief Determine whether this class has a non-trivial copy constructor
/// (C++ [class.copy]p6, C++11 [class.copy]p12)
bool hasNonTrivialCopyConstructor() const {
  return data().DeclaredNonTrivialSpecialMembers & SMF_CopyConstructor ||
         !hasTrivialCopyConstructor();
}

bool hasNonTrivialCopyConstructorForCall() const {
  return (data().DeclaredNonTrivialSpecialMembersForCall &
          SMF_CopyConstructor) ||
         !hasTrivialCopyConstructorForCall();
}

/// \brief Determine whether this class has a trivial move constructor
/// (C++11 [class.copy]p12)
bool hasTrivialMoveConstructor() const {
  return hasMoveConstructor() &&
         (data().HasTrivialSpecialMembers & SMF_MoveConstructor);
}

bool hasTrivialMoveConstructorForCall() const {
  return hasMoveConstructor() &&
         (data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor);
}

/// \brief Determine whether this class has a non-trivial move constructor
/// (C++11 [class.copy]p12)
bool hasNonTrivialMoveConstructor() const {
  return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveConstructor) ||
         (needsImplicitMoveConstructor() &&
          !(data().HasTrivialSpecialMembers & SMF_MoveConstructor));
}

bool hasNonTrivialMoveConstructorForCall() const {
  return (data().DeclaredNonTrivialSpecialMembersForCall &
          SMF_MoveConstructor) ||
         (needsImplicitMoveConstructor() &&
          !(data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor));
}

/// \brief Determine whether this class has a trivial copy assignment operator
/// (C++ [class.copy]p11, C++11 [class.copy]p25)
bool hasTrivialCopyAssignment() const {
  return data().HasTrivialSpecialMembers & SMF_CopyAssignment;
}

/// \brief Determine whether this class has a non-trivial copy assignment
/// operator (C++ [class.copy]p11, C++11 [class.copy]p25)
bool hasNonTrivialCopyAssignment() const {
  return data().DeclaredNonTrivialSpecialMembers & SMF_CopyAssignment ||
         !hasTrivialCopyAssignment();
}

/// \brief Determine whether this class has a trivial move assignment operator
/// (C++11 [class.copy]p25)
bool hasTrivialMoveAssignment() const {
  return hasMoveAssignment() &&
         (data().HasTrivialSpecialMembers & SMF_MoveAssignment);
}

/// \brief Determine whether this class has a non-trivial move assignment
/// operator (C++11 [class.copy]p25)
bool hasNonTrivialMoveAssignment() const {
  return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveAssignment) ||
         (needsImplicitMoveAssignment() &&
          !(data().HasTrivialSpecialMembers & SMF_MoveAssignment));
}

/// \brief Determine whether this class has a trivial destructor
/// (C++ [class.dtor]p3)
bool hasTrivialDestructor() const {
  return data().HasTrivialSpecialMembers & SMF_Destructor;
}

bool hasTrivialDestructorForCall() const {
  return data().HasTrivialSpecialMembersForCall & SMF_Destructor;
}

/// \brief Determine whether this class has a non-trivial destructor
/// (C++ [class.dtor]p3)
bool hasNonTrivialDestructor() const {
  return !(data().HasTrivialSpecialMembers & SMF_Destructor);
}

bool hasNonTrivialDestructorForCall() const {
  return !(data().HasTrivialSpecialMembersForCall & SMF_Destructor);
}

void setHasTrivialSpecialMemberForCall() {
  data().HasTrivialSpecialMembersForCall =
      (SMF_CopyConstructor | SMF_MoveConstructor | SMF_Destructor);
}

/// \brief Determine whether declaring a const variable with this type is ok
/// per core issue 253.
bool allowConstDefaultInit() const {
  return !data().HasUninitializedFields ||
         !(data().HasDefaultedDefaultConstructor ||
           needsImplicitDefaultConstructor());
}

/// \brief Determine whether this class has a destructor which has no
/// semantic effect.
///
/// Any such destructor will be trivial, public, defaulted and not deleted,
/// and will call only irrelevant destructors.
bool hasIrrelevantDestructor() const {
  return data().HasIrrelevantDestructor;
}

/// \brief Determine whether this class has at least one trivial, non-deleted
/// copy or move constructor.
bool canPassInRegisters() const {
  return data().CanPassInRegisters;
}

/// \brief Set that we can pass this RecordDecl in registers.
// FIXME: This should be set as part of completeDefinition.
void setCanPassInRegisters(bool CanPass) {
  data().CanPassInRegisters = CanPass;
}

/// Determine whether the triviality for the purpose of calls for this class
/// is overridden to be trivial because this class or the type of one of its
/// subobjects has attribute "trivial_abi".
bool hasTrivialABIOverride() const {
  return canPassInRegisters() && hasNonTrivialDestructor();
}

/// \brief Determine whether this class has a non-literal or/ volatile type
/// non-static data member or base class.
bool hasNonLiteralTypeFieldsOrBases() const {
  return data().HasNonLiteralTypeFieldsOrBases;
}

/// \brief Determine whether this class has a using-declaration that names
/// a user-declared base class constructor.
bool hasInheritedConstructor() const {
  return data().HasInheritedConstructor;
}

/// \brief Determine whether this class has a using-declaration that names
/// a base class assignment operator.
bool hasInheritedAssignment() const {
  return data().HasInheritedAssignment;
}

/// \brief Determine whether this class is considered trivially copyable per
/// (C++11 [class]p6).
bool isTriviallyCopyable() const;

/// \brief Determine whether this class is considered trivial.
///
/// C++11 [class]p6:
///    "A trivial class is a class that has a trivial default constructor and
///    is trivially copiable."
bool isTrivial() const {
  return isTriviallyCopyable() && hasTrivialDefaultConstructor();
}

/// \brief Determine whether this class is a literal type.
///
/// C++11 [basic.types]p10:
///   A class type that has all the following properties:
///     - it has a trivial destructor
///     - every constructor call and full-expression in the
///       brace-or-equal-intializers for non-static data members (if any) is
///       a constant expression.
///     - it is an aggregate type or has at least one constexpr constructor
///       or constructor template that is not a copy or move constructor, and
///     - all of its non-static data members and base classes are of literal
///       types
///
/// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by
/// treating types with trivial default constructors as literal types.
///
/// Only in C++17 and beyond, are lambdas literal types.
bool isLiteral() const {
  return hasTrivialDestructor() &&
         (!isLambda() || getASTContext().getLangOpts().CPlusPlus17) &&
         !hasNonLiteralTypeFieldsOrBases() &&
         (isAggregate() || isLambda() ||
          hasConstexprNonCopyMoveConstructor() ||
          hasTrivialDefaultConstructor());
}

/// \brief If this record is an instantiation of a member class,
/// retrieves the member class from which it was instantiated.
///
/// This routine will return non-null for (non-templated) member
/// classes of class templates. For example, given:
///
/// \code
/// template<typename T>
/// struct X {
///   struct A { };
/// };
/// \endcode
///
/// The declaration for X<int>::A is a (non-templated) CXXRecordDecl
/// whose parent is the class template specialization X<int>. For
/// this declaration, getInstantiatedFromMemberClass() will return
/// the CXXRecordDecl X<T>::A. When a complete definition of
/// X<int>::A is required, it will be instantiated from the
/// declaration returned by getInstantiatedFromMemberClass().
CXXRecordDecl *getInstantiatedFromMemberClass() const;

/// \brief If this class is an instantiation of a member class of a
/// class template specialization, retrieves the member specialization
/// information.
MemberSpecializationInfo *getMemberSpecializationInfo() const;

/// \brief Specify that this record is an instantiation of the
/// member class \p RD.
void setInstantiationOfMemberClass(CXXRecordDecl *RD,
                                   TemplateSpecializationKind TSK);

/// \brief Retrieves the class template that is described by this
/// class declaration.
///
/// Every class template is represented as a ClassTemplateDecl and a
/// CXXRecordDecl. The former contains template properties (such as
/// the template parameter lists) while the latter contains the
/// actual description of the template's
/// contents. ClassTemplateDecl::getTemplatedDecl() retrieves the
/// CXXRecordDecl that from a ClassTemplateDecl, while
/// getDescribedClassTemplate() retrieves the ClassTemplateDecl from
/// a CXXRecordDecl.
ClassTemplateDecl *getDescribedClassTemplate() const;

void setDescribedClassTemplate(ClassTemplateDecl *Template);

/// \brief Determine whether this particular class is a specialization or
/// instantiation of a class template or member class of a class template,
/// and how it was instantiated or specialized.
TemplateSpecializationKind getTemplateSpecializationKind() const;

/// \brief Set the kind of specialization or template instantiation this is.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK);

/// \brief Retrieve the record declaration from which this record could be
/// instantiated. Returns null if this class is not a template instantiation.
const CXXRecordDecl *getTemplateInstantiationPattern() const;

CXXRecordDecl *getTemplateInstantiationPattern() {
  return const_cast<CXXRecordDecl *>(const_cast<const CXXRecordDecl *>(this)
                                         ->getTemplateInstantiationPattern());
}

/// \brief Returns the destructor decl for this class.
CXXDestructorDecl *getDestructor() const;

/// \brief Returns true if the class destructor, or any implicitly invoked
/// destructors are marked noreturn.
bool isAnyDestructorNoReturn() const;

/// \brief If the class is a local class [class.local], returns
/// the enclosing function declaration.
const FunctionDecl *isLocalClass() const {
  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(getDeclContext()))
    return RD->isLocalClass();

  return dyn_cast<FunctionDecl>(getDeclContext());
}

FunctionDecl *isLocalClass() {
  return const_cast<FunctionDecl*>(
      const_cast<const CXXRecordDecl*>(this)->isLocalClass());
}

/// \brief Determine whether this dependent class is a current instantiation,
/// when viewed from within the given context.
bool isCurrentInstantiation(const DeclContext *CurContext) const;

/// \brief Determine whether this class is derived from the class \p Base.
///
/// This routine only determines whether this class is derived from \p Base,
/// but does not account for factors that may make a Derived -> Base class
/// ill-formed, such as private/protected inheritance or multiple, ambiguous
/// base class subobjects.
///
/// \param Base the base class we are searching for.
///
/// \returns true if this class is derived from Base, false otherwise.
bool isDerivedFrom(const CXXRecordDecl *Base) const;

/// \brief Determine whether this class is derived from the type \p Base.
///
/// This routine only determines whether this class is derived from \p Base,
/// but does not account for factors that may make a Derived -> Base class
/// ill-formed, such as private/protected inheritance or multiple, ambiguous
/// base class subobjects.
///
/// \param Base the base class we are searching for.
///
/// \param Paths will contain the paths taken from the current class to the
/// given \p Base class.
///
/// \returns true if this class is derived from \p Base, false otherwise.
///
/// \todo add a separate parameter to configure IsDerivedFrom, rather than
/// tangling input and output in \p Paths
bool isDerivedFrom(const CXXRecordDecl *Base, CXXBasePaths &Paths) const;

/// \brief Determine whether this class is virtually derived from
/// the class \p Base.
///
/// This routine only determines whether this class is virtually
/// derived from \p Base, but does not account for factors that may
/// make a Derived -> Base class ill-formed, such as
/// private/protected inheritance or multiple, ambiguous base class
/// subobjects.
///
/// \param Base the base class we are searching for.
///
/// \returns true if this class is virtually derived from Base,
/// false otherwise.
bool isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const;

/// \brief Determine whether this class is provably not derived from
/// the type \p Base.
bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const;

/// \brief Function type used by forallBases() as a callback.
///
/// \param BaseDefinition the definition of the base class
///
/// \returns true if this base matched the search criteria
using ForallBasesCallback =
    llvm::function_ref<bool(const CXXRecordDecl *BaseDefinition)>;

/// \brief Determines if the given callback holds for all the direct
/// or indirect base classes of this type.
///
/// The class itself does not count as a base class.  This routine
/// returns false if the class has non-computable base classes.
///
/// \param BaseMatches Callback invoked for each (direct or indirect) base
/// class of this type, or if \p AllowShortCircuit is true then until a call
/// returns false.
///
/// \param AllowShortCircuit if false, forces the callback to be called
/// for every base class, even if a dependent or non-matching base was
/// found.
bool forallBases(ForallBasesCallback BaseMatches,
                 bool AllowShortCircuit = true) const;

/// \brief Function type used by lookupInBases() to determine whether a
/// specific base class subobject matches the lookup criteria.
///
/// \param Specifier the base-class specifier that describes the inheritance
/// from the base class we are trying to match.
///
/// \param Path the current path, from the most-derived class down to the
/// base named by the \p Specifier.
///
/// \returns true if this base matched the search criteria, false otherwise.
using BaseMatchesCallback =
    llvm::function_ref<bool(const CXXBaseSpecifier *Specifier,
                            CXXBasePath &Path)>;

/// \brief Look for entities within the base classes of this C++ class,
/// transitively searching all base class subobjects.
///
/// This routine uses the callback function \p BaseMatches to find base
/// classes meeting some search criteria, walking all base class subobjects
/// and populating the given \p Paths structure with the paths through the
/// inheritance hierarchy that resulted in a match. On a successful search,
/// the \p Paths structure can be queried to retrieve the matching paths and
/// to determine if there were any ambiguities.
///
/// \param BaseMatches callback function used to determine whether a given
/// base matches the user-defined search criteria.
///
/// \param Paths used to record the paths from this class to its base class
/// subobjects that match the search criteria.
///
/// \param LookupInDependent can be set to true to extend the search to
/// dependent base classes.
///
/// \returns true if there exists any path from this class to a base class
/// subobject that matches the search criteria.
bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths,
                   bool LookupInDependent = false) const;

/// \brief Base-class lookup callback that determines whether the given
/// base class specifier refers to a specific class declaration.
///
/// This callback can be used with \c lookupInBases() to determine whether
/// a given derived class has is a base class subobject of a particular type.
/// The base record pointer should refer to the canonical CXXRecordDecl of the
/// base class that we are searching for.
static bool FindBaseClass(const CXXBaseSpecifier *Specifier,
                          CXXBasePath &Path, const CXXRecordDecl *BaseRecord);

/// \brief Base-class lookup callback that determines whether the
/// given base class specifier refers to a specific class
/// declaration and describes virtual derivation.
///
/// This callback can be used with \c lookupInBases() to determine
/// whether a given derived class has is a virtual base class
/// subobject of a particular type.  The base record pointer should
/// refer to the canonical CXXRecordDecl of the base class that we
/// are searching for.
static bool FindVirtualBaseClass(const CXXBaseSpecifier *Specifier,
                                 CXXBasePath &Path,
                                 const CXXRecordDecl *BaseRecord);

/// \brief Base-class lookup callback that determines whether there exists
/// a tag with the given name.
///
/// This callback can be used with \c lookupInBases() to find tag members
/// of the given name within a C++ class hierarchy.
static bool FindTagMember(const CXXBaseSpecifier *Specifier,
                          CXXBasePath &Path, DeclarationName Name);

/// \brief Base-class lookup callback that determines whether there exists
/// a member with the given name.
///
/// This callback can be used with \c lookupInBases() to find members
/// of the given name within a C++ class hierarchy.
static bool FindOrdinaryMember(const CXXBaseSpecifier *Specifier,
                               CXXBasePath &Path, DeclarationName Name);

/// \brief Base-class lookup callback that determines whether there exists
/// a member with the given name.
///
/// This callback can be used with \c lookupInBases() to find members
/// of the given name within a C++ class hierarchy, including dependent
/// classes.
static bool
FindOrdinaryMemberInDependentClasses(const CXXBaseSpecifier *Specifier,
                                     CXXBasePath &Path, DeclarationName Name);

/// \brief Base-class lookup callback that determines whether there exists
/// an OpenMP declare reduction member with the given name.
///
/// This callback can be used with \c lookupInBases() to find members
/// of the given name within a C++ class hierarchy.
static bool FindOMPReductionMember(const CXXBaseSpecifier *Specifier,
                                   CXXBasePath &Path, DeclarationName Name);

/// \brief Base-class lookup callback that determines whether there exists
/// a member with the given name that can be used in a nested-name-specifier.
///
/// This callback can be used with \c lookupInBases() to find members of
/// the given name within a C++ class hierarchy that can occur within
/// nested-name-specifiers.
static bool FindNestedNameSpecifierMember(const CXXBaseSpecifier *Specifier,
                                          CXXBasePath &Path,
                                          DeclarationName Name);

/// \brief Retrieve the final overriders for each virtual member
/// function in the class hierarchy where this class is the
/// most-derived class in the class hierarchy.
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const;

/// \brief Get the indirect primary bases for this class.
void getIndirectPrimaryBases(CXXIndirectPrimaryBaseSet& Bases) const;

/// Performs an imprecise lookup of a dependent name in this class.
///
/// This function does not follow strict semantic rules and should be used
/// only when lookup rules can be relaxed, e.g. indexing.
std::vector<const NamedDecl *>
lookupDependentName(const DeclarationName &Name,
                    llvm::function_ref<bool(const NamedDecl *ND)> Filter);

/// Renders and displays an inheritance diagram
/// for this C++ class and all of its base classes (transitively) using
/// GraphViz.
void viewInheritance(ASTContext& Context) const;

/// \brief Calculates the access of a decl that is reached
/// along a path.
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess,
                                   AccessSpecifier DeclAccess) {
  assert(DeclAccess != AS_none)(static_cast <bool> (DeclAccess != AS_none) ? void (0) :
 __assert_fail ("DeclAccess != AS_none", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1844, __extension__ __PRETTY_FUNCTION__));
  if (DeclAccess == AS_private) return AS_none;
  return (PathAccess > DeclAccess ? PathAccess : DeclAccess);
}

/// \brief Indicates that the declaration of a defaulted or deleted special
/// member function is now complete.
void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD);

void setTrivialForCallFlags(CXXMethodDecl *MD);

/// \brief Indicates that the definition of this class is now complete.
void completeDefinition() override;

/// \brief Indicates that the definition of this class is now complete,
/// and provides a final overrider map to help determine
///
/// \param FinalOverriders The final overrider map for this class, which can
/// be provided as an optimization for abstract-class checking. If NULL,
/// final overriders will be computed if they are needed to complete the
/// definition.
void completeDefinition(CXXFinalOverriderMap *FinalOverriders);

/// \brief Determine whether this class may end up being abstract, even though
/// it is not yet known to be abstract.
///
/// \returns true if this class is not known to be abstract but has any
/// base classes that are abstract. In this case, \c completeDefinition()
/// will need to compute final overriders to determine whether the class is
/// actually abstract.
bool mayBeAbstract() const;

/// \brief If this is the closure type of a lambda expression, retrieve the
/// number to be used for name mangling in the Itanium C++ ABI.
///
/// Zero indicates that this closure type has internal linkage, so the 
/// mangling number does not matter, while a non-zero value indicates which
/// lambda expression this is in this particular context.
unsigned getLambdaManglingNumber() const {
  assert(isLambda() && "Not a lambda closure type!")(static_cast <bool> (isLambda() && "Not a lambda closure type!"
) ? void (0) : __assert_fail ("isLambda() && \"Not a lambda closure type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 1883, __extension__ __PRETTY_FUNCTION__));
  return getLambdaData().ManglingNumber;
}

/// \brief Retrieve the declaration that provides additional context for a 
/// lambda, when the normal declaration context is not specific enough.
///
/// Certain contexts (default arguments of in-class function parameters and 
/// the initializers of data members) have separate name mangling rules for
/// lambdas within the Itanium C++ ABI. For these cases, this routine provides
/// the declaration in which the lambda occurs, e.g., the function parameter 
/// or the non-static data member. Otherwise, it returns NULL to imply that
/// the declaration context suffices.
Decl *getLambdaContextDecl() const;

/// \brief Set the mangling number and context declaration for a lambda
/// class.
void setLambdaMangling(unsigned ManglingNumber, Decl *ContextDecl) {
  getLambdaData().ManglingNumber = ManglingNumber;
  getLambdaData().ContextDecl = ContextDecl;
}

/// \brief Returns the inheritance model used for this record.
MSInheritanceAttr::Spelling getMSInheritanceModel() const;

/// \brief Calculate what the inheritance model would be for this class.
MSInheritanceAttr::Spelling calculateInheritanceModel() const;

/// In the Microsoft C++ ABI, use zero for the field offset of a null data
/// member pointer if we can guarantee that zero is not a valid field offset,
/// or if the member pointer has multiple fields.  Polymorphic classes have a
/// vfptr at offset zero, so we can use zero for null.  If there are multiple
/// fields, we can use zero even if it is a valid field offset because
/// null-ness testing will check the other fields.
bool nullFieldOffsetIsZero() const {
  return !MSInheritanceAttr::hasOnlyOneField(/*IsMemberFunction=*/false,
                                             getMSInheritanceModel()) ||
         (hasDefinition() && isPolymorphic());
}

/// \brief Controls when vtordisps will be emitted if this record is used as a
/// virtual base.
MSVtorDispAttr::Mode getMSVtorDispMode() const;

/// \brief Determine whether this lambda expression was known to be dependent
/// at the time it was created, even if its context does not appear to be
/// dependent.
///
/// This flag is a workaround for an issue with parsing, where default
/// arguments are parsed before their enclosing function declarations have
/// been created. This means that any lambda expressions within those
/// default arguments will have as their DeclContext the context enclosing
/// the function declaration, which may be non-dependent even when the
/// function declaration itself is dependent. This flag indicates when we
/// know that the lambda is dependent despite that.
bool isDependentLambda() const {
  return isLambda() && getLambdaData().Dependent;
}

TypeSourceInfo *getLambdaTypeInfo() const {
  return getLambdaData().MethodTyInfo;
}

// \brief Determine whether this type is an Interface Like type for
// __interface inheritence purposes.
bool isInterfaceLike() const;

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstCXXRecord && K <= lastCXXRecord;
}
1954};

1956/// \brief Represents a C++ deduction guide declaration.
1957///
1958/// \code
1959/// template<typename T> struct A { A(); A(T); };
1960/// A() -> A<int>;
1961/// \endcode
1962///
1963/// In this example, there will be an explicit deduction guide from the
1964/// second line, and implicit deduction guide templates synthesized from
1965/// the constructors of \c A.
1966class CXXDeductionGuideDecl : public FunctionDecl {
void anchor() override;

1969private:
CXXDeductionGuideDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                      bool IsExplicit, const DeclarationNameInfo &NameInfo,
                      QualType T, TypeSourceInfo *TInfo,
                      SourceLocation EndLocation)
    : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
                   SC_None, false, false) {
  if (EndLocation.isValid())
    setRangeEnd(EndLocation);
  IsExplicitSpecified = IsExplicit;
}

1981public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static CXXDeductionGuideDecl *Create(ASTContext &C, DeclContext *DC,
                                     SourceLocation StartLoc, bool IsExplicit,
                                     const DeclarationNameInfo &NameInfo,
                                     QualType T, TypeSourceInfo *TInfo,
                                     SourceLocation EndLocation);

static CXXDeductionGuideDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// Whether this deduction guide is explicit.
bool isExplicit() const { return IsExplicitSpecified; }

/// Whether this deduction guide was declared with the 'explicit' specifier.
bool isExplicitSpecified() const { return IsExplicitSpecified; }

/// Get the template for which this guide performs deduction.
TemplateDecl *getDeducedTemplate() const {
  return getDeclName().getCXXDeductionGuideTemplate();
}

void setIsCopyDeductionCandidate() {
  IsCopyDeductionCandidate = true;
}

bool isCopyDeductionCandidate() const { return IsCopyDeductionCandidate; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == CXXDeductionGuide; }
2013};

2015/// \brief Represents a static or instance method of a struct/union/class.
2016///
2017/// In the terminology of the C++ Standard, these are the (static and
2018/// non-static) member functions, whether virtual or not.
2019class CXXMethodDecl : public FunctionDecl {
void anchor() override;

2022protected:
CXXMethodDecl(Kind DK, ASTContext &C, CXXRecordDecl *RD,
              SourceLocation StartLoc, const DeclarationNameInfo &NameInfo,
              QualType T, TypeSourceInfo *TInfo,
              StorageClass SC, bool isInline,
              bool isConstexpr, SourceLocation EndLocation)
  : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo,
                 SC, isInline, isConstexpr) {
  if (EndLocation.isValid())
    setRangeEnd(EndLocation);
}

2034public:
static CXXMethodDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                             SourceLocation StartLoc,
                             const DeclarationNameInfo &NameInfo,
                             QualType T, TypeSourceInfo *TInfo,
                             StorageClass SC,
                             bool isInline,
                             bool isConstexpr,
                             SourceLocation EndLocation);

static CXXMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);

bool isStatic() const;
bool isInstance() const { return !isStatic(); }

/// Returns true if the given operator is implicitly static in a record
/// context.
static bool isStaticOverloadedOperator(OverloadedOperatorKind OOK) {
  // [class.free]p1:
  // Any allocation function for a class T is a static member
  // (even if not explicitly declared static).
  // [class.free]p6 Any deallocation function for a class X is a static member
  // (even if not explicitly declared static).
  return OOK == OO_New || OOK == OO_Array_New || OOK == OO_Delete ||
         OOK == OO_Array_Delete;
}

bool isConst() const { return getType()->castAs<FunctionType>()->isConst(); }
bool isVolatile() const { return getType()->castAs<FunctionType>()->isVolatile(); }

bool isVirtual() const {
  CXXMethodDecl *CD =
    cast<CXXMethodDecl>(const_cast<CXXMethodDecl*>(this)->getCanonicalDecl());

  // Member function is virtual if it is marked explicitly so, or if it is
  // declared in __interface -- then it is automatically pure virtual.
  if (CD->isVirtualAsWritten() || CD->isPure())
    return true;

  return CD->size_overridden_methods() != 0;
}

/// If it's possible to devirtualize a call to this method, return the called
/// function. Otherwise, return null.

/// \param Base The object on which this virtual function is called.
/// \param IsAppleKext True if we are compiling for Apple kext.
CXXMethodDecl *getDevirtualizedMethod(const Expr *Base, bool IsAppleKext);

const CXXMethodDecl *getDevirtualizedMethod(const Expr *Base,
                                            bool IsAppleKext) const {
  return const_cast<CXXMethodDecl *>(this)->getDevirtualizedMethod(
      Base, IsAppleKext);
}

/// \brief Determine whether this is a usual deallocation function
/// (C++ [basic.stc.dynamic.deallocation]p2), which is an overloaded
/// delete or delete[] operator with a particular signature.
bool isUsualDeallocationFunction() const;

/// \brief Determine whether this is a copy-assignment operator, regardless
/// of whether it was declared implicitly or explicitly.
bool isCopyAssignmentOperator() const;

/// \brief Determine whether this is a move assignment operator.
bool isMoveAssignmentOperator() const;

CXXMethodDecl *getCanonicalDecl() override {
  return cast<CXXMethodDecl>(FunctionDecl::getCanonicalDecl());
}
const CXXMethodDecl *getCanonicalDecl() const {
  return const_cast<CXXMethodDecl*>(this)->getCanonicalDecl();
}

CXXMethodDecl *getMostRecentDecl() {
  return cast<CXXMethodDecl>(
          static_cast<FunctionDecl *>(this)->getMostRecentDecl());
}
const CXXMethodDecl *getMostRecentDecl() const {
  return const_cast<CXXMethodDecl*>(this)->getMostRecentDecl();
}

/// True if this method is user-declared and was not
/// deleted or defaulted on its first declaration.
bool isUserProvided() const {
  auto *DeclAsWritten = this;
  if (auto *Pattern = getTemplateInstantiationPattern())
    DeclAsWritten = cast<CXXMethodDecl>(Pattern);
  return !(DeclAsWritten->isDeleted() ||
           DeclAsWritten->getCanonicalDecl()->isDefaulted());
}

void addOverriddenMethod(const CXXMethodDecl *MD);

using method_iterator = const CXXMethodDecl *const *;

method_iterator begin_overridden_methods() const;
method_iterator end_overridden_methods() const;
unsigned size_overridden_methods() const;

using overridden_method_range= ASTContext::overridden_method_range;

overridden_method_range overridden_methods() const;

/// Returns the parent of this method declaration, which
/// is the class in which this method is defined.
const CXXRecordDecl *getParent() const {
  return cast<CXXRecordDecl>(FunctionDecl::getParent());
}

/// Returns the parent of this method declaration, which
/// is the class in which this method is defined.
CXXRecordDecl *getParent() {
  return const_cast<CXXRecordDecl *>(
           cast<CXXRecordDecl>(FunctionDecl::getParent()));
}

/// \brief Returns the type of the \c this pointer.
///
/// Should only be called for instance (i.e., non-static) methods. Note
/// that for the call operator of a lambda closure type, this returns the
/// desugared 'this' type (a pointer to the closure type), not the captured
/// 'this' type.
QualType getThisType(ASTContext &C) const;

unsigned getTypeQualifiers() const {
  return getType()->getAs<FunctionProtoType>()->getTypeQuals();
}

/// \brief Retrieve the ref-qualifier associated with this method.
///
/// In the following example, \c f() has an lvalue ref-qualifier, \c g()
/// has an rvalue ref-qualifier, and \c h() has no ref-qualifier.
/// @code
/// struct X {
///   void f() &;
///   void g() &&;
///   void h();
/// };
/// @endcode
RefQualifierKind getRefQualifier() const {
  return getType()->getAs<FunctionProtoType>()->getRefQualifier();
}

bool hasInlineBody() const;

/// \brief Determine whether this is a lambda closure type's static member
/// function that is used for the result of the lambda's conversion to
/// function pointer (for a lambda with no captures).
///
/// The function itself, if used, will have a placeholder body that will be
/// supplied by IR generation to either forward to the function call operator
/// or clone the function call operator.
bool isLambdaStaticInvoker() const;

/// \brief Find the method in \p RD that corresponds to this one.
///
/// Find if \p RD or one of the classes it inherits from override this method.
/// If so, return it. \p RD is assumed to be a subclass of the class defining
/// this method (or be the class itself), unless \p MayBeBase is set to true.
CXXMethodDecl *
getCorrespondingMethodInClass(const CXXRecordDecl *RD,
                              bool MayBeBase = false);

const CXXMethodDecl *
getCorrespondingMethodInClass(const CXXRecordDecl *RD,
                              bool MayBeBase = false) const {
  return const_cast<CXXMethodDecl *>(this)
            ->getCorrespondingMethodInClass(RD, MayBeBase);
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstCXXMethod && K <= lastCXXMethod;
}
2210};

2212/// \brief Represents a C++ base or member initializer.
2213///
2214/// This is part of a constructor initializer that
2215/// initializes one non-static member variable or one base class. For
2216/// example, in the following, both 'A(a)' and 'f(3.14159)' are member
2217/// initializers:
2218///
2219/// \code
2220/// class A { };
2221/// class B : public A {
2222///   float f;
2223/// public:
2224///   B(A& a) : A(a), f(3.14159) { }
2225/// };
2226/// \endcode
2227class CXXCtorInitializer final {
/// \brief Either the base class name/delegating constructor type (stored as
/// a TypeSourceInfo*), an normal field (FieldDecl), or an anonymous field
/// (IndirectFieldDecl*) being initialized.
llvm::PointerUnion3<TypeSourceInfo *, FieldDecl *, IndirectFieldDecl *>
  Initializee;

/// \brief The source location for the field name or, for a base initializer
/// pack expansion, the location of the ellipsis.
///
/// In the case of a delegating
/// constructor, it will still include the type's source location as the
/// Initializee points to the CXXConstructorDecl (to allow loop detection).
SourceLocation MemberOrEllipsisLocation;

/// \brief The argument used to initialize the base or member, which may
/// end up constructing an object (when multiple arguments are involved).
Stmt *Init;

/// \brief Location of the left paren of the ctor-initializer.
SourceLocation LParenLoc;

/// \brief Location of the right paren of the ctor-initializer.
SourceLocation RParenLoc;

/// \brief If the initializee is a type, whether that type makes this
/// a delegating initialization.
unsigned IsDelegating : 1;

/// \brief If the initializer is a base initializer, this keeps track
/// of whether the base is virtual or not.
unsigned IsVirtual : 1;

/// \brief Whether or not the initializer is explicitly written
/// in the sources.
unsigned IsWritten : 1;

/// If IsWritten is true, then this number keeps track of the textual order
/// of this initializer in the original sources, counting from 0.
unsigned SourceOrder : 13;

2268public:
/// \brief Creates a new base-class initializer.
explicit
CXXCtorInitializer(ASTContext &Context, TypeSourceInfo *TInfo, bool IsVirtual,
                   SourceLocation L, Expr *Init, SourceLocation R,
                   SourceLocation EllipsisLoc);

/// \brief Creates a new member initializer.
explicit
CXXCtorInitializer(ASTContext &Context, FieldDecl *Member,
                   SourceLocation MemberLoc, SourceLocation L, Expr *Init,
                   SourceLocation R);

/// \brief Creates a new anonymous field initializer.
explicit
CXXCtorInitializer(ASTContext &Context, IndirectFieldDecl *Member,
                   SourceLocation MemberLoc, SourceLocation L, Expr *Init,
                   SourceLocation R);

/// \brief Creates a new delegating initializer.
explicit
CXXCtorInitializer(ASTContext &Context, TypeSourceInfo *TInfo,
                   SourceLocation L, Expr *Init, SourceLocation R);

/// \brief Determine whether this initializer is initializing a base class.
bool isBaseInitializer() const {
  return Initializee.is<TypeSourceInfo*>() && !IsDelegating;
}

/// \brief Determine whether this initializer is initializing a non-static
/// data member.
bool isMemberInitializer() const { return Initializee.is<FieldDecl*>(); }

bool isAnyMemberInitializer() const {
  return isMemberInitializer() || isIndirectMemberInitializer();
}

bool isIndirectMemberInitializer() const {
  return Initializee.is<IndirectFieldDecl*>();
}

/// \brief Determine whether this initializer is an implicit initializer
/// generated for a field with an initializer defined on the member
/// declaration.
///
/// In-class member initializers (also known as "non-static data member
/// initializations", NSDMIs) were introduced in C++11.
bool isInClassMemberInitializer() const {
  return Init->getStmtClass() == Stmt::CXXDefaultInitExprClass;
}

/// \brief Determine whether this initializer is creating a delegating
/// constructor.
bool isDelegatingInitializer() const {
  return Initializee.is<TypeSourceInfo*>() && IsDelegating;
}

/// \brief Determine whether this initializer is a pack expansion.
bool isPackExpansion() const {
  return isBaseInitializer() && MemberOrEllipsisLocation.isValid();
}

// \brief For a pack expansion, returns the location of the ellipsis.
SourceLocation getEllipsisLoc() const {
  assert(isPackExpansion() && "Initializer is not a pack expansion")(static_cast <bool> (isPackExpansion() && "Initializer is not a pack expansion"
) ? void (0) : __assert_fail ("isPackExpansion() && \"Initializer is not a pack expansion\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2332, __extension__ __PRETTY_FUNCTION__));
  return MemberOrEllipsisLocation;
}

/// If this is a base class initializer, returns the type of the
/// base class with location information. Otherwise, returns an NULL
/// type location.
TypeLoc getBaseClassLoc() const;

/// If this is a base class initializer, returns the type of the base class.
/// Otherwise, returns null.
const Type *getBaseClass() const;

/// Returns whether the base is virtual or not.
bool isBaseVirtual() const {
  assert(isBaseInitializer() && "Must call this on base initializer!")(static_cast <bool> (isBaseInitializer() && "Must call this on base initializer!"
) ? void (0) : __assert_fail ("isBaseInitializer() && \"Must call this on base initializer!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2347, __extension__ __PRETTY_FUNCTION__));

  return IsVirtual;
}

/// \brief Returns the declarator information for a base class or delegating
/// initializer.
TypeSourceInfo *getTypeSourceInfo() const {
  return Initializee.dyn_cast<TypeSourceInfo *>();
}

/// \brief If this is a member initializer, returns the declaration of the
/// non-static data member being initialized. Otherwise, returns null.
FieldDecl *getMember() const {
  if (isMemberInitializer())
    return Initializee.get<FieldDecl*>();
  return nullptr;
}

FieldDecl *getAnyMember() const {
  if (isMemberInitializer())
    return Initializee.get<FieldDecl*>();
  if (isIndirectMemberInitializer())
    return Initializee.get<IndirectFieldDecl*>()->getAnonField();
  return nullptr;
}

IndirectFieldDecl *getIndirectMember() const {
  if (isIndirectMemberInitializer())
    return Initializee.get<IndirectFieldDecl*>();
  return nullptr;
}

SourceLocation getMemberLocation() const {
  return MemberOrEllipsisLocation;
}

/// \brief Determine the source location of the initializer.
SourceLocation getSourceLocation() const;

/// \brief Determine the source range covering the entire initializer.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__));

/// \brief Determine whether this initializer is explicitly written
/// in the source code.
bool isWritten() const { return IsWritten; }

/// \brief Return the source position of the initializer, counting from 0.
/// If the initializer was implicit, -1 is returned.
int getSourceOrder() const {
  return IsWritten ? static_cast<int>(SourceOrder) : -1;
}

/// \brief Set the source order of this initializer.
///
/// This can only be called once for each initializer; it cannot be called
/// on an initializer having a positive number of (implicit) array indices.
///
/// This assumes that the initializer was written in the source code, and
/// ensures that isWritten() returns true.
void setSourceOrder(int Pos) {
  assert(!IsWritten &&(static_cast <bool> (!IsWritten && "setSourceOrder() used on implicit initializer"
) ? void (0) : __assert_fail ("!IsWritten && \"setSourceOrder() used on implicit initializer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2409, __extension__ __PRETTY_FUNCTION__))
         "setSourceOrder() used on implicit initializer")(static_cast <bool> (!IsWritten && "setSourceOrder() used on implicit initializer"
) ? void (0) : __assert_fail ("!IsWritten && \"setSourceOrder() used on implicit initializer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2409, __extension__ __PRETTY_FUNCTION__));
  assert(SourceOrder == 0 &&(static_cast <bool> (SourceOrder == 0 && "calling twice setSourceOrder() on the same initializer"
) ? void (0) : __assert_fail ("SourceOrder == 0 && \"calling twice setSourceOrder() on the same initializer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2411, __extension__ __PRETTY_FUNCTION__))
         "calling twice setSourceOrder() on the same initializer")(static_cast <bool> (SourceOrder == 0 && "calling twice setSourceOrder() on the same initializer"
) ? void (0) : __assert_fail ("SourceOrder == 0 && \"calling twice setSourceOrder() on the same initializer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2411, __extension__ __PRETTY_FUNCTION__));
  assert(Pos >= 0 &&(static_cast <bool> (Pos >= 0 && "setSourceOrder() used to make an initializer implicit"
) ? void (0) : __assert_fail ("Pos >= 0 && \"setSourceOrder() used to make an initializer implicit\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2413, __extension__ __PRETTY_FUNCTION__))
         "setSourceOrder() used to make an initializer implicit")(static_cast <bool> (Pos >= 0 && "setSourceOrder() used to make an initializer implicit"
) ? void (0) : __assert_fail ("Pos >= 0 && \"setSourceOrder() used to make an initializer implicit\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2413, __extension__ __PRETTY_FUNCTION__));
  IsWritten = true;
  SourceOrder = static_cast<unsigned>(Pos);
}

SourceLocation getLParenLoc() const { return LParenLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }

/// \brief Get the initializer.
Expr *getInit() const { return static_cast<Expr*>(Init); }
2423};

2425/// Description of a constructor that was inherited from a base class.
2426class InheritedConstructor {
ConstructorUsingShadowDecl *Shadow = nullptr;
CXXConstructorDecl *BaseCtor = nullptr;

2430public:
InheritedConstructor() = default;
InheritedConstructor(ConstructorUsingShadowDecl *Shadow,
                     CXXConstructorDecl *BaseCtor)
    : Shadow(Shadow), BaseCtor(BaseCtor) {}

explicit operator bool() const { return Shadow; }

ConstructorUsingShadowDecl *getShadowDecl() const { return Shadow; }
CXXConstructorDecl *getConstructor() const { return BaseCtor; }
2440};

2442/// \brief Represents a C++ constructor within a class.
2443///
2444/// For example:
2445///
2446/// \code
2447/// class X {
2448/// public:
2449///   explicit X(int); // represented by a CXXConstructorDecl.
2450/// };
2451/// \endcode
2452class CXXConstructorDecl final
  : public CXXMethodDecl,
    private llvm::TrailingObjects<CXXConstructorDecl, InheritedConstructor> {
/// \name Support for base and member initializers.
/// \{
/// \brief The arguments used to initialize the base or member.
LazyCXXCtorInitializersPtr CtorInitializers;
unsigned NumCtorInitializers : 31;
/// \}

/// \brief Whether this constructor declaration is an implicitly-declared
/// inheriting constructor.
unsigned IsInheritingConstructor : 1;

CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                   const DeclarationNameInfo &NameInfo,
                   QualType T, TypeSourceInfo *TInfo,
                   bool isExplicitSpecified, bool isInline,
                   bool isImplicitlyDeclared, bool isConstexpr,
                   InheritedConstructor Inherited)
  : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
                  SC_None, isInline, isConstexpr, SourceLocation()),
    NumCtorInitializers(0), IsInheritingConstructor((bool)Inherited) {
  setImplicit(isImplicitlyDeclared);
  if (Inherited)
    *getTrailingObjects<InheritedConstructor>() = Inherited;
  IsExplicitSpecified = isExplicitSpecified;
}

void anchor() override;

2483public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

static CXXConstructorDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                              bool InheritsConstructor);
static CXXConstructorDecl *
Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
       const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
       bool isExplicit, bool isInline, bool isImplicitlyDeclared,
       bool isConstexpr,
       InheritedConstructor Inherited = InheritedConstructor());

/// \brief Iterates through the member/base initializer list.
using init_iterator = CXXCtorInitializer **;

/// \brief Iterates through the member/base initializer list.
using init_const_iterator = CXXCtorInitializer *const *;

using init_range = llvm::iterator_range<init_iterator>;
using init_const_range = llvm::iterator_range<init_const_iterator>;

init_range inits() { return init_range(init_begin(), init_end()); }
init_const_range inits() const {
  return init_const_range(init_begin(), init_end());
}

/// \brief Retrieve an iterator to the first initializer.
init_iterator init_begin() {
  const auto *ConstThis = this;
  return const_cast<init_iterator>(ConstThis->init_begin());
}

/// \brief Retrieve an iterator to the first initializer.
init_const_iterator init_begin() const;

/// \brief Retrieve an iterator past the last initializer.
init_iterator       init_end()       {
  return init_begin() + NumCtorInitializers;
}

/// \brief Retrieve an iterator past the last initializer.
init_const_iterator init_end() const {
  return init_begin() + NumCtorInitializers;
}

using init_reverse_iterator = std::reverse_iterator<init_iterator>;
using init_const_reverse_iterator =
    std::reverse_iterator<init_const_iterator>;

init_reverse_iterator init_rbegin() {
  return init_reverse_iterator(init_end());
}
init_const_reverse_iterator init_rbegin() const {
  return init_const_reverse_iterator(init_end());
}

init_reverse_iterator init_rend() {
  return init_reverse_iterator(init_begin());
}
init_const_reverse_iterator init_rend() const {
  return init_const_reverse_iterator(init_begin());
}

/// \brief Determine the number of arguments used to initialize the member
/// or base.
unsigned getNumCtorInitializers() const {
    return NumCtorInitializers;
}

void setNumCtorInitializers(unsigned numCtorInitializers) {
  NumCtorInitializers = numCtorInitializers;
}

void setCtorInitializers(CXXCtorInitializer **Initializers) {
  CtorInitializers = Initializers;
}

/// Whether this function is marked as explicit explicitly.
bool isExplicitSpecified() const { return IsExplicitSpecified; }

/// Whether this function is explicit.
bool isExplicit() const {
  return getCanonicalDecl()->isExplicitSpecified();
}

/// \brief Determine whether this constructor is a delegating constructor.
bool isDelegatingConstructor() const {
  return (getNumCtorInitializers() == 1) &&
         init_begin()[0]->isDelegatingInitializer();
}

/// \brief When this constructor delegates to another, retrieve the target.
CXXConstructorDecl *getTargetConstructor() const;

/// Whether this constructor is a default
/// constructor (C++ [class.ctor]p5), which can be used to
/// default-initialize a class of this type.
bool isDefaultConstructor() const;

/// \brief Whether this constructor is a copy constructor (C++ [class.copy]p2,
/// which can be used to copy the class.
///
/// \p TypeQuals will be set to the qualifiers on the
/// argument type. For example, \p TypeQuals would be set to \c
/// Qualifiers::Const for the following copy constructor:
///
/// \code
/// class X {
/// public:
///   X(const X&);
/// };
/// \endcode
bool isCopyConstructor(unsigned &TypeQuals) const;

/// Whether this constructor is a copy
/// constructor (C++ [class.copy]p2, which can be used to copy the
/// class.
bool isCopyConstructor() const {
  unsigned TypeQuals = 0;
  return isCopyConstructor(TypeQuals);
}

/// \brief Determine whether this constructor is a move constructor
/// (C++11 [class.copy]p3), which can be used to move values of the class.
///
/// \param TypeQuals If this constructor is a move constructor, will be set
/// to the type qualifiers on the referent of the first parameter's type.
bool isMoveConstructor(unsigned &TypeQuals) const;

/// \brief Determine whether this constructor is a move constructor
/// (C++11 [class.copy]p3), which can be used to move values of the class.
bool isMoveConstructor() const {
  unsigned TypeQuals = 0;
  return isMoveConstructor(TypeQuals);
}

/// \brief Determine whether this is a copy or move constructor.
///
/// \param TypeQuals Will be set to the type qualifiers on the reference
/// parameter, if in fact this is a copy or move constructor.
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const;

/// \brief Determine whether this a copy or move constructor.
bool isCopyOrMoveConstructor() const {
  unsigned Quals;
  return isCopyOrMoveConstructor(Quals);
}

/// Whether this constructor is a
/// converting constructor (C++ [class.conv.ctor]), which can be
/// used for user-defined conversions.
bool isConvertingConstructor(bool AllowExplicit) const;

/// \brief Determine whether this is a member template specialization that
/// would copy the object to itself. Such constructors are never used to copy
/// an object.
bool isSpecializationCopyingObject() const;

/// \brief Determine whether this is an implicit constructor synthesized to
/// model a call to a constructor inherited from a base class.
bool isInheritingConstructor() const { return IsInheritingConstructor; }

/// \brief Get the constructor that this inheriting constructor is based on.
InheritedConstructor getInheritedConstructor() const {
  return IsInheritingConstructor ? *getTrailingObjects<InheritedConstructor>()
                                 : InheritedConstructor();
}

CXXConstructorDecl *getCanonicalDecl() override {
  return cast<CXXConstructorDecl>(FunctionDecl::getCanonicalDecl());
}
const CXXConstructorDecl *getCanonicalDecl() const {
  return const_cast<CXXConstructorDecl*>(this)->getCanonicalDecl();
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == CXXConstructor; }
2663};

2665/// \brief Represents a C++ destructor within a class.
2666///
2667/// For example:
2668///
2669/// \code
2670/// class X {
2671/// public:
2672///   ~X(); // represented by a CXXDestructorDecl.
2673/// };
2674/// \endcode
2675class CXXDestructorDecl : public CXXMethodDecl {
friend class ASTDeclReader;
friend class ASTDeclWriter;

// FIXME: Don't allocate storage for these except in the first declaration
// of a virtual destructor.
FunctionDecl *OperatorDelete = nullptr;
Expr *OperatorDeleteThisArg = nullptr;

CXXDestructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                  const DeclarationNameInfo &NameInfo,
                  QualType T, TypeSourceInfo *TInfo,
                  bool isInline, bool isImplicitlyDeclared)
  : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
                  SC_None, isInline, /*isConstexpr=*/false, SourceLocation())
{
  setImplicit(isImplicitlyDeclared);
}

void anchor() override;

2696public:
static CXXDestructorDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                 SourceLocation StartLoc,
                                 const DeclarationNameInfo &NameInfo,
                                 QualType T, TypeSourceInfo* TInfo,
                                 bool isInline,
                                 bool isImplicitlyDeclared);
static CXXDestructorDecl *CreateDeserialized(ASTContext & C, unsigned ID);

void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg);

const FunctionDecl *getOperatorDelete() const {
  return getCanonicalDecl()->OperatorDelete;
}

Expr *getOperatorDeleteThisArg() const {
  return getCanonicalDecl()->OperatorDeleteThisArg;
}

CXXDestructorDecl *getCanonicalDecl() override {
  return cast<CXXDestructorDecl>(FunctionDecl::getCanonicalDecl());
}
const CXXDestructorDecl *getCanonicalDecl() const {
  return const_cast<CXXDestructorDecl*>(this)->getCanonicalDecl();
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == CXXDestructor; }
2725};

2727/// \brief Represents a C++ conversion function within a class.
2728///
2729/// For example:
2730///
2731/// \code
2732/// class X {
2733/// public:
2734///   operator bool();
2735/// };
2736/// \endcode
2737class CXXConversionDecl : public CXXMethodDecl {
CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                  const DeclarationNameInfo &NameInfo, QualType T,
                  TypeSourceInfo *TInfo, bool isInline,
                  bool isExplicitSpecified, bool isConstexpr,
                  SourceLocation EndLocation)
    : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
                    SC_None, isInline, isConstexpr, EndLocation) {
  IsExplicitSpecified = isExplicitSpecified;
}

void anchor() override;

2750public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static CXXConversionDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                 SourceLocation StartLoc,
                                 const DeclarationNameInfo &NameInfo,
                                 QualType T, TypeSourceInfo *TInfo,
                                 bool isInline, bool isExplicit,
                                 bool isConstexpr,
                                 SourceLocation EndLocation);
static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// Whether this function is marked as explicit explicitly.
bool isExplicitSpecified() const { return IsExplicitSpecified; }

/// Whether this function is explicit.
bool isExplicit() const {
  return getCanonicalDecl()->isExplicitSpecified();
}

/// \brief Returns the type that this conversion function is converting to.
QualType getConversionType() const {
  return getType()->getAs<FunctionType>()->getReturnType();
}

/// \brief Determine whether this conversion function is a conversion from
/// a lambda closure type to a block pointer.
bool isLambdaToBlockPointerConversion() const;

CXXConversionDecl *getCanonicalDecl() override {
  return cast<CXXConversionDecl>(FunctionDecl::getCanonicalDecl());
}
const CXXConversionDecl *getCanonicalDecl() const {
  return const_cast<CXXConversionDecl*>(this)->getCanonicalDecl();
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == CXXConversion; }
2790};

2792/// \brief Represents a linkage specification. 
2793///
2794/// For example:
2795/// \code
2796///   extern "C" void foo();
2797/// \endcode
2798class LinkageSpecDecl : public Decl, public DeclContext {
virtual void anchor();

2801public:
/// \brief Represents the language in a linkage specification.
///
/// The values are part of the serialization ABI for
/// ASTs and cannot be changed without altering that ABI.  To help
/// ensure a stable ABI for this, we choose the DW_LANG_ encodings
/// from the dwarf standard.
enum LanguageIDs {
  lang_c = /* DW_LANG_C */ 0x0002,
  lang_cxx = /* DW_LANG_C_plus_plus */ 0x0004
};

2813private:
/// \brief The language for this linkage specification.
unsigned Language : 3;

/// \brief True if this linkage spec has braces.
///
/// This is needed so that hasBraces() returns the correct result while the
/// linkage spec body is being parsed.  Once RBraceLoc has been set this is
/// not used, so it doesn't need to be serialized.
unsigned HasBraces : 1;

/// \brief The source location for the extern keyword.
SourceLocation ExternLoc;

/// \brief The source location for the right brace (if valid).
SourceLocation RBraceLoc;

LinkageSpecDecl(DeclContext *DC, SourceLocation ExternLoc,
                SourceLocation LangLoc, LanguageIDs lang, bool HasBraces)
    : Decl(LinkageSpec, DC, LangLoc), DeclContext(LinkageSpec),
      Language(lang), HasBraces(HasBraces), ExternLoc(ExternLoc),
      RBraceLoc(SourceLocation()) {}

2836public:
static LinkageSpecDecl *Create(ASTContext &C, DeclContext *DC,
                               SourceLocation ExternLoc,
                               SourceLocation LangLoc, LanguageIDs Lang,
                               bool HasBraces);
static LinkageSpecDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// \brief Return the language specified by this linkage specification.
LanguageIDs getLanguage() const { return LanguageIDs(Language); }

/// \brief Set the language specified by this linkage specification.
void setLanguage(LanguageIDs L) { Language = L; }

/// \brief Determines whether this linkage specification had braces in
/// its syntactic form.
bool hasBraces() const {
  assert(!RBraceLoc.isValid() || HasBraces)(static_cast <bool> (!RBraceLoc.isValid() || HasBraces)
 ? void (0) : __assert_fail ("!RBraceLoc.isValid() || HasBraces"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 2852, __extension__ __PRETTY_FUNCTION__));
  return HasBraces;
}

SourceLocation getExternLoc() const { return ExternLoc; }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setExternLoc(SourceLocation L) { ExternLoc = L; }
void setRBraceLoc(SourceLocation L) {
  RBraceLoc = L;
  HasBraces = RBraceLoc.isValid();
}

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasBraces())
    return getRBraceLoc();
  // No braces: get the end location of the (only) declaration in context
  // (if present).
  return decls_empty() ? getLocation() : decls_begin()->getLocEnd();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(ExternLoc, getLocEnd());
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == LinkageSpec; }

static DeclContext *castToDeclContext(const LinkageSpecDecl *D) {
  return static_cast<DeclContext *>(const_cast<LinkageSpecDecl*>(D));
}

static LinkageSpecDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<LinkageSpecDecl *>(const_cast<DeclContext*>(DC));
}
2886};

2888/// \brief Represents C++ using-directive.
2889///
2890/// For example:
2891/// \code
2892///    using namespace std;
2893/// \endcode
2894///
2895/// \note UsingDirectiveDecl should be Decl not NamedDecl, but we provide
2896/// artificial names for all using-directives in order to store
2897/// them in DeclContext effectively.
2898class UsingDirectiveDecl : public NamedDecl {
/// \brief The location of the \c using keyword.
SourceLocation UsingLoc;

/// \brief The location of the \c namespace keyword.
SourceLocation NamespaceLoc;

/// \brief The nested-name-specifier that precedes the namespace.
NestedNameSpecifierLoc QualifierLoc;

/// \brief The namespace nominated by this using-directive.
NamedDecl *NominatedNamespace;

/// Enclosing context containing both using-directive and nominated
/// namespace.
DeclContext *CommonAncestor;

UsingDirectiveDecl(DeclContext *DC, SourceLocation UsingLoc,
                   SourceLocation NamespcLoc,
                   NestedNameSpecifierLoc QualifierLoc,
                   SourceLocation IdentLoc,
                   NamedDecl *Nominated,
                   DeclContext *CommonAncestor)
    : NamedDecl(UsingDirective, DC, IdentLoc, getName()), UsingLoc(UsingLoc),
      NamespaceLoc(NamespcLoc), QualifierLoc(QualifierLoc),
      NominatedNamespace(Nominated), CommonAncestor(CommonAncestor) {}

/// \brief Returns special DeclarationName used by using-directives.
///
/// This is only used by DeclContext for storing UsingDirectiveDecls in
/// its lookup structure.
static DeclarationName getName() {
  return DeclarationName::getUsingDirectiveName();
}

void anchor() override;

2935public:
friend class ASTDeclReader;

// Friend for getUsingDirectiveName.
friend class DeclContext;

/// \brief Retrieve the nested-name-specifier that qualifies the
/// name of the namespace, with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// \brief Retrieve the nested-name-specifier that qualifies the
/// name of the namespace.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

NamedDecl *getNominatedNamespaceAsWritten() { return NominatedNamespace; }
const NamedDecl *getNominatedNamespaceAsWritten() const {
  return NominatedNamespace;
}

/// \brief Returns the namespace nominated by this using-directive.
NamespaceDecl *getNominatedNamespace();

const NamespaceDecl *getNominatedNamespace() const {
  return const_cast<UsingDirectiveDecl*>(this)->getNominatedNamespace();
}

/// \brief Returns the common ancestor context of this using-directive and
/// its nominated namespace.
DeclContext *getCommonAncestor() { return CommonAncestor; }
const DeclContext *getCommonAncestor() const { return CommonAncestor; }

/// \brief Return the location of the \c using keyword.
SourceLocation getUsingLoc() const { return UsingLoc; }

// FIXME: Could omit 'Key' in name.
/// \brief Returns the location of the \c namespace keyword.
SourceLocation getNamespaceKeyLocation() const { return NamespaceLoc; }

/// \brief Returns the location of this using declaration's identifier.
SourceLocation getIdentLocation() const { return getLocation(); }

static UsingDirectiveDecl *Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation UsingLoc,
                                  SourceLocation NamespaceLoc,
                                  NestedNameSpecifierLoc QualifierLoc,
                                  SourceLocation IdentLoc,
                                  NamedDecl *Nominated,
                                  DeclContext *CommonAncestor);
static UsingDirectiveDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(UsingLoc, getLocation());
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == UsingDirective; }
2993};

2995/// \brief Represents a C++ namespace alias.
2996///
2997/// For example:
2998///
2999/// \code
3000/// namespace Foo = Bar;
3001/// \endcode
3002class NamespaceAliasDecl : public NamedDecl,
                         public Redeclarable<NamespaceAliasDecl> {
friend class ASTDeclReader;

/// \brief The location of the \c namespace keyword.
SourceLocation NamespaceLoc;

/// \brief The location of the namespace's identifier.
///
/// This is accessed by TargetNameLoc.
SourceLocation IdentLoc;

/// \brief The nested-name-specifier that precedes the namespace.
NestedNameSpecifierLoc QualifierLoc;

/// \brief The Decl that this alias points to, either a NamespaceDecl or
/// a NamespaceAliasDecl.
NamedDecl *Namespace;

NamespaceAliasDecl(ASTContext &C, DeclContext *DC,
                   SourceLocation NamespaceLoc, SourceLocation AliasLoc,
                   IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc,
                   SourceLocation IdentLoc, NamedDecl *Namespace)
    : NamedDecl(NamespaceAlias, DC, AliasLoc, Alias), redeclarable_base(C),
      NamespaceLoc(NamespaceLoc), IdentLoc(IdentLoc),
      QualifierLoc(QualifierLoc), Namespace(Namespace) {}

void anchor() override;

using redeclarable_base = Redeclarable<NamespaceAliasDecl>;

NamespaceAliasDecl *getNextRedeclarationImpl() override;
NamespaceAliasDecl *getPreviousDeclImpl() override;
NamespaceAliasDecl *getMostRecentDeclImpl() override;

3037public:
static NamespaceAliasDecl *Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation NamespaceLoc,
                                  SourceLocation AliasLoc,
                                  IdentifierInfo *Alias,
                                  NestedNameSpecifierLoc QualifierLoc,
                                  SourceLocation IdentLoc,
                                  NamedDecl *Namespace);

static NamespaceAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;

NamespaceAliasDecl *getCanonicalDecl() override {
  return getFirstDecl();
}
const NamespaceAliasDecl *getCanonicalDecl() const {
  return getFirstDecl();
}

/// \brief Retrieve the nested-name-specifier that qualifies the
/// name of the namespace, with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// \brief Retrieve the nested-name-specifier that qualifies the
/// name of the namespace.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// \brief Retrieve the namespace declaration aliased by this directive.
NamespaceDecl *getNamespace() {
  if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(Namespace))
    return AD->getNamespace();

  return cast<NamespaceDecl>(Namespace);
}

const NamespaceDecl *getNamespace() const {
  return const_cast<NamespaceAliasDecl*>(this)->getNamespace();
}

/// Returns the location of the alias name, i.e. 'foo' in
/// "namespace foo = ns::bar;".
SourceLocation getAliasLoc() const { return getLocation(); }

/// Returns the location of the \c namespace keyword.
SourceLocation getNamespaceLoc() const { return NamespaceLoc; }

/// Returns the location of the identifier in the named namespace.
SourceLocation getTargetNameLoc() const { return IdentLoc; }

/// \brief Retrieve the namespace that this alias refers to, which
/// may either be a NamespaceDecl or a NamespaceAliasDecl.
NamedDecl *getAliasedNamespace() const { return Namespace; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(NamespaceLoc, IdentLoc);
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == NamespaceAlias; }
3106};

3108/// \brief Represents a shadow declaration introduced into a scope by a
3109/// (resolved) using declaration.
3110///
3111/// For example,
3112/// \code
3113/// namespace A {
3114///   void foo();
3115/// }
3116/// namespace B {
3117///   using A::foo; // <- a UsingDecl
3118///                 // Also creates a UsingShadowDecl for A::foo() in B
3119/// }
3120/// \endcode
3121class UsingShadowDecl : public NamedDecl, public Redeclarable<UsingShadowDecl> {
friend class UsingDecl;

/// The referenced declaration.
NamedDecl *Underlying = nullptr;

/// \brief The using declaration which introduced this decl or the next using
/// shadow declaration contained in the aforementioned using declaration.
NamedDecl *UsingOrNextShadow = nullptr;

void anchor() override;

using redeclarable_base = Redeclarable<UsingShadowDecl>;

UsingShadowDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

UsingShadowDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

UsingShadowDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

3147protected:
UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC, SourceLocation Loc,
                UsingDecl *Using, NamedDecl *Target);
UsingShadowDecl(Kind K, ASTContext &C, EmptyShell);

3152public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static UsingShadowDecl *Create(ASTContext &C, DeclContext *DC,
                               SourceLocation Loc, UsingDecl *Using,
                               NamedDecl *Target) {
  return new (C, DC) UsingShadowDecl(UsingShadow, C, DC, Loc, Using, Target);
}

static UsingShadowDecl *CreateDeserialized(ASTContext &C, unsigned ID);

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

UsingShadowDecl *getCanonicalDecl() override {
  return getFirstDecl();
}
const UsingShadowDecl *getCanonicalDecl() const {
  return getFirstDecl();
}

/// \brief Gets the underlying declaration which has been brought into the
/// local scope.
NamedDecl *getTargetDecl() const { return Underlying; }

/// \brief Sets the underlying declaration which has been brought into the
/// local scope.
void setTargetDecl(NamedDecl *ND) {
  assert(ND && "Target decl is null!")(static_cast <bool> (ND && "Target decl is null!"
) ? void (0) : __assert_fail ("ND && \"Target decl is null!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/DeclCXX.h"
, 3188, __extension__ __PRETTY_FUNCTION__));
  Underlying = ND;
  // A UsingShadowDecl is never a friend or local extern declaration, even
  // if it is a shadow declaration for one.
  IdentifierNamespace =
      ND->getIdentifierNamespace() &
      ~(IDNS_OrdinaryFriend | IDNS_TagFriend | IDNS_LocalExtern);
}

/// \brief Gets the using declaration to which this declaration is tied.
UsingDecl *getUsingDecl() const;

/// \brief The next using shadow declaration contained in the shadow decl
/// chain of the using declaration which introduced this decl.
UsingShadowDecl *getNextUsingShadowDecl() const {
  return dyn_cast_or_null<UsingShadowDecl>(UsingOrNextShadow);
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K == Decl::UsingShadow || K == Decl::ConstructorUsingShadow;
}
3210};

3212/// \brief Represents a shadow constructor declaration introduced into a
3213/// class by a C++11 using-declaration that names a constructor.
3214///
3215/// For example:
3216/// \code
3217/// struct Base { Base(int); };
3218/// struct Derived {
3219///    using Base::Base; // creates a UsingDecl and a ConstructorUsingShadowDecl
3220/// };
3221/// \endcode
3222class ConstructorUsingShadowDecl final : public UsingShadowDecl {
/// \brief If this constructor using declaration inherted the constructor
/// from an indirect base class, this is the ConstructorUsingShadowDecl
/// in the named direct base class from which the declaration was inherited.
ConstructorUsingShadowDecl *NominatedBaseClassShadowDecl = nullptr;

/// \brief If this constructor using declaration inherted the constructor
/// from an indirect base class, this is the ConstructorUsingShadowDecl
/// that will be used to construct the unique direct or virtual base class
/// that receives the constructor arguments.
ConstructorUsingShadowDecl *ConstructedBaseClassShadowDecl = nullptr;

/// \brief \c true if the constructor ultimately named by this using shadow
/// declaration is within a virtual base class subobject of the class that
/// contains this declaration.
unsigned IsVirtual : 1;

ConstructorUsingShadowDecl(ASTContext &C, DeclContext *DC, SourceLocation Loc,
                           UsingDecl *Using, NamedDecl *Target,
                           bool TargetInVirtualBase)
    : UsingShadowDecl(ConstructorUsingShadow, C, DC, Loc, Using,
                      Target->getUnderlyingDecl()),
      NominatedBaseClassShadowDecl(
          dyn_cast<ConstructorUsingShadowDecl>(Target)),
      ConstructedBaseClassShadowDecl(NominatedBaseClassShadowDecl),
      IsVirtual(TargetInVirtualBase) {
  // If we found a constructor that chains to a constructor for a virtual
  // base, we should directly call that virtual base constructor instead.
  // FIXME: This logic belongs in Sema.
  if (NominatedBaseClassShadowDecl &&
      NominatedBaseClassShadowDecl->constructsVirtualBase()) {
    ConstructedBaseClassShadowDecl =
        NominatedBaseClassShadowDecl->ConstructedBaseClassShadowDecl;
    IsVirtual = true;
  }
}

ConstructorUsingShadowDecl(ASTContext &C, EmptyShell Empty)
    : UsingShadowDecl(ConstructorUsingShadow, C, Empty), IsVirtual(false) {}

void anchor() override;

3264public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static ConstructorUsingShadowDecl *Create(ASTContext &C, DeclContext *DC,
                                          SourceLocation Loc,
                                          UsingDecl *Using, NamedDecl *Target,
                                          bool IsVirtual);
static ConstructorUsingShadowDecl *CreateDeserialized(ASTContext &C,
                                                      unsigned ID);

/// Returns the parent of this using shadow declaration, which
/// is the class in which this is declared.
//@{
const CXXRecordDecl *getParent() const {
  return cast<CXXRecordDecl>(getDeclContext());
}
CXXRecordDecl *getParent() {
  return cast<CXXRecordDecl>(getDeclContext());
}
//@}

/// \brief Get the inheriting constructor declaration for the direct base
/// class from which this using shadow declaration was inherited, if there is
/// one. This can be different for each redeclaration of the same shadow decl.
ConstructorUsingShadowDecl *getNominatedBaseClassShadowDecl() const {
  return NominatedBaseClassShadowDecl;
}

/// \brief Get the inheriting constructor declaration for the base class
/// for which we don't have an explicit initializer, if there is one.
ConstructorUsingShadowDecl *getConstructedBaseClassShadowDecl() const {
  return ConstructedBaseClassShadowDecl;
}

/// \brief Get the base class that was named in the using declaration. This
/// can be different for each redeclaration of this same shadow decl.
CXXRecordDecl *getNominatedBaseClass() const;

/// \brief Get the base class whose constructor or constructor shadow
/// declaration is passed the constructor arguments.
CXXRecordDecl *getConstructedBaseClass() const {
  return cast<CXXRecordDecl>((ConstructedBaseClassShadowDecl
                                  ? ConstructedBaseClassShadowDecl
                                  : getTargetDecl())
                                 ->getDeclContext());
}

/// \brief Returns \c true if the constructed base class is a virtual base
/// class subobject of this declaration's class.
bool constructsVirtualBase() const {
  return IsVirtual;
}

/// \brief Get the constructor or constructor template in the derived class
/// correspnding to this using shadow declaration, if it has been implicitly
/// declared already.
CXXConstructorDecl *getConstructor() const;
void setConstructor(NamedDecl *Ctor);

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ConstructorUsingShadow; }
3326};

3328/// \brief Represents a C++ using-declaration.
3329///
3330/// For example:
3331/// \code
3332///    using someNameSpace::someIdentifier;
3333/// \endcode
3334class UsingDecl : public NamedDecl, public Mergeable<UsingDecl> {
/// \brief The source location of the 'using' keyword itself.
SourceLocation UsingLocation;

/// \brief The nested-name-specifier that precedes the name.
NestedNameSpecifierLoc QualifierLoc;

/// \brief Provides source/type location info for the declaration name
/// embedded in the ValueDecl base class.
DeclarationNameLoc DNLoc;

/// \brief The first shadow declaration of the shadow decl chain associated
/// with this using declaration.
///
/// The bool member of the pair store whether this decl has the \c typename
/// keyword.
llvm::PointerIntPair<UsingShadowDecl *, 1, bool> FirstUsingShadow;

UsingDecl(DeclContext *DC, SourceLocation UL,
          NestedNameSpecifierLoc QualifierLoc,
          const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
  : NamedDecl(Using, DC, NameInfo.getLoc(), NameInfo.getName()),
    UsingLocation(UL), QualifierLoc(QualifierLoc),
    DNLoc(NameInfo.getInfo()), FirstUsingShadow(nullptr, HasTypenameKeyword) {
}

void anchor() override;

3362public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

/// \brief Return the source location of the 'using' keyword.
SourceLocation getUsingLoc() const { return UsingLocation; }

/// \brief Set the source location of the 'using' keyword.
void setUsingLoc(SourceLocation L) { UsingLocation = L; }

/// \brief Retrieve the nested-name-specifier that qualifies the name,
/// with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// \brief Retrieve the nested-name-specifier that qualifies the name.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
}

/// \brief Return true if it is a C++03 access declaration (no 'using').
bool isAccessDeclaration() const { return UsingLocation.isInvalid(); }

/// \brief Return true if the using declaration has 'typename'.
bool hasTypename() const { return FirstUsingShadow.getInt(); }

/// \brief Sets whether the using declaration has 'typename'.
void setTypename(bool TN) { FirstUsingShadow.setInt(TN); }

/// \brief Iterates through the using shadow declarations associated with
/// this using declaration.
class shadow_iterator {
  /// \brief The current using shadow declaration.
  UsingShadowDecl *Current = nullptr;

public:
  using value_type = UsingShadowDecl *;
  using reference = UsingShadowDecl *;
  using pointer = UsingShadowDecl *;
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;

  shadow_iterator() = default;
  explicit shadow_iterator(UsingShadowDecl *C) : Current(C) {}

  reference operator*() const { return Current; }
  pointer operator->() const { return Current; }

  shadow_iterator& operator++() {
    Current = Current->getNextUsingShadowDecl();
    return *this;
  }

  shadow_iterator operator++(int) {
    shadow_iterator tmp(*this);
    ++(*this);
    return tmp;
  }

  friend bool operator==(shadow_iterator x, shadow_iterator y) {
    return x.Current == y.Current;
  }
  friend bool operator!=(shadow_iterator x, shadow_iterator y) {
    return x.Current != y.Current;
  }
};

using shadow_range = llvm::iterator_range<shadow_iterator>;

shadow_range shadows() const {
  return shadow_range(shadow_begin(), shadow_end());
}

shadow_iterator shadow_begin() const {
  return shadow_iterator(FirstUsingShadow.getPointer());
}

shadow_iterator shadow_end() const { return shadow_iterator(); }

/// \brief Return the number of shadowed declarations associated with this
/// using declaration.
unsigned shadow_size() const {
  return std::distance(shadow_begin(), shadow_end());
}

void addShadowDecl(UsingShadowDecl *S);
void removeShadowDecl(UsingShadowDecl *S);

static UsingDecl *Create(ASTContext &C, DeclContext *DC,
                         SourceLocation UsingL,
                         NestedNameSpecifierLoc QualifierLoc,
                         const DeclarationNameInfo &NameInfo,
                         bool HasTypenameKeyword);

static UsingDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Retrieves the canonical declaration of this declaration.
UsingDecl *getCanonicalDecl() override { return getFirstDecl(); }
const UsingDecl *getCanonicalDecl() const { return getFirstDecl(); }

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Using; }
3469};

3471/// Represents a pack of using declarations that a single
3472/// using-declarator pack-expanded into.
3473///
3474/// \code
3475/// template<typename ...T> struct X : T... {
3476///   using T::operator()...;
3477///   using T::operator T...;
3478/// };
3479/// \endcode
3480///
3481/// In the second case above, the UsingPackDecl will have the name
3482/// 'operator T' (which contains an unexpanded pack), but the individual
3483/// UsingDecls and UsingShadowDecls will have more reasonable names.
3484class UsingPackDecl final
  : public NamedDecl, public Mergeable<UsingPackDecl>,
    private llvm::TrailingObjects<UsingPackDecl, NamedDecl *> {
/// The UnresolvedUsingValueDecl or UnresolvedUsingTypenameDecl from
/// which this waas instantiated.
NamedDecl *InstantiatedFrom;

/// The number of using-declarations created by this pack expansion.
unsigned NumExpansions;

UsingPackDecl(DeclContext *DC, NamedDecl *InstantiatedFrom,
              ArrayRef<NamedDecl *> UsingDecls)
    : NamedDecl(UsingPack, DC,
                InstantiatedFrom ? InstantiatedFrom->getLocation()
                                 : SourceLocation(),
                InstantiatedFrom ? InstantiatedFrom->getDeclName()
                                 : DeclarationName()),
      InstantiatedFrom(InstantiatedFrom), NumExpansions(UsingDecls.size()) {
  std::uninitialized_copy(UsingDecls.begin(), UsingDecls.end(),
                          getTrailingObjects<NamedDecl *>());
}

void anchor() override;

3508public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

/// Get the using declaration from which this was instantiated. This will
/// always be an UnresolvedUsingValueDecl or an UnresolvedUsingTypenameDecl
/// that is a pack expansion.
NamedDecl *getInstantiatedFromUsingDecl() const { return InstantiatedFrom; }

/// Get the set of using declarations that this pack expanded into. Note that
/// some of these may still be unresolved.
ArrayRef<NamedDecl *> expansions() const {
  return llvm::makeArrayRef(getTrailingObjects<NamedDecl *>(), NumExpansions);
}

static UsingPackDecl *Create(ASTContext &C, DeclContext *DC,
                             NamedDecl *InstantiatedFrom,
                             ArrayRef<NamedDecl *> UsingDecls);

static UsingPackDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                         unsigned NumExpansions);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return InstantiatedFrom->getSourceRange();
}

UsingPackDecl *getCanonicalDecl() override { return getFirstDecl(); }
const UsingPackDecl *getCanonicalDecl() const { return getFirstDecl(); }

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == UsingPack; }
3540};

3542/// \brief Represents a dependent using declaration which was not marked with
3543/// \c typename.
3544///
3545/// Unlike non-dependent using declarations, these *only* bring through
3546/// non-types; otherwise they would break two-phase lookup.
3547///
3548/// \code
3549/// template \<class T> class A : public Base<T> {
3550///   using Base<T>::foo;
3551/// };
3552/// \endcode
3553class UnresolvedUsingValueDecl : public ValueDecl,
                               public Mergeable<UnresolvedUsingValueDecl> {
/// \brief The source location of the 'using' keyword
SourceLocation UsingLocation;

/// \brief If this is a pack expansion, the location of the '...'.
SourceLocation EllipsisLoc;

/// \brief The nested-name-specifier that precedes the name.
NestedNameSpecifierLoc QualifierLoc;

/// \brief Provides source/type location info for the declaration name
/// embedded in the ValueDecl base class.
DeclarationNameLoc DNLoc;

UnresolvedUsingValueDecl(DeclContext *DC, QualType Ty,
                         SourceLocation UsingLoc,
                         NestedNameSpecifierLoc QualifierLoc,
                         const DeclarationNameInfo &NameInfo,
                         SourceLocation EllipsisLoc)
    : ValueDecl(UnresolvedUsingValue, DC,
                NameInfo.getLoc(), NameInfo.getName(), Ty),
      UsingLocation(UsingLoc), EllipsisLoc(EllipsisLoc),
      QualifierLoc(QualifierLoc), DNLoc(NameInfo.getInfo()) {}

void anchor() override;

3580public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

/// \brief Returns the source location of the 'using' keyword.
SourceLocation getUsingLoc() const { return UsingLocation; }

/// \brief Set the source location of the 'using' keyword.
void setUsingLoc(SourceLocation L) { UsingLocation = L; }

/// \brief Return true if it is a C++03 access declaration (no 'using').
bool isAccessDeclaration() const { return UsingLocation.isInvalid(); }

/// \brief Retrieve the nested-name-specifier that qualifies the name,
/// with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// \brief Retrieve the nested-name-specifier that qualifies the name.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
}

/// \brief Determine whether this is a pack expansion.
bool isPackExpansion() const {
  return EllipsisLoc.isValid();
}

/// \brief Get the location of the ellipsis if this is a pack expansion.
SourceLocation getEllipsisLoc() const {
  return EllipsisLoc;
}

static UnresolvedUsingValueDecl *
  Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc,
         NestedNameSpecifierLoc QualifierLoc,
         const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc);

static UnresolvedUsingValueDecl *
CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Retrieves the canonical declaration of this declaration.
UnresolvedUsingValueDecl *getCanonicalDecl() override {
  return getFirstDecl();
}
const UnresolvedUsingValueDecl *getCanonicalDecl() const {
  return getFirstDecl();
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == UnresolvedUsingValue; }
3636};

3638/// \brief Represents a dependent using declaration which was marked with
3639/// \c typename.
3640///
3641/// \code
3642/// template \<class T> class A : public Base<T> {
3643///   using typename Base<T>::foo;
3644/// };
3645/// \endcode
3646///
3647/// The type associated with an unresolved using typename decl is
3648/// currently always a typename type.
3649class UnresolvedUsingTypenameDecl
  : public TypeDecl,
    public Mergeable<UnresolvedUsingTypenameDecl> {
friend class ASTDeclReader;

/// \brief The source location of the 'typename' keyword
SourceLocation TypenameLocation;

/// \brief If this is a pack expansion, the location of the '...'.
SourceLocation EllipsisLoc;

/// \brief The nested-name-specifier that precedes the name.
NestedNameSpecifierLoc QualifierLoc;

UnresolvedUsingTypenameDecl(DeclContext *DC, SourceLocation UsingLoc,
                            SourceLocation TypenameLoc,
                            NestedNameSpecifierLoc QualifierLoc,
                            SourceLocation TargetNameLoc,
                            IdentifierInfo *TargetName,
                            SourceLocation EllipsisLoc)
  : TypeDecl(UnresolvedUsingTypename, DC, TargetNameLoc, TargetName,
             UsingLoc),
    TypenameLocation(TypenameLoc), EllipsisLoc(EllipsisLoc),
    QualifierLoc(QualifierLoc) {}

void anchor() override;

3676public:
/// \brief Returns the source location of the 'using' keyword.
SourceLocation getUsingLoc() const { return getLocStart(); }

/// \brief Returns the source location of the 'typename' keyword.
SourceLocation getTypenameLoc() const { return TypenameLocation; }

/// \brief Retrieve the nested-name-specifier that qualifies the name,
/// with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// \brief Retrieve the nested-name-specifier that qualifies the name.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDeclName(), getLocation());
}

/// \brief Determine whether this is a pack expansion.
bool isPackExpansion() const {
  return EllipsisLoc.isValid();
}

/// \brief Get the location of the ellipsis if this is a pack expansion.
SourceLocation getEllipsisLoc() const {
  return EllipsisLoc;
}

static UnresolvedUsingTypenameDecl *
  Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc,
         SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc,
         SourceLocation TargetNameLoc, DeclarationName TargetName,
         SourceLocation EllipsisLoc);

static UnresolvedUsingTypenameDecl *
CreateDeserialized(ASTContext &C, unsigned ID);

/// Retrieves the canonical declaration of this declaration.
UnresolvedUsingTypenameDecl *getCanonicalDecl() override {
  return getFirstDecl();
}
const UnresolvedUsingTypenameDecl *getCanonicalDecl() const {
  return getFirstDecl();
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == UnresolvedUsingTypename; }
3725};

3727/// \brief Represents a C++11 static_assert declaration.
3728class StaticAssertDecl : public Decl {
llvm::PointerIntPair<Expr *, 1, bool> AssertExprAndFailed;
StringLiteral *Message;
SourceLocation RParenLoc;

StaticAssertDecl(DeclContext *DC, SourceLocation StaticAssertLoc,
                 Expr *AssertExpr, StringLiteral *Message,
                 SourceLocation RParenLoc, bool Failed)
    : Decl(StaticAssert, DC, StaticAssertLoc),
      AssertExprAndFailed(AssertExpr, Failed), Message(Message),
      RParenLoc(RParenLoc) {}

virtual void anchor();

3742public:
friend class ASTDeclReader;

static StaticAssertDecl *Create(ASTContext &C, DeclContext *DC,
                                SourceLocation StaticAssertLoc,
                                Expr *AssertExpr, StringLiteral *Message,
                                SourceLocation RParenLoc, bool Failed);
static StaticAssertDecl *CreateDeserialized(ASTContext &C, unsigned ID);

Expr *getAssertExpr() { return AssertExprAndFailed.getPointer(); }
const Expr *getAssertExpr() const { return AssertExprAndFailed.getPointer(); }

StringLiteral *getMessage() { return Message; }
const StringLiteral *getMessage() const { return Message; }

bool isFailed() const { return AssertExprAndFailed.getInt(); }

SourceLocation getRParenLoc() const { return RParenLoc; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getLocation(), getRParenLoc());
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == StaticAssert; }
3767};

3769/// A binding in a decomposition declaration. For instance, given:
3770///
3771///   int n[3];
3772///   auto &[a, b, c] = n;
3773///
3774/// a, b, and c are BindingDecls, whose bindings are the expressions
3775/// x[0], x[1], and x[2] respectively, where x is the implicit
3776/// DecompositionDecl of type 'int (&)[3]'.
3777class BindingDecl : public ValueDecl {
/// The binding represented by this declaration. References to this
/// declaration are effectively equivalent to this expression (except
/// that it is only evaluated once at the point of declaration of the
/// binding).
Expr *Binding = nullptr;

BindingDecl(DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
    : ValueDecl(Decl::Binding, DC, IdLoc, Id, QualType()) {}

void anchor() override;

3789public:
friend class ASTDeclReader;

static BindingDecl *Create(ASTContext &C, DeclContext *DC,
                           SourceLocation IdLoc, IdentifierInfo *Id);
static BindingDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// Get the expression to which this declaration is bound. This may be null
/// in two different cases: while parsing the initializer for the
/// decomposition declaration, and when the initializer is type-dependent.
Expr *getBinding() const { return Binding; }

/// Get the variable (if any) that holds the value of evaluating the binding.
/// Only present for user-defined bindings for tuple-like types.
VarDecl *getHoldingVar() const;

/// Set the binding for this BindingDecl, along with its declared type (which
/// should be a possibly-cv-qualified form of the type of the binding, or a
/// reference to such a type).
void setBinding(QualType DeclaredType, Expr *Binding) {
  setType(DeclaredType);
  this->Binding = Binding;
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Decl::Binding; }
3815};

3817/// A decomposition declaration. For instance, given:
3818///
3819///   int n[3];
3820///   auto &[a, b, c] = n;
3821///
3822/// the second line declares a DecompositionDecl of type 'int (&)[3]', and
3823/// three BindingDecls (named a, b, and c). An instance of this class is always
3824/// unnamed, but behaves in almost all other respects like a VarDecl.
3825class DecompositionDecl final
  : public VarDecl,
    private llvm::TrailingObjects<DecompositionDecl, BindingDecl *> {
/// The number of BindingDecl*s following this object.
unsigned NumBindings;

DecompositionDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                  SourceLocation LSquareLoc, QualType T,
                  TypeSourceInfo *TInfo, StorageClass SC,
                  ArrayRef<BindingDecl *> Bindings)
    : VarDecl(Decomposition, C, DC, StartLoc, LSquareLoc, nullptr, T, TInfo,
              SC),
      NumBindings(Bindings.size()) {
  std::uninitialized_copy(Bindings.begin(), Bindings.end(),
                          getTrailingObjects<BindingDecl *>());
}

void anchor() override;

3844public:
friend class ASTDeclReader;
friend TrailingObjects;

static DecompositionDecl *Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation StartLoc,
                                 SourceLocation LSquareLoc,
                                 QualType T, TypeSourceInfo *TInfo,
                                 StorageClass S,
                                 ArrayRef<BindingDecl *> Bindings);
static DecompositionDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                             unsigned NumBindings);

ArrayRef<BindingDecl *> bindings() const {
  return llvm::makeArrayRef(getTrailingObjects<BindingDecl *>(), NumBindings);
}

void printName(raw_ostream &os) const override;

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Decomposition; }
3865};

3867/// An instance of this class represents the declaration of a property
3868/// member.  This is a Microsoft extension to C++, first introduced in
3869/// Visual Studio .NET 2003 as a parallel to similar features in C#
3870/// and Managed C++.
3871///
3872/// A property must always be a non-static class member.
3873///
3874/// A property member superficially resembles a non-static data
3875/// member, except preceded by a property attribute:
3876///   __declspec(property(get=GetX, put=PutX)) int x;
3877/// Either (but not both) of the 'get' and 'put' names may be omitted.
3878///
3879/// A reference to a property is always an lvalue.  If the lvalue
3880/// undergoes lvalue-to-rvalue conversion, then a getter name is
3881/// required, and that member is called with no arguments.
3882/// If the lvalue is assigned into, then a setter name is required,
3883/// and that member is called with one argument, the value assigned.
3884/// Both operations are potentially overloaded.  Compound assignments
3885/// are permitted, as are the increment and decrement operators.
3886///
3887/// The getter and putter methods are permitted to be overloaded,
3888/// although their return and parameter types are subject to certain
3889/// restrictions according to the type of the property.
3890///
3891/// A property declared using an incomplete array type may
3892/// additionally be subscripted, adding extra parameters to the getter
3893/// and putter methods.
3894class MSPropertyDecl : public DeclaratorDecl {
IdentifierInfo *GetterId, *SetterId;

MSPropertyDecl(DeclContext *DC, SourceLocation L, DeclarationName N,
               QualType T, TypeSourceInfo *TInfo, SourceLocation StartL,
               IdentifierInfo *Getter, IdentifierInfo *Setter)
    : DeclaratorDecl(MSProperty, DC, L, N, T, TInfo, StartL),
      GetterId(Getter), SetterId(Setter) {}

3903public:
friend class ASTDeclReader;

static MSPropertyDecl *Create(ASTContext &C, DeclContext *DC,
                              SourceLocation L, DeclarationName N, QualType T,
                              TypeSourceInfo *TInfo, SourceLocation StartL,
                              IdentifierInfo *Getter, IdentifierInfo *Setter);
static MSPropertyDecl *CreateDeserialized(ASTContext &C, unsigned ID);

static bool classof(const Decl *D) { return D->getKind() == MSProperty; }

bool hasGetter() const { return GetterId != nullptr; }
IdentifierInfo* getGetterId() const { return GetterId; }
bool hasSetter() const { return SetterId != nullptr; }
IdentifierInfo* getSetterId() const { return SetterId; }
3918};

3920/// Insertion operator for diagnostics.  This allows sending an AccessSpecifier
3921/// into a diagnostic with <<.
3922const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                  AccessSpecifier AS);

3925const PartialDiagnostic &operator<<(const PartialDiagnostic &DB,
                                  AccessSpecifier AS);

3928} // namespace clang

3930#endif // LLVM_CLANG_AST_DECLCXX_H

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h

→

1//===- Decl.h - Classes for representing declarations -----------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file defines the Decl subclasses.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_CLANG_AST_DECL_H
15#define LLVM_CLANG_AST_DECL_H

17#include "clang/AST/APValue.h"
18#include "clang/AST/DeclBase.h"
19#include "clang/AST/DeclarationName.h"
20#include "clang/AST/ExternalASTSource.h"
21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/Redeclarable.h"
23#include "clang/AST/Type.h"
24#include "clang/Basic/AddressSpaces.h"
25#include "clang/Basic/Diagnostic.h"
26#include "clang/Basic/IdentifierTable.h"
27#include "clang/Basic/LLVM.h"
28#include "clang/Basic/Linkage.h"
29#include "clang/Basic/OperatorKinds.h"
30#include "clang/Basic/PartialDiagnostic.h"
31#include "clang/Basic/PragmaKinds.h"
32#include "clang/Basic/SourceLocation.h"
33#include "clang/Basic/Specifiers.h"
34#include "clang/Basic/Visibility.h"
35#include "llvm/ADT/APSInt.h"
36#include "llvm/ADT/ArrayRef.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/iterator_range.h"
42#include "llvm/Support/Casting.h"
43#include "llvm/Support/Compiler.h"
44#include "llvm/Support/TrailingObjects.h"
45#include <cassert>
46#include <cstddef>
47#include <cstdint>
48#include <string>
49#include <utility>

51namespace clang {

53class ASTContext;
54struct ASTTemplateArgumentListInfo;
55class Attr;
56class CompoundStmt;
57class DependentFunctionTemplateSpecializationInfo;
58class EnumDecl;
59class Expr;
60class FunctionTemplateDecl;
61class FunctionTemplateSpecializationInfo;
62class LabelStmt;
63class MemberSpecializationInfo;
64class Module;
65class NamespaceDecl;
66class ParmVarDecl;
67class RecordDecl;
68class Stmt;
69class StringLiteral;
70class TagDecl;
71class TemplateArgumentList;
72class TemplateArgumentListInfo;
73class TemplateParameterList;
74class TypeAliasTemplateDecl;
75class TypeLoc;
76class UnresolvedSetImpl;
77class VarTemplateDecl;

79/// A container of type source information.
80///
81/// A client can read the relevant info using TypeLoc wrappers, e.g:
82/// @code
83/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
84/// TL.getStartLoc().print(OS, SrcMgr);
85/// @endcode
86class LLVM_ALIGNAS(8)alignas(8) TypeSourceInfo {
// Contains a memory block after the class, used for type source information,
// allocated by ASTContext.
friend class ASTContext;

QualType Ty;

TypeSourceInfo(QualType ty) : Ty(ty) {}

95public:
/// Return the type wrapped by this type source info.
QualType getType() const { return Ty; }

/// Return the TypeLoc wrapper for the type source info.
TypeLoc getTypeLoc() const; // implemented in TypeLoc.h

/// Override the type stored in this TypeSourceInfo. Use with caution!
void overrideType(QualType T) { Ty = T; }
104};

106/// The top declaration context.
107class TranslationUnitDecl : public Decl, public DeclContext {
ASTContext &Ctx;

/// The (most recently entered) anonymous namespace for this
/// translation unit, if one has been created.
NamespaceDecl *AnonymousNamespace = nullptr;

explicit TranslationUnitDecl(ASTContext &ctx);

virtual void anchor();

118public:
ASTContext &getASTContext() const { return Ctx; }

NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }

static TranslationUnitDecl *Create(ASTContext &C);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == TranslationUnit; }
static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {
  return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
}
static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
}
135};

137/// Represents a `#pragma comment` line. Always a child of
138/// TranslationUnitDecl.
139class PragmaCommentDecl final
  : public Decl,
    private llvm::TrailingObjects<PragmaCommentDecl, char> {
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

PragmaMSCommentKind CommentKind;

PragmaCommentDecl(TranslationUnitDecl *TU, SourceLocation CommentLoc,
                  PragmaMSCommentKind CommentKind)
    : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}

virtual void anchor();

154public:
static PragmaCommentDecl *Create(const ASTContext &C, TranslationUnitDecl *DC,
                                 SourceLocation CommentLoc,
                                 PragmaMSCommentKind CommentKind,
                                 StringRef Arg);
static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                             unsigned ArgSize);

PragmaMSCommentKind getCommentKind() const { return CommentKind; }

StringRef getArg() const { return getTrailingObjects<char>(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == PragmaComment; }
169};

171/// Represents a `#pragma detect_mismatch` line. Always a child of
172/// TranslationUnitDecl.
173class PragmaDetectMismatchDecl final
  : public Decl,
    private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

size_t ValueStart;

PragmaDetectMismatchDecl(TranslationUnitDecl *TU, SourceLocation Loc,
                         size_t ValueStart)
    : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}

virtual void anchor();

188public:
static PragmaDetectMismatchDecl *Create(const ASTContext &C,
                                        TranslationUnitDecl *DC,
                                        SourceLocation Loc, StringRef Name,
                                        StringRef Value);
static PragmaDetectMismatchDecl *
CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);

StringRef getName() const { return getTrailingObjects<char>(); }
StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
202};

204/// Declaration context for names declared as extern "C" in C++. This
205/// is neither the semantic nor lexical context for such declarations, but is
206/// used to check for conflicts with other extern "C" declarations. Example:
207///
208/// \code
209///   namespace N { extern "C" void f(); } // #1
210///   void N::f() {}                       // #2
211///   namespace M { extern "C" void f(); } // #3
212/// \endcode
213///
214/// The semantic context of #1 is namespace N and its lexical context is the
215/// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
216/// context is the TU. However, both declarations are also visible in the
217/// extern "C" context.
218///
219/// The declaration at #3 finds it is a redeclaration of \c N::f through
220/// lookup in the extern "C" context.
221class ExternCContextDecl : public Decl, public DeclContext {
explicit ExternCContextDecl(TranslationUnitDecl *TU)
  : Decl(ExternCContext, TU, SourceLocation()),
    DeclContext(ExternCContext) {}

virtual void anchor();

228public:
static ExternCContextDecl *Create(const ASTContext &C,
                                  TranslationUnitDecl *TU);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ExternCContext; }
static DeclContext *castToDeclContext(const ExternCContextDecl *D) {
  return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
}
static ExternCContextDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
}
241};

243/// This represents a decl that may have a name.  Many decls have names such
244/// as ObjCMethodDecl, but not \@class, etc.
245///
246/// Note that not every NamedDecl is actually named (e.g., a struct might
247/// be anonymous), and not every name is an identifier.
248class NamedDecl : public Decl {
/// The name of this declaration, which is typically a normal
/// identifier but may also be a special kind of name (C++
/// constructor, Objective-C selector, etc.)
DeclarationName Name;

virtual void anchor();

256private:
NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY__attribute__((__pure__));

259protected:
NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
    : Decl(DK, DC, L), Name(N) {}

263public:
/// Get the identifier that names this declaration, if there is one.
///
/// This will return NULL if this declaration has no name (e.g., for
/// an unnamed class) or if the name is a special name (C++ constructor,
/// Objective-C selector, etc.).
IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }

/// Get the name of identifier for this declaration as a StringRef.
///
/// This requires that the declaration have a name and that it be a simple
/// identifier.
StringRef getName() const {
  assert(Name.isIdentifier() && "Name is not a simple identifier")(static_cast <bool> (Name.isIdentifier() && "Name is not a simple identifier"
) ? void (0) : __assert_fail ("Name.isIdentifier() && \"Name is not a simple identifier\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 276, __extension__ __PRETTY_FUNCTION__));
  return getIdentifier() ? getIdentifier()->getName() : "";
}

/// Get a human-readable name for the declaration, even if it is one of the
/// special kinds of names (C++ constructor, Objective-C selector, etc).
///
/// Creating this name requires expensive string manipulation, so it should
/// be called only when performance doesn't matter. For simple declarations,
/// getNameAsCString() should suffice.
//
// FIXME: This function should be renamed to indicate that it is not just an
// alternate form of getName(), and clients should move as appropriate.
//
// FIXME: Deprecated, move clients to getName().
std::string getNameAsString() const { return Name.getAsString(); }

virtual void printName(raw_ostream &os) const;

/// Get the actual, stored name of the declaration, which may be a special
/// name.
DeclarationName getDeclName() const { return Name; }

/// Set the name of this declaration.
void setDeclName(DeclarationName N) { Name = N; }

/// Returns a human-readable qualified name for this declaration, like
/// A::B::i, for i being member of namespace A::B.
///
/// If the declaration is not a member of context which can be named (record,
/// namespace), it will return the same result as printName().
///
/// Creating this name is expensive, so it should be called only when
/// performance doesn't matter.
void printQualifiedName(raw_ostream &OS) const;
void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;

// FIXME: Remove string version.
std::string getQualifiedNameAsString() const;

/// Appends a human-readable name for this declaration into the given stream.
///
/// This is the method invoked by Sema when displaying a NamedDecl
/// in a diagnostic.  It does not necessarily produce the same
/// result as printName(); for example, class template
/// specializations are printed with their template arguments.
virtual void getNameForDiagnostic(raw_ostream &OS,
                                  const PrintingPolicy &Policy,
                                  bool Qualified) const;

/// Determine whether this declaration, if known to be well-formed within
/// its context, will replace the declaration OldD if introduced into scope.
///
/// A declaration will replace another declaration if, for example, it is
/// a redeclaration of the same variable or function, but not if it is a
/// declaration of a different kind (function vs. class) or an overloaded
/// function.
///
/// \param IsKnownNewer \c true if this declaration is known to be newer
/// than \p OldD (for instance, if this declaration is newly-created).
bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;

/// Determine whether this declaration has linkage.
bool hasLinkage() const;

using Decl::isModulePrivate;
using Decl::setModulePrivate;

/// Determine whether this declaration is a C++ class member.
bool isCXXClassMember() const {
  const DeclContext *DC = getDeclContext();

  // C++0x [class.mem]p1:
  //   The enumerators of an unscoped enumeration defined in
  //   the class are members of the class.
  if (isa<EnumDecl>(DC))
    DC = DC->getRedeclContext();

  return DC->isRecord();
}

/// Determine whether the given declaration is an instance member of
/// a C++ class.
bool isCXXInstanceMember() const;

/// Determine what kind of linkage this entity has.
///
/// This is not the linkage as defined by the standard or the codegen notion
/// of linkage. It is just an implementation detail that is used to compute
/// those.
Linkage getLinkageInternal() const;

/// Get the linkage from a semantic point of view. Entities in
/// anonymous namespaces are external (in c++98).
Linkage getFormalLinkage() const {
  return clang::getFormalLinkage(getLinkageInternal());
}

/// True if this decl has external linkage.
bool hasExternalFormalLinkage() const {
  return isExternalFormalLinkage(getLinkageInternal());
}

bool isExternallyVisible() const {
  return clang::isExternallyVisible(getLinkageInternal());
}

/// Determine whether this declaration can be redeclared in a
/// different translation unit.
bool isExternallyDeclarable() const {
  return isExternallyVisible() && !getOwningModuleForLinkage();
}

/// Determines the visibility of this entity.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Determines the linkage and visibility of this entity.
LinkageInfo getLinkageAndVisibility() const;

/// Kinds of explicit visibility.
enum ExplicitVisibilityKind {
  /// Do an LV computation for, ultimately, a type.
  /// Visibility may be restricted by type visibility settings and
  /// the visibility of template arguments.
  VisibilityForType,

  /// Do an LV computation for, ultimately, a non-type declaration.
  /// Visibility may be restricted by value visibility settings and
  /// the visibility of template arguments.
  VisibilityForValue
};

/// If visibility was explicitly specified for this
/// declaration, return that visibility.
Optional<Visibility>
getExplicitVisibility(ExplicitVisibilityKind kind) const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// True if something has required us to compute the linkage
/// of this declaration.
///
/// Language features which can retroactively change linkage (like a
/// typedef name for linkage purposes) may need to consider this,
/// but hopefully only in transitory ways during parsing.
bool hasLinkageBeenComputed() const {
  return hasCachedLinkage();
}

/// Looks through UsingDecls and ObjCCompatibleAliasDecls for
/// the underlying named decl.
NamedDecl *getUnderlyingDecl() {
  // Fast-path the common case.
  if (this->getKind() != UsingShadow &&
      this->getKind() != ConstructorUsingShadow &&
      this->getKind() != ObjCCompatibleAlias &&
      this->getKind() != NamespaceAlias)
    return this;

  return getUnderlyingDeclImpl();
}
const NamedDecl *getUnderlyingDecl() const {
  return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
}

NamedDecl *getMostRecentDecl() {
  return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
}
const NamedDecl *getMostRecentDecl() const {
  return const_cast<NamedDecl*>(this)->getMostRecentDecl();
}

ObjCStringFormatFamily getObjCFStringFormattingFamily() const;

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
456};

458inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
ND.printName(OS);
return OS;
461}

463/// Represents the declaration of a label.  Labels also have a
464/// corresponding LabelStmt, which indicates the position that the label was
465/// defined at.  For normal labels, the location of the decl is the same as the
466/// location of the statement.  For GNU local labels (__label__), the decl
467/// location is where the __label__ is.
468class LabelDecl : public NamedDecl {
LabelStmt *TheStmt;
StringRef MSAsmName;
bool MSAsmNameResolved = false;

/// For normal labels, this is the same as the main declaration
/// label, i.e., the location of the identifier; for GNU local labels,
/// this is the location of the __label__ keyword.
SourceLocation LocStart;

LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,
          LabelStmt *S, SourceLocation StartL)
    : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}

void anchor() override;

484public:
static LabelDecl *Create(ASTContext &C, DeclContext *DC,
                         SourceLocation IdentL, IdentifierInfo *II);
static LabelDecl *Create(ASTContext &C, DeclContext *DC,
                         SourceLocation IdentL, IdentifierInfo *II,
                         SourceLocation GnuLabelL);
static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);

LabelStmt *getStmt() const { return TheStmt; }
void setStmt(LabelStmt *T) { TheStmt = T; }

bool isGnuLocal() const { return LocStart != getLocation(); }
void setLocStart(SourceLocation L) { LocStart = L; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(LocStart, getLocation());
}

bool isMSAsmLabel() const { return !MSAsmName.empty(); }
bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
void setMSAsmLabel(StringRef Name);
StringRef getMSAsmLabel() const { return MSAsmName; }
void setMSAsmLabelResolved() { MSAsmNameResolved = true; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Label; }
511};

513/// Represent a C++ namespace.
514class NamespaceDecl : public NamedDecl, public DeclContext, 
                    public Redeclarable<NamespaceDecl> 
516{
/// The starting location of the source range, pointing
/// to either the namespace or the inline keyword.
SourceLocation LocStart;

/// The ending location of the source range.
SourceLocation RBraceLoc;

/// A pointer to either the anonymous namespace that lives just inside
/// this namespace or to the first namespace in the chain (the latter case
/// only when this is not the first in the chain), along with a 
/// boolean value indicating whether this is an inline namespace.
llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;

NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
              SourceLocation StartLoc, SourceLocation IdLoc,
              IdentifierInfo *Id, NamespaceDecl *PrevDecl);

using redeclarable_base = Redeclarable<NamespaceDecl>;

NamespaceDecl *getNextRedeclarationImpl() override;
NamespaceDecl *getPreviousDeclImpl() override;
NamespaceDecl *getMostRecentDeclImpl() override;

540public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
                             bool Inline, SourceLocation StartLoc,
                             SourceLocation IdLoc, IdentifierInfo *Id,
                             NamespaceDecl *PrevDecl);

static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

/// Returns true if this is an anonymous namespace declaration.
///
/// For example:
/// \code
///   namespace {
///     ...
///   };
/// \endcode
/// q.v. C++ [namespace.unnamed]
bool isAnonymousNamespace() const {
  return !getIdentifier();
}

/// Returns true if this is an inline namespace declaration.
bool isInline() const {
  return AnonOrFirstNamespaceAndInline.getInt();
}

/// Set whether this is an inline namespace declaration.
void setInline(bool Inline) {
  AnonOrFirstNamespaceAndInline.setInt(Inline);
}

/// Get the original (first) namespace declaration.
NamespaceDecl *getOriginalNamespace();

/// Get the original (first) namespace declaration.
const NamespaceDecl *getOriginalNamespace() const;

/// Return true if this declaration is an original (first) declaration
/// of the namespace. This is false for non-original (subsequent) namespace
/// declarations and anonymous namespaces.
bool isOriginalNamespace() const;

/// Retrieve the anonymous namespace nested inside this namespace,
/// if any.
NamespaceDecl *getAnonymousNamespace() const {
  return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
}

void setAnonymousNamespace(NamespaceDecl *D) {
  getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
}

/// Retrieves the canonical declaration of this namespace.
NamespaceDecl *getCanonicalDecl() override {
  return getOriginalNamespace();
}
const NamespaceDecl *getCanonicalDecl() const {
  return getOriginalNamespace();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(LocStart, RBraceLoc);
}

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setLocStart(SourceLocation L) { LocStart = L; }
void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Namespace; }
static DeclContext *castToDeclContext(const NamespaceDecl *D) {
  return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
}
static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
}
631};

633/// Represent the declaration of a variable (in which case it is
634/// an lvalue) a function (in which case it is a function designator) or
635/// an enum constant.
636class ValueDecl : public NamedDecl {
QualType DeclType;

void anchor() override;

641protected:
ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
          DeclarationName N, QualType T)
  : NamedDecl(DK, DC, L, N), DeclType(T) {}

646public:
QualType getType() const { return DeclType; }
void setType(QualType newType) { DeclType = newType; }

/// Determine whether this symbol is weakly-imported,
///        or declared with the weak or weak-ref attr.
bool isWeak() const;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
657};

659/// A struct with extended info about a syntactic
660/// name qualifier, to be used for the case of out-of-line declarations.
661struct QualifierInfo {
NestedNameSpecifierLoc QualifierLoc;

/// The number of "outer" template parameter lists.
/// The count includes all of the template parameter lists that were matched
/// against the template-ids occurring into the NNS and possibly (in the
/// case of an explicit specialization) a final "template <>".
unsigned NumTemplParamLists = 0;

/// A new-allocated array of size NumTemplParamLists,
/// containing pointers to the "outer" template parameter lists.
/// It includes all of the template parameter lists that were matched
/// against the template-ids occurring into the NNS and possibly (in the
/// case of an explicit specialization) a final "template <>".
TemplateParameterList** TemplParamLists = nullptr;

QualifierInfo() = default;
QualifierInfo(const QualifierInfo &) = delete;
QualifierInfo& operator=(const QualifierInfo &) = delete;

/// Sets info about "outer" template parameter lists.
void setTemplateParameterListsInfo(ASTContext &Context,
                                   ArrayRef<TemplateParameterList *> TPLists);
684};

686/// Represents a ValueDecl that came out of a declarator.
687/// Contains type source information through TypeSourceInfo.
688class DeclaratorDecl : public ValueDecl {
// A struct representing both a TInfo and a syntactic qualifier,
// to be used for the (uncommon) case of out-of-line declarations.
struct ExtInfo : public QualifierInfo {
  TypeSourceInfo *TInfo;
};

llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;

/// The start of the source range for this declaration,
/// ignoring outer template declarations.
SourceLocation InnerLocStart;

bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }

705protected:
DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,
               DeclarationName N, QualType T, TypeSourceInfo *TInfo,
               SourceLocation StartL)
    : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}

711public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

TypeSourceInfo *getTypeSourceInfo() const {
  return hasExtInfo()
    ? getExtInfo()->TInfo
    : DeclInfo.get<TypeSourceInfo*>();
}

void setTypeSourceInfo(TypeSourceInfo *TI) {
  if (hasExtInfo())
    getExtInfo()->TInfo = TI;
  else
    DeclInfo = TI;
}

/// Return start of source range ignoring outer template declarations.
SourceLocation getInnerLocStart() const { return InnerLocStart; }
void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }

/// Return start of source range taking into account any outer template
/// declarations.
SourceLocation getOuterLocStart() const;

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) {
  return getOuterLocStart();
}

/// Retrieve the nested-name-specifier that qualifies the name of this
/// declaration, if it was present in the source.
NestedNameSpecifier *getQualifier() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
                      : nullptr;
}

/// Retrieve the nested-name-specifier (with source-location
/// information) that qualifies the name of this declaration, if it was
/// present in the source.
NestedNameSpecifierLoc getQualifierLoc() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc
                      : NestedNameSpecifierLoc();
}

void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);

unsigned getNumTemplateParameterLists() const {
  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
}

TemplateParameterList *getTemplateParameterList(unsigned index) const {
  assert(index < getNumTemplateParameterLists())(static_cast <bool> (index < getNumTemplateParameterLists
()) ? void (0) : __assert_fail ("index < getNumTemplateParameterLists()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 764, __extension__ __PRETTY_FUNCTION__));
  return getExtInfo()->TemplParamLists[index];
}

void setTemplateParameterListsInfo(ASTContext &Context,
                                   ArrayRef<TemplateParameterList *> TPLists);

SourceLocation getTypeSpecStartLoc() const;

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstDeclarator && K <= lastDeclarator;
}
778};

780/// Structure used to store a statement, the constant value to
781/// which it was evaluated (if any), and whether or not the statement
782/// is an integral constant expression (if known).
783struct EvaluatedStmt {
/// Whether this statement was already evaluated.
bool WasEvaluated : 1;

/// Whether this statement is being evaluated.
bool IsEvaluating : 1;

/// Whether we already checked whether this statement was an
/// integral constant expression.
bool CheckedICE : 1;

/// Whether we are checking whether this statement is an
/// integral constant expression.
bool CheckingICE : 1;

/// Whether this statement is an integral constant expression,
/// or in C++11, whether the statement is a constant expression. Only
/// valid if CheckedICE is true.
bool IsICE : 1;

Stmt *Value;
APValue Evaluated;

EvaluatedStmt() : WasEvaluated(false), IsEvaluating(false), CheckedICE(false),
                  CheckingICE(false), IsICE(false) {}

809};

811/// Represents a variable declaration or definition.
812class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
813public:
/// Initialization styles.
enum InitializationStyle {
  /// C-style initialization with assignment
  CInit,

  /// Call-style initialization (C++98)
  CallInit,

  /// Direct list-initialization (C++11)
  ListInit
};

/// Kinds of thread-local storage.
enum TLSKind {
  /// Not a TLS variable.
  TLS_None,

  /// TLS with a known-constant initializer.
  TLS_Static,

  /// TLS with a dynamic initializer.
  TLS_Dynamic
};

/// Return the string used to specify the storage class \p SC.
///
/// It is illegal to call this function with SC == None.
static const char *getStorageClassSpecifierString(StorageClass SC);

843protected:
// A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
// have allocated the auxiliary struct of information there.
//
// TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
// this as *many* VarDecls are ParmVarDecls that don't have default
// arguments. We could save some space by moving this pointer union to be
// allocated in trailing space when necessary.
using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;

/// The initializer for this variable or, for a ParmVarDecl, the
/// C++ default argument.
mutable InitType Init;

857private:
friend class ASTDeclReader;
friend class ASTNodeImporter;
friend class StmtIteratorBase;

class VarDeclBitfields {
  friend class ASTDeclReader;
  friend class VarDecl;

  unsigned SClass : 3;
  unsigned TSCSpec : 2;
  unsigned InitStyle : 2;
};
enum { NumVarDeclBits = 7 };

872protected:
enum { NumParameterIndexBits = 8 };

enum DefaultArgKind {
  DAK_None,
  DAK_Unparsed,
  DAK_Uninstantiated,
  DAK_Normal
};

class ParmVarDeclBitfields {
  friend class ASTDeclReader;
  friend class ParmVarDecl;

  unsigned : NumVarDeclBits;

  /// Whether this parameter inherits a default argument from a
  /// prior declaration.
  unsigned HasInheritedDefaultArg : 1;

  /// Describes the kind of default argument for this parameter. By default
  /// this is none. If this is normal, then the default argument is stored in
  /// the \c VarDecl initializer expression unless we were unable to parse
  /// (even an invalid) expression for the default argument.
  unsigned DefaultArgKind : 2;

  /// Whether this parameter undergoes K&R argument promotion.
  unsigned IsKNRPromoted : 1;

  /// Whether this parameter is an ObjC method parameter or not.
  unsigned IsObjCMethodParam : 1;

  /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
  /// Otherwise, the number of function parameter scopes enclosing
  /// the function parameter scope in which this parameter was
  /// declared.
  unsigned ScopeDepthOrObjCQuals : 7;

  /// The number of parameters preceding this parameter in the
  /// function parameter scope in which it was declared.
  unsigned ParameterIndex : NumParameterIndexBits;
};

class NonParmVarDeclBitfields {
  friend class ASTDeclReader;
  friend class ImplicitParamDecl;
  friend class VarDecl;

  unsigned : NumVarDeclBits;

  // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
  /// Whether this variable is a definition which was demoted due to
  /// module merge.
  unsigned IsThisDeclarationADemotedDefinition : 1;

  /// Whether this variable is the exception variable in a C++ catch
  /// or an Objective-C @catch statement.
  unsigned ExceptionVar : 1;

  /// Whether this local variable could be allocated in the return
  /// slot of its function, enabling the named return value optimization
  /// (NRVO).
  unsigned NRVOVariable : 1;

  /// Whether this variable is the for-range-declaration in a C++0x
  /// for-range statement.
  unsigned CXXForRangeDecl : 1;

  /// Whether this variable is an ARC pseudo-__strong
  /// variable;  see isARCPseudoStrong() for details.
  unsigned ARCPseudoStrong : 1;

  /// Whether this variable is (C++1z) inline.
  unsigned IsInline : 1;

  /// Whether this variable has (C++1z) inline explicitly specified.
  unsigned IsInlineSpecified : 1;

  /// Whether this variable is (C++0x) constexpr.
  unsigned IsConstexpr : 1;

  /// Whether this variable is the implicit variable for a lambda
  /// init-capture.
  unsigned IsInitCapture : 1;

  /// Whether this local extern variable's previous declaration was
  /// declared in the same block scope. This controls whether we should merge
  /// the type of this declaration with its previous declaration.
  unsigned PreviousDeclInSameBlockScope : 1;

  /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
  /// something else.
  unsigned ImplicitParamKind : 3;
};

union {
  unsigned AllBits;
  VarDeclBitfields VarDeclBits;
  ParmVarDeclBitfields ParmVarDeclBits;
  NonParmVarDeclBitfields NonParmVarDeclBits;
};

VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
        SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
        TypeSourceInfo *TInfo, StorageClass SC);

using redeclarable_base = Redeclarable<VarDecl>;

VarDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

VarDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

VarDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

992public:
using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

static VarDecl *Create(ASTContext &C, DeclContext *DC,
                       SourceLocation StartLoc, SourceLocation IdLoc,
                       IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
                       StorageClass S);

static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Returns the storage class as written in the source. For the
/// computed linkage of symbol, see getLinkage.
StorageClass getStorageClass() const {
  return (StorageClass) VarDeclBits.SClass;
}
void setStorageClass(StorageClass SC);

void setTSCSpec(ThreadStorageClassSpecifier TSC) {
  VarDeclBits.TSCSpec = TSC;
  assert(VarDeclBits.TSCSpec == TSC && "truncation")(static_cast <bool> (VarDeclBits.TSCSpec == TSC &&
 "truncation") ? void (0) : __assert_fail ("VarDeclBits.TSCSpec == TSC && \"truncation\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1021, __extension__ __PRETTY_FUNCTION__));
}
ThreadStorageClassSpecifier getTSCSpec() const {
  return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
}
TLSKind getTLSKind() const;

/// Returns true if a variable with function scope is a non-static local
/// variable.
bool hasLocalStorage() const {
  if (getStorageClass() == SC_None) {
    // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
    // used to describe variables allocated in global memory and which are
    // accessed inside a kernel(s) as read-only variables. As such, variables
    // in constant address space cannot have local storage.
    if (getType().getAddressSpace() == LangAS::opencl_constant)
      return false;
    // Second check is for C++11 [dcl.stc]p4.
    return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
  }

  // Global Named Register (GNU extension)
  if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
    return false;

  // Return true for:  Auto, Register.
  // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.

  return getStorageClass() >= SC_Auto;
}

/// Returns true if a variable with function scope is a static local
/// variable.
bool isStaticLocal() const {
  return (getStorageClass() == SC_Static ||
          // C++11 [dcl.stc]p4
          (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
    && !isFileVarDecl();
}

/// Returns true if a variable has extern or __private_extern__
/// storage.
bool hasExternalStorage() const {
  return getStorageClass() == SC_Extern ||
         getStorageClass() == SC_PrivateExtern;
}

/// Returns true for all variables that do not have local storage.
///
/// This includes all global variables as well as static variables declared
/// within a function.
bool hasGlobalStorage() const { return !hasLocalStorage(); }

/// Get the storage duration of this variable, per C++ [basic.stc].
StorageDuration getStorageDuration() const {
  return hasLocalStorage() ? SD_Automatic :
         getTSCSpec() ? SD_Thread : SD_Static;
}

/// Compute the language linkage.
LanguageLinkage getLanguageLinkage() const;

/// Determines whether this variable is a variable with external, C linkage.
bool isExternC() const;

/// Determines whether this variable's context is, or is nested within,
/// a C++ extern "C" linkage spec.
bool isInExternCContext() const;

/// Determines whether this variable's context is, or is nested within,
/// a C++ extern "C++" linkage spec.
bool isInExternCXXContext() const;

/// Returns true for local variable declarations other than parameters.
/// Note that this includes static variables inside of functions. It also
/// includes variables inside blocks.
///
///   void foo() { int x; static int y; extern int z; }
bool isLocalVarDecl() const {
  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
    return false;
  if (const DeclContext *DC = getLexicalDeclContext())
    return DC->getRedeclContext()->isFunctionOrMethod();
  return false;
}

/// Similar to isLocalVarDecl but also includes parameters.
bool isLocalVarDeclOrParm() const {
  return isLocalVarDecl() || getKind() == Decl::ParmVar;
}

/// Similar to isLocalVarDecl, but excludes variables declared in blocks.
bool isFunctionOrMethodVarDecl() const {
  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
    return false;
  const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
  return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
}

/// Determines whether this is a static data member.
///
/// This will only be true in C++, and applies to, e.g., the
/// variable 'x' in:
/// \code
/// struct S {
///   static int x;
/// };
/// \endcode
bool isStaticDataMember() const {
  // If it wasn't static, it would be a FieldDecl.
  return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
}

VarDecl *getCanonicalDecl() override;
const VarDecl *getCanonicalDecl() const {
  return const_cast<VarDecl*>(this)->getCanonicalDecl();
}

enum DefinitionKind {
  /// This declaration is only a declaration.
  DeclarationOnly,

  /// This declaration is a tentative definition.
  TentativeDefinition,

  /// This declaration is definitely a definition.
  Definition
};

/// Check whether this declaration is a definition. If this could be
/// a tentative definition (in C), don't check whether there's an overriding
/// definition.
DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
DefinitionKind isThisDeclarationADefinition() const {
  return isThisDeclarationADefinition(getASTContext());
}

/// Check whether this variable is defined in this translation unit.
DefinitionKind hasDefinition(ASTContext &) const;
DefinitionKind hasDefinition() const {
  return hasDefinition(getASTContext());
}

/// Get the tentative definition that acts as the real definition in a TU.
/// Returns null if there is a proper definition available.
VarDecl *getActingDefinition();
const VarDecl *getActingDefinition() const {
  return const_cast<VarDecl*>(this)->getActingDefinition();
}

/// Get the real (not just tentative) definition for this declaration.
VarDecl *getDefinition(ASTContext &);
const VarDecl *getDefinition(ASTContext &C) const {
  return const_cast<VarDecl*>(this)->getDefinition(C);
}
VarDecl *getDefinition() {
  return getDefinition(getASTContext());
}
const VarDecl *getDefinition() const {
  return const_cast<VarDecl*>(this)->getDefinition();
}

/// Determine whether this is or was instantiated from an out-of-line
/// definition of a static data member.
bool isOutOfLine() const override;

/// Returns true for file scoped variable declaration.
bool isFileVarDecl() const {
  Kind K = getKind();
  if (K == ParmVar || K == ImplicitParam)
    return false;

  if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
    return true;

  if (isStaticDataMember())
    return true;

  return false;
}

/// Get the initializer for this variable, no matter which
/// declaration it is attached to.
const Expr *getAnyInitializer() const {
  const VarDecl *D;
  return getAnyInitializer(D);
}

/// Get the initializer for this variable, no matter which
/// declaration it is attached to. Also get that declaration.
const Expr *getAnyInitializer(const VarDecl *&D) const;

bool hasInit() const;
const Expr *getInit() const {
  return const_cast<VarDecl *>(this)->getInit();
}
Expr *getInit();

/// Retrieve the address of the initializer expression.
Stmt **getInitAddress();

void setInit(Expr *I);

/// Determine whether this variable's value can be used in a
/// constant expression, according to the relevant language standard.
/// This only checks properties of the declaration, and does not check
/// whether the initializer is in fact a constant expression.
bool isUsableInConstantExpressions(ASTContext &C) const;

EvaluatedStmt *ensureEvaluatedStmt() const;

/// \brief Attempt to evaluate the value of the initializer attached to this
/// declaration, and produce notes explaining why it cannot be evaluated or is
/// not a constant expression. Returns a pointer to the value if evaluation
/// succeeded, 0 otherwise.
APValue *evaluateValue() const;
APValue *evaluateValue(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;

/// \brief Return the already-evaluated value of this variable's
/// initializer, or NULL if the value is not yet known. Returns pointer
/// to untyped APValue if the value could not be evaluated.
APValue *getEvaluatedValue() const;

/// \brief Determines whether it is already known whether the
/// initializer is an integral constant expression or not.
bool isInitKnownICE() const;

/// \brief Determines whether the initializer is an integral constant
/// expression, or in C++11, whether the initializer is a constant
/// expression.
///
/// \pre isInitKnownICE()
bool isInitICE() const;

/// \brief Determine whether the value of the initializer attached to this
/// declaration is an integral constant expression.
bool checkInitIsICE() const;

void setInitStyle(InitializationStyle Style) {
  VarDeclBits.InitStyle = Style;
}

/// \brief The style of initialization for this declaration.
///
/// C-style initialization is "int x = 1;". Call-style initialization is
/// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
/// the expression inside the parens or a "ClassType(a,b,c)" class constructor
/// expression for class types. List-style initialization is C++11 syntax,
/// e.g. "int x{1};". Clients can distinguish between different forms of
/// initialization by checking this value. In particular, "int x = {1};" is
/// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
/// Init expression in all three cases is an InitListExpr.
InitializationStyle getInitStyle() const {
  return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
}

/// \brief Whether the initializer is a direct-initializer (list or call).
bool isDirectInit() const {
  return getInitStyle() != CInit;
}

/// \brief If this definition should pretend to be a declaration.
bool isThisDeclarationADemotedDefinition() const {
  return isa<ParmVarDecl>(this) ? false :
    NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
}

/// \brief This is a definition which should be demoted to a declaration.
///
/// In some cases (mostly module merging) we can end up with two visible
/// definitions one of which needs to be demoted to a declaration to keep
/// the AST invariants.
void demoteThisDefinitionToDeclaration() {
  assert(isThisDeclarationADefinition() && "Not a definition!")(static_cast <bool> (isThisDeclarationADefinition() &&
 "Not a definition!") ? void (0) : __assert_fail ("isThisDeclarationADefinition() && \"Not a definition!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1294, __extension__ __PRETTY_FUNCTION__));
  assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!")(static_cast <bool> (!isa<ParmVarDecl>(this) &&
 "Cannot demote ParmVarDecls!") ? void (0) : __assert_fail ("!isa<ParmVarDecl>(this) && \"Cannot demote ParmVarDecls!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1295, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
}

/// \brief Determine whether this variable is the exception variable in a
/// C++ catch statememt or an Objective-C \@catch statement.
bool isExceptionVariable() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
}
void setExceptionVariable(bool EV) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1305, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.ExceptionVar = EV;
}

/// \brief Determine whether this local variable can be used with the named
/// return value optimization (NRVO).
///
/// The named return value optimization (NRVO) works by marking certain
/// non-volatile local variables of class type as NRVO objects. These
/// locals can be allocated within the return slot of their containing
/// function, in which case there is no need to copy the object to the
/// return slot when returning from the function. Within the function body,
/// each return that returns the NRVO object will have this variable as its
/// NRVO candidate.
bool isNRVOVariable() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
}
void setNRVOVariable(bool NRVO) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1323, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.NRVOVariable = NRVO;
}

/// \brief Determine whether this variable is the for-range-declaration in
/// a C++0x for-range statement.
bool isCXXForRangeDecl() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
}
void setCXXForRangeDecl(bool FRD) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1333, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.CXXForRangeDecl = FRD;
}

/// \brief Determine whether this variable is an ARC pseudo-__strong
/// variable.  A pseudo-__strong variable has a __strong-qualified
/// type but does not actually retain the object written into it.
/// Generally such variables are also 'const' for safety.
bool isARCPseudoStrong() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ARCPseudoStrong;
}
void setARCPseudoStrong(bool ps) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1345, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.ARCPseudoStrong = ps;
}

/// Whether this variable is (C++1z) inline.
bool isInline() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
}
bool isInlineSpecified() const {
  return isa<ParmVarDecl>(this) ? false
                                : NonParmVarDeclBits.IsInlineSpecified;
}
void setInlineSpecified() {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1358, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsInline = true;
  NonParmVarDeclBits.IsInlineSpecified = true;
}
void setImplicitlyInline() {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1363, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsInline = true;
}

/// Whether this variable is (C++11) constexpr.
bool isConstexpr() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
}
void setConstexpr(bool IC) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1372, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsConstexpr = IC;
}

/// Whether this variable is the implicit variable for a lambda init-capture.
bool isInitCapture() const {
  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
}
void setInitCapture(bool IC) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1381, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.IsInitCapture = IC;
}

/// Whether this local extern variable declaration's previous declaration
/// was declared in the same block scope. Only correct in C++.
bool isPreviousDeclInSameBlockScope() const {
  return isa<ParmVarDecl>(this)
             ? false
             : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
}
void setPreviousDeclInSameBlockScope(bool Same) {
  assert(!isa<ParmVarDecl>(this))(static_cast <bool> (!isa<ParmVarDecl>(this)) ? void
 (0) : __assert_fail ("!isa<ParmVarDecl>(this)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1393, __extension__ __PRETTY_FUNCTION__));
  NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
}

/// \brief Retrieve the variable declaration from which this variable could
/// be instantiated, if it is an instantiation (rather than a non-template).
VarDecl *getTemplateInstantiationPattern() const;

/// \brief If this variable is an instantiated static data member of a
/// class template specialization, returns the templated static data member
/// from which it was instantiated.
VarDecl *getInstantiatedFromStaticDataMember() const;

/// \brief If this variable is an instantiation of a variable template or a
/// static data member of a class template, determine what kind of
/// template specialization or instantiation this is.
TemplateSpecializationKind getTemplateSpecializationKind() const;

/// \brief If this variable is an instantiation of a variable template or a
/// static data member of a class template, determine its point of
/// instantiation.
SourceLocation getPointOfInstantiation() const;

/// \brief If this variable is an instantiation of a static data member of a
/// class template specialization, retrieves the member specialization
/// information.
MemberSpecializationInfo *getMemberSpecializationInfo() const;

/// \brief For a static data member that was instantiated from a static
/// data member of a class template, set the template specialiation kind.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

/// \brief Specify that this variable is an instantiation of the
/// static data member VD.
void setInstantiationOfStaticDataMember(VarDecl *VD,
                                        TemplateSpecializationKind TSK);

/// \brief Retrieves the variable template that is described by this
/// variable declaration.
///
/// Every variable template is represented as a VarTemplateDecl and a
/// VarDecl. The former contains template properties (such as
/// the template parameter lists) while the latter contains the
/// actual description of the template's
/// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
/// VarDecl that from a VarTemplateDecl, while
/// getDescribedVarTemplate() retrieves the VarTemplateDecl from
/// a VarDecl.
VarTemplateDecl *getDescribedVarTemplate() const;

void setDescribedVarTemplate(VarTemplateDecl *Template);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1449};

1451class ImplicitParamDecl : public VarDecl {
void anchor() override;

1454public:
/// Defines the kind of the implicit parameter: is this an implicit parameter
/// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
/// context or something else.
enum ImplicitParamKind : unsigned {
  /// Parameter for Objective-C 'self' argument
  ObjCSelf,

  /// Parameter for Objective-C '_cmd' argument
  ObjCCmd,

  /// Parameter for C++ 'this' argument
  CXXThis,

  /// Parameter for C++ virtual table pointers
  CXXVTT,

  /// Parameter for captured context
  CapturedContext,

  /// Other implicit parameter
  Other,
};

/// Create implicit parameter.
static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation IdLoc, IdentifierInfo *Id,
                                 QualType T, ImplicitParamKind ParamKind);
static ImplicitParamDecl *Create(ASTContext &C, QualType T,
                                 ImplicitParamKind ParamKind);

static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);

ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
                  IdentifierInfo *Id, QualType Type,
                  ImplicitParamKind ParamKind)
    : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
              /*TInfo=*/nullptr, SC_None) {
  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
  setImplicit();
}

ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
    : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
              SourceLocation(), /*Id=*/nullptr, Type,
              /*TInfo=*/nullptr, SC_None) {
  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
  setImplicit();
}

/// Returns the implicit parameter kind.
ImplicitParamKind getParameterKind() const {
  return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ImplicitParam; }
1512};

1514/// Represents a parameter to a function.
1515class ParmVarDecl : public VarDecl {
1516public:
enum { MaxFunctionScopeDepth = 255 };
enum { MaxFunctionScopeIndex = 255 };

1520protected:
ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
            SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
            TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
    : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
  assert(ParmVarDeclBits.HasInheritedDefaultArg == false)(static_cast <bool> (ParmVarDeclBits.HasInheritedDefaultArg
 == false) ? void (0) : __assert_fail ("ParmVarDeclBits.HasInheritedDefaultArg == false"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1525, __extension__ __PRETTY_FUNCTION__));
  assert(ParmVarDeclBits.DefaultArgKind == DAK_None)(static_cast <bool> (ParmVarDeclBits.DefaultArgKind == DAK_None
) ? void (0) : __assert_fail ("ParmVarDeclBits.DefaultArgKind == DAK_None"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1526, __extension__ __PRETTY_FUNCTION__));
  assert(ParmVarDeclBits.IsKNRPromoted == false)(static_cast <bool> (ParmVarDeclBits.IsKNRPromoted == false
) ? void (0) : __assert_fail ("ParmVarDeclBits.IsKNRPromoted == false"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1527, __extension__ __PRETTY_FUNCTION__));
  assert(ParmVarDeclBits.IsObjCMethodParam == false)(static_cast <bool> (ParmVarDeclBits.IsObjCMethodParam ==
 false) ? void (0) : __assert_fail ("ParmVarDeclBits.IsObjCMethodParam == false"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1528, __extension__ __PRETTY_FUNCTION__));
  setDefaultArg(DefArg);
}

1532public:
static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
                           SourceLocation StartLoc,
                           SourceLocation IdLoc, IdentifierInfo *Id,
                           QualType T, TypeSourceInfo *TInfo,
                           StorageClass S, Expr *DefArg);

static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

void setObjCMethodScopeInfo(unsigned parameterIndex) {
  ParmVarDeclBits.IsObjCMethodParam = true;
  setParameterIndex(parameterIndex);
}

void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
  assert(!ParmVarDeclBits.IsObjCMethodParam)(static_cast <bool> (!ParmVarDeclBits.IsObjCMethodParam
) ? void (0) : __assert_fail ("!ParmVarDeclBits.IsObjCMethodParam"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1549, __extension__ __PRETTY_FUNCTION__));

  ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
  assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth(static_cast <bool> (ParmVarDeclBits.ScopeDepthOrObjCQuals
 == scopeDepth && "truncation!") ? void (0) : __assert_fail
 ("ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth && \"truncation!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1553, __extension__ __PRETTY_FUNCTION__))
         && "truncation!")(static_cast <bool> (ParmVarDeclBits.ScopeDepthOrObjCQuals
 == scopeDepth && "truncation!") ? void (0) : __assert_fail
 ("ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth && \"truncation!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1553, __extension__ __PRETTY_FUNCTION__));

  setParameterIndex(parameterIndex);
}

bool isObjCMethodParameter() const {
  return ParmVarDeclBits.IsObjCMethodParam;
}

unsigned getFunctionScopeDepth() const {
  if (ParmVarDeclBits.IsObjCMethodParam) return 0;
  return ParmVarDeclBits.ScopeDepthOrObjCQuals;
}

/// Returns the index of this parameter in its prototype or method scope.
unsigned getFunctionScopeIndex() const {
  return getParameterIndex();
}

ObjCDeclQualifier getObjCDeclQualifier() const {
  if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
  return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
}
void setObjCDeclQualifier(ObjCDeclQualifier QTVal) {
  assert(ParmVarDeclBits.IsObjCMethodParam)(static_cast <bool> (ParmVarDeclBits.IsObjCMethodParam)
 ? void (0) : __assert_fail ("ParmVarDeclBits.IsObjCMethodParam"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1577, __extension__ __PRETTY_FUNCTION__));
  ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
}

/// True if the value passed to this parameter must undergo
/// K&R-style default argument promotion:
///
/// C99 6.5.2.2.
///   If the expression that denotes the called function has a type
///   that does not include a prototype, the integer promotions are
///   performed on each argument, and arguments that have type float
///   are promoted to double.
bool isKNRPromoted() const {
  return ParmVarDeclBits.IsKNRPromoted;
}
void setKNRPromoted(bool promoted) {
  ParmVarDeclBits.IsKNRPromoted = promoted;
}

Expr *getDefaultArg();
const Expr *getDefaultArg() const {
  return const_cast<ParmVarDecl *>(this)->getDefaultArg();
}

void setDefaultArg(Expr *defarg);

/// \brief Retrieve the source range that covers the entire default
/// argument.
SourceRange getDefaultArgRange() const;
void setUninstantiatedDefaultArg(Expr *arg);
Expr *getUninstantiatedDefaultArg();
const Expr *getUninstantiatedDefaultArg() const {
  return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
}

/// Determines whether this parameter has a default argument,
/// either parsed or not.
bool hasDefaultArg() const;

/// Determines whether this parameter has a default argument that has not
/// yet been parsed. This will occur during the processing of a C++ class
/// whose member functions have default arguments, e.g.,
/// @code
///   class X {
///   public:
///     void f(int x = 17); // x has an unparsed default argument now
///   }; // x has a regular default argument now
/// @endcode
bool hasUnparsedDefaultArg() const {
  return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
}

bool hasUninstantiatedDefaultArg() const {
  return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
}

/// Specify that this parameter has an unparsed default argument.
/// The argument will be replaced with a real default argument via
/// setDefaultArg when the class definition enclosing the function
/// declaration that owns this default argument is completed.
void setUnparsedDefaultArg() {
  ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
}

bool hasInheritedDefaultArg() const {
  return ParmVarDeclBits.HasInheritedDefaultArg;
}

void setHasInheritedDefaultArg(bool I = true) {
  ParmVarDeclBits.HasInheritedDefaultArg = I;
}

QualType getOriginalType() const;

/// \brief Determine whether this parameter is actually a function
/// parameter pack.
bool isParameterPack() const;

/// Sets the function declaration that owns this
/// ParmVarDecl. Since ParmVarDecls are often created before the
/// FunctionDecls that own them, this routine is required to update
/// the DeclContext appropriately.
void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == ParmVar; }

1665private:
enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };

void setParameterIndex(unsigned parameterIndex) {
  if (parameterIndex >= ParameterIndexSentinel) {
    setParameterIndexLarge(parameterIndex);
    return;
  }

  ParmVarDeclBits.ParameterIndex = parameterIndex;
  assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!")(static_cast <bool> (ParmVarDeclBits.ParameterIndex == parameterIndex
 && "truncation!") ? void (0) : __assert_fail ("ParmVarDeclBits.ParameterIndex == parameterIndex && \"truncation!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 1675, __extension__ __PRETTY_FUNCTION__));
}
unsigned getParameterIndex() const {
  unsigned d = ParmVarDeclBits.ParameterIndex;
  return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
}

void setParameterIndexLarge(unsigned parameterIndex);
unsigned getParameterIndexLarge() const;
1684};

1686/// Represents a function declaration or definition.
1687///
1688/// Since a given function can be declared several times in a program,
1689/// there may be several FunctionDecls that correspond to that
1690/// function. Only one of those FunctionDecls will be found when
1691/// traversing the list of declarations in the context of the
1692/// FunctionDecl (e.g., the translation unit); this FunctionDecl
1693/// contains all of the information known about the function. Other,
1694/// previous declarations of the function are available via the
1695/// getPreviousDecl() chain.
1696class FunctionDecl : public DeclaratorDecl, public DeclContext,
                   public Redeclarable<FunctionDecl> {
1698public:
/// \brief The kind of templated function a FunctionDecl can be.
enum TemplatedKind {
  TK_NonTemplate,
  TK_FunctionTemplate,
  TK_MemberSpecialization,
  TK_FunctionTemplateSpecialization,
  TK_DependentFunctionTemplateSpecialization
};

1708private:
/// A new[]'d array of pointers to VarDecls for the formal
/// parameters of this function.  This is null if a prototype or if there are
/// no formals.
ParmVarDecl **ParamInfo = nullptr;

LazyDeclStmtPtr Body;

// FIXME: This can be packed into the bitfields in DeclContext.
// NOTE: VC++ packs bitfields poorly if the types differ.
unsigned SClass : 3;
unsigned IsInline : 1;
unsigned IsInlineSpecified : 1;

1722protected:
// This is shared by CXXConstructorDecl, CXXConversionDecl, and
// CXXDeductionGuideDecl.
unsigned IsExplicitSpecified : 1;

1727private:
unsigned IsVirtualAsWritten : 1;
unsigned IsPure : 1;
unsigned HasInheritedPrototype : 1;
unsigned HasWrittenPrototype : 1;
unsigned IsDeleted : 1;
unsigned IsTrivial : 1; // sunk from CXXMethodDecl

/// This flag indicates whether this function is trivial for the purpose of
/// calls. This is meaningful only when this function is a copy/move
/// constructor or a destructor.
unsigned IsTrivialForCall : 1;

unsigned IsDefaulted : 1; // sunk from CXXMethoDecl
unsigned IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
unsigned HasImplicitReturnZero : 1;
unsigned IsLateTemplateParsed : 1;
unsigned IsConstexpr : 1;
unsigned InstantiationIsPending : 1;

/// \brief Indicates if the function uses __try.
unsigned UsesSEHTry : 1;

/// \brief Indicates if the function was a definition but its body was
/// skipped.
unsigned HasSkippedBody : 1;

/// Indicates if the function declaration will have a body, once we're done
/// parsing it.
unsigned WillHaveBody : 1;

/// Indicates that this function is a multiversioned function using attribute
/// 'target'.
unsigned IsMultiVersion : 1;

1762protected:
/// [C++17] Only used by CXXDeductionGuideDecl. Declared here to avoid
/// increasing the size of CXXDeductionGuideDecl by the size of an unsigned
/// int as opposed to adding a single bit to FunctionDecl.
/// Indicates that the Deduction Guide is the implicitly generated 'copy
/// deduction candidate' (is used during overload resolution).
unsigned IsCopyDeductionCandidate : 1;

1770private:

/// Store the ODRHash after first calculation.
unsigned HasODRHash : 1;
unsigned ODRHash;

/// \brief End part of this FunctionDecl's source range.
///
/// We could compute the full range in getSourceRange(). However, when we're
/// dealing with a function definition deserialized from a PCH/AST file,
/// we can only compute the full range once the function body has been
/// de-serialized, so it's far better to have the (sometimes-redundant)
/// EndRangeLoc.
SourceLocation EndRangeLoc;

/// \brief The template or declaration that this declaration
/// describes or was instantiated from, respectively.
///
/// For non-templates, this value will be NULL. For function
/// declarations that describe a function template, this will be a
/// pointer to a FunctionTemplateDecl. For member functions
/// of class template specializations, this will be a MemberSpecializationInfo
/// pointer containing information about the specialization.
/// For function template specializations, this will be a
/// FunctionTemplateSpecializationInfo, which contains information about
/// the template being specialized and the template arguments involved in
/// that specialization.
llvm::PointerUnion4<FunctionTemplateDecl *,
                    MemberSpecializationInfo *,
                    FunctionTemplateSpecializationInfo *,
                    DependentFunctionTemplateSpecializationInfo *>
  TemplateOrSpecialization;

/// Provides source/type location info for the declaration name embedded in
/// the DeclaratorDecl base class.
DeclarationNameLoc DNLoc;

/// \brief Specify that this function declaration is actually a function
/// template specialization.
///
/// \param C the ASTContext.
///
/// \param Template the function template that this function template
/// specialization specializes.
///
/// \param TemplateArgs the template arguments that produced this
/// function template specialization from the template.
///
/// \param InsertPos If non-NULL, the position in the function template
/// specialization set where the function template specialization data will
/// be inserted.
///
/// \param TSK the kind of template specialization this is.
///
/// \param TemplateArgsAsWritten location info of template arguments.
///
/// \param PointOfInstantiation point at which the function template
/// specialization was first instantiated.
void setFunctionTemplateSpecialization(ASTContext &C,
                                       FunctionTemplateDecl *Template,
                                     const TemplateArgumentList *TemplateArgs,
                                       void *InsertPos,
                                       TemplateSpecializationKind TSK,
                        const TemplateArgumentListInfo *TemplateArgsAsWritten,
                                       SourceLocation PointOfInstantiation);

/// \brief Specify that this record is an instantiation of the
/// member function FD.
void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
                                      TemplateSpecializationKind TSK);

void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);

1843protected:
FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
             const DeclarationNameInfo &NameInfo, QualType T,
             TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
             bool isConstexprSpecified)
    : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
                     StartLoc),
      DeclContext(DK), redeclarable_base(C), SClass(S),
      IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
      IsExplicitSpecified(false), IsVirtualAsWritten(false), IsPure(false),
      HasInheritedPrototype(false), HasWrittenPrototype(true),
      IsDeleted(false), IsTrivial(false), IsTrivialForCall(false),
      IsDefaulted(false),
      IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
      IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
      InstantiationIsPending(false), UsesSEHTry(false), HasSkippedBody(false),
      WillHaveBody(false), IsMultiVersion(false),
      IsCopyDeductionCandidate(false), HasODRHash(false), ODRHash(0),
      EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {}

using redeclarable_base = Redeclarable<FunctionDecl>;

FunctionDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

FunctionDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

FunctionDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

1877public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
                            SourceLocation StartLoc, SourceLocation NLoc,
                            DeclarationName N, QualType T,
                            TypeSourceInfo *TInfo,
                            StorageClass SC,
                            bool isInlineSpecified = false,
                            bool hasWrittenPrototype = true,
                            bool isConstexprSpecified = false) {
  DeclarationNameInfo NameInfo(N, NLoc);
  return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
                              SC,
                              isInlineSpecified, hasWrittenPrototype,
                              isConstexprSpecified);
}

static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
                            SourceLocation StartLoc,
                            const DeclarationNameInfo &NameInfo,
                            QualType T, TypeSourceInfo *TInfo,
                            StorageClass SC,
                            bool isInlineSpecified,
                            bool hasWrittenPrototype,
                            bool isConstexprSpecified = false);

static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
                     
DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
}

void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
                          bool Qualified) const override;

void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// \brief Returns true if the function has a body (definition). The
/// function body might be in any of the (re-)declarations of this
/// function. The variant that accepts a FunctionDecl pointer will
/// set that function declaration to the actual declaration
/// containing the body (if there is one).
bool hasBody(const FunctionDecl *&Definition) const;

bool hasBody() const override {
  const FunctionDecl* Definition;
  return hasBody(Definition);
}

/// Returns whether the function has a trivial body that does not require any
/// specific codegen.
bool hasTrivialBody() const;

/// Returns true if the function is defined at all, including a deleted
/// definition. Except for the behavior when the function is deleted, behaves
/// like hasBody.
bool isDefined(const FunctionDecl *&Definition) const;

virtual bool isDefined() const {
  const FunctionDecl* Definition;
  return isDefined(Definition);
}

/// \brief Get the definition for this declaration.
FunctionDecl *getDefinition() {
  const FunctionDecl *Definition;
  if (isDefined(Definition))
    return const_cast<FunctionDecl *>(Definition);
  return nullptr;
}
const FunctionDecl *getDefinition() const {
  return const_cast<FunctionDecl *>(this)->getDefinition();
}

/// Retrieve the body (definition) of the function. The function body might be
/// in any of the (re-)declarations of this function. The variant that accepts
/// a FunctionDecl pointer will set that function declaration to the actual
/// declaration containing the body (if there is one).
/// NOTE: For checking if there is a body, use hasBody() instead, to avoid
/// unnecessary AST de-serialization of the body.
Stmt *getBody(const FunctionDecl *&Definition) const;

Stmt *getBody() const override {
  const FunctionDecl* Definition;
  return getBody(Definition);
}

/// Returns whether this specific declaration of the function is also a
/// definition that does not contain uninstantiated body.
///
/// This does not determine whether the function has been defined (e.g., in a
/// previous definition); for that information, use isDefined.
bool isThisDeclarationADefinition() const {
  return IsDeleted || IsDefaulted || Body || HasSkippedBody ||
         IsLateTemplateParsed || WillHaveBody || hasDefiningAttr();
}

/// Returns whether this specific declaration of the function has a body -
/// that is, if it is a non-deleted definition.
bool doesThisDeclarationHaveABody() const {
  return Body || IsLateTemplateParsed;
}

void setBody(Stmt *B);
void setLazyBody(uint64_t Offset) { Body = Offset; }

/// Whether this function is variadic.
bool isVariadic() const;

/// Whether this function is marked as virtual explicitly.
bool isVirtualAsWritten() const { return IsVirtualAsWritten; }
void setVirtualAsWritten(bool V) { IsVirtualAsWritten = V; }

/// Whether this virtual function is pure, i.e. makes the containing class
/// abstract.
bool isPure() const { return IsPure; }
void setPure(bool P = true);

/// Whether this templated function will be late parsed.
bool isLateTemplateParsed() const { return IsLateTemplateParsed; }
void setLateTemplateParsed(bool ILT = true) { IsLateTemplateParsed = ILT; }

/// Whether this function is "trivial" in some specialized C++ senses.
/// Can only be true for default constructors, copy constructors,
/// copy assignment operators, and destructors.  Not meaningful until
/// the class has been fully built by Sema.
bool isTrivial() const { return IsTrivial; }
void setTrivial(bool IT) { IsTrivial = IT; }

bool isTrivialForCall() const { return IsTrivialForCall; }
void setTrivialForCall(bool IT) { IsTrivialForCall = IT; }

/// Whether this function is defaulted per C++0x. Only valid for
/// special member functions.
bool isDefaulted() const { return IsDefaulted; }
void setDefaulted(bool D = true) { IsDefaulted = D; }

/// Whether this function is explicitly defaulted per C++0x. Only valid
/// for special member functions.
bool isExplicitlyDefaulted() const { return IsExplicitlyDefaulted; }
void setExplicitlyDefaulted(bool ED = true) { IsExplicitlyDefaulted = ED; }

/// Whether falling off this function implicitly returns null/zero.
/// If a more specific implicit return value is required, front-ends
/// should synthesize the appropriate return statements.
bool hasImplicitReturnZero() const { return HasImplicitReturnZero; }
void setHasImplicitReturnZero(bool IRZ) { HasImplicitReturnZero = IRZ; }

/// \brief Whether this function has a prototype, either because one
/// was explicitly written or because it was "inherited" by merging
/// a declaration without a prototype with a declaration that has a
/// prototype.
bool hasPrototype() const {
  return HasWrittenPrototype || HasInheritedPrototype;
}

bool hasWrittenPrototype() const { return HasWrittenPrototype; }

/// \brief Whether this function inherited its prototype from a
/// previous declaration.
bool hasInheritedPrototype() const { return HasInheritedPrototype; }
void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }

/// Whether this is a (C++11) constexpr function or constexpr constructor.
bool isConstexpr() const { return IsConstexpr; }
void setConstexpr(bool IC) { IsConstexpr = IC; }

/// \brief Whether the instantiation of this function is pending.
/// This bit is set when the decision to instantiate this function is made
/// and unset if and when the function body is created. That leaves out
/// cases where instantiation did not happen because the template definition
/// was not seen in this TU. This bit remains set in those cases, under the
/// assumption that the instantiation will happen in some other TU.
bool instantiationIsPending() const { return InstantiationIsPending; }
void setInstantiationIsPending(bool IC) { InstantiationIsPending = IC; }

/// \brief Indicates the function uses __try.
bool usesSEHTry() const { return UsesSEHTry; }
void setUsesSEHTry(bool UST) { UsesSEHTry = UST; }

/// \brief Whether this function has been deleted.
///
/// A function that is "deleted" (via the C++0x "= delete" syntax)
/// acts like a normal function, except that it cannot actually be
/// called or have its address taken. Deleted functions are
/// typically used in C++ overload resolution to attract arguments
/// whose type or lvalue/rvalue-ness would permit the use of a
/// different overload that would behave incorrectly. For example,
/// one might use deleted functions to ban implicit conversion from
/// a floating-point number to an Integer type:
///
/// @code
/// struct Integer {
///   Integer(long); // construct from a long
///   Integer(double) = delete; // no construction from float or double
///   Integer(long double) = delete; // no construction from long double
/// };
/// @endcode
// If a function is deleted, its first declaration must be.
bool isDeleted() const { return getCanonicalDecl()->IsDeleted; }
bool isDeletedAsWritten() const { return IsDeleted && !IsDefaulted; }
void setDeletedAsWritten(bool D = true) { IsDeleted = D; }

/// \brief Determines whether this function is "main", which is the
/// entry point into an executable program.
bool isMain() const;

/// \brief Determines whether this function is a MSVCRT user defined entry
/// point.
bool isMSVCRTEntryPoint() const;

/// \brief Determines whether this operator new or delete is one
/// of the reserved global placement operators:
///    void *operator new(size_t, void *);
///    void *operator new[](size_t, void *);
///    void operator delete(void *, void *);
///    void operator delete[](void *, void *);
/// These functions have special behavior under [new.delete.placement]:
///    These functions are reserved, a C++ program may not define
///    functions that displace the versions in the Standard C++ library.
///    The provisions of [basic.stc.dynamic] do not apply to these
///    reserved placement forms of operator new and operator delete.
///
/// This function must be an allocation or deallocation function.
bool isReservedGlobalPlacementOperator() const;

/// \brief Determines whether this function is one of the replaceable
/// global allocation functions:
///    void *operator new(size_t);
///    void *operator new(size_t, const std::nothrow_t &) noexcept;
///    void *operator new[](size_t);
///    void *operator new[](size_t, const std::nothrow_t &) noexcept;
///    void operator delete(void *) noexcept;
///    void operator delete(void *, std::size_t) noexcept;      [C++1y]
///    void operator delete(void *, const std::nothrow_t &) noexcept;
///    void operator delete[](void *) noexcept;
///    void operator delete[](void *, std::size_t) noexcept;    [C++1y]
///    void operator delete[](void *, const std::nothrow_t &) noexcept;
/// These functions have special behavior under C++1y [expr.new]:
///    An implementation is allowed to omit a call to a replaceable global
///    allocation function. [...]
///
/// If this function is an aligned allocation/deallocation function, return
/// true through IsAligned.
bool isReplaceableGlobalAllocationFunction(bool *IsAligned = nullptr) const;

/// \brief Determine whether this is a destroying operator delete.
bool isDestroyingOperatorDelete() const;

/// Compute the language linkage.
LanguageLinkage getLanguageLinkage() const;

/// \brief Determines whether this function is a function with
/// external, C linkage.
bool isExternC() const;

/// \brief Determines whether this function's context is, or is nested within,
/// a C++ extern "C" linkage spec.
bool isInExternCContext() const;

/// \brief Determines whether this function's context is, or is nested within,
/// a C++ extern "C++" linkage spec.
bool isInExternCXXContext() const;

/// \brief Determines whether this is a global function.
bool isGlobal() const;

/// \brief Determines whether this function is known to be 'noreturn', through
/// an attribute on its declaration or its type.
bool isNoReturn() const;

/// \brief True if the function was a definition but its body was skipped.
bool hasSkippedBody() const { return HasSkippedBody; }
void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }

/// True if this function will eventually have a body, once it's fully parsed.
bool willHaveBody() const { return WillHaveBody; }
void setWillHaveBody(bool V = true) { WillHaveBody = V; }

/// True if this function is considered a multiversioned function.
bool isMultiVersion() const { return getCanonicalDecl()->IsMultiVersion; }

/// Sets the multiversion state for this declaration and all of its
/// redeclarations.
void setIsMultiVersion(bool V = true) {
  getCanonicalDecl()->IsMultiVersion = V;
}

void setPreviousDeclaration(FunctionDecl * PrevDecl);

FunctionDecl *getCanonicalDecl() override;
const FunctionDecl *getCanonicalDecl() const {
  return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
}

unsigned getBuiltinID() const;

// ArrayRef interface to parameters.
ArrayRef<ParmVarDecl *> parameters() const {
  return {ParamInfo, getNumParams()};
}
MutableArrayRef<ParmVarDecl *> parameters() {
  return {ParamInfo, getNumParams()};
}

// Iterator access to formal parameters.
using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;

bool param_empty() const { return parameters().empty(); }
param_iterator param_begin() { return parameters().begin(); }
param_iterator param_end() { return parameters().end(); }
param_const_iterator param_begin() const { return parameters().begin(); }
param_const_iterator param_end() const { return parameters().end(); }
size_t param_size() const { return parameters().size(); }

/// Return the number of parameters this function must have based on its
/// FunctionType.  This is the length of the ParamInfo array after it has been
/// created.
unsigned getNumParams() const;

const ParmVarDecl *getParamDecl(unsigned i) const {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2213, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}
ParmVarDecl *getParamDecl(unsigned i) {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2217, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}
void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
  setParams(getASTContext(), NewParamInfo);
}

/// Returns the minimum number of arguments needed to call this function. This
/// may be fewer than the number of function parameters, if some of the
/// parameters have default arguments (in C++).
unsigned getMinRequiredArguments() const;

QualType getReturnType() const {
  assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!")(static_cast <bool> (getType()->getAs<FunctionType
>() && "Expected a FunctionType!") ? void (0) : __assert_fail
 ("getType()->getAs<FunctionType>() && \"Expected a FunctionType!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2230, __extension__ __PRETTY_FUNCTION__));
  return getType()->getAs<FunctionType>()->getReturnType();
}

/// \brief Attempt to compute an informative source range covering the
/// function return type. This may omit qualifiers and other information with
/// limited representation in the AST.
SourceRange getReturnTypeSourceRange() const;

/// \brief Attempt to compute an informative source range covering the
/// function exception specification, if any.
SourceRange getExceptionSpecSourceRange() const;

/// \brief Determine the type of an expression that calls this function.
QualType getCallResultType() const {
  assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!")(static_cast <bool> (getType()->getAs<FunctionType
>() && "Expected a FunctionType!") ? void (0) : __assert_fail
 ("getType()->getAs<FunctionType>() && \"Expected a FunctionType!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2245, __extension__ __PRETTY_FUNCTION__));
  return getType()->getAs<FunctionType>()->getCallResultType(getASTContext());
}

/// \brief Returns the WarnUnusedResultAttr that is either declared on this
/// function, or its return type declaration.
const Attr *getUnusedResultAttr() const;

/// \brief Returns true if this function or its return type has the
/// warn_unused_result attribute.
bool hasUnusedResultAttr() const { return getUnusedResultAttr() != nullptr; }

/// \brief Returns the storage class as written in the source. For the
/// computed linkage of symbol, see getLinkage.
StorageClass getStorageClass() const { return StorageClass(SClass); }

/// \brief Determine whether the "inline" keyword was specified for this
/// function.
bool isInlineSpecified() const { return IsInlineSpecified; }

/// Set whether the "inline" keyword was specified for this function.
void setInlineSpecified(bool I) {
  IsInlineSpecified = I;
  IsInline = I;
}

/// Flag that this function is implicitly inline.
void setImplicitlyInline() {
  IsInline = true;
}

/// \brief Determine whether this function should be inlined, because it is
/// either marked "inline" or "constexpr" or is a member function of a class
/// that was defined in the class body.
bool isInlined() const { return IsInline; }

bool isInlineDefinitionExternallyVisible() const;

bool isMSExternInline() const;

bool doesDeclarationForceExternallyVisibleDefinition() const;

/// Whether this function declaration represents an C++ overloaded
/// operator, e.g., "operator+".
bool isOverloadedOperator() const {
  return getOverloadedOperator() != OO_None;
}

OverloadedOperatorKind getOverloadedOperator() const;

const IdentifierInfo *getLiteralIdentifier() const;

/// \brief If this function is an instantiation of a member function
/// of a class template specialization, retrieves the function from
/// which it was instantiated.
///
/// This routine will return non-NULL for (non-templated) member
/// functions of class templates and for instantiations of function
/// templates. For example, given:
///
/// \code
/// template<typename T>
/// struct X {
///   void f(T);
/// };
/// \endcode
///
/// The declaration for X<int>::f is a (non-templated) FunctionDecl
/// whose parent is the class template specialization X<int>. For
/// this declaration, getInstantiatedFromFunction() will return
/// the FunctionDecl X<T>::A. When a complete definition of
/// X<int>::A is required, it will be instantiated from the
/// declaration returned by getInstantiatedFromMemberFunction().
FunctionDecl *getInstantiatedFromMemberFunction() const;

/// \brief What kind of templated function this is.
TemplatedKind getTemplatedKind() const;

/// \brief If this function is an instantiation of a member function of a
/// class template specialization, retrieves the member specialization
/// information.
MemberSpecializationInfo *getMemberSpecializationInfo() const;

/// \brief Specify that this record is an instantiation of the
/// member function FD.
void setInstantiationOfMemberFunction(FunctionDecl *FD,
                                      TemplateSpecializationKind TSK) {
  setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
}

/// \brief Retrieves the function template that is described by this
/// function declaration.
///
/// Every function template is represented as a FunctionTemplateDecl
/// and a FunctionDecl (or something derived from FunctionDecl). The
/// former contains template properties (such as the template
/// parameter lists) while the latter contains the actual
/// description of the template's
/// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
/// FunctionDecl that describes the function template,
/// getDescribedFunctionTemplate() retrieves the
/// FunctionTemplateDecl from a FunctionDecl.
FunctionTemplateDecl *getDescribedFunctionTemplate() const;

void setDescribedFunctionTemplate(FunctionTemplateDecl *Template);

/// \brief Determine whether this function is a function template
/// specialization.
bool isFunctionTemplateSpecialization() const {
  return getPrimaryTemplate() != nullptr;
}

/// \brief Retrieve the class scope template pattern that this function
///  template specialization is instantiated from.
FunctionDecl *getClassScopeSpecializationPattern() const;

/// \brief If this function is actually a function template specialization,
/// retrieve information about this function template specialization.
/// Otherwise, returns NULL.
FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const;

/// \brief Determines whether this function is a function template
/// specialization or a member of a class template specialization that can
/// be implicitly instantiated.
bool isImplicitlyInstantiable() const;

/// \brief Determines if the given function was instantiated from a
/// function template.
bool isTemplateInstantiation() const;

/// \brief Retrieve the function declaration from which this function could
/// be instantiated, if it is an instantiation (rather than a non-template
/// or a specialization, for example).
FunctionDecl *getTemplateInstantiationPattern() const;

/// \brief Retrieve the primary template that this function template
/// specialization either specializes or was instantiated from.
///
/// If this function declaration is not a function template specialization,
/// returns NULL.
FunctionTemplateDecl *getPrimaryTemplate() const;

/// \brief Retrieve the template arguments used to produce this function
/// template specialization from the primary template.
///
/// If this function declaration is not a function template specialization,
/// returns NULL.
const TemplateArgumentList *getTemplateSpecializationArgs() const;

/// \brief Retrieve the template argument list as written in the sources,
/// if any.
///
/// If this function declaration is not a function template specialization
/// or if it had no explicit template argument list, returns NULL.
/// Note that it an explicit template argument list may be written empty,
/// e.g., template<> void foo<>(char* s);
const ASTTemplateArgumentListInfo*
getTemplateSpecializationArgsAsWritten() const;

/// \brief Specify that this function declaration is actually a function
/// template specialization.
///
/// \param Template the function template that this function template
/// specialization specializes.
///
/// \param TemplateArgs the template arguments that produced this
/// function template specialization from the template.
///
/// \param InsertPos If non-NULL, the position in the function template
/// specialization set where the function template specialization data will
/// be inserted.
///
/// \param TSK the kind of template specialization this is.
///
/// \param TemplateArgsAsWritten location info of template arguments.
///
/// \param PointOfInstantiation point at which the function template
/// specialization was first instantiated.
void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
              const TemplateArgumentList *TemplateArgs,
              void *InsertPos,
              TemplateSpecializationKind TSK = TSK_ImplicitInstantiation,
              const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
              SourceLocation PointOfInstantiation = SourceLocation()) {
  setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
                                    InsertPos, TSK, TemplateArgsAsWritten,
                                    PointOfInstantiation);
}

/// \brief Specifies that this function declaration is actually a
/// dependent function template specialization.
void setDependentTemplateSpecialization(ASTContext &Context,
                           const UnresolvedSetImpl &Templates,
                    const TemplateArgumentListInfo &TemplateArgs);

DependentFunctionTemplateSpecializationInfo *
getDependentSpecializationInfo() const;

/// \brief Determine what kind of template instantiation this function
/// represents.
TemplateSpecializationKind getTemplateSpecializationKind() const;

/// \brief Determine what kind of template instantiation this function
/// represents.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

/// \brief Retrieve the (first) point of instantiation of a function template
/// specialization or a member of a class template specialization.
///
/// \returns the first point of instantiation, if this function was
/// instantiated from a template; otherwise, returns an invalid source
/// location.
SourceLocation getPointOfInstantiation() const;

/// \brief Determine whether this is or was instantiated from an out-of-line
/// definition of a member function.
bool isOutOfLine() const override;

/// \brief Identify a memory copying or setting function.
/// If the given function is a memory copy or setting function, returns
/// the corresponding Builtin ID. If the function is not a memory function,
/// returns 0.
unsigned getMemoryFunctionKind() const;

/// \brief Returns ODRHash of the function.  This value is calculated and
/// stored on first call, then the stored value returned on the other calls.
unsigned getODRHash();

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstFunction && K <= lastFunction;
}
static DeclContext *castToDeclContext(const FunctionDecl *D) {
  return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
}
static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
}
2485};

2487/// Represents a member of a struct/union/class.
2488class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
unsigned BitField : 1;
unsigned Mutable : 1;
mutable unsigned CachedFieldIndex : 30;

/// The kinds of value we can store in InitializerOrBitWidth.
///
/// Note that this is compatible with InClassInitStyle except for
/// ISK_CapturedVLAType.
enum InitStorageKind {
  /// If the pointer is null, there's nothing special.  Otherwise,
  /// this is a bitfield and the pointer is the Expr* storing the
  /// bit-width.
  ISK_NoInit = (unsigned) ICIS_NoInit,

  /// The pointer is an (optional due to delayed parsing) Expr*
  /// holding the copy-initializer.
  ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,

  /// The pointer is an (optional due to delayed parsing) Expr*
  /// holding the list-initializer.
  ISK_InClassListInit = (unsigned) ICIS_ListInit,

  /// The pointer is a VariableArrayType* that's been captured;
  /// the enclosing context is a lambda or captured statement.
  ISK_CapturedVLAType,
};

/// If this is a bitfield with a default member initializer, this
/// structure is used to represent the two expressions.
struct InitAndBitWidth {
  Expr *Init;
  Expr *BitWidth;
};

/// \brief Storage for either the bit-width, the in-class initializer, or
/// both (via InitAndBitWidth), or the captured variable length array bound.
///
/// If the storage kind is ISK_InClassCopyInit or
/// ISK_InClassListInit, but the initializer is null, then this
/// field has an in-class initializer that has not yet been parsed
/// and attached.
// FIXME: Tail-allocate this to reduce the size of FieldDecl in the
// overwhelmingly common case that we have none of these things.
llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;

2534protected:
FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
          SourceLocation IdLoc, IdentifierInfo *Id,
          QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
          InClassInitStyle InitStyle)
  : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
    BitField(false), Mutable(Mutable), CachedFieldIndex(0),
    InitStorage(nullptr, (InitStorageKind) InitStyle) {
  if (BW)
    setBitWidth(BW);
}

2546public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
                         SourceLocation StartLoc, SourceLocation IdLoc,
                         IdentifierInfo *Id, QualType T,
                         TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
                         InClassInitStyle InitStyle);

static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// Returns the index of this field within its record,
/// as appropriate for passing to ASTRecordLayout::getFieldOffset.
unsigned getFieldIndex() const;

/// Determines whether this field is mutable (C++ only).
bool isMutable() const { return Mutable; }

/// Determines whether this field is a bitfield.
bool isBitField() const { return BitField; }

/// Determines whether this is an unnamed bitfield.
bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }

/// Determines whether this field is a
/// representative for an anonymous struct or union. Such fields are
/// unnamed and are implicitly generated by the implementation to
/// store the data for the anonymous union or struct.
bool isAnonymousStructOrUnion() const;

Expr *getBitWidth() const {
  if (!BitField)
    return nullptr;
  void *Ptr = InitStorage.getPointer();
  if (getInClassInitStyle())
    return static_cast<InitAndBitWidth*>(Ptr)->BitWidth;
  return static_cast<Expr*>(Ptr);
}

unsigned getBitWidthValue(const ASTContext &Ctx) const;

/// Set the bit-field width for this member.
// Note: used by some clients (i.e., do not remove it).
void setBitWidth(Expr *Width) {
  assert(!hasCapturedVLAType() && !BitField &&(static_cast <bool> (!hasCapturedVLAType() && !
BitField && "bit width or captured type already set")
 ? void (0) : __assert_fail ("!hasCapturedVLAType() && !BitField && \"bit width or captured type already set\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2592, __extension__ __PRETTY_FUNCTION__))
         "bit width or captured type already set")(static_cast <bool> (!hasCapturedVLAType() && !
BitField && "bit width or captured type already set")
 ? void (0) : __assert_fail ("!hasCapturedVLAType() && !BitField && \"bit width or captured type already set\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2592, __extension__ __PRETTY_FUNCTION__));
  assert(Width && "no bit width specified")(static_cast <bool> (Width && "no bit width specified"
) ? void (0) : __assert_fail ("Width && \"no bit width specified\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2593, __extension__ __PRETTY_FUNCTION__));
  InitStorage.setPointer(
      InitStorage.getInt()
          ? new (getASTContext())
                InitAndBitWidth{getInClassInitializer(), Width}
          : static_cast<void*>(Width));
  BitField = true;
}

/// Remove the bit-field width from this member.
// Note: used by some clients (i.e., do not remove it).
void removeBitWidth() {
  assert(isBitField() && "no bitfield width to remove")(static_cast <bool> (isBitField() && "no bitfield width to remove"
) ? void (0) : __assert_fail ("isBitField() && \"no bitfield width to remove\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2605, __extension__ __PRETTY_FUNCTION__));
  InitStorage.setPointer(getInClassInitializer());
  BitField = false;
}

/// Get the kind of (C++11) default member initializer that this field has.
InClassInitStyle getInClassInitStyle() const {
  InitStorageKind storageKind = InitStorage.getInt();
  return (storageKind == ISK_CapturedVLAType
            ? ICIS_NoInit : (InClassInitStyle) storageKind);
}

/// Determine whether this member has a C++11 default member initializer.
bool hasInClassInitializer() const {
  return getInClassInitStyle() != ICIS_NoInit;
}

/// Get the C++11 default member initializer for this member, or null if one
/// has not been set. If a valid declaration has a default member initializer,
/// but this returns null, then we have not parsed and attached it yet.
Expr *getInClassInitializer() const {
  if (!hasInClassInitializer())
    return nullptr;
  void *Ptr = InitStorage.getPointer();
  if (BitField)
    return static_cast<InitAndBitWidth*>(Ptr)->Init;
  return static_cast<Expr*>(Ptr);
}

/// Set the C++11 in-class initializer for this member.
void setInClassInitializer(Expr *Init) {
  assert(hasInClassInitializer() && !getInClassInitializer())(static_cast <bool> (hasInClassInitializer() &&
 !getInClassInitializer()) ? void (0) : __assert_fail ("hasInClassInitializer() && !getInClassInitializer()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2636, __extension__ __PRETTY_FUNCTION__));
  if (BitField)
    static_cast<InitAndBitWidth*>(InitStorage.getPointer())->Init = Init;
  else
    InitStorage.setPointer(Init);
}

/// Remove the C++11 in-class initializer from this member.
void removeInClassInitializer() {
  assert(hasInClassInitializer() && "no initializer to remove")(static_cast <bool> (hasInClassInitializer() &&
 "no initializer to remove") ? void (0) : __assert_fail ("hasInClassInitializer() && \"no initializer to remove\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2645, __extension__ __PRETTY_FUNCTION__));
  InitStorage.setPointerAndInt(getBitWidth(), ISK_NoInit);
}

/// \brief Determine whether this member captures the variable length array
/// type.
bool hasCapturedVLAType() const {
  return InitStorage.getInt() == ISK_CapturedVLAType;
}

/// \brief Get the captured variable length array type.
const VariableArrayType *getCapturedVLAType() const {
  return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
                                    InitStorage.getPointer())
                              : nullptr;
}

/// \brief Set the captured variable length array type for this field.
void setCapturedVLAType(const VariableArrayType *VLAType);

/// Returns the parent of this field declaration, which
/// is the struct in which this field is defined.
const RecordDecl *getParent() const {
  return cast<RecordDecl>(getDeclContext());
}

RecordDecl *getParent() {
  return cast<RecordDecl>(getDeclContext());
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Retrieves the canonical declaration of this field.
FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
2684};

2686/// An instance of this object exists for each enum constant
2687/// that is defined.  For example, in "enum X {a,b}", each of a/b are
2688/// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
2689/// TagType for the X EnumDecl.
2690class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
Stmt *Init; // an integer constant expression
llvm::APSInt Val; // The value.

2694protected:
EnumConstantDecl(DeclContext *DC, SourceLocation L,
                 IdentifierInfo *Id, QualType T, Expr *E,
                 const llvm::APSInt &V)
  : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}

2700public:
friend class StmtIteratorBase;

static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
                                SourceLocation L, IdentifierInfo *Id,
                                QualType T, Expr *E,
                                const llvm::APSInt &V);
static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);

const Expr *getInitExpr() const { return (const Expr*) Init; }
Expr *getInitExpr() { return (Expr*) Init; }
const llvm::APSInt &getInitVal() const { return Val; }

void setInitExpr(Expr *E) { Init = (Stmt*) E; }
void setInitVal(const llvm::APSInt &V) { Val = V; }

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

/// Retrieves the canonical declaration of this enumerator.
EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == EnumConstant; }
2725};

2727/// Represents a field injected from an anonymous union/struct into the parent
2728/// scope. These are always implicit.
2729class IndirectFieldDecl : public ValueDecl,
                        public Mergeable<IndirectFieldDecl> {
NamedDecl **Chaining;
unsigned ChainingSize;

IndirectFieldDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
                  DeclarationName N, QualType T,
                  MutableArrayRef<NamedDecl *> CH);

void anchor() override;

2740public:
friend class ASTDeclReader;

static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation L, IdentifierInfo *Id,
                                 QualType T, llvm::MutableArrayRef<NamedDecl *> CH);

static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);

using chain_iterator = ArrayRef<NamedDecl *>::const_iterator;

ArrayRef<NamedDecl *> chain() const {
  return llvm::makeArrayRef(Chaining, ChainingSize);
}
chain_iterator chain_begin() const { return chain().begin(); }
chain_iterator chain_end() const { return chain().end(); }

unsigned getChainingSize() const { return ChainingSize; }

FieldDecl *getAnonField() const {
  assert(chain().size() >= 2)(static_cast <bool> (chain().size() >= 2) ? void (0)
 : __assert_fail ("chain().size() >= 2", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2760, __extension__ __PRETTY_FUNCTION__));
  return cast<FieldDecl>(chain().back());
}

VarDecl *getVarDecl() const {
  assert(chain().size() >= 2)(static_cast <bool> (chain().size() >= 2) ? void (0)
 : __assert_fail ("chain().size() >= 2", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 2765, __extension__ __PRETTY_FUNCTION__));
  return dyn_cast<VarDecl>(chain().front());
}

IndirectFieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == IndirectField; }
2775};

2777/// Represents a declaration of a type.
2778class TypeDecl : public NamedDecl {
friend class ASTContext;

/// This indicates the Type object that represents
/// this TypeDecl.  It is a cache maintained by
/// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
/// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
mutable const Type *TypeForDecl = nullptr;

/// The start of the source range for this declaration.
SourceLocation LocStart;

void anchor() override;

2792protected:
TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
         SourceLocation StartL = SourceLocation())
  : NamedDecl(DK, DC, L, Id), LocStart(StartL) {}

2797public:
// Low-level accessor. If you just want the type defined by this node,
// check out ASTContext::getTypeDeclType or one of
// ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
// already know the specific kind of node this is.
const Type *getTypeForDecl() const { return TypeForDecl; }
void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }

SourceLocation getLocStart() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
void setLocStart(SourceLocation L) { LocStart = L; }
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  if (LocStart.isValid())
    return SourceRange(LocStart, getLocation());
  else
    return SourceRange(getLocation());
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
2817};

2819/// Base class for declarations which introduce a typedef-name.
2820class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
struct LLVM_ALIGNAS(8)alignas(8) ModedTInfo {
  TypeSourceInfo *first;
  QualType second;
};

/// If int part is 0, we have not computed IsTransparentTag.
/// Otherwise, IsTransparentTag is (getInt() >> 1).
mutable llvm::PointerIntPair<
    llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
    MaybeModedTInfo;

void anchor() override;

2834protected:
TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC,
                SourceLocation StartLoc, SourceLocation IdLoc,
                IdentifierInfo *Id, TypeSourceInfo *TInfo)
    : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
      MaybeModedTInfo(TInfo, 0) {}

using redeclarable_base = Redeclarable<TypedefNameDecl>;

TypedefNameDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

TypedefNameDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

TypedefNameDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

2855public:
using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

bool isModed() const {
  return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
}

TypeSourceInfo *getTypeSourceInfo() const {
  return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
                   : MaybeModedTInfo.getPointer().get<TypeSourceInfo *>();
}

QualType getUnderlyingType() const {
  return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
                   : MaybeModedTInfo.getPointer()
                         .get<TypeSourceInfo *>()
                         ->getType();
}

void setTypeSourceInfo(TypeSourceInfo *newType) {
  MaybeModedTInfo.setPointer(newType);
}

void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
  MaybeModedTInfo.setPointer(new (getASTContext(), 8)
                                 ModedTInfo({unmodedTSI, modedTy}));
}

/// Retrieves the canonical declaration of this typedef-name.
TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }

/// Retrieves the tag declaration for which this is the typedef name for
/// linkage purposes, if any.
///
/// \param AnyRedecl Look for the tag declaration in any redeclaration of
/// this typedef declaration.
TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;

/// Determines if this typedef shares a name and spelling location with its
/// underlying tag type, as is the case with the NS_ENUM macro.
bool isTransparentTag() const {
  if (MaybeModedTInfo.getInt())
    return MaybeModedTInfo.getInt() & 0x2;
  return isTransparentTagSlow();
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstTypedefName && K <= lastTypedefName;
}

2916private:
bool isTransparentTagSlow() const;
2918};

2920/// Represents the declaration of a typedef-name via the 'typedef'
2921/// type specifier.
2922class TypedefDecl : public TypedefNameDecl {
TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
            SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
    : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}

2927public:
static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
                           SourceLocation StartLoc, SourceLocation IdLoc,
                           IdentifierInfo *Id, TypeSourceInfo *TInfo);
static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Typedef; }
2938};

2940/// Represents the declaration of a typedef-name via a C++11
2941/// alias-declaration.
2942class TypeAliasDecl : public TypedefNameDecl {
/// The template for which this is the pattern, if any.
TypeAliasTemplateDecl *Template;

TypeAliasDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
              SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
    : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
      Template(nullptr) {}

2951public:
static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
                             SourceLocation StartLoc, SourceLocation IdLoc,
                             IdentifierInfo *Id, TypeSourceInfo *TInfo);
static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == TypeAlias; }
2965};

2967/// Represents the declaration of a struct/union/class/enum.
2968class TagDecl
: public TypeDecl, public DeclContext, public Redeclarable<TagDecl> {
2970public:
// This is really ugly.
using TagKind = TagTypeKind;

2974private:
// FIXME: This can be packed into the bitfields in Decl.
/// The TagKind enum.
unsigned TagDeclKind : 3;

/// True if this is a definition ("struct foo {};"), false if it is a
/// declaration ("struct foo;").  It is not considered a definition
/// until the definition has been fully processed.
unsigned IsCompleteDefinition : 1;

2984protected:
/// True if this is currently being defined.
unsigned IsBeingDefined : 1;

2988private:
/// True if this tag declaration is "embedded" (i.e., defined or declared
/// for the very first time) in the syntax of a declarator.
unsigned IsEmbeddedInDeclarator : 1;

/// True if this tag is free standing, e.g. "struct foo;".
unsigned IsFreeStanding : 1;

2996protected:
// These are used by (and only defined for) EnumDecl.
unsigned NumPositiveBits : 8;
unsigned NumNegativeBits : 8;

/// True if this tag declaration is a scoped enumeration. Only
/// possible in C++11 mode.
unsigned IsScoped : 1;

/// If this tag declaration is a scoped enum,
/// then this is true if the scoped enum was declared using the class
/// tag, false if it was declared with the struct tag. No meaning is
/// associated if this tag declaration is not a scoped enum.
unsigned IsScopedUsingClassTag : 1;

/// True if this is an enumeration with fixed underlying type. Only
/// possible in C++11, Microsoft extensions, or Objective C mode.
unsigned IsFixed : 1;

/// Indicates whether it is possible for declarations of this kind
/// to have an out-of-date definition.
///
/// This option is only enabled when modules are enabled.
unsigned MayHaveOutOfDateDef : 1;

/// Has the full definition of this type been required by a use somewhere in
/// the TU.
unsigned IsCompleteDefinitionRequired : 1;

3025private:
SourceRange BraceRange;

// A struct representing syntactic qualifier info,
// to be used for the (uncommon) case of out-of-line declarations.
using ExtInfo = QualifierInfo;

/// \brief If the (out-of-line) tag declaration name
/// is qualified, it points to the qualifier info (nns and range);
/// otherwise, if the tag declaration is anonymous and it is part of
/// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
/// otherwise, if the tag declaration is anonymous and it is used as a
/// declaration specifier for variables, it points to the first VarDecl (used
/// for mangling);
/// otherwise, it is a null (TypedefNameDecl) pointer.
llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;

bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
const ExtInfo *getExtInfo() const {
  return TypedefNameDeclOrQualifier.get<ExtInfo *>();
}

3048protected:
TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
        SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
        SourceLocation StartL)
    : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
      TagDeclKind(TK), IsCompleteDefinition(false), IsBeingDefined(false),
      IsEmbeddedInDeclarator(false), IsFreeStanding(false),
      IsCompleteDefinitionRequired(false),
      TypedefNameDeclOrQualifier((TypedefNameDecl *)nullptr) {
  assert((DK != Enum || TK == TTK_Enum) &&(static_cast <bool> ((DK != Enum || TK == TTK_Enum) &&
 "EnumDecl not matched with TTK_Enum") ? void (0) : __assert_fail
 ("(DK != Enum || TK == TTK_Enum) && \"EnumDecl not matched with TTK_Enum\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3058, __extension__ __PRETTY_FUNCTION__))
         "EnumDecl not matched with TTK_Enum")(static_cast <bool> ((DK != Enum || TK == TTK_Enum) &&
 "EnumDecl not matched with TTK_Enum") ? void (0) : __assert_fail
 ("(DK != Enum || TK == TTK_Enum) && \"EnumDecl not matched with TTK_Enum\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3058, __extension__ __PRETTY_FUNCTION__));
  setPreviousDecl(PrevDecl);
}

using redeclarable_base = Redeclarable<TagDecl>;

TagDecl *getNextRedeclarationImpl() override {
  return getNextRedeclaration();
}

TagDecl *getPreviousDeclImpl() override {
  return getPreviousDecl();
}

TagDecl *getMostRecentDeclImpl() override {
  return getMostRecentDecl();
}

/// @brief Completes the definition of this tag declaration.
///
/// This is a helper function for derived classes.
void completeDefinition();

3081public:
friend class ASTDeclReader;
friend class ASTDeclWriter;

using redecl_range = redeclarable_base::redecl_range;
using redecl_iterator = redeclarable_base::redecl_iterator;

using redeclarable_base::redecls_begin;
using redeclarable_base::redecls_end;
using redeclarable_base::redecls;
using redeclarable_base::getPreviousDecl;
using redeclarable_base::getMostRecentDecl;
using redeclarable_base::isFirstDecl;

SourceRange getBraceRange() const { return BraceRange; }
void setBraceRange(SourceRange R) { BraceRange = R; }

/// Return SourceLocation representing start of source
/// range ignoring outer template declarations.
SourceLocation getInnerLocStart() const { return getLocStart(); }

/// Return SourceLocation representing start of source
/// range taking into account any outer template declarations.
SourceLocation getOuterLocStart() const;
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

TagDecl *getCanonicalDecl() override;
const TagDecl *getCanonicalDecl() const {
  return const_cast<TagDecl*>(this)->getCanonicalDecl();
}

/// Return true if this declaration is a completion definition of the type.
/// Provided for consistency.
bool isThisDeclarationADefinition() const {
  return isCompleteDefinition();
}

/// Return true if this decl has its body fully specified.
bool isCompleteDefinition() const {
  return IsCompleteDefinition;
}

/// \brief Return true if this complete decl is
/// required to be complete for some existing use.
bool isCompleteDefinitionRequired() const {
  return IsCompleteDefinitionRequired;
}

/// Return true if this decl is currently being defined.
bool isBeingDefined() const {
  return IsBeingDefined;
}

bool isEmbeddedInDeclarator() const {
  return IsEmbeddedInDeclarator;
}
void setEmbeddedInDeclarator(bool isInDeclarator) {
  IsEmbeddedInDeclarator = isInDeclarator;
}

bool isFreeStanding() const { return IsFreeStanding; }
void setFreeStanding(bool isFreeStanding = true) {
  IsFreeStanding = isFreeStanding;
}

/// \brief Whether this declaration declares a type that is
/// dependent, i.e., a type that somehow depends on template
/// parameters.
bool isDependentType() const { return isDependentContext(); }

/// Starts the definition of this tag declaration.
///
/// This method should be invoked at the beginning of the definition
/// of this tag declaration. It will set the tag type into a state
/// where it is in the process of being defined.
void startDefinition();

/// Returns the TagDecl that actually defines this
///  struct/union/class/enum.  When determining whether or not a
///  struct/union/class/enum has a definition, one should use this
///  method as opposed to 'isDefinition'.  'isDefinition' indicates
///  whether or not a specific TagDecl is defining declaration, not
///  whether or not the struct/union/class/enum type is defined.
///  This method returns NULL if there is no TagDecl that defines
///  the struct/union/class/enum.
TagDecl *getDefinition() const;

void setCompleteDefinition(bool V) { IsCompleteDefinition = V; }

void setCompleteDefinitionRequired(bool V = true) {
  IsCompleteDefinitionRequired = V;
}

StringRef getKindName() const {
  return TypeWithKeyword::getTagTypeKindName(getTagKind());
}

TagKind getTagKind() const {
  return TagKind(TagDeclKind);
}

void setTagKind(TagKind TK) { TagDeclKind = TK; }

bool isStruct() const { return getTagKind() == TTK_Struct; }
bool isInterface() const { return getTagKind() == TTK_Interface; }
bool isClass()  const { return getTagKind() == TTK_Class; }
bool isUnion()  const { return getTagKind() == TTK_Union; }
bool isEnum()   const { return getTagKind() == TTK_Enum; }

/// Is this tag type named, either directly or via being defined in
/// a typedef of this type?
///
/// C++11 [basic.link]p8:
///   A type is said to have linkage if and only if:
///     - it is a class or enumeration type that is named (or has a
///       name for linkage purposes) and the name has linkage; ...
/// C++11 [dcl.typedef]p9:
///   If the typedef declaration defines an unnamed class (or enum),
///   the first typedef-name declared by the declaration to be that
///   class type (or enum type) is used to denote the class type (or
///   enum type) for linkage purposes only.
///
/// C does not have an analogous rule, but the same concept is
/// nonetheless useful in some places.
bool hasNameForLinkage() const {
  return (getDeclName() || getTypedefNameForAnonDecl());
}

TypedefNameDecl *getTypedefNameForAnonDecl() const {
  return hasExtInfo() ? nullptr
                      : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
}

void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);

/// \brief Retrieve the nested-name-specifier that qualifies the name of this
/// declaration, if it was present in the source.
NestedNameSpecifier *getQualifier() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
                      : nullptr;
}

/// \brief Retrieve the nested-name-specifier (with source-location
/// information) that qualifies the name of this declaration, if it was
/// present in the source.
NestedNameSpecifierLoc getQualifierLoc() const {
  return hasExtInfo() ? getExtInfo()->QualifierLoc
                      : NestedNameSpecifierLoc();
}

void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);

unsigned getNumTemplateParameterLists() const {
  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
}

TemplateParameterList *getTemplateParameterList(unsigned i) const {
  assert(i < getNumTemplateParameterLists())(static_cast <bool> (i < getNumTemplateParameterLists
()) ? void (0) : __assert_fail ("i < getNumTemplateParameterLists()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3238, __extension__ __PRETTY_FUNCTION__));
  return getExtInfo()->TemplParamLists[i];
}

void setTemplateParameterListsInfo(ASTContext &Context,
                                   ArrayRef<TemplateParameterList *> TPLists);

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }

static DeclContext *castToDeclContext(const TagDecl *D) {
  return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
}

static TagDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
}
3256};

3258/// Represents an enum.  In C++11, enums can be forward-declared
3259/// with a fixed underlying type, and in C we allow them to be forward-declared
3260/// with no underlying type as an extension.
3261class EnumDecl : public TagDecl {
/// This represent the integer type that the enum corresponds
/// to for code generation purposes.  Note that the enumerator constants may
/// have a different type than this does.
///
/// If the underlying integer type was explicitly stated in the source
/// code, this is a TypeSourceInfo* for that type. Otherwise this type
/// was automatically deduced somehow, and this is a Type*.
///
/// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
/// some cases it won't.
///
/// The underlying type of an enumeration never has any qualifiers, so
/// we can get away with just storing a raw Type*, and thus save an
/// extra pointer when TypeSourceInfo is needed.
llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;

/// The integer type that values of this type should
/// promote to.  In C, enumerators are generally of an integer type
/// directly, but gcc-style large enumerators (and all enumerators
/// in C++) are of the enum type instead.
QualType PromotionType;

/// \brief If this enumeration is an instantiation of a member enumeration
/// of a class template specialization, this is the member specialization
/// information.
MemberSpecializationInfo *SpecializationInfo = nullptr;

EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
         SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
         bool Scoped, bool ScopedUsingClassTag, bool Fixed)
    : TagDecl(Enum, TTK_Enum, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
  assert(Scoped || !ScopedUsingClassTag)(static_cast <bool> (Scoped || !ScopedUsingClassTag) ? void
 (0) : __assert_fail ("Scoped || !ScopedUsingClassTag", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3293, __extension__ __PRETTY_FUNCTION__));
  IntegerType = (const Type *)nullptr;
  NumNegativeBits = 0;
  NumPositiveBits = 0;
  IsScoped = Scoped;
  IsScopedUsingClassTag = ScopedUsingClassTag;
  IsFixed = Fixed;
}

void anchor() override;

void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
                                  TemplateSpecializationKind TSK);
3306public:
friend class ASTDeclReader;

EnumDecl *getCanonicalDecl() override {
  return cast<EnumDecl>(TagDecl::getCanonicalDecl());
}
const EnumDecl *getCanonicalDecl() const {
  return const_cast<EnumDecl*>(this)->getCanonicalDecl();
}

EnumDecl *getPreviousDecl() {
  return cast_or_null<EnumDecl>(
          static_cast<TagDecl *>(this)->getPreviousDecl());
}
const EnumDecl *getPreviousDecl() const {
  return const_cast<EnumDecl*>(this)->getPreviousDecl();
}

EnumDecl *getMostRecentDecl() {
  return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
}
const EnumDecl *getMostRecentDecl() const {
  return const_cast<EnumDecl*>(this)->getMostRecentDecl();
}

EnumDecl *getDefinition() const {
  return cast_or_null<EnumDecl>(TagDecl::getDefinition());
}

static EnumDecl *Create(ASTContext &C, DeclContext *DC,
                        SourceLocation StartLoc, SourceLocation IdLoc,
                        IdentifierInfo *Id, EnumDecl *PrevDecl,
                        bool IsScoped, bool IsScopedUsingClassTag,
                        bool IsFixed);
static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);

/// When created, the EnumDecl corresponds to a
/// forward-declared enum. This method is used to mark the
/// declaration as being defined; its enumerators have already been
/// added (via DeclContext::addDecl). NewType is the new underlying
/// type of the enumeration type.
void completeDefinition(QualType NewType,
                        QualType PromotionType,
                        unsigned NumPositiveBits,
                        unsigned NumNegativeBits);

// Iterates through the enumerators of this enumeration.
using enumerator_iterator = specific_decl_iterator<EnumConstantDecl>;
using enumerator_range =
    llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>;

enumerator_range enumerators() const {
  return enumerator_range(enumerator_begin(), enumerator_end());
}

enumerator_iterator enumerator_begin() const {
  const EnumDecl *E = getDefinition();
  if (!E)
    E = this;
  return enumerator_iterator(E->decls_begin());
}

enumerator_iterator enumerator_end() const {
  const EnumDecl *E = getDefinition();
  if (!E)
    E = this;
  return enumerator_iterator(E->decls_end());
}

/// Return the integer type that enumerators should promote to.
QualType getPromotionType() const { return PromotionType; }

/// Set the promotion type.
void setPromotionType(QualType T) { PromotionType = T; }

/// Return the integer type this enum decl corresponds to.
/// This returns a null QualType for an enum forward definition with no fixed
/// underlying type.
QualType getIntegerType() const {
  if (!IntegerType)
    return QualType();
  if (const Type *T = IntegerType.dyn_cast<const Type*>())
    return QualType(T, 0);
  return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
}

/// \brief Set the underlying integer type.
void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }

/// \brief Set the underlying integer type source info.
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }

/// \brief Return the type source info for the underlying integer type,
/// if no type source info exists, return 0.
TypeSourceInfo *getIntegerTypeSourceInfo() const {
  return IntegerType.dyn_cast<TypeSourceInfo*>();
}

/// \brief Retrieve the source range that covers the underlying type if
/// specified.
SourceRange getIntegerTypeRange() const LLVM_READONLY__attribute__((__pure__));

/// \brief Returns the width in bits required to store all the
/// non-negative enumerators of this enum.
unsigned getNumPositiveBits() const {
  return NumPositiveBits;
}
void setNumPositiveBits(unsigned Num) {
  NumPositiveBits = Num;
  assert(NumPositiveBits == Num && "can't store this bitcount")(static_cast <bool> (NumPositiveBits == Num && "can't store this bitcount"
) ? void (0) : __assert_fail ("NumPositiveBits == Num && \"can't store this bitcount\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3415, __extension__ __PRETTY_FUNCTION__));
}

/// \brief Returns the width in bits required to store all the
/// negative enumerators of this enum.  These widths include
/// the rightmost leading 1;  that is:
///
/// MOST NEGATIVE ENUMERATOR     PATTERN     NUM NEGATIVE BITS
/// ------------------------     -------     -----------------
///                       -1     1111111                     1
///                      -10     1110110                     5
///                     -101     1001011                     8
unsigned getNumNegativeBits() const {
  return NumNegativeBits;
}
void setNumNegativeBits(unsigned Num) {
  NumNegativeBits = Num;
}

/// \brief Returns true if this is a C++11 scoped enumeration.
bool isScoped() const {
  return IsScoped;
}

/// \brief Returns true if this is a C++11 scoped enumeration.
bool isScopedUsingClassTag() const {
  return IsScopedUsingClassTag;
}

/// \brief Returns true if this is an Objective-C, C++11, or
/// Microsoft-style enumeration with a fixed underlying type.
bool isFixed() const {
  return IsFixed;
}

/// \brief Returns true if this can be considered a complete type.
bool isComplete() const {
  // IntegerType is set for fixed type enums and non-fixed but implicitly
  // int-sized Microsoft enums.
  return isCompleteDefinition() || IntegerType;
}

/// Returns true if this enum is either annotated with
/// enum_extensibility(closed) or isn't annotated with enum_extensibility.
bool isClosed() const;

/// Returns true if this enum is annotated with flag_enum and isn't annotated
/// with enum_extensibility(open).
bool isClosedFlag() const;

/// Returns true if this enum is annotated with neither flag_enum nor
/// enum_extensibility(open).
bool isClosedNonFlag() const;

/// \brief Retrieve the enum definition from which this enumeration could
/// be instantiated, if it is an instantiation (rather than a non-template).
EnumDecl *getTemplateInstantiationPattern() const;

/// \brief Returns the enumeration (declared within the template)
/// from which this enumeration type was instantiated, or NULL if
/// this enumeration was not instantiated from any template.
EnumDecl *getInstantiatedFromMemberEnum() const;

/// \brief If this enumeration is a member of a specialization of a
/// templated class, determine what kind of template specialization
/// or instantiation this is.
TemplateSpecializationKind getTemplateSpecializationKind() const;

/// \brief For an enumeration member that was instantiated from a member
/// enumeration of a templated class, set the template specialiation kind.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

/// \brief If this enumeration is an instantiation of a member enumeration of
/// a class template specialization, retrieves the member specialization
/// information.
MemberSpecializationInfo *getMemberSpecializationInfo() const {
  return SpecializationInfo;
}

/// \brief Specify that this enumeration is an instantiation of the
/// member enumeration ED.
void setInstantiationOfMemberEnum(EnumDecl *ED,
                                  TemplateSpecializationKind TSK) {
  setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Enum; }
3504};

3506/// Represents a struct/union/class.  For example:
3507///   struct X;                  // Forward declaration, no "body".
3508///   union Y { int A, B; };     // Has body with members A and B (FieldDecls).
3509/// This decl will be marked invalid if *any* members are invalid.
3510class RecordDecl : public TagDecl {
friend class DeclContext;

// FIXME: This can be packed into the bitfields in Decl.
/// This is true if this struct ends with a flexible
/// array member (e.g. int X[]) or if this union contains a struct that does.
/// If so, this cannot be contained in arrays or other structs as a member.
bool HasFlexibleArrayMember : 1;

/// Whether this is the type of an anonymous struct or union.
bool AnonymousStructOrUnion : 1;

/// This is true if this struct has at least one member
/// containing an Objective-C object pointer type.
bool HasObjectMember : 1;

/// This is true if struct has at least one member of
/// 'volatile' type.
bool HasVolatileMember : 1;

/// Whether the field declarations of this record have been loaded
/// from external storage. To avoid unnecessary deserialization of
/// methods/nested types we allow deserialization of just the fields
/// when needed.
mutable bool LoadedFieldsFromExternalStorage : 1;

3536protected:
RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
           SourceLocation StartLoc, SourceLocation IdLoc,
           IdentifierInfo *Id, RecordDecl *PrevDecl);

3541public:
static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
                          SourceLocation StartLoc, SourceLocation IdLoc,
                          IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);

RecordDecl *getPreviousDecl() {
  return cast_or_null<RecordDecl>(
          static_cast<TagDecl *>(this)->getPreviousDecl());
}
const RecordDecl *getPreviousDecl() const {
  return const_cast<RecordDecl*>(this)->getPreviousDecl();
}

RecordDecl *getMostRecentDecl() {
  return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
35
←
Calling 'Redeclarable::getMostRecentDecl'→
50
←
Returning from 'Redeclarable::getMostRecentDecl'→
51
←
Calling 'cast'→
63
←
Returning from 'cast'→
97
←
Calling 'Redeclarable::getMostRecentDecl'→
111
←
Returning from 'Redeclarable::getMostRecentDecl'→
112
←
Calling 'cast'→
124
←
Returning from 'cast'→
156
←
Calling 'Redeclarable::getMostRecentDecl'→
170
←
Returning from 'Redeclarable::getMostRecentDecl'→
171
←
Calling 'cast'→
183
←
Returning from 'cast'→
}
const RecordDecl *getMostRecentDecl() const {
  return const_cast<RecordDecl*>(this)->getMostRecentDecl();
}

bool hasFlexibleArrayMember() const { return HasFlexibleArrayMember; }
void setHasFlexibleArrayMember(bool V) { HasFlexibleArrayMember = V; }

/// Whether this is an anonymous struct or union. To be an anonymous
/// struct or union, it must have been declared without a name and
/// there must be no objects of this type declared, e.g.,
/// @code
///   union { int i; float f; };
/// @endcode
/// is an anonymous union but neither of the following are:
/// @code
///  union X { int i; float f; };
///  union { int i; float f; } obj;
/// @endcode
bool isAnonymousStructOrUnion() const { return AnonymousStructOrUnion; }
void setAnonymousStructOrUnion(bool Anon) {
  AnonymousStructOrUnion = Anon;
}

bool hasObjectMember() const { return HasObjectMember; }
void setHasObjectMember (bool val) { HasObjectMember = val; }

bool hasVolatileMember() const { return HasVolatileMember; }
void setHasVolatileMember (bool val) { HasVolatileMember = val; }

bool hasLoadedFieldsFromExternalStorage() const {
  return LoadedFieldsFromExternalStorage;
}
void setHasLoadedFieldsFromExternalStorage(bool val) {
  LoadedFieldsFromExternalStorage = val;
}

/// \brief Determines whether this declaration represents the
/// injected class name.
///
/// The injected class name in C++ is the name of the class that
/// appears inside the class itself. For example:
///
/// \code
/// struct C {
///   // C is implicitly declared here as a synonym for the class name.
/// };
///
/// C::C c; // same as "C c;"
/// \endcode
bool isInjectedClassName() const;

/// \brief Determine whether this record is a class describing a lambda
/// function object.
bool isLambda() const;

/// \brief Determine whether this record is a record for captured variables in
/// CapturedStmt construct.
bool isCapturedRecord() const;

/// \brief Mark the record as a record for captured variables in CapturedStmt
/// construct.
void setCapturedRecord();

/// Returns the RecordDecl that actually defines
///  this struct/union/class.  When determining whether or not a
///  struct/union/class is completely defined, one should use this
///  method as opposed to 'isCompleteDefinition'.
///  'isCompleteDefinition' indicates whether or not a specific
///  RecordDecl is a completed definition, not whether or not the
///  record type is defined.  This method returns NULL if there is
///  no RecordDecl that defines the struct/union/tag.
RecordDecl *getDefinition() const {
  return cast_or_null<RecordDecl>(TagDecl::getDefinition());
}

// Iterator access to field members. The field iterator only visits
// the non-static data members of this class, ignoring any static
// data members, functions, constructors, destructors, etc.
using field_iterator = specific_decl_iterator<FieldDecl>;
using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;

field_range fields() const { return field_range(field_begin(), field_end()); }
field_iterator field_begin() const;

field_iterator field_end() const {
  return field_iterator(decl_iterator());
}

// Whether there are any fields (non-static data members) in this record.
bool field_empty() const {
  return field_begin() == field_end();
}

/// Note that the definition of this type is now complete.
virtual void completeDefinition();

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) {
  return K >= firstRecord && K <= lastRecord;
}

/// \brief Get whether or not this is an ms_struct which can
/// be turned on with an attribute, pragma, or -mms-bitfields
/// commandline option.
bool isMsStruct(const ASTContext &C) const;

/// \brief Whether we are allowed to insert extra padding between fields.
/// These padding are added to help AddressSanitizer detect
/// intra-object-overflow bugs.
bool mayInsertExtraPadding(bool EmitRemark = false) const;

/// Finds the first data member which has a name.
/// nullptr is returned if no named data member exists.
const FieldDecl *findFirstNamedDataMember() const;  

3673private:
/// \brief Deserialize just the fields.
void LoadFieldsFromExternalStorage() const;
3676};

3678class FileScopeAsmDecl : public Decl {
StringLiteral *AsmString;
SourceLocation RParenLoc;

FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
                 SourceLocation StartL, SourceLocation EndL)
  : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}

virtual void anchor();

3688public:
static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC,
                                StringLiteral *Str, SourceLocation AsmLoc,
                                SourceLocation RParenLoc);

static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceLocation getAsmLoc() const { return getLocation(); }
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }
SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getAsmLoc(), getRParenLoc());
}

const StringLiteral *getAsmString() const { return AsmString; }
StringLiteral *getAsmString() { return AsmString; }
void setAsmString(StringLiteral *Asm) { AsmString = Asm; }

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == FileScopeAsm; }
3708};

3710/// Pepresents a block literal declaration, which is like an
3711/// unnamed FunctionDecl.  For example:
3712/// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
3713class BlockDecl : public Decl, public DeclContext {
3714public:
/// A class which contains all the information about a particular
/// captured value.
class Capture {
  enum {
    flag_isByRef = 0x1,
    flag_isNested = 0x2
  };

  /// The variable being captured.
  llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;

  /// The copy expression, expressed in terms of a DeclRef (or
  /// BlockDeclRef) to the captured variable.  Only required if the
  /// variable has a C++ class type.
  Expr *CopyExpr;

public:
  Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
    : VariableAndFlags(variable,
                (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
      CopyExpr(copy) {}

  /// The variable being captured.
  VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }

  /// Whether this is a "by ref" capture, i.e. a capture of a __block
  /// variable.
  bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }

  /// Whether this is a nested capture, i.e. the variable captured
  /// is not from outside the immediately enclosing function/block.
  bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }

  bool hasCopyExpr() const { return CopyExpr != nullptr; }
  Expr *getCopyExpr() const { return CopyExpr; }
  void setCopyExpr(Expr *e) { CopyExpr = e; }
};

3753private:
// FIXME: This can be packed into the bitfields in Decl.
bool IsVariadic : 1;
bool CapturesCXXThis : 1;
bool BlockMissingReturnType : 1;
bool IsConversionFromLambda : 1;

/// A new[]'d array of pointers to ParmVarDecls for the formal
/// parameters of this function.  This is null if a prototype or if there are
/// no formals.
ParmVarDecl **ParamInfo = nullptr;
unsigned NumParams = 0;

Stmt *Body = nullptr;
TypeSourceInfo *SignatureAsWritten = nullptr;

const Capture *Captures = nullptr;
unsigned NumCaptures = 0;

unsigned ManglingNumber = 0;
Decl *ManglingContextDecl = nullptr;

3775protected:
BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
    : Decl(Block, DC, CaretLoc), DeclContext(Block), IsVariadic(false),
      CapturesCXXThis(false), BlockMissingReturnType(true),
      IsConversionFromLambda(false) {}

3781public:
static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L); 
static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceLocation getCaretLocation() const { return getLocation(); }

bool isVariadic() const { return IsVariadic; }
void setIsVariadic(bool value) { IsVariadic = value; }

CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
Stmt *getBody() const override { return (Stmt*) Body; }
void setBody(CompoundStmt *B) { Body = (Stmt*) B; }

void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }

// ArrayRef access to formal parameters.
ArrayRef<ParmVarDecl *> parameters() const {
  return {ParamInfo, getNumParams()};
}
MutableArrayRef<ParmVarDecl *> parameters() {
  return {ParamInfo, getNumParams()};
}

// Iterator access to formal parameters.
using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;

bool param_empty() const { return parameters().empty(); }
param_iterator param_begin() { return parameters().begin(); }
param_iterator param_end() { return parameters().end(); }
param_const_iterator param_begin() const { return parameters().begin(); }
param_const_iterator param_end() const { return parameters().end(); }
size_t param_size() const { return parameters().size(); }

unsigned getNumParams() const { return NumParams; }

const ParmVarDecl *getParamDecl(unsigned i) const {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3819, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}
ParmVarDecl *getParamDecl(unsigned i) {
  assert(i < getNumParams() && "Illegal param #")(static_cast <bool> (i < getNumParams() && "Illegal param #"
) ? void (0) : __assert_fail ("i < getNumParams() && \"Illegal param #\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3823, __extension__ __PRETTY_FUNCTION__));
  return ParamInfo[i];
}

void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);

/// True if this block (or its nested blocks) captures
/// anything of local storage from its enclosing scopes.
bool hasCaptures() const { return NumCaptures != 0 || CapturesCXXThis; }

/// Returns the number of captured variables.
/// Does not include an entry for 'this'.
unsigned getNumCaptures() const { return NumCaptures; }

using capture_const_iterator = ArrayRef<Capture>::const_iterator;

ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }

capture_const_iterator capture_begin() const { return captures().begin(); }
capture_const_iterator capture_end() const { return captures().end(); }

bool capturesCXXThis() const { return CapturesCXXThis; }
bool blockMissingReturnType() const { return BlockMissingReturnType; }
void setBlockMissingReturnType(bool val) { BlockMissingReturnType = val; }

bool isConversionFromLambda() const { return IsConversionFromLambda; }
void setIsConversionFromLambda(bool val) { IsConversionFromLambda = val; }

bool capturesVariable(const VarDecl *var) const;

void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
                 bool CapturesCXXThis);

 unsigned getBlockManglingNumber() const {
   return ManglingNumber;
 }

 Decl *getBlockManglingContextDecl() const {
   return ManglingContextDecl;    
 }

void setBlockMangling(unsigned Number, Decl *Ctx) {
  ManglingNumber = Number;
  ManglingContextDecl = Ctx;
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Block; }
static DeclContext *castToDeclContext(const BlockDecl *D) {
  return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
}
static BlockDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
}
3880};

3882/// Represents the body of a CapturedStmt, and serves as its DeclContext.
3883class CapturedDecl final
  : public Decl,
    public DeclContext,
    private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
3887protected:
size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
  return NumParams;
}

3892private:
/// \brief The number of parameters to the outlined function.
unsigned NumParams;

/// \brief The position of context parameter in list of parameters.
unsigned ContextParam;

/// \brief The body of the outlined function.
llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;

explicit CapturedDecl(DeclContext *DC, unsigned NumParams);

ImplicitParamDecl *const *getParams() const {
  return getTrailingObjects<ImplicitParamDecl *>();
}

ImplicitParamDecl **getParams() {
  return getTrailingObjects<ImplicitParamDecl *>();
}

3912public:
friend class ASTDeclReader;
friend class ASTDeclWriter;
friend TrailingObjects;

static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
                            unsigned NumParams);
static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                        unsigned NumParams);

Stmt *getBody() const override;
void setBody(Stmt *B);

bool isNothrow() const;
void setNothrow(bool Nothrow = true);

unsigned getNumParams() const { return NumParams; }

ImplicitParamDecl *getParam(unsigned i) const {
  assert(i < NumParams)(static_cast <bool> (i < NumParams) ? void (0) : __assert_fail
 ("i < NumParams", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3931, __extension__ __PRETTY_FUNCTION__));
  return getParams()[i];
}
void setParam(unsigned i, ImplicitParamDecl *P) {
  assert(i < NumParams)(static_cast <bool> (i < NumParams) ? void (0) : __assert_fail
 ("i < NumParams", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3935, __extension__ __PRETTY_FUNCTION__));
  getParams()[i] = P;
}

// ArrayRef interface to parameters.
ArrayRef<ImplicitParamDecl *> parameters() const {
  return {getParams(), getNumParams()};
}
MutableArrayRef<ImplicitParamDecl *> parameters() {
  return {getParams(), getNumParams()};
}

/// \brief Retrieve the parameter containing captured variables.
ImplicitParamDecl *getContextParam() const {
  assert(ContextParam < NumParams)(static_cast <bool> (ContextParam < NumParams) ? void
 (0) : __assert_fail ("ContextParam < NumParams", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3949, __extension__ __PRETTY_FUNCTION__));
  return getParam(ContextParam);
}
void setContextParam(unsigned i, ImplicitParamDecl *P) {
  assert(i < NumParams)(static_cast <bool> (i < NumParams) ? void (0) : __assert_fail
 ("i < NumParams", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 3953, __extension__ __PRETTY_FUNCTION__));
  ContextParam = i;
  setParam(i, P);
}
unsigned getContextParamPosition() const { return ContextParam; }

using param_iterator = ImplicitParamDecl *const *;
using param_range = llvm::iterator_range<param_iterator>;

/// \brief Retrieve an iterator pointing to the first parameter decl.
param_iterator param_begin() const { return getParams(); }
/// \brief Retrieve an iterator one past the last parameter decl.
param_iterator param_end() const { return getParams() + NumParams; }

// Implement isa/cast/dyncast/etc.
static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Captured; }
static DeclContext *castToDeclContext(const CapturedDecl *D) {
  return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
}
static CapturedDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
}
3976};

3978/// \brief Describes a module import declaration, which makes the contents
3979/// of the named module visible in the current translation unit.
3980///
3981/// An import declaration imports the named module (or submodule). For example:
3982/// \code
3983///   @import std.vector;
3984/// \endcode
3985///
3986/// Import declarations can also be implicitly generated from
3987/// \#include/\#import directives.
3988class ImportDecl final : public Decl,
                       llvm::TrailingObjects<ImportDecl, SourceLocation> {
friend class ASTContext;
friend class ASTDeclReader;
friend class ASTReader;
friend TrailingObjects;

/// \brief The imported module, along with a bit that indicates whether
/// we have source-location information for each identifier in the module
/// name. 
///
/// When the bit is false, we only have a single source location for the
/// end of the import declaration.
llvm::PointerIntPair<Module *, 1, bool> ImportedAndComplete;

/// \brief The next import in the list of imports local to the translation
/// unit being parsed (not loaded from an AST file).
ImportDecl *NextLocalImport = nullptr;

ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
           ArrayRef<SourceLocation> IdentifierLocs);

ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
           SourceLocation EndLoc);

ImportDecl(EmptyShell Empty) : Decl(Import, Empty) {}

4015public:
/// \brief Create a new module import declaration.
static ImportDecl *Create(ASTContext &C, DeclContext *DC, 
                          SourceLocation StartLoc, Module *Imported,
                          ArrayRef<SourceLocation> IdentifierLocs);

/// \brief Create a new module import declaration for an implicitly-generated
/// import.
static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC, 
                                  SourceLocation StartLoc, Module *Imported, 
                                  SourceLocation EndLoc);

/// \brief Create a new, deserialized module import declaration.
static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID, 
                                      unsigned NumLocations);

/// \brief Retrieve the module that was imported by the import declaration.
Module *getImportedModule() const { return ImportedAndComplete.getPointer(); }

/// \brief Retrieves the locations of each of the identifiers that make up
/// the complete module name in the import declaration.
///
/// This will return an empty array if the locations of the individual
/// identifiers aren't available.
ArrayRef<SourceLocation> getIdentifierLocs() const;

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Import; }
4045};

4047/// \brief Represents a C++ Modules TS module export declaration.
4048///
4049/// For example:
4050/// \code
4051///   export void foo();
4052/// \endcode
4053class ExportDecl final : public Decl, public DeclContext {
virtual void anchor();

4056private:
friend class ASTDeclReader;

/// \brief The source location for the right brace (if valid).
SourceLocation RBraceLoc;

ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
    : Decl(Export, DC, ExportLoc), DeclContext(Export),
      RBraceLoc(SourceLocation()) {}

4066public:
static ExportDecl *Create(ASTContext &C, DeclContext *DC,
                          SourceLocation ExportLoc);
static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);

SourceLocation getExportLoc() const { return getLocation(); }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }

SourceLocation getLocEnd() const LLVM_READONLY__attribute__((__pure__)) {
  if (RBraceLoc.isValid())
    return RBraceLoc;
  // No braces: get the end location of the (only) declaration in context
  // (if present).
  return decls_empty() ? getLocation() : decls_begin()->getLocEnd();
}

SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getLocation(), getLocEnd());
}

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Export; }
static DeclContext *castToDeclContext(const ExportDecl *D) {
  return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
}
static ExportDecl *castFromDeclContext(const DeclContext *DC) {
  return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
}
4095};

4097/// Represents an empty-declaration.
4098class EmptyDecl : public Decl {
EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}

virtual void anchor();

4103public:
static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
                         SourceLocation L);
static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);

static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { return K == Empty; }
4110};

4112/// Insertion operator for diagnostics.  This allows sending NamedDecl's
4113/// into a diagnostic with <<.
4114inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         const NamedDecl* ND) {
DB.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
                DiagnosticsEngine::ak_nameddecl);
return DB;
4119}
4120inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         const NamedDecl* ND) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
                DiagnosticsEngine::ak_nameddecl);
return PD;
4125}

4127template<typename decl_type>
4128void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
// Note: This routine is implemented here because we need both NamedDecl
// and Redeclarable to be defined.
assert(RedeclLink.NextIsLatest() &&(static_cast <bool> (RedeclLink.NextIsLatest() &&
 "setPreviousDecl on a decl already in a redeclaration chain"
) ? void (0) : __assert_fail ("RedeclLink.NextIsLatest() && \"setPreviousDecl on a decl already in a redeclaration chain\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 4132, __extension__ __PRETTY_FUNCTION__))
       "setPreviousDecl on a decl already in a redeclaration chain")(static_cast <bool> (RedeclLink.NextIsLatest() &&
 "setPreviousDecl on a decl already in a redeclaration chain"
) ? void (0) : __assert_fail ("RedeclLink.NextIsLatest() && \"setPreviousDecl on a decl already in a redeclaration chain\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 4132, __extension__ __PRETTY_FUNCTION__));

if (PrevDecl) {
  // Point to previous. Make sure that this is actually the most recent
  // redeclaration, or we can build invalid chains. If the most recent
  // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
  First = PrevDecl->getFirstDecl();
  assert(First->RedeclLink.NextIsLatest() && "Expected first")(static_cast <bool> (First->RedeclLink.NextIsLatest(
) && "Expected first") ? void (0) : __assert_fail ("First->RedeclLink.NextIsLatest() && \"Expected first\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 4139, __extension__ __PRETTY_FUNCTION__));
  decl_type *MostRecent = First->getNextRedeclaration();
  RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));

  // If the declaration was previously visible, a redeclaration of it remains
  // visible even if it wouldn't be visible by itself.
  static_cast<decl_type*>(this)->IdentifierNamespace |=
    MostRecent->getIdentifierNamespace() &
    (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
} else {
  // Make this first.
  First = static_cast<decl_type*>(this);
}

// First one will point to this one as latest.
First->RedeclLink.setLatest(static_cast<decl_type*>(this));

assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||(static_cast <bool> (!isa<NamedDecl>(static_cast<
decl_type*>(this)) || cast<NamedDecl>(static_cast<
decl_type*>(this))->isLinkageValid()) ? void (0) : __assert_fail
 ("!isa<NamedDecl>(static_cast<decl_type*>(this)) || cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 4157, __extension__ __PRETTY_FUNCTION__))
       cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid())(static_cast <bool> (!isa<NamedDecl>(static_cast<
decl_type*>(this)) || cast<NamedDecl>(static_cast<
decl_type*>(this))->isLinkageValid()) ? void (0) : __assert_fail
 ("!isa<NamedDecl>(static_cast<decl_type*>(this)) || cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Decl.h"
, 4157, __extension__ __PRETTY_FUNCTION__));
4158}

4160// Inline function definitions.

4162/// Check if the given decl is complete.
4163///
4164/// We use this function to break a cycle between the inline definitions in
4165/// Type.h and Decl.h.
4166inline bool IsEnumDeclComplete(EnumDecl *ED) {
return ED->isComplete();
4168}

4170/// Check if the given decl is scoped.
4171///
4172/// We use this function to break a cycle between the inline definitions in
4173/// Type.h and Decl.h.
4174inline bool IsEnumDeclScoped(EnumDecl *ED) {
return ED->isScoped();
4176}

4178} // namespace clang

4180#endif // LLVM_CLANG_AST_DECL_H

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Redeclarable.h

→

1//===- Redeclarable.h - Base for Decls that can be redeclared --*- C++ -*-====//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file defines the Redeclarable interface.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_CLANG_AST_REDECLARABLE_H
15#define LLVM_CLANG_AST_REDECLARABLE_H
16 
17#include "clang/AST/ExternalASTSource.h"
18#include "llvm/ADT/DenseMapInfo.h"
19#include "llvm/ADT/PointerUnion.h"
20#include "llvm/ADT/iterator_range.h"
21#include "llvm/Support/Casting.h"
22#include <cassert>
23#include <cstddef>
24#include <iterator>
25 
26namespace clang {
27 
28class ASTContext;
29class Decl;
30 
31// Some notes on redeclarables:
32//
33//  - Every redeclarable is on a circular linked list.
34//
35//  - Every decl has a pointer to the first element of the chain _and_ a
36//    DeclLink that may point to one of 3 possible states:
37//      - the "previous" (temporal) element in the chain
38//      - the "latest" (temporal) element in the chain
39//      - the an "uninitialized-latest" value (when newly-constructed)
40//
41//  - The first element is also often called the canonical element. Every
42//    element has a pointer to it so that "getCanonical" can be fast.
43//
44//  - Most links in the chain point to previous, except the link out of
45//    the first; it points to latest.
46//
47//  - Elements are called "first", "previous", "latest" or
48//    "most-recent" when referring to temporal order: order of addition
49//    to the chain.
50//
51//  - To make matters confusing, the DeclLink type uses the term "next"
52//    for its pointer-storage internally (thus functions like
53//    NextIsPrevious). It's easiest to just ignore the implementation of
54//    DeclLink when making sense of the redeclaration chain.
55//
56//  - There's also a "definition" link for several types of
57//    redeclarable, where only one definition should exist at any given
58//    time (and the defn pointer is stored in the decl's "data" which
59//    is copied to every element on the chain when it's changed).
60//
61//    Here is some ASCII art:
62//
63//      "first"                                     "latest"
64//      "canonical"                                 "most recent"
65//      +------------+         first                +--------------+
66//      |            | <--------------------------- |              |
67//      |            |                              |              |
68//      |            |                              |              |
69//      |            |       +--------------+       |              |
70//      |            | first |              |       |              |
71//      |            | <---- |              |       |              |
72//      |            |       |              |       |              |
73//      | @class A   |  link | @interface A |  link | @class A     |
74//      | seen first | <---- | seen second  | <---- | seen third   |
75//      |            |       |              |       |              |
76//      +------------+       +--------------+       +--------------+
77//      | data       | defn  | data         |  defn | data         |
78//      |            | ----> |              | <---- |              |
79//      +------------+       +--------------+       +--------------+
80//        |                     |     ^                  ^
81//        |                     |defn |                  |
82//        | link                +-----+                  |
83//        +-->-------------------------------------------+
84 
85/// \brief Provides common interface for the Decls that can be redeclared.
86template<typename decl_type>
87class Redeclarable {
88protected:
89  class DeclLink {
90    /// A pointer to a known latest declaration, either statically known or
91    /// generationally updated as decls are added by an external source.
92    using KnownLatest =
93        LazyGenerationalUpdatePtr<const Decl *, Decl *,
94                                  &ExternalASTSource::CompleteRedeclChain>;
95 
96    /// We store a pointer to the ASTContext in the UninitializedLatest
97    /// pointer, but to avoid circular type dependencies when we steal the low
98    /// bits of this pointer, we use a raw void* here.
99    using UninitializedLatest = const void *;
100 
101    using Previous = Decl *;
102 
103    /// A pointer to either an uninitialized latest declaration (where either
104    /// we've not yet set the previous decl or there isn't one), or to a known
105    /// previous declaration.
106    using NotKnownLatest = llvm::PointerUnion<Previous, UninitializedLatest>;
107 
108    mutable llvm::PointerUnion<NotKnownLatest, KnownLatest> Next;
109 
110  public:
111    enum PreviousTag { PreviousLink };
112    enum LatestTag { LatestLink };
113 
114    DeclLink(LatestTag, const ASTContext &Ctx)
115        : Next(NotKnownLatest(reinterpret_cast<UninitializedLatest>(&Ctx))) {}
116    DeclLink(PreviousTag, decl_type *D) : Next(NotKnownLatest(Previous(D))) {}
117 
118    bool NextIsPrevious() const {
119      return Next.is<NotKnownLatest>() &&
120             // FIXME: 'template' is required on the next line due to an
121             // apparent clang bug.
122             Next.get<NotKnownLatest>().template is<Previous>();
123    }
124 
125    bool NextIsLatest() const { return !NextIsPrevious(); }
126 
127    decl_type *getNext(const decl_type *D) const {
128      if (Next.is<NotKnownLatest>()) {
40
←
Calling 'PointerUnion::is'→
46
←
Returning from 'PointerUnion::is'→
47
←
Taking false branch→
102
←
Calling 'PointerUnion::is'→
107
←
Returning from 'PointerUnion::is'→
108
←
Taking false branch→
161
←
Calling 'PointerUnion::is'→
166
←
Returning from 'PointerUnion::is'→
167
←
Taking false branch→
129        NotKnownLatest NKL = Next.get<NotKnownLatest>();
130        if (NKL.is<Previous>())
131          return static_cast<decl_type*>(NKL.get<Previous>());
132 
133        // Allocate the generational 'most recent' cache now, if needed.
134        Next = KnownLatest(*reinterpret_cast<const ASTContext *>(
135                               NKL.get<UninitializedLatest>()),
136                           const_cast<decl_type *>(D));
137      }
138 
139      return static_cast<decl_type*>(Next.get<KnownLatest>().get(D));
140    }
141 
142    void setPrevious(decl_type *D) {
143      assert(NextIsPrevious() && "decl became non-canonical unexpectedly")(static_cast <bool> (NextIsPrevious() && "decl became non-canonical unexpectedly"
) ? void (0) : __assert_fail ("NextIsPrevious() && \"decl became non-canonical unexpectedly\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Redeclarable.h"
, 143, __extension__ __PRETTY_FUNCTION__));
144      Next = Previous(D);
145    }
146 
147    void setLatest(decl_type *D) {
148      assert(NextIsLatest() && "decl became canonical unexpectedly")(static_cast <bool> (NextIsLatest() && "decl became canonical unexpectedly"
) ? void (0) : __assert_fail ("NextIsLatest() && \"decl became canonical unexpectedly\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Redeclarable.h"
, 148, __extension__ __PRETTY_FUNCTION__));
149      if (Next.is<NotKnownLatest>()) {
150        NotKnownLatest NKL = Next.get<NotKnownLatest>();
151        Next = KnownLatest(*reinterpret_cast<const ASTContext *>(
152                               NKL.get<UninitializedLatest>()),
153                           D);
154      } else {
155        auto Latest = Next.get<KnownLatest>();
156        Latest.set(D);
157        Next = Latest;
158      }
159    }
160 
161    void markIncomplete() { Next.get<KnownLatest>().markIncomplete(); }
162 
163    Decl *getLatestNotUpdated() const {
164      assert(NextIsLatest() && "expected a canonical decl")(static_cast <bool> (NextIsLatest() && "expected a canonical decl"
) ? void (0) : __assert_fail ("NextIsLatest() && \"expected a canonical decl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Redeclarable.h"
, 164, __extension__ __PRETTY_FUNCTION__));
165      if (Next.is<NotKnownLatest>())
166        return nullptr;
167      return Next.get<KnownLatest>().getNotUpdated();
168    }
169  };
170 
171  static DeclLink PreviousDeclLink(decl_type *D) {
172    return DeclLink(DeclLink::PreviousLink, D);
173  }
174 
175  static DeclLink LatestDeclLink(const ASTContext &Ctx) {
176    return DeclLink(DeclLink::LatestLink, Ctx);
177  }
178 
179  /// \brief Points to the next redeclaration in the chain.
180  ///
181  /// If NextIsPrevious() is true, this is a link to the previous declaration
182  /// of this same Decl. If NextIsLatest() is true, this is the first
183  /// declaration and Link points to the latest declaration. For example:
184  ///
185  ///  #1 int f(int x, int y = 1); // <pointer to #3, true>
186  ///  #2 int f(int x = 0, int y); // <pointer to #1, false>
187  ///  #3 int f(int x, int y) { return x + y; } // <pointer to #2, false>
188  ///
189  /// If there is only one declaration, it is <pointer to self, true>
190  DeclLink RedeclLink;
191 
192  decl_type *First;
193 
194  decl_type *getNextRedeclaration() const {
195    return RedeclLink.getNext(static_cast<const decl_type *>(this));
39
←
Calling 'DeclLink::getNext'→
48
←
Returning from 'DeclLink::getNext'→
101
←
Calling 'DeclLink::getNext'→
109
←
Returning from 'DeclLink::getNext'→
160
←
Calling 'DeclLink::getNext'→
168
←
Returning from 'DeclLink::getNext'→
196  }
197 
198public:
199  friend class ASTDeclReader;
200  friend class ASTDeclWriter;
201 
202  Redeclarable(const ASTContext &Ctx)
203      : RedeclLink(LatestDeclLink(Ctx)),
204        First(static_cast<decl_type *>(this)) {}
205 
206  /// \brief Return the previous declaration of this declaration or NULL if this
207  /// is the first declaration.
208  decl_type *getPreviousDecl() {
209    if (RedeclLink.NextIsPrevious())
210      return getNextRedeclaration();
211    return nullptr;
212  }
213  const decl_type *getPreviousDecl() const {
214    return const_cast<decl_type *>(
215                 static_cast<const decl_type*>(this))->getPreviousDecl();
216  }
217 
218  /// \brief Return the first declaration of this declaration or itself if this
219  /// is the only declaration.
220  decl_type *getFirstDecl() { return First; }
221 
222  /// \brief Return the first declaration of this declaration or itself if this
223  /// is the only declaration.
224  const decl_type *getFirstDecl() const { return First; }
225 
226  /// \brief True if this is the first declaration in its redeclaration chain.
227  bool isFirstDecl() const { return RedeclLink.NextIsLatest(); }
228 
229  /// \brief Returns the most recent (re)declaration of this declaration.
230  decl_type *getMostRecentDecl() {
231    return getFirstDecl()->getNextRedeclaration();
36
←
Calling 'Redeclarable::getFirstDecl'→
37
←
Returning from 'Redeclarable::getFirstDecl'→
38
←
Calling 'Redeclarable::getNextRedeclaration'→
49
←
Returning from 'Redeclarable::getNextRedeclaration'→
98
←
Calling 'Redeclarable::getFirstDecl'→
99
←
Returning from 'Redeclarable::getFirstDecl'→
100
←
Calling 'Redeclarable::getNextRedeclaration'→
110
←
Returning from 'Redeclarable::getNextRedeclaration'→
157
←
Calling 'Redeclarable::getFirstDecl'→
158
←
Returning from 'Redeclarable::getFirstDecl'→
159
←
Calling 'Redeclarable::getNextRedeclaration'→
169
←
Returning from 'Redeclarable::getNextRedeclaration'→
232  }
233 
234  /// \brief Returns the most recent (re)declaration of this declaration.
235  const decl_type *getMostRecentDecl() const {
236    return getFirstDecl()->getNextRedeclaration();
237  }
238 
239  /// \brief Set the previous declaration. If PrevDecl is NULL, set this as the
240  /// first and only declaration.
241  void setPreviousDecl(decl_type *PrevDecl);
242 
243  /// \brief Iterates through all the redeclarations of the same decl.
244  class redecl_iterator {
245    /// Current - The current declaration.
246    decl_type *Current = nullptr;
247    decl_type *Starter;
248    bool PassedFirst = false;
249 
250  public:
251    using value_type = decl_type *;
252    using reference = decl_type *;
253    using pointer = decl_type *;
254    using iterator_category = std::forward_iterator_tag;
255    using difference_type = std::ptrdiff_t;
256 
257    redecl_iterator() = default;
258    explicit redecl_iterator(decl_type *C) : Current(C), Starter(C) {}
259 
260    reference operator*() const { return Current; }
261    pointer operator->() const { return Current; }
262 
263    redecl_iterator& operator++() {
264      assert(Current && "Advancing while iterator has reached end")(static_cast <bool> (Current && "Advancing while iterator has reached end"
) ? void (0) : __assert_fail ("Current && \"Advancing while iterator has reached end\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Redeclarable.h"
, 264, __extension__ __PRETTY_FUNCTION__));
265      // Sanity check to avoid infinite loop on invalid redecl chain.
266      if (Current->isFirstDecl()) {
267        if (PassedFirst) {
268          assert(0 && "Passed first decl twice, invalid redecl chain!")(static_cast <bool> (0 && "Passed first decl twice, invalid redecl chain!"
) ? void (0) : __assert_fail ("0 && \"Passed first decl twice, invalid redecl chain!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Redeclarable.h"
, 268, __extension__ __PRETTY_FUNCTION__));
269          Current = nullptr;
270          return *this;
271        }
272        PassedFirst = true;
273      }
274 
275      // Get either previous decl or latest decl.
276      decl_type *Next = Current->getNextRedeclaration();
277      Current = (Next != Starter) ? Next : nullptr;
278      return *this;
279    }
280 
281    redecl_iterator operator++(int) {
282      redecl_iterator tmp(*this);
283      ++(*this);
284      return tmp;
285    }
286 
287    friend bool operator==(redecl_iterator x, redecl_iterator y) {
288      return x.Current == y.Current;
289    }
290    friend bool operator!=(redecl_iterator x, redecl_iterator y) {
291      return x.Current != y.Current;
292    }
293  };
294 
295  using redecl_range = llvm::iterator_range<redecl_iterator>;
296 
297  /// \brief Returns an iterator range for all the redeclarations of the same
298  /// decl. It will iterate at least once (when this decl is the only one).
299  redecl_range redecls() const {
300    return redecl_range(redecl_iterator(const_cast<decl_type *>(
301                            static_cast<const decl_type *>(this))),
302                        redecl_iterator());
303  }
304 
305  redecl_iterator redecls_begin() const { return redecls().begin(); }
306  redecl_iterator redecls_end() const { return redecls().end(); }
307};
308 
309/// \brief Get the primary declaration for a declaration from an AST file. That
310/// will be the first-loaded declaration.
311Decl *getPrimaryMergedDecl(Decl *D);
312 
313/// \brief Provides common interface for the Decls that cannot be redeclared,
314/// but can be merged if the same declaration is brought in from multiple
315/// modules.
316template<typename decl_type>
317class Mergeable {
318public:
319  Mergeable() = default;
320 
321  /// \brief Return the first declaration of this declaration or itself if this
322  /// is the only declaration.
323  decl_type *getFirstDecl() {
324    decl_type *D = static_cast<decl_type*>(this);
325    if (!D->isFromASTFile())
326      return D;
327    return cast<decl_type>(getPrimaryMergedDecl(const_cast<decl_type*>(D)));
328  }
329 
330  /// \brief Return the first declaration of this declaration or itself if this
331  /// is the only declaration.
332  const decl_type *getFirstDecl() const {
333    const decl_type *D = static_cast<const decl_type*>(this);
334    if (!D->isFromASTFile())
335      return D;
336    return cast<decl_type>(getPrimaryMergedDecl(const_cast<decl_type*>(D)));
337  }
338 
339  /// \brief Returns true if this is the first declaration.
340  bool isFirstDecl() const { return getFirstDecl() == this; }
341};
342 
343/// A wrapper class around a pointer that always points to its canonical
344/// declaration.
345///
346/// CanonicalDeclPtr<decl_type> behaves just like decl_type*, except we call
347/// decl_type::getCanonicalDecl() on construction.
348///
349/// This is useful for hashtables that you want to be keyed on a declaration's
350/// canonical decl -- if you use CanonicalDeclPtr as the key, you don't need to
351/// remember to call getCanonicalDecl() everywhere.
352template <typename decl_type> class CanonicalDeclPtr {
353public:
354  CanonicalDeclPtr() = default;
355  CanonicalDeclPtr(decl_type *Ptr)
356      : Ptr(Ptr ? Ptr->getCanonicalDecl() : nullptr) {}
357  CanonicalDeclPtr(const CanonicalDeclPtr &) = default;
358  CanonicalDeclPtr &operator=(const CanonicalDeclPtr &) = default;
359 
360  operator decl_type *() { return Ptr; }
361  operator const decl_type *() const { return Ptr; }
362 
363  decl_type *operator->() { return Ptr; }
364  const decl_type *operator->() const { return Ptr; }
365 
366  decl_type &operator*() { return *Ptr; }
367  const decl_type &operator*() const { return *Ptr; }
368 
369private:
370  friend struct llvm::DenseMapInfo<CanonicalDeclPtr<decl_type>>;
371 
372  decl_type *Ptr = nullptr;
373};
374 
375} // namespace clang
376 
377namespace llvm {
378 
379template <typename decl_type>
380struct DenseMapInfo<clang::CanonicalDeclPtr<decl_type>> {
381  using CanonicalDeclPtr = clang::CanonicalDeclPtr<decl_type>;
382  using BaseInfo = DenseMapInfo<decl_type *>;
383 
384  static CanonicalDeclPtr getEmptyKey() {
385    // Construct our CanonicalDeclPtr this way because the regular constructor
386    // would dereference P.Ptr, which is not allowed.
387    CanonicalDeclPtr P;
388    P.Ptr = BaseInfo::getEmptyKey();
389    return P;
390  }
391 
392  static CanonicalDeclPtr getTombstoneKey() {
393    CanonicalDeclPtr P;
394    P.Ptr = BaseInfo::getTombstoneKey();
395    return P;
396  }
397 
398  static unsigned getHashValue(const CanonicalDeclPtr &P) {
399    return BaseInfo::getHashValue(P);
400  }
401 
402  static bool isEqual(const CanonicalDeclPtr &LHS,
403                      const CanonicalDeclPtr &RHS) {
404    return BaseInfo::isEqual(LHS, RHS);
405  }
406};
407 
408} // namespace llvm
409 
410#endif // LLVM_CLANG_AST_REDECLARABLE_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerUnion.h

→

//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===//

// The LLVM Compiler Infrastructure

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//===----------------------------------------------------------------------===//

// This file defines the PointerUnion class, which is a discriminated union of

// pointer types.

//===----------------------------------------------------------------------===//

#ifndef LLVM_ADT_POINTERUNION_H

#define LLVM_ADT_POINTERUNION_H

#include "llvm/ADT/DenseMapInfo.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/Support/PointerLikeTypeTraits.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

namespace llvm {

template <typename T> struct PointerUnionTypeSelectorReturn {

using Return = T;

};

/// Get a type based on whether two types are the same or not.

///

/// For:

///

/// \code

/// using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;

/// \endcode

///

/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.

template <typename T1, typename T2, typename RET_EQ, typename RET_NE>

struct PointerUnionTypeSelector {

using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;

};

template <typename T, typename RET_EQ, typename RET_NE>

struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {

using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;

};

template <typename T1, typename T2, typename RET_EQ, typename RET_NE>

struct PointerUnionTypeSelectorReturn<

PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {

using Return =

typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;

};

/// Provide PointerLikeTypeTraits for void* that is used by PointerUnion

/// for the two template arguments.

template <typename PT1, typename PT2> class PointerUnionUIntTraits {

public:

static inline void *getAsVoidPointer(void *P) { return P; }

static inline void *getFromVoidPointer(void *P) { return P; }

enum {

PT1BitsAv = (int)(PointerLikeTypeTraits<PT1>::NumLowBitsAvailable),

PT2BitsAv = (int)(PointerLikeTypeTraits<PT2>::NumLowBitsAvailable),

NumLowBitsAvailable = PT1BitsAv < PT2BitsAv ? PT1BitsAv : PT2BitsAv

};

/// A discriminated union of two pointer types, with the discriminator in the

/// low bit of the pointer.

///

/// This implementation is extremely efficient in space due to leveraging the

/// low bits of the pointer, while exposing a natural and type-safe API.

///

/// Common use patterns would be something like this:

/// PointerUnion<int*, float*> P;

/// P = (int*)0;

/// printf("%d %d", P.is<int*>(), P.is<float*>()); // prints "1 0"

/// X = P.get<int*>(); // ok.

/// Y = P.get<float*>(); // runtime assertion failure.

/// Z = P.get<double*>(); // compile time failure.

/// P = (float*)0;

/// Y = P.get<float*>(); // ok.

/// X = P.get<int*>(); // runtime assertion failure.

template <typename PT1, typename PT2> class PointerUnion {

public:

using ValTy =

PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>;

private:

ValTy Val;

struct IsPT1 {

static const int Num = 0;

};

struct IsPT2 {

static const int Num = 1;

100

};

101

template <typename T> struct UNION_DOESNT_CONTAIN_TYPE {};

102

103

public:

104

PointerUnion() = default;

218

←

Calling defaulted default constructor for 'PointerIntPair'

→

219

←

Returning from default constructor for 'PointerIntPair'

→

305

←

Calling defaulted default constructor for 'PointerIntPair'

→

306

←

Returning from default constructor for 'PointerIntPair'

→

365

←

Calling defaulted default constructor for 'PointerIntPair'

→

366

←

Returning from default constructor for 'PointerIntPair'

→

423

←

Calling defaulted default constructor for 'PointerIntPair'

→

424

←

Returning from default constructor for 'PointerIntPair'

→

483

←

Calling defaulted default constructor for 'PointerIntPair'

→

484

←

Returning from default constructor for 'PointerIntPair'

→

547

←

Calling defaulted default constructor for 'PointerIntPair'

→

548

←

Returning from default constructor for 'PointerIntPair'

→

633

←

Calling defaulted default constructor for 'PointerIntPair'

→

634

←

Returning from default constructor for 'PointerIntPair'

→

693

←

Calling defaulted default constructor for 'PointerIntPair'

→

694

←

Returning from default constructor for 'PointerIntPair'

→

751

←

Calling defaulted default constructor for 'PointerIntPair'

→

752

←

Returning from default constructor for 'PointerIntPair'

→

811

←

Calling defaulted default constructor for 'PointerIntPair'

→

812

←

Returning from default constructor for 'PointerIntPair'

→

105

PointerUnion(PT1 V)

106

: Val(const_cast<void *>(

266

←

Calling constructor for 'PointerIntPair'

→

274

←

Returning from constructor for 'PointerIntPair'

→

594

←

Calling constructor for 'PointerIntPair'

→

602

←

Returning from constructor for 'PointerIntPair'

→

107

PointerLikeTypeTraits<PT1>::getAsVoidPointer(V))) {}

262

←

Calling 'PointerLikeTypeTraits::getAsVoidPointer'

→

265

←

Returning from 'PointerLikeTypeTraits::getAsVoidPointer'

→

590

←

Calling 'PointerLikeTypeTraits::getAsVoidPointer'

→

593

←

Returning from 'PointerLikeTypeTraits::getAsVoidPointer'

→

108

PointerUnion(PT2 V)

109

: Val(const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(V)),

110

1) {}

111

112

/// Test if the pointer held in the union is null, regardless of

113

/// which type it is.

114

bool isNull() const {

115

// Convert from the void* to one of the pointer types, to make sure that

116

// we recursively strip off low bits if we have a nested PointerUnion.

117

return !PointerLikeTypeTraits<PT1>::getFromVoidPointer(Val.getPointer());

232

←

Calling 'PointerIntPair::getPointer'

→

237

←

Returning from 'PointerIntPair::getPointer'

→

238

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

241

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

242

←

Assuming the condition is false

→

319

←

Calling 'PointerIntPair::getPointer'

→

324

←

Returning from 'PointerIntPair::getPointer'

→

325

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

328

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

329

←

Assuming the condition is false

→

379

←

Calling 'PointerIntPair::getPointer'

→

384

←

Returning from 'PointerIntPair::getPointer'

→

385

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

388

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

389

←

Assuming the condition is false

→

437

←

Calling 'PointerIntPair::getPointer'

→

442

←

Returning from 'PointerIntPair::getPointer'

→

443

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

446

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

447

←

Assuming the condition is false

→

497

←

Calling 'PointerIntPair::getPointer'

→

502

←

Returning from 'PointerIntPair::getPointer'

→

503

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

506

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

507

←

Assuming the condition is false

→

561

←

Calling 'PointerIntPair::getPointer'

→

566

←

Returning from 'PointerIntPair::getPointer'

→

567

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

570

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

571

←

Assuming the condition is false

→

647

←

Calling 'PointerIntPair::getPointer'

→

652

←

Returning from 'PointerIntPair::getPointer'

→

653

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

656

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

657

←

Assuming the condition is false

→

707

←

Calling 'PointerIntPair::getPointer'

→

712

←

Returning from 'PointerIntPair::getPointer'

→

713

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

716

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

717

←

Assuming the condition is false

→

765

←

Calling 'PointerIntPair::getPointer'

→

770

←

Returning from 'PointerIntPair::getPointer'

→

771

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

774

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

775

←

Assuming the condition is false

→

825

←

Calling 'PointerIntPair::getPointer'

→

830

←

Returning from 'PointerIntPair::getPointer'

→

831

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

834

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

835

←

Assuming the condition is false

→

118

}

119

120

explicit operator bool() const { return !isNull(); }

121

122

/// Test if the Union currently holds the type matching T.

123

template <typename T> int is() const {

124

using Ty = typename ::llvm::PointerUnionTypeSelector<

125

PT1, T, IsPT1,

126

::llvm::PointerUnionTypeSelector<PT2, T, IsPT2,

127

UNION_DOESNT_CONTAIN_TYPE<T>>>::Return;

128

int TyNo = Ty::Num;

129

return static_cast<int>(Val.getInt()) == TyNo;

←

Calling 'PointerIntPair::getInt'

→

←

Returning from 'PointerIntPair::getInt'

→

←

Assuming the condition is false

→

103

←

Calling 'PointerIntPair::getInt'

→

106

←

Returning from 'PointerIntPair::getInt'

→

162

←

Calling 'PointerIntPair::getInt'

→

165

←

Returning from 'PointerIntPair::getInt'

→

130

}

131

132

/// Returns the value of the specified pointer type.

133

///

134

/// If the specified pointer type is incorrect, assert.

135

template <typename T> T get() const {

136

assert(is<T>() && "Invalid accessor called")(static_cast <bool> (is<T>() && "Invalid accessor called"
) ? void (0) : __assert_fail ("is<T>() && \"Invalid accessor called\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerUnion.h"
, 136, __extension__ __PRETTY_FUNCTION__));

137

return PointerLikeTypeTraits<T>::getFromVoidPointer(Val.getPointer());

138

}

139

140

/// Returns the current pointer if it is of the specified pointer type,

141

/// otherwises returns null.

142

template <typename T> T dyn_cast() const {

143

if (is<T>())

144

return get<T>();

145

return T();

146

}

147

148

/// If the union is set to the first pointer type get an address pointing to

149

/// it.

150

PT1 const *getAddrOfPtr1() const {

151

return const_cast<PointerUnion *>(this)->getAddrOfPtr1();

152

}

153

154

/// If the union is set to the first pointer type get an address pointing to

155

/// it.

156

PT1 *getAddrOfPtr1() {

157

assert(is<PT1>() && "Val is not the first pointer")(static_cast <bool> (is<PT1>() && "Val is not the first pointer"
) ? void (0) : __assert_fail ("is<PT1>() && \"Val is not the first pointer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerUnion.h"
, 157, __extension__ __PRETTY_FUNCTION__));

158

assert((static_cast <bool> (get<PT1>() == Val.getPointer
() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? void (0) : __assert_fail ("get<PT1>() == Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerUnion.h"
, 160, __extension__ __PRETTY_FUNCTION__))

159

get<PT1>() == Val.getPointer() &&(static_cast <bool> (get<PT1>() == Val.getPointer
() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? void (0) : __assert_fail ("get<PT1>() == Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerUnion.h"
, 160, __extension__ __PRETTY_FUNCTION__))

160

"Can't get the address because PointerLikeTypeTraits changes the ptr")(static_cast <bool> (get<PT1>() == Val.getPointer
() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? void (0) : __assert_fail ("get<PT1>() == Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerUnion.h"
, 160, __extension__ __PRETTY_FUNCTION__));

161

return const_cast<PT1 *>(

162

reinterpret_cast<const PT1 *>(Val.getAddrOfPointer()));

163

}

164

165

/// Assignment from nullptr which just clears the union.

166

const PointerUnion &operator=(std::nullptr_t) {

167

Val.initWithPointer(nullptr);

168

return *this;

169

}

170

171

/// Assignment operators - Allow assigning into this union from either

172

/// pointer type, setting the discriminator to remember what it came from.

173

const PointerUnion &operator=(const PT1 &RHS) {

174

Val.initWithPointer(

175

const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(RHS)));

176

return *this;

177

}

178

const PointerUnion &operator=(const PT2 &RHS) {

179

Val.setPointerAndInt(

180

const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(RHS)),

181

1);

182

return *this;

183

}

184

185

void *getOpaqueValue() const { return Val.getOpaqueValue(); }

281

←

Calling 'PointerIntPair::getOpaqueValue'

→

282

←

Returning from 'PointerIntPair::getOpaqueValue'

→

609

←

Calling 'PointerIntPair::getOpaqueValue'

→

610

←

Returning from 'PointerIntPair::getOpaqueValue'

→

186

static inline PointerUnion getFromOpaqueValue(void *VP) {

187

PointerUnion V;

217

←

Calling defaulted default constructor for 'PointerUnion'

→

220

←

Returning from default constructor for 'PointerUnion'

→

304

←

Calling defaulted default constructor for 'PointerUnion'

→

307

←

Returning from default constructor for 'PointerUnion'

→

364

←

Calling defaulted default constructor for 'PointerUnion'

→

367

←

Returning from default constructor for 'PointerUnion'

→

422

←

Calling defaulted default constructor for 'PointerUnion'

→

425

←

Returning from default constructor for 'PointerUnion'

→

482

←

Calling defaulted default constructor for 'PointerUnion'

→

485

←

Returning from default constructor for 'PointerUnion'

→

546

←

Calling defaulted default constructor for 'PointerUnion'

→

549

←

Returning from default constructor for 'PointerUnion'

→

632

←

Calling defaulted default constructor for 'PointerUnion'

→

635

←

Returning from default constructor for 'PointerUnion'

→

692

←

Calling defaulted default constructor for 'PointerUnion'

→

695

←

Returning from default constructor for 'PointerUnion'

→

750

←

Calling defaulted default constructor for 'PointerUnion'

→

753

←

Returning from default constructor for 'PointerUnion'

→

810

←

Calling defaulted default constructor for 'PointerUnion'

→

813

←

Returning from default constructor for 'PointerUnion'

→

188

V.Val = ValTy::getFromOpaqueValue(VP);

221

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

226

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

308

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

313

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

368

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

373

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

426

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

431

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

486

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

491

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

550

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

555

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

636

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

641

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

696

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

701

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

754

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

759

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

814

←

Calling 'PointerIntPair::getFromOpaqueValue'

→

819

←

Returning from 'PointerIntPair::getFromOpaqueValue'

→

189

return V;

190

}

191

};

192

193

template <typename PT1, typename PT2>

194

bool operator==(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) {

195

return lhs.getOpaqueValue() == rhs.getOpaqueValue();

196

}

197

198

template <typename PT1, typename PT2>

199

bool operator!=(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) {

200

return lhs.getOpaqueValue() != rhs.getOpaqueValue();

201

}

202

203

template <typename PT1, typename PT2>

204

bool operator<(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) {

205

return lhs.getOpaqueValue() < rhs.getOpaqueValue();

206

}

207

208

// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has

209

// # low bits available = min(PT1bits,PT2bits)-1.

210

template <typename PT1, typename PT2>

211

struct PointerLikeTypeTraits<PointerUnion<PT1, PT2>> {

212

static inline void *getAsVoidPointer(const PointerUnion<PT1, PT2> &P) {

213

return P.getOpaqueValue();

280

←

Calling 'PointerUnion::getOpaqueValue'

→

283

←

Returning from 'PointerUnion::getOpaqueValue'

→

608

←

Calling 'PointerUnion::getOpaqueValue'

→

611

←

Returning from 'PointerUnion::getOpaqueValue'

→

214

}

215

216

static inline PointerUnion<PT1, PT2> getFromVoidPointer(void *P) {

217

return PointerUnion<PT1, PT2>::getFromOpaqueValue(P);

216

←

Calling 'PointerUnion::getFromOpaqueValue'

→

227

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

303

←

Calling 'PointerUnion::getFromOpaqueValue'

→

314

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

363

←

Calling 'PointerUnion::getFromOpaqueValue'

→

374

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

421

←

Calling 'PointerUnion::getFromOpaqueValue'

→

432

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

481

←

Calling 'PointerUnion::getFromOpaqueValue'

→

492

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

545

←

Calling 'PointerUnion::getFromOpaqueValue'

→

556

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

631

←

Calling 'PointerUnion::getFromOpaqueValue'

→

642

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

691

←

Calling 'PointerUnion::getFromOpaqueValue'

→

702

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

749

←

Calling 'PointerUnion::getFromOpaqueValue'

→

760

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

809

←

Calling 'PointerUnion::getFromOpaqueValue'

→

820

←

Returning from 'PointerUnion::getFromOpaqueValue'

→

218

}

219

220

// The number of bits available are the min of the two pointer types.

221

enum {

222

NumLowBitsAvailable = PointerLikeTypeTraits<

223

typename PointerUnion<PT1, PT2>::ValTy>::NumLowBitsAvailable

224

};

225

};

226

227

/// A pointer union of three pointer types. See documentation for PointerUnion

228

/// for usage.

229

template <typename PT1, typename PT2, typename PT3> class PointerUnion3 {

230

public:

231

using InnerUnion = PointerUnion<PT1, PT2>;

232

using ValTy = PointerUnion<InnerUnion, PT3>;

233

234

private:

235

ValTy Val;

236

237

struct IsInnerUnion {

238

ValTy Val;

239

240

IsInnerUnion(ValTy val) : Val(val) {}

241

242

template <typename T> int is() const {

243

return Val.template is<InnerUnion>() &&

244

Val.template get<InnerUnion>().template is<T>();

245

}

246

247

template <typename T> T get() const {

248

return Val.template get<InnerUnion>().template get<T>();

249

}

250

};

251

252

struct IsPT3 {

253

ValTy Val;

254

255

IsPT3(ValTy val) : Val(val) {}

256

257

template <typename T> int is() const { return Val.template is<T>(); }

258

template <typename T> T get() const { return Val.template get<T>(); }

259

};

260

261

public:

262

PointerUnion3() = default;

263

PointerUnion3(PT1 V) { Val = InnerUnion(V); }

264

PointerUnion3(PT2 V) { Val = InnerUnion(V); }

265

PointerUnion3(PT3 V) { Val = V; }

266

267

/// Test if the pointer held in the union is null, regardless of

268

/// which type it is.

269

bool isNull() const { return Val.isNull(); }

270

explicit operator bool() const { return !isNull(); }

271

272

/// Test if the Union currently holds the type matching T.

273

template <typename T> int is() const {

274

// If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.

275

using Ty = typename ::llvm::PointerUnionTypeSelector<

276

PT1, T, IsInnerUnion,

277

::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;

278

return Ty(Val).template is<T>();

279

}

280

281

/// Returns the value of the specified pointer type.

282

///

283

/// If the specified pointer type is incorrect, assert.

284

template <typename T> T get() const {

285

286

// If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.

287

using Ty = typename ::llvm::PointerUnionTypeSelector<

288

PT1, T, IsInnerUnion,

289

::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;

290

return Ty(Val).template get<T>();

291

}

292

293

/// Returns the current pointer if it is of the specified pointer type,

294

/// otherwises returns null.

295

template <typename T> T dyn_cast() const {

296

if (is<T>())

297

return get<T>();

298

return T();

299

}

300

301

/// Assignment from nullptr which just clears the union.

302

const PointerUnion3 &operator=(std::nullptr_t) {

303

Val = nullptr;

304

return *this;

305

}

306

307

/// Assignment operators - Allow assigning into this union from either

308

/// pointer type, setting the discriminator to remember what it came from.

309

const PointerUnion3 &operator=(const PT1 &RHS) {

310

Val = InnerUnion(RHS);

311

return *this;

312

}

313

const PointerUnion3 &operator=(const PT2 &RHS) {

314

Val = InnerUnion(RHS);

315

return *this;

316

}

317

const PointerUnion3 &operator=(const PT3 &RHS) {

318

Val = RHS;

319

return *this;

320

}

321

322

void *getOpaqueValue() const { return Val.getOpaqueValue(); }

323

static inline PointerUnion3 getFromOpaqueValue(void *VP) {

324

PointerUnion3 V;

325

V.Val = ValTy::getFromOpaqueValue(VP);

326

return V;

327

}

328

};

329

330

// Teach SmallPtrSet that PointerUnion3 is "basically a pointer", that has

331

// # low bits available = min(PT1bits,PT2bits,PT2bits)-2.

332

template <typename PT1, typename PT2, typename PT3>

333

struct PointerLikeTypeTraits<PointerUnion3<PT1, PT2, PT3>> {

334

static inline void *getAsVoidPointer(const PointerUnion3<PT1, PT2, PT3> &P) {

335

return P.getOpaqueValue();

336

}

337

338

static inline PointerUnion3<PT1, PT2, PT3> getFromVoidPointer(void *P) {

339

return PointerUnion3<PT1, PT2, PT3>::getFromOpaqueValue(P);

340

}

341

342

// The number of bits available are the min of the two pointer types.

343

enum {

344

NumLowBitsAvailable = PointerLikeTypeTraits<

345

typename PointerUnion3<PT1, PT2, PT3>::ValTy>::NumLowBitsAvailable

346

};

347

};

348

349

/// A pointer union of four pointer types. See documentation for PointerUnion

350

/// for usage.

351

template <typename PT1, typename PT2, typename PT3, typename PT4>

352

class PointerUnion4 {

353

public:

354

using InnerUnion1 = PointerUnion<PT1, PT2>;

355

using InnerUnion2 = PointerUnion<PT3, PT4>;

356

using ValTy = PointerUnion<InnerUnion1, InnerUnion2>;

357

358

private:

359

ValTy Val;

360

361

public:

362

PointerUnion4() = default;

363

PointerUnion4(PT1 V) { Val = InnerUnion1(V); }

364

PointerUnion4(PT2 V) { Val = InnerUnion1(V); }

365

PointerUnion4(PT3 V) { Val = InnerUnion2(V); }

366

PointerUnion4(PT4 V) { Val = InnerUnion2(V); }

367

368

/// Test if the pointer held in the union is null, regardless of

369

/// which type it is.

370

bool isNull() const { return Val.isNull(); }

371

explicit operator bool() const { return !isNull(); }

372

373

/// Test if the Union currently holds the type matching T.

374

template <typename T> int is() const {

375

// If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.

376

using Ty = typename ::llvm::PointerUnionTypeSelector<

377

PT1, T, InnerUnion1,

378

::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,

379

InnerUnion2>>::Return;

380

return Val.template is<Ty>() && Val.template get<Ty>().template is<T>();

381

}

382

383

/// Returns the value of the specified pointer type.

384

///

385

/// If the specified pointer type is incorrect, assert.

386

template <typename T> T get() const {

387

388

// If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.

389

using Ty = typename ::llvm::PointerUnionTypeSelector<

390

PT1, T, InnerUnion1,

391

::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,

392

InnerUnion2>>::Return;

393

return Val.template get<Ty>().template get<T>();

394

}

395

396

/// Returns the current pointer if it is of the specified pointer type,

397

/// otherwises returns null.

398

template <typename T> T dyn_cast() const {

399

if (is<T>())

400

return get<T>();

401

return T();

402

}

403

404

/// Assignment from nullptr which just clears the union.

405

const PointerUnion4 &operator=(std::nullptr_t) {

406

Val = nullptr;

407

return *this;

408

}

409

410

/// Assignment operators - Allow assigning into this union from either

411

/// pointer type, setting the discriminator to remember what it came from.

412

const PointerUnion4 &operator=(const PT1 &RHS) {

413

Val = InnerUnion1(RHS);

414

return *this;

415

}

416

const PointerUnion4 &operator=(const PT2 &RHS) {

417

Val = InnerUnion1(RHS);

418

return *this;

419

}

420

const PointerUnion4 &operator=(const PT3 &RHS) {

421

Val = InnerUnion2(RHS);

422

return *this;

423

}

424

const PointerUnion4 &operator=(const PT4 &RHS) {

425

Val = InnerUnion2(RHS);

426

return *this;

427

}

428

429

void *getOpaqueValue() const { return Val.getOpaqueValue(); }

430

static inline PointerUnion4 getFromOpaqueValue(void *VP) {

431

PointerUnion4 V;

432

V.Val = ValTy::getFromOpaqueValue(VP);

433

return V;

434

}

435

};

436

437

// Teach SmallPtrSet that PointerUnion4 is "basically a pointer", that has

438

// # low bits available = min(PT1bits,PT2bits,PT2bits)-2.

439

template <typename PT1, typename PT2, typename PT3, typename PT4>

440

struct PointerLikeTypeTraits<PointerUnion4<PT1, PT2, PT3, PT4>> {

441

static inline void *

442

getAsVoidPointer(const PointerUnion4<PT1, PT2, PT3, PT4> &P) {

443

return P.getOpaqueValue();

444

}

445

446

static inline PointerUnion4<PT1, PT2, PT3, PT4> getFromVoidPointer(void *P) {

447

return PointerUnion4<PT1, PT2, PT3, PT4>::getFromOpaqueValue(P);

448

}

449

450

// The number of bits available are the min of the two pointer types.

451

enum {

452

NumLowBitsAvailable = PointerLikeTypeTraits<

453

typename PointerUnion4<PT1, PT2, PT3, PT4>::ValTy>::NumLowBitsAvailable

454

};

455

};

456

457

// Teach DenseMap how to use PointerUnions as keys.

458

template <typename T, typename U> struct DenseMapInfo<PointerUnion<T, U>> {

459

using Pair = PointerUnion<T, U>;

460

using FirstInfo = DenseMapInfo<T>;

461

using SecondInfo = DenseMapInfo<U>;

462

463

static inline Pair getEmptyKey() { return Pair(FirstInfo::getEmptyKey()); }

464

465

static inline Pair getTombstoneKey() {

466

return Pair(FirstInfo::getTombstoneKey());

467

}

468

469

static unsigned getHashValue(const Pair &PairVal) {

470

intptr_t key = (intptr_t)PairVal.getOpaqueValue();

471

return DenseMapInfo<intptr_t>::getHashValue(key);

472

}

473

474

static bool isEqual(const Pair &LHS, const Pair &RHS) {

475

return LHS.template is<T>() == RHS.template is<T>() &&

476

(LHS.template is<T>() ? FirstInfo::isEqual(LHS.template get<T>(),

477

RHS.template get<T>())

478

: SecondInfo::isEqual(LHS.template get<U>(),

479

RHS.template get<U>()));

480

}

481

};

482

483

} // end namespace llvm

484

485

#endif // LLVM_ADT_POINTERUNION_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerIntPair.h

→

//===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- C++ -*-===//

// The LLVM Compiler Infrastructure

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//===----------------------------------------------------------------------===//

// This file defines the PointerIntPair class.

//===----------------------------------------------------------------------===//

#ifndef LLVM_ADT_POINTERINTPAIR_H

#define LLVM_ADT_POINTERINTPAIR_H

#include "llvm/Support/PointerLikeTypeTraits.h"

#include <cassert>

#include <cstdint>

#include <limits>

namespace llvm {

template <typename T> struct DenseMapInfo;

template <typename PointerT, unsigned IntBits, typename PtrTraits>

struct PointerIntPairInfo;

/// PointerIntPair - This class implements a pair of a pointer and small

/// integer. It is designed to represent this in the space required by one

/// pointer by bitmangling the integer into the low part of the pointer. This

/// can only be done for small integers: typically up to 3 bits, but it depends

/// on the number of bits available according to PointerLikeTypeTraits for the

/// type.

///

/// Note that PointerIntPair always puts the IntVal part in the highest bits

/// possible. For example, PointerIntPair<void*, 1, bool> will put the bit for

/// the bool into bit #2, not bit #0, which allows the low two bits to be used

/// for something else. For example, this allows:

/// PointerIntPair<PointerIntPair<void*, 1, bool>, 1, bool>

/// ... and the two bools will land in different bits.

template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,

typename PtrTraits = PointerLikeTypeTraits<PointerTy>,

typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>

class PointerIntPair {

intptr_t Value = 0;

public:

constexpr PointerIntPair() = default;

PointerIntPair(PointerTy PtrVal, IntType IntVal) {

setPointerAndInt(PtrVal, IntVal);

277

←

Calling 'PointerIntPair::setPointerAndInt'

→

290

←

Returning from 'PointerIntPair::setPointerAndInt'

→

605

←

Calling 'PointerIntPair::setPointerAndInt'

→

618

←

Returning from 'PointerIntPair::setPointerAndInt'

→

}

explicit PointerIntPair(PointerTy PtrVal) { initWithPointer(PtrVal); }

267

←

Calling 'PointerIntPair::initWithPointer'

→

273

←

Returning from 'PointerIntPair::initWithPointer'

→

595

←

Calling 'PointerIntPair::initWithPointer'

→

601

←

Returning from 'PointerIntPair::initWithPointer'

→

PointerTy getPointer() const { return Info::getPointer(Value); }

214

←

Calling 'PointerIntPairInfo::getPointer'

→

229

←

Returning from 'PointerIntPairInfo::getPointer'

→

233

←

Calling 'PointerIntPairInfo::getPointer'

→

236

←

Returning from 'PointerIntPairInfo::getPointer'

→

301

←

Calling 'PointerIntPairInfo::getPointer'

→

316

←

Returning from 'PointerIntPairInfo::getPointer'

→

320

←

Calling 'PointerIntPairInfo::getPointer'

→

323

←

Returning from 'PointerIntPairInfo::getPointer'

→

361

←

Calling 'PointerIntPairInfo::getPointer'

→

376

←

Returning from 'PointerIntPairInfo::getPointer'

→

380

←

Calling 'PointerIntPairInfo::getPointer'

→

383

←

Returning from 'PointerIntPairInfo::getPointer'

→

419

←

Calling 'PointerIntPairInfo::getPointer'

→

434

←

Returning from 'PointerIntPairInfo::getPointer'

→

438

←

Calling 'PointerIntPairInfo::getPointer'

→

441

←

Returning from 'PointerIntPairInfo::getPointer'

→

479

←

Calling 'PointerIntPairInfo::getPointer'

→

494

←

Returning from 'PointerIntPairInfo::getPointer'

→

498

←

Calling 'PointerIntPairInfo::getPointer'

→

501

←

Returning from 'PointerIntPairInfo::getPointer'

→

543

←

Calling 'PointerIntPairInfo::getPointer'

→

558

←

Returning from 'PointerIntPairInfo::getPointer'

→

562

←

Calling 'PointerIntPairInfo::getPointer'

→

565

←

Returning from 'PointerIntPairInfo::getPointer'

→

629

←

Calling 'PointerIntPairInfo::getPointer'

→

644

←

Returning from 'PointerIntPairInfo::getPointer'

→

648

←

Calling 'PointerIntPairInfo::getPointer'

→

651

←

Returning from 'PointerIntPairInfo::getPointer'

→

689

←

Calling 'PointerIntPairInfo::getPointer'

→

704

←

Returning from 'PointerIntPairInfo::getPointer'

→

708

←

Calling 'PointerIntPairInfo::getPointer'

→

711

←

Returning from 'PointerIntPairInfo::getPointer'

→

747

←

Calling 'PointerIntPairInfo::getPointer'

→

762

←

Returning from 'PointerIntPairInfo::getPointer'

→

766

←

Calling 'PointerIntPairInfo::getPointer'

→

769

←

Returning from 'PointerIntPairInfo::getPointer'

→

807

←

Calling 'PointerIntPairInfo::getPointer'

→

822

←

Returning from 'PointerIntPairInfo::getPointer'

→

826

←

Calling 'PointerIntPairInfo::getPointer'

→

829

←

Returning from 'PointerIntPairInfo::getPointer'

→

IntType getInt() const { return (IntType)Info::getInt(Value); }

←

Calling 'PointerIntPairInfo::getInt'

→

←

Returning from 'PointerIntPairInfo::getInt'

→

104

←

Calling 'PointerIntPairInfo::getInt'

→

105

←

Returning from 'PointerIntPairInfo::getInt'

→

163

←

Calling 'PointerIntPairInfo::getInt'

→

164

←

Returning from 'PointerIntPairInfo::getInt'

→

253

←

Calling 'PointerIntPairInfo::getInt'

→

254

←

Returning from 'PointerIntPairInfo::getInt'

→

336

←

Calling 'PointerIntPairInfo::getInt'

→

337

←

Returning from 'PointerIntPairInfo::getInt'

→

344

←

Calling 'PointerIntPairInfo::getInt'

→

345

←

Returning from 'PointerIntPairInfo::getInt'

→

454

←

Calling 'PointerIntPairInfo::getInt'

→

455

←

Returning from 'PointerIntPairInfo::getInt'

→

462

←

Calling 'PointerIntPairInfo::getInt'

→

463

←

Returning from 'PointerIntPairInfo::getInt'

→

582

←

Calling 'PointerIntPairInfo::getInt'

→

583

←

Returning from 'PointerIntPairInfo::getInt'

→

664

←

Calling 'PointerIntPairInfo::getInt'

→

665

←

Returning from 'PointerIntPairInfo::getInt'

→

672

←

Calling 'PointerIntPairInfo::getInt'

→

673

←

Returning from 'PointerIntPairInfo::getInt'

→

782

←

Calling 'PointerIntPairInfo::getInt'

→

783

←

Returning from 'PointerIntPairInfo::getInt'

→

790

←

Calling 'PointerIntPairInfo::getInt'

→

791

←

Returning from 'PointerIntPairInfo::getInt'

→

void setPointer(PointerTy PtrVal) {

Value = Info::updatePointer(Value, PtrVal);

}

void setInt(IntType IntVal) {

Value = Info::updateInt(Value, static_cast<intptr_t>(IntVal));

348

←

Calling 'PointerIntPairInfo::updateInt'

→

350

←

Returning from 'PointerIntPairInfo::updateInt'

→

466

←

Calling 'PointerIntPairInfo::updateInt'

→

468

←

Returning from 'PointerIntPairInfo::updateInt'

→

676

←

Calling 'PointerIntPairInfo::updateInt'

→

678

←

Returning from 'PointerIntPairInfo::updateInt'

→

794

←

Calling 'PointerIntPairInfo::updateInt'

→

796

←

Returning from 'PointerIntPairInfo::updateInt'

→

}

void initWithPointer(PointerTy PtrVal) {

Value = Info::updatePointer(0, PtrVal);

268

←

Calling 'PointerIntPairInfo::updatePointer'

→

272

←

Returning from 'PointerIntPairInfo::updatePointer'

→

596

←

Calling 'PointerIntPairInfo::updatePointer'

→

600

←

Returning from 'PointerIntPairInfo::updatePointer'

→

}

void setPointerAndInt(PointerTy PtrVal, IntType IntVal) {

Value = Info::updateInt(Info::updatePointer(0, PtrVal),

278

←

Calling 'PointerIntPairInfo::updatePointer'

→

286

←

Returning from 'PointerIntPairInfo::updatePointer'

→

287

←

Calling 'PointerIntPairInfo::updateInt'

→

289

←

Returning from 'PointerIntPairInfo::updateInt'

→

606

←

Calling 'PointerIntPairInfo::updatePointer'

→

614

←

Returning from 'PointerIntPairInfo::updatePointer'

→

615

←

Calling 'PointerIntPairInfo::updateInt'

→

617

←

Returning from 'PointerIntPairInfo::updateInt'

→

static_cast<intptr_t>(IntVal));

}

PointerTy const *getAddrOfPointer() const {

return const_cast<PointerIntPair *>(this)->getAddrOfPointer();

}

PointerTy *getAddrOfPointer() {

assert(Value == reinterpret_cast<intptr_t>(getPointer()) &&(static_cast <bool> (Value == reinterpret_cast<intptr_t
>(getPointer()) && "Can only return the address if IntBits is cleared and "
"PtrTraits doesn't change the pointer") ? 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-7~svn326246/include/llvm/ADT/PointerIntPair.h"
, 84, __extension__ __PRETTY_FUNCTION__))

"Can only return the address if IntBits is cleared and "(static_cast <bool> (Value == reinterpret_cast<intptr_t
>(getPointer()) && "Can only return the address if IntBits is cleared and "
"PtrTraits doesn't change the pointer") ? 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-7~svn326246/include/llvm/ADT/PointerIntPair.h"
, 84, __extension__ __PRETTY_FUNCTION__))

"PtrTraits doesn't change the pointer")(static_cast <bool> (Value == reinterpret_cast<intptr_t
>(getPointer()) && "Can only return the address if IntBits is cleared and "
"PtrTraits doesn't change the pointer") ? 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-7~svn326246/include/llvm/ADT/PointerIntPair.h"
, 84, __extension__ __PRETTY_FUNCTION__));

return reinterpret_cast<PointerTy *>(&Value);

}

void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }

void setFromOpaqueValue(void *Val) {

Value = reinterpret_cast<intptr_t>(Val);

}

static PointerIntPair getFromOpaqueValue(void *V) {

PointerIntPair P;

222

←

Calling defaulted default constructor for 'PointerIntPair'

→

223

←

Returning from default constructor for 'PointerIntPair'

→

309

←

Calling defaulted default constructor for 'PointerIntPair'

→

310

←

Returning from default constructor for 'PointerIntPair'

→

369

←

Calling defaulted default constructor for 'PointerIntPair'

→

370

←

Returning from default constructor for 'PointerIntPair'

→

427

←

Calling defaulted default constructor for 'PointerIntPair'

→

428

←

Returning from default constructor for 'PointerIntPair'

→

487

←

Calling defaulted default constructor for 'PointerIntPair'

→

488

←

Returning from default constructor for 'PointerIntPair'

→

551

←

Calling defaulted default constructor for 'PointerIntPair'

→

552

←

Returning from default constructor for 'PointerIntPair'

→

637

←

Calling defaulted default constructor for 'PointerIntPair'

→

638

←

Returning from default constructor for 'PointerIntPair'

→

697

←

Calling defaulted default constructor for 'PointerIntPair'

→

698

←

Returning from default constructor for 'PointerIntPair'

→

755

←

Calling defaulted default constructor for 'PointerIntPair'

→

756

←

Returning from default constructor for 'PointerIntPair'

→

815

←

Calling defaulted default constructor for 'PointerIntPair'

→

816

←

Returning from default constructor for 'PointerIntPair'

→

P.setFromOpaqueValue(V);

224

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

225

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

311

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

312

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

371

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

372

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

429

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

430

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

489

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

490

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

553

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

554

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

639

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

640

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

699

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

700

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

757

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

758

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

817

←

Calling 'PointerIntPair::setFromOpaqueValue'

→

818

←

Returning from 'PointerIntPair::setFromOpaqueValue'

→

return P;

}

100

// Allow PointerIntPairs to be created from const void * if and only if the

101

// pointer type could be created from a const void *.

102

static PointerIntPair getFromOpaqueValue(const void *V) {

103

(void)PtrTraits::getFromVoidPointer(V);

104

return getFromOpaqueValue(const_cast<void *>(V));

105

}

106

107

bool operator==(const PointerIntPair &RHS) const {

108

return Value == RHS.Value;

109

}

110

111

bool operator!=(const PointerIntPair &RHS) const {

112

return Value != RHS.Value;

113

}

114

115

bool operator<(const PointerIntPair &RHS) const { return Value < RHS.Value; }

116

bool operator>(const PointerIntPair &RHS) const { return Value > RHS.Value; }

117

118

bool operator<=(const PointerIntPair &RHS) const {

119

return Value <= RHS.Value;

120

}

121

122

bool operator>=(const PointerIntPair &RHS) const {

123

return Value >= RHS.Value;

124

}

125

};

126

127

template <typename PointerT, unsigned IntBits, typename PtrTraits>

128

struct PointerIntPairInfo {

129

static_assert(PtrTraits::NumLowBitsAvailable <

130

std::numeric_limits<uintptr_t>::digits,

131

"cannot use a pointer type that has all bits free");

132

static_assert(IntBits <= PtrTraits::NumLowBitsAvailable,

133

"PointerIntPair with integer size too large for pointer");

134

enum : uintptr_t {

135

/// PointerBitMask - The bits that come from the pointer.

136

PointerBitMask =

137

~(uintptr_t)(((intptr_t)1 << PtrTraits::NumLowBitsAvailable) - 1),

138

139

/// IntShift - The number of low bits that we reserve for other uses, and

140

/// keep zero.

141

IntShift = (uintptr_t)PtrTraits::NumLowBitsAvailable - IntBits,

142

143

/// IntMask - This is the unshifted mask for valid bits of the int type.

144

IntMask = (uintptr_t)(((intptr_t)1 << IntBits) - 1),

145

146

// ShiftedIntMask - This is the bits for the integer shifted in place.

147

ShiftedIntMask = (uintptr_t)(IntMask << IntShift)

148

};

149

150

static PointerT getPointer(intptr_t Value) {

151

return PtrTraits::getFromVoidPointer(

215

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

228

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

234

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

235

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

302

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

315

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

321

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

322

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

362

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

375

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

381

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

382

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

420

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

433

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

439

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

440

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

480

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

493

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

499

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

500

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

544

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

557

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

563

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

564

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

630

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

643

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

649

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

650

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

690

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

703

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

709

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

710

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

748

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

761

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

767

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

768

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

808

←

Calling 'PointerLikeTypeTraits::getFromVoidPointer'

→

821

←

Returning from 'PointerLikeTypeTraits::getFromVoidPointer'

→

827

←

Calling 'PointerUnionUIntTraits::getFromVoidPointer'

→

828

←

Returning from 'PointerUnionUIntTraits::getFromVoidPointer'

→

152

reinterpret_cast<void *>(Value & PointerBitMask));

153

}

154

155

static intptr_t getInt(intptr_t Value) {

156

return (Value >> IntShift) & IntMask;

157

}

158

159

static intptr_t updatePointer(intptr_t OrigValue, PointerT Ptr) {

160

intptr_t PtrWord =

161

reinterpret_cast<intptr_t>(PtrTraits::getAsVoidPointer(Ptr));

269

←

Calling 'PointerUnionUIntTraits::getAsVoidPointer'

→

270

←

Returning from 'PointerUnionUIntTraits::getAsVoidPointer'

→

279

←

Calling 'PointerLikeTypeTraits::getAsVoidPointer'

→

284

←

Returning from 'PointerLikeTypeTraits::getAsVoidPointer'

→

597

←

Calling 'PointerUnionUIntTraits::getAsVoidPointer'

→

598

←

Returning from 'PointerUnionUIntTraits::getAsVoidPointer'

→

607

←

Calling 'PointerLikeTypeTraits::getAsVoidPointer'

→

612

←

Returning from 'PointerLikeTypeTraits::getAsVoidPointer'

→

162

assert((PtrWord & ~PointerBitMask) == 0 &&(static_cast <bool> ((PtrWord & ~PointerBitMask) ==
0 && "Pointer is not sufficiently aligned") ? void (
0) : __assert_fail ("(PtrWord & ~PointerBitMask) == 0 && \"Pointer is not sufficiently aligned\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerIntPair.h"
, 163, __extension__ __PRETTY_FUNCTION__))

271

←

Within the expansion of the macro 'assert':

→

285

←

Within the expansion of the macro 'assert':

→

a	Assuming the condition is true

599

←

Within the expansion of the macro 'assert':

→

613

←

Within the expansion of the macro 'assert':

→

a	Assuming the condition is true

163

"Pointer is not sufficiently aligned")(static_cast <bool> ((PtrWord & ~PointerBitMask) ==
0 && "Pointer is not sufficiently aligned") ? void (
0) : __assert_fail ("(PtrWord & ~PointerBitMask) == 0 && \"Pointer is not sufficiently aligned\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerIntPair.h"
, 163, __extension__ __PRETTY_FUNCTION__));

164

// Preserve all low bits, just update the pointer.

165

return PtrWord | (OrigValue & ~PointerBitMask);

166

}

167

168

static intptr_t updateInt(intptr_t OrigValue, intptr_t Int) {

169

intptr_t IntWord = static_cast<intptr_t>(Int);

170

assert((IntWord & ~IntMask) == 0 && "Integer too large for field")(static_cast <bool> ((IntWord & ~IntMask) == 0 &&
"Integer too large for field") ? void (0) : __assert_fail ("(IntWord & ~IntMask) == 0 && \"Integer too large for field\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/ADT/PointerIntPair.h"
, 170, __extension__ __PRETTY_FUNCTION__));

288

←

Within the expansion of the macro 'assert':

→

349

←

Within the expansion of the macro 'assert':

→

a	Assuming the condition is true

467

←

Within the expansion of the macro 'assert':

→

a	Assuming the condition is true

616

←

Within the expansion of the macro 'assert':

→

677

←

Within the expansion of the macro 'assert':

→

a	Assuming the condition is true

795

←

Within the expansion of the macro 'assert':

→

a	Assuming the condition is true

171

172

// Preserve all bits other than the ones we are updating.

173

return (OrigValue & ~ShiftedIntMask) | IntWord << IntShift;

174

}

175

};

176

177

template <typename T> struct isPodLike;

178

template <typename PointerTy, unsigned IntBits, typename IntType>

179

struct isPodLike<PointerIntPair<PointerTy, IntBits, IntType>> {

180

static const bool value = true;

181

};

182

183

// Provide specialization of DenseMapInfo for PointerIntPair.

184

template <typename PointerTy, unsigned IntBits, typename IntType>

185

struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {

186

using Ty = PointerIntPair<PointerTy, IntBits, IntType>;

187

188

static Ty getEmptyKey() {

189

uintptr_t Val = static_cast<uintptr_t>(-1);

190

Val <<= PointerLikeTypeTraits<Ty>::NumLowBitsAvailable;

191

return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));

192

}

193

194

static Ty getTombstoneKey() {

195

uintptr_t Val = static_cast<uintptr_t>(-2);

196

Val <<= PointerLikeTypeTraits<PointerTy>::NumLowBitsAvailable;

197

return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));

198

}

199

200

static unsigned getHashValue(Ty V) {

201

uintptr_t IV = reinterpret_cast<uintptr_t>(V.getOpaqueValue());

202

return unsigned(IV) ^ unsigned(IV >> 9);

203

}

204

205

static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; }

206

};

207

208

// Teach SmallPtrSet that PointerIntPair is "basically a pointer".

209

template <typename PointerTy, unsigned IntBits, typename IntType,

210

typename PtrTraits>

211

struct PointerLikeTypeTraits<

212

PointerIntPair<PointerTy, IntBits, IntType, PtrTraits>> {

213

static inline void *

214

getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {

215

return P.getOpaqueValue();

216

}

217

218

static inline PointerIntPair<PointerTy, IntBits, IntType>

219

getFromVoidPointer(void *P) {

220

return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);

221

}

222

223

static inline PointerIntPair<PointerTy, IntBits, IntType>

224

getFromVoidPointer(const void *P) {

225

return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);

226

}

227

228

enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };

229

};

230

231

} // end namespace llvm

232

233

#endif // LLVM_ADT_POINTERINTPAIR_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Casting.h

→

//===- llvm/Support/Casting.h - Allow flexible, checked, casts --*- C++ -*-===//

// The LLVM Compiler Infrastructure

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//===----------------------------------------------------------------------===//

// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),

// and dyn_cast_or_null<X>() templates.

//===----------------------------------------------------------------------===//

#ifndef LLVM_SUPPORT_CASTING_H

#define LLVM_SUPPORT_CASTING_H

#include "llvm/Support/Compiler.h"

#include "llvm/Support/type_traits.h"

#include <cassert>

#include <memory>

#include <type_traits>

namespace llvm {

//===----------------------------------------------------------------------===//

// isa<x> Support Templates

//===----------------------------------------------------------------------===//

// Define a template that can be specialized by smart pointers to reflect the

// fact that they are automatically dereferenced, and are not involved with the

// template selection process... the default implementation is a noop.

template<typename From> struct simplify_type {

using SimpleType = From; // The real type this represents...

// An accessor to get the real value...

static SimpleType &getSimplifiedValue(From &Val) { return Val; }

};

template<typename From> struct simplify_type<const From> {

using NonConstSimpleType = typename simplify_type<From>::SimpleType;

using SimpleType =

typename add_const_past_pointer<NonConstSimpleType>::type;

using RetType =

typename add_lvalue_reference_if_not_pointer<SimpleType>::type;

static RetType getSimplifiedValue(const From& Val) {

return simplify_type<From>::getSimplifiedValue(const_cast<From&>(Val));

←

Calling 'simplify_type::getSimplifiedValue'

→

←

Returning from 'simplify_type::getSimplifiedValue'

→

←

Calling 'simplify_type::getSimplifiedValue'

→

←

Returning from 'simplify_type::getSimplifiedValue'

→

116

←

Calling 'simplify_type::getSimplifiedValue'

→

117

←

Returning from 'simplify_type::getSimplifiedValue'

→

130

←

Calling 'simplify_type::getSimplifiedValue'

→

131

←

Returning from 'simplify_type::getSimplifiedValue'

→

175

←

Calling 'simplify_type::getSimplifiedValue'

→

176

←

Returning from 'simplify_type::getSimplifiedValue'

→

189

←

Calling 'simplify_type::getSimplifiedValue'

→

190

←

Returning from 'simplify_type::getSimplifiedValue'

→

399

←

Calling 'simplify_type::getSimplifiedValue'

→

400

←

Returning from 'simplify_type::getSimplifiedValue'

→

517

←

Calling 'simplify_type::getSimplifiedValue'

→

518

←

Returning from 'simplify_type::getSimplifiedValue'

→

727

←

Calling 'simplify_type::getSimplifiedValue'

→

728

←

Returning from 'simplify_type::getSimplifiedValue'

→

845

←

Calling 'simplify_type::getSimplifiedValue'

→

846

←

Returning from 'simplify_type::getSimplifiedValue'

→

}

};

// The core of the implementation of isa<X> is here; To and From should be

// the names of classes. This template can be specialized to customize the

// implementation of isa<> without rewriting it from scratch.

template <typename To, typename From, typename Enabler = void>

struct isa_impl {

static inline bool doit(const From &Val) {

return To::classof(&Val);

}

};

/// \brief Always allow upcasts, and perform no dynamic check for them.

template <typename To, typename From>

struct isa_impl<

To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> {

static inline bool doit(const From &) { return true; }

};

template <typename To, typename From> struct isa_impl_cl {

static inline bool doit(const From &Val) {

return isa_impl<To, From>::doit(Val);

}

};

template <typename To, typename From> struct isa_impl_cl<To, const From> {

static inline bool doit(const From &Val) {

return isa_impl<To, From>::doit(Val);

}

};

template <typename To, typename From>

struct isa_impl_cl<To, const std::unique_ptr<From>> {

static inline bool doit(const std::unique_ptr<From> &Val) {

assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Casting.h"
, 85, __extension__ __PRETTY_FUNCTION__));

return isa_impl_cl<To, From>::doit(*Val);

}

};

template <typename To, typename From> struct isa_impl_cl<To, From*> {

static inline bool doit(const From *Val) {

return isa_impl<To, From>::doit(*Val);

}

};

template <typename To, typename From> struct isa_impl_cl<To, From*const> {

static inline bool doit(const From *Val) {

100

return isa_impl<To, From>::doit(*Val);

101

}

102

};

103

104

template <typename To, typename From> struct isa_impl_cl<To, const From*> {

105

static inline bool doit(const From *Val) {

106

404

←

Within the expansion of the macro 'assert':

→

a	Assuming 'Val' is non-null

522

←

Within the expansion of the macro 'assert':

→

a	Assuming 'Val' is non-null

732

←

Within the expansion of the macro 'assert':

→

a	Assuming 'Val' is non-null

850

←

Within the expansion of the macro 'assert':

→

a	Assuming 'Val' is non-null

107

return isa_impl<To, From>::doit(*Val);

405

←

Calling 'isa_impl::doit'

→

406

←

Returning from 'isa_impl::doit'

→

523

←

Calling 'isa_impl::doit'

→

524

←

Returning from 'isa_impl::doit'

→

733

←

Calling 'isa_impl::doit'

→

734

←

Returning from 'isa_impl::doit'

→

851

←

Calling 'isa_impl::doit'

→

852

←

Returning from 'isa_impl::doit'

→

108

}

109

};

110

111

template <typename To, typename From> struct isa_impl_cl<To, const From*const> {

112

static inline bool doit(const From *Val) {

113

114

return isa_impl<To, From>::doit(*Val);

115

}

116

};

117

118

template<typename To, typename From, typename SimpleFrom>

119

struct isa_impl_wrap {

120

// When From != SimplifiedType, we can simplify the type some more by using

121

// the simplify_type template.

122

static bool doit(const From &Val) {

123

return isa_impl_wrap<To, SimpleFrom,

←

Calling 'isa_impl_wrap::doit'

→

←

Returning from 'isa_impl_wrap::doit'

→

←

Calling 'isa_impl_wrap::doit'

→

←

Returning from 'isa_impl_wrap::doit'

→

119

←

Calling 'isa_impl_wrap::doit'

→

120

←

Returning from 'isa_impl_wrap::doit'

→

133

←

Calling 'isa_impl_wrap::doit'

→

134

←

Returning from 'isa_impl_wrap::doit'

→

178

←

Calling 'isa_impl_wrap::doit'

→

179

←

Returning from 'isa_impl_wrap::doit'

→

192

←

Calling 'isa_impl_wrap::doit'

→

193

←

Returning from 'isa_impl_wrap::doit'

→

402

←

Calling 'isa_impl_wrap::doit'

→

408

←

Returning from 'isa_impl_wrap::doit'

→

520

←

Calling 'isa_impl_wrap::doit'

→

526

←

Returning from 'isa_impl_wrap::doit'

→

730

←

Calling 'isa_impl_wrap::doit'

→

736

←

Returning from 'isa_impl_wrap::doit'

→

848

←

Calling 'isa_impl_wrap::doit'

→

854

←

Returning from 'isa_impl_wrap::doit'

→

124

typename simplify_type<SimpleFrom>::SimpleType>::doit(

125

simplify_type<const From>::getSimplifiedValue(Val));

←

Calling 'simplify_type::getSimplifiedValue'

→

←

Returning from 'simplify_type::getSimplifiedValue'

→

←

Calling 'simplify_type::getSimplifiedValue'

→

←

Returning from 'simplify_type::getSimplifiedValue'

→

115

←

Calling 'simplify_type::getSimplifiedValue'

→

118

←

Returning from 'simplify_type::getSimplifiedValue'

→

129

←

Calling 'simplify_type::getSimplifiedValue'

→

132

←

Returning from 'simplify_type::getSimplifiedValue'

→

174

←

Calling 'simplify_type::getSimplifiedValue'

→

177

←

Returning from 'simplify_type::getSimplifiedValue'

→

188

←

Calling 'simplify_type::getSimplifiedValue'

→

191

←

Returning from 'simplify_type::getSimplifiedValue'

→

398

←

Calling 'simplify_type::getSimplifiedValue'

→

401

←

Returning from 'simplify_type::getSimplifiedValue'

→

516

←

Calling 'simplify_type::getSimplifiedValue'

→

519

←

Returning from 'simplify_type::getSimplifiedValue'

→

726

←

Calling 'simplify_type::getSimplifiedValue'

→

729

←

Returning from 'simplify_type::getSimplifiedValue'

→

844

←

Calling 'simplify_type::getSimplifiedValue'

→

847

←

Returning from 'simplify_type::getSimplifiedValue'

→

126

}

127

};

128

129

template<typename To, typename FromTy>

130

struct isa_impl_wrap<To, FromTy, FromTy> {

131

// When From == SimpleType, we are as simple as we are going to get.

132

static bool doit(const FromTy &Val) {

133

return isa_impl_cl<To,FromTy>::doit(Val);

403

←

Calling 'isa_impl_cl::doit'

→

407

←

Returning from 'isa_impl_cl::doit'

→

521

←

Calling 'isa_impl_cl::doit'

→

525

←

Returning from 'isa_impl_cl::doit'

→

731

←

Calling 'isa_impl_cl::doit'

→

735

←

Returning from 'isa_impl_cl::doit'

→

849

←

Calling 'isa_impl_cl::doit'

→

853

←

Returning from 'isa_impl_cl::doit'

→

134

}

135

};

136

137

// isa<X> - Return true if the parameter to the template is an instance of the

138

// template type argument. Used like this:

139

140

// if (isa<Type>(myVal)) { ... }

141

142

template <class X, class Y> LLVM_NODISCARD[[clang::warn_unused_result]] inline bool isa(const Y &Val) {

143

return isa_impl_wrap<X, const Y,

←

Calling 'isa_impl_wrap::doit'

→

←

Returning from 'isa_impl_wrap::doit'

→

←

Calling 'isa_impl_wrap::doit'

→

←

Returning from 'isa_impl_wrap::doit'

→

114

←

Calling 'isa_impl_wrap::doit'

→

121

←

Returning from 'isa_impl_wrap::doit'

→

128

←

Calling 'isa_impl_wrap::doit'

→

135

←

Returning from 'isa_impl_wrap::doit'

→

173

←

Calling 'isa_impl_wrap::doit'

→

180

←

Returning from 'isa_impl_wrap::doit'

→

187

←

Calling 'isa_impl_wrap::doit'

→

194

←

Returning from 'isa_impl_wrap::doit'

→

397

←

Calling 'isa_impl_wrap::doit'

→

409

←

Returning from 'isa_impl_wrap::doit'

→

515

←

Calling 'isa_impl_wrap::doit'

→

527

←

Returning from 'isa_impl_wrap::doit'

→

725

←

Calling 'isa_impl_wrap::doit'

→

737

←

Returning from 'isa_impl_wrap::doit'

→

843

←

Calling 'isa_impl_wrap::doit'

→

855

←

Returning from 'isa_impl_wrap::doit'

→

144

typename simplify_type<const Y>::SimpleType>::doit(Val);

145

}

146

147

//===----------------------------------------------------------------------===//

148

// cast<x> Support Templates

149

//===----------------------------------------------------------------------===//

150

151

template<class To, class From> struct cast_retty;

152

153

// Calculate what type the 'cast' function should return, based on a requested

154

// type of To and a source type of From.

155

template<class To, class From> struct cast_retty_impl {

156

using ret_type = To &; // Normal case, return Ty&

157

};

158

template<class To, class From> struct cast_retty_impl<To, const From> {

159

using ret_type = const To &; // Normal case, return Ty&

160

};

161

162

template<class To, class From> struct cast_retty_impl<To, From*> {

163

using ret_type = To *; // Pointer arg case, return Ty*

164

};

165

166

template<class To, class From> struct cast_retty_impl<To, const From*> {

167

using ret_type = const To *; // Constant pointer arg case, return const Ty*

168

};

169

170

template<class To, class From> struct cast_retty_impl<To, const From*const> {

171

using ret_type = const To *; // Constant pointer arg case, return const Ty*

172

};

173

174

template <class To, class From>

175

struct cast_retty_impl<To, std::unique_ptr<From>> {

176

private:

177

using PointerType = typename cast_retty_impl<To, From *>::ret_type;

178

using ResultType = typename std::remove_pointer<PointerType>::type;

179

180

public:

181

using ret_type = std::unique_ptr<ResultType>;

182

};

183

184

template<class To, class From, class SimpleFrom>

185

struct cast_retty_wrap {

186

// When the simplified type and the from type are not the same, use the type

187

// simplifier to reduce the type, then reuse cast_retty_impl to get the

188

// resultant type.

189

using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;

190

};

191

192

template<class To, class FromTy>

193

struct cast_retty_wrap<To, FromTy, FromTy> {

194

// When the simplified type is equal to the from type, use it directly.

195

using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;

196

};

197

198

template<class To, class From>

199

struct cast_retty {

200

using ret_type = typename cast_retty_wrap<

201

To, From, typename simplify_type<From>::SimpleType>::ret_type;

202

};

203

204

// Ensure the non-simple values are converted using the simplify_type template

205

// that may be specialized by smart pointers...

206

207

template<class To, class From, class SimpleFrom> struct cast_convert_val {

208

// This is not a simple type, use the template to simplify it...

209

static typename cast_retty<To, From>::ret_type doit(From &Val) {

210

return cast_convert_val<To, SimpleFrom,

211

typename simplify_type<SimpleFrom>::SimpleType>::doit(

212

simplify_type<From>::getSimplifiedValue(Val));

213

}

214

};

215

216

template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {

217

// This _is_ a simple type, just cast it.

218

static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {

219

typename cast_retty<To, FromTy>::ret_type Res2

220

= (typename cast_retty<To, FromTy>::ret_type)const_cast<FromTy&>(Val);

221

return Res2;

222

}

223

};

224

225

template <class X> struct is_simple_type {

226

static const bool value =

227

std::is_same<X, typename simplify_type<X>::SimpleType>::value;

228

};

229

230

// cast<X> - Return the argument parameter cast to the specified type. This

231

// casting operator asserts that the type is correct, so it does not return null

232

// on failure. It does not allow a null argument (use cast_or_null for that).

233

// It is typically used like this:

234

235

// cast<Instruction>(myVal)->getParent()

236

237

template <class X, class Y>

238

inline typename std::enable_if<!is_simple_type<Y>::value,

239

typename cast_retty<X, const Y>::ret_type>::type

240

cast(const Y &Val) {

241

assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Casting.h"
, 241, __extension__ __PRETTY_FUNCTION__));

242

return cast_convert_val<

243

X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);

244

}

245

246

template <class X, class Y>

247

inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {

248

249

return cast_convert_val<X, Y,

250

typename simplify_type<Y>::SimpleType>::doit(Val);

251

}

252

253

template <class X, class Y>

254

inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {

255

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

c	Assuming the condition is true

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

c	Assuming the condition is true

113

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

c	Assuming the condition is true

127

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

c	Assuming the condition is true

172

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

c	Assuming the condition is true

186

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

c	Assuming the condition is true

396

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

514

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

724

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

842

←

Within the expansion of the macro 'assert':

→

a	Calling 'isa'

b	Returning from 'isa'

256

return cast_convert_val<X, Y*,

←

Calling 'cast_convert_val::doit'

→

←

Returning from 'cast_convert_val::doit'

→

←

Calling 'cast_convert_val::doit'

→

←

Returning from 'cast_convert_val::doit'

→

122

←

Calling 'cast_convert_val::doit'

→

123

←

Returning from 'cast_convert_val::doit'

→

136

←

Calling 'cast_convert_val::doit'

→

137

←

Returning from 'cast_convert_val::doit'

→

181

←

Calling 'cast_convert_val::doit'

→

182

←

Returning from 'cast_convert_val::doit'

→

195

←

Calling 'cast_convert_val::doit'

→

196

←

Returning from 'cast_convert_val::doit'

→

410

←

Calling 'cast_convert_val::doit'

→

411

←

Returning from 'cast_convert_val::doit'

→

528

←

Calling 'cast_convert_val::doit'

→

529

←

Returning from 'cast_convert_val::doit'

→

738

←

Calling 'cast_convert_val::doit'

→

739

←

Returning from 'cast_convert_val::doit'

→

856

←

Calling 'cast_convert_val::doit'

→

857

←

Returning from 'cast_convert_val::doit'

→

257

typename simplify_type<Y*>::SimpleType>::doit(Val);

258

}

259

260

template <class X, class Y>

261

inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type

262

cast(std::unique_ptr<Y> &&Val) {

263

assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val.get()) &&
"cast<Ty>() argument of incompatible type!") ? void (0
) : __assert_fail ("isa<X>(Val.get()) && \"cast<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Casting.h"
, 263, __extension__ __PRETTY_FUNCTION__));

264

using ret_type = typename cast_retty<X, std::unique_ptr<Y>>::ret_type;

265

return ret_type(

266

cast_convert_val<X, Y *, typename simplify_type<Y *>::SimpleType>::doit(

267

Val.release()));

268

}

269

270

// cast_or_null<X> - Functionally identical to cast, except that a null value is

271

// accepted.

272

273

template <class X, class Y>

274

LLVM_NODISCARD[[clang::warn_unused_result]] inline

275

typename std::enable_if<!is_simple_type<Y>::value,

276

typename cast_retty<X, const Y>::ret_type>::type

277

cast_or_null(const Y &Val) {

278

if (!Val)

279

return nullptr;

280

assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast_or_null<Ty>() argument of incompatible type!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Casting.h"
, 280, __extension__ __PRETTY_FUNCTION__));

281

return cast<X>(Val);

282

}

283

284

template <class X, class Y>

285

LLVM_NODISCARD[[clang::warn_unused_result]] inline

286

typename std::enable_if<!is_simple_type<Y>::value,

287

typename cast_retty<X, Y>::ret_type>::type

288

cast_or_null(Y &Val) {

289

if (!Val)

290

return nullptr;

291

292

return cast<X>(Val);

293

}

294

295

template <class X, class Y>

296

LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type

297

cast_or_null(Y *Val) {

298

if (!Val) return nullptr;

299

300

return cast<X>(Val);

301

}

302

303

template <class X, class Y>

304

inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type

305

cast_or_null(std::unique_ptr<Y> &&Val) {

306

if (!Val)

307

return nullptr;

308

return cast<X>(std::move(Val));

309

}

310

311

// dyn_cast<X> - Return the argument parameter cast to the specified type. This

312

// casting operator returns null if the argument is of the wrong type, so it can

313

// be used to test for a type as well as cast if successful. This should be

314

// used in the context of an if statement like this:

315

316

// if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }

317

318

319

template <class X, class Y>

320

LLVM_NODISCARD[[clang::warn_unused_result]] inline

321

typename std::enable_if<!is_simple_type<Y>::value,

322

typename cast_retty<X, const Y>::ret_type>::type

323

dyn_cast(const Y &Val) {

324

return isa<X>(Val) ? cast<X>(Val) : nullptr;

325

}

326

327

template <class X, class Y>

328

LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {

329

return isa<X>(Val) ? cast<X>(Val) : nullptr;

330

}

331

332

template <class X, class Y>

333

LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {

334

return isa<X>(Val) ? cast<X>(Val) : nullptr;

335

}

336

337

// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null

338

// value is accepted.

339

340

template <class X, class Y>

341

LLVM_NODISCARD[[clang::warn_unused_result]] inline

342

typename std::enable_if<!is_simple_type<Y>::value,

343

typename cast_retty<X, const Y>::ret_type>::type

344

dyn_cast_or_null(const Y &Val) {

345

return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

346

}

347

348

template <class X, class Y>

349

LLVM_NODISCARD[[clang::warn_unused_result]] inline

350

typename std::enable_if<!is_simple_type<Y>::value,

351

typename cast_retty<X, Y>::ret_type>::type

352

dyn_cast_or_null(Y &Val) {

353

return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

354

}

355

356

template <class X, class Y>

357

LLVM_NODISCARD[[clang::warn_unused_result]] inline typename cast_retty<X, Y *>::ret_type

358

dyn_cast_or_null(Y *Val) {

359

return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

360

}

361

362

// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,

363

// taking ownership of the input pointer iff isa<X>(Val) is true. If the

364

// cast is successful, From refers to nullptr on exit and the casted value

365

// is returned. If the cast is unsuccessful, the function returns nullptr

366

// and From is unchanged.

367

template <class X, class Y>

368

LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast(std::unique_ptr<Y> &Val)

369

-> decltype(cast<X>(Val)) {

370

if (!isa<X>(Val))

371

return nullptr;

372

return cast<X>(std::move(Val));

373

}

374

375

template <class X, class Y>

376

LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val)

377

-> decltype(cast<X>(Val)) {

378

return unique_dyn_cast<X, Y>(Val);

379

}

380

381

// dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, except that

382

// a null value is accepted.

383

template <class X, class Y>

384

LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &Val)

385

-> decltype(cast<X>(Val)) {

386

if (!Val)

387

return nullptr;

388

return unique_dyn_cast<X, Y>(Val);

389

}

390

391

template <class X, class Y>

392

LLVM_NODISCARD[[clang::warn_unused_result]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val)

393

-> decltype(cast<X>(Val)) {

394

return unique_dyn_cast_or_null<X, Y>(Val);

395

}

396

397

} // end namespace llvm

398

399

#endif // LLVM_SUPPORT_CASTING_H

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h

→

1//===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10/// \file
11/// \brief C Language Family Type Representation
12///
13/// This file defines the clang::Type interface and subclasses, used to
14/// represent types for languages in the C family.
15//
16//===----------------------------------------------------------------------===//

18#ifndef LLVM_CLANG_AST_TYPE_H
19#define LLVM_CLANG_AST_TYPE_H

21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/TemplateName.h"
23#include "clang/Basic/AddressSpaces.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/ArrayRef.h"
34#include "llvm/ADT/FoldingSet.h"
35#include "llvm/ADT/None.h"
36#include "llvm/ADT/Optional.h"
37#include "llvm/ADT/PointerIntPair.h"
38#include "llvm/ADT/PointerUnion.h"
39#include "llvm/ADT/StringRef.h"
40#include "llvm/ADT/Twine.h"
41#include "llvm/ADT/iterator_range.h"
42#include "llvm/Support/Casting.h"
43#include "llvm/Support/Compiler.h"
44#include "llvm/Support/ErrorHandling.h"
45#include "llvm/Support/PointerLikeTypeTraits.h"
46#include "llvm/Support/type_traits.h"
47#include <cassert>
48#include <cstddef>
49#include <cstdint>
50#include <cstring>
51#include <string>
52#include <type_traits>
53#include <utility>

55namespace clang {

57class ExtQuals;
58class QualType;
59class Type;

61enum {
TypeAlignmentInBits = 4,
TypeAlignment = 1 << TypeAlignmentInBits
64};

66} // namespace clang

68namespace 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 };
};

template <>
struct isPodLike<clang::QualType> { static const bool value = true; };

97} // namespace llvm

99namespace clang {

101class ArrayType;
102class ASTContext;
103class AttributedType;
104class AutoType;
105class BuiltinType;
106template <typename> class CanQual;
107class ComplexType;
108class CXXRecordDecl;
109class DeclContext;
110class DeducedType;
111class EnumDecl;
112class Expr;
113class ExtQualsTypeCommonBase;
114class FunctionDecl;
115class FunctionNoProtoType;
116class FunctionProtoType;
117class IdentifierInfo;
118class InjectedClassNameType;
119class NamedDecl;
120class ObjCInterfaceDecl;
121class ObjCObjectPointerType;
122class ObjCObjectType;
123class ObjCProtocolDecl;
124class ObjCTypeParamDecl;
125class ParenType;
126struct PrintingPolicy;
127class RecordDecl;
128class RecordType;
129class Stmt;
130class TagDecl;
131class TemplateArgument;
132class TemplateArgumentListInfo;
133class TemplateArgumentLoc;
134class TemplateSpecializationType;
135class TemplateTypeParmDecl;
136class TypedefNameDecl;
137class TypedefType;
138class UnresolvedUsingTypenameDecl;

140using CanQualType = CanQual<Type>;

// Provide forward declarations for all of the *Type classes
143#define TYPE(Class, Base) class Class##Type;
144#include "clang/AST/TypeNodes.def"

146/// The collection of all-type qualifiers we support.
147/// Clang supports five independent qualifiers:
148/// * C99: const, volatile, and restrict
149/// * MS: __unaligned
150/// * Embedded C (TR18037): address spaces
151/// * Objective C: the GC attributes (none, weak, or strong)
152class Qualifiers {
153public:
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; }
void setConst(bool flag) {
  Mask = (Mask & ~Const) | (flag ? Const : 0);
}
void removeConst() { Mask &= ~Const; }
void addConst() { Mask |= Const; }

bool hasVolatile() const { return Mask & Volatile; }
void setVolatile(bool flag) {
  Mask = (Mask & ~Volatile) | (flag ? Volatile : 0);
}
void removeVolatile() { Mask &= ~Volatile; }
void addVolatile() { Mask |= Volatile; }

bool hasRestrict() const { return Mask & Restrict; }
void setRestrict(bool flag) {
  Mask = (Mask & ~Restrict) | (flag ? Restrict : 0);
}
void removeRestrict() { Mask &= ~Restrict; }
void addRestrict() { Mask |= Restrict; }

bool hasCVRQualifiers() const { return getCVRQualifiers(); }
unsigned getCVRQualifiers() const { return Mask & CVRMask; }
void setCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast <bool> (!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? void (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 293, __extension__ __PRETTY_FUNCTION__));
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast <bool> (!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? void (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 297, __extension__ __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast <bool> (!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? void (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 304, __extension__ __PRETTY_FUNCTION__));
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")(static_cast <bool> (!(mask & ~CVRMask & ~UMask
) && "bitmask contains non-CVRU bits") ? void (0) : __assert_fail
 ("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 308, __extension__ __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)(static_cast <bool> (type) ? void (0) : __assert_fail (
"type", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 326, __extension__ __PRETTY_FUNCTION__));
  setObjCGCAttr(type);
}
Qualifiers withoutObjCGCAttr() const {
  Qualifiers qs = *this;
  qs.removeObjCGCAttr();
  return qs;
}
Qualifiers withoutObjCLifetime() const {
  Qualifiers qs = *this;
  qs.removeObjCLifetime();
  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)(static_cast <bool> (type) ? void (0) : __assert_fail (
"type", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 349, __extension__ __PRETTY_FUNCTION__));
  assert(!hasObjCLifetime())(static_cast <bool> (!hasObjCLifetime()) ? void (0) : __assert_fail
 ("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 350, __extension__ __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())(static_cast <bool> (Addr == LangAS::Default || hasTargetSpecificAddressSpace
()) ? void (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 379, __extension__ __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)(static_cast <bool> ((unsigned)space <= MaxAddressSpace
) ? void (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 388, __extension__ __PRETTY_FUNCTION__));
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)(static_cast <bool> (space != LangAS::Default) ? void (
0) : __assert_fail ("space != LangAS::Default", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 394, __extension__ __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")(static_cast <bool> (!(mask & ~FastMask) &&
 "bitmask contains non-fast qualifier bits") ? void (0) : __assert_fail
 ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 403, __extension__ __PRETTY_FUNCTION__));
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast <bool> (!(mask & ~FastMask) &&
 "bitmask contains non-fast qualifier bits") ? void (0) : __assert_fail
 ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 407, __extension__ __PRETTY_FUNCTION__));
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast <bool> (!(mask & ~FastMask) &&
 "bitmask contains non-fast qualifier bits") ? void (0) : __assert_fail
 ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 414, __extension__ __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());
  }
}

/// \brief 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() ||(static_cast <bool> (getAddressSpace() == qs.getAddressSpace
() || !hasAddressSpace() || !qs.hasAddressSpace()) ? void (0)
 : __assert_fail ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 469, __extension__ __PRETTY_FUNCTION__))
         !hasAddressSpace() || !qs.hasAddressSpace())(static_cast <bool> (getAddressSpace() == qs.getAddressSpace
() || !hasAddressSpace() || !qs.hasAddressSpace()) ? void (0)
 : __assert_fail ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 469, __extension__ __PRETTY_FUNCTION__));
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||(static_cast <bool> (getObjCGCAttr() == qs.getObjCGCAttr
() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()) ? void (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 471, __extension__ __PRETTY_FUNCTION__))
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())(static_cast <bool> (getObjCGCAttr() == qs.getObjCGCAttr
() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()) ? void (0) : __assert_fail
 ("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 471, __extension__ __PRETTY_FUNCTION__));
  assert(getObjCLifetime() == qs.getObjCLifetime() ||(static_cast <bool> (getObjCLifetime() == qs.getObjCLifetime
() || !hasObjCLifetime() || !qs.hasObjCLifetime()) ? void (0)
 : __assert_fail ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 473, __extension__ __PRETTY_FUNCTION__))
         !hasObjCLifetime() || !qs.hasObjCLifetime())(static_cast <bool> (getObjCLifetime() == qs.getObjCLifetime
() || !hasObjCLifetime() || !qs.hasObjCLifetime()) ? void (0)
 : __assert_fail ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 473, __extension__ __PRETTY_FUNCTION__));
  Mask |= qs.Mask;
}

/// Returns true if this address space is a superset of the other one.
/// 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.
bool isAddressSpaceSupersetOf(Qualifiers other) const {
  return
      // Address spaces must match exactly.
      getAddressSpace() == other.getAddressSpace() ||
      // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
      // for __constant can be used as __generic.
      (getAddressSpace() == LangAS::opencl_generic &&
       other.getAddressSpace() != LangAS::opencl_constant);
}

/// 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());
}

/// \brief 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();
}

/// \brief 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; }

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;
}

/// \brief 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);
}

574private:
// 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;
588};

590/// A std::pair-like structure for storing a qualified type split
591/// into its local qualifiers and its locally-unqualified type.
592struct 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;
}
615};

617/// The kind of type we are substituting Objective-C type arguments into.
618///
619/// The kind of substitution affects the replacement of type parameters when
620/// no concrete type information is provided, e.g., when dealing with an
621/// unspecialized type.
622enum 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,
637};

639/// A (possibly-)qualified type.
640///
641/// For efficiency, we don't store CV-qualified types as nodes on their
642/// own: instead each reference to a type stores the qualifiers.  This
643/// greatly reduces the number of nodes we need to allocate for types (for
644/// example we only need one for 'int', 'const int', 'volatile int',
645/// 'const volatile int', etc).
646///
647/// As an added efficiency bonus, instead of making this a pair, we
648/// just store the two bits we care about in the low bits of the
649/// pointer.  To handle the packing/unpacking, we make QualType be a
650/// simple wrapper class that acts like a smart pointer.  A third bit
651/// indicates whether there are extended qualifiers present, in which
652/// case the pointer points to a special structure.
653class 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")(static_cast <bool> (!isNull() && "Cannot retrieve a NULL type pointer"
) ? void (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 669, __extension__ __PRETTY_FUNCTION__));
212
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
299
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
359
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
417
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
477
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
541
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
627
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
687
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
745
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
805
←
Within the expansion of the macro 'assert':
→
a
Calling 'QualType::isNull'
b
Returning from 'QualType::isNull'
  uintptr_t CommonPtrVal
    = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
244
←
Calling 'PointerIntPair::getOpaqueValue'→
245
←
Returning from 'PointerIntPair::getOpaqueValue'→
331
←
Calling 'PointerIntPair::getOpaqueValue'→
332
←
Returning from 'PointerIntPair::getOpaqueValue'→
391
←
Calling 'PointerIntPair::getOpaqueValue'→
392
←
Returning from 'PointerIntPair::getOpaqueValue'→
449
←
Calling 'PointerIntPair::getOpaqueValue'→
450
←
Returning from 'PointerIntPair::getOpaqueValue'→
509
←
Calling 'PointerIntPair::getOpaqueValue'→
510
←
Returning from 'PointerIntPair::getOpaqueValue'→
573
←
Calling 'PointerIntPair::getOpaqueValue'→
574
←
Returning from 'PointerIntPair::getOpaqueValue'→
659
←
Calling 'PointerIntPair::getOpaqueValue'→
660
←
Returning from 'PointerIntPair::getOpaqueValue'→
719
←
Calling 'PointerIntPair::getOpaqueValue'→
720
←
Returning from 'PointerIntPair::getOpaqueValue'→
777
←
Calling 'PointerIntPair::getOpaqueValue'→
778
←
Returning from 'PointerIntPair::getOpaqueValue'→
837
←
Calling 'PointerIntPair::getOpaqueValue'→
838
←
Returning from 'PointerIntPair::getOpaqueValue'→
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

676public:
QualType() = default;
QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
261
←
Calling constructor for 'PointerUnion'→
275
←
Returning from constructor for 'PointerUnion'→
276
←
Calling constructor for 'PointerIntPair'→
291
←
Returning from constructor for 'PointerIntPair'→
589
←
Calling constructor for 'PointerUnion'→
603
←
Returning from constructor for 'PointerUnion'→
604
←
Calling constructor for 'PointerIntPair'→
619
←
Returning from constructor for 'PointerIntPair'→
QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}

unsigned getLocalFastQualifiers() const { return Value.getInt(); }
252
←
Calling 'PointerIntPair::getInt'→
255
←
Returning from 'PointerIntPair::getInt'→
335
←
Calling 'PointerIntPair::getInt'→
338
←
Returning from 'PointerIntPair::getInt'→
453
←
Calling 'PointerIntPair::getInt'→
456
←
Returning from 'PointerIntPair::getInt'→
581
←
Calling 'PointerIntPair::getInt'→
584
←
Returning from 'PointerIntPair::getInt'→
663
←
Calling 'PointerIntPair::getInt'→
666
←
Returning from 'PointerIntPair::getInt'→
781
←
Calling 'PointerIntPair::getInt'→
784
←
Returning from 'PointerIntPair::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();
213
←
Calling 'PointerIntPair::getPointer'→
230
←
Returning from 'PointerIntPair::getPointer'→
231
←
Calling 'PointerUnion::isNull'→
243
←
Returning from 'PointerUnion::isNull'→
300
←
Calling 'PointerIntPair::getPointer'→
317
←
Returning from 'PointerIntPair::getPointer'→
318
←
Calling 'PointerUnion::isNull'→
330
←
Returning from 'PointerUnion::isNull'→
360
←
Calling 'PointerIntPair::getPointer'→
377
←
Returning from 'PointerIntPair::getPointer'→
378
←
Calling 'PointerUnion::isNull'→
390
←
Returning from 'PointerUnion::isNull'→
418
←
Calling 'PointerIntPair::getPointer'→
435
←
Returning from 'PointerIntPair::getPointer'→
436
←
Calling 'PointerUnion::isNull'→
448
←
Returning from 'PointerUnion::isNull'→
478
←
Calling 'PointerIntPair::getPointer'→
495
←
Returning from 'PointerIntPair::getPointer'→
496
←
Calling 'PointerUnion::isNull'→
508
←
Returning from 'PointerUnion::isNull'→
542
←
Calling 'PointerIntPair::getPointer'→
559
←
Returning from 'PointerIntPair::getPointer'→
560
←
Calling 'PointerUnion::isNull'→
572
←
Returning from 'PointerUnion::isNull'→
628
←
Calling 'PointerIntPair::getPointer'→
645
←
Returning from 'PointerIntPair::getPointer'→
646
←
Calling 'PointerUnion::isNull'→
658
←
Returning from 'PointerUnion::isNull'→
688
←
Calling 'PointerIntPair::getPointer'→
705
←
Returning from 'PointerIntPair::getPointer'→
706
←
Calling 'PointerUnion::isNull'→
718
←
Returning from 'PointerUnion::isNull'→
746
←
Calling 'PointerIntPair::getPointer'→
763
←
Returning from 'PointerIntPair::getPointer'→
764
←
Calling 'PointerUnion::isNull'→
776
←
Returning from 'PointerUnion::isNull'→
806
←
Calling 'PointerIntPair::getPointer'→
823
←
Returning from 'PointerIntPair::getPointer'→
824
←
Calling 'PointerUnion::isNull'→
836
←
Returning from 'PointerUnion::isNull'→
}

/// \brief 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);
}

/// \brief Determine whether this type is const-qualified.
bool isConstQualified() const;

/// \brief 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);
}

/// \brief Determine whether this type is restrict-qualified.
bool isRestrictQualified() const;

/// \brief 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);
}

/// \brief Determine whether this type is volatile-qualified.
bool isVolatileQualified() const;

/// \brief 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();
251
←
Calling 'QualType::getLocalFastQualifiers'→
256
←
Returning from 'QualType::getLocalFastQualifiers'→
257
←
Assuming the condition is true→
580
←
Calling 'QualType::getLocalFastQualifiers'→
585
←
Returning from 'QualType::getLocalFastQualifiers'→
}

/// \brief Determine whether this type has any qualifiers.
bool hasQualifiers() const;

/// \brief 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*>();
}

/// \brief Retrieve the set of qualifiers local to this particular QualType
/// instance, not including any qualifiers acquired through typedefs or
/// other sugar.
Qualifiers getLocalQualifiers() const;

/// \brief Retrieve the set of qualifiers applied to this type.
Qualifiers getQualifiers() const;

/// \brief 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();
}

/// \brief 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);
}

/// \brief 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)
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;

/// Determine whether this is a class whose triviality for the purpose of
/// calls is overridden to be trivial because the class or the type of one of
/// its subobjects has attribute "trivial_abi".
bool hasTrivialABIOverride() 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)(static_cast <bool> (!(TQs & ~Qualifiers::FastMask)
 && "non-fast qualifier bits set in mask!") ? void (0
) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 849, __extension__ __PRETTY_FUNCTION__))
342
←
Within the expansion of the macro 'assert':
→
460
←
Within the expansion of the macro 'assert':
→
a
Assuming the condition is true
670
←
Within the expansion of the macro 'assert':
→
788
←
Within the expansion of the macro 'assert':
→
a
Assuming the condition is true
         && "non-fast qualifier bits set in mask!")(static_cast <bool> (!(TQs & ~Qualifiers::FastMask)
 && "non-fast qualifier bits set in mask!") ? void (0
) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 849, __extension__ __PRETTY_FUNCTION__));
  Value.setInt(Value.getInt() | TQs);
343
←
Calling 'PointerIntPair::getInt'→
346
←
Returning from 'PointerIntPair::getInt'→
347
←
Calling 'PointerIntPair::setInt'→
351
←
Returning from 'PointerIntPair::setInt'→
461
←
Calling 'PointerIntPair::getInt'→
464
←
Returning from 'PointerIntPair::getInt'→
465
←
Calling 'PointerIntPair::setInt'→
469
←
Returning from 'PointerIntPair::setInt'→
671
←
Calling 'PointerIntPair::getInt'→
674
←
Returning from 'PointerIntPair::getInt'→
675
←
Calling 'PointerIntPair::setInt'→
679
←
Returning from 'PointerIntPair::setInt'→
789
←
Calling 'PointerIntPair::getInt'→
792
←
Returning from 'PointerIntPair::getInt'→
793
←
Calling 'PointerIntPair::setInt'→
797
←
Returning from 'PointerIntPair::setInt'→
}

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")(static_cast <bool> (!(Mask & ~Qualifiers::FastMask
) && "mask has non-fast qualifiers") ? void (0) : __assert_fail
 ("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 860, __extension__ __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);
341
←
Calling 'QualType::addFastQualifiers'→
352
←
Returning from 'QualType::addFastQualifiers'→
459
←
Calling 'QualType::addFastQualifiers'→
470
←
Returning from 'QualType::addFastQualifiers'→
669
←
Calling 'QualType::addFastQualifiers'→
680
←
Returning from 'QualType::addFastQualifiers'→
787
←
Calling 'QualType::addFastQualifiers'→
798
←
Returning from 'QualType::addFastQualifiers'→
  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;

/// \brief 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); }

/// \brief 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;

/// \brief Determine whether this type is more qualified than the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isMoreQualifiedThan(QualType Other) const;

/// \brief 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;

/// \brief 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);
}

/// \brief 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;
}
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 {
  print(split(), OS, Policy, PlaceHolder, Indentation);
}

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 {
  return getAsStringInternal(split(), Str, Policy);
}

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 DestructionKind {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime
};

/// 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);
}

/// 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;

1165private:
// 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);
1177};

1179} // namespace clang

1181namespace llvm {

1183/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1184/// to a specific Type class.
1185template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1191};

1193// Teach SmallPtrSet that QualType is "basically a pointer".
1194template<>
1195struct 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 };
1206};

1208} // namespace llvm

1210namespace clang {

1212/// \brief Base class that is common to both the \c ExtQuals and \c Type
1213/// classes, which allows \c QualType to access the common fields between the
1214/// two.
1215class ExtQualsTypeCommonBase {
friend class ExtQuals;
friend class QualType;
friend class Type;

/// \brief 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;

/// \brief The canonical type of this type.  A QualType.
QualType CanonicalType;

ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
    : BaseType(baseType), CanonicalType(canon) {}
1232};

1234/// We can encode up to four bits in the low bits of a
1235/// type pointer, but there are many more type qualifiers that we want
1236/// to be able to apply to an arbitrary type.  Therefore we have this
1237/// struct, intended to be heap-allocated and used by QualType to
1238/// store qualifiers.
1239///
1240/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1241/// in three low bits on the QualType pointer; a fourth bit records whether
1242/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1243/// Objective-C GC attributes) are much more rare.
1244class 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; }

1264public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()(static_cast <bool> (Quals.hasNonFastQualifiers() &&
 "ExtQuals created with no fast qualifiers") ? void (0) : __assert_fail
 ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 1270, __extension__ __PRETTY_FUNCTION__))
         && "ExtQuals created with no fast qualifiers")(static_cast <bool> (Quals.hasNonFastQualifiers() &&
 "ExtQuals created with no fast qualifiers") ? void (0) : __assert_fail
 ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 1270, __extension__ __PRETTY_FUNCTION__));
  assert(!Quals.hasFastQualifiers()(static_cast <bool> (!Quals.hasFastQualifiers() &&
 "ExtQuals created with fast qualifiers") ? void (0) : __assert_fail
 ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 1272, __extension__ __PRETTY_FUNCTION__))
         && "ExtQuals created with fast qualifiers")(static_cast <bool> (!Quals.hasFastQualifiers() &&
 "ExtQuals created with fast qualifiers") ? void (0) : __assert_fail
 ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 1272, __extension__ __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; }

1290public:
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!")(static_cast <bool> (!Quals.hasFastQualifiers() &&
 "fast qualifiers in ExtQuals hash!") ? void (0) : __assert_fail
 ("!Quals.hasFastQualifiers() && \"fast qualifiers in ExtQuals hash!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 1298, __extension__ __PRETTY_FUNCTION__));
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1302};

1304/// The kind of C++11 ref-qualifier associated with a function type.
1305/// This determines whether a member function's "this" object can be an
1306/// lvalue, rvalue, or neither.
1307enum RefQualifierKind {
/// \brief No ref-qualifier was provided.
RQ_None = 0,

/// \brief An lvalue ref-qualifier was provided (\c &).
RQ_LValue,

/// \brief An rvalue ref-qualifier was provided (\c &&).
RQ_RValue
1316};

1318/// Which keyword(s) were used to create an AutoType.
1319enum class AutoTypeKeyword {
/// \brief auto
Auto,

/// \brief decltype(auto)
DecltypeAuto,

/// \brief __auto_type (GNU extension)
GNUAutoType
1328};

1330/// The base class of the type hierarchy.
1331///
1332/// A central concept with types is that each type always has a canonical
1333/// type.  A canonical type is the type with any typedef names stripped out
1334/// of it or the types it references.  For example, consider:
1335///
1336///  typedef int  foo;
1337///  typedef foo* bar;
1338///    'int *'    'foo *'    'bar'
1339///
1340/// There will be a Type object created for 'int'.  Since int is canonical, its
1341/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1342/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1343/// there is a PointerType that represents 'int*', which, like 'int', is
1344/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1345/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1346/// is also 'int*'.
1347///
1348/// Non-canonical types are useful for emitting diagnostics, without losing
1349/// information about typedefs being used.  Canonical types are useful for type
1350/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1351/// about whether something has a particular form (e.g. is a function type),
1352/// because they implicitly, recursively, strip all typedefs out of a type.
1353///
1354/// Types, once created, are immutable.
1355///
1356class Type : public ExtQualsTypeCommonBase {
1357public:
enum TypeClass {
1359#define TYPE(Class, Base) Class,
1360#define LAST_TYPE(Class) TypeLast = Class,
1361#define ABSTRACT_TYPE(Class, Base)
1362#include "clang/AST/TypeNodes.def"
  TagFirst = Record, TagLast = Enum
};

1366private:
/// 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;

  /// \brief Whether this type contains an unexpanded parameter pack
  /// (for C++11 variadic templates).
  unsigned ContainsUnexpandedParameterPack : 1;

  /// \brief True if the cache (i.e. the bitfields here starting with
  /// 'Cache') is valid.
  mutable unsigned CacheValid : 1;

  /// \brief Linkage of this type.
  mutable unsigned CachedLinkage : 3;

  /// \brief Whether this type involves and local or unnamed types.
  mutable unsigned CachedLocalOrUnnamed : 1;

  /// \brief 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")(static_cast <bool> (isCacheValid() && "getting linkage from invalid cache"
) ? void (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 1407, __extension__ __PRETTY_FUNCTION__));
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")(static_cast <bool> (isCacheValid() && "getting linkage from invalid cache"
) ? void (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 1412, __extension__ __PRETTY_FUNCTION__));
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 18 };

1418protected:
// 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;
};

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 : 11;

  /// 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 TypeQuals : 4;

  /// \brief The ref-qualifier associated with a \c FunctionProtoType.
  ///
  /// This is a value of type \c RefQualifierKind.
  unsigned RefQualifier : 2;
};

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;
};

static_assert(NumTypeBits + 7 + 6 + 1 <= 32, "Does not fit in an unsigned");

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;
};

class VectorTypeBitfields {
  friend class VectorType;

  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;
};

union {
  TypeBitfields TypeBits;
  ArrayTypeBitfields ArrayTypeBits;
  AttributedTypeBitfields AttributedTypeBits;
  AutoTypeBitfields AutoTypeBits;
  BuiltinTypeBitfields BuiltinTypeBits;
  FunctionTypeBitfields FunctionTypeBits;
  ObjCObjectTypeBitfields ObjCObjectTypeBits;
  ReferenceTypeBitfields ReferenceTypeBits;
  TypeWithKeywordBitfields TypeWithKeywordBits;
  VectorTypeBitfields VectorTypeBits;
};

1566private:
template <class T> friend class TypePropertyCache;

/// \brief Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1574protected:
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;
}

1611public:
friend class ASTReader;
friend class ASTWriter;

Type(const Type &) = delete;
Type &operator=(const Type &) = delete;

TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }

/// \brief Whether this type comes from an AST file.
bool isFromAST() const { return TypeBits.FromAST; }

/// \brief 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.
///
/// \brief 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();
}

/// \brief 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;
bool isBooleanType() const;
bool isCharType() const;
bool isWideCharType() 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 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 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 isObjCInertUnsafeUnretainedType() const;

/// 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 isAlignValT() const;                     // C++17 std::align_val_t
bool isStdByteType() const;                   // C++17 std::byte
bool isAtomicType() const;                    // C11 _Atomic()

1824#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
1826#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

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
};

/// 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; }

/// \brief 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;
}

/// \brief 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;

/// \brief Whether this type is a variably-modified type (C99 6.7.5).
bool isVariablyModifiedType() const { return TypeBits.VariablyModified; }

/// \brief Whether this type involves a variable-length array type
/// with a definite size.
bool hasSizedVLAType() const;

/// \brief Whether this type is or contains a local or unnamed type.
bool hasUnnamedOrLocalType() const;

bool isOverloadableType() const;

/// \brief 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;

/// \brief Determine whether this type has an integer representation
/// of some sort, e.g., it is an integer type or a vector.
bool hasIntegerRepresentation() const;

/// \brief 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;

/// \brief 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;

/// \brief 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;

/// \brief 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;

/// \brief 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 that 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;

/// 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 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;
2120};

2122/// \brief This will check for a TypedefType by removing any existing sugar
2123/// until it reaches a TypedefType or a non-sugared type.
2124template <> const TypedefType *Type::getAs() const;

2126/// \brief This will check for a TemplateSpecializationType by removing any
2127/// existing sugar until it reaches a TemplateSpecializationType or a
2128/// non-sugared type.
2129template <> const TemplateSpecializationType *Type::getAs() const;

2131/// \brief This will check for an AttributedType by removing any existing sugar
2132/// until it reaches an AttributedType or a non-sugared type.
2133template <> const AttributedType *Type::getAs() const;

2135// We can do canonical leaf types faster, because we don't have to
2136// worry about preserving child type decoration.
2137#define TYPE(Class, Base)
2138#define LEAF_TYPE(Class) \
2139template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2141} \
2142template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2144}
2145#include "clang/AST/TypeNodes.def"

2147/// This class is used for builtin types like 'int'.  Builtin
2148/// types are always canonical and have a literal name field.
2149class BuiltinType : public Type {
2150public:
enum Kind {
2152// OpenCL image types
2153#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2154#include "clang/Basic/OpenCLImageTypes.def"
2155// All other builtin types
2156#define BUILTIN_TYPE(Id, SingletonId) Id,
2157#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2158#include "clang/AST/BuiltinTypes.def"
};

2161public:
BuiltinType(Kind K)
    : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent),
           /*InstantiationDependent=*/(K == Dependent),
           /*VariablyModified=*/false,
           /*Unexpanded parameter pack=*/false) {
  BuiltinTypeBits.Kind = K;
}

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')(static_cast <bool> (!str.empty() && str.data()
[str.size()] == '\0') ? void (0) : __assert_fail ("!str.empty() && str.data()[str.size()] == '\\0'"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 2176, __extension__ __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; }
2225};

2227/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2228/// types (_Complex float etc) as well as the GCC integer complex extensions.
2229class 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) {}

2241public:
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; }
2256};

2258/// Sugar for parentheses used when specifying types.
2259class 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) {}

2271public:
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; }
2286};

2288/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2289class 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) {}

2301public:
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; }
2332};

2334/// Represents a type which was implicitly adjusted by the semantic
2335/// engine for arbitrary reasons.  For example, array and function types can
2336/// decay, and function types can have their calling conventions adjusted.
2337class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2341protected:
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) {}

2352public:
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;
}
2371};

2373/// Represents a pointer type decayed from an array or function type.
2374class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2380public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2386};

2388/// Pointer to a block type.
2389/// This type is to represent types syntactically represented as
2390/// "void (^)(int)", etc. Pointee is required to always be a function type.
2391class 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) {}

2404public:
// 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;
}
2422};

2424/// Base for LValueReferenceType and RValueReferenceType
2425class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2428protected:
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();
}

2440public:
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;
}
2469};

2471/// An lvalue reference type, per C++11 [dcl.ref].
2472class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2480public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2487};

2489/// An rvalue reference type, per C++11 [dcl.ref].
2490class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2496public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2503};

2505/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2506///
2507/// This includes both pointers to data members and pointer to member functions.
2508class 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) {}

2527public:
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;
}
2561};

2563/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2564class ArrayType : public Type, public llvm::FoldingSetNode {
2565public:
/// 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
};

2574private:
/// The element type of the array.
QualType ElementType;

2578protected:
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;
}

2598public:
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;
}
2619};

2621/// Represents the canonical version of C arrays with a specified constant size.
2622/// For example, the canonical type for 'int A[4 + 4*100]' is a
2623/// ConstantArrayType where the element type is 'int' and the size is 404.
2624class 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) {}

2633protected:
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) {}

2641public:
const llvm::APInt &getSize() const { return Size; }
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// \brief 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);

/// \brief 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;
}
2673};

2675/// Represents a C array with an unspecified size.  For example 'int A[]' has
2676/// an IncompleteArrayType where the element type is 'int' and the size is
2677/// unspecified.
2678class 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()) {}

2686public:
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);
}
2707};

2709/// Represents a C array with a specified size that is not an
2710/// integer-constant-expression.  For example, 'int s[x+foo()]'.
2711/// Since the size expression is an arbitrary expression, we store it as such.
2712///
2713/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
2714/// should not be: two lexically equivalent variable array types could mean
2715/// different things, for example, these variables do not have the same type
2716/// dynamically:
2717///
2718/// void foo(int x) {
2719///   int Y[x];
2720///   ++x;
2721///   int Z[x];
2722/// }
2723class 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) {}

2740public:
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-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 2761);
}
2763};

2765/// Represents an array type in C++ whose size is a value-dependent expression.
2766///
2767/// For example:
2768/// \code
2769/// template<typename T, int Size>
2770/// class array {
2771///   T data[Size];
2772/// };
2773/// \endcode
2774///
2775/// For these types, we won't actually know what the array bound is
2776/// until template instantiation occurs, at which point this will
2777/// become either a ConstantArrayType or a VariableArrayType.
2778class DependentSizedArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

const ASTContext &Context;

/// \brief 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);

2797public:
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);
2825};

2827/// Represents an extended address space qualifier where the input address space
2828/// value is dependent. Non-dependent address spaces are not represented with a 
2829/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
2830///
2831/// For example:
2832/// \code
2833/// template<typename T, int AddrSpace>
2834/// class AddressSpace {
2835///   typedef T __attribute__((address_space(AddrSpace))) type;
2836/// }
2837/// \endcode
2838class 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);

2850public:
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);
2868};

2870/// Represents an extended vector type where either the type or size is
2871/// dependent.
2872///
2873/// For example:
2874/// \code
2875/// template<typename T, int Size>
2876/// class vector {
2877///   typedef T __attribute__((ext_vector_type(Size))) type;
2878/// }
2879/// \endcode
2880class 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);

2894public:
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);
2912};


2915/// Represents a GCC generic vector type. This type is created using
2916/// __attribute__((vector_size(n)), where "n" specifies the vector size in
2917/// bytes; or from an Altivec __vector or vector declaration.
2918/// Since the constructor takes the number of vector elements, the
2919/// client is responsible for converting the size into the number of elements.
2920class VectorType : public Type, public llvm::FoldingSetNode {
2921public:
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
};

2942protected:
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);

2954public:
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;
}
2986};

2988/// ExtVectorType - Extended vector type. This type is created using
2989/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
2990/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
2991/// class enables syntactic extensions, like Vector Components for accessing
2992/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
2993/// Shading Language).
2994class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3000public:
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;
}
3058};

3060/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3061/// class of FunctionNoProtoType and FunctionProtoType.
3062class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3066public:
/// 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 11,
  // you'll need to adjust both the Bits field below and
  // Type::FunctionTypeBitfields.

  //   |  CC  |noreturn|produces|nocallersavedregs|regparm|
  //   |0 .. 4|   5    |    6   |       7         |8 .. 10|
  //
  // 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 {
    RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask |
                    NoCallerSavedRegsMask),
    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) {
     assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(static_cast <bool> ((!hasRegParm || regParm < 7) &&
 "Invalid regparm value") ? void (0) : __assert_fail ("(!hasRegParm || regParm < 7) && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3117, __extension__ __PRETTY_FUNCTION__));
     Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
            (producesResult ? ProducesResultMask : 0) |
            (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
            (hasRegParm ? ((regParm + 1) << RegParmOffset) : 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 getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }

  unsigned getRegParm() const {
    unsigned RegParm = Bits >> 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 withRegParm(unsigned RegParm) const {
    assert(RegParm < 7 && "Invalid regparm value")(static_cast <bool> (RegParm < 7 && "Invalid regparm value"
) ? void (0) : __assert_fail ("RegParm < 7 && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3178, __extension__ __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);
  }
};

3192protected:
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;
}

unsigned getTypeQuals() const { return FunctionTypeBits.TypeQuals; }

3206public:
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); }
bool isConst() const { return getTypeQuals() & Qualifiers::Const; }
bool isVolatile() const { return getTypeQuals() & Qualifiers::Volatile; }
bool isRestrict() const { return getTypeQuals() & Qualifiers::Restrict; }

/// \brief 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;
}
3235};

3237/// Represents a K&R-style 'int foo()' function, which has
3238/// no information available about its arguments.
3239class 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) {}

3248public:
// 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;
}
3267};

3269/// Represents a prototype with parameter type info, e.g.
3270/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3271/// parameters, not as having a single void parameter. Such a type can have an
3272/// exception specification, but this specification is not part of the canonical
3273/// type.
3274class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
3275public:
/// Interesting information about a specific parameter that can't simply
/// be reflected in parameter's type.
///
/// 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;
  }
};

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 EST_ComputedNoexcept.
  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.
struct ExtProtoInfo {
  FunctionType::ExtInfo ExtInfo;
  bool Variadic : 1;
  bool HasTrailingReturn : 1;
  unsigned char TypeQuals = 0;
  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 &O) {
    ExtProtoInfo Result(*this);
    Result.ExceptionSpec = O;
    return Result;
  }
};

3415private:
friend class ASTContext; // ASTContext creates these.

/// \brief 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);

/// The number of parameters this function has, not counting '...'.
unsigned NumParams : 15;

/// The number of types in the exception spec, if any.
unsigned NumExceptions : 9;

/// 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;

// ParamInfo - There is an variable size array after the class in memory that
// holds the parameter types.

// Exceptions - There is another variable size array after ArgInfo that
// holds the exception types.

// NoexceptExpr - Instead of Exceptions, there may be a single Expr* pointing
// to the expression in the noexcept() specifier.

// ExceptionSpecDecl, ExceptionSpecTemplate - Instead of Exceptions, there may
// be a pair of FunctionDecl* pointing to the function which should be used to
// instantiate this function type's exception specification, and the function
// from which it should be instantiated.

// ExtParameterInfos - A variable size array, following the exception
// specification and of length NumParams, holding an ExtParameterInfo
// for each of the parameters.  This only appears if HasExtParameterInfos
// is true.

const ExtParameterInfo *getExtParameterInfosBuffer() const {
  assert(hasExtParameterInfos())(static_cast <bool> (hasExtParameterInfos()) ? void (0)
 : __assert_fail ("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3470, __extension__ __PRETTY_FUNCTION__));

  // Find the end of the exception specification.
  const char *ptr = reinterpret_cast<const char *>(exception_begin());
  ptr += getExceptionSpecSize();

  return reinterpret_cast<const ExtParameterInfo *>(ptr);
}

size_t getExceptionSpecSize() const {
  switch (getExceptionSpecType()) {
  case EST_None:             return 0;
  case EST_DynamicNone:      return 0;
  case EST_MSAny:            return 0;
  case EST_BasicNoexcept:    return 0;
  case EST_Unparsed:         return 0;
  case EST_Dynamic:          return getNumExceptions() * sizeof(QualType);
  case EST_ComputedNoexcept: return sizeof(Expr*);
  case EST_Uninstantiated:   return 2 * sizeof(FunctionDecl*);
  case EST_Unevaluated:      return sizeof(FunctionDecl*);
  }
  llvm_unreachable("bad exception specification kind")::llvm::llvm_unreachable_internal("bad exception specification kind"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3491);
}

3494public:
unsigned getNumParams() const { return NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < NumParams && "invalid parameter index")(static_cast <bool> (i < NumParams && "invalid parameter index"
) ? void (0) : __assert_fail ("i < NumParams && \"invalid parameter index\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3498, __extension__ __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 = static_cast<unsigned char>(getTypeQuals());
  EPI.RefQualifier = getRefQualifier();
  if (EPI.ExceptionSpec.Type == EST_Dynamic) {
    EPI.ExceptionSpec.Exceptions = exceptions();
  } else if (EPI.ExceptionSpec.Type == EST_ComputedNoexcept) {
    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();
  }
  if (hasExtParameterInfos())
    EPI.ExtParameterInfos = getExtParameterInfosBuffer();
  return EPI;
}

/// Get the kind of exception specification on this function.
ExceptionSpecificationType getExceptionSpecType() const {
  return static_cast<ExceptionSpecificationType>(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;

/// Result type of getNoexceptSpec().
enum NoexceptResult {
  /// There is no noexcept specifier.
  NR_NoNoexcept,

  /// The noexcept specifier has a bad expression.
  NR_BadNoexcept,

  /// The noexcept specifier is dependent.
  NR_Dependent,

  /// The noexcept specifier evaluates to false.
  NR_Throw,

  /// The noexcept specifier evaluates to true.
  NR_Nothrow
};

/// Get the meaning of the noexcept spec on this function, if any.
NoexceptResult getNoexceptSpec(const ASTContext &Ctx) const;
unsigned getNumExceptions() const { return NumExceptions; }
QualType getExceptionType(unsigned i) const {
  assert(i < NumExceptions && "Invalid exception number!")(static_cast <bool> (i < NumExceptions && "Invalid exception number!"
) ? void (0) : __assert_fail ("i < NumExceptions && \"Invalid exception number!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3578, __extension__ __PRETTY_FUNCTION__));
  return exception_begin()[i];
}
Expr *getNoexceptExpr() const {
  if (getExceptionSpecType() != EST_ComputedNoexcept)
    return nullptr;
  // NoexceptExpr sits where the arguments end.
  return *reinterpret_cast<Expr *const *>(param_type_end());
}

/// \brief 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 reinterpret_cast<FunctionDecl *const *>(param_type_end())[0];
}

/// \brief 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 reinterpret_cast<FunctionDecl *const *>(param_type_end())[1];
}

/// Determine whether this function type has a non-throwing exception
/// specification.
CanThrowResult canThrow(const ASTContext &Ctx) const;

/// Determine whether this function type has a non-throwing exception
/// specification. If this depends on template arguments, returns
/// \c ResultIfDependent.
bool isNothrow(const ASTContext &Ctx, bool ResultIfDependent = false) const {
  return ResultIfDependent ? canThrow(Ctx) != CT_Can
                           : canThrow(Ctx) == CT_Cannot;
}

bool isVariadic() const { return 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;

bool hasTrailingReturn() const { return HasTrailingReturn; }

unsigned getTypeQuals() const { return FunctionType::getTypeQuals(); }

/// 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 reinterpret_cast<const QualType *>(this+1);
}

param_type_iterator param_type_end() const {
  return param_type_begin() + NumParams;
}

using exception_iterator = const QualType *;

ArrayRef<QualType> exceptions() const {
  return llvm::makeArrayRef(exception_begin(), exception_end());
}

exception_iterator exception_begin() const {
  // exceptions begin where arguments end
  return param_type_end();
}

exception_iterator exception_end() const {
  if (getExceptionSpecType() != EST_Dynamic)
    return exception_begin();
  return exception_begin() + NumExceptions;
}

/// Is there any interesting extra information for any of the parameters
/// of this function type?
bool hasExtParameterInfos() const { return HasExtParameterInfos; }
ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
  assert(hasExtParameterInfos())(static_cast <bool> (hasExtParameterInfos()) ? void (0)
 : __assert_fail ("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3676, __extension__ __PRETTY_FUNCTION__));
  return ArrayRef<ExtParameterInfo>(getExtParameterInfosBuffer(),
                                    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 getExtParameterInfosBuffer();
}

ExtParameterInfo getExtParameterInfo(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")(static_cast <bool> (I < getNumParams() && "parameter index out of range"
) ? void (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3691, __extension__ __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getExtParameterInfosBuffer()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")(static_cast <bool> (I < getNumParams() && "parameter index out of range"
) ? void (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3698, __extension__ __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getExtParameterInfosBuffer()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")(static_cast <bool> (I < getNumParams() && "parameter index out of range"
) ? void (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3705, __extension__ __PRETTY_FUNCTION__));
  if (hasExtParameterInfos())
    return getExtParameterInfosBuffer()[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);
3726};

3728/// \brief Represents the dependent type named by a dependently-scoped
3729/// typename using declaration, e.g.
3730///   using typename Base<T>::foo;
3731///
3732/// Template instantiation turns these into the underlying type.
3733class 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)) {}

3743public:
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);
}
3761};

3763class TypedefType : public Type {
TypedefNameDecl *Decl;

3766protected:
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")(static_cast <bool> (!isa<TypedefType>(can) &&
 "Invalid canonical type") ? void (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3775, __extension__ __PRETTY_FUNCTION__));
}

3778public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
3785};

3787/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
3788class TypeOfExprType : public Type {
Expr *TOExpr;

3791protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

3796public:
Expr *getUnderlyingExpr() const { return TOExpr; }

/// \brief Remove a single level of sugar.
QualType desugar() const;

/// \brief Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
3806};

3808/// \brief Internal representation of canonical, dependent
3809/// `typeof(expr)` types.
3810///
3811/// This class is used internally by the ASTContext to manage
3812/// canonical, dependent types, only. Clients will only see instances
3813/// of this class via TypeOfExprType nodes.
3814class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

3818public:
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);
3828};

3830/// Represents `typeof(type)`, a GCC extension.
3831class 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")(static_cast <bool> (!isa<TypedefType>(can) &&
 "Invalid canonical type") ? void (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 3842, __extension__ __PRETTY_FUNCTION__));
}

3845public:
QualType getUnderlyingType() const { return TOType; }

/// \brief Remove a single level of sugar.
QualType desugar() const { return getUnderlyingType(); }

/// \brief Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
3855};

3857/// Represents the type `decltype(expr)` (C++11).
3858class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

3862protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

3867public:
Expr *getUnderlyingExpr() const { return E; }
QualType getUnderlyingType() const { return UnderlyingType; }

/// \brief Remove a single level of sugar.
QualType desugar() const;

/// \brief Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
3878};

3880/// \brief Internal representation of canonical, dependent
3881/// decltype(expr) types.
3882///
3883/// This class is used internally by the ASTContext to manage
3884/// canonical, dependent types, only. Clients will only see instances
3885/// of this class via DecltypeType nodes.
3886class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

3889public:
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);
3898};

3900/// A unary type transform, which is a type constructed from another.
3901class UnaryTransformType : public Type {
3902public:
enum UTTKind {
  EnumUnderlyingType
};

3907private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

3916protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

3922public:
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;
}
3934};

3936/// \brief Internal representation of canonical, dependent
3937/// __underlying_type(type) types.
3938///
3939/// This class is used internally by the ASTContext to manage
3940/// canonical, dependent types, only. Clients will only see instances
3941/// of this class via UnaryTransformType nodes.
3942class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
3944public:
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);
}
3957};

3959class 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;

3966protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

3969public:
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() >= TagFirst && T->getTypeClass() <= TagLast;
}
3978};

3980/// A helper class that allows the use of isa/cast/dyncast
3981/// to detect TagType objects of structs/unions/classes.
3982class RecordType : public TagType {
3983protected:
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()) {}

3991public:
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; }
4004};

4006/// A helper class that allows the use of isa/cast/dyncast
4007/// to detect TagType objects of enums.
4008class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4014public:
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; }
4023};

4025/// An attributed type is a type to which a type attribute has been applied.
4026///
4027/// The "modified type" is the fully-sugared type to which the attributed
4028/// type was applied; generally it is not canonically equivalent to the
4029/// attributed type. The "equivalent type" is the minimally-desugared type
4030/// which the type is canonically equivalent to.
4031///
4032/// For example, in the following attributed type:
4033///     int32_t __attribute__((vector_size(16)))
4034///   - the modified type is the TypedefType for int32_t
4035///   - the equivalent type is VectorType(16, int32_t)
4036///   - the canonical type is VectorType(16, int)
4037class AttributedType : public Type, public llvm::FoldingSetNode {
4038public:
// It is really silly to have yet another attribute-kind enum, but
// clang::attr::Kind doesn't currently cover the pure type attrs.
enum Kind {
  // Expression operand.
  attr_address_space,
  attr_regparm,
  attr_vector_size,
  attr_neon_vector_type,
  attr_neon_polyvector_type,

  FirstExprOperandKind = attr_address_space,
  LastExprOperandKind = attr_neon_polyvector_type,

  // Enumerated operand (string or keyword).
  attr_objc_gc,
  attr_objc_ownership,
  attr_pcs,
  attr_pcs_vfp,

  FirstEnumOperandKind = attr_objc_gc,
  LastEnumOperandKind = attr_pcs_vfp,

  // No operand.
  attr_noreturn,
  attr_cdecl,
  attr_fastcall,
  attr_stdcall,
  attr_thiscall,
  attr_regcall,
  attr_pascal,
  attr_swiftcall,
  attr_vectorcall,
  attr_inteloclbicc,
  attr_ms_abi,
  attr_sysv_abi,
  attr_preserve_most,
  attr_preserve_all,
  attr_ptr32,
  attr_ptr64,
  attr_sptr,
  attr_uptr,
  attr_nonnull,
  attr_ns_returns_retained,
  attr_nullable,
  attr_null_unspecified,
  attr_objc_kindof,
  attr_objc_inert_unsafe_unretained,
};

4088private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->isDependentType(),
           equivalent->isInstantiationDependentType(),
           equivalent->isVariablyModifiedType(),
           equivalent->containsUnexpandedParameterPack()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4104public:
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_nonnull;

  case NullabilityKind::Nullable:
    return attr_nullable;

  case NullabilityKind::Unspecified:
    return attr_null_unspecified;
  }
  llvm_unreachable("Unknown nullability kind.")::llvm::llvm_unreachable_internal("Unknown nullability kind."
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4151);
}

/// 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;
}
4179};

4181class 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;
}

4223public:
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;
}
4253};

4255/// \brief Represents the result of substituting a type for a template
4256/// type parameter.
4257///
4258/// Within an instantiated template, all template type parameters have
4259/// been replaced with these.  They are used solely to record that a
4260/// type was originally written as a template type parameter;
4261/// therefore they are never canonical.
4262class 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) {}

4275public:
/// 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;
}
4304};

4306/// \brief Represents the result of substituting a set of types for a template
4307/// type parameter pack.
4308///
4309/// When a pack expansion in the source code contains multiple parameter packs
4310/// and those parameter packs correspond to different levels of template
4311/// parameter lists, this type node is used to represent a template type
4312/// parameter pack from an outer level, which has already had its argument pack
4313/// substituted but that still lives within a pack expansion that itself
4314/// could not be instantiated. When actually performing a substitution into
4315/// that pack expansion (e.g., when all template parameters have corresponding
4316/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4317/// at the current pack substitution index.
4318class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

/// \brief The original type parameter.
const TemplateTypeParmType *Replaced;

/// \brief A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

/// \brief The number of template arguments in \c Arguments.
unsigned NumArguments;

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                              QualType Canon,
                              const TemplateArgument &ArgPack);

4335public:
IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }

/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

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;
}
4356};

4358/// \brief Common base class for placeholders for types that get replaced by
4359/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4360/// class template types, and (eventually) constrained type names from the C++
4361/// Concepts TS.
4362///
4363/// These types are usually a placeholder for a deduced type. However, before
4364/// the initializer is attached, or (usually) if the initializer is
4365/// type-dependent, there is no deduced type and the type is canonical. In
4366/// the latter case, it is also a dependent type.
4367class DeducedType : public Type {
4368protected:
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();
  }
}

4387public:
bool isSugared() const { return !isCanonicalUnqualified(); }
QualType desugar() const { return getCanonicalTypeInternal(); }

/// \brief 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;
}
4404};

4406/// \brief Represents a C++11 auto or C++14 decltype(auto) type.
4407class AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         bool IsDeducedAsDependent)
    : DeducedType(Auto, DeducedAsType, IsDeducedAsDependent,
                  IsDeducedAsDependent, /*ContainsPack=*/false) {
  AutoTypeBits.Keyword = (unsigned)Keyword;
}

4417public:
bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDeducedType(), getKeyword(), isDependentType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Deduced,
                    AutoTypeKeyword Keyword, bool IsDependent) {
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddInteger((unsigned)Keyword);
  ID.AddBoolean(IsDependent);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
4440};

4442/// \brief Represents a C++17 deduced template specialization type.
4443class 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) {}

4459public:
/// 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;
}
4477};

4479/// \brief Represents a type template specialization; the template
4480/// must be a class template, a type alias template, or a template
4481/// template parameter.  A template which cannot be resolved to one of
4482/// these, e.g. because it is written with a dependent scope
4483/// specifier, is instead represented as a
4484/// @c DependentTemplateSpecializationType.
4485///
4486/// A non-dependent template specialization type is always "sugar",
4487/// typically for a \c RecordType.  For example, a class template
4488/// specialization type of \c vector<int> will refer to a tag type for
4489/// the instantiation \c std::vector<int, std::allocator<int>>
4490///
4491/// Template specializations are dependent if either the template or
4492/// any of the template arguments are dependent, in which case the
4493/// type may also be canonical.
4494///
4495/// Instances of this type are allocated with a trailing array of
4496/// TemplateArguments, followed by a QualType representing the
4497/// non-canonical aliased type when the template is a type alias
4498/// template.
4499class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8)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;

/// The number of template arguments named in this class template
/// specialization.
unsigned NumArgs : 31;

/// Whether this template specialization type is a substituted type alias.
unsigned TypeAlias : 1;

TemplateSpecializationType(TemplateName T,
                           ArrayRef<TemplateArgument> Args,
                           QualType Canon,
                           QualType Aliased);

4525public:
/// 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());
}

/// \brief 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 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")(static_cast <bool> (isTypeAlias() && "not a type alias template specialization"
) ? void (0) : __assert_fail ("isTypeAlias() && \"not a type alias template specialization\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4559, __extension__ __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 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(), NumArgs};
}

bool isSugared() const {
  return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
}

QualType desugar() const { return 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;
}
4606};

4608/// \brief Print a template argument list, including the '<' and '>'
4609/// enclosing the template arguments.
4610void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy);

4614void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy);

4618void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy);

4622/// The injected class name of a C++ class template or class
4623/// template partial specialization.  Used to record that a type was
4624/// spelled with a bare identifier rather than as a template-id; the
4625/// equivalent for non-templated classes is just RecordType.
4626///
4627/// Injected class name types are always dependent.  Template
4628/// instantiation turns these into RecordTypes.
4629///
4630/// Injected class name types are always canonical.  This works
4631/// because it is impossible to compare an injected class name type
4632/// with the corresponding non-injected template type, for the same
4633/// reason that it is impossible to directly compare template
4634/// parameters from different dependent contexts: injected class name
4635/// types can only occur within the scope of a particular templated
4636/// declaration, and within that scope every template specialization
4637/// will canonicalize to the injected class name (when appropriate
4638/// according to the rules of the language).
4639class 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))(static_cast <bool> (isa<TemplateSpecializationType>
(TST)) ? void (0) : __assert_fail ("isa<TemplateSpecializationType>(TST)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4665, __extension__ __PRETTY_FUNCTION__));
  assert(!TST.hasQualifiers())(static_cast <bool> (!TST.hasQualifiers()) ? void (0) :
 __assert_fail ("!TST.hasQualifiers()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4666, __extension__ __PRETTY_FUNCTION__));
  assert(TST->isDependentType())(static_cast <bool> (TST->isDependentType()) ? void (
0) : __assert_fail ("TST->isDependentType()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4667, __extension__ __PRETTY_FUNCTION__));
}

4670public:
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;
}
4689};

4691/// \brief The kind of a tag type.
4692enum TagTypeKind {
/// \brief The "struct" keyword.
TTK_Struct,

/// \brief The "__interface" keyword.
TTK_Interface,

/// \brief The "union" keyword.
TTK_Union,

/// \brief The "class" keyword.
TTK_Class,

/// \brief The "enum" keyword.
TTK_Enum
4707};

4709/// \brief The elaboration keyword that precedes a qualified type name or
4710/// introduces an elaborated-type-specifier.
4711enum ElaboratedTypeKeyword {
/// \brief The "struct" keyword introduces the elaborated-type-specifier.
ETK_Struct,

/// \brief The "__interface" keyword introduces the elaborated-type-specifier.
ETK_Interface,

/// \brief The "union" keyword introduces the elaborated-type-specifier.
ETK_Union,

/// \brief The "class" keyword introduces the elaborated-type-specifier.
ETK_Class,

/// \brief The "enum" keyword introduces the elaborated-type-specifier.
ETK_Enum,

/// \brief The "typename" keyword precedes the qualified type name, e.g.,
/// \c typename T::type.
ETK_Typename,

/// \brief No keyword precedes the qualified type name.
ETK_None
4733};

4735/// A helper class for Type nodes having an ElaboratedTypeKeyword.
4736/// The keyword in stored in the free bits of the base class.
4737/// Also provides a few static helpers for converting and printing
4738/// elaborated type keyword and tag type kind enumerations.
4739class TypeWithKeyword : public Type {
4740protected:
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;
}

4750public:
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 *);
4780};

4782/// \brief Represents a type that was referred to using an elaborated type
4783/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
4784/// or both.
4785///
4786/// This type is used to keep track of a type name as written in the
4787/// source code, including tag keywords and any nested-name-specifiers.
4788/// The type itself is always "sugar", used to express what was written
4789/// in the source code but containing no additional semantic information.
4790class ElaboratedType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this qualified name refers to.
QualType NamedType;

ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
               QualType NamedType, QualType CanonType)
  : TypeWithKeyword(Keyword, Elaborated, CanonType,
                    NamedType->isDependentType(),
                    NamedType->isInstantiationDependentType(),
                    NamedType->isVariablyModifiedType(),
                    NamedType->containsUnexpandedParameterPack()),
    NNS(NNS), NamedType(NamedType) {
  assert(!(Keyword == ETK_None && NNS == nullptr) &&(static_cast <bool> (!(Keyword == ETK_None && NNS
 == nullptr) && "ElaboratedType cannot have elaborated type keyword "
 "and name qualifier both null.") ? void (0) : __assert_fail (
"!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4809, __extension__ __PRETTY_FUNCTION__))
         "ElaboratedType cannot have elaborated type keyword "(static_cast <bool> (!(Keyword == ETK_None && NNS
 == nullptr) && "ElaboratedType cannot have elaborated type keyword "
 "and name qualifier both null.") ? void (0) : __assert_fail (
"!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4809, __extension__ __PRETTY_FUNCTION__))
         "and name qualifier both null.")(static_cast <bool> (!(Keyword == ETK_None && NNS
 == nullptr) && "ElaboratedType cannot have elaborated type keyword "
 "and name qualifier both null.") ? void (0) : __assert_fail (
"!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 4809, __extension__ __PRETTY_FUNCTION__));
}

4812public:
~ElaboratedType();

/// 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; }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, NamedType);
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, QualType NamedType) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  NamedType.Profile(ID);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Elaborated;
}
4841};

4843/// \brief Represents a qualified type name for which the type name is
4844/// dependent.
4845///
4846/// DependentNameType represents a class of dependent types that involve a
4847/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
4848/// name of a type. The DependentNameType may start with a "typename" (for a
4849/// typename-specifier), "class", "struct", "union", or "enum" (for a
4850/// dependent elaborated-type-specifier), or nothing (in contexts where we
4851/// know that we must be referring to a type, e.g., in a base class specifier).
4852/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
4853/// mode, this type is used with non-dependent names to delay name lookup until
4854/// instantiation.
4855class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// \brief The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// \brief 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) {}

4872public:
/// 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;
}
4902};

4904/// Represents a template specialization type whose template cannot be
4905/// resolved, e.g.
4906///   A<T>::template B<T>
4907class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8)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;

/// \brief The number of template arguments named in this class template
/// specialization.
unsigned NumArgs;

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);
}

4936public:
NestedNameSpecifier *getQualifier() const { return NNS; }
const IdentifierInfo *getIdentifier() const { return Name; }

/// \brief Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// \brief Retrieve the number of template arguments.
unsigned getNumArgs() const { return NumArgs; }

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), NumArgs};
}

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(), NumArgs});
}

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;
}
4976};

4978/// \brief Represents a pack expansion of types.
4979///
4980/// Pack expansions are part of C++11 variadic templates. A pack
4981/// expansion contains a pattern, which itself contains one or more
4982/// "unexpanded" parameter packs. When instantiated, a pack expansion
4983/// produces a series of types, each instantiated from the pattern of
4984/// the expansion, where the Ith instantiation of the pattern uses the
4985/// Ith arguments bound to each of the unexpanded parameter packs. The
4986/// pack expansion is considered to "expand" these unexpanded
4987/// parameter packs.
4988///
4989/// \code
4990/// template<typename ...Types> struct tuple;
4991///
4992/// template<typename ...Types>
4993/// struct tuple_of_references {
4994///   typedef tuple<Types&...> type;
4995/// };
4996/// \endcode
4997///
4998/// Here, the pack expansion \c Types&... is represented via a
4999/// PackExpansionType whose pattern is Types&.
5000class PackExpansionType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// \brief The pattern of the pack expansion.
QualType Pattern;

/// \brief The number of expansions that this pack expansion will
/// generate when substituted (+1), or indicates that
///
/// 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;

PackExpansionType(QualType Pattern, QualType Canon,
                  Optional<unsigned> NumExpansions)
    : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(),
           /*InstantiationDependent=*/true,
           /*VariablyModified=*/Pattern->isVariablyModifiedType(),
           /*ContainsUnexpandedParameterPack=*/false),
      Pattern(Pattern),
      NumExpansions(NumExpansions ? *NumExpansions + 1 : 0) {}

5023public:
/// \brief 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; }

/// \brief Retrieve the number of expansions that this pack expansion will
/// generate, if known.
Optional<unsigned> getNumExpansions() const {
  if (NumExpansions)
    return 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;
}
5056};

5058/// This class wraps the list of protocol qualifiers. For types that can
5059/// take ObjC protocol qualifers, they can subclass this class.
5060template <class T>
5061class ObjCProtocolQualifiers {
5062protected:
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() &&(static_cast <bool> (getNumProtocols() == protocols.size
() && "bitfield overflow in protocol count") ? void (
0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 5080, __extension__ __PRETTY_FUNCTION__))
         "bitfield overflow in protocol count")(static_cast <bool> (getNumProtocols() == protocols.size
() && "bitfield overflow in protocol count") ? void (
0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 5080, __extension__ __PRETTY_FUNCTION__));
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5086public:
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")(static_cast <bool> (I < getNumProtocols() &&
 "Out-of-range protocol access") ? void (0) : __assert_fail (
"I < getNumProtocols() && \"Out-of-range protocol access\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 5104, __extension__ __PRETTY_FUNCTION__));
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5112};

5114/// Represents a type parameter type in Objective C. It can take
5115/// a list of protocols.
5116class 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);

5146public:
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; }
5160};

5162/// Represents a class type in Objective C.
5163///
5164/// Every Objective C type is a combination of a base type, a set of
5165/// type arguments (optional, for parameterized classes) and a list of
5166/// protocols.
5167///
5168/// Given the following declarations:
5169/// \code
5170///   \@class C<T>;
5171///   \@protocol P;
5172/// \endcode
5173///
5174/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5175/// with base C and no protocols.
5176///
5177/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5178/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no 
5179/// protocol list.
5180/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5181/// and protocol list [P].
5182///
5183/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5184/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5185/// and no protocols.
5186///
5187/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5188/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5189/// this should get its own sugar class to better represent the source.
5190class 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;
}

5228protected:
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;

5246public:
/// 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?")(static_cast <bool> (CachedSuperClassType.getInt() &&
 "Superclass not set?") ? void (0) : __assert_fail ("CachedSuperClassType.getInt() && \"Superclass not set?\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 5322, __extension__ __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;
}
5337};

5339/// A class providing a concrete implementation
5340/// of ObjCObjectType, so as to not increase the footprint of
5341/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5342/// system should not reference this type.
5343class 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) {}

5355public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5362};

5364inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5366}

5368inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5371}

5373inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
5376}

5378/// Interfaces are the core concept in Objective-C for object oriented design.
5379/// They basically correspond to C++ classes.  There are two kinds of interface
5380/// types: normal interfaces like `NSString`, and qualified interfaces, which
5381/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
5382///
5383/// ObjCInterfaceType guarantees the following properties when considered
5384/// as a subtype of its superclass, ObjCObjectType:
5385///   - There are no protocol qualifiers.  To reinforce this, code which
5386///     tries to invoke the protocol methods via an ObjCInterfaceType will
5387///     fail to compile.
5388///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
5389///     T->getBaseType() == QualType(T, 0).
5390class 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)) {}

5401public:
/// 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
};
5423};

5425inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
QualType baseType = getBaseType();
while (const ObjCObjectType *ObjT = baseType->getAs<ObjCObjectType>()) {
  if (const ObjCInterfaceType *T = dyn_cast<ObjCInterfaceType>(ObjT))
    return T->getDecl();

  baseType = ObjT->getBaseType();
}

return nullptr;
5435}

5437/// Represents a pointer to an Objective C object.
5438///
5439/// These are constructed from pointer declarators when the pointee type is
5440/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
5441/// types are typedefs for these, and the protocol-qualified types 'id<P>'
5442/// and 'Class<P>' are translated into these.
5443///
5444/// Pointers to pointers to Objective C objects are still PointerTypes;
5445/// only the first level of pointer gets it own type implementation.
5446class 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) {}

5459public:
/// 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;
}
5618};

5620class 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) {}

5632public:
/// 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;
}
5651};

5653/// PipeType - OpenCL20.
5654class 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) {}

5667public:
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; }
5688};

5690/// A qualifier set is used to build a set of qualifiers.
5691class QualifierCollector : public Qualifiers {
5692public:
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;
5713};

5715// Inline function definitions.

5717inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
5722}

5724inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
211
←
Calling 'QualType::getCommonPtr'→
246
←
Returning from 'QualType::getCommonPtr'→
358
←
Calling 'QualType::getCommonPtr'→
393
←
Returning from 'QualType::getCommonPtr'→
476
←
Calling 'QualType::getCommonPtr'→
511
←
Returning from 'QualType::getCommonPtr'→
540
←
Calling 'QualType::getCommonPtr'→
575
←
Returning from 'QualType::getCommonPtr'→
686
←
Calling 'QualType::getCommonPtr'→
721
←
Returning from 'QualType::getCommonPtr'→
804
←
Calling 'QualType::getCommonPtr'→
839
←
Returning from 'QualType::getCommonPtr'→
5726}

5728inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
5730}

5732inline 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);
5741}

5743inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
5749}

5751inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
5755}

5757inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
5761}

5763inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
298
←
Calling 'QualType::getCommonPtr'→
333
←
Returning from 'QualType::getCommonPtr'→
416
←
Calling 'QualType::getCommonPtr'→
451
←
Returning from 'QualType::getCommonPtr'→
626
←
Calling 'QualType::getCommonPtr'→
661
←
Returning from 'QualType::getCommonPtr'→
744
←
Calling 'QualType::getCommonPtr'→
779
←
Returning from 'QualType::getCommonPtr'→
return canon.withFastQualifiers(getLocalFastQualifiers());
334
←
Calling 'QualType::getLocalFastQualifiers'→
339
←
Returning from 'QualType::getLocalFastQualifiers'→
340
←
Calling 'QualType::withFastQualifiers'→
353
←
Returning from 'QualType::withFastQualifiers'→
452
←
Calling 'QualType::getLocalFastQualifiers'→
457
←
Returning from 'QualType::getLocalFastQualifiers'→
458
←
Calling 'QualType::withFastQualifiers'→
471
←
Returning from 'QualType::withFastQualifiers'→
662
←
Calling 'QualType::getLocalFastQualifiers'→
667
←
Returning from 'QualType::getLocalFastQualifiers'→
668
←
Calling 'QualType::withFastQualifiers'→
681
←
Returning from 'QualType::withFastQualifiers'→
780
←
Calling 'QualType::getLocalFastQualifiers'→
785
←
Returning from 'QualType::getLocalFastQualifiers'→
786
←
Calling 'QualType::withFastQualifiers'→
799
←
Returning from 'QualType::withFastQualifiers'→
5766}

5768inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
5770}

5772inline 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);
5781}

5783inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
5786}

5788inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
5791}


5794inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
5797}

5799inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
5802}

5804inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
210
←
Calling 'QualType::getTypePtr'→
247
←
Returning from 'QualType::getTypePtr'→
248
←
Calling 'Type::getCanonicalTypeInternal'→
249
←
Returning from 'Type::getCanonicalTypeInternal'→
250
←
Calling 'QualType::hasLocalQualifiers'→
258
←
Returning from 'QualType::hasLocalQualifiers'→
259
←
Taking false branch→
539
←
Calling 'QualType::getTypePtr'→
576
←
Returning from 'QualType::getTypePtr'→
577
←
Calling 'Type::getCanonicalTypeInternal'→
578
←
Returning from 'Type::getCanonicalTypeInternal'→
579
←
Calling 'QualType::hasLocalQualifiers'→
586
←
Returning from 'QualType::hasLocalQualifiers'→
587
←
Taking false branch→
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
260
←
Calling constructor for 'QualType'→
292
←
Returning from constructor for 'QualType'→
588
←
Calling constructor for 'QualType'→
620
←
Returning from constructor for 'QualType'→
5809}

5811inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
5816}

5818inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
5820}

5822inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
5824}

5826inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
5828}

5830inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")(static_cast <bool> (!(Mask & ~Qualifiers::CVRMask)
 && "mask has non-CVR bits") ? void (0) : __assert_fail
 ("!(Mask & ~Qualifiers::CVRMask) && \"mask has non-CVR bits\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 5831, __extension__ __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);
5837}

5839/// Return the address space of this type.
5840inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
5842}

5844/// Return the gc attribute of this type.
5845inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
5847}

5849inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
if (const PointerType *PT = t.getAs<PointerType>()) {
  if (const FunctionType *FT = PT->getPointeeType()->getAs<FunctionType>())
    return FT->getExtInfo();
} else if (const FunctionType *FT = t.getAs<FunctionType>())
  return FT->getExtInfo();

return FunctionType::ExtInfo();
5857}

5859inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
5861}

5863/// Determine whether this type is more
5864/// qualified than the Other type. For example, "const volatile int"
5865/// is more qualified than "const int", "volatile int", and
5866/// "int". However, it is not more qualified than "const volatile
5867/// int".
5868inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
5872}

5874/// Determine whether this type is at last
5875/// as qualified as the Other type. For example, "const volatile
5876/// int" is at least as qualified as "const int", "volatile int",
5877/// "int", and "const volatile int".
5878inline 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);
5886}

5888/// If Type is a reference type (e.g., const
5889/// int&), returns the type that the reference refers to ("const
5890/// int"). Otherwise, returns the type itself. This routine is used
5891/// throughout Sema to implement C++ 5p6:
5892///
5893///   If an expression initially has the type "reference to T" (8.3.2,
5894///   8.5.3), the type is adjusted to "T" prior to any further
5895///   analysis, the expression designates the object or function
5896///   denoted by the reference, and the expression is an lvalue.
5897inline QualType QualType::getNonReferenceType() const {
if (const ReferenceType *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
5902}

5904inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
5907}

5909/// Tests whether the type is categorized as a fundamental type.
5910///
5911/// \returns True for types specified in C++0x [basic.fundamental].
5912inline bool Type::isFundamentalType() const {
return isVoidType() ||
       // FIXME: It's really annoying that we don't have an
       // 'isArithmeticType()' which agrees with the standard definition.
       (isArithmeticType() && !isEnumeralType());
5917}

5919/// Tests whether the type is categorized as a compound type.
5920///
5921/// \returns True for types specified in C++0x [basic.compound].
5922inline 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();
5942}

5944inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
5946}

5948inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
5950}

5952inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
5954}

5956inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
5958}

5960inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
5962}

5964inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
5966}

5968inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
5970}

5972inline bool Type::isFunctionPointerType() const {
if (const PointerType *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
5977}

5979inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
5981}

5983inline bool Type::isMemberFunctionPointerType() const {
if (const MemberPointerType* T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
5988}

5990inline bool Type::isMemberDataPointerType() const {
if (const MemberPointerType* T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
5995}

5997inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
5999}

6001inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6003}

6005inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6007}

6009inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6011}

6013inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6015}

6017inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6019}

6021inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6023}

6025inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6027}

6029inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6031}

6033inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6035}

6037inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6039}

6041inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6043}

6045inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6047}

6049inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6051}

6053inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6056}

6058inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6060}

6062inline bool Type::isObjCQualifiedIdType() const {
if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6066}

6068inline bool Type::isObjCQualifiedClassType() const {
if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6072}

6074inline bool Type::isObjCIdType() const {
if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6078}

6080inline bool Type::isObjCClassType() const {
if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6084}

6086inline bool Type::isObjCSelType() const {
if (const PointerType *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6090}

6092inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6094}

6096#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6100#include "clang/Basic/OpenCLImageTypes.def"

6102inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6104}

6106inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6108}

6110inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6112}

6114inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6116}

6118inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6120}

6122inline bool Type::isImageType() const {
6123#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6125#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6127}

6129inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6131}

6133inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType();
6136}

6138inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6140}

6142inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>())
  if (BT->getKind() == (BuiltinType::Kind) K)
    return true;
return false;
6147}

6149inline bool Type::isPlaceholderType() const {
if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6153}

6155inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6160}

6162inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))(static_cast <bool> (BuiltinType::isPlaceholderTypeKind
((BuiltinType::Kind) K)) ? void (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 6163, __extension__ __PRETTY_FUNCTION__));
if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
  return (BT->getKind() == (BuiltinType::Kind) K);
return false;
6167}

6169inline bool Type::isNonOverloadPlaceholderType() const {
if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6173}

6175inline bool Type::isVoidType() const {
if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Void;
return false;
6179}

6181inline bool Type::isHalfType() const {
if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Half;
// FIXME: Should we allow complex __fp16? Probably not.
return false;
6186}

6188inline bool Type::isFloat16Type() const {
if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Float16;
return false;
6192}

6194inline bool Type::isNullPtrType() const {
if (const BuiltinType *BT = getAs<BuiltinType>())
  return BT->getKind() == BuiltinType::NullPtr;
return false;
6198}

6200bool IsEnumDeclComplete(EnumDecl *);
6201bool IsEnumDeclScoped(EnumDecl *);

6203inline bool Type::isIntegerType() const {
if (const BuiltinType *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;
6214}

6216inline bool Type::isScalarType() const {
if (const BuiltinType *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);
6229}

6231inline bool Type::isIntegralOrEnumerationType() const {
if (const BuiltinType *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 EnumType *ET = dyn_cast<EnumType>(CanonicalType))
  return IsEnumDeclComplete(ET->getDecl());

return false;  
6242}

6244inline bool Type::isBooleanType() const {
if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
6248}

6250inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
6253}

6255/// \brief Determines whether this is a type for which one can define
6256/// an overloaded operator.
6257inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
6259}

6261/// \brief Determines whether this type can decay to a pointer type.
6262inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
6264}

6266inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
6269}

6271inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
6273}

6275inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
6280}

6282inline 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;
6289}

6291/// Insertion operator for diagnostics.  This allows sending QualType's into a
6292/// diagnostic with <<.
6293inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         QualType T) {
DB.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return DB;
6298}

6300/// Insertion operator for partial diagnostics.  This allows sending QualType's
6301/// into a diagnostic with <<.
6302inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                         QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
6307}

6309// Helper class template that is used by Type::getAs to ensure that one does
6310// not try to look through a qualified type to get to an array type.
6311template <typename T>
6312using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

6316// Member-template getAs<specific type>'.
6317template <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 T *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());
6332}

6334template <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 T *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
    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);
6364}

6366inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
// If this is directly an array type, return it.
if (const ArrayType *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());
6378}

6380template <typename T> const T *Type::castAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with castAs!");

if (const T *ty = dyn_cast<T>(this)) return ty;
assert(isa<T>(CanonicalType))(static_cast <bool> (isa<T>(CanonicalType)) ? void
 (0) : __assert_fail ("isa<T>(CanonicalType)", "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 6385, __extension__ __PRETTY_FUNCTION__));
return cast<T>(getUnqualifiedDesugaredType());
6387}

6389inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))(static_cast <bool> (isa<ArrayType>(CanonicalType
)) ? void (0) : __assert_fail ("isa<ArrayType>(CanonicalType)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 6390, __extension__ __PRETTY_FUNCTION__));
if (const ArrayType *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
6393}

6395DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
6398#ifndef NDEBUG
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))(static_cast <bool> (isa<PointerType>(Adjusted)) ?
 void (0) : __assert_fail ("isa<PointerType>(Adjusted)"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/Type.h"
, 6401, __extension__ __PRETTY_FUNCTION__));
6402#endif
6403}

6405QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
6409}

6411} // namespace clang

6413#endif // LLVM_CLANG_AST_TYPE_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/PointerLikeTypeTraits.h

→

1//===- llvm/Support/PointerLikeTypeTraits.h - Pointer Traits ----*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the PointerLikeTypeTraits class.  This allows data
11// structures to reason about pointers and other things that are pointer sized.
12//
13//===----------------------------------------------------------------------===//
14 
15#ifndef LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
16#define LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
17 
18#include "llvm/Support/DataTypes.h"
19#include <type_traits>
20 
21namespace llvm {
22 
23/// A traits type that is used to handle pointer types and things that are just
24/// wrappers for pointers as a uniform entity.
25template <typename T> struct PointerLikeTypeTraits;
26 
27namespace detail {
28/// A tiny meta function to compute the log2 of a compile time constant.
29template <size_t N>
30struct ConstantLog2
31    : std::integral_constant<size_t, ConstantLog2<N / 2>::value + 1> {};
32template <> struct ConstantLog2<1> : std::integral_constant<size_t, 0> {};
33 
34// Provide a trait to check if T is pointer-like.
35template <typename T, typename U = void> struct HasPointerLikeTypeTraits {
36  static const bool value = false;
37};
38 
39// sizeof(T) is valid only for a complete T.
40template <typename T> struct HasPointerLikeTypeTraits<
41  T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
42  static const bool value = true;
43};
44 
45template <typename T> struct IsPointerLike {
46  static const bool value = HasPointerLikeTypeTraits<T>::value;
47};
48 
49template <typename T> struct IsPointerLike<T *> {
50  static const bool value = true;
51};
52} // namespace detail
53 
54// Provide PointerLikeTypeTraits for non-cvr pointers.
55template <typename T> struct PointerLikeTypeTraits<T *> {
56  static inline void *getAsVoidPointer(T *P) { return P; }
57  static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
58 
59  enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
60};
61 
62template <> struct PointerLikeTypeTraits<void *> {
63  static inline void *getAsVoidPointer(void *P) { return P; }
64  static inline void *getFromVoidPointer(void *P) { return P; }
65 
66  /// Note, we assume here that void* is related to raw malloc'ed memory and
67  /// that malloc returns objects at least 4-byte aligned. However, this may be
68  /// wrong, or pointers may be from something other than malloc. In this case,
69  /// you should specify a real typed pointer or avoid this template.
70  ///
71  /// All clients should use assertions to do a run-time check to ensure that
72  /// this is actually true.
73  enum { NumLowBitsAvailable = 2 };
74};
75 
76// Provide PointerLikeTypeTraits for const things.
77template <typename T> struct PointerLikeTypeTraits<const T> {
78  typedef PointerLikeTypeTraits<T> NonConst;
79 
80  static inline const void *getAsVoidPointer(const T P) {
81    return NonConst::getAsVoidPointer(P);
82  }
83  static inline const T getFromVoidPointer(const void *P) {
84    return NonConst::getFromVoidPointer(const_cast<void *>(P));
85  }
86  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
87};
88 
89// Provide PointerLikeTypeTraits for const pointers.
90template <typename T> struct PointerLikeTypeTraits<const T *> {
91  typedef PointerLikeTypeTraits<T *> NonConst;
92 
93  static inline const void *getAsVoidPointer(const T *P) {
94    return NonConst::getAsVoidPointer(const_cast<T *>(P));
263
←
Calling 'PointerLikeTypeTraits::getAsVoidPointer'→
264
←
Returning from 'PointerLikeTypeTraits::getAsVoidPointer'→
591
←
Calling 'PointerLikeTypeTraits::getAsVoidPointer'→
592
←
Returning from 'PointerLikeTypeTraits::getAsVoidPointer'→
95  }
96  static inline const T *getFromVoidPointer(const void *P) {
97    return NonConst::getFromVoidPointer(const_cast<void *>(P));
239
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
240
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
326
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
327
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
386
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
387
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
444
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
445
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
504
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
505
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
568
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
569
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
654
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
655
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
714
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
715
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
772
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
773
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
832
←
Calling 'PointerLikeTypeTraits::getFromVoidPointer'→
833
←
Returning from 'PointerLikeTypeTraits::getFromVoidPointer'→
98  }
99  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
100};
101 
102// Provide PointerLikeTypeTraits for uintptr_t.
103template <> struct PointerLikeTypeTraits<uintptr_t> {
104  static inline void *getAsVoidPointer(uintptr_t P) {
105    return reinterpret_cast<void *>(P);
106  }
107  static inline uintptr_t getFromVoidPointer(void *P) {
108    return reinterpret_cast<uintptr_t>(P);
109  }
110  // No bits are available!
111  enum { NumLowBitsAvailable = 0 };
112};
113 
114} // end namespace llvm
115 
116#endif

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h

→

1//===- ASTContext.h - Context to hold long-lived AST nodes ------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10/// \file
11/// \brief Defines the clang::ASTContext interface.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_CLANG_AST_ASTCONTEXT_H
16#define LLVM_CLANG_AST_ASTCONTEXT_H

18#include "clang/AST/ASTTypeTraits.h"
19#include "clang/AST/CanonicalType.h"
20#include "clang/AST/CommentCommandTraits.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclBase.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/ExternalASTSource.h"
25#include "clang/AST/NestedNameSpecifier.h"
26#include "clang/AST/PrettyPrinter.h"
27#include "clang/AST/RawCommentList.h"
28#include "clang/AST/TemplateBase.h"
29#include "clang/AST/TemplateName.h"
30#include "clang/AST/Type.h"
31#include "clang/Basic/AddressSpaces.h"
32#include "clang/Basic/IdentifierTable.h"
33#include "clang/Basic/LLVM.h"
34#include "clang/Basic/LangOptions.h"
35#include "clang/Basic/Linkage.h"
36#include "clang/Basic/OperatorKinds.h"
37#include "clang/Basic/PartialDiagnostic.h"
38#include "clang/Basic/SanitizerBlacklist.h"
39#include "clang/Basic/SourceLocation.h"
40#include "clang/Basic/Specifiers.h"
41#include "clang/Basic/TargetInfo.h"
42#include "clang/Basic/XRayLists.h"
43#include "llvm/ADT/APSInt.h"
44#include "llvm/ADT/ArrayRef.h"
45#include "llvm/ADT/DenseMap.h"
46#include "llvm/ADT/FoldingSet.h"
47#include "llvm/ADT/IntrusiveRefCntPtr.h"
48#include "llvm/ADT/MapVector.h"
49#include "llvm/ADT/None.h"
50#include "llvm/ADT/Optional.h"
51#include "llvm/ADT/PointerIntPair.h"
52#include "llvm/ADT/PointerUnion.h"
53#include "llvm/ADT/SmallVector.h"
54#include "llvm/ADT/StringMap.h"
55#include "llvm/ADT/StringRef.h"
56#include "llvm/ADT/TinyPtrVector.h"
57#include "llvm/ADT/Triple.h"
58#include "llvm/ADT/iterator_range.h"
59#include "llvm/Support/AlignOf.h"
60#include "llvm/Support/Allocator.h"
61#include "llvm/Support/Casting.h"
62#include "llvm/Support/Compiler.h"
63#include <cassert>
64#include <cstddef>
65#include <cstdint>
66#include <iterator>
67#include <memory>
68#include <string>
69#include <type_traits>
70#include <utility>
71#include <vector>

73namespace llvm {

75struct fltSemantics;

77} // namespace llvm

79namespace clang {

81class APValue;
82class ASTMutationListener;
83class ASTRecordLayout;
84class AtomicExpr;
85class BlockExpr;
86class BuiltinTemplateDecl;
87class CharUnits;
88class CXXABI;
89class CXXConstructorDecl;
90class CXXMethodDecl;
91class CXXRecordDecl;
92class DiagnosticsEngine;
93class Expr;
94class MangleContext;
95class MangleNumberingContext;
96class MaterializeTemporaryExpr;
97class MemberSpecializationInfo;
98class Module;
99class ObjCCategoryDecl;
100class ObjCCategoryImplDecl;
101class ObjCContainerDecl;
102class ObjCImplDecl;
103class ObjCImplementationDecl;
104class ObjCInterfaceDecl;
105class ObjCIvarDecl;
106class ObjCMethodDecl;
107class ObjCPropertyDecl;
108class ObjCPropertyImplDecl;
109class ObjCProtocolDecl;
110class ObjCTypeParamDecl;
111class Preprocessor;
112class Stmt;
113class StoredDeclsMap;
114class TemplateDecl;
115class TemplateParameterList;
116class TemplateTemplateParmDecl;
117class TemplateTypeParmDecl;
118class UnresolvedSetIterator;
119class UsingShadowDecl;
120class VarTemplateDecl;
121class VTableContextBase;

123namespace Builtin {

125class Context;

127} // namespace Builtin

129enum BuiltinTemplateKind : int;

131namespace comments {

133class FullComment;

135} // namespace comments

137struct TypeInfo {
uint64_t Width = 0;
unsigned Align = 0;
bool AlignIsRequired : 1;

TypeInfo() : AlignIsRequired(false) {}
TypeInfo(uint64_t Width, unsigned Align, bool AlignIsRequired)
    : Width(Width), Align(Align), AlignIsRequired(AlignIsRequired) {}
145};

147/// \brief Holds long-lived AST nodes (such as types and decls) that can be
148/// referred to throughout the semantic analysis of a file.
149class ASTContext : public RefCountedBase<ASTContext> {
friend class NestedNameSpecifier;

mutable SmallVector<Type *, 0> Types;
mutable llvm::FoldingSet<ExtQuals> ExtQualNodes;
mutable llvm::FoldingSet<ComplexType> ComplexTypes;
mutable llvm::FoldingSet<PointerType> PointerTypes;
mutable llvm::FoldingSet<AdjustedType> AdjustedTypes;
mutable llvm::FoldingSet<BlockPointerType> BlockPointerTypes;
mutable llvm::FoldingSet<LValueReferenceType> LValueReferenceTypes;
mutable llvm::FoldingSet<RValueReferenceType> RValueReferenceTypes;
mutable llvm::FoldingSet<MemberPointerType> MemberPointerTypes;
mutable llvm::FoldingSet<ConstantArrayType> ConstantArrayTypes;
mutable llvm::FoldingSet<IncompleteArrayType> IncompleteArrayTypes;
mutable std::vector<VariableArrayType*> VariableArrayTypes;
mutable llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes;
mutable llvm::FoldingSet<DependentSizedExtVectorType>
  DependentSizedExtVectorTypes;
mutable llvm::FoldingSet<DependentAddressSpaceType>
    DependentAddressSpaceTypes;
mutable llvm::FoldingSet<VectorType> VectorTypes;
mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>
  FunctionProtoTypes;
mutable llvm::FoldingSet<DependentTypeOfExprType> DependentTypeOfExprTypes;
mutable llvm::FoldingSet<DependentDecltypeType> DependentDecltypeTypes;
mutable llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
mutable llvm::FoldingSet<ObjCTypeParamType> ObjCTypeParamTypes;
mutable llvm::FoldingSet<SubstTemplateTypeParmType>
  SubstTemplateTypeParmTypes;
mutable llvm::FoldingSet<SubstTemplateTypeParmPackType>
  SubstTemplateTypeParmPackTypes;
mutable llvm::ContextualFoldingSet<TemplateSpecializationType, ASTContext&>
  TemplateSpecializationTypes;
mutable llvm::FoldingSet<ParenType> ParenTypes;
mutable llvm::FoldingSet<ElaboratedType> ElaboratedTypes;
mutable llvm::FoldingSet<DependentNameType> DependentNameTypes;
mutable llvm::ContextualFoldingSet<DependentTemplateSpecializationType,
                                   ASTContext&>
  DependentTemplateSpecializationTypes;
llvm::FoldingSet<PackExpansionType> PackExpansionTypes;
mutable llvm::FoldingSet<ObjCObjectTypeImpl> ObjCObjectTypes;
mutable llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;
mutable llvm::FoldingSet<DependentUnaryTransformType>
  DependentUnaryTransformTypes;
mutable llvm::FoldingSet<AutoType> AutoTypes;
mutable llvm::FoldingSet<DeducedTemplateSpecializationType>
  DeducedTemplateSpecializationTypes;
mutable llvm::FoldingSet<AtomicType> AtomicTypes;
llvm::FoldingSet<AttributedType> AttributedTypes;
mutable llvm::FoldingSet<PipeType> PipeTypes;

mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>
  SubstTemplateTemplateParms;
mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
                                   ASTContext&>
  SubstTemplateTemplateParmPacks;

/// \brief The set of nested name specifiers.
///
/// This set is managed by the NestedNameSpecifier class.
mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr;

/// \brief A cache mapping from RecordDecls to ASTRecordLayouts.
///
/// This is lazily created.  This is intentionally not serialized.
mutable llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>
  ASTRecordLayouts;
mutable llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>
  ObjCLayouts;

/// \brief A cache from types to size and alignment information.
using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;
mutable TypeInfoMap MemoizedTypeInfo;

/// \brief A cache mapping from CXXRecordDecls to key functions.
llvm::DenseMap<const CXXRecordDecl*, LazyDeclPtr> KeyFunctions;

/// \brief Mapping from ObjCContainers to their ObjCImplementations.
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;

/// \brief Mapping from ObjCMethod to its duplicate declaration in the same
/// interface.
llvm::DenseMap<const ObjCMethodDecl*,const ObjCMethodDecl*> ObjCMethodRedecls;

/// \brief Mapping from __block VarDecls to their copy initialization expr.
llvm::DenseMap<const VarDecl*, Expr*> BlockVarCopyInits;

/// \brief Mapping from class scope functions specialization to their
/// template patterns.
llvm::DenseMap<const FunctionDecl*, FunctionDecl*>
  ClassScopeSpecializationPattern;

/// \brief Mapping from materialized temporaries with static storage duration
/// that appear in constant initializers to their evaluated values.  These are
/// allocated in a std::map because their address must be stable.
llvm::DenseMap<const MaterializeTemporaryExpr *, APValue *>
  MaterializedTemporaryValues;

/// \brief Representation of a "canonical" template template parameter that
/// is used in canonical template names.
class CanonicalTemplateTemplateParm : public llvm::FoldingSetNode {
  TemplateTemplateParmDecl *Parm;

public:
  CanonicalTemplateTemplateParm(TemplateTemplateParmDecl *Parm)
      : Parm(Parm) {}

  TemplateTemplateParmDecl *getParam() const { return Parm; }

  void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, Parm); }

  static void Profile(llvm::FoldingSetNodeID &ID,
                      TemplateTemplateParmDecl *Parm);
};
mutable llvm::FoldingSet<CanonicalTemplateTemplateParm>
  CanonTemplateTemplateParms;

TemplateTemplateParmDecl *
  getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const;

/// \brief The typedef for the __int128_t type.
mutable TypedefDecl *Int128Decl = nullptr;

/// \brief The typedef for the __uint128_t type.
mutable TypedefDecl *UInt128Decl = nullptr;

/// \brief The typedef for the target specific predefined
/// __builtin_va_list type.
mutable TypedefDecl *BuiltinVaListDecl = nullptr;

/// The typedef for the predefined \c __builtin_ms_va_list type.
mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;

/// \brief The typedef for the predefined \c id type.
mutable TypedefDecl *ObjCIdDecl = nullptr;

/// \brief The typedef for the predefined \c SEL type.
mutable TypedefDecl *ObjCSelDecl = nullptr;

/// \brief The typedef for the predefined \c Class type.
mutable TypedefDecl *ObjCClassDecl = nullptr;

/// \brief The typedef for the predefined \c Protocol class in Objective-C.
mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr;

/// \brief The typedef for the predefined 'BOOL' type.
mutable TypedefDecl *BOOLDecl = nullptr;

// Typedefs which may be provided defining the structure of Objective-C
// pseudo-builtins
QualType ObjCIdRedefinitionType;
QualType ObjCClassRedefinitionType;
QualType ObjCSelRedefinitionType;

/// The identifier 'bool'.
mutable IdentifierInfo *BoolName = nullptr;

/// The identifier 'NSObject'.
IdentifierInfo *NSObjectName = nullptr;

/// The identifier 'NSCopying'.
IdentifierInfo *NSCopyingName = nullptr;

/// The identifier '__make_integer_seq'.
mutable IdentifierInfo *MakeIntegerSeqName = nullptr;

/// The identifier '__type_pack_element'.
mutable IdentifierInfo *TypePackElementName = nullptr;

QualType ObjCConstantStringType;
mutable RecordDecl *CFConstantStringTagDecl = nullptr;
mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;

mutable QualType ObjCSuperType;

QualType ObjCNSStringType;

/// \brief The typedef declaration for the Objective-C "instancetype" type.
TypedefDecl *ObjCInstanceTypeDecl = nullptr;

/// \brief The type for the C FILE type.
TypeDecl *FILEDecl = nullptr;

/// \brief The type for the C jmp_buf type.
TypeDecl *jmp_bufDecl = nullptr;

/// \brief The type for the C sigjmp_buf type.
TypeDecl *sigjmp_bufDecl = nullptr;

/// \brief The type for the C ucontext_t type.
TypeDecl *ucontext_tDecl = nullptr;

/// \brief Type for the Block descriptor for Blocks CodeGen.
///
/// Since this is only used for generation of debug info, it is not
/// serialized.
mutable RecordDecl *BlockDescriptorType = nullptr;

/// \brief Type for the Block descriptor for Blocks CodeGen.
///
/// Since this is only used for generation of debug info, it is not
/// serialized.
mutable RecordDecl *BlockDescriptorExtendedType = nullptr;

/// \brief Declaration for the CUDA cudaConfigureCall function.
FunctionDecl *cudaConfigureCallDecl = nullptr;

/// \brief Keeps track of all declaration attributes.
///
/// Since so few decls have attrs, we keep them in a hash map instead of
/// wasting space in the Decl class.
llvm::DenseMap<const Decl*, AttrVec*> DeclAttrs;

/// \brief A mapping from non-redeclarable declarations in modules that were
/// merged with other declarations to the canonical declaration that they were
/// merged into.
llvm::DenseMap<Decl*, Decl*> MergedDecls;

/// \brief A mapping from a defining declaration to a list of modules (other
/// than the owning module of the declaration) that contain merged
/// definitions of that entity.
llvm::DenseMap<NamedDecl*, llvm::TinyPtrVector<Module*>> MergedDefModules;

/// \brief Initializers for a module, in order. Each Decl will be either
/// something that has a semantic effect on startup (such as a variable with
/// a non-constant initializer), or an ImportDecl (which recursively triggers
/// initialization of another module).
struct PerModuleInitializers {
  llvm::SmallVector<Decl*, 4> Initializers;
  llvm::SmallVector<uint32_t, 4> LazyInitializers;

  void resolve(ASTContext &Ctx);
};
llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers;

ASTContext &this_() { return *this; }

390public:
/// \brief A type synonym for the TemplateOrInstantiation mapping.
using TemplateOrSpecializationInfo =
    llvm::PointerUnion<VarTemplateDecl *, MemberSpecializationInfo *>;

395private:
friend class ASTDeclReader;
friend class ASTReader;
friend class ASTWriter;
friend class CXXRecordDecl;

/// \brief A mapping to contain the template or declaration that
/// a variable declaration describes or was instantiated from,
/// respectively.
///
/// For non-templates, this value will be NULL. For variable
/// declarations that describe a variable template, this will be a
/// pointer to a VarTemplateDecl. For static data members
/// of class template specializations, this will be the
/// MemberSpecializationInfo referring to the member variable that was
/// instantiated or specialized. Thus, the mapping will keep track of
/// the static data member templates from which static data members of
/// class template specializations were instantiated.
///
/// Given the following example:
///
/// \code
/// template<typename T>
/// struct X {
///   static T value;
/// };
///
/// template<typename T>
///   T X<T>::value = T(17);
///
/// int *x = &X<int>::value;
/// \endcode
///
/// This mapping will contain an entry that maps from the VarDecl for
/// X<int>::value to the corresponding VarDecl for X<T>::value (within the
/// class template X) and will be marked TSK_ImplicitInstantiation.
llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>
TemplateOrInstantiation;

/// \brief Keeps track of the declaration from which a using declaration was
/// created during instantiation.
///
/// The source and target declarations are always a UsingDecl, an
/// UnresolvedUsingValueDecl, or an UnresolvedUsingTypenameDecl.
///
/// For example:
/// \code
/// template<typename T>
/// struct A {
///   void f();
/// };
///
/// template<typename T>
/// struct B : A<T> {
///   using A<T>::f;
/// };
///
/// template struct B<int>;
/// \endcode
///
/// This mapping will contain an entry that maps from the UsingDecl in
/// B<int> to the UnresolvedUsingDecl in B<T>.
llvm::DenseMap<NamedDecl *, NamedDecl *> InstantiatedFromUsingDecl;

llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
  InstantiatedFromUsingShadowDecl;

llvm::DenseMap<FieldDecl *, FieldDecl *> InstantiatedFromUnnamedFieldDecl;

/// \brief Mapping that stores the methods overridden by a given C++
/// member function.
///
/// Since most C++ member functions aren't virtual and therefore
/// don't override anything, we store the overridden functions in
/// this map on the side rather than within the CXXMethodDecl structure.
using CXXMethodVector = llvm::TinyPtrVector<const CXXMethodDecl *>;
llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods;

/// \brief Mapping from each declaration context to its corresponding
/// mangling numbering context (used for constructs like lambdas which
/// need to be consistently numbered for the mangler).
llvm::DenseMap<const DeclContext *, std::unique_ptr<MangleNumberingContext>>
    MangleNumberingContexts;

/// \brief Side-table of mangling numbers for declarations which rarely
/// need them (like static local vars).
llvm::MapVector<const NamedDecl *, unsigned> MangleNumbers;
llvm::MapVector<const VarDecl *, unsigned> StaticLocalNumbers;

/// \brief Mapping that stores parameterIndex values for ParmVarDecls when
/// that value exceeds the bitfield size of ParmVarDeclBits.ParameterIndex.
using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>;
ParameterIndexTable ParamIndices;

ImportDecl *FirstLocalImport = nullptr;
ImportDecl *LastLocalImport = nullptr;

TranslationUnitDecl *TUDecl;
mutable ExternCContextDecl *ExternCContext = nullptr;
mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;

/// \brief The associated SourceManager object.
SourceManager &SourceMgr;

/// \brief The language options used to create the AST associated with
///  this ASTContext object.
LangOptions &LangOpts;

/// \brief Blacklist object that is used by sanitizers to decide which
/// entities should not be instrumented.
std::unique_ptr<SanitizerBlacklist> SanitizerBL;

/// \brief Function filtering mechanism to determine whether a given function
/// should be imbued with the XRay "always" or "never" attributes.
std::unique_ptr<XRayFunctionFilter> XRayFilter;

/// \brief The allocator used to create AST objects.
///
/// AST objects are never destructed; rather, all memory associated with the
/// AST objects will be released when the ASTContext itself is destroyed.
mutable llvm::BumpPtrAllocator BumpAlloc;

/// \brief Allocator for partial diagnostics.
PartialDiagnostic::StorageAllocator DiagAllocator;

/// \brief The current C++ ABI.
std::unique_ptr<CXXABI> ABI;
CXXABI *createCXXABI(const TargetInfo &T);

/// \brief The logical -> physical address space map.
const LangASMap *AddrSpaceMap = nullptr;

/// \brief Address space map mangling must be used with language specific
/// address spaces (e.g. OpenCL/CUDA)
bool AddrSpaceMapMangling;

const TargetInfo *Target = nullptr;
const TargetInfo *AuxTarget = nullptr;
clang::PrintingPolicy PrintingPolicy;

536public:
IdentifierTable &Idents;
SelectorTable &Selectors;
Builtin::Context &BuiltinInfo;
mutable DeclarationNameTable DeclarationNames;
IntrusiveRefCntPtr<ExternalASTSource> ExternalSource;
ASTMutationListener *Listener = nullptr;

/// \brief Contains parents of a node.
using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;

/// \brief 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 *>>;

/// Container for either a single DynTypedNode or for an ArrayRef to
/// DynTypedNode. For use with ParentMap.
class DynTypedNodeList {
  using DynTypedNode = ast_type_traits::DynTypedNode;

  llvm::AlignedCharArrayUnion<ast_type_traits::DynTypedNode,
                              ArrayRef<DynTypedNode>> Storage;
  bool IsSingleNode;

public:
  DynTypedNodeList(const DynTypedNode &N) : IsSingleNode(true) {
    new (Storage.buffer) DynTypedNode(N);
  }

  DynTypedNodeList(ArrayRef<DynTypedNode> A) : IsSingleNode(false) {
    new (Storage.buffer) ArrayRef<DynTypedNode>(A);
  }

  const ast_type_traits::DynTypedNode *begin() const {
    if (!IsSingleNode)
      return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
          ->begin();
    return reinterpret_cast<const DynTypedNode *>(Storage.buffer);
  }

  const ast_type_traits::DynTypedNode *end() const {
    if (!IsSingleNode)
      return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
          ->end();
    return reinterpret_cast<const DynTypedNode *>(Storage.buffer) + 1;
  }

  size_t size() const { return end() - begin(); }
  bool empty() const { return begin() == end(); }

  const DynTypedNode &operator[](size_t N) const {
    assert(N < size() && "Out of bounds!")(static_cast <bool> (N < size() && "Out of bounds!"
) ? void (0) : __assert_fail ("N < size() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 600, __extension__ __PRETTY_FUNCTION__));
    return *(begin() + N);
  }
};

/// \brief Returns the parents of the given node.
///
/// Note that this will lazily compute the parents of all nodes
/// and store them for later retrieval. Thus, the first call is O(n)
/// in the number of AST nodes.
///
/// Caveats and FIXMEs:
/// Calculating the parent map over all AST nodes will need to load the
/// full AST. This can be undesirable in the case where the full AST is
/// expensive to create (for example, when using precompiled header
/// preambles). Thus, there are good opportunities for optimization here.
/// One idea is to walk the given node downwards, looking for references
/// to declaration contexts - once a declaration context is found, compute
/// the parent map for the declaration context; if that can satisfy the
/// request, loading the whole AST can be avoided. Note that this is made
/// more complex by statements in templates having multiple parents - those
/// problems can be solved by building closure over the templated parts of
/// the AST, which also avoids touching large parts of the AST.
/// Additionally, we will want to add an interface to already give a hint
/// where to search for the parents, for example when looking at a statement
/// inside a certain function.
///
/// 'NodeT' can be one of Decl, Stmt, Type, TypeLoc,
/// NestedNameSpecifier or NestedNameSpecifierLoc.
template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
  return getParents(ast_type_traits::DynTypedNode::create(Node));
}

DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node);

const clang::PrintingPolicy &getPrintingPolicy() const {
  return PrintingPolicy;
}

void setPrintingPolicy(const clang::PrintingPolicy &Policy) {
  PrintingPolicy = Policy;
}

SourceManager& getSourceManager() { return SourceMgr; }
const SourceManager& getSourceManager() const { return SourceMgr; }

llvm::BumpPtrAllocator &getAllocator() const {
  return BumpAlloc;
}

void *Allocate(size_t Size, unsigned Align = 8) const {
  return BumpAlloc.Allocate(Size, Align);
}
template <typename T> T *Allocate(size_t Num = 1) const {
  return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
}
void Deallocate(void *Ptr) const {}

/// Return the total amount of physical memory allocated for representing
/// AST nodes and type information.
size_t getASTAllocatedMemory() const {
  return BumpAlloc.getTotalMemory();
}

/// Return the total memory used for various side tables.
size_t getSideTableAllocatedMemory() const;

PartialDiagnostic::StorageAllocator &getDiagAllocator() {
  return DiagAllocator;
}

const TargetInfo &getTargetInfo() const { return *Target; }
const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }

/// getIntTypeForBitwidth -
/// sets integer QualTy according to specified details:
/// bitwidth, signed/unsigned.
/// Returns empty type if there is no appropriate target types.
QualType getIntTypeForBitwidth(unsigned DestWidth,
                               unsigned Signed) const;

/// getRealTypeForBitwidth -
/// sets floating point QualTy according to specified bitwidth.
/// Returns empty type if there is no appropriate target types.
QualType getRealTypeForBitwidth(unsigned DestWidth) const;

bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const;

const LangOptions& getLangOpts() const { return LangOpts; }

const SanitizerBlacklist &getSanitizerBlacklist() const {
  return *SanitizerBL;
}

const XRayFunctionFilter &getXRayFilter() const {
  return *XRayFilter;
}

DiagnosticsEngine &getDiagnostics() const;

FullSourceLoc getFullLoc(SourceLocation Loc) const {
  return FullSourceLoc(Loc,SourceMgr);
}

/// \brief All comments in this translation unit.
RawCommentList Comments;

/// \brief True if comments are already loaded from ExternalASTSource.
mutable bool CommentsLoaded = false;

class RawCommentAndCacheFlags {
public:
  enum Kind {
    /// We searched for a comment attached to the particular declaration, but
    /// didn't find any.
    ///
    /// getRaw() == 0.
    NoCommentInDecl = 0,

    /// We have found a comment attached to this particular declaration.
    ///
    /// getRaw() != 0.
    FromDecl,

    /// This declaration does not have an attached comment, and we have
    /// searched the redeclaration chain.
    ///
    /// If getRaw() == 0, the whole redeclaration chain does not have any
    /// comments.
    ///
    /// If getRaw() != 0, it is a comment propagated from other
    /// redeclaration.
    FromRedecl
  };

  Kind getKind() const LLVM_READONLY__attribute__((__pure__)) {
    return Data.getInt();
  }

  void setKind(Kind K) {
    Data.setInt(K);
  }

  const RawComment *getRaw() const LLVM_READONLY__attribute__((__pure__)) {
    return Data.getPointer();
  }

  void setRaw(const RawComment *RC) {
    Data.setPointer(RC);
  }

  const Decl *getOriginalDecl() const LLVM_READONLY__attribute__((__pure__)) {
    return OriginalDecl;
  }

  void setOriginalDecl(const Decl *Orig) {
    OriginalDecl = Orig;
  }

private:
  llvm::PointerIntPair<const RawComment *, 2, Kind> Data;
  const Decl *OriginalDecl;
};

/// \brief Mapping from declarations to comments attached to any
/// redeclaration.
///
/// Raw comments are owned by Comments list.  This mapping is populated
/// lazily.
mutable llvm::DenseMap<const Decl *, RawCommentAndCacheFlags> RedeclComments;

/// \brief Mapping from declarations to parsed comments attached to any
/// redeclaration.
mutable llvm::DenseMap<const Decl *, comments::FullComment *> ParsedComments;

/// \brief Return the documentation comment attached to a given declaration,
/// without looking into cache.
RawComment *getRawCommentForDeclNoCache(const Decl *D) const;

779public:
RawCommentList &getRawCommentList() {
  return Comments;
}

void addComment(const RawComment &RC) {
  assert(LangOpts.RetainCommentsFromSystemHeaders ||(static_cast <bool> (LangOpts.RetainCommentsFromSystemHeaders
 || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin(
))) ? void (0) : __assert_fail ("LangOpts.RetainCommentsFromSystemHeaders || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 786, __extension__ __PRETTY_FUNCTION__))
         !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin()))(static_cast <bool> (LangOpts.RetainCommentsFromSystemHeaders
 || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin(
))) ? void (0) : __assert_fail ("LangOpts.RetainCommentsFromSystemHeaders || !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 786, __extension__ __PRETTY_FUNCTION__));
  Comments.addComment(RC, BumpAlloc);
}

/// \brief Return the documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached.
///
/// \param OriginalDecl if not nullptr, is set to declaration AST node that
/// had the comment, if the comment we found comes from a redeclaration.
const RawComment *
getRawCommentForAnyRedecl(const Decl *D,
                          const Decl **OriginalDecl = nullptr) const;

/// Return parsed documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached.
///
/// \param PP the Preprocessor used with this TU.  Could be nullptr if
/// preprocessor is not available.
comments::FullComment *getCommentForDecl(const Decl *D,
                                         const Preprocessor *PP) const;

/// Return parsed documentation comment attached to a given declaration.
/// Returns nullptr if no comment is attached. Does not look at any
/// redeclarations of the declaration.
comments::FullComment *getLocalCommentForDeclUncached(const Decl *D) const;

comments::FullComment *cloneFullComment(comments::FullComment *FC,
                                       const Decl *D) const;

815private:
mutable comments::CommandTraits CommentCommandTraits;

/// \brief Iterator that visits import declarations.
class import_iterator {
  ImportDecl *Import = nullptr;

public:
  using value_type = ImportDecl *;
  using reference = ImportDecl *;
  using pointer = ImportDecl *;
  using difference_type = int;
  using iterator_category = std::forward_iterator_tag;

  import_iterator() = default;
  explicit import_iterator(ImportDecl *Import) : Import(Import) {}

  reference operator*() const { return Import; }
  pointer operator->() const { return Import; }

  import_iterator &operator++() {
    Import = ASTContext::getNextLocalImport(Import);
    return *this;
  }

  import_iterator operator++(int) {
    import_iterator Other(*this);
    ++(*this);
    return Other;
  }

  friend bool operator==(import_iterator X, import_iterator Y) {
    return X.Import == Y.Import;
  }

  friend bool operator!=(import_iterator X, import_iterator Y) {
    return X.Import != Y.Import;
  }
};

855public:
comments::CommandTraits &getCommentCommandTraits() const {
  return CommentCommandTraits;
}

/// \brief Retrieve the attributes for the given declaration.
AttrVec& getDeclAttrs(const Decl *D);

/// \brief Erase the attributes corresponding to the given declaration.
void eraseDeclAttrs(const Decl *D);

/// \brief If this variable is an instantiated static data member of a
/// class template specialization, returns the templated static data member
/// from which it was instantiated.
// FIXME: Remove ?
MemberSpecializationInfo *getInstantiatedFromStaticDataMember(
                                                         const VarDecl *Var);

TemplateOrSpecializationInfo
getTemplateOrSpecializationInfo(const VarDecl *Var);

FunctionDecl *getClassScopeSpecializationPattern(const FunctionDecl *FD);

void setClassScopeSpecializationPattern(FunctionDecl *FD,
                                        FunctionDecl *Pattern);

/// \brief Note that the static data member \p Inst is an instantiation of
/// the static data member template \p Tmpl of a class template.
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
                                         TemplateSpecializationKind TSK,
                      SourceLocation PointOfInstantiation = SourceLocation());

void setTemplateOrSpecializationInfo(VarDecl *Inst,
                                     TemplateOrSpecializationInfo TSI);

/// \brief If the given using decl \p Inst is an instantiation of a
/// (possibly unresolved) using decl from a template instantiation,
/// return it.
NamedDecl *getInstantiatedFromUsingDecl(NamedDecl *Inst);

/// \brief Remember that the using decl \p Inst is an instantiation
/// of the using decl \p Pattern of a class template.
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern);

void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
                                        UsingShadowDecl *Pattern);
UsingShadowDecl *getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst);

FieldDecl *getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field);

void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl);

// Access to the set of methods overridden by the given C++ method.
using overridden_cxx_method_iterator = CXXMethodVector::const_iterator;
overridden_cxx_method_iterator
overridden_methods_begin(const CXXMethodDecl *Method) const;

overridden_cxx_method_iterator
overridden_methods_end(const CXXMethodDecl *Method) const;

unsigned overridden_methods_size(const CXXMethodDecl *Method) const;

using overridden_method_range =
    llvm::iterator_range<overridden_cxx_method_iterator>;

overridden_method_range overridden_methods(const CXXMethodDecl *Method) const;

/// \brief Note that the given C++ \p Method overrides the given \p
/// Overridden method.
void addOverriddenMethod(const CXXMethodDecl *Method,
                         const CXXMethodDecl *Overridden);

/// \brief Return C++ or ObjC overridden methods for the given \p Method.
///
/// An ObjC method is considered to override any method in the class's
/// base classes, its protocols, or its categories' protocols, that has
/// the same selector and is of the same kind (class or instance).
/// A method in an implementation is not considered as overriding the same
/// method in the interface or its categories.
void getOverriddenMethods(
                      const NamedDecl *Method,
                      SmallVectorImpl<const NamedDecl *> &Overridden) const;

/// \brief Notify the AST context that a new import declaration has been
/// parsed or implicitly created within this translation unit.
void addedLocalImportDecl(ImportDecl *Import);

static ImportDecl *getNextLocalImport(ImportDecl *Import) {
  return Import->NextLocalImport;
}

using import_range = llvm::iterator_range<import_iterator>;

import_range local_imports() const {
  return import_range(import_iterator(FirstLocalImport), import_iterator());
}

Decl *getPrimaryMergedDecl(Decl *D) {
  Decl *Result = MergedDecls.lookup(D);
  return Result ? Result : D;
}
void setPrimaryMergedDecl(Decl *D, Decl *Primary) {
  MergedDecls[D] = Primary;
}

/// \brief Note that the definition \p ND has been merged into module \p M,
/// and should be visible whenever \p M is visible.
void mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
                               bool NotifyListeners = true);

/// \brief Clean up the merged definition list. Call this if you might have
/// added duplicates into the list.
void deduplicateMergedDefinitonsFor(NamedDecl *ND);

/// \brief Get the additional modules in which the definition \p Def has
/// been merged.
ArrayRef<Module*> getModulesWithMergedDefinition(const NamedDecl *Def) {
  auto MergedIt = MergedDefModules.find(Def);
  if (MergedIt == MergedDefModules.end())
    return None;
  return MergedIt->second;
}

/// Add a declaration to the list of declarations that are initialized
/// for a module. This will typically be a global variable (with internal
/// linkage) that runs module initializers, such as the iostream initializer,
/// or an ImportDecl nominating another module that has initializers.
void addModuleInitializer(Module *M, Decl *Init);

void addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs);

/// Get the initializations to perform when importing a module, if any.
ArrayRef<Decl*> getModuleInitializers(Module *M);

TranslationUnitDecl *getTranslationUnitDecl() const { return TUDecl; }

ExternCContextDecl *getExternCContextDecl() const;
BuiltinTemplateDecl *getMakeIntegerSeqDecl() const;
BuiltinTemplateDecl *getTypePackElementDecl() const;

// Builtin Types.
CanQualType VoidTy;
CanQualType BoolTy;
CanQualType CharTy;
CanQualType WCharTy;  // [C++ 3.9.1p5].
CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.
CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.
CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType Char32Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy, Int128Ty;
CanQualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;
CanQualType UnsignedLongLongTy, UnsignedInt128Ty;
CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty;
CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
CanQualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy;
CanQualType Float128ComplexTy;
CanQualType VoidPtrTy, NullPtrTy;
CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;
CanQualType BuiltinFnTy;
CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
CanQualType ObjCBuiltinBoolTy;
1018#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
CanQualType SingletonId;
1020#include "clang/Basic/OpenCLImageTypes.def"
CanQualType OCLSamplerTy, OCLEventTy, OCLClkEventTy;
CanQualType OCLQueueTy, OCLReserveIDTy;
CanQualType OMPArraySectionTy;

// Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
mutable QualType AutoDeductTy;     // Deduction against 'auto'.
mutable QualType AutoRRefDeductTy; // Deduction against 'auto &&'.

// Decl used to help define __builtin_va_list for some targets.
// The decl is built when constructing 'BuiltinVaListDecl'.
mutable Decl *VaListTagDecl;

ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents,
           SelectorTable &sels, Builtin::Context &builtins);
ASTContext(const ASTContext &) = delete;
ASTContext &operator=(const ASTContext &) = delete;
~ASTContext();

/// \brief Attach an external AST source to the AST context.
///
/// The external AST source provides the ability to load parts of
/// the abstract syntax tree as needed from some external storage,
/// e.g., a precompiled header.
void setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source);

/// \brief Retrieve a pointer to the external AST source associated
/// with this AST context, if any.
ExternalASTSource *getExternalSource() const {
  return ExternalSource.get();
}

/// \brief Attach an AST mutation listener to the AST context.
///
/// The AST mutation listener provides the ability to track modifications to
/// the abstract syntax tree entities committed after they were initially
/// created.
void setASTMutationListener(ASTMutationListener *Listener) {
  this->Listener = Listener;
}

/// \brief Retrieve a pointer to the AST mutation listener associated
/// with this AST context, if any.
ASTMutationListener *getASTMutationListener() const { return Listener; }

void PrintStats() const;
const SmallVectorImpl<Type *>& getTypes() const { return Types; }

BuiltinTemplateDecl *buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,
                                              const IdentifierInfo *II) const;

/// \brief Create a new implicit TU-level CXXRecordDecl or RecordDecl
/// declaration.
RecordDecl *buildImplicitRecord(StringRef Name,
                                RecordDecl::TagKind TK = TTK_Struct) const;

/// \brief Create a new implicit TU-level typedef declaration.
TypedefDecl *buildImplicitTypedef(QualType T, StringRef Name) const;

/// \brief Retrieve the declaration for the 128-bit signed integer type.
TypedefDecl *getInt128Decl() const;

/// \brief Retrieve the declaration for the 128-bit unsigned integer type.
TypedefDecl *getUInt128Decl() const;

//===--------------------------------------------------------------------===//
//                           Type Constructors
//===--------------------------------------------------------------------===//

1089private:
/// \brief Return a type with extended qualifiers.
QualType getExtQualType(const Type *Base, Qualifiers Quals) const;

QualType getTypeDeclTypeSlow(const TypeDecl *Decl) const;

QualType getPipeType(QualType T, bool ReadOnly) const;

1097public:
/// \brief Return the uniqued reference to the type for an address space
/// qualified type with the specified type and address space.
///
/// The resulting type has a union of the qualifiers from T and the address
/// space. If T already has an address space specifier, it is silently
/// replaced.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const;

/// \brief Remove any existing address space on the type and returns the type
/// with qualifiers intact (or that's the idea anyway)
///
/// The return type should be T with all prior qualifiers minus the address
/// space.
QualType removeAddrSpaceQualType(QualType T) const;

/// \brief Apply Objective-C protocol qualifiers to the given type.
/// \param allowOnPointerType specifies if we can apply protocol
/// qualifiers on ObjCObjectPointerType. It can be set to true when
/// contructing the canonical type of a Objective-C type parameter.
QualType applyObjCProtocolQualifiers(QualType type,
    ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
    bool allowOnPointerType = false) const;

/// \brief Return the uniqued reference to the type for an Objective-C
/// gc-qualified type.
///
/// The retulting type has a union of the qualifiers from T and the gc
/// attribute.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const;

/// \brief Return the uniqued reference to the type for a \c restrict
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and
/// \c restrict.
QualType getRestrictType(QualType T) const {
  return T.withFastQualifiers(Qualifiers::Restrict);
}

/// \brief Return the uniqued reference to the type for a \c volatile
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and
/// \c volatile.
QualType getVolatileType(QualType T) const {
  return T.withFastQualifiers(Qualifiers::Volatile);
}

/// \brief Return the uniqued reference to the type for a \c const
/// qualified type.
///
/// The resulting type has a union of the qualifiers from \p T and \c const.
///
/// It can be reasonably expected that this will always be equivalent to
/// calling T.withConst().
QualType getConstType(QualType T) const { return T.withConst(); }

/// \brief Change the ExtInfo on a function type.
const FunctionType *adjustFunctionType(const FunctionType *Fn,
                                       FunctionType::ExtInfo EInfo);

/// Adjust the given function result type.
CanQualType getCanonicalFunctionResultType(QualType ResultType) const;

/// \brief Change the result type of a function type once it is deduced.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType);

/// Get a function type and produce the equivalent function type with the
/// specified exception specification. Type sugar that can be present on a
/// declaration of a function with an exception specification is permitted
/// and preserved. Other type sugar (for instance, typedefs) is not.
QualType getFunctionTypeWithExceptionSpec(
    QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI);

/// \brief Determine whether two function types are the same, ignoring
/// exception specifications in cases where they're part of the type.
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U);

/// \brief Change the exception specification on a function once it is
/// delay-parsed, instantiated, or computed.
void adjustExceptionSpec(FunctionDecl *FD,
                         const FunctionProtoType::ExceptionSpecInfo &ESI,
                         bool AsWritten = false);

/// Determine whether a type is a class that should be detructed in the
/// callee function.
bool isParamDestroyedInCallee(QualType T) const;

/// \brief Return the uniqued reference to the type for a complex
/// number with the specified element type.
QualType getComplexType(QualType T) const;
CanQualType getComplexType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getComplexType((QualType) T));
}

/// \brief Return the uniqued reference to the type for a pointer to
/// the specified type.
QualType getPointerType(QualType T) const;
CanQualType getPointerType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getPointerType((QualType) T));
}

/// \brief Return the uniqued reference to a type adjusted from the original
/// type to a new type.
QualType getAdjustedType(QualType Orig, QualType New) const;
CanQualType getAdjustedType(CanQualType Orig, CanQualType New) const {
  return CanQualType::CreateUnsafe(
      getAdjustedType((QualType)Orig, (QualType)New));
}

/// \brief Return the uniqued reference to the decayed version of the given
/// type.  Can only be called on array and function types which decay to
/// pointer types.
QualType getDecayedType(QualType T) const;
CanQualType getDecayedType(CanQualType T) const {
  return CanQualType::CreateUnsafe(getDecayedType((QualType) T));
}

/// \brief Return the uniqued reference to the atomic type for the specified
/// type.
QualType getAtomicType(QualType T) const;

/// \brief Return the uniqued reference to the type for a block of the
/// specified type.
QualType getBlockPointerType(QualType T) const;

/// Gets the struct used to keep track of the descriptor for pointer to
/// blocks.
QualType getBlockDescriptorType() const;

/// \brief Return a read_only pipe type for the specified type.
QualType getReadPipeType(QualType T) const;

/// \brief Return a write_only pipe type for the specified type.
QualType getWritePipeType(QualType T) const;

/// Gets the struct used to keep track of the extended descriptor for
/// pointer to blocks.
QualType getBlockDescriptorExtendedType() const;

/// Map an AST Type to an OpenCLTypeKind enum value.
TargetInfo::OpenCLTypeKind getOpenCLTypeKind(const Type *T) const;

/// Get address space for OpenCL type.
LangAS getOpenCLTypeAddrSpace(const Type *T) const;

void setcudaConfigureCallDecl(FunctionDecl *FD) {
  cudaConfigureCallDecl = FD;
}

FunctionDecl *getcudaConfigureCallDecl() {
  return cudaConfigureCallDecl;
}

/// Returns true iff we need copy/dispose helpers for the given type.
bool BlockRequiresCopying(QualType Ty, const VarDecl *D);

/// Returns true, if given type has a known lifetime. HasByrefExtendedLayout is set
/// to false in this case. If HasByrefExtendedLayout returns true, byref variable
/// has extended lifetime.
bool getByrefLifetime(QualType Ty,
                      Qualifiers::ObjCLifetime &Lifetime,
                      bool &HasByrefExtendedLayout) const;

/// \brief Return the uniqued reference to the type for an lvalue reference
/// to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue = true)
  const;

/// \brief Return the uniqued reference to the type for an rvalue reference
/// to the specified type.
QualType getRValueReferenceType(QualType T) const;

/// \brief Return the uniqued reference to the type for a member pointer to
/// the specified type in the specified class.
///
/// The class \p Cls is a \c Type because it could be a dependent name.
QualType getMemberPointerType(QualType T, const Type *Cls) const;

/// \brief Return a non-unique reference to the type for a variable array of
/// the specified element type.
QualType getVariableArrayType(QualType EltTy, Expr *NumElts,
                              ArrayType::ArraySizeModifier ASM,
                              unsigned IndexTypeQuals,
                              SourceRange Brackets) const;

/// \brief Return a non-unique reference to the type for a dependently-sized
/// array of the specified element type.
///
/// FIXME: We will need these to be uniqued, or at least comparable, at some
/// point.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts,
                                    ArrayType::ArraySizeModifier ASM,
                                    unsigned IndexTypeQuals,
                                    SourceRange Brackets) const;

/// \brief Return a unique reference to the type for an incomplete array of
/// the specified element type.
QualType getIncompleteArrayType(QualType EltTy,
                                ArrayType::ArraySizeModifier ASM,
                                unsigned IndexTypeQuals) const;

/// \brief Return the unique reference to the type for a constant array of
/// the specified element type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize,
                              ArrayType::ArraySizeModifier ASM,
                              unsigned IndexTypeQuals) const;

/// \brief Returns a vla type where known sizes are replaced with [*].
QualType getVariableArrayDecayedType(QualType Ty) const;

/// \brief Return the unique reference to a vector type of the specified
/// element type and size.
///
/// \pre \p VectorType must be a built-in type.
QualType getVectorType(QualType VectorType, unsigned NumElts,
                       VectorType::VectorKind VecKind) const;

/// \brief Return the unique reference to an extended vector type
/// of the specified element type and size.
///
/// \pre \p VectorType must be a built-in type.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const;

/// \pre Return a non-unique reference to the type for a dependently-sized
/// vector of the specified element type.
///
/// FIXME: We will need these to be uniqued, or at least comparable, at some
/// point.
QualType getDependentSizedExtVectorType(QualType VectorType,
                                        Expr *SizeExpr,
                                        SourceLocation AttrLoc) const;

QualType getDependentAddressSpaceType(QualType PointeeType,
                                      Expr *AddrSpaceExpr,
                                      SourceLocation AttrLoc) const;

/// \brief Return a K&R style C function type like 'int()'.
QualType getFunctionNoProtoType(QualType ResultTy,
                                const FunctionType::ExtInfo &Info) const;

QualType getFunctionNoProtoType(QualType ResultTy) const {
  return getFunctionNoProtoType(ResultTy, FunctionType::ExtInfo());
}

/// \brief Return a normal function type with a typed argument list.
QualType getFunctionType(QualType ResultTy, ArrayRef<QualType> Args,
                         const FunctionProtoType::ExtProtoInfo &EPI) const {
  return getFunctionTypeInternal(ResultTy, Args, EPI, false);
}

1349private:
/// \brief Return a normal function type with a typed argument list.
QualType getFunctionTypeInternal(QualType ResultTy, ArrayRef<QualType> Args,
                                 const FunctionProtoType::ExtProtoInfo &EPI,
                                 bool OnlyWantCanonical) const;

1355public:
/// \brief Return the unique reference to the type for the specified type
/// declaration.
QualType getTypeDeclType(const TypeDecl *Decl,
                         const TypeDecl *PrevDecl = nullptr) const {
  assert(Decl && "Passed null for Decl param")(static_cast <bool> (Decl && "Passed null for Decl param"
) ? void (0) : __assert_fail ("Decl && \"Passed null for Decl param\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1360, __extension__ __PRETTY_FUNCTION__));
  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);

  if (PrevDecl) {
    assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl")(static_cast <bool> (PrevDecl->TypeForDecl &&
 "previous decl has no TypeForDecl") ? void (0) : __assert_fail
 ("PrevDecl->TypeForDecl && \"previous decl has no TypeForDecl\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1364, __extension__ __PRETTY_FUNCTION__));
    Decl->TypeForDecl = PrevDecl->TypeForDecl;
    return QualType(PrevDecl->TypeForDecl, 0);
  }

  return getTypeDeclTypeSlow(Decl);
}

/// \brief Return the unique reference to the type for the specified
/// typedef-name decl.
QualType getTypedefType(const TypedefNameDecl *Decl,
                        QualType Canon = QualType()) const;

QualType getRecordType(const RecordDecl *Decl) const;

QualType getEnumType(const EnumDecl *Decl) const;

QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const;

QualType getAttributedType(AttributedType::Kind attrKind,
                           QualType modifiedType,
                           QualType equivalentType);

QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced,
                                      QualType Replacement) const;
QualType getSubstTemplateTypeParmPackType(
                                        const TemplateTypeParmType *Replaced,
                                          const TemplateArgument &ArgPack);

QualType
getTemplateTypeParmType(unsigned Depth, unsigned Index,
                        bool ParameterPack,
                        TemplateTypeParmDecl *ParmDecl = nullptr) const;

QualType getTemplateSpecializationType(TemplateName T,
                                       ArrayRef<TemplateArgument> Args,
                                       QualType Canon = QualType()) const;

QualType
getCanonicalTemplateSpecializationType(TemplateName T,
                                       ArrayRef<TemplateArgument> Args) const;

QualType getTemplateSpecializationType(TemplateName T,
                                       const TemplateArgumentListInfo &Args,
                                       QualType Canon = QualType()) const;

TypeSourceInfo *
getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc,
                                  const TemplateArgumentListInfo &Args,
                                  QualType Canon = QualType()) const;

QualType getParenType(QualType NamedType) const;

QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
                           NestedNameSpecifier *NNS,
                           QualType NamedType) const;
QualType getDependentNameType(ElaboratedTypeKeyword Keyword,
                              NestedNameSpecifier *NNS,
                              const IdentifierInfo *Name,
                              QualType Canon = QualType()) const;

QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                                NestedNameSpecifier *NNS,
                                                const IdentifierInfo *Name,
                                  const TemplateArgumentListInfo &Args) const;
QualType getDependentTemplateSpecializationType(
    ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
    const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;

TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl);

/// Get a template argument list with one argument per template parameter
/// in a template parameter list, such as for the injected class name of
/// a class template.
void getInjectedTemplateArgs(const TemplateParameterList *Params,
                             SmallVectorImpl<TemplateArgument> &Args);

QualType getPackExpansionType(QualType Pattern,
                              Optional<unsigned> NumExpansions);

QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
                              ObjCInterfaceDecl *PrevDecl = nullptr) const;

/// Legacy interface: cannot provide type arguments or __kindof.
QualType getObjCObjectType(QualType Base,
                           ObjCProtocolDecl * const *Protocols,
                           unsigned NumProtocols) const;

QualType getObjCObjectType(QualType Base,
                           ArrayRef<QualType> typeArgs,
                           ArrayRef<ObjCProtocolDecl *> protocols,
                           bool isKindOf) const;

QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
                              ArrayRef<ObjCProtocolDecl *> protocols,
                              QualType Canonical = QualType()) const;

bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl);

/// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
/// QT's qualified-id protocol list adopt all protocols in IDecl's list
/// of protocols.
bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
                                          ObjCInterfaceDecl *IDecl);

/// \brief Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectPointerType(QualType OIT) const;

/// \brief GCC extension.
QualType getTypeOfExprType(Expr *e) const;
QualType getTypeOfType(QualType t) const;

/// \brief C++11 decltype.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const;

/// \brief Unary type transforms
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType,
                               UnaryTransformType::UTTKind UKind) const;

/// \brief C++11 deduced auto type.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
                     bool IsDependent) const;

/// \brief C++11 deduction pattern for 'auto' type.
QualType getAutoDeductType() const;

/// \brief C++11 deduction pattern for 'auto &&' type.
QualType getAutoRRefDeductType() const;

/// \brief C++17 deduced class template specialization type.
QualType getDeducedTemplateSpecializationType(TemplateName Template,
                                              QualType DeducedType,
                                              bool IsDependent) const;

/// \brief Return the unique reference to the type for the specified TagDecl
/// (struct/union/class/enum) decl.
QualType getTagDeclType(const TagDecl *Decl) const;

/// \brief Return the unique type for "size_t" (C99 7.17), defined in
/// <stddef.h>.
///
/// The sizeof operator requires this (C99 6.5.3.4p4).
CanQualType getSizeType() const;

/// \brief Return the unique signed counterpart of 
/// the integer type corresponding to size_t.
CanQualType getSignedSizeType() const;

/// \brief Return the unique type for "intmax_t" (C99 7.18.1.5), defined in
/// <stdint.h>.
CanQualType getIntMaxType() const;

/// \brief Return the unique type for "uintmax_t" (C99 7.18.1.5), defined in
/// <stdint.h>.
CanQualType getUIntMaxType() const;

/// \brief Return the unique wchar_t type available in C++ (and available as
/// __wchar_t as a Microsoft extension).
QualType getWCharType() const { return WCharTy; }

/// \brief Return the type of wide characters. In C++, this returns the
/// unique wchar_t type. In C99, this returns a type compatible with the type
/// defined in <stddef.h> as defined by the target.
QualType getWideCharType() const { return WideCharTy; }

/// \brief Return the type of "signed wchar_t".
///
/// Used when in C++, as a GCC extension.
QualType getSignedWCharType() const;

/// \brief Return the type of "unsigned wchar_t".
///
/// Used when in C++, as a GCC extension.
QualType getUnsignedWCharType() const;

/// \brief In C99, this returns a type compatible with the type
/// defined in <stddef.h> as defined by the target.
QualType getWIntType() const { return WIntTy; }

/// \brief Return a type compatible with "intptr_t" (C99 7.18.1.4),
/// as defined by the target.
QualType getIntPtrType() const;

/// \brief Return a type compatible with "uintptr_t" (C99 7.18.1.4),
/// as defined by the target.
QualType getUIntPtrType() const;

/// \brief Return the unique type for "ptrdiff_t" (C99 7.17) defined in
/// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
QualType getPointerDiffType() const;

/// \brief Return the unique unsigned counterpart of "ptrdiff_t"
/// integer type. The standard (C11 7.21.6.1p7) refers to this type
/// in the definition of %tu format specifier.
QualType getUnsignedPointerDiffType() const;

/// \brief Return the unique type for "pid_t" defined in
/// <sys/types.h>. We need this to compute the correct type for vfork().
QualType getProcessIDType() const;

/// \brief Return the C structure type used to represent constant CFStrings.
QualType getCFConstantStringType() const;

/// \brief Returns the C struct type for objc_super
QualType getObjCSuperType() const;
void setObjCSuperType(QualType ST) { ObjCSuperType = ST; }

/// Get the structure type used to representation CFStrings, or NULL
/// if it hasn't yet been built.
QualType getRawCFConstantStringType() const {
  if (CFConstantStringTypeDecl)
    return getTypedefType(CFConstantStringTypeDecl);
  return QualType();
}
void setCFConstantStringType(QualType T);
TypedefDecl *getCFConstantStringDecl() const;
RecordDecl *getCFConstantStringTagDecl() const;

// This setter/getter represents the ObjC type for an NSConstantString.
void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl);
QualType getObjCConstantStringInterface() const {
  return ObjCConstantStringType;
}

QualType getObjCNSStringType() const {
  return ObjCNSStringType;
}

void setObjCNSStringType(QualType T) {
  ObjCNSStringType = T;
}

/// \brief Retrieve the type that \c id has been defined to, which may be
/// different from the built-in \c id if \c id has been typedef'd.
QualType getObjCIdRedefinitionType() const {
  if (ObjCIdRedefinitionType.isNull())
    return getObjCIdType();
  return ObjCIdRedefinitionType;
}

/// \brief Set the user-written type that redefines \c id.
void setObjCIdRedefinitionType(QualType RedefType) {
  ObjCIdRedefinitionType = RedefType;
}

/// \brief Retrieve the type that \c Class has been defined to, which may be
/// different from the built-in \c Class if \c Class has been typedef'd.
QualType getObjCClassRedefinitionType() const {
  if (ObjCClassRedefinitionType.isNull())
    return getObjCClassType();
  return ObjCClassRedefinitionType;
}

/// \brief Set the user-written type that redefines 'SEL'.
void setObjCClassRedefinitionType(QualType RedefType) {
  ObjCClassRedefinitionType = RedefType;
}

/// \brief Retrieve the type that 'SEL' has been defined to, which may be
/// different from the built-in 'SEL' if 'SEL' has been typedef'd.
QualType getObjCSelRedefinitionType() const {
  if (ObjCSelRedefinitionType.isNull())
    return getObjCSelType();
  return ObjCSelRedefinitionType;
}

/// \brief Set the user-written type that redefines 'SEL'.
void setObjCSelRedefinitionType(QualType RedefType) {
  ObjCSelRedefinitionType = RedefType;
}

/// Retrieve the identifier 'NSObject'.
IdentifierInfo *getNSObjectName() {
  if (!NSObjectName) {
    NSObjectName = &Idents.get("NSObject");
  }

  return NSObjectName;
}

/// Retrieve the identifier 'NSCopying'.
IdentifierInfo *getNSCopyingName() {
  if (!NSCopyingName) {
    NSCopyingName = &Idents.get("NSCopying");
  }

  return NSCopyingName;
}

CanQualType getNSUIntegerType() const {
  assert(Target && "Expected target to be initialized")(static_cast <bool> (Target && "Expected target to be initialized"
) ? void (0) : __assert_fail ("Target && \"Expected target to be initialized\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1654, __extension__ __PRETTY_FUNCTION__));
  const llvm::Triple &T = Target->getTriple();
  // Windows is LLP64 rather than LP64
  if (T.isOSWindows() && T.isArch64Bit())
    return UnsignedLongLongTy;
  return UnsignedLongTy;
}

CanQualType getNSIntegerType() const {
  assert(Target && "Expected target to be initialized")(static_cast <bool> (Target && "Expected target to be initialized"
) ? void (0) : __assert_fail ("Target && \"Expected target to be initialized\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1663, __extension__ __PRETTY_FUNCTION__));
  const llvm::Triple &T = Target->getTriple();
  // Windows is LLP64 rather than LP64
  if (T.isOSWindows() && T.isArch64Bit())
    return LongLongTy;
  return LongTy;
}

/// Retrieve the identifier 'bool'.
IdentifierInfo *getBoolName() const {
  if (!BoolName)
    BoolName = &Idents.get("bool");
  return BoolName;
}

IdentifierInfo *getMakeIntegerSeqName() const {
  if (!MakeIntegerSeqName)
    MakeIntegerSeqName = &Idents.get("__make_integer_seq");
  return MakeIntegerSeqName;
}

IdentifierInfo *getTypePackElementName() const {
  if (!TypePackElementName)
    TypePackElementName = &Idents.get("__type_pack_element");
  return TypePackElementName;
}

/// \brief Retrieve the Objective-C "instancetype" type, if already known;
/// otherwise, returns a NULL type;
QualType getObjCInstanceType() {
  return getTypeDeclType(getObjCInstanceTypeDecl());
}

/// \brief Retrieve the typedef declaration corresponding to the Objective-C
/// "instancetype" type.
TypedefDecl *getObjCInstanceTypeDecl();

/// \brief Set the type for the C FILE type.
void setFILEDecl(TypeDecl *FILEDecl) { this->FILEDecl = FILEDecl; }

/// \brief Retrieve the C FILE type.
QualType getFILEType() const {
  if (FILEDecl)
    return getTypeDeclType(FILEDecl);
  return QualType();
}

/// \brief Set the type for the C jmp_buf type.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl) {
  this->jmp_bufDecl = jmp_bufDecl;
}

/// \brief Retrieve the C jmp_buf type.
QualType getjmp_bufType() const {
  if (jmp_bufDecl)
    return getTypeDeclType(jmp_bufDecl);
  return QualType();
}

/// \brief Set the type for the C sigjmp_buf type.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl) {
  this->sigjmp_bufDecl = sigjmp_bufDecl;
}

/// \brief Retrieve the C sigjmp_buf type.
QualType getsigjmp_bufType() const {
  if (sigjmp_bufDecl)
    return getTypeDeclType(sigjmp_bufDecl);
  return QualType();
}

/// \brief Set the type for the C ucontext_t type.
void setucontext_tDecl(TypeDecl *ucontext_tDecl) {
  this->ucontext_tDecl = ucontext_tDecl;
}

/// \brief Retrieve the C ucontext_t type.
QualType getucontext_tType() const {
  if (ucontext_tDecl)
    return getTypeDeclType(ucontext_tDecl);
  return QualType();
}

/// \brief The result type of logical operations, '<', '>', '!=', etc.
QualType getLogicalOperationType() const {
  return getLangOpts().CPlusPlus ? BoolTy : IntTy;
}

/// \brief Emit the Objective-CC type encoding for the given type \p T into
/// \p S.
///
/// If \p Field is specified then record field names are also encoded.
void getObjCEncodingForType(QualType T, std::string &S,
                            const FieldDecl *Field=nullptr,
                            QualType *NotEncodedT=nullptr) const;

/// \brief Emit the Objective-C property type encoding for the given
/// type \p T into \p S.
void getObjCEncodingForPropertyType(QualType T, std::string &S) const;

void getLegacyIntegralTypeEncoding(QualType &t) const;

/// \brief Put the string version of the type qualifiers \p QT into \p S.
void getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
                                     std::string &S) const;

/// \brief Emit the encoded type for the function \p Decl into \p S.
///
/// This is in the same format as Objective-C method encodings.
///
/// \returns true if an error occurred (e.g., because one of the parameter
/// types is incomplete), false otherwise.
std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const;

/// \brief Emit the encoded type for the method declaration \p Decl into
/// \p S.
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
                                         bool Extended = false) const;

/// \brief Return the encoded type for this block declaration.
std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const;

/// getObjCEncodingForPropertyDecl - Return the encoded type for
/// this method declaration. If non-NULL, Container must be either
/// an ObjCCategoryImplDecl or ObjCImplementationDecl; it should
/// only be NULL when getting encodings for protocol properties.
std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
                                           const Decl *Container) const;

bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
                                    ObjCProtocolDecl *rProto) const;

ObjCPropertyImplDecl *getObjCPropertyImplDeclForPropertyDecl(
                                                const ObjCPropertyDecl *PD,
                                                const Decl *Container) const;

/// \brief Return the size of type \p T for Objective-C encoding purpose,
/// in characters.
CharUnits getObjCEncodingTypeSize(QualType T) const;

/// \brief Retrieve the typedef corresponding to the predefined \c id type
/// in Objective-C.
TypedefDecl *getObjCIdDecl() const;

/// \brief Represents the Objective-CC \c id type.
///
/// This is set up lazily, by Sema.  \c id is always a (typedef for a)
/// pointer type, a pointer to a struct.
QualType getObjCIdType() const {
  return getTypeDeclType(getObjCIdDecl());
}

/// \brief Retrieve the typedef corresponding to the predefined 'SEL' type
/// in Objective-C.
TypedefDecl *getObjCSelDecl() const;

/// \brief Retrieve the type that corresponds to the predefined Objective-C
/// 'SEL' type.
QualType getObjCSelType() const {
  return getTypeDeclType(getObjCSelDecl());
}

/// \brief Retrieve the typedef declaration corresponding to the predefined
/// Objective-C 'Class' type.
TypedefDecl *getObjCClassDecl() const;

/// \brief Represents the Objective-C \c Class type.
///
/// This is set up lazily, by Sema.  \c Class is always a (typedef for a)
/// pointer type, a pointer to a struct.
QualType getObjCClassType() const {
  return getTypeDeclType(getObjCClassDecl());
}

/// \brief Retrieve the Objective-C class declaration corresponding to
/// the predefined \c Protocol class.
ObjCInterfaceDecl *getObjCProtocolDecl() const;

/// \brief Retrieve declaration of 'BOOL' typedef
TypedefDecl *getBOOLDecl() const {
  return BOOLDecl;
}

/// \brief Save declaration of 'BOOL' typedef
void setBOOLDecl(TypedefDecl *TD) {
  BOOLDecl = TD;
}

/// \brief type of 'BOOL' type.
QualType getBOOLType() const {
  return getTypeDeclType(getBOOLDecl());
}

/// \brief Retrieve the type of the Objective-C \c Protocol class.
QualType getObjCProtoType() const {
  return getObjCInterfaceType(getObjCProtocolDecl());
}

/// \brief Retrieve the C type declaration corresponding to the predefined
/// \c __builtin_va_list type.
TypedefDecl *getBuiltinVaListDecl() const;

/// \brief Retrieve the type of the \c __builtin_va_list type.
QualType getBuiltinVaListType() const {
  return getTypeDeclType(getBuiltinVaListDecl());
}

/// \brief Retrieve the C type declaration corresponding to the predefined
/// \c __va_list_tag type used to help define the \c __builtin_va_list type
/// for some targets.
Decl *getVaListTagDecl() const;

/// Retrieve the C type declaration corresponding to the predefined
/// \c __builtin_ms_va_list type.
TypedefDecl *getBuiltinMSVaListDecl() const;

/// Retrieve the type of the \c __builtin_ms_va_list type.
QualType getBuiltinMSVaListType() const {
  return getTypeDeclType(getBuiltinMSVaListDecl());
}

/// \brief Return a type with additional \c const, \c volatile, or
/// \c restrict qualifiers.
QualType getCVRQualifiedType(QualType T, unsigned CVR) const {
  return getQualifiedType(T, Qualifiers::fromCVRMask(CVR));
}

/// \brief Un-split a SplitQualType.
QualType getQualifiedType(SplitQualType split) const {
  return getQualifiedType(split.Ty, split.Quals);
}

/// \brief Return a type with additional qualifiers.
QualType getQualifiedType(QualType T, Qualifiers Qs) const {
  if (!Qs.hasNonFastQualifiers())
    return T.withFastQualifiers(Qs.getFastQualifiers());
  QualifierCollector Qc(Qs);
  const Type *Ptr = Qc.strip(T);
  return getExtQualType(Ptr, Qc);
}

/// \brief Return a type with additional qualifiers.
QualType getQualifiedType(const Type *T, Qualifiers Qs) const {
  if (!Qs.hasNonFastQualifiers())
    return QualType(T, Qs.getFastQualifiers());
  return getExtQualType(T, Qs);
}

/// \brief Return a type with the given lifetime qualifier.
///
/// \pre Neither type.ObjCLifetime() nor \p lifetime may be \c OCL_None.
QualType getLifetimeQualifiedType(QualType type,
                                  Qualifiers::ObjCLifetime lifetime) {
  assert(type.getObjCLifetime() == Qualifiers::OCL_None)(static_cast <bool> (type.getObjCLifetime() == Qualifiers
::OCL_None) ? void (0) : __assert_fail ("type.getObjCLifetime() == Qualifiers::OCL_None"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1916, __extension__ __PRETTY_FUNCTION__));
  assert(lifetime != Qualifiers::OCL_None)(static_cast <bool> (lifetime != Qualifiers::OCL_None) ?
 void (0) : __assert_fail ("lifetime != Qualifiers::OCL_None"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/ASTContext.h"
, 1917, __extension__ __PRETTY_FUNCTION__));

  Qualifiers qs;
  qs.addObjCLifetime(lifetime);
  return getQualifiedType(type, qs);
}

/// getUnqualifiedObjCPointerType - Returns version of
/// Objective-C pointer type with lifetime qualifier removed.
QualType getUnqualifiedObjCPointerType(QualType type) const {
  if (!type.getTypePtr()->isObjCObjectPointerType() ||
      !type.getQualifiers().hasObjCLifetime())
    return type;
  Qualifiers Qs = type.getQualifiers();
  Qs.removeObjCLifetime();
  return getQualifiedType(type.getUnqualifiedType(), Qs);
}

DeclarationNameInfo getNameForTemplate(TemplateName Name,
                                       SourceLocation NameLoc) const;

TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin,
                                       UnresolvedSetIterator End) const;

TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS,
                                      bool TemplateKeyword,
                                      TemplateDecl *Template) const;

TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                      const IdentifierInfo *Name) const;
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                      OverloadedOperatorKind Operator) const;
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param,
                                          TemplateName replacement) const;
TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,
                                      const TemplateArgument &ArgPack) const;

enum GetBuiltinTypeError {
  /// No error
  GE_None,

  /// Missing a type from <stdio.h>
  GE_Missing_stdio,

  /// Missing a type from <setjmp.h>
  GE_Missing_setjmp,

  /// Missing a type from <ucontext.h>
  GE_Missing_ucontext
};

/// \brief Return the type for the specified builtin.
///
/// If \p IntegerConstantArgs is non-null, it is filled in with a bitmask of
/// arguments to the builtin that are required to be integer constant
/// expressions.
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error,
                        unsigned *IntegerConstantArgs = nullptr) const;

1976private:
CanQualType getFromTargetType(unsigned Type) const;
TypeInfo getTypeInfoImpl(const Type *T) const;

//===--------------------------------------------------------------------===//
//                         Type Predicates.
//===--------------------------------------------------------------------===//

1984public:
/// \brief Return one of the GCNone, Weak or Strong Objective-C garbage
/// collection attributes.
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const;

/// \brief Return true if the given vector types are of the same unqualified
/// type or if they are equivalent to the same GCC vector type.
///
/// \note This ignores whether they are target-specific (AltiVec or Neon)
/// types.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec);

/// \brief Return true if this is an \c NSObject object with its \c NSObject
/// attribute set.
static bool isObjCNSObjectType(QualType Ty) {
  return Ty->isObjCNSObjectType();
}

//===--------------------------------------------------------------------===//
//                         Type Sizing and Analysis
//===--------------------------------------------------------------------===//

/// \brief Return the APFloat 'semantics' for the specified scalar floating
/// point type.
const llvm::fltSemantics &getFloatTypeSemantics(QualType T) const;

/// \brief Get the size and alignment of the specified complete type in bits.
TypeInfo getTypeInfo(const Type *T) const;
TypeInfo getTypeInfo(QualType T) const { return getTypeInfo(T.getTypePtr()); }

/// \brief Get default simd alignment of the specified complete type in bits.
unsigned getOpenMPDefaultSimdAlign(QualType T) const;

/// \brief Return the size of the specified (complete) type \p T, in bits.
uint64_t getTypeSize(QualType T) const { return getTypeInfo(T).Width; }
uint64_t getTypeSize(const Type *T) const { return getTypeInfo(T).Width; }

/// \brief Return the size of the character type, in bits.
uint64_t getCharWidth() const {
  return getTypeSize(CharTy);
}

/// \brief Convert a size in bits to a size in characters.
CharUnits toCharUnitsFromBits(int64_t BitSize) const;

/// \brief Convert a size in characters to a size in bits.
int64_t toBits(CharUnits CharSize) const;

/// \brief Return the size of the specified (complete) type \p T, in
/// characters.
CharUnits getTypeSizeInChars(QualType T) const;
CharUnits getTypeSizeInChars(const Type *T) const;

/// \brief Return the ABI-specified alignment of a (complete) type \p T, in
/// bits.
unsigned getTypeAlign(QualType T) const { return getTypeInfo(T).Align; }
unsigned getTypeAlign(const Type *T) const { return getTypeInfo(T).Align; }

/// \brief Return the ABI-specified alignment of a type, in bits, or 0 if
/// the type is incomplete and we cannot determine the alignment (for
/// example, from alignment attributes).
unsigned getTypeAlignIfKnown(QualType T) const;

/// \brief Return the ABI-specified alignment of a (complete) type \p T, in
/// characters.
CharUnits getTypeAlignInChars(QualType T) const;
CharUnits getTypeAlignInChars(const Type *T) const;

// getTypeInfoDataSizeInChars - Return the size of a type, in chars. If the
// type is a record, its data size is returned.
std::pair<CharUnits, CharUnits> getTypeInfoDataSizeInChars(QualType T) const;

std::pair<CharUnits, CharUnits> getTypeInfoInChars(const Type *T) const;
std::pair<CharUnits, CharUnits> getTypeInfoInChars(QualType T) const;

/// \brief Determine if the alignment the type has was required using an
/// alignment attribute.
bool isAlignmentRequired(const Type *T) const;
bool isAlignmentRequired(QualType T) const;

/// \brief Return the "preferred" alignment of the specified type \p T for
/// the current target, in bits.
///
/// This can be different than the ABI alignment in cases where it is
/// beneficial for performance to overalign a data type.
unsigned getPreferredTypeAlign(const Type *T) const;

/// \brief Return the default alignment for __attribute__((aligned)) on
/// this target, to be used if no alignment value is specified.
unsigned getTargetDefaultAlignForAttributeAligned() const;

/// \brief Return the alignment in bits that should be given to a
/// global variable with type \p T.
unsigned getAlignOfGlobalVar(QualType T) const;

/// \brief Return the alignment in characters that should be given to a
/// global variable with type \p T.
CharUnits getAlignOfGlobalVarInChars(QualType T) const;

/// \brief Return a conservative estimate of the alignment of the specified
/// decl \p D.
///
/// \pre \p D must not be a bitfield type, as bitfields do not have a valid
/// alignment.
///
/// If \p ForAlignof, references are treated like their underlying type
/// and  large arrays don't get any special treatment. If not \p ForAlignof
/// it computes the value expected by CodeGen: references are treated like
/// pointers and large arrays get extra alignment.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof = false) const;

/// \brief Get or compute information about the layout of the specified
/// record (struct/union/class) \p D, which indicates its size and field
/// position information.
const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D) const;

/// \brief Get or compute information about the layout of the specified
/// Objective-C interface.
const ASTRecordLayout &getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D)
  const;

void DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS,
                      bool Simple = false) const;

/// \brief Get or compute information about the layout of the specified
/// Objective-C implementation.
///
/// This may differ from the interface if synthesized ivars are present.
const ASTRecordLayout &
getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const;

/// \brief Get our current best idea for the key function of the
/// given record decl, or nullptr if there isn't one.
///
/// The key function is, according to the Itanium C++ ABI section 5.2.3:
///   ...the first non-pure virtual function that is not inline at the
///   point of class definition.
///
/// Other ABIs use the same idea.  However, the ARM C++ ABI ignores
/// virtual functions that are defined 'inline', which means that
/// the result of this computation can change.
const CXXMethodDecl *getCurrentKeyFunction(const CXXRecordDecl *RD);

/// \brief Observe that the given method cannot be a key function.
/// Checks the key-function cache for the method's class and clears it
/// if matches the given declaration.
///
/// This is used in ABIs where out-of-line definitions marked
/// inline are not considered to be key functions.
///
/// \param method should be the declaration from the class definition
void setNonKeyFunction(const CXXMethodDecl *method);

/// Loading virtual member pointers using the virtual inheritance model
/// always results in an adjustment using the vbtable even if the index is
/// zero.
///
/// This is usually OK because the first slot in the vbtable points
/// backwards to the top of the MDC.  However, the MDC might be reusing a
/// vbptr from an nv-base.  In this case, the first slot in the vbtable
/// points to the start of the nv-base which introduced the vbptr and *not*
/// the MDC.  Modify the NonVirtualBaseAdjustment to account for this.
CharUnits getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const;

/// Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
uint64_t getFieldOffset(const ValueDecl *FD) const;

/// Get the offset of an ObjCIvarDecl in bits.
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID,
                              const ObjCImplementationDecl *ID,
                              const ObjCIvarDecl *Ivar) const;

bool isNearlyEmpty(const CXXRecordDecl *RD) const;

VTableContextBase *getVTableContext();

MangleContext *createMangleContext();

void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass,
                          SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const;

unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const;
void CollectInheritedProtocols(const Decl *CDecl,
                        llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols);

/// \brief Return true if the specified type has unique object representations
/// according to (C++17 [meta.unary.prop]p9)
bool hasUniqueObjectRepresentations(QualType Ty) const;

//===--------------------------------------------------------------------===//
//                            Type Operators
//===--------------------------------------------------------------------===//

/// \brief Return the canonical (structural) type corresponding to the
/// specified potentially non-canonical type \p T.
///
/// The non-canonical version of a type may have many "decorated" versions of
/// types.  Decorators can include typedefs, 'typeof' operators, etc. The
/// returned type is guaranteed to be free of any of these, allowing two
/// canonical types to be compared for exact equality with a simple pointer
/// comparison.
CanQualType getCanonicalType(QualType T) const {
  return CanQualType::CreateUnsafe(T.getCanonicalType());
297
←
Calling 'QualType::getCanonicalType'→
354
←
Returning from 'QualType::getCanonicalType'→
415
←
Calling 'QualType::getCanonicalType'→
472
←
Returning from 'QualType::getCanonicalType'→
625
←
Calling 'QualType::getCanonicalType'→
682
←
Returning from 'QualType::getCanonicalType'→
743
←
Calling 'QualType::getCanonicalType'→
800
←
Returning from 'QualType::getCanonicalType'→
}

const Type *getCanonicalType(const Type *T) const {
  return T->getCanonicalTypeInternal().getTypePtr();
}

/// \brief Return the canonical parameter type corresponding to the specific
/// potentially non-canonical one.
///
/// Qualifiers are stripped off, functions are turned into function
/// pointers, and arrays decay one level into pointers.
CanQualType getCanonicalParamType(QualType T) const;

/// \brief Determine whether the given types \p T1 and \p T2 are equivalent.
bool hasSameType(QualType T1, QualType T2) const {
  return getCanonicalType(T1) == getCanonicalType(T2);
}
bool hasSameType(const Type *T1, const Type *T2) const {
  return getCanonicalType(T1) == getCanonicalType(T2);
}

/// \brief Return this type as a completely-unqualified array type,
/// capturing the qualifiers in \p Quals.
///
/// This will remove the minimal amount of sugaring from the types, similar
/// to the behavior of QualType::getUnqualifiedType().
///
/// \param T is the qualified type, which may be an ArrayType
///
/// \param Quals will receive the full set of qualifiers that were
/// applied to the array.
///
/// \returns if this is an array type, the completely unqualified array type
/// that corresponds to it. Otherwise, returns T.getUnqualifiedType().
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals);

/// \brief Determine whether the given types are equivalent after
/// cvr-qualifiers have been removed.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const {
  return getCanonicalType(T1).getTypePtr() ==
296
←
Calling 'ASTContext::getCanonicalType'→
355
←
Returning from 'ASTContext::getCanonicalType'→
356
←
Calling 'CanQual::getTypePtr'→
413
←
Returning from 'CanQual::getTypePtr'→
532
←
Assuming the condition is false→
624
←
Calling 'ASTContext::getCanonicalType'→
683
←
Returning from 'ASTContext::getCanonicalType'→
684
←
Calling 'CanQual::getTypePtr'→
741
←
Returning from 'CanQual::getTypePtr'→
860
←
Assuming the condition is true→
         getCanonicalType(T2).getTypePtr();
414
←
Calling 'ASTContext::getCanonicalType'→
473
←
Returning from 'ASTContext::getCanonicalType'→
474
←
Calling 'CanQual::getTypePtr'→
531
←
Returning from 'CanQual::getTypePtr'→
742
←
Calling 'ASTContext::getCanonicalType'→
801
←
Returning from 'ASTContext::getCanonicalType'→
802
←
Calling 'CanQual::getTypePtr'→
859
←
Returning from 'CanQual::getTypePtr'→
}

bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT,
                                     bool IsParam) const {
  auto SubTnullability = SubT->getNullability(*this);
  auto SuperTnullability = SuperT->getNullability(*this);
  if (SubTnullability.hasValue() == SuperTnullability.hasValue()) {
    // Neither has nullability; return true
    if (!SubTnullability)
      return true;
    // Both have nullability qualifier.
    if (*SubTnullability == *SuperTnullability ||
        *SubTnullability == NullabilityKind::Unspecified ||
        *SuperTnullability == NullabilityKind::Unspecified)
      return true;

    if (IsParam) {
      // Ok for the superclass method parameter to be "nonnull" and the subclass
      // method parameter to be "nullable"
      return (*SuperTnullability == NullabilityKind::NonNull &&
              *SubTnullability == NullabilityKind::Nullable);
    }
    else {
      // For the return type, it's okay for the superclass method to specify
      // "nullable" and the subclass method specify "nonnull"
      return (*SuperTnullability == NullabilityKind::Nullable &&
              *SubTnullability == NullabilityKind::NonNull);
    }
  }
  return true;
}

bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
                         const ObjCMethodDecl *MethodImp);

bool UnwrapSimilarPointerTypes(QualType &T1, QualType &T2);

/// \brief Retrieves the "canonical" nested name specifier for a
/// given nested name specifier.
///
/// The canonical nested name specifier is a nested name specifier
/// that uniquely identifies a type or namespace within the type
/// system. For example, given:
///
/// \code
/// namespace N {
///   struct S {
///     template<typename T> struct X { typename T* type; };
///   };
/// }
///
/// template<typename T> struct Y {
///   typename N::S::X<T>::type member;
/// };
/// \endcode
///
/// Here, the nested-name-specifier for N::S::X<T>:: will be
/// S::X<template-param-0-0>, since 'S' and 'X' are uniquely defined
/// by declarations in the type system and the canonical type for
/// the template type parameter 'T' is template-param-0-0.
NestedNameSpecifier *
getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const;

/// \brief Retrieves the default calling convention for the current target.
CallingConv getDefaultCallingConvention(bool IsVariadic,
                                        bool IsCXXMethod) const;

/// \brief Retrieves the "canonical" template name that refers to a
/// given template.
///
/// The canonical template name is the simplest expression that can
/// be used to refer to a given template. For most templates, this
/// expression is just the template declaration itself. For example,
/// the template std::vector can be referred to via a variety of
/// names---std::vector, \::std::vector, vector (if vector is in
/// scope), etc.---but all of these names map down to the same
/// TemplateDecl, which is used to form the canonical template name.
///
/// Dependent template names are more interesting. Here, the
/// template name could be something like T::template apply or
/// std::allocator<T>::template rebind, where the nested name
/// specifier itself is dependent. In this case, the canonical
/// template name uses the shortest form of the dependent
/// nested-name-specifier, which itself contains all canonical
/// types, values, and templates.
TemplateName getCanonicalTemplateName(TemplateName Name) const;

/// \brief Determine whether the given template names refer to the same
/// template.
bool hasSameTemplateName(TemplateName X, TemplateName Y);

/// \brief Retrieve the "canonical" template argument.
///
/// The canonical template argument is the simplest template argument
/// (which may be a type, value, expression, or declaration) that
/// expresses the value of the argument.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg)
  const;

/// Type Query functions.  If the type is an instance of the specified class,
/// return the Type pointer for the underlying maximally pretty type.  This
/// is a member of ASTContext because this may need to do some amount of
/// canonicalization, e.g. to move type qualifiers into the element type.
const ArrayType *getAsArrayType(QualType T) const;
const ConstantArrayType *getAsConstantArrayType(QualType T) const {
  return dyn_cast_or_null<ConstantArrayType>(getAsArrayType(T));
}
const VariableArrayType *getAsVariableArrayType(QualType T) const {
  return dyn_cast_or_null<VariableArrayType>(getAsArrayType(T));
}
const IncompleteArrayType *getAsIncompleteArrayType(QualType T) const {
  return dyn_cast_or_null<IncompleteArrayType>(getAsArrayType(T));
}
const DependentSizedArrayType *getAsDependentSizedArrayType(QualType T)
  const {
  return dyn_cast_or_null<DependentSizedArrayType>(getAsArrayType(T));
}

/// \brief Return the innermost element type of an array type.
///
/// For example, will return "int" for int[m][n]
QualType getBaseElementType(const ArrayType *VAT) const;

/// \brief Return the innermost element type of a type (which needn't
/// actually be an array type).
QualType getBaseElementType(QualType QT) const;

/// \brief Return number of constant array elements.
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const;

/// \brief Perform adjustment on the parameter type of a function.
///
/// This routine adjusts the given parameter type @p T to the actual
/// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
/// C++ [dcl.fct]p3). The adjusted parameter type is returned.
QualType getAdjustedParameterType(QualType T) const;

/// \brief Retrieve the parameter type as adjusted for use in the signature
/// of a function, decaying array and function types and removing top-level
/// cv-qualifiers.
QualType getSignatureParameterType(QualType T) const;

QualType getExceptionObjectType(QualType T) const;

/// \brief Return the properly qualified result of decaying the specified
/// array type to a pointer.
///
/// This operation is non-trivial when handling typedefs etc.  The canonical
/// type of \p T must be an array type, this returns a pointer to a properly
/// qualified element of the array.
///
/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
QualType getArrayDecayedType(QualType T) const;

/// \brief Return the type that \p PromotableType will promote to: C99
/// 6.3.1.1p2, assuming that \p PromotableType is a promotable integer type.
QualType getPromotedIntegerType(QualType PromotableType) const;

/// \brief Recurses in pointer/array types until it finds an Objective-C
/// retainable type and returns its ownership.
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const;

/// \brief Whether this is a promotable bitfield reference according
/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
///
/// \returns the type this bit-field will promote to, or NULL if no
/// promotion occurs.
QualType isPromotableBitField(Expr *E) const;

/// \brief Return the highest ranked integer type, see C99 6.3.1.8p1.
///
/// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
/// \p LHS < \p RHS, return -1.
int getIntegerTypeOrder(QualType LHS, QualType RHS) const;

/// \brief Compare the rank of the two specified floating point types,
/// ignoring the domain of the type (i.e. 'double' == '_Complex double').
///
/// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
/// \p LHS < \p RHS, return -1.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const;

/// \brief Return a real floating point or a complex type (based on
/// \p typeDomain/\p typeSize).
///
/// \param typeDomain a real floating point or complex type.
/// \param typeSize a real floating point or complex type.
QualType getFloatingTypeOfSizeWithinDomain(QualType typeSize,
                                           QualType typeDomain) const;

unsigned getTargetAddressSpace(QualType T) const {
  return getTargetAddressSpace(T.getQualifiers());
}

unsigned getTargetAddressSpace(Qualifiers Q) const {
  return getTargetAddressSpace(Q.getAddressSpace());
}

unsigned getTargetAddressSpace(LangAS AS) const;

/// Get target-dependent integer value for null pointer which is used for
/// constant folding.
uint64_t getTargetNullPointerValue(QualType QT) const;

bool addressSpaceMapManglingFor(LangAS AS) const {
  return AddrSpaceMapMangling || isTargetAddressSpace(AS);
}

2436private:
// Helper for integer ordering
unsigned getIntegerRank(const Type *T) const;

2440public:
//===--------------------------------------------------------------------===//
//                    Type Compatibility Predicates
//===--------------------------------------------------------------------===//

/// Compatibility predicates used to check assignment expressions.
bool typesAreCompatible(QualType T1, QualType T2,
                        bool CompareUnqualified = false); // C99 6.2.7p1

bool propertyTypesAreCompatible(QualType, QualType);
bool typesAreBlockPointerCompatible(QualType, QualType);

bool isObjCIdType(QualType T) const {
  return T == getObjCIdType();
}

bool isObjCClassType(QualType T) const {
  return T == getObjCClassType();
}

bool isObjCSelType(QualType T) const {
  return T == getObjCSelType();
}

bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
                                       bool ForCompare);

bool ObjCQualifiedClassTypesAreCompatible(QualType LHS, QualType RHS);

// Check the safety of assignment from LHS to RHS
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
                             const ObjCObjectPointerType *RHSOPT);
bool canAssignObjCInterfaces(const ObjCObjectType *LHS,
                             const ObjCObjectType *RHS);
bool canAssignObjCInterfacesInBlockPointer(
                                        const ObjCObjectPointerType *LHSOPT,
                                        const ObjCObjectPointerType *RHSOPT,
                                        bool BlockReturnType);
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS);
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT,
                                 const ObjCObjectPointerType *RHSOPT);
bool canBindObjCObjectType(QualType To, QualType From);

// Functions for calculating composite types
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false,
                    bool Unqualified = false, bool BlockReturnType = false);
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false,
                            bool Unqualified = false);
QualType mergeFunctionParameterTypes(QualType, QualType,
                                     bool OfBlockPointer = false,
                                     bool Unqualified = false);
QualType mergeTransparentUnionType(QualType, QualType,
                                   bool OfBlockPointer=false,
                                   bool Unqualified = false);

QualType mergeObjCGCQualifiers(QualType, QualType);

/// This function merges the ExtParameterInfo lists of two functions. It
/// returns true if the lists are compatible. The merged list is returned in
/// NewParamInfos.
///
/// \param FirstFnType The type of the first function.
///
/// \param SecondFnType The type of the second function.
///
/// \param CanUseFirst This flag is set to true if the first function's
/// ExtParameterInfo list can be used as the composite list of
/// ExtParameterInfo.
///
/// \param CanUseSecond This flag is set to true if the second function's
/// ExtParameterInfo list can be used as the composite list of
/// ExtParameterInfo.
///
/// \param NewParamInfos The composite list of ExtParameterInfo. The list is
/// empty if none of the flags are set.
///
bool mergeExtParameterInfo(
    const FunctionProtoType *FirstFnType,
    const FunctionProtoType *SecondFnType,
    bool &CanUseFirst, bool &CanUseSecond,
    SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &NewParamInfos);

void ResetObjCLayout(const ObjCContainerDecl *CD);

//===--------------------------------------------------------------------===//
//                    Integer Predicates
//===--------------------------------------------------------------------===//

// The width of an integer, as defined in C99 6.2.6.2. This is the number
// of bits in an integer type excluding any padding bits.
unsigned getIntWidth(QualType T) const;

// Per C99 6.2.5p6, for every signed integer type, there is a corresponding
// unsigned integer type.  This method takes a signed type, and returns the
// corresponding unsigned integer type.
QualType getCorrespondingUnsignedType(QualType T) const;

//===--------------------------------------------------------------------===//
//                    Integer Values
//===--------------------------------------------------------------------===//

/// \brief Make an APSInt of the appropriate width and signedness for the
/// given \p Value and integer \p Type.
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const {
  // If Type is a signed integer type larger than 64 bits, we need to be sure
  // to sign extend Res appropriately.
  llvm::APSInt Res(64, !Type->isSignedIntegerOrEnumerationType());
  Res = Value;
  unsigned Width = getIntWidth(Type);
  if (Width != Res.getBitWidth())
    return Res.extOrTrunc(Width);
  return Res;
}

bool isSentinelNullExpr(const Expr *E);

/// \brief Get the implementation of the ObjCInterfaceDecl \p D, or nullptr if
/// none exists.
ObjCImplementationDecl *getObjCImplementation(ObjCInterfaceDecl *D);

/// \brief Get the implementation of the ObjCCategoryDecl \p D, or nullptr if
/// none exists.
ObjCCategoryImplDecl *getObjCImplementation(ObjCCategoryDecl *D);

/// \brief Return true if there is at least one \@implementation in the TU.
bool AnyObjCImplementation() {
  return !ObjCImpls.empty();
}

/// \brief Set the implementation of ObjCInterfaceDecl.
void setObjCImplementation(ObjCInterfaceDecl *IFaceD,
                           ObjCImplementationDecl *ImplD);

/// \brief Set the implementation of ObjCCategoryDecl.
void setObjCImplementation(ObjCCategoryDecl *CatD,
                           ObjCCategoryImplDecl *ImplD);

/// \brief Get the duplicate declaration of a ObjCMethod in the same
/// interface, or null if none exists.
const ObjCMethodDecl *
getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const;

void setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
                                const ObjCMethodDecl *Redecl);

/// \brief Returns the Objective-C interface that \p ND belongs to if it is
/// an Objective-C method/property/ivar etc. that is part of an interface,
/// otherwise returns null.
const ObjCInterfaceDecl *getObjContainingInterface(const NamedDecl *ND) const;

/// \brief Set the copy inialization expression of a block var decl.
void setBlockVarCopyInits(VarDecl*VD, Expr* Init);

/// \brief Get the copy initialization expression of the VarDecl \p VD, or
/// nullptr if none exists.
Expr *getBlockVarCopyInits(const VarDecl* VD);

/// \brief Allocate an uninitialized TypeSourceInfo.
///
/// The caller should initialize the memory held by TypeSourceInfo using
/// the TypeLoc wrappers.
///
/// \param T the type that will be the basis for type source info. This type
/// should refer to how the declarator was written in source code, not to
/// what type semantic analysis resolved the declarator to.
///
/// \param Size the size of the type info to create, or 0 if the size
/// should be calculated based on the type.
TypeSourceInfo *CreateTypeSourceInfo(QualType T, unsigned Size = 0) const;

/// \brief Allocate a TypeSourceInfo where all locations have been
/// initialized to a given location, which defaults to the empty
/// location.
TypeSourceInfo *
getTrivialTypeSourceInfo(QualType T,
                         SourceLocation Loc = SourceLocation()) const;

/// \brief Add a deallocation callback that will be invoked when the
/// ASTContext is destroyed.
///
/// \param Callback A callback function that will be invoked on destruction.
///
/// \param Data Pointer data that will be provided to the callback function
/// when it is called.
void AddDeallocation(void (*Callback)(void*), void *Data);

/// If T isn't trivially destructible, calls AddDeallocation to register it
/// for destruction.
template <typename T>
void addDestruction(T *Ptr) {
  if (!std::is_trivially_destructible<T>::value) {
    auto DestroyPtr = [](void *V) { static_cast<T *>(V)->~T(); };
    AddDeallocation(DestroyPtr, Ptr);
  }
}

GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const;
GVALinkage GetGVALinkageForVariable(const VarDecl *VD);

/// \brief Determines if the decl can be CodeGen'ed or deserialized from PCH
/// lazily, only when used; this is only relevant for function or file scoped
/// var definitions.
///
/// \returns true if the function/var must be CodeGen'ed/deserialized even if
/// it is not used.
bool DeclMustBeEmitted(const Decl *D);

/// \brief Visits all versions of a multiversioned function with the passed
/// predicate.
void forEachMultiversionedFunctionVersion(
    const FunctionDecl *FD,
    llvm::function_ref<void(const FunctionDecl *)> Pred) const;

const CXXConstructorDecl *
getCopyConstructorForExceptionObject(CXXRecordDecl *RD);

void addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
                                          CXXConstructorDecl *CD);

void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND);

TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD);

void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD);

DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD);

void setManglingNumber(const NamedDecl *ND, unsigned Number);
unsigned getManglingNumber(const NamedDecl *ND) const;

void setStaticLocalNumber(const VarDecl *VD, unsigned Number);
unsigned getStaticLocalNumber(const VarDecl *VD) const;

/// \brief Retrieve the context for computing mangling numbers in the given
/// DeclContext.
MangleNumberingContext &getManglingNumberContext(const DeclContext *DC);

std::unique_ptr<MangleNumberingContext> createMangleNumberingContext() const;

/// \brief Used by ParmVarDecl to store on the side the
/// index of the parameter when it exceeds the size of the normal bitfield.
void setParameterIndex(const ParmVarDecl *D, unsigned index);

/// \brief Used by ParmVarDecl to retrieve on the side the
/// index of the parameter when it exceeds the size of the normal bitfield.
unsigned getParameterIndex(const ParmVarDecl *D) const;

/// \brief Get the storage for the constant value of a materialized temporary
/// of static storage duration.
APValue *getMaterializedTemporaryValue(const MaterializeTemporaryExpr *E,
                                       bool MayCreate);

//===--------------------------------------------------------------------===//
//                    Statistics
//===--------------------------------------------------------------------===//

/// \brief The number of implicitly-declared default constructors.
static unsigned NumImplicitDefaultConstructors;

/// \brief The number of implicitly-declared default constructors for
/// which declarations were built.
static unsigned NumImplicitDefaultConstructorsDeclared;

/// \brief The number of implicitly-declared copy constructors.
static unsigned NumImplicitCopyConstructors;

/// \brief The number of implicitly-declared copy constructors for
/// which declarations were built.
static unsigned NumImplicitCopyConstructorsDeclared;

/// \brief The number of implicitly-declared move constructors.
static unsigned NumImplicitMoveConstructors;

/// \brief The number of implicitly-declared move constructors for
/// which declarations were built.
static unsigned NumImplicitMoveConstructorsDeclared;

/// \brief The number of implicitly-declared copy assignment operators.
static unsigned NumImplicitCopyAssignmentOperators;

/// \brief The number of implicitly-declared copy assignment operators for
/// which declarations were built.
static unsigned NumImplicitCopyAssignmentOperatorsDeclared;

/// \brief The number of implicitly-declared move assignment operators.
static unsigned NumImplicitMoveAssignmentOperators;

/// \brief The number of implicitly-declared move assignment operators for
/// which declarations were built.
static unsigned NumImplicitMoveAssignmentOperatorsDeclared;

/// \brief The number of implicitly-declared destructors.
static unsigned NumImplicitDestructors;

/// \brief The number of implicitly-declared destructors for which
/// declarations were built.
static unsigned NumImplicitDestructorsDeclared;

2738public:
/// \brief Initialize built-in types.
///
/// This routine may only be invoked once for a given ASTContext object.
/// It is normally invoked after ASTContext construction.
///
/// \param Target The target
void InitBuiltinTypes(const TargetInfo &Target,
                      const TargetInfo *AuxTarget = nullptr);

2748private:
void InitBuiltinType(CanQualType &R, BuiltinType::Kind K);

// Return the Objective-C type encoding for a given type.
void getObjCEncodingForTypeImpl(QualType t, std::string &S,
                                bool ExpandPointedToStructures,
                                bool ExpandStructures,
                                const FieldDecl *Field,
                                bool OutermostType = false,
                                bool EncodingProperty = false,
                                bool StructField = false,
                                bool EncodeBlockParameters = false,
                                bool EncodeClassNames = false,
                                bool EncodePointerToObjCTypedef = false,
                                QualType *NotEncodedT=nullptr) const;

// Adds the encoding of the structure's members.
void getObjCEncodingForStructureImpl(RecordDecl *RD, std::string &S,
                                     const FieldDecl *Field,
                                     bool includeVBases = true,
                                     QualType *NotEncodedT=nullptr) const;

2770public:
// Adds the encoding of a method parameter or return type.
void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT,
                                       QualType T, std::string& S,
                                       bool Extended) const;

/// \brief Returns true if this is an inline-initialized static data member
/// which is treated as a definition for MSVC compatibility.
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const;

enum class InlineVariableDefinitionKind {
  /// Not an inline variable.
  None,

  /// Weak definition of inline variable.
  Weak,

  /// Weak for now, might become strong later in this TU.
  WeakUnknown,

  /// Strong definition.
  Strong
};

/// \brief Determine whether a definition of this inline variable should
/// be treated as a weak or strong definition. For compatibility with
/// C++14 and before, for a constexpr static data member, if there is an
/// out-of-line declaration of the member, we may promote it from weak to
/// strong.
InlineVariableDefinitionKind
getInlineVariableDefinitionKind(const VarDecl *VD) const;

2802private:
friend class DeclarationNameTable;
friend class DeclContext;

const ASTRecordLayout &
getObjCLayout(const ObjCInterfaceDecl *D,
              const ObjCImplementationDecl *Impl) const;

/// \brief A set of deallocations that should be performed when the
/// ASTContext is destroyed.
// FIXME: We really should have a better mechanism in the ASTContext to
// manage running destructors for types which do variable sized allocation
// within the AST. In some places we thread the AST bump pointer allocator
// into the datastructures which avoids this mess during deallocation but is
// wasteful of memory, and here we require a lot of error prone book keeping
// in order to track and run destructors while we're tearing things down.
using DeallocationFunctionsAndArguments =
    llvm::SmallVector<std::pair<void (*)(void *), void *>, 16>;
DeallocationFunctionsAndArguments Deallocations;

// FIXME: This currently contains the set of StoredDeclMaps used
// by DeclContext objects.  This probably should not be in ASTContext,
// but we include it here so that ASTContext can quickly deallocate them.
llvm::PointerIntPair<StoredDeclsMap *, 1> LastSDM;

std::unique_ptr<ParentMapPointers> PointerParents;
std::unique_ptr<ParentMapOtherNodes> OtherParents;

std::unique_ptr<VTableContextBase> VTContext;

void ReleaseDeclContextMaps();
void ReleaseParentMapEntries();

2835public:
enum PragmaSectionFlag : unsigned {
  PSF_None = 0,
  PSF_Read = 0x1,
  PSF_Write = 0x2,
  PSF_Execute = 0x4,
  PSF_Implicit = 0x8,
  PSF_Invalid = 0x80000000U,
};

struct SectionInfo {
  DeclaratorDecl *Decl;
  SourceLocation PragmaSectionLocation;
  int SectionFlags;

  SectionInfo() = default;
  SectionInfo(DeclaratorDecl *Decl,
              SourceLocation PragmaSectionLocation,
              int SectionFlags)
      : Decl(Decl), PragmaSectionLocation(PragmaSectionLocation),
        SectionFlags(SectionFlags) {}
};

llvm::StringMap<SectionInfo> SectionInfos;
2859};

2861/// \brief Utility function for constructing a nullary selector.
2862inline Selector GetNullarySelector(StringRef name, ASTContext &Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(0, &II);
2865}

2867/// \brief Utility function for constructing an unary selector.
2868inline Selector GetUnarySelector(StringRef name, ASTContext &Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(1, &II);
2871}

2873} // namespace clang

2875// operator new and delete aren't allowed inside namespaces.

2877/// @brief Placement new for using the ASTContext's allocator.
2878///
2879/// This placement form of operator new uses the ASTContext's allocator for
2880/// obtaining memory.
2881///
2882/// IMPORTANT: These are also declared in clang/AST/AttrIterator.h! Any changes
2883/// here need to also be made there.
2884///
2885/// We intentionally avoid using a nothrow specification here so that the calls
2886/// to this operator will not perform a null check on the result -- the
2887/// underlying allocator never returns null pointers.
2888///
2889/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
2890/// @code
2891/// // Default alignment (8)
2892/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
2893/// // Specific alignment
2894/// IntegerLiteral *Ex2 = new (Context, 4) IntegerLiteral(arguments);
2895/// @endcode
2896/// Memory allocated through this placement new operator does not need to be
2897/// explicitly freed, as ASTContext will free all of this memory when it gets
2898/// destroyed. Please note that you cannot use delete on the pointer.
2899///
2900/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
2901/// @param C The ASTContext that provides the allocator.
2902/// @param Alignment The alignment of the allocated memory (if the underlying
2903///                  allocator supports it).
2904/// @return The allocated memory. Could be nullptr.
2905inline void *operator new(size_t Bytes, const clang::ASTContext &C,
                        size_t Alignment) {
return C.Allocate(Bytes, Alignment);
2908}

2910/// @brief Placement delete companion to the new above.
2911///
2912/// This operator is just a companion to the new above. There is no way of
2913/// invoking it directly; see the new operator for more details. This operator
2914/// is called implicitly by the compiler if a placement new expression using
2915/// the ASTContext throws in the object constructor.
2916inline void operator delete(void *Ptr, const clang::ASTContext &C, size_t) {
C.Deallocate(Ptr);
2918}

2920/// This placement form of operator new[] uses the ASTContext's allocator for
2921/// obtaining memory.
2922///
2923/// We intentionally avoid using a nothrow specification here so that the calls
2924/// to this operator will not perform a null check on the result -- the
2925/// underlying allocator never returns null pointers.
2926///
2927/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
2928/// @code
2929/// // Default alignment (8)
2930/// char *data = new (Context) char[10];
2931/// // Specific alignment
2932/// char *data = new (Context, 4) char[10];
2933/// @endcode
2934/// Memory allocated through this placement new[] operator does not need to be
2935/// explicitly freed, as ASTContext will free all of this memory when it gets
2936/// destroyed. Please note that you cannot use delete on the pointer.
2937///
2938/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
2939/// @param C The ASTContext that provides the allocator.
2940/// @param Alignment The alignment of the allocated memory (if the underlying
2941///                  allocator supports it).
2942/// @return The allocated memory. Could be nullptr.
2943inline void *operator new[](size_t Bytes, const clang::ASTContext& C,
                          size_t Alignment = 8) {
return C.Allocate(Bytes, Alignment);
2946}

2948/// @brief Placement delete[] companion to the new[] above.
2949///
2950/// This operator is just a companion to the new[] above. There is no way of
2951/// invoking it directly; see the new[] operator for more details. This operator
2952/// is called implicitly by the compiler if a placement new[] expression using
2953/// the ASTContext throws in the object constructor.
2954inline void operator delete[](void *Ptr, const clang::ASTContext &C, size_t) {
C.Deallocate(Ptr);
2956}

2958/// \brief Create the representation of a LazyGenerationalUpdatePtr.
2959template <typename Owner, typename T,
        void (clang::ExternalASTSource::*Update)(Owner)>
2961typename clang::LazyGenerationalUpdatePtr<Owner, T, Update>::ValueType
  clang::LazyGenerationalUpdatePtr<Owner, T, Update>::makeValue(
      const clang::ASTContext &Ctx, T Value) {
// Note, this is implemented here so that ExternalASTSource.h doesn't need to
// include ASTContext.h. We explicitly instantiate it for all relevant types
// in ASTContext.cpp.
if (auto *Source = Ctx.getExternalSource())
  return new (Ctx) LazyData(Source, Value);
return Value;
2970}

2972#endif // LLVM_CLANG_AST_ASTCONTEXT_H

←

/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/CanonicalType.h

1//===- CanonicalType.h - C Language Family Type Representation --*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file defines the CanQual class template, which provides access to
11//  canonical types.
12//
13//===----------------------------------------------------------------------===//
14 
15#ifndef LLVM_CLANG_AST_CANONICALTYPE_H
16#define LLVM_CLANG_AST_CANONICALTYPE_H
17 
18#include "clang/AST/Type.h"
19#include "clang/Basic/Diagnostic.h"
20#include "clang/Basic/SourceLocation.h"
21#include "llvm/ADT/ArrayRef.h"
22#include "llvm/ADT/FoldingSet.h"
23#include "llvm/ADT/iterator.h"
24#include "llvm/Support/Casting.h"
25#include "llvm/Support/PointerLikeTypeTraits.h"
26#include <cassert>
27#include <iterator>
28#include <type_traits>
29 
30namespace clang {
31 
32template<typename T> class CanProxy;
33template<typename T> struct CanProxyAdaptor;
34class CXXRecordDecl;
35class EnumDecl;
36class Expr;
37class IdentifierInfo;
38class ObjCInterfaceDecl;
39class RecordDecl;
40class TagDecl;
41class TemplateTypeParmDecl;
42 
43//----------------------------------------------------------------------------//
44// Canonical, qualified type template
45//----------------------------------------------------------------------------//
46 
47/// \brief Represents a canonical, potentially-qualified type.
48///
49/// The CanQual template is a lightweight smart pointer that provides access
50/// to the canonical representation of a type, where all typedefs and other
51/// syntactic sugar has been eliminated. A CanQualType may also have various
52/// qualifiers (const, volatile, restrict) attached to it.
53///
54/// The template type parameter @p T is one of the Type classes (PointerType,
55/// BuiltinType, etc.). The type stored within @c CanQual<T> will be of that
56/// type (or some subclass of that type). The typedef @c CanQualType is just
57/// a shorthand for @c CanQual<Type>.
58///
59/// An instance of @c CanQual<T> can be implicitly converted to a
60/// @c CanQual<U> when T is derived from U, which essentially provides an
61/// implicit upcast. For example, @c CanQual<LValueReferenceType> can be
62/// converted to @c CanQual<ReferenceType>. Note that any @c CanQual type can
63/// be implicitly converted to a QualType, but the reverse operation requires
64/// a call to ASTContext::getCanonicalType().
65template<typename T = Type>
66class CanQual {
67  /// \brief The actual, canonical type.
68  QualType Stored;
69 
70public:
71  /// \brief Constructs a NULL canonical type.
72  CanQual() = default;
73 
74  /// \brief Converting constructor that permits implicit upcasting of
75  /// canonical type pointers.
76  template <typename U>
77  CanQual(const CanQual<U> &Other,
78          typename std::enable_if<std::is_base_of<T, U>::value, int>::type = 0);
79 
80  /// \brief Retrieve the underlying type pointer, which refers to a
81  /// canonical type.
82  ///
83  /// The underlying pointer must not be nullptr.
84  const T *getTypePtr() const { return cast<T>(Stored.getTypePtr()); }
357
←
Calling 'QualType::getTypePtr'→
394
←
Returning from 'QualType::getTypePtr'→
395
←
Calling 'cast'→
412
←
Returning from 'cast'→
475
←
Calling 'QualType::getTypePtr'→
512
←
Returning from 'QualType::getTypePtr'→
513
←
Calling 'cast'→
530
←
Returning from 'cast'→
685
←
Calling 'QualType::getTypePtr'→
722
←
Returning from 'QualType::getTypePtr'→
723
←
Calling 'cast'→
740
←
Returning from 'cast'→
803
←
Calling 'QualType::getTypePtr'→
840
←
Returning from 'QualType::getTypePtr'→
841
←
Calling 'cast'→
858
←
Returning from 'cast'→
85 
86  /// \brief Retrieve the underlying type pointer, which refers to a
87  /// canonical type, or nullptr.
88  const T *getTypePtrOrNull() const { 
89    return cast_or_null<T>(Stored.getTypePtrOrNull()); 
90  }
91 
92  /// \brief Implicit conversion to a qualified type.
93  operator QualType() const { return Stored; }
94 
95  /// \brief Implicit conversion to bool.
96  explicit operator bool() const { return !isNull(); }
97  
98  bool isNull() const {
99    return Stored.isNull();
100  }
101 
102  SplitQualType split() const { return Stored.split(); }
103 
104  /// \brief Retrieve a canonical type pointer with a different static type,
105  /// upcasting or downcasting as needed.
106  ///
107  /// The getAs() function is typically used to try to downcast to a
108  /// more specific (canonical) type in the type system. For example:
109  ///
110  /// @code
111  /// void f(CanQual<Type> T) {
112  ///   if (CanQual<PointerType> Ptr = T->getAs<PointerType>()) {
113  ///     // look at Ptr's pointee type
114  ///   }
115  /// }
116  /// @endcode
117  ///
118  /// \returns A proxy pointer to the same type, but with the specified
119  /// static type (@p U). If the dynamic type is not the specified static type
120  /// or a derived class thereof, a NULL canonical type.
121  template<typename U> CanProxy<U> getAs() const;
122 
123  template<typename U> CanProxy<U> castAs() const;
124 
125  /// \brief Overloaded arrow operator that produces a canonical type
126  /// proxy.
127  CanProxy<T> operator->() const;
128 
129  /// \brief Retrieve all qualifiers.
130  Qualifiers getQualifiers() const { return Stored.getLocalQualifiers(); }
131 
132  /// \brief Retrieve the const/volatile/restrict qualifiers.
133  unsigned getCVRQualifiers() const { return Stored.getLocalCVRQualifiers(); }
134 
135  /// \brief Determines whether this type has any qualifiers
136  bool hasQualifiers() const { return Stored.hasLocalQualifiers(); }
137 
138  bool isConstQualified() const {
139    return Stored.isLocalConstQualified();
140  }
141 
142  bool isVolatileQualified() const {
143    return Stored.isLocalVolatileQualified();
144  }
145 
146  bool isRestrictQualified() const {
147    return Stored.isLocalRestrictQualified();
148  }
149 
150  /// \brief Determines if this canonical type is furthermore
151  /// canonical as a parameter.  The parameter-canonicalization
152  /// process decays arrays to pointers and drops top-level qualifiers.
153  bool isCanonicalAsParam() const {
154    return Stored.isCanonicalAsParam();
155  }
156 
157  /// \brief Retrieve the unqualified form of this type.
158  CanQual<T> getUnqualifiedType() const;
159 
160  /// \brief Retrieves a version of this type with const applied.
161  /// Note that this does not always yield a canonical type.
162  QualType withConst() const {
163    return Stored.withConst();
164  }
165 
166  /// \brief Determines whether this canonical type is more qualified than
167  /// the @p Other canonical type.
168  bool isMoreQualifiedThan(CanQual<T> Other) const {
169    return Stored.isMoreQualifiedThan(Other.Stored);
170  }
171 
172  /// \brief Determines whether this canonical type is at least as qualified as
173  /// the @p Other canonical type.
174  bool isAtLeastAsQualifiedAs(CanQual<T> Other) const {
175    return Stored.isAtLeastAsQualifiedAs(Other.Stored);
176  }
177 
178  /// \brief If the canonical type is a reference type, returns the type that
179  /// it refers to; otherwise, returns the type itself.
180  CanQual<Type> getNonReferenceType() const;
181 
182  /// \brief Retrieve the internal representation of this canonical type.
183  void *getAsOpaquePtr() const { return Stored.getAsOpaquePtr(); }
184 
185  /// \brief Construct a canonical type from its internal representation.
186  static CanQual<T> getFromOpaquePtr(void *Ptr);
187 
188  /// \brief Builds a canonical type from a QualType.
189  ///
190  /// This routine is inherently unsafe, because it requires the user to
191  /// ensure that the given type is a canonical type with the correct
192  // (dynamic) type.
193  static CanQual<T> CreateUnsafe(QualType Other);
194 
195  void dump() const { Stored.dump(); }
196 
197  void Profile(llvm::FoldingSetNodeID &ID) const {
198    ID.AddPointer(getAsOpaquePtr());
199  }
200};
201 
202template<typename T, typename U>
203inline bool operator==(CanQual<T> x, CanQual<U> y) {
204  return x.getAsOpaquePtr() == y.getAsOpaquePtr();
205}
206 
207template<typename T, typename U>
208inline bool operator!=(CanQual<T> x, CanQual<U> y) {
209  return x.getAsOpaquePtr() != y.getAsOpaquePtr();
210}
211 
212/// \brief Represents a canonical, potentially-qualified type.
213using CanQualType = CanQual<Type>;
214 
215inline CanQualType Type::getCanonicalTypeUnqualified() const {
216  return CanQualType::CreateUnsafe(getCanonicalTypeInternal());
217}
218 
219inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
220                                           CanQualType T) {
221  DB << static_cast<QualType>(T);
222  return DB;
223}
224 
225//----------------------------------------------------------------------------//
226// Internal proxy classes used by canonical types
227//----------------------------------------------------------------------------//
228 
229#define LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(Accessor)CanQualType Accessor() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->Accessor()); }                    \
230CanQualType Accessor() const {                                           \
231return CanQualType::CreateUnsafe(this->getTypePtr()->Accessor());      \
232}
233 
234#define LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Type, Accessor)Type Accessor() const { return this->getTypePtr()->Accessor
(); }             \
235Type Accessor() const { return this->getTypePtr()->Accessor(); }
236 
237/// \brief Base class of all canonical proxy types, which is responsible for
238/// storing the underlying canonical type and providing basic conversions.
239template<typename T>
240class CanProxyBase {
241protected:
242  CanQual<T> Stored;
243 
244public:
245  /// \brief Retrieve the pointer to the underlying Type
246  const T *getTypePtr() const { return Stored.getTypePtr(); }
247 
248  /// \brief Implicit conversion to the underlying pointer.
249  ///
250  /// Also provides the ability to use canonical type proxies in a Boolean
251  // context,e.g.,
252  /// @code
253  ///   if (CanQual<PointerType> Ptr = T->getAs<PointerType>()) { ... }
254  /// @endcode
255  operator const T*() const { return this->Stored.getTypePtrOrNull(); }
256 
257  /// \brief Try to convert the given canonical type to a specific structural
258  /// type.
259  template<typename U> CanProxy<U> getAs() const {
260    return this->Stored.template getAs<U>();
261  }
262 
263  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Type::TypeClass, getTypeClass)Type::TypeClass getTypeClass() const { return this->getTypePtr
()->getTypeClass(); }
264 
265  // Type predicates
266  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjectType)bool isObjectType() const { return this->getTypePtr()->
isObjectType(); }
267  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteType)bool isIncompleteType() const { return this->getTypePtr()->
isIncompleteType(); }
268  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteOrObjectType)bool isIncompleteOrObjectType() const { return this->getTypePtr
()->isIncompleteOrObjectType(); }
269  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVariablyModifiedType)bool isVariablyModifiedType() const { return this->getTypePtr
()->isVariablyModifiedType(); }
270  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegerType)bool isIntegerType() const { return this->getTypePtr()->
isIntegerType(); }
271  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isEnumeralType)bool isEnumeralType() const { return this->getTypePtr()->
isEnumeralType(); }
272  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBooleanType)bool isBooleanType() const { return this->getTypePtr()->
isBooleanType(); }
273  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isCharType)bool isCharType() const { return this->getTypePtr()->isCharType
(); }
274  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isWideCharType)bool isWideCharType() const { return this->getTypePtr()->
isWideCharType(); }
275  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegralType)bool isIntegralType() const { return this->getTypePtr()->
isIntegralType(); }
276  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegralOrEnumerationType)bool isIntegralOrEnumerationType() const { return this->getTypePtr
()->isIntegralOrEnumerationType(); }
277  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isRealFloatingType)bool isRealFloatingType() const { return this->getTypePtr(
)->isRealFloatingType(); }
278  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isComplexType)bool isComplexType() const { return this->getTypePtr()->
isComplexType(); }
279  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isAnyComplexType)bool isAnyComplexType() const { return this->getTypePtr()->
isAnyComplexType(); }
280  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isFloatingType)bool isFloatingType() const { return this->getTypePtr()->
isFloatingType(); }
281  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isRealType)bool isRealType() const { return this->getTypePtr()->isRealType
(); }
282  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isArithmeticType)bool isArithmeticType() const { return this->getTypePtr()->
isArithmeticType(); }
283  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVoidType)bool isVoidType() const { return this->getTypePtr()->isVoidType
(); }
284  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isDerivedType)bool isDerivedType() const { return this->getTypePtr()->
isDerivedType(); }
285  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isScalarType)bool isScalarType() const { return this->getTypePtr()->
isScalarType(); }
286  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isAggregateType)bool isAggregateType() const { return this->getTypePtr()->
isAggregateType(); }
287  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isAnyPointerType)bool isAnyPointerType() const { return this->getTypePtr()->
isAnyPointerType(); }
288  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVoidPointerType)bool isVoidPointerType() const { return this->getTypePtr()
->isVoidPointerType(); }
289  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isFunctionPointerType)bool isFunctionPointerType() const { return this->getTypePtr
()->isFunctionPointerType(); }
290  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isMemberFunctionPointerType)bool isMemberFunctionPointerType() const { return this->getTypePtr
()->isMemberFunctionPointerType(); }
291  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isClassType)bool isClassType() const { return this->getTypePtr()->isClassType
(); }
292  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isStructureType)bool isStructureType() const { return this->getTypePtr()->
isStructureType(); }
293  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isInterfaceType)bool isInterfaceType() const { return this->getTypePtr()->
isInterfaceType(); }
294  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isStructureOrClassType)bool isStructureOrClassType() const { return this->getTypePtr
()->isStructureOrClassType(); }
295  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isUnionType)bool isUnionType() const { return this->getTypePtr()->isUnionType
(); }
296  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isComplexIntegerType)bool isComplexIntegerType() const { return this->getTypePtr
()->isComplexIntegerType(); }
297  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isNullPtrType)bool isNullPtrType() const { return this->getTypePtr()->
isNullPtrType(); }
298  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isDependentType)bool isDependentType() const { return this->getTypePtr()->
isDependentType(); }
299  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isOverloadableType)bool isOverloadableType() const { return this->getTypePtr(
)->isOverloadableType(); }
300  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isArrayType)bool isArrayType() const { return this->getTypePtr()->isArrayType
(); }
301  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasPointerRepresentation)bool hasPointerRepresentation() const { return this->getTypePtr
()->hasPointerRepresentation(); }
302  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasObjCPointerRepresentation)bool hasObjCPointerRepresentation() const { return this->getTypePtr
()->hasObjCPointerRepresentation(); }
303  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasIntegerRepresentation)bool hasIntegerRepresentation() const { return this->getTypePtr
()->hasIntegerRepresentation(); }
304  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasSignedIntegerRepresentation)bool hasSignedIntegerRepresentation() const { return this->
getTypePtr()->hasSignedIntegerRepresentation(); }
305  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasUnsignedIntegerRepresentation)bool hasUnsignedIntegerRepresentation() const { return this->
getTypePtr()->hasUnsignedIntegerRepresentation(); }
306  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasFloatingRepresentation)bool hasFloatingRepresentation() const { return this->getTypePtr
()->hasFloatingRepresentation(); }
307  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isPromotableIntegerType)bool isPromotableIntegerType() const { return this->getTypePtr
()->isPromotableIntegerType(); }
308  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSignedIntegerType)bool isSignedIntegerType() const { return this->getTypePtr
()->isSignedIntegerType(); }
309  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isUnsignedIntegerType)bool isUnsignedIntegerType() const { return this->getTypePtr
()->isUnsignedIntegerType(); }
310  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSignedIntegerOrEnumerationType)bool isSignedIntegerOrEnumerationType() const { return this->
getTypePtr()->isSignedIntegerOrEnumerationType(); }
311  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isUnsignedIntegerOrEnumerationType)bool isUnsignedIntegerOrEnumerationType() const { return this
->getTypePtr()->isUnsignedIntegerOrEnumerationType(); }
312  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isConstantSizeType)bool isConstantSizeType() const { return this->getTypePtr(
)->isConstantSizeType(); }
313  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSpecifierType)bool isSpecifierType() const { return this->getTypePtr()->
isSpecifierType(); }
314  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(CXXRecordDecl*, getAsCXXRecordDecl)CXXRecordDecl* getAsCXXRecordDecl() const { return this->getTypePtr
()->getAsCXXRecordDecl(); }
315 
316  /// \brief Retrieve the proxy-adaptor type.
317  ///
318  /// This arrow operator is used when CanProxyAdaptor has been specialized
319  /// for the given type T. In that case, we reference members of the
320  /// CanProxyAdaptor specialization. Otherwise, this operator will be hidden
321  /// by the arrow operator in the primary CanProxyAdaptor template.
322  const CanProxyAdaptor<T> *operator->() const {
323    return static_cast<const CanProxyAdaptor<T> *>(this);
324  }
325};
326 
327/// \brief Replacable canonical proxy adaptor class that provides the link
328/// between a canonical type and the accessors of the type.
329///
330/// The CanProxyAdaptor is a replaceable class template that is instantiated
331/// as part of each canonical proxy type. The primary template merely provides
332/// redirection to the underlying type (T), e.g., @c PointerType. One can
333/// provide specializations of this class template for each underlying type
334/// that provide accessors returning canonical types (@c CanQualType) rather
335/// than the more typical @c QualType, to propagate the notion of "canonical"
336/// through the system.
337template<typename T>
338struct CanProxyAdaptor : CanProxyBase<T> {};
339 
340/// \brief Canonical proxy type returned when retrieving the members of a
341/// canonical type or as the result of the @c CanQual<T>::getAs member
342/// function.
343///
344/// The CanProxy type mainly exists as a proxy through which operator-> will
345/// look to either map down to a raw T* (e.g., PointerType*) or to a proxy
346/// type that provides canonical-type access to the fields of the type.
347template<typename T>
348class CanProxy : public CanProxyAdaptor<T> {
349public:
350  /// \brief Build a NULL proxy.
351  CanProxy() = default;
352 
353  /// \brief Build a proxy to the given canonical type.
354  CanProxy(CanQual<T> Stored) { this->Stored = Stored; }
355 
356  /// \brief Implicit conversion to the stored canonical type.
357  operator CanQual<T>() const { return this->Stored; }
358};
359 
360} // namespace clang
361 
362namespace llvm {
363 
364/// Implement simplify_type for CanQual<T>, so that we can dyn_cast from
365/// CanQual<T> to a specific Type class. We're prefer isa/dyn_cast/cast/etc.
366/// to return smart pointer (proxies?).
367template<typename T>
368struct simplify_type< ::clang::CanQual<T>> {
369  using SimpleType = const T *;
370 
371  static SimpleType getSimplifiedValue(::clang::CanQual<T> Val) {
372    return Val.getTypePtr();
373  }
374};
375 
376// Teach SmallPtrSet that CanQual<T> is "basically a pointer".
377template<typename T>
378struct PointerLikeTypeTraits<clang::CanQual<T>> {
379  static void *getAsVoidPointer(clang::CanQual<T> P) {
380    return P.getAsOpaquePtr();
381  }
382 
383  static clang::CanQual<T> getFromVoidPointer(void *P) {
384    return clang::CanQual<T>::getFromOpaquePtr(P);
385  }
386 
387  // qualifier information is encoded in the low bits.
388  enum { NumLowBitsAvailable = 0 };
389};
390 
391} // namespace llvm
392 
393namespace clang {
394 
395//----------------------------------------------------------------------------//
396// Canonical proxy adaptors for canonical type nodes.
397//----------------------------------------------------------------------------//
398 
399/// \brief Iterator adaptor that turns an iterator over canonical QualTypes
400/// into an iterator over CanQualTypes.
401template <typename InputIterator>
402struct CanTypeIterator
403    : llvm::iterator_adaptor_base<
404          CanTypeIterator<InputIterator>, InputIterator,
405          typename std::iterator_traits<InputIterator>::iterator_category,
406          CanQualType,
407          typename std::iterator_traits<InputIterator>::difference_type,
408          CanProxy<Type>, CanQualType> {
409  CanTypeIterator() = default;
410  explicit CanTypeIterator(InputIterator Iter)
411      : CanTypeIterator::iterator_adaptor_base(std::move(Iter)) {}
412 
413  CanQualType operator*() const { return CanQualType::CreateUnsafe(*this->I); }
414  CanProxy<Type> operator->() const;
415};
416 
417template<>
418struct CanProxyAdaptor<ComplexType> : public CanProxyBase<ComplexType> {
419  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)CanQualType getElementType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getElementType()); }
420};
421 
422template<>
423struct CanProxyAdaptor<PointerType> : public CanProxyBase<PointerType> {
424  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)CanQualType getPointeeType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getPointeeType()); }
425};
426 
427template<>
428struct CanProxyAdaptor<BlockPointerType>
429  : public CanProxyBase<BlockPointerType> {
430  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)CanQualType getPointeeType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getPointeeType()); }
431};
432 
433template<>
434struct CanProxyAdaptor<ReferenceType> : public CanProxyBase<ReferenceType> {
435  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)CanQualType getPointeeType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getPointeeType()); }
436};
437 
438template<>
439struct CanProxyAdaptor<LValueReferenceType>
440  : public CanProxyBase<LValueReferenceType> {
441  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)CanQualType getPointeeType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getPointeeType()); }
442};
443 
444template<>
445struct CanProxyAdaptor<RValueReferenceType>
446  : public CanProxyBase<RValueReferenceType> {
447  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)CanQualType getPointeeType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getPointeeType()); }
448};
449 
450template<>
451struct CanProxyAdaptor<MemberPointerType>
452  : public CanProxyBase<MemberPointerType> {
453  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)CanQualType getPointeeType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getPointeeType()); }
454  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Type *, getClass)const Type * getClass() const { return this->getTypePtr()->
getClass(); }
455};
456 
457// CanProxyAdaptors for arrays are intentionally unimplemented because
458// they are not safe.
459template<> struct CanProxyAdaptor<ArrayType>;
460template<> struct CanProxyAdaptor<ConstantArrayType>;
461template<> struct CanProxyAdaptor<IncompleteArrayType>;
462template<> struct CanProxyAdaptor<VariableArrayType>;
463template<> struct CanProxyAdaptor<DependentSizedArrayType>;
464 
465template<>
466struct CanProxyAdaptor<DependentSizedExtVectorType>
467  : public CanProxyBase<DependentSizedExtVectorType> {
468  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)CanQualType getElementType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getElementType()); }
469  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const Expr *, getSizeExpr)const Expr * getSizeExpr() const { return this->getTypePtr
()->getSizeExpr(); }
470  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(SourceLocation, getAttributeLoc)SourceLocation getAttributeLoc() const { return this->getTypePtr
()->getAttributeLoc(); }
471};
472 
473template<>
474struct CanProxyAdaptor<VectorType> : public CanProxyBase<VectorType> {
475  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)CanQualType getElementType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getElementType()); }
476  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumElements)unsigned getNumElements() const { return this->getTypePtr(
)->getNumElements(); }
477};
478 
479template<>
480struct CanProxyAdaptor<ExtVectorType> : public CanProxyBase<ExtVectorType> {
481  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getElementType)CanQualType getElementType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getElementType()); }
482  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumElements)unsigned getNumElements() const { return this->getTypePtr(
)->getNumElements(); }
483};
484 
485template<>
486struct CanProxyAdaptor<FunctionType> : public CanProxyBase<FunctionType> {
487  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)CanQualType getReturnType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getReturnType()); }
488  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(FunctionType::ExtInfo, getExtInfo)FunctionType::ExtInfo getExtInfo() const { return this->getTypePtr
()->getExtInfo(); }
489};
490 
491template<>
492struct CanProxyAdaptor<FunctionNoProtoType>
493  : public CanProxyBase<FunctionNoProtoType> {
494  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)CanQualType getReturnType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getReturnType()); }
495  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(FunctionType::ExtInfo, getExtInfo)FunctionType::ExtInfo getExtInfo() const { return this->getTypePtr
()->getExtInfo(); }
496};
497 
498template<>
499struct CanProxyAdaptor<FunctionProtoType>
500  : public CanProxyBase<FunctionProtoType> {
501  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getReturnType)CanQualType getReturnType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getReturnType()); }
502  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(FunctionType::ExtInfo, getExtInfo)FunctionType::ExtInfo getExtInfo() const { return this->getTypePtr
()->getExtInfo(); }
503  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumParams)unsigned getNumParams() const { return this->getTypePtr()->
getNumParams(); }
504  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasExtParameterInfos)bool hasExtParameterInfos() const { return this->getTypePtr
()->hasExtParameterInfos(); }
505  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(ArrayRef<FunctionProtoType::ExtParameterInfo> getExtParameterInfos
() const { return this->getTypePtr()->getExtParameterInfos
(); }
506            ArrayRef<FunctionProtoType::ExtParameterInfo>, getExtParameterInfos)ArrayRef<FunctionProtoType::ExtParameterInfo> getExtParameterInfos
() const { return this->getTypePtr()->getExtParameterInfos
(); }
507 
508  CanQualType getParamType(unsigned i) const {
509    return CanQualType::CreateUnsafe(this->getTypePtr()->getParamType(i));
510  }
511 
512  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVariadic)bool isVariadic() const { return this->getTypePtr()->isVariadic
(); }
513  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getTypeQuals)unsigned getTypeQuals() const { return this->getTypePtr()->
getTypeQuals(); }
514 
515  using param_type_iterator =
516      CanTypeIterator<FunctionProtoType::param_type_iterator>;
517 
518  param_type_iterator param_type_begin() const {
519    return param_type_iterator(this->getTypePtr()->param_type_begin());
520  }
521 
522  param_type_iterator param_type_end() const {
523    return param_type_iterator(this->getTypePtr()->param_type_end());
524  }
525 
526  // Note: canonical function types never have exception specifications
527};
528 
529template<>
530struct CanProxyAdaptor<TypeOfType> : public CanProxyBase<TypeOfType> {
531  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnderlyingType)CanQualType getUnderlyingType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getUnderlyingType()); }
532};
533 
534template<>
535struct CanProxyAdaptor<DecltypeType> : public CanProxyBase<DecltypeType> {
536  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Expr *, getUnderlyingExpr)Expr * getUnderlyingExpr() const { return this->getTypePtr
()->getUnderlyingExpr(); }
537  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnderlyingType)CanQualType getUnderlyingType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getUnderlyingType()); }
538};
539 
540template <>
541struct CanProxyAdaptor<UnaryTransformType>
542    : public CanProxyBase<UnaryTransformType> {
543  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getBaseType)CanQualType getBaseType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getBaseType()); }
544  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnderlyingType)CanQualType getUnderlyingType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getUnderlyingType()); }
545  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(UnaryTransformType::UTTKind, getUTTKind)UnaryTransformType::UTTKind getUTTKind() const { return this->
getTypePtr()->getUTTKind(); }
546};
547 
548template<>
549struct CanProxyAdaptor<TagType> : public CanProxyBase<TagType> {
550  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(TagDecl *, getDecl)TagDecl * getDecl() const { return this->getTypePtr()->
getDecl(); }
551  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)bool isBeingDefined() const { return this->getTypePtr()->
isBeingDefined(); }
552};
553 
554template<>
555struct CanProxyAdaptor<RecordType> : public CanProxyBase<RecordType> {
556  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(RecordDecl *, getDecl)RecordDecl * getDecl() const { return this->getTypePtr()->
getDecl(); }
557  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)bool isBeingDefined() const { return this->getTypePtr()->
isBeingDefined(); }
558  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, hasConstFields)bool hasConstFields() const { return this->getTypePtr()->
hasConstFields(); }
559};
560 
561template<>
562struct CanProxyAdaptor<EnumType> : public CanProxyBase<EnumType> {
563  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(EnumDecl *, getDecl)EnumDecl * getDecl() const { return this->getTypePtr()->
getDecl(); }
564  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)bool isBeingDefined() const { return this->getTypePtr()->
isBeingDefined(); }
565};
566 
567template<>
568struct CanProxyAdaptor<TemplateTypeParmType>
569  : public CanProxyBase<TemplateTypeParmType> {
570  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getDepth)unsigned getDepth() const { return this->getTypePtr()->
getDepth(); }
571  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getIndex)unsigned getIndex() const { return this->getTypePtr()->
getIndex(); }
572  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isParameterPack)bool isParameterPack() const { return this->getTypePtr()->
isParameterPack(); }
573  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(TemplateTypeParmDecl *, getDecl)TemplateTypeParmDecl * getDecl() const { return this->getTypePtr
()->getDecl(); }
574  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(IdentifierInfo *, getIdentifier)IdentifierInfo * getIdentifier() const { return this->getTypePtr
()->getIdentifier(); }
575};
576 
577template<>
578struct CanProxyAdaptor<ObjCObjectType>
579  : public CanProxyBase<ObjCObjectType> {
580  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getBaseType)CanQualType getBaseType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getBaseType()); }
581  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const ObjCInterfaceDecl *,const ObjCInterfaceDecl * getInterface() const { return this->
getTypePtr()->getInterface(); }
582                                      getInterface)const ObjCInterfaceDecl * getInterface() const { return this->
getTypePtr()->getInterface(); }
583  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCUnqualifiedId)bool isObjCUnqualifiedId() const { return this->getTypePtr
()->isObjCUnqualifiedId(); }
584  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCUnqualifiedClass)bool isObjCUnqualifiedClass() const { return this->getTypePtr
()->isObjCUnqualifiedClass(); }
585  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedId)bool isObjCQualifiedId() const { return this->getTypePtr()
->isObjCQualifiedId(); }
586  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedClass)bool isObjCQualifiedClass() const { return this->getTypePtr
()->isObjCQualifiedClass(); }
587 
588  using qual_iterator = ObjCObjectPointerType::qual_iterator;
589 
590  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_begin)qual_iterator qual_begin() const { return this->getTypePtr
()->qual_begin(); }
591  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_end)qual_iterator qual_end() const { return this->getTypePtr()
->qual_end(); }
592  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, qual_empty)bool qual_empty() const { return this->getTypePtr()->qual_empty
(); }
593  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumProtocols)unsigned getNumProtocols() const { return this->getTypePtr
()->getNumProtocols(); }
594};
595 
596template<>
597struct CanProxyAdaptor<ObjCObjectPointerType>
598  : public CanProxyBase<ObjCObjectPointerType> {
599  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getPointeeType)CanQualType getPointeeType() const { return CanQualType::CreateUnsafe
(this->getTypePtr()->getPointeeType()); }
600  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(const ObjCInterfaceType *,const ObjCInterfaceType * getInterfaceType() const { return this
->getTypePtr()->getInterfaceType(); }
601                                      getInterfaceType)const ObjCInterfaceType * getInterfaceType() const { return this
->getTypePtr()->getInterfaceType(); }
602  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCIdType)bool isObjCIdType() const { return this->getTypePtr()->
isObjCIdType(); }
603  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCClassType)bool isObjCClassType() const { return this->getTypePtr()->
isObjCClassType(); }
604  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedIdType)bool isObjCQualifiedIdType() const { return this->getTypePtr
()->isObjCQualifiedIdType(); }
605  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjCQualifiedClassType)bool isObjCQualifiedClassType() const { return this->getTypePtr
()->isObjCQualifiedClassType(); }
606 
607  using qual_iterator = ObjCObjectPointerType::qual_iterator;
608 
609  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_begin)qual_iterator qual_begin() const { return this->getTypePtr
()->qual_begin(); }
610  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(qual_iterator, qual_end)qual_iterator qual_end() const { return this->getTypePtr()
->qual_end(); }
611  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, qual_empty)bool qual_empty() const { return this->getTypePtr()->qual_empty
(); }
612  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(unsigned, getNumProtocols)unsigned getNumProtocols() const { return this->getTypePtr
()->getNumProtocols(); }
613};
614 
615//----------------------------------------------------------------------------//
616// Method and function definitions
617//----------------------------------------------------------------------------//
618template<typename T>
619inline CanQual<T> CanQual<T>::getUnqualifiedType() const {
620  return CanQual<T>::CreateUnsafe(Stored.getLocalUnqualifiedType());
621}
622 
623template<typename T>
624inline CanQual<Type> CanQual<T>::getNonReferenceType() const {
625  if (CanQual<ReferenceType> RefType = getAs<ReferenceType>())
626    return RefType->getPointeeType();
627  else
628    return *this;
629}
630 
631template<typename T>
632CanQual<T> CanQual<T>::getFromOpaquePtr(void *Ptr) {
633  CanQual<T> Result;
634  Result.Stored = QualType::getFromOpaquePtr(Ptr);
635  assert((!Result || Result.Stored.getAsOpaquePtr() == (void*)-1 ||(static_cast <bool> ((!Result || Result.Stored.getAsOpaquePtr
() == (void*)-1 || Result.Stored.isCanonical()) && "Type is not canonical!"
) ? void (0) : __assert_fail ("(!Result || Result.Stored.getAsOpaquePtr() == (void*)-1 || Result.Stored.isCanonical()) && \"Type is not canonical!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/CanonicalType.h"
, 636, __extension__ __PRETTY_FUNCTION__))
636          Result.Stored.isCanonical()) && "Type is not canonical!")(static_cast <bool> ((!Result || Result.Stored.getAsOpaquePtr
() == (void*)-1 || Result.Stored.isCanonical()) && "Type is not canonical!"
) ? void (0) : __assert_fail ("(!Result || Result.Stored.getAsOpaquePtr() == (void*)-1 || Result.Stored.isCanonical()) && \"Type is not canonical!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/CanonicalType.h"
, 636, __extension__ __PRETTY_FUNCTION__));
637  return Result;
638}
639 
640template<typename T>
641CanQual<T> CanQual<T>::CreateUnsafe(QualType Other) {
642  assert((Other.isNull() || Other.isCanonical()) && "Type is not canonical!")(static_cast <bool> ((Other.isNull() || Other.isCanonical
()) && "Type is not canonical!") ? void (0) : __assert_fail
 ("(Other.isNull() || Other.isCanonical()) && \"Type is not canonical!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/CanonicalType.h"
, 642, __extension__ __PRETTY_FUNCTION__));
643  assert((Other.isNull() || isa<T>(Other.getTypePtr())) &&(static_cast <bool> ((Other.isNull() || isa<T>(Other
.getTypePtr())) && "Dynamic type does not meet the static type's requires"
) ? void (0) : __assert_fail ("(Other.isNull() || isa<T>(Other.getTypePtr())) && \"Dynamic type does not meet the static type's requires\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/CanonicalType.h"
, 644, __extension__ __PRETTY_FUNCTION__))
644         "Dynamic type does not meet the static type's requires")(static_cast <bool> ((Other.isNull() || isa<T>(Other
.getTypePtr())) && "Dynamic type does not meet the static type's requires"
) ? void (0) : __assert_fail ("(Other.isNull() || isa<T>(Other.getTypePtr())) && \"Dynamic type does not meet the static type's requires\""
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/CanonicalType.h"
, 644, __extension__ __PRETTY_FUNCTION__));
645  CanQual<T> Result;
646  Result.Stored = Other;
647  return Result;
648}
649 
650template<typename T>
651template<typename U>
652CanProxy<U> CanQual<T>::getAs() const {
653  static_assert(!TypeIsArrayType<T>::value,
654                "ArrayType cannot be used with getAs!");
655 
656  if (Stored.isNull())
657    return CanProxy<U>();
658 
659  if (isa<U>(Stored.getTypePtr()))
660    return CanQual<U>::CreateUnsafe(Stored);
661 
662  return CanProxy<U>();
663}
664 
665template<typename T>
666template<typename U>
667CanProxy<U> CanQual<T>::castAs() const {
668  static_assert(!TypeIsArrayType<U>::value,
669                "ArrayType cannot be used with castAs!");
670 
671  assert(!Stored.isNull() && isa<U>(Stored.getTypePtr()))(static_cast <bool> (!Stored.isNull() && isa<
U>(Stored.getTypePtr())) ? void (0) : __assert_fail ("!Stored.isNull() && isa<U>(Stored.getTypePtr())"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include/clang/AST/CanonicalType.h"
, 671, __extension__ __PRETTY_FUNCTION__));
672  return CanQual<U>::CreateUnsafe(Stored);
673}
674 
675template<typename T>
676CanProxy<T> CanQual<T>::operator->() const {
677  return CanProxy<T>(*this);
678}
679 
680template <typename InputIterator>
681CanProxy<Type> CanTypeIterator<InputIterator>::operator->() const {
682  return CanProxy<Type>(*this);
683}
684 
685} // namespace clang
686 
687#endif // LLVM_CLANG_AST_CANONICALTYPE_H