/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp

Bug Summary

File:	tools/clang/lib/Sema/SemaDeclCXX.cpp
Warning:	line 1638, column 51 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-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn374814/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~svn374814/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn374814/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn374814/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn374814/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn374814/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn374814=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-15-035155-28452-1 -x c++ /build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp
1//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file implements semantic analysis for C++ declarations.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTLambda.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/CXXInheritance.h"
18#include "clang/AST/CharUnits.h"
19#include "clang/AST/ComparisonCategories.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/AttributeCommonInfo.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/TargetInfo.h"
30#include "clang/Lex/LiteralSupport.h"
31#include "clang/Lex/Preprocessor.h"
32#include "clang/Sema/CXXFieldCollector.h"
33#include "clang/Sema/DeclSpec.h"
34#include "clang/Sema/Initialization.h"
35#include "clang/Sema/Lookup.h"
36#include "clang/Sema/ParsedTemplate.h"
37#include "clang/Sema/Scope.h"
38#include "clang/Sema/ScopeInfo.h"
39#include "clang/Sema/SemaInternal.h"
40#include "clang/Sema/Template.h"
41#include "llvm/ADT/STLExtras.h"
42#include "llvm/ADT/SmallString.h"
43#include "llvm/ADT/StringExtras.h"
44#include <map>
45#include <set>

47using namespace clang;

49//===----------------------------------------------------------------------===//
50// CheckDefaultArgumentVisitor
51//===----------------------------------------------------------------------===//

53namespace {
/// 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->getBeginLoc(),
                   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->getBeginLoc(),
                     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->getBeginLoc(),
                 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?")((E && "pseudo-object binding without source expression?"
) ? static_cast<void> (0) : __assert_fail ("E && \"pseudo-object binding without source expression?\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 132, __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->getBeginLoc(), 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) {
case EST_Unparsed:
case EST_Uninstantiated:
case EST_Unevaluated:
  llvm_unreachable("should not see unresolved exception specs here")::llvm::llvm_unreachable_internal("should not see unresolved exception specs here"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 177);

// If this function can throw any exceptions, make a note of that.
case EST_MSAny:
case EST_None:
  // FIXME: Whichever we see last of MSAny and None determines our result.
  // We should make a consistent, order-independent choice here.
  ClearExceptions();
  ComputedEST = EST;
  return;
case EST_NoexceptFalse:
  ClearExceptions();
  ComputedEST = EST_None;
  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:
case EST_NoexceptTrue:
case EST_NoThrow:
  return;
// If we're still at noexcept(true) and there's a throw() callee,
// change to that specification.
case EST_DynamicNone:
  if (ComputedEST == EST_BasicNoexcept)
    ComputedEST = EST_DynamicNone;
  return;
case EST_DependentNoexcept:
  llvm_unreachable(::llvm::llvm_unreachable_internal("should not generate implicit declarations for dependent cases"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 206)
      "should not generate implicit declarations for dependent cases")::llvm::llvm_unreachable_internal("should not generate implicit declarations for dependent cases"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 206);
case EST_Dynamic:
  break;
}
assert(EST == EST_Dynamic && "EST case not considered earlier.")((EST == EST_Dynamic && "EST case not considered earlier."
) ? static_cast<void> (0) : __assert_fail ("EST == EST_Dynamic && \"EST case not considered earlier.\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 210, __PRETTY_FUNCTION__));
assert(ComputedEST != EST_None &&((ComputedEST != EST_None && "Shouldn't collect exceptions when throw-all is guaranteed."
) ? static_cast<void> (0) : __assert_fail ("ComputedEST != EST_None && \"Shouldn't collect exceptions when throw-all is guaranteed.\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 212, __PRETTY_FUNCTION__))
       "Shouldn't collect exceptions when throw-all is guaranteed.")((ComputedEST != EST_None && "Shouldn't collect exceptions when throw-all is guaranteed."
) ? static_cast<void> (0) : __assert_fail ("ComputedEST != EST_None && \"Shouldn't collect exceptions when throw-all is guaranteed.\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 212, __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);
218}

220void 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;
247}

249bool
250Sema::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;
293}

295/// ActOnParamDefaultArgument - Check whether the default argument
296/// provided for a function parameter is well-formed. If so, attach it
297/// to the parameter declaration.
298void
299Sema::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);
338}

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

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

355/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
356/// the default argument for the parameter param failed.
357void 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));
369}

371/// CheckExtraCXXDefaultArguments - Check for any extra default
372/// arguments in the declarator, which is not a function declaration
373/// or definition and therefore is not permitted to have default
374/// arguments. This routine should be invoked for every declarator
375/// that is not a function declaration or definition.
376void 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;
  }
}
419}

421static 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;
430}

432/// MergeCXXFunctionDecl - Merge two declarations of the same C++
433/// function, once we already know that they have the same
434/// type. Subroutine of MergeFunctionDecl. Returns true if there was an
435/// error, false otherwise.
436bool 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())((NewParam->hasDefaultArg()) ? static_cast<void> (0)
 : __assert_fail ("NewParam->hasDefaultArg()", "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 631, __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->getConstexprKind() != Old->getConstexprKind()) {
  Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
      << New << New->getConstexprKind() << Old->getConstexprKind();
  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;
}

// C++17 [temp.deduct.guide]p3:
//   Two deduction guide declarations in the same translation unit
//   for the same class template shall not have equivalent
//   parameter-declaration-clauses.
if (isa<CXXDeductionGuideDecl>(New) &&
    !New->isFunctionTemplateSpecialization()) {
  Diag(New->getLocation(), diag::err_deduction_guide_redeclared);
  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;
684}

686NamedDecl *
687Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,
                                 MultiTemplateParamsArg TemplateParamLists) {
assert(D.isDecompositionDeclarator())((D.isDecompositionDeclarator()) ? static_cast<void> (0
) : __assert_fail ("D.isDecompositionDeclarator()", "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 689, __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++17 [dcl.dcl]/8:
//   The decl-specifier-seq shall contain only the type-specifier auto
//   and cv-qualifiers.
// C++2a [dcl.dcl]/8:
//   If decl-specifier-seq contains any decl-specifier other than static,
//   thread_local, auto, or cv-qualifiers, the program is ill-formed.
auto &DS = D.getDeclSpec();
{
  SmallVector<StringRef, 8> BadSpecifiers;
  SmallVector<SourceLocation, 8> BadSpecifierLocs;
  SmallVector<StringRef, 8> CPlusPlus20Specifiers;
  SmallVector<SourceLocation, 8> CPlusPlus20SpecifierLocs;
  if (auto SCS = DS.getStorageClassSpec()) {
    if (SCS == DeclSpec::SCS_static) {
      CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(SCS));
      CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());
    } else {
      BadSpecifiers.push_back(DeclSpec::getSpecifierName(SCS));
      BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());
    }
  }
  if (auto TSCS = DS.getThreadStorageClassSpec()) {
    CPlusPlus20Specifiers.push_back(DeclSpec::getSpecifierName(TSCS));
    CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());
  }
  if (DS.hasConstexprSpecifier()) {
    BadSpecifiers.push_back(
        DeclSpec::getSpecifierName(DS.getConstexprSpecifier()));
    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);
  } else if (!CPlusPlus20Specifiers.empty()) {
    auto &&Warn = Diag(CPlusPlus20SpecifierLocs.front(),
                       getLangOpts().CPlusPlus2a
                           ? diag::warn_cxx17_compat_decomp_decl_spec
                           : diag::ext_decomp_decl_spec);
    Warn << (int)CPlusPlus20Specifiers.size()
         << llvm::join(CPlusPlus20Specifiers.begin(),
                       CPlusPlus20Specifiers.end(), " ");
    for (auto Loc : CPlusPlus20SpecifierLocs)
      Warn << SourceRange(Loc, Loc);
  }
  // We can't recover from it being declared as a typedef.
  if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
    return nullptr;
}

// C++2a [dcl.struct.bind]p1:
//   A cv that includes volatile is deprecated
if ((DS.getTypeQualifiers() & DeclSpec::TQ_volatile) &&
    getLangOpts().CPlusPlus2a)
  Diag(DS.getVolatileSpecLoc(),
       diag::warn_deprecated_volatile_structured_binding);

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;
871}

873static 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;
897}

899static 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);
    });
912}

914static 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());
920}

922static 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()));
929}

931static 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);
    });
942}

944static 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();
956}

958static 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?")((RD && "specialization of class template is not a class?"
) ? static_cast<void> (0) : __assert_fail ("RD && \"specialization of class template is not a class?\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1008, __PRETTY_FUNCTION__));

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

1015static TemplateArgumentLoc
1016getTrivialIntegralTemplateArgument(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);
1020}

1022static TemplateArgumentLoc
1023getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T) {
return S.getTrivialTemplateArgumentLoc(TemplateArgument(T), QualType(), Loc);
1025}

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

1029static 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 or the lookup of 'value' is empty,
// it's not tuple-like.
if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/ 0) ||
    R.empty())
  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);

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;
1071}

1073/// \return std::tuple_element<I, T>::type.
1074static 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);
1100}

1102namespace {
1103struct 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;
}
1114};
1115}

1117static 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;
  //   ... and if that finds at least one declaration that is a function
  //   template whose first template parameter is a non-type parameter ...
  for (NamedDecl *D : MemberGet) {
    if (FunctionTemplateDecl *FTD =
            dyn_cast<FunctionTemplateDecl>(D->getUnderlyingDecl())) {
      TemplateParameterList *TPL = FTD->getTemplateParameters();
      if (TPL->size() != 0 &&
          isa<NonTypeTemplateParmDecl>(TPL->getParam(0))) {
        //   ... the initializer is e.get<i>().
        UseMemberGet = true;
        break;
      }
    }
  }
}

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.BuildCallExpr(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.BuildCallExpr(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, /*DiscardedValue*/ false);
  if (E.isInvalid())
    return true;
  RefVD->setInit(E.get());
  if (!E.get()->isValueDependent())
    RefVD->checkInitIsICE();

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

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

return false;
1250}

1252/// Find the base class to decompose in a built-in decomposition of a class type.
1253/// This base class search is, unfortunately, not quite like any other that we
1254/// perform anywhere else in C++.
1255static DeclAccessPair 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;
AccessSpecifier AS = AS_public;
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 DeclAccessPair::make(const_cast<CXXRecordDecl*>(RD), AS_public);
  }

  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 DeclAccessPair();
    } 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 DeclAccessPair();
  }

  //   ... [accessible, implied by other rules] base class of E.
  S.CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD),
                         *BestPath, diag::err_decomp_decl_inaccessible_base);
  AS = BestPath->Access;

  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 DeclAccessPair();
}

return DeclAccessPair::make(const_cast<CXXRecordDecl*>(ClassWithFields), AS);
1324}

1326static bool checkMemberDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
                                   ValueDecl *Src, QualType DecompType,
                                   const CXXRecordDecl *OrigRD) {
if (S.RequireCompleteType(Src->getLocation(), DecompType,
                          diag::err_incomplete_type))
  return true;

CXXCastPath BasePath;
DeclAccessPair BasePair =
    findDecomposableBaseClass(S, Src->getLocation(), OrigRD, BasePath);
const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
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)((Bindings.size() != NumFields) ? static_cast<void> (0)
 : __assert_fail ("Bindings.size() != NumFields", "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1346, __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 [...] well-formed
//   when named as e.name in the context of the structured binding,
//   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();

  // The field must be accessible in the context of the structured binding.
  // We already checked that the base class is accessible.
  // FIXME: Add 'const' to AccessedEntity's classes so we can remove the
  // const_cast here.
  S.CheckStructuredBindingMemberAccess(
      Loc, const_cast<CXXRecordDecl *>(OrigRD),
      DeclAccessPair::make(FD, CXXRecordDecl::MergeAccess(
                                   BasePair.getAccess(), FD->getAccess())));

  // 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;
1413}

1415void 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();
1482}

1484/// Merge the exception specifications of two variable declarations.
1485///
1486/// This is called when there's a redeclaration of a VarDecl. The function
1487/// checks if the redeclaration might have an exception specification and
1488/// validates compatibility and merges the specs if necessary.
1489void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) {
// Shortcut if exceptions are disabled.
if (!getLangOpts().CXXExceptions)
  return;

assert(Context.hasSameType(New->getType(), Old->getType()) &&((Context.hasSameType(New->getType(), Old->getType()) &&
 "Should only be called if types are otherwise the same.") ? static_cast
<void> (0) : __assert_fail ("Context.hasSameType(New->getType(), Old->getType()) && \"Should only be called if types are otherwise the same.\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1495, __PRETTY_FUNCTION__))
       "Should only be called if types are otherwise the same.")((Context.hasSameType(New->getType(), Old->getType()) &&
 "Should only be called if types are otherwise the same.") ? static_cast
<void> (0) : __assert_fail ("Context.hasSameType(New->getType(), Old->getType()) && \"Should only be called if types are otherwise the same.\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1495, __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();
}
1524}

1526/// CheckCXXDefaultArguments - Verify that the default arguments for a
1527/// function declaration are well-formed according to C++
1528/// [dcl.fct.default].
1529void 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);
    }
  }
}
1576}

1578/// Check that the given type is a literal type. Issue a diagnostic if not,
1579/// if Kind is Diagnose.
1580/// \return \c true if a problem has been found (and optionally diagnosed).
1581template <typename... Ts>
1582static bool CheckLiteralType(Sema &SemaRef, Sema::CheckConstexprKind Kind,
                           SourceLocation Loc, QualType T, unsigned DiagID,
                           Ts &&...DiagArgs) {
if (T->isDependentType())
  return false;

switch (Kind) {
case Sema::CheckConstexprKind::Diagnose:
  return SemaRef.RequireLiteralType(Loc, T, DiagID,
                                    std::forward<Ts>(DiagArgs)...);

case Sema::CheckConstexprKind::CheckValid:
  return !T->isLiteralType(SemaRef.Context);
}

llvm_unreachable("unknown CheckConstexprKind")::llvm::llvm_unreachable_internal("unknown CheckConstexprKind"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1597);
1598}

1600/// Determine whether a destructor cannot be constexpr due to
1601static bool CheckConstexprDestructorSubobjects(Sema &SemaRef,
                                             const CXXDestructorDecl *DD,
                                             Sema::CheckConstexprKind Kind) {
auto Check = [&](SourceLocation Loc, QualType T, const FieldDecl *FD) {
  const CXXRecordDecl *RD =
      T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
  if (!RD || RD->hasConstexprDestructor())
    return true;

  if (Kind == Sema::CheckConstexprKind::Diagnose) {
    SemaRef.Diag(DD->getLocation(), diag::err_constexpr_dtor_subobject)
        << DD->getConstexprKind() << !FD
        << (FD ? FD->getDeclName() : DeclarationName()) << T;
    SemaRef.Diag(Loc, diag::note_constexpr_dtor_subobject)
        << !FD << (FD ? FD->getDeclName() : DeclarationName()) << T;
  }
  return false;
};

const CXXRecordDecl *RD = DD->getParent();
for (const CXXBaseSpecifier &B : RD->bases())
  if (!Check(B.getBaseTypeLoc(), B.getType(), nullptr))
    return false;
for (const FieldDecl *FD : RD->fields())
  if (!Check(FD->getLocation(), FD->getType(), FD))
    return false;
return true;
1628}

1630// CheckConstexprParameterTypes - Check whether a function's parameter types
1631// are all literal types. If so, return true. If not, produce a suitable
1632// diagnostic and return false.
1633static bool CheckConstexprParameterTypes(Sema &SemaRef,
                                       const FunctionDecl *FD,
                                       Sema::CheckConstexprKind Kind) {
unsigned ArgIndex = 0;
const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
7
←
Assuming the object is not a 'FunctionProtoType'→
8
←
'FT' initialized to a null pointer value→
for (FunctionProtoType::param_type_iterator i = FT->param_type_begin(),
9
←
Called C++ object pointer is null
                                            e = FT->param_type_end();
     i != e; ++i, ++ArgIndex) {
  const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
  SourceLocation ParamLoc = PD->getLocation();
  if (CheckLiteralType(SemaRef, Kind, ParamLoc, *i,
                       diag::err_constexpr_non_literal_param, ArgIndex + 1,
                       PD->getSourceRange(), isa<CXXConstructorDecl>(FD),
                       FD->isConsteval()))
    return false;
}
return true;
1650}

1652/// Get diagnostic %select index for tag kind for
1653/// record diagnostic message.
1654/// WARNING: Indexes apply to particular diagnostics only!
1655///
1656/// \returns diagnostic %select index.
1657static 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-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1662);
}
1664}

1666static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
                                     Stmt *Body,
                                     Sema::CheckConstexprKind Kind);

1670// Check whether a function declaration satisfies the requirements of a
1671// constexpr function definition or a constexpr constructor definition. If so,
1672// return true. If not, produce appropriate diagnostics (unless asked not to by
1673// Kind) and return false.
1674//
1675// This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
1676bool Sema::CheckConstexprFunctionDefinition(const FunctionDecl *NewFD,
                                          CheckConstexprKind Kind) {
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
1
Assuming 'NewFD' is not a 'CXXMethodDecl'→
if (MD1.1
'MD' is null
 && 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;
  //
  // FIXME: This only applies to constructors and destructors, not arbitrary
  // member functions.
  const CXXRecordDecl *RD = MD->getParent();
  if (RD->getNumVBases()) {
    if (Kind == CheckConstexprKind::CheckValid)
      return false;

    Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
      << isa<CXXConstructorDecl>(NewFD)
      << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases();
    for (const auto &I : RD->vbases())
      Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
          << I.getSourceRange();
    return false;
  }
}

if (!isa<CXXConstructorDecl>(NewFD)) {
2
←
Assuming 'NewFD' is a 'CXXConstructorDecl'→
3
←
Taking false branch→
  // C++11 [dcl.constexpr]p3:
  //  The definition of a constexpr function shall satisfy the following
  //  constraints:
  // - it shall not be virtual; (removed in C++20)
  const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
  if (Method && Method->isVirtual()) {
    if (getLangOpts().CPlusPlus2a) {
      if (Kind == CheckConstexprKind::Diagnose)
        Diag(Method->getLocation(), diag::warn_cxx17_compat_constexpr_virtual);
    } else {
      if (Kind == CheckConstexprKind::CheckValid)
        return false;

      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 (CheckLiteralType(*this, Kind, NewFD->getLocation(), RT,
                       diag::err_constexpr_non_literal_return,
                       NewFD->isConsteval()))
    return false;
}

if (auto *Dtor4.1
'Dtor' is null
 = dyn_cast<CXXDestructorDecl>(NewFD)) {
4
←
Assuming 'NewFD' is not a 'CXXDestructorDecl'→
5
←
Taking false branch→
  // A destructor can be constexpr only if the defaulted destructor could be;
  // we don't need to check the members and bases if we already know they all
  // have constexpr destructors.
  if (!Dtor->getParent()->defaultedDestructorIsConstexpr()) {
    if (Kind == CheckConstexprKind::CheckValid)
      return false;
    if (!CheckConstexprDestructorSubobjects(*this, Dtor, Kind))
      return false;
  }
}

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

Stmt *Body = NewFD->getBody();
assert(Body &&((Body && "CheckConstexprFunctionDefinition called on function with no body"
) ? static_cast<void> (0) : __assert_fail ("Body && \"CheckConstexprFunctionDefinition called on function with no body\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1757, __PRETTY_FUNCTION__))
       "CheckConstexprFunctionDefinition called on function with no body")((Body && "CheckConstexprFunctionDefinition called on function with no body"
) ? static_cast<void> (0) : __assert_fail ("Body && \"CheckConstexprFunctionDefinition called on function with no body\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 1757, __PRETTY_FUNCTION__));
return CheckConstexprFunctionBody(*this, NewFD, Body, Kind);
1759}

1761/// Check the given declaration statement is legal within a constexpr function
1762/// body. C++11 [dcl.constexpr]p3,p4, and C++1y [dcl.constexpr]p3.
1763///
1764/// \return true if the body is OK (maybe only as an extension), false if we
1765///         have diagnosed a problem.
1766static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
                                 DeclStmt *DS, SourceLocation &Cxx1yLoc,
                                 Sema::CheckConstexprKind Kind) {
// 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.
      if (Kind == Sema::CheckConstexprKind::Diagnose) {
        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()) {
      if (Kind == Sema::CheckConstexprKind::Diagnose) {
        SemaRef.Diag(DS->getBeginLoc(),
                     SemaRef.getLangOpts().CPlusPlus14
                         ? diag::warn_cxx11_compat_constexpr_type_definition
                         : diag::ext_constexpr_type_definition)
            << isa<CXXConstructorDecl>(Dcl);
      } else if (!SemaRef.getLangOpts().CPlusPlus14) {
        return false;
      }
    }
    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 [before C++2a] for which no
    //   initialization is performed.
    const auto *VD = cast<VarDecl>(DclIt);
    if (VD->isThisDeclarationADefinition()) {
      if (VD->isStaticLocal()) {
        if (Kind == Sema::CheckConstexprKind::Diagnose) {
          SemaRef.Diag(VD->getLocation(),
                       diag::err_constexpr_local_var_static)
            << isa<CXXConstructorDecl>(Dcl)
            << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
        }
        return false;
      }
      if (CheckLiteralType(SemaRef, Kind, 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()) {
        if (Kind == Sema::CheckConstexprKind::Diagnose) {
          SemaRef.Diag(
              VD->getLocation(),
              SemaRef.getLangOpts().CPlusPlus2a
                  ? diag::warn_cxx17_compat_constexpr_local_var_no_init
                  : diag::ext_constexpr_local_var_no_init)
              << isa<CXXConstructorDecl>(Dcl);
        } else if (!SemaRef.getLangOpts().CPlusPlus2a) {
          return false;
        }
        continue;
      }
    }
    if (Kind == Sema::CheckConstexprKind::Diagnose) {
      SemaRef.Diag(VD->getLocation(),
                   SemaRef.getLangOpts().CPlusPlus14
                    ? diag::warn_cxx11_compat_constexpr_local_var
                    : diag::ext_constexpr_local_var)
        << isa<CXXConstructorDecl>(Dcl);
    } else if (!SemaRef.getLangOpts().CPlusPlus14) {
      return false;
    }
    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->getBeginLoc();
    continue;

  default:
    if (Kind == Sema::CheckConstexprKind::Diagnose) {
      SemaRef.Diag(DS->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
          << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
    }
    return false;
  }
}

return true;
1892}

1894/// Check that the given field is initialized within a constexpr constructor.
1895///
1896/// \param Dcl The constexpr constructor being checked.
1897/// \param Field The field being checked. This may be a member of an anonymous
1898///        struct or union nested within the class being checked.
1899/// \param Inits All declarations, including anonymous struct/union members and
1900///        indirect members, for which any initialization was provided.
1901/// \param Diagnosed Whether we've emitted the error message yet. Used to attach
1902///        multiple notes for different members to the same error.
1903/// \param Kind Whether we're diagnosing a constructor as written or determining
1904///        whether the formal requirements are satisfied.
1905/// \return \c false if we're checking for validity and the constructor does
1906///         not satisfy the requirements on a constexpr constructor.
1907static bool CheckConstexprCtorInitializer(Sema &SemaRef,
                                        const FunctionDecl *Dcl,
                                        FieldDecl *Field,
                                        llvm::SmallSet<Decl*, 16> &Inits,
                                        bool &Diagnosed,
                                        Sema::CheckConstexprKind Kind) {
// In C++20 onwards, there's nothing to check for validity.
if (Kind == Sema::CheckConstexprKind::CheckValid &&
    SemaRef.getLangOpts().CPlusPlus2a)
  return true;

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

if (Field->isUnnamedBitfield())
  return true;

// 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 true;

if (!Inits.count(Field)) {
  if (Kind == Sema::CheckConstexprKind::Diagnose) {
    if (!Diagnosed) {
      SemaRef.Diag(Dcl->getLocation(),
                   SemaRef.getLangOpts().CPlusPlus2a
                       ? diag::warn_cxx17_compat_constexpr_ctor_missing_init
                       : diag::ext_constexpr_ctor_missing_init);
      Diagnosed = true;
    }
    SemaRef.Diag(Field->getLocation(),
                 diag::note_constexpr_ctor_missing_init);
  } else if (!SemaRef.getLangOpts().CPlusPlus2a) {
    return false;
  }
} 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))
      if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
                                         Kind))
        return false;
}
return true;
1958}

1960/// Check the provided statement is allowed in a constexpr function
1961/// definition.
1962static bool
1963CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
                         SmallVectorImpl<SourceLocation> &ReturnStmts,
                         SourceLocation &Cxx1yLoc, SourceLocation &Cxx2aLoc,
                         Sema::CheckConstexprKind Kind) {
// - 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, Kind))
    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->getBeginLoc();
    return true;
  }

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

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

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

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

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

  IfStmt *If = cast<IfStmt>(S);
  if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
                                  Cxx1yLoc, Cxx2aLoc, Kind))
    return false;
  if (If->getElse() &&
      !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
                                  Cxx1yLoc, Cxx2aLoc, Kind))
    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->getBeginLoc();
  for (Stmt *SubStmt : S->children())
    if (SubStmt &&
        !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
                                    Cxx1yLoc, Cxx2aLoc, Kind))
      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->getBeginLoc();
  for (Stmt *SubStmt : S->children())
    if (SubStmt &&
        !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
                                    Cxx1yLoc, Cxx2aLoc, Kind))
      return false;
  return true;

case Stmt::GCCAsmStmtClass:
case Stmt::MSAsmStmtClass:
  // C++2a allows inline assembly statements.
case Stmt::CXXTryStmtClass:
  if (Cxx2aLoc.isInvalid())
    Cxx2aLoc = S->getBeginLoc();
  for (Stmt *SubStmt : S->children()) {
    if (SubStmt &&
        !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
                                    Cxx1yLoc, Cxx2aLoc, Kind))
      return false;
  }
  return true;

case Stmt::CXXCatchStmtClass:
  // Do not bother checking the language mode (already covered by the
  // try block check).
  if (!CheckConstexprFunctionStmt(SemaRef, Dcl,
                                  cast<CXXCatchStmt>(S)->getHandlerBlock(),
                                  ReturnStmts, Cxx1yLoc, Cxx2aLoc, Kind))
    return false;
  return true;

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

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

if (Kind == Sema::CheckConstexprKind::Diagnose) {
  SemaRef.Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
      << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
}
return false;
2101}

2103/// Check the body for the given constexpr function declaration only contains
2104/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
2105///
2106/// \return true if the body is OK, false if we have found or diagnosed a
2107/// problem.
2108static bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl,
                                     Stmt *Body,
                                     Sema::CheckConstexprKind Kind) {
SmallVector<SourceLocation, 4> ReturnStmts;

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;
  //
  // This restriction is lifted in C++2a, as long as inner statements also
  // apply the general constexpr rules.
  switch (Kind) {
  case Sema::CheckConstexprKind::CheckValid:
    if (!SemaRef.getLangOpts().CPlusPlus2a)
      return false;
    break;

  case Sema::CheckConstexprKind::Diagnose:
    SemaRef.Diag(Body->getBeginLoc(),
         !SemaRef.getLangOpts().CPlusPlus2a
             ? diag::ext_constexpr_function_try_block_cxx2a
             : diag::warn_cxx17_compat_constexpr_function_try_block)
        << isa<CXXConstructorDecl>(Dcl);
    break;
  }
}

// - its function-body shall be [...] a compound-statement that contains only
//   [... list of cases ...]
//
// Note that walking the children here is enough to properly check for
// CompoundStmt and CXXTryStmt body.
SourceLocation Cxx1yLoc, Cxx2aLoc;
for (Stmt *SubStmt : Body->children()) {
  if (SubStmt &&
      !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
                                  Cxx1yLoc, Cxx2aLoc, Kind))
    return false;
}

if (Kind == Sema::CheckConstexprKind::CheckValid) {
  // If this is only valid as an extension, report that we don't satisfy the
  // constraints of the current language.
  if ((Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus2a) ||
      (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
    return false;
} else if (Cxx2aLoc.isValid()) {
  SemaRef.Diag(Cxx2aLoc,
       SemaRef.getLangOpts().CPlusPlus2a
         ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
         : diag::ext_constexpr_body_invalid_stmt_cxx2a)
    << isa<CXXConstructorDecl>(Dcl);
} else if (Cxx1yLoc.isValid()) {
  SemaRef.Diag(Cxx1yLoc,
       SemaRef.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()) {
      if (Kind == Sema::CheckConstexprKind::Diagnose) {
        SemaRef.Diag(
            Dcl->getLocation(),
            SemaRef.getLangOpts().CPlusPlus2a
                ? diag::warn_cxx17_compat_constexpr_union_ctor_no_init
                : diag::ext_constexpr_union_ctor_no_init);
      } else if (!SemaRef.getLangOpts().CPlusPlus2a) {
        return false;
      }
    }
  } else if (!Constructor->isDependentContext() &&
             !Constructor->isDelegatingConstructor()) {
    assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases")((RD->getNumVBases() == 0 && "constexpr ctor with virtual bases"
) ? static_cast<void> (0) : __assert_fail ("RD->getNumVBases() == 0 && \"constexpr ctor with virtual bases\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2199, __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())
        if (!CheckConstexprCtorInitializer(SemaRef, Dcl, I, Inits, Diagnosed,
                                           Kind))
          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 = SemaRef.getLangOpts().CPlusPlus14 &&
              (Dcl->getReturnType()->isVoidType() ||
               Dcl->getReturnType()->isDependentType());
    switch (Kind) {
    case Sema::CheckConstexprKind::Diagnose:
      SemaRef.Diag(Dcl->getLocation(),
                   OK ? diag::warn_cxx11_compat_constexpr_body_no_return
                      : diag::err_constexpr_body_no_return)
          << Dcl->isConsteval();
      if (!OK)
        return false;
      break;

    case Sema::CheckConstexprKind::CheckValid:
      // The formal requirements don't include this rule in C++14, even
      // though the "must be able to produce a constant expression" rules
      // still imply it in some cases.
      if (!SemaRef.getLangOpts().CPlusPlus14)
        return false;
      break;
    }
  } else if (ReturnStmts.size() > 1) {
    switch (Kind) {
    case Sema::CheckConstexprKind::Diagnose:
      SemaRef.Diag(
          ReturnStmts.back(),
          SemaRef.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)
        SemaRef.Diag(ReturnStmts[I],
                     diag::note_constexpr_body_previous_return);
      break;

    case Sema::CheckConstexprKind::CheckValid:
      if (!SemaRef.getLangOpts().CPlusPlus14)
        return false;
      break;
    }
  }
}

// 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.
//
// Note that this rule is distinct from the "requirements for a constexpr
// function", so is not checked in CheckValid mode.
SmallVector<PartialDiagnosticAt, 8> Diags;
if (Kind == Sema::CheckConstexprKind::Diagnose &&
    !Expr::isPotentialConstantExpr(Dcl, Diags)) {
  SemaRef.Diag(Dcl->getLocation(),
               diag::ext_constexpr_function_never_constant_expr)
      << isa<CXXConstructorDecl>(Dcl);
  for (size_t I = 0, N = Diags.size(); I != N; ++I)
    SemaRef.Diag(Diags[I].first, Diags[I].second);
  // Don't return false here: we allow this for compatibility in
  // system headers.
}

return true;
2310}

2312/// Get the class that is directly named by the current context. This is the
2313/// class for which an unqualified-id in this scope could name a constructor
2314/// or destructor.
2315///
2316/// If the scope specifier denotes a class, this will be that class.
2317/// If the scope specifier is empty, this will be the class whose
2318/// member-specification we are currently within. Otherwise, there
2319/// is no such class.
2320CXXRecordDecl *Sema::getCurrentClass(Scope *, const CXXScopeSpec *SS) {
assert(getLangOpts().CPlusPlus && "No class names in C!")((getLangOpts().CPlusPlus && "No class names in C!") ?
 static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"No class names in C!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2321, __PRETTY_FUNCTION__));

if (SS && SS->isInvalid())
  return nullptr;

if (SS && SS->isNotEmpty()) {
  DeclContext *DC = computeDeclContext(*SS, true);
  return dyn_cast_or_null<CXXRecordDecl>(DC);
}

return dyn_cast_or_null<CXXRecordDecl>(CurContext);
2332}

2334/// isCurrentClassName - Determine whether the identifier II is the
2335/// name of the class type currently being defined. In the case of
2336/// nested classes, this will only return true if II is the name of
2337/// the innermost class.
2338bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *S,
                            const CXXScopeSpec *SS) {
CXXRecordDecl *CurDecl = getCurrentClass(S, SS);
return CurDecl && &II == CurDecl->getIdentifier();
2342}

2344/// Determine whether the identifier II is a typo for the name of
2345/// the class type currently being defined. If so, update it to the identifier
2346/// that should have been used.
2347bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) {
assert(getLangOpts().CPlusPlus && "No class names in C!")((getLangOpts().CPlusPlus && "No class names in C!") ?
 static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"No class names in C!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2348, __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;
2368}

2370/// Determine whether the given class is a base class of the given
2371/// class, including looking at dependent bases.
2372static 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;
2400}

2402/// Check the validity of a C++ base class specifier.
2403///
2404/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
2405/// and returns NULL otherwise.
2406CXXBaseSpecifier *
2407Sema::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->castAs<RecordType>()->getDecl();
assert(BaseDecl && "Record type has no declaration")((BaseDecl && "Record type has no declaration") ? static_cast
<void> (0) : __assert_fail ("BaseDecl && \"Record type has no declaration\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2490, __PRETTY_FUNCTION__));
BaseDecl = BaseDecl->getDefinition();
assert(BaseDecl && "Base type is not incomplete, but has no definition")((BaseDecl && "Base type is not incomplete, but has no definition"
) ? static_cast<void> (0) : __assert_fail ("BaseDecl && \"Base type is not incomplete, but has no definition\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2492, __PRETTY_FUNCTION__));
CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
assert(CXXBaseDecl && "Base type is not a C++ type")((CXXBaseDecl && "Base type is not a C++ type") ? static_cast
<void> (0) : __assert_fail ("CXXBaseDecl && \"Base type is not a C++ type\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2494, __PRETTY_FUNCTION__));

// Microsoft docs say:
// "If a base-class has a code_seg attribute, derived classes must have the
// same attribute."
const auto *BaseCSA = CXXBaseDecl->getAttr<CodeSegAttr>();
const auto *DerivedCSA = Class->getAttr<CodeSegAttr>();
if ((DerivedCSA || BaseCSA) &&
    (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {
  Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
  Diag(CXXBaseDecl->getLocation(), diag::note_base_class_specified_here)
    << CXXBaseDecl;
  return nullptr;
}

// 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);
2540}

2542/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
2543/// one entry in the base class list of a class specifier, for
2544/// example:
2545///    class foo : public bar, virtual private baz {
2546/// 'public bar' and 'virtual private baz' are each base-specifiers.
2547BaseResult
2548Sema::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.
for (const ParsedAttr &AL : Attributes) {
  if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
    continue;
  Diag(AL.getLoc(), AL.getKind() == ParsedAttr::UnknownAttribute
                        ? (unsigned)diag::warn_unknown_attribute_ignored
                        : (unsigned)diag::err_base_specifier_attribute)
      << AL;
}

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;
2591}

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

2597/// Recursively add the bases of Type.  Don't add Type itself.
2598static void
2599NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set,
                const QualType &Type)
2601{
// 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);
  }
}
2616}

2618/// Performs the actual work of attaching the given base class
2619/// specifiers to a C++ class.
2620bool 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]->getBeginLoc(), 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->getBeginLoc(), diag::err_invalid_base_in_interface)
            << getRecordDiagFromTagKind(RD->getTagKind()) << RD
            << 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)((found) ? static_cast<void> (0) : __assert_fail ("found"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2704, __PRETTY_FUNCTION__));
    (void)found;

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

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

return Invalid;
2721}

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

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

2735/// Determine whether the type \p Derived is a C++ class that is
2736/// derived from the type \p Base.
2737bool 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);
2760}

2762/// Determine whether the type \p Derived is a C++ class that is
2763/// derived from the type \p Base.
2764bool 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);
2781}

2783static 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));
2799}


2802void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
                            CXXCastPath &BasePathArray) {
assert(BasePathArray.empty() && "Base path array must be empty!")((BasePathArray.empty() && "Base path array must be empty!"
) ? static_cast<void> (0) : __assert_fail ("BasePathArray.empty() && \"Base path array must be empty!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2804, __PRETTY_FUNCTION__));
assert(Paths.isRecordingPaths() && "Must record paths!")((Paths.isRecordingPaths() && "Must record paths!") ?
 static_cast<void> (0) : __assert_fail ("Paths.isRecordingPaths() && \"Must record paths!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2805, __PRETTY_FUNCTION__));
return ::BuildBasePathArray(Paths.front(), BasePathArray);
2807}
2808/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
2809/// conversion (where Derived and Base are class types) is
2810/// well-formed, meaning that the conversion is unambiguous (and
2811/// that all of the base classes are accessible). Returns true
2812/// and emits a diagnostic if the code is ill-formed, returns false
2813/// otherwise. Loc is the location where this routine should point to
2814/// if there is an error, and Range is the source range to highlight
2815/// if there is an error.
2816///
2817/// If either InaccessibleBaseID or AmbigiousBaseConvID are 0, then the
2818/// diagnostic for the respective type of error will be suppressed, but the
2819/// check for ill-formed code will still be performed.
2820bool
2821Sema::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")((StillOkay && "Can only be used with a derived-to-base conversion"
) ? static_cast<void> (0) : __assert_fail ("StillOkay && \"Can only be used with a derived-to-base conversion\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 2887, __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;
2900}

2902bool
2903Sema::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);
2911}


2914/// Builds a string representing ambiguous paths from a
2915/// specific derived class to different subobjects of the same base
2916/// class.
2917///
2918/// This function builds a string that can be used in error messages
2919/// to show the different paths that one can take through the
2920/// inheritance hierarchy to go from the derived class to different
2921/// subobjects of a base class. The result looks something like this:
2922/// @code
2923/// struct D -> struct B -> struct A
2924/// struct D -> struct C -> struct A
2925/// @endcode
2926std::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;
2943}

2945//===----------------------------------------------------------------------===//
2946// C++ class member Handling
2947//===----------------------------------------------------------------------===//

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

2960/// CheckOverrideControl - Check C++11 override control semantics.
2961void 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();
3027}

3029void 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).getBegin();
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);
}
3052}

3054/// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
3055/// function overrides a virtual member function marked 'final', according to
3056/// C++11 [class.virtual]p4.
3057bool 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;
3068}

3070static 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;
3078}

3080static const ParsedAttr *getMSPropertyAttr(const ParsedAttributesView &list) {
ParsedAttributesView::const_iterator Itr =
    llvm::find_if(list, [](const ParsedAttr &AL) {
      return AL.isDeclspecPropertyAttribute();
    });
if (Itr != list.end())
  return &*Itr;
return nullptr;
3088}

3090// Check if there is a field shadowing.
3091void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
                                    DeclarationName FieldName,
                                    const CXXRecordDecl *RD,
                                    bool DeclIsField) {
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)((Field->getAccess() != AS_none) ? static_cast<void>
 (0) : __assert_fail ("Field->getAccess() != AS_none", "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3109, __PRETTY_FUNCTION__));
      assert(Bases.find(Base) == Bases.end())((Bases.find(Base) == Bases.end()) ? static_cast<void> (
0) : __assert_fail ("Bases.find(Base) == Bases.end()", "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3110, __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)((BaseField->getAccess() != AS_private) ? static_cast<void
> (0) : __assert_fail ("BaseField->getAccess() != AS_private"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3130, __PRETTY_FUNCTION__));
  if (AS_none !=
      CXXRecordDecl::MergeAccess(P.Access, BaseField->getAccess())) {
    Diag(Loc, diag::warn_shadow_field)
      << FieldName << RD << Base << DeclIsField;
    Diag(BaseField->getLocation(), diag::note_shadow_field);
    Bases.erase(It);
  }
}
3139}

3141/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
3142/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
3143/// bitfield width if there is one, 'InitExpr' specifies the initializer if
3144/// one has been parsed, and 'InitStyle' is set if an in-class initializer is
3145/// present (but parsing it has been deferred).
3146NamedDecl *
3147Sema::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.getBeginLoc();

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

assert(isa<CXXRecordDecl>(CurContext))((isa<CXXRecordDecl>(CurContext)) ? static_cast<void
> (0) : __assert_fail ("isa<CXXRecordDecl>(CurContext)"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3162, __PRETTY_FUNCTION__));
assert(!DS.isFriendSpecified())((!DS.isFriendSpecified()) ? static_cast<void> (0) : __assert_fail
 ("!DS.isFriendSpecified()", "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3163, __PRETTY_FUNCTION__));

bool isFunc = D.isDeclarationOfFunction();
const ParsedAttr *MSPropertyAttr =
    getMSPropertyAttr(D.getDeclSpec().getAttributes());

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.hasConstexprSpecifier() && 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")((!Failed && "Making a constexpr member const shouldn't fail"
) ? static_cast<void> (0) : __assert_fail ("!Failed && \"Making a constexpr member const shouldn't fail\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3262, __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 &&((DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
 "This is the only DeclSpec that should fail to be applied") ?
 static_cast<void> (0) : __assert_fail ("DS.getStorageClassSpec() == DeclSpec::SCS_mutable && \"This is the only DeclSpec that should fail to be applied\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3272, __PRETTY_FUNCTION__))
             "This is the only DeclSpec that should fail to be applied")((DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
 "This is the only DeclSpec that should fail to be applied") ?
 static_cast<void> (0) : __assert_fail ("DS.getStorageClassSpec() == DeclSpec::SCS_mutable && \"This is the only DeclSpec that should fail to be applied\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3272, __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(),
                                   D.getName().getKind() ==
                                       UnqualifiedIdKind::IK_TemplateId);
    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();
  }

  NamedDecl *NonTemplateMember = Member;
  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
    NonTemplateMember = FunTmpl->getTemplatedDecl();
  else if (VarTemplateDecl *VarTmpl = dyn_cast<VarTemplateDecl>(Member))
    NonTemplateMember = VarTmpl->getTemplatedDecl();

  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 (NonTemplateMember != Member)
    NonTemplateMember->setAccess(AS);

  // C++ [temp.deduct.guide]p3:
  //   A deduction guide [...] for a member class template [shall be
  //   declared] with the same access [as the template].
  if (auto *DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {
    auto *TD = DG->getDeducedTemplate();
    // Access specifiers are only meaningful if both the template and the
    // deduction guide are from the same scope.
    if (AS != TD->getAccess() &&
        TD->getDeclContext()->getRedeclContext()->Equals(
            DG->getDeclContext()->getRedeclContext())) {
      Diag(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);
      Diag(TD->getBeginLoc(), diag::note_deduction_guide_template_access)
          << TD->getAccess();
      const AccessSpecDecl *LastAccessSpec = nullptr;
      for (const auto *D : cast<CXXRecordDecl>(CurContext)->decls()) {
        if (const auto *AccessSpec = dyn_cast<AccessSpecDecl>(D))
          LastAccessSpec = AccessSpec;
      }
      assert(LastAccessSpec && "differing access with no access specifier")((LastAccessSpec && "differing access with no access specifier"
) ? static_cast<void> (0) : __assert_fail ("LastAccessSpec && \"differing access with no access specifier\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3408, __PRETTY_FUNCTION__));
      Diag(LastAccessSpec->getBeginLoc(), diag::note_deduction_guide_access)
          << AS;
    }
  }
}

if (VS.isOverrideSpecified())
  Member->addAttr(OverrideAttr::Create(Context, VS.getOverrideLoc(),
                                       AttributeCommonInfo::AS_Keyword));
if (VS.isFinalSpecified())
  Member->addAttr(FinalAttr::Create(
      Context, VS.getFinalLoc(), AttributeCommonInfo::AS_Keyword,
      static_cast<FinalAttr::Spelling>(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 ?")(((Name || isInstField) && "No identifier for non-field ?"
) ? static_cast<void> (0) : __assert_fail ("(Name || isInstField) && \"No identifier for non-field ?\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3431, __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;
3450}

3452namespace {
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 uninitialized 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());
    }
  }
}
3853} // namespace

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

3864/// This is invoked after parsing an in-class initializer for a
3865/// non-static C++ class member, and after instantiating an in-class initializer
3866/// in a class template. Such actions are deferred until the class is complete.
3867void 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) &&(((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle
() != ICIS_NoInit) && "must set init style when field is created"
) ? static_cast<void> (0) : __assert_fail ("(isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) && \"must set init style when field is created\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3875, __PRETTY_FUNCTION__))
       "must set init style when field is created")(((isa<MSPropertyDecl>(D) || FD->getInClassInitStyle
() != ICIS_NoInit) && "must set init style when field is created"
) ? static_cast<void> (0) : __assert_fail ("(isa<MSPropertyDecl>(D) || FD->getInClassInitStyle() != ICIS_NoInit) && \"must set init style when field is created\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 3875, __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::InitializeMemberFromDefaultMemberInitializer(FD);
  InitializationKind Kind =
      FD->getInClassInitStyle() == ICIS_ListInit
          ? InitializationKind::CreateDirectList(InitExpr->getBeginLoc(),
                                                 InitExpr->getBeginLoc(),
                                                 InitExpr->getEndLoc())
          : InitializationKind::CreateCopy(InitExpr->getBeginLoc(), 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, /*DiscardedValue*/ false);
if (Init.isInvalid()) {
  FD->setInvalidDecl();
  return;
}

InitExpr = Init.get();

FD->setInClassInitializer(InitExpr);
3920}

3922/// Find the direct and/or virtual base specifiers that
3923/// correspond to the given base type, for use in base initialization
3924/// within a constructor.
3925static 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()) {
  if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
    // We found a direct base of this type. That's what we're
    // initializing.
    DirectBaseSpec = &Base;
    break;
  }
}

// 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;
if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
  // 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;
3964}

3966/// Handle a C++ member initializer using braced-init-list syntax.
3967MemInitResult
3968Sema::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);
3980}

3982/// Handle a C++ member initializer using parentheses syntax.
3983MemInitResult
3984Sema::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 = ParenListExpr::Create(Context, LParenLoc, Args, RParenLoc);
return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
                           DS, IdLoc, List, EllipsisLoc);
3998}

4000namespace {

4002// Callback to only accept typo corrections that can be a valid C++ member
4003// intializer: either a non-static field member or a base class.
4004class MemInitializerValidatorCCC final : public CorrectionCandidateCallback {
4005public:
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;
}

std::unique_ptr<CorrectionCandidateCallback> clone() override {
  return std::make_unique<MemInitializerValidatorCCC>(*this);
}

4022private:
CXXRecordDecl *ClassDecl;
4024};

4026}

4028ValueDecl *Sema::tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
                                           CXXScopeSpec &SS,
                                           ParsedType TemplateTypeTy,
                                           IdentifierInfo *MemberOrBase) {
if (SS.getScopeRep() || TemplateTypeTy)
  return nullptr;
DeclContext::lookup_result Result = ClassDecl->lookup(MemberOrBase);
if (Result.empty())
  return nullptr;
ValueDecl *Member;
if ((Member = dyn_cast<FieldDecl>(Result.front())) ||
    (Member = dyn_cast<IndirectFieldDecl>(Result.front())))
  return Member;
return nullptr;
4042}

4044/// Handle a C++ member initializer.
4045MemInitResult
4046Sema::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())
  return true;
Init = Res.get();

if (!ConstructorD)
  return true;

AdjustDeclIfTemplate(ConstructorD);

CXXConstructorDecl *Constructor
  = dyn_cast<CXXConstructorDecl>(ConstructorD);
if (!Constructor) {
  // 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. ]

// Look for a member, first.
if (ValueDecl *Member = tryLookupCtorInitMemberDecl(
        ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {
  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) {
  BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
  if (BaseType.isNull())
    return true;
} else if (DS.getTypeSpecType() == TST_decltype) {
  BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
} else if (DS.getTypeSpecType() == TST_decltype_auto) {
  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) {
    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;
    MemInitializerValidatorCCC CCC(ClassDecl);
    if (R.empty() && BaseType.isNull() &&
        (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
                            CCC, 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->getBeginLoc(), 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()) {
    BaseType = Context.getTypeDeclType(TyD);
    MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
    if (SS.isSet()) {
      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)
  TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);

return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
4215}

4217MemInitResult
4218Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
                           SourceLocation IdLoc) {
FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
assert((DirectMember || IndirectMember) &&(((DirectMember || IndirectMember) && "Member must be a FieldDecl or IndirectFieldDecl"
) ? static_cast<void> (0) : __assert_fail ("(DirectMember || IndirectMember) && \"Member must be a FieldDecl or IndirectFieldDecl\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4223, __PRETTY_FUNCTION__))
       "Member must be a FieldDecl or IndirectFieldDecl")(((DirectMember || IndirectMember) && "Member must be a FieldDecl or IndirectFieldDecl"
) ? static_cast<void> (0) : __assert_fail ("(DirectMember || IndirectMember) && \"Member must be a FieldDecl or IndirectFieldDecl\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4223, __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->getBeginLoc(), Init->getEndLoc())
               : 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;

  // C++11 [class.base.init]p7:
  //   The initialization of each base and member constitutes a
  //   full-expression.
  MemberInit = ActOnFinishFullExpr(MemberInit.get(), InitRange.getBegin(),
                                   /*DiscardedValue*/ false);
  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());
}
4291}

4293MemInitResult
4294Sema::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->getBeginLoc(), Init->getEndLoc())
             : 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() &&((cast<CXXConstructExpr>(DelegationInit.get())->getConstructor
() && "Delegating constructor with no target?") ? static_cast
<void> (0) : __assert_fail ("cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() && \"Delegating constructor with no target?\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4325, __PRETTY_FUNCTION__))
       "Delegating constructor with no target?")((cast<CXXConstructExpr>(DelegationInit.get())->getConstructor
() && "Delegating constructor with no target?") ? static_cast
<void> (0) : __assert_fail ("cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() && \"Delegating constructor with no target?\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4325, __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(), /*DiscardedValue*/ false);
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());
4348}

4350MemInitResult
4351Sema::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()) {
  // 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))
    return true;

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

// Check for direct and virtual base classes.
const CXXBaseSpecifier *DirectBaseSpec = nullptr;
const CXXBaseSpecifier *VirtualBaseSpec = nullptr;
if (!Dependent) {
  if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
                                     BaseType))
    return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);

  FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
                      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) {
  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)
  return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
    << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();

const CXXBaseSpecifier *BaseSpec = DirectBaseSpec;
if (!BaseSpec)
  BaseSpec = VirtualBaseSpec;

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

InitializedEntity BaseEntity =
  InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
InitializationKind Kind =
    InitList ? InitializationKind::CreateDirectList(BaseLoc)
             : 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())
  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(),
                               /*DiscardedValue*/ false);
if (BaseInit.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())
  BaseInit = Init;

return new (Context) CXXCtorInitializer(Context, BaseTInfo,
                                        BaseSpec->isVirtual(),
                                        InitRange.getBegin(),
                                        BaseInit.getAs<Expr>(),
                                        InitRange.getEnd(), EllipsisLoc);
4480}

4482// Create a static_cast\<T&&>(expr).
4483static 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->getBeginLoc();
TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
    TargetType, ExprLoc);

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

4496/// ImplicitInitializerKind - How an implicit base or member initializer should
4497/// initialize its base or member.
4498enum ImplicitInitializerKind {
IIK_Default,
IIK_Copy,
IIK_Move,
IIK_Inherit
4503};

4505static bool
4506BuildImplicitBaseInitializer(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;
4581}

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

4588static bool
4589BuildImplicitMemberInitializer(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->isZeroLengthBitField(SemaRef.Context))
    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) &&(((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit
) && "Unhandled implicit init kind!") ? static_cast<
void> (0) : __assert_fail ("(ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) && \"Unhandled implicit init kind!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4673, __PRETTY_FUNCTION__))
       "Unhandled implicit init kind!")(((ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit
) && "Unhandled implicit init kind!") ? static_cast<
void> (0) : __assert_fail ("(ImplicitInitKind == IIK_Default || ImplicitInitKind == IIK_Inherit) && \"Unhandled implicit init kind!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4673, __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;
4745}

4747namespace {
4748struct 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-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4781);
}

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();
}

/// 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;
}
4834};
4835}

4837/// Determine whether the given type is an incomplete or zero-lenfgth
4838/// array type.
4839static 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;
4851}

4853static 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;

  auto Entity = InitializedEntity::InitializeMember(Field, nullptr, true);
  SemaRef.checkInitializerLifetime(Entity, DIE.get());

  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);
4919}

4921bool
4922Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor,
                             CXXCtorInitializer *Initializer) {
assert(Initializer->isDelegatingInitializer())((Initializer->isDelegatingInitializer()) ? static_cast<
void> (0) : __assert_fail ("Initializer->isDelegatingInitializer()"
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 4924, __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;
4941}

4943bool 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() &&((ClassDecl->hasFlexibleArrayMember() && "Incomplete array type is not valid"
) ? static_cast<void> (0) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5089, __PRETTY_FUNCTION__))
             "Incomplete array type is not valid")((ClassDecl->hasFlexibleArrayMember() && "Incomplete array type is not valid"
) ? static_cast<void> (0) : __assert_fail ("ClassDecl->hasFlexibleArrayMember() && \"Incomplete array type is not valid\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5089, __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;
5117}

5119static 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());
5129}

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

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

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

5143static 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 &&((IdealIndex < NumIdealInits && "initializer not found in initializer list"
) ? static_cast<void> (0) : __assert_fail ("IdealIndex < NumIdealInits && \"initializer not found in initializer list\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5227, __PRETTY_FUNCTION__))
           "initializer not found in initializer list")((IdealIndex < NumIdealInits && "initializer not found in initializer list"
) ? static_cast<void> (0) : __assert_fail ("IdealIndex < NumIdealInits && \"initializer not found in initializer list\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5227, __PRETTY_FUNCTION__));
  }

  PrevInit = Init;
}
5232}

5234namespace {
5235bool 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")((BaseClass && "neither field nor base") ? static_cast
<void> (0) : __assert_fail ("BaseClass && \"neither field nor base\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5250, __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;
5260}

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

5265bool 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;
5297}
5298}

5300/// ActOnMemInitializers - Handle the member initializers for a constructor.
5301void 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())((Init->isDelegatingInitializer()) ? static_cast<void>
 (0) : __assert_fail ("Init->isDelegatingInitializer()", "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5343, __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);
5365}

5367void
5368Sema::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!")((Dtor && "No dtor found for FieldClassDecl!") ? static_cast
<void> (0) : __assert_fail ("Dtor && \"No dtor found for FieldClassDecl!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5405, __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!")((Dtor && "No dtor found for BaseClassDecl!") ? static_cast
<void> (0) : __assert_fail ("Dtor && \"No dtor found for BaseClassDecl!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5441, __PRETTY_FUNCTION__));

  // FIXME: caret should be on the start of the class name
  CheckDestructorAccess(Base.getBeginLoc(), 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!")((Dtor && "No dtor found for BaseClassDecl!") ? static_cast
<void> (0) : __assert_fail ("Dtor && \"No dtor found for BaseClassDecl!\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 5473, __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);
}
5489}

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

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

5502bool 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();
5521}

5523bool 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;
5532}

5534void 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);
5584}

5586namespace {
5587struct 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);
5606};

5608struct 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()) {
5617#define ABSTRACT_TYPELOC(CLASS, PARENT)
5618#define TYPELOC(CLASS, PARENT) \
  case TypeLoc::CLASS: Check(TL.castAs<CLASS##TypeLoc>(), Sel); break;
5620#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.
5651#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();
}
5693};

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

5700}

5702/// Check for invalid uses of an abstract type in a method declaration.
5703static 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);
5715}

5717/// Check for invalid uses of an abstract type within a class definition.
5718static 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());
  }
}
5748}

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

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

TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();

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

if (S.Context.getTargetInfo().getTriple().isWindowsGNUEnvironment())
  S.MarkVTableUsed(Class->getLocation(), Class, true);

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 << !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));
    }
  }
}
5813}

5815static 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;
}
5851}

5853void Sema::checkClassLevelCodeSegAttribute(CXXRecordDecl *Class) {
// Mark any compiler-generated routines with the implicit code_seg attribute.
for (auto *Method : Class->methods()) {
  if (Method->isUserProvided())
    continue;
  if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
    Method->addAttr(A);
}
5861}

5863/// Check class-level dllimport/dllexport attribute.
5864void 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;

// Check if this was a dllimport attribute propagated from a derived class to
// a base class template specialization. We don't apply these attributes to
// static data members.
const bool PropagatedImport =
    !ClassExported &&
    cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();

TemplateSpecializationKind TSK = Class->getTemplateSpecializationKind();

// Ignore explicit dllexport on explicit class template instantiation
// declarations, except in MinGW mode.
if (ClassExported && !ClassAttr->isInherited() &&
    TSK == TSK_ExplicitInstantiationDeclaration &&
    !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {
  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. But do it for
      // template instantiations.
      if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
          !Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment() &&
          TSK != TSK_ExplicitInstantiationDeclaration &&
          TSK != TSK_ExplicitInstantiationDefinition)
        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;
    }
  }

  // Don't apply dllimport attributes to static data members of class template
  // instantiations when the attribute is propagated from a derived class.
  if (VD && PropagatedImport)
    continue;

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

  if (!getDLLAttr(Member)) {
    InheritableAttr *NewAttr = nullptr;

    // Do not export/import inline function when -fno-dllexport-inlines is
    // passed. But add attribute for later local static var check.
    if (!getLangOpts().DllExportInlines && MD && MD->isInlined() &&
        TSK != TSK_ExplicitInstantiationDeclaration &&
        TSK != TSK_ExplicitInstantiationDefinition) {
      if (ClassExported) {
        NewAttr = ::new (getASTContext())
            DLLExportStaticLocalAttr(getASTContext(), *ClassAttr);
      } else {
        NewAttr = ::new (getASTContext())
            DLLImportStaticLocalAttr(getASTContext(), *ClassAttr);
      }
    } else {
      NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
    }

    NewAttr->setInherited(true);
    Member->addAttr(NewAttr);

    if (MD) {
      // Propagate DLLAttr to friend re-declarations of MD that have already
      // been constructed.
      for (FunctionDecl *FD = MD->getMostRecentDecl(); FD;
           FD = FD->getPreviousDecl()) {
        if (FD->getFriendObjectKind() == Decl::FOK_None)
          continue;
        assert(!getDLLAttr(FD) &&((!getDLLAttr(FD) && "friend re-decl should not already have a DLLAttr"
) ? static_cast<void> (0) : __assert_fail ("!getDLLAttr(FD) && \"friend re-decl should not already have a DLLAttr\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6014, __PRETTY_FUNCTION__))
               "friend re-decl should not already have a DLLAttr")((!getDLLAttr(FD) && "friend re-decl should not already have a DLLAttr"
) ? static_cast<void> (0) : __assert_fail ("!getDLLAttr(FD) && \"friend re-decl should not already have a DLLAttr\""
, "/build/llvm-toolchain-snapshot-10~svn374814/tools/clang/lib/Sema/SemaDeclCXX.cpp"
, 6014, __PRETTY_FUNCTION__));
        NewAttr = cast<InheritableAttr>(ClassAttr->clone(getASTContext()));
        NewAttr->setInherited(true);
        FD->addAttr(NewAttr);
      }
    }
  }
}

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

6027/// Perform propagation of DLL attributes from a derived class to a
6028/// templated base class for MS compatibility.
6029void 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 this was an import, mark that we propagated it from a derived class to
  // a base class template specialization.
  if (auto *ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))
    ImportAttr->setPropagatedToBaseTemplate();

  // 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;
}
6085}

6087static 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:
  