//===------ 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/EvaluatedExprVisitor.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/Initialization.h"

#include "clang/Sema/Lookup.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/ScopeExit.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringExtras.h"

#include <map>

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

    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 NamedDecl *Decl = DRE->getDecl();

  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 (const auto *VDecl = dyn_cast<VarDecl>(Decl)) {

    // 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 (VDecl->isLocalVarDecl() && 
!DRE->isNonOdrUse()13
)

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

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

}

} // 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>()1.46k
)

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

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

  auto Fail = [&] {

    Param->setInvalidDecl();

    Param->setDefaultArg(new (Context) OpaqueValueExpr(

        EqualLoc, Param->getType().getNonReferenceType(), VK_PRValue));

  };

  // Default arguments are only permitted in C++

  if (!getLangOpts().CPlusPlus) {

    Diag(EqualLoc, diag::err_param_default_argument)

      << DefaultArg->getSourceRange();

    return Fail();

  }

  // Check for unexpanded parameter packs.

  if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {

    return Fail();

  }

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

  DefaultArg = Result.getAs<Expr>();

  // Check that the default argument is well-formed

  CheckDefaultArgumentVisitor DefaultArgChecker(*this, DefaultArg);

  if (DefaultArgChecker.Visit(DefaultArg))

    return Fail();

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

  if (!param)

    return;

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

  Param->setInvalidDecl();

  UnparsedDefaultArgLocs.erase(Param);

  Param->setDefaultArg(new (Context) OpaqueValueExpr(

      EqualLoc, Param->getType().getNonReferenceType(), VK_PRValue));

}

/// 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; 
++i15.0M
) {

    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; 121k
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()56
;

  });

}

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

                             : 
New->getDeclContext()209k
;

  // 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 = 558
New->isLocalExternDecl()558

                                ? 
nullptr181

                                : 
PrevForDefaultArgs->getPreviousDecl()377
) {

    // Ignore hidden declarations.

    if (!LookupResult::isVisible(*this, PrevForDefaultArgs))

      continue;

    if (S && 
!isDeclInScope(PrevForDefaultArgs, ScopeDC, S)197k
 &&

        
!New->isCXXClassMember()220
) {

      // 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()208k

                                       : 
0396
;

       p < NumParams; 
++p335k
) {

    ParmVarDecl *OldParam = PrevForDefaultArgs->getParamDecl(p);

    ParmVarDecl *NewParam = New->getParamDecl(p);

    bool OldParamHasDfl = OldParam ? OldParam->hasDefaultArg() : 
false0
;

    bool NewParamHasDfl = NewParam->hasDefaultArg();

    if (OldParamHasDfl && 
NewParamHasDfl21.1k
) {

      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()331
) {

        // 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()24.6k
) {

    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()165k
 &&

             
Old->isDefined(Def)61.8k
 &&

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

             
(21
New->isInlineSpecified()21
 ||

              
New->getFriendObjectKind() == Decl::FOK_None2
)) {

    // 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()7
 && 
isVisible(Old)3
) {

    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)2.11k
) {

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

    CheckForFunctionRedefinition(New, OldDefinition);

  return Invalid;

}

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_decl15

           : 
D.getContext() == DeclaratorContext::Condition415

                 ? 
diag::ext_decomp_decl_cond30

                 : 
diag::warn_cxx14_compat_decomp_decl385
)

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

                             ? 
diag::warn_cxx17_compat_decomp_decl_spec5

                             : 
diag::ext_decomp_decl_spec12
);

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

    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()411
 || 
D.getNumTypeObjects() > 1411
 ||

      
(411
D.getNumTypeObjects() == 1411
 &&

       
D.getTypeObject(0).Kind != DeclaratorChunk::Reference144
)) {

    Diag(Decomp.getLSquareLoc(),

         (D.hasGroupingParens() ||

          (D.getNumTypeObjects() &&

           
D.getTypeObject(0).Kind == DeclaratorChunk::Paren6
))

             ? 
diag::err_decomp_decl_parens2

             : 
diag::err_decomp_decl_type21
)

        << 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()61
) {

      DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),

                                      Previous.getFoundDecl());

      Previous.clear();

    }

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

    // Find the shadowed declaration before filtering for scope.

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

                                  ? getShadowedDeclaration(BD, Previous)

                                  : 
nullptr0
;

    bool ConsiderLinkage = DC->isFunctionOrMethod() &&

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

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

    } else if (ShadowedDecl && 
!D.isRedeclaration()8
) {

      CheckShadow(BD, ShadowedDecl, Previous);

    }

    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;

}

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

        << (unsigned)NumElems.getLimitedValue(UINT_MAX)

        << toString(NumElems, 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;

}

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

      });

}

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

}

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

}

static 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_Imag3
 : 
UO_Real3
, Base);

      });

}

static std::string printTemplateArgs(const PrintingPolicy &PrintingPolicy,

                                     TemplateArgumentListInfo &Args,

                                     const TemplateParameterList *Params) {

  SmallString<128> SS;

  llvm::raw_svector_ostream OS(SS);

  bool First = true;

  unsigned I = 0;

  for (auto &Arg : Args.arguments()) {

    if (!First)

      OS << ", ";

    Arg.getArgument().print(PrintingPolicy, OS,

                            TemplateParameterList::shouldIncludeTypeForArgument(

                                PrintingPolicy, Params, I));

    First = false;

    I++;

  }

  return std::string(OS.str());

}

static 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, /*Params*/ nullptr);

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