//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file implements semantic analysis for C++ declarations.

//

//===----------------------------------------------------------------------===//

#include "clang/AST/ASTConsumer.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/ASTLambda.h"

#include "clang/AST/ASTMutationListener.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/CharUnits.h"

#include "clang/AST/ComparisonCategories.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/EvaluatedExprVisitor.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/RecordLayout.h"

#include "clang/AST/RecursiveASTVisitor.h"

#include "clang/AST/StmtVisitor.h"

#include "clang/AST/TypeLoc.h"

#include "clang/AST/TypeOrdering.h"

#include "clang/Basic/AttributeCommonInfo.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Lex/LiteralSupport.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Sema/CXXFieldCollector.h"

#include "clang/Sema/DeclSpec.h"

#include "clang/Sema/EnterExpressionEvaluationContext.h"

#include "clang/Sema/Initialization.h"

#include "clang/Sema/Lookup.h"

#include "clang/Sema/Ownership.h"

#include "clang/Sema/ParsedTemplate.h"

#include "clang/Sema/Scope.h"

#include "clang/Sema/ScopeInfo.h"

#include "clang/Sema/SemaInternal.h"

#include "clang/Sema/Template.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/ScopeExit.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Support/ConvertUTF.h"

#include "llvm/Support/SaveAndRestore.h"

#include <map>

#include <optional>

#include <set>

using namespace clang;

//===----------------------------------------------------------------------===//

// CheckDefaultArgumentVisitor

//===----------------------------------------------------------------------===//

namespace {

/// 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 ConstStmtVisitor<CheckDefaultArgumentVisitor, bool> {

  Sema &S;

  const Expr *DefaultArg;

public:

  CheckDefaultArgumentVisitor(Sema &S, const Expr *DefaultArg)

      : S(S), DefaultArg(DefaultArg) {}

  bool VisitExpr(const Expr *Node);

  bool VisitDeclRefExpr(const DeclRefExpr *DRE);

  bool VisitCXXThisExpr(const CXXThisExpr *ThisE);

  bool VisitLambdaExpr(const LambdaExpr *Lambda);

  bool VisitPseudoObjectExpr(const PseudoObjectExpr *POE);

};

/// VisitExpr - Visit all of the children of this expression.

bool CheckDefaultArgumentVisitor::VisitExpr(const Expr *Node) {

  bool IsInvalid = false;

  for (const Stmt *SubStmt : Node->children())

    if (SubStmt)

      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(const DeclRefExpr *DRE) {

  const ValueDecl *Decl = dyn_cast<ValueDecl>(DRE->getDecl());

  if (!isa<VarDecl, BindingDecl>(Decl))

    return false;

  if (const auto *Param = dyn_cast<ParmVarDecl>(Decl)) {

    // C++ [dcl.fct.default]p9:

    //   [...] parameters of a function shall not be used in default

    //   argument expressions, even if they are not evaluated. [...]

    //

    // C++17 [dcl.fct.default]p9 (by CWG 2082):

    //   [...] A parameter shall not appear as a potentially-evaluated

    //   expression in a default argument. [...]

    //

    if (DRE->isNonOdrUse() != NOUR_Unevaluated)

      return S.Diag(DRE->getBeginLoc(),

                    diag::err_param_default_argument_references_param)

             << Param->getDeclName() << DefaultArg->getSourceRange();

  } else if (auto *VD = Decl->getPotentiallyDecomposedVarDecl()) {

    // C++ [dcl.fct.default]p7:

    //   Local variables shall not be used in default argument

    //   expressions.

    //

    // C++17 [dcl.fct.default]p7 (by CWG 2082):

    //   A local variable shall not appear as a potentially-evaluated

    //   expression in a default argument.

    //

    // C++20 [dcl.fct.default]p7 (DR as part of P0588R1, see also CWG 2346):

    //   Note: A local variable cannot be odr-used (6.3) in a default

    //   argument.

    //

    if (VD->isLocalVarDecl() && !DRE->isNonOdrUse())

      return S.Diag(DRE->getBeginLoc(),

                    diag::err_param_default_argument_references_local)

             << Decl << DefaultArg->getSourceRange();

  }

  return false;

}

/// VisitCXXThisExpr - Visit a C++ "this" expression.

bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(const 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(

    const PseudoObjectExpr *POE) {

  bool Invalid = false;

  for (const Expr *E : POE->semantics()) {

    // Look through bindings.

    if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E)) {

      E = OVE->getSourceExpr();

      assert(E && "pseudo-object binding without source expression?");

    }

    Invalid |= Visit(E);

  }

  return Invalid;

}

bool CheckDefaultArgumentVisitor::VisitLambdaExpr(const LambdaExpr *Lambda) {

  // [expr.prim.lambda.capture]p9

  // a lambda-expression appearing in a default argument cannot implicitly or

  // explicitly capture any local entity. Such a lambda-expression can still

  // have an init-capture if any full-expression in its initializer satisfies

  // the constraints of an expression appearing in a default argument.

  bool Invalid = false;

  for (const LambdaCapture &LC : Lambda->captures()) {

    if (!Lambda->isInitCapture(&LC))

      return S.Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);

    // Init captures are always VarDecl.

    auto *D = cast<VarDecl>(LC.getCapturedVar());

    Invalid |= Visit(D->getInit());

  }

  return Invalid;

}

} // namespace

void

Sema::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");

  // 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(

        "should not generate implicit declarations for dependent cases");

  case EST_Dynamic:

    break;

  }

  assert(EST == EST_Dynamic && "EST case not considered earlier.");

  assert(ComputedEST != EST_None &&

         "Shouldn't collect exceptions when throw-all is guaranteed.");

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

}

void Sema::ImplicitExceptionSpecification::CalledStmt(Stmt *S) {

  if (!S || 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(S))

    ComputedEST = EST_None;

}

ExprResult Sema::ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,

                                             SourceLocation EqualLoc) {

  if (RequireCompleteType(Param->getLocation(), Param->getType(),

                          diag::err_typecheck_decl_incomplete_type))

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

  return Arg;

}

void Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,

                                   SourceLocation EqualLoc) {

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

  }

}

/// ActOnParamDefaultArgument - Check whether the default argument

/// provided for a function parameter is well-formed. If so, attach it

/// to the parameter declaration.

void

Sema::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();

    return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);

  }

  // Check for unexpanded parameter packs.

  if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument))

    return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);

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

    // Recover by discarding the default argument.

    Param->setDefaultArg(nullptr);

    return;

  }

  ExprResult Result = ConvertParamDefaultArgument(Param, DefaultArg, EqualLoc);

  if (Result.isInvalid())

    return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);

  DefaultArg = Result.getAs<Expr>();

  // Check that the default argument is well-formed

  CheckDefaultArgumentVisitor DefaultArgChecker(*this, DefaultArg);

  if (DefaultArgChecker.Visit(DefaultArg))

    return ActOnParamDefaultArgumentError(param, EqualLoc, DefaultArg);

  SetParamDefaultArgument(Param, DefaultArg, EqualLoc);

}

/// ActOnParamUnparsedDefaultArgument - We've seen a default

/// argument for a function parameter, but we can't parse it yet

/// because we're inside a class definition. Note that this default

/// argument will be parsed later.

void Sema::ActOnParamUnparsedDefaultArgument(Decl *param,

                                             SourceLocation EqualLoc,

                                             SourceLocation ArgLoc) {

  if (!param)

    return;

  ParmVarDecl *Param = cast<ParmVarDecl>(param);

  Param->setUnparsedDefaultArg();

  UnparsedDefaultArgLocs[Param] = ArgLoc;

}

/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of

/// the default argument for the parameter param failed.

void Sema::ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc,

                                          Expr *DefaultArg) {

  if (!param)

    return;

  ParmVarDecl *Param = cast<ParmVarDecl>(param);

  Param->setInvalidDecl();

  UnparsedDefaultArgLocs.erase(Param);

  ExprResult RE;

  if (DefaultArg) {

    RE = CreateRecoveryExpr(EqualLoc, DefaultArg->getEndLoc(), {DefaultArg},

                            Param->getType().getNonReferenceType());

  } else {

    RE = CreateRecoveryExpr(EqualLoc, EqualLoc, {},

                            Param->getType().getNonReferenceType());

  }

  Param->setDefaultArg(RE.get());

}

/// CheckExtraCXXDefaultArguments - Check for any extra default

/// arguments in the declarator, which is not a function declaration

/// or definition and therefore is not permitted to have default

/// arguments. This routine should be invoked for every declarator

/// that is not a function declaration or definition.

void 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;

    }

  }

}

static bool functionDeclHasDefaultArgument(const FunctionDecl *FD) {

  return llvm::any_of(FD->parameters(), [](ParmVarDecl *P) {

    return P->hasDefaultArg() && !P->hasInheritedDefaultArg();

  });

}

/// MergeCXXFunctionDecl - Merge two declarations of the same C++

/// function, once we already know that they have the same

/// type. Subroutine of MergeFunctionDecl. Returns true if there was an

/// error, false otherwise.

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

      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 << static_cast<int>(New->getConstexprKind())

        << static_cast<int>(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() && isVisible(Old)) {

    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;

  }

  // C++11 [temp.friend]p4 (DR329):

  //   When a function is defined in a friend function declaration in a class

  //   template, the function is instantiated when the function is odr-used.

  //   The same restrictions on multiple declarations and definitions that

  //   apply to non-template function declarations and definitions also apply

  //   to these implicit definitions.

  const FunctionDecl *OldDefinition = nullptr;

  if (New->isThisDeclarationInstantiatedFromAFriendDefinition() &&

      Old->isDefined(OldDefinition, true))

    CheckForFunctionRedefinition(New, OldDefinition);

  return Invalid;

}

void Sema::DiagPlaceholderVariableDefinition(SourceLocation Loc) {

  Diag(Loc, getLangOpts().CPlusPlus26

                ? diag::warn_cxx23_placeholder_var_definition

                : diag::ext_placeholder_var_definition);

}

NamedDecl *

Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,

                                   MultiTemplateParamsArg TemplateParamLists) {

  assert(D.isDecompositionDeclarator());

  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::Condition

                 ? 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++20 [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.

  // C++23 [dcl.pre]/6:

  //   Each decl-specifier in the decl-specifier-seq shall be static,

  //   thread_local, auto (9.2.9.6 [dcl.spec.auto]), or a cv-qualifier.

  auto &DS = D.getDeclSpec();

  {

    // Note: While constrained-auto needs to be checked, we do so separately so

    // we can emit a better diagnostic.

    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().CPlusPlus20

                             ? 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().CPlusPlus20)

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

  }

  // Constrained auto is prohibited by [decl.pre]p6, so check that here.

  if (DS.isConstrainedAuto()) {

    TemplateIdAnnotation *TemplRep = DS.getRepAsTemplateId();

    assert(TemplRep->Kind == TNK_Concept_template &&

           "No other template kind should be possible for a constrained auto");

    SourceRange TemplRange{TemplRep->TemplateNameLoc,

                           TemplRep->RAngleLoc.isValid()

                               ? TemplRep->RAngleLoc

                               : TemplRep->TemplateNameLoc};

    Diag(TemplRep->TemplateNameLoc, diag::err_decomp_decl_constraint)

        << TemplRange << FixItHint::CreateRemoval(TemplRange);

  }

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

    IdentifierInfo *VarName = B.Name;

    assert(VarName && "Cannot have an unnamed binding declaration");

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

    }

    auto *BD = BindingDecl::Create(Context, DC, B.NameLoc, VarName);

    // Find the shadowed declaration before filtering for scope.

    NamedDecl *ShadowedDecl = D.getCXXScopeSpec().isEmpty()

                                  ? getShadowedDeclaration(BD, Previous)

                                  : nullptr;

    bool ConsiderLinkage = DC->isFunctionOrMethod() &&

                           DS.getStorageClassSpec() == DeclSpec::SCS_extern;

    FilterLookupForScope(Previous, DC, S, ConsiderLinkage,

                         /*AllowInlineNamespace*/false);

    bool IsPlaceholder = DS.getStorageClassSpec() != DeclSpec::SCS_static &&

                         DC->isFunctionOrMethod() && VarName->isPlaceholder();

    if (!Previous.empty()) {

      if (IsPlaceholder) {

        bool sameDC = (Previous.end() - 1)

                          ->getDeclContext()