//===--- SemaLambda.cpp - Semantic Analysis for C++11 Lambdas -------------===//

//

// 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++ lambda expressions.

//

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

#include "clang/Sema/DeclSpec.h"

#include "TypeLocBuilder.h"

#include "clang/AST/ASTLambda.h"

#include "clang/AST/ExprCXX.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Sema/Initialization.h"

#include "clang/Sema/Lookup.h"

#include "clang/Sema/Scope.h"

#include "clang/Sema/ScopeInfo.h"

#include "clang/Sema/SemaInternal.h"

#include "clang/Sema/SemaLambda.h"

#include "llvm/ADT/STLExtras.h"

using namespace clang;

using namespace sema;

/// Examines the FunctionScopeInfo stack to determine the nearest

/// enclosing lambda (to the current lambda) that is 'capture-ready' for

/// the variable referenced in the current lambda (i.e. \p VarToCapture).

/// If successful, returns the index into Sema's FunctionScopeInfo stack

/// of the capture-ready lambda's LambdaScopeInfo.

///

/// Climbs down the stack of lambdas (deepest nested lambda - i.e. current

/// lambda - is on top) to determine the index of the nearest enclosing/outer

/// lambda that is ready to capture the \p VarToCapture being referenced in

/// the current lambda.

/// As we climb down the stack, we want the index of the first such lambda -

/// that is the lambda with the highest index that is 'capture-ready'.

///

/// A lambda 'L' is capture-ready for 'V' (var or this) if:

///  - its enclosing context is non-dependent

///  - and if the chain of lambdas between L and the lambda in which

///    V is potentially used (i.e. the lambda at the top of the scope info

///    stack), can all capture or have already captured V.

/// If \p VarToCapture is 'null' then we are trying to capture 'this'.

///

/// Note that a lambda that is deemed 'capture-ready' still needs to be checked

/// for whether it is 'capture-capable' (see

/// getStackIndexOfNearestEnclosingCaptureCapableLambda), before it can truly

/// capture.

///

/// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a

///  LambdaScopeInfo inherits from).  The current/deepest/innermost lambda

///  is at the top of the stack and has the highest index.

/// \param VarToCapture - the variable to capture.  If NULL, capture 'this'.

///

/// \returns An Optional<unsigned> Index that if evaluates to 'true' contains

/// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda

/// which is capture-ready.  If the return value evaluates to 'false' then

/// no lambda is capture-ready for \p VarToCapture.

static inline Optional<unsigned>

getStackIndexOfNearestEnclosingCaptureReadyLambda(

    ArrayRef<const clang::sema::FunctionScopeInfo *> FunctionScopes,

    VarDecl *VarToCapture) {

  // Label failure to capture.

  const Optional<unsigned> NoLambdaIsCaptureReady;

  // Ignore all inner captured regions.

  unsigned CurScopeIndex = FunctionScopes.size() - 1;

  while (CurScopeIndex > 0 && isa<clang::sema::CapturedRegionScopeInfo>(

                                  FunctionScopes[CurScopeIndex]))

    --CurScopeIndex;

  assert(

      isa<clang::sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]) &&

      "The function on the top of sema's function-info stack must be a lambda");

  // If VarToCapture is null, we are attempting to capture 'this'.

  const bool IsCapturingThis = !VarToCapture;

  const bool IsCapturingVariable = !IsCapturingThis;

  // Start with the current lambda at the top of the stack (highest index).

  DeclContext *EnclosingDC =

      cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex])->CallOperator;

  do {

    const clang::sema::LambdaScopeInfo *LSI =

        cast<sema::LambdaScopeInfo>(FunctionScopes[CurScopeIndex]);

    // IF we have climbed down to an intervening enclosing lambda that contains

    // the variable declaration - it obviously can/must not capture the

    // variable.

    // Since its enclosing DC is dependent, all the lambdas between it and the

    // innermost nested lambda are dependent (otherwise we wouldn't have

    // arrived here) - so we don't yet have a lambda that can capture the

    // variable.

    if (IsCapturingVariable &&

        
VarToCapture->getDeclContext()->Equals(EnclosingDC)817
)

      return NoLambdaIsCaptureReady;

    // For an enclosing lambda to be capture ready for an entity, all

    // intervening lambda's have to be able to capture that entity. If even

    // one of the intervening lambda's is not capable of capturing the entity

    // then no enclosing lambda can ever capture that entity.

    // For e.g.

    // const int x = 10;

    // [=](auto a) {    #1

    //   [](auto b) {   #2 <-- an intervening lambda that can never capture 'x'

    //    [=](auto c) { #3

    //       f(x, c);  <-- can not lead to x's speculative capture by #1 or #2

    //    }; }; };

    // If they do not have a default implicit capture, check to see

    // if the entity has already been explicitly captured.

    // If even a single dependent enclosing lambda lacks the capability

    // to ever capture this variable, there is no further enclosing

    // non-dependent lambda that can capture this variable.

    if (LSI->ImpCaptureStyle == sema::LambdaScopeInfo::ImpCap_None) {

      if (IsCapturingVariable && 
!LSI->isCaptured(VarToCapture)160
)

        return NoLambdaIsCaptureReady;

      if (IsCapturingThis && 
!LSI->isCXXThisCaptured()26
)

        return NoLambdaIsCaptureReady;

    }

    EnclosingDC = getLambdaAwareParentOfDeclContext(EnclosingDC);

    assert(CurScopeIndex);

    --CurScopeIndex;

  } while (!EnclosingDC->isTranslationUnit() &&

           EnclosingDC->isDependentContext() &&

           
isLambdaCallOperator(EnclosingDC)440
);

  assert(CurScopeIndex < (FunctionScopes.size() - 1));

  // If the enclosingDC is not dependent, then the immediately nested lambda

  // (one index above) is capture-ready.

  if (!EnclosingDC->isDependentContext())

    return CurScopeIndex + 1;

  return NoLambdaIsCaptureReady;

}

/// Examines the FunctionScopeInfo stack to determine the nearest

/// enclosing lambda (to the current lambda) that is 'capture-capable' for

/// the variable referenced in the current lambda (i.e. \p VarToCapture).

/// If successful, returns the index into Sema's FunctionScopeInfo stack

/// of the capture-capable lambda's LambdaScopeInfo.

///

/// Given the current stack of lambdas being processed by Sema and

/// the variable of interest, to identify the nearest enclosing lambda (to the

/// current lambda at the top of the stack) that can truly capture

/// a variable, it has to have the following two properties:

///  a) 'capture-ready' - be the innermost lambda that is 'capture-ready':

///     - climb down the stack (i.e. starting from the innermost and examining

///       each outer lambda step by step) checking if each enclosing

///       lambda can either implicitly or explicitly capture the variable.

///       Record the first such lambda that is enclosed in a non-dependent

///       context. If no such lambda currently exists return failure.

///  b) 'capture-capable' - make sure the 'capture-ready' lambda can truly

///  capture the variable by checking all its enclosing lambdas:

///     - check if all outer lambdas enclosing the 'capture-ready' lambda

///       identified above in 'a' can also capture the variable (this is done

///       via tryCaptureVariable for variables and CheckCXXThisCapture for

///       'this' by passing in the index of the Lambda identified in step 'a')

///

/// \param FunctionScopes - Sema's stack of nested FunctionScopeInfo's (which a

/// LambdaScopeInfo inherits from).  The current/deepest/innermost lambda

/// is at the top of the stack.

///

/// \param VarToCapture - the variable to capture.  If NULL, capture 'this'.

///

///

/// \returns An Optional<unsigned> Index that if evaluates to 'true' contains

/// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda

/// which is capture-capable.  If the return value evaluates to 'false' then

/// no lambda is capture-capable for \p VarToCapture.

Optional<unsigned> clang::getStackIndexOfNearestEnclosingCaptureCapableLambda(

    ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes,

    VarDecl *VarToCapture, Sema &S) {

  const Optional<unsigned> NoLambdaIsCaptureCapable;

  const Optional<unsigned> OptionalStackIndex =

      getStackIndexOfNearestEnclosingCaptureReadyLambda(FunctionScopes,

                                                        VarToCapture);

  if (!OptionalStackIndex)

    return NoLambdaIsCaptureCapable;

  const unsigned IndexOfCaptureReadyLambda = OptionalStackIndex.getValue();

  assert(((IndexOfCaptureReadyLambda != (FunctionScopes.size() - 1)) ||

          S.getCurGenericLambda()) &&

         "The capture ready lambda for a potential capture can only be the "

         "current lambda if it is a generic lambda");

  const sema::LambdaScopeInfo *const CaptureReadyLambdaLSI =

      cast<sema::LambdaScopeInfo>(FunctionScopes[IndexOfCaptureReadyLambda]);

  // If VarToCapture is null, we are attempting to capture 'this'

  const bool IsCapturingThis = !VarToCapture;

  const bool IsCapturingVariable = !IsCapturingThis;

  if (IsCapturingVariable) {

    // Check if the capture-ready lambda can truly capture the variable, by

    // checking whether all enclosing lambdas of the capture-ready lambda allow

    // the capture - i.e. make sure it is capture-capable.

    QualType CaptureType, DeclRefType;

    const bool CanCaptureVariable =

        !S.tryCaptureVariable(VarToCapture,

                              /*ExprVarIsUsedInLoc*/ SourceLocation(),

                              clang::Sema::TryCapture_Implicit,

                              /*EllipsisLoc*/ SourceLocation(),

                              /*BuildAndDiagnose*/ false, CaptureType,

                              DeclRefType, &IndexOfCaptureReadyLambda);

    if (!CanCaptureVariable)

      return NoLambdaIsCaptureCapable;

  } else {

    // Check if the capture-ready lambda can truly capture 'this' by checking

    // whether all enclosing lambdas of the capture-ready lambda can capture

    // 'this'.

    const bool CanCaptureThis =

        !S.CheckCXXThisCapture(

             CaptureReadyLambdaLSI->PotentialThisCaptureLocation,

             /*Explicit*/ false, /*BuildAndDiagnose*/ false,

             &IndexOfCaptureReadyLambda);

    if (!CanCaptureThis)

      return NoLambdaIsCaptureCapable;

  }

  return IndexOfCaptureReadyLambda;

}

static inline TemplateParameterList *

getGenericLambdaTemplateParameterList(LambdaScopeInfo *LSI, Sema &SemaRef) {

  if (!LSI->GLTemplateParameterList && 
!LSI->TemplateParams.empty()11.7k
) {

    LSI->GLTemplateParameterList = TemplateParameterList::Create(

        SemaRef.Context,

        /*Template kw loc*/ SourceLocation(),

        /*L angle loc*/ LSI->ExplicitTemplateParamsRange.getBegin(),

        LSI->TemplateParams,

        /*R angle loc*/LSI->ExplicitTemplateParamsRange.getEnd(),

        nullptr);

  }

  return LSI->GLTemplateParameterList;

}

CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange,

                                             TypeSourceInfo *Info,

                                             bool KnownDependent,

                                             LambdaCaptureDefault CaptureDefault) {

  DeclContext *DC = CurContext;

  while (!(DC->isFunctionOrMethod() || 
DC->isRecord()1.08k
 || 
DC->isFileContext()758
))

    DC = DC->getParent();

  bool IsGenericLambda = getGenericLambdaTemplateParameterList(getCurLambda(),

                                                               *this);

  // Start constructing the lambda class.

  CXXRecordDecl *Class = CXXRecordDecl::CreateLambda(Context, DC, Info,

                                                     IntroducerRange.getBegin(),

                                                     KnownDependent,

                                                     IsGenericLambda,

                                                     CaptureDefault);

  DC->addDecl(Class);

  return Class;

}

/// Determine whether the given context is or is enclosed in an inline

/// function.

static bool isInInlineFunction(const DeclContext *DC) {

  while (!DC->isFileContext()) {

    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))

      if (FD->isInlined())

        return true;

    DC = DC->getLexicalParent();

  }

  
return false971k
;

}

std::tuple<MangleNumberingContext *, Decl *>

Sema::getCurrentMangleNumberContext(const DeclContext *DC) {

  // Compute the context for allocating mangling numbers in the current

  // expression, if the ABI requires them.

  Decl *ManglingContextDecl = ExprEvalContexts.back().ManglingContextDecl;

  enum ContextKind {

    Normal,

    DefaultArgument,

    DataMember,

    StaticDataMember,

    InlineVariable,

    VariableTemplate

  } Kind = Normal;

  // Default arguments of member function parameters that appear in a class

  // definition, as well as the initializers of data members, receive special

  // treatment. Identify them.

  if (ManglingContextDecl) {

    if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(ManglingContextDecl)) {

      if (const DeclContext *LexicalDC

          = Param->getDeclContext()->getLexicalParent())

        if (LexicalDC->isRecord())

          Kind = DefaultArgument;

    } else if (VarDecl *Var = dyn_cast<VarDecl>(ManglingContextDecl)) {

      if (Var->getDeclContext()->isRecord())

        Kind = StaticDataMember;

      else if (Var->getMostRecentDecl()->isInline())

        Kind = InlineVariable;

      else if (Var->getDescribedVarTemplate())

        Kind = VariableTemplate;

      else if (auto *VTS = dyn_cast<VarTemplateSpecializationDecl>(Var)) {

        if (!VTS->isExplicitSpecialization())

          Kind = VariableTemplate;

      }

    } else 
if (143
isa<FieldDecl>(ManglingContextDecl)143
) {

      Kind = DataMember;

    }

  }

  // Itanium ABI [5.1.7]:

  //   In the following contexts [...] the one-definition rule requires closure

  //   types in different translation units to "correspond":

  bool IsInNonspecializedTemplate =

      inTemplateInstantiation() || 
CurContext->isDependentContext()994k
;

  switch (Kind) {

  case Normal: {

    //  -- the bodies of non-exported nonspecialized template functions

    //  -- the bodies of inline functions

    if ((IsInNonspecializedTemplate &&

         
!(13.9k
ManglingContextDecl13.9k
 && 
isa<ParmVarDecl>(ManglingContextDecl)583
)) ||

        
isInInlineFunction(CurContext)981k
) {

      while (auto *CD = dyn_cast<CapturedDecl>(DC))

        DC = CD->getParent();

      return std::make_tuple(&Context.getManglingNumberContext(DC), nullptr);

    }

    return std::make_tuple(nullptr, nullptr);

  }

  case StaticDataMember:

    //  -- the initializers of nonspecialized static members of template classes

    if (!IsInNonspecializedTemplate)

      return std::make_tuple(nullptr, ManglingContextDecl);

    // Fall through to get the current context.

    LLVM_FALLTHROUGH;

  case DataMember:

    //  -- the in-class initializers of class members

  case DefaultArgument:

    //  -- default arguments appearing in class definitions

  case InlineVariable:

    //  -- the initializers of inline variables

  case VariableTemplate:

    //  -- the initializers of templated variables

    return std::make_tuple(

        &Context.getManglingNumberContext(ASTContext::NeedExtraManglingDecl,

                                          ManglingContextDecl),

        ManglingContextDecl);

  }

  llvm_unreachable("unexpected context");

}

CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,

                                           SourceRange IntroducerRange,

                                           TypeSourceInfo *MethodTypeInfo,

                                           SourceLocation EndLoc,

                                           ArrayRef<ParmVarDecl *> Params,

                                           ConstexprSpecKind ConstexprKind,

                                           Expr *TrailingRequiresClause) {

  QualType MethodType = MethodTypeInfo->getType();

  TemplateParameterList *TemplateParams =

      getGenericLambdaTemplateParameterList(getCurLambda(), *this);

  // If a lambda appears in a dependent context or is a generic lambda (has

  // template parameters) and has an 'auto' return type, deduce it to a

  // dependent type.

  if (Class->isDependentContext() || 
TemplateParams5.58k
) {

    const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();

    QualType Result = FPT->getReturnType();

    if (Result->isUndeducedType()) {

      Result = SubstAutoType(Result, Context.DependentTy);

      MethodType = Context.getFunctionType(Result, FPT->getParamTypes(),

                                           FPT->getExtProtoInfo());

    }

  }

  // C++11 [expr.prim.lambda]p5:

  //   The closure type for a lambda-expression has a public inline function

  //   call operator (13.5.4) whose parameters and return type are described by

  //   the lambda-expression's parameter-declaration-clause and

  //   trailing-return-type respectively.

  DeclarationName MethodName

    = Context.DeclarationNames.getCXXOperatorName(OO_Call);

  DeclarationNameLoc MethodNameLoc;

  MethodNameLoc.CXXOperatorName.BeginOpNameLoc

    = IntroducerRange.getBegin().getRawEncoding();

  MethodNameLoc.CXXOperatorName.EndOpNameLoc

    = IntroducerRange.getEnd().getRawEncoding();

  CXXMethodDecl *Method = CXXMethodDecl::Create(

      Context, Class, EndLoc,

      DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),

                          MethodNameLoc),

      MethodType, MethodTypeInfo, SC_None,

      /*isInline=*/true, ConstexprKind, EndLoc, TrailingRequiresClause);

  Method->setAccess(AS_public);

  if (!TemplateParams)

    Class->addDecl(Method);

  // Temporarily set the lexical declaration context to the current

  // context, so that the Scope stack matches the lexical nesting.

  Method->setLexicalDeclContext(CurContext);

  // Create a function template if we have a template parameter list

  FunctionTemplateDecl *const TemplateMethod = TemplateParams ?

            FunctionTemplateDecl::Create(Context, Class,

                                         Method->getLocation(), MethodName,

                                         TemplateParams,

                                         Method) : nullptr;

  if (TemplateMethod) {

    TemplateMethod->setAccess(AS_public);

    Method->setDescribedFunctionTemplate(TemplateMethod);

    Class->addDecl(TemplateMethod);

    TemplateMethod->setLexicalDeclContext(CurContext);

  }

  // Add parameters.

  if (!Params.empty()) {

    Method->setParams(Params);

    CheckParmsForFunctionDef(Params,

                             /*CheckParameterNames=*/false);

    for (auto P : Method->parameters())

      P->setOwningFunction(Method);

  }

  return Method;

}

void Sema::handleLambdaNumbering(

    CXXRecordDecl *Class, CXXMethodDecl *Method,

    Optional<std::tuple<unsigned, bool, Decl *>> Mangling) {

  if (Mangling) {

    unsigned ManglingNumber;

    bool HasKnownInternalLinkage;

    Decl *ManglingContextDecl;

    std::tie(ManglingNumber, HasKnownInternalLinkage, ManglingContextDecl) =

        Mangling.getValue();

    Class->setLambdaMangling(ManglingNumber, ManglingContextDecl,

                             HasKnownInternalLinkage);

    return;

  }

  auto getMangleNumberingContext =

      [this](CXXRecordDecl *Class,

             Decl *ManglingContextDecl) -> MangleNumberingContext * {

    // Get mangle numbering context if there's any extra decl context.

    if (ManglingContextDecl)

      return &Context.getManglingNumberContext(

          ASTContext::NeedExtraManglingDecl, ManglingContextDecl);

    // Otherwise, from that lambda's decl context.

    auto DC = Class->getDeclContext();

    while (auto *CD = dyn_cast<CapturedDecl>(DC))

      DC = CD->getParent();

    return &Context.getManglingNumberContext(DC);

  };

  MangleNumberingContext *MCtx;

  Decl *ManglingContextDecl;

  std::tie(MCtx, ManglingContextDecl) =

      getCurrentMangleNumberContext(Class->getDeclContext());

  bool HasKnownInternalLinkage = false;

  if (!MCtx && 
getLangOpts().CUDA3.00k
) {

    // Force lambda numbering in CUDA/HIP as we need to name lambdas following

    // ODR. Both device- and host-compilation need to have a consistent naming

    // on kernel functions. As lambdas are potential part of these `__global__`

    // function names, they needs numbering following ODR.

    MCtx = getMangleNumberingContext(Class, ManglingContextDecl);

    assert(MCtx && "Retrieving mangle numbering context failed!");

    HasKnownInternalLinkage = true;

  }

  if (MCtx) {

    unsigned ManglingNumber = MCtx->getManglingNumber(Method);

    Class->setLambdaMangling(ManglingNumber, ManglingContextDecl,

                             HasKnownInternalLinkage);

  }

}

void Sema::buildLambdaScope(LambdaScopeInfo *LSI,

                                        CXXMethodDecl *CallOperator,

                                        SourceRange IntroducerRange,

                                        LambdaCaptureDefault CaptureDefault,

                                        SourceLocation CaptureDefaultLoc,

                                        bool ExplicitParams,

                                        bool ExplicitResultType,

                                        bool Mutable) {

  LSI->CallOperator = CallOperator;

  CXXRecordDecl *LambdaClass = CallOperator->getParent();

  LSI->Lambda = LambdaClass;

  if (CaptureDefault == LCD_ByCopy)

    LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByval;

  else if (CaptureDefault == LCD_ByRef)

    LSI->ImpCaptureStyle = LambdaScopeInfo::ImpCap_LambdaByref;

  LSI->CaptureDefaultLoc = CaptureDefaultLoc;

  LSI->IntroducerRange = IntroducerRange;

  LSI->ExplicitParams = ExplicitParams;

  LSI->Mutable = Mutable;

  if (ExplicitResultType) {

    LSI->ReturnType = CallOperator->getReturnType();

    if (!LSI->ReturnType->isDependentType() &&

        
!LSI->ReturnType->isVoidType()738
) {

      if (RequireCompleteType(CallOperator->getBeginLoc(), LSI->ReturnType,

                              diag::err_lambda_incomplete_result)) {

        // Do nothing.

      }

    }

  } else {

    LSI->HasImplicitReturnType = true;

  }

}

void Sema::finishLambdaExplicitCaptures(LambdaScopeInfo *LSI) {

  LSI->finishedExplicitCaptures();

}

void Sema::ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,

                                                    ArrayRef<NamedDecl *> TParams,

                                                    SourceLocation RAngleLoc) {

  LambdaScopeInfo *LSI = getCurLambda();

  assert(LSI && "Expected a lambda scope");

  assert(LSI->NumExplicitTemplateParams == 0 &&

         "Already acted on explicit template parameters");

  assert(LSI->TemplateParams.empty() &&

         "Explicit template parameters should come "

         "before invented (auto) ones");

  assert(!TParams.empty() &&

         "No template parameters to act on");

  LSI->TemplateParams.append(TParams.begin(), TParams.end());

  LSI->NumExplicitTemplateParams = TParams.size();

  LSI->ExplicitTemplateParamsRange = {LAngleLoc, RAngleLoc};

}

void Sema::addLambdaParameters(

    ArrayRef<LambdaIntroducer::LambdaCapture> Captures,

    CXXMethodDecl *CallOperator, Scope *CurScope) {

  // Introduce our parameters into the function scope

  for (unsigned p = 0, NumParams = CallOperator->getNumParams();

       p < NumParams; 
++p2.59k
) {

    ParmVarDecl *Param = CallOperator->getParamDecl(p);

    // If this has an identifier, add it to the scope stack.

    if (CurScope && Param->getIdentifier()) {

      bool Error = false;

      // Resolution of CWG 2211 in C++17 renders shadowing ill-formed, but we

      // retroactively apply it.

      for (const auto &Capture : Captures) {

        if (Capture.Id == Param->getIdentifier()) {

          Error = true;

          Diag(Param->getLocation(), diag::err_parameter_shadow_capture);

          Diag(Capture.Loc, diag::note_var_explicitly_captured_here)

              << Capture.Id << true;

        }

      }

      if (!Error)

        CheckShadow(CurScope, Param);

      PushOnScopeChains(Param, CurScope);

    }

  }

}

/// If this expression is an enumerator-like expression of some type

/// T, return the type T; otherwise, return null.

///

/// Pointer comparisons on the result here should always work because

/// it's derived from either the parent of an EnumConstantDecl

/// (i.e. the definition) or the declaration returned by

/// EnumType::getDecl() (i.e. the definition).

static EnumDecl *findEnumForBlockReturn(Expr *E) {

  // An expression is an enumerator-like expression of type T if,

  // ignoring parens and parens-like expressions:

  E = E->IgnoreParens();

  //  - it is an enumerator whose enum type is T or

  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {

    if (EnumConstantDecl *D

          = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {

      return cast<EnumDecl>(D->getDeclContext());

    }

    return nullptr;

  }

  //  - it is a comma expression whose RHS is an enumerator-like

  //    expression of type T or

  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {

    if (BO->getOpcode() == BO_Comma)

      return findEnumForBlockReturn(BO->getRHS());

    return nullptr;

  }

  //  - it is a statement-expression whose value expression is an

  //    enumerator-like expression of type T or

  if (StmtExpr *SE = dyn_cast<StmtExpr>(E)) {

    if (Expr *last = dyn_cast_or_null<Expr>(SE->getSubStmt()->body_back()))

      return findEnumForBlockReturn(last);

    return nullptr;

  }

  //   - it is a ternary conditional operator (not the GNU ?:

  //     extension) whose second and third operands are

  //     enumerator-like expressions of type T or

  if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {

    if (EnumDecl *ED = findEnumForBlockReturn(CO->getTrueExpr()))

      if (ED == findEnumForBlockReturn(CO->getFalseExpr()))

        return ED;

    return nullptr;

  }

  // (implicitly:)

  //   - it is an implicit integral conversion applied to an

  //     enumerator-like expression of type T or

  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {

    // We can sometimes see integral conversions in valid

    // enumerator-like expressions.

    if (ICE->getCastKind() == CK_IntegralCast)

      return findEnumForBlockReturn(ICE->getSubExpr());

    // Otherwise, just rely on the type.

  }

  //   - it is an expression of that formal enum type.

  if (const EnumType *ET = E->getType()->getAs<EnumType>()) {

    return ET->getDecl();

  }

  // Otherwise, nope.

  return nullptr;

}

/// Attempt to find a type T for which the returned expression of the

/// given statement is an enumerator-like expression of that type.

static EnumDecl *findEnumForBlockReturn(ReturnStmt *ret) {

  if (Expr *retValue = ret->getRetValue())

    return findEnumForBlockReturn(retValue);

  return nullptr;

}

/// Attempt to find a common type T for which all of the returned

/// expressions in a block are enumerator-like expressions of that

/// type.

static EnumDecl *findCommonEnumForBlockReturns(ArrayRef<ReturnStmt*> returns) {

  ArrayRef<ReturnStmt*>::iterator i = returns.begin(), e = returns.end();

  // Try to find one for the first return.

  EnumDecl *ED = findEnumForBlockReturn(*i);

  if (!ED) 
return nullptr424
;

  // Check that the rest of the returns have the same enum.

  
for (++i; 26
i != e; 
++i13
) {

    if (findEnumForBlockReturn(*i) != ED)

      return nullptr;

  }

  // Never infer an anonymous enum type.

  
if (24
!ED->hasNameForLinkage()24
) 
return nullptr3
;

  return ED;

}

/// Adjust the given return statements so that they formally return

/// the given type.  It should require, at most, an IntegralCast.

static void adjustBlockReturnsToEnum(Sema &S, ArrayRef<ReturnStmt*> returns,

                                     QualType returnType) {

  for (ArrayRef<ReturnStmt*>::iterator

         i = returns.begin(), e = returns.end(); i != e; 
++i34
) {

    ReturnStmt *ret = *i;

    Expr *retValue = ret->getRetValue();

    if (S.Context.hasSameType(retValue->getType(), returnType))

      continue;

    // Right now we only support integral fixup casts.

    assert(returnType->isIntegralOrUnscopedEnumerationType());

    assert(retValue->getType()->isIntegralOrUnscopedEnumerationType());

    ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(retValue);

    Expr *E = (cleanups ? 
cleanups->getSubExpr()0
 : retValue);

    E = ImplicitCastExpr::Create(S.Context, returnType, CK_IntegralCast,

                                 E, /*base path*/ nullptr, VK_RValue);

    if (cleanups) {

      cleanups->setSubExpr(E);

    } else {

      ret->setRetValue(E);

    }

  }

}

void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) {

  assert(CSI.HasImplicitReturnType);

  // If it was ever a placeholder, it had to been deduced to DependentTy.

  assert(CSI.ReturnType.isNull() || !CSI.ReturnType->isUndeducedType());

  assert((!isa<LambdaScopeInfo>(CSI) || !getLangOpts().CPlusPlus14) &&

         "lambda expressions use auto deduction in C++14 onwards");

  // C++ core issue 975:

  //   If a lambda-expression does not include a trailing-return-type,

  //   it is as if the trailing-return-type denotes the following type:

  //     - if there are no return statements in the compound-statement,

  //       or all return statements return either an expression of type

  //       void or no expression or braced-init-list, the type void;

  //     - otherwise, if all return statements return an expression

  //       and the types of the returned expressions after

  //       lvalue-to-rvalue conversion (4.1 [conv.lval]),

  //       array-to-pointer conversion (4.2 [conv.array]), and

  //       function-to-pointer conversion (4.3 [conv.func]) are the

  //       same, that common type;

  //     - otherwise, the program is ill-formed.

  //

  // C++ core issue 1048 additionally removes top-level cv-qualifiers

  // from the types of returned expressions to match the C++14 auto

  // deduction rules.

  //

  // In addition, in blocks in non-C++ modes, if all of the return

  // statements are enumerator-like expressions of some type T, where

  // T has a name for linkage, then we infer the return type of the

  // block to be that type.

  // First case: no return statements, implicit void return type.

  ASTContext &Ctx = getASTContext();

  if (CSI.Returns.empty()) {

    // It's possible there were simply no /valid/ return statements.

    // In this case, the first one we found may have at least given us a type.

    if (CSI.ReturnType.isNull())

      CSI.ReturnType = Ctx.VoidTy;

    return;

  }

  // Second case: at least one return statement has dependent type.

  // Delay type checking until instantiation.

  assert(!CSI.ReturnType.isNull() && "We should have a tentative return type.");

  if (CSI.ReturnType->isDependentType())

    return;

  // Try to apply the enum-fuzz rule.

  if (!getLangOpts().CPlusPlus) {

    assert(isa<BlockScopeInfo>(CSI));

    const EnumDecl *ED = findCommonEnumForBlockReturns(CSI.Returns);

    if (ED) {

      CSI.ReturnType = Context.getTypeDeclType(ED);

      adjustBlockReturnsToEnum(*this, CSI.Returns, CSI.ReturnType);

      return;

    }

  }

  // Third case: only one return statement. Don't bother doing extra work!

  if (CSI.Returns.size() == 1)

    return;

  // General case: many return statements.

  // Check that they all have compatible return types.

  // We require the return types to strictly match here.

  // Note that we've already done the required promotions as part of

  // processing the return statement.

  
for (const ReturnStmt *RS : CSI.Returns)50
 {

    const Expr *RetE = RS->getRetValue();

    QualType ReturnType =

        (RetE ? 
RetE->getType()127
 : 
Context.VoidTy5
).getUnqualifiedType();

    if (Context.getCanonicalFunctionResultType(ReturnType) ==

          Context.getCanonicalFunctionResultType(CSI.ReturnType)) {

      // Use the return type with the strictest possible nullability annotation.

      auto RetTyNullability = ReturnType->getNullability(Ctx);

      auto BlockNullability = CSI.ReturnType->getNullability(Ctx);

      if (BlockNullability &&

          
(4
!RetTyNullability4
 ||

           
hasWeakerNullability(*RetTyNullability, *BlockNullability)2
))

        CSI.ReturnType = ReturnType;

      continue;

    }

    // FIXME: This is a poor diagnostic for ReturnStmts without expressions.

    // TODO: It's possible that the *first* return is the divergent one.

    Diag(RS->getBeginLoc(),

         diag::err_typecheck_missing_return_type_incompatible)

        << ReturnType << CSI.ReturnType << isa<LambdaScopeInfo>(CSI);

    // Continue iterating so that we keep emitting diagnostics.

  }

}

QualType Sema::buildLambdaInitCaptureInitialization(

    SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,

    Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool IsDirectInit,

    Expr *&Init) {

  // Create an 'auto' or 'auto&' TypeSourceInfo that we can use to

  // deduce against.

  QualType DeductType = Context.getAutoDeductType();

  TypeLocBuilder TLB;

  AutoTypeLoc TL = TLB.push<AutoTypeLoc>(DeductType);

  TL.setNameLoc(Loc);

  if (ByRef) {

    DeductType = BuildReferenceType(DeductType, true, Loc, Id);

    assert(!DeductType.isNull() && "can't build reference to auto");

    TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc);

  }

  if (EllipsisLoc.isValid()) {

    if (Init->containsUnexpandedParameterPack()) {

      Diag(EllipsisLoc, getLangOpts().CPlusPlus2a

                            ? 
diag::warn_cxx17_compat_init_capture_pack29

                            : 
diag::ext_init_capture_pack27
);

      DeductType = Context.getPackExpansionType(DeductType, NumExpansions);

      TLB.push<PackExpansionTypeLoc>(DeductType).setEllipsisLoc(EllipsisLoc);

    } else {

      // Just ignore the ellipsis for now and form a non-pack variable. We'll

      // diagnose this later when we try to capture it.

    }

  }

  TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, DeductType);

  // Deduce the type of the init capture.

  QualType DeducedType = deduceVarTypeFromInitializer(

      /*VarDecl*/nullptr, DeclarationName(Id), DeductType, TSI,

      SourceRange(Loc, Loc), IsDirectInit, Init);

  if (DeducedType.isNull())

    return QualType();

  // Are we a non-list direct initialization?

  ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);

  // Perform initialization analysis and ensure any implicit conversions

  // (such as lvalue-to-rvalue) are enforced.

  InitializedEntity Entity =

      InitializedEntity::InitializeLambdaCapture(Id, DeducedType, Loc);

  InitializationKind Kind =

      IsDirectInit

          ? 
(CXXDirectInit 145
? InitializationKind::CreateDirect(

                                 Loc, Init->getBeginLoc(), Init->getEndLoc())

                           : 
InitializationKind::CreateDirectList(Loc)17
)

          : 
InitializationKind::CreateCopy(Loc, Init->getBeginLoc())316
;

  MultiExprArg Args = Init;

  if (CXXDirectInit)

    Args =

        MultiExprArg(CXXDirectInit->getExprs(), CXXDirectInit->getNumExprs());

  QualType DclT;

  InitializationSequence InitSeq(*this, Entity, Kind, Args);

  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);

  if (Result.isInvalid())

    return QualType();

  Init = Result.getAs<Expr>();

  return DeducedType;

}

VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc,

                                              QualType InitCaptureType,

                                              SourceLocation EllipsisLoc,

                                              IdentifierInfo *Id,

                                              unsigned InitStyle, Expr *Init) {

  // FIXME: Retain the TypeSourceInfo from buildLambdaInitCaptureInitialization

  // rather than reconstructing it here.

  TypeSourceInfo *TSI = Context.getTrivialTypeSourceInfo(InitCaptureType, Loc);

  if (auto PETL = TSI->getTypeLoc().getAs<PackExpansionTypeLoc>())

    PETL.setEllipsisLoc(EllipsisLoc);

  // Create a dummy variable representing the init-capture. This is not actually

  // used as a variable, and only exists as a way to name and refer to the

  // init-capture.

  // FIXME: Pass in separate source locations for '&' and identifier.

  VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc,

                                   Loc, Id, InitCaptureType, TSI, SC_Auto);

  NewVD->setInitCapture(true);

  NewVD->setReferenced(true);

  // FIXME: Pass in a VarDecl::InitializationStyle.

  NewVD->setInitStyle(static_cast<VarDecl::InitializationStyle>(InitStyle));

  NewVD->markUsed(Context);

  NewVD->setInit(Init);

  if (NewVD->isParameterPack())

    getCurLambda()->LocalPacks.push_back(NewVD);

  return NewVD;

}

void Sema::addInitCapture(LambdaScopeInfo *LSI, VarDecl *Var) {

  assert(Var->isInitCapture() && "init capture flag should be set");

  LSI->addCapture(Var, /*isBlock*/false, Var->getType()->isReferenceType(),

                  /*isNested*/false, Var->getLocation(), SourceLocation(),

                  Var->getType(), /*Invalid*/false);

}

void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,

                                        Declarator &ParamInfo,

                                        Scope *CurScope) {

  LambdaScopeInfo *const LSI = getCurLambda();

  assert(LSI && "LambdaScopeInfo should be on stack!");

  // Determine if we're within a context where we know that the lambda will

  // be dependent, because there are template parameters in scope.

  bool KnownDependent;

  if (LSI->NumExplicitTemplateParams > 0) {

    auto *TemplateParamScope = CurScope->getTemplateParamParent();

    assert(TemplateParamScope &&

           "Lambda with explicit template param list should establish a "

           "template param scope");

    assert(TemplateParamScope->getParent());

    KnownDependent = TemplateParamScope->getParent()

                                       ->getTemplateParamParent() != nullptr;

  } else {

    KnownDependent = CurScope->getTemplateParamParent() != nullptr;

  }

  // Determine the signature of the call operator.

  TypeSourceInfo *MethodTyInfo;

  bool ExplicitParams = true;

  bool ExplicitResultType = true;

  bool ContainsUnexpandedParameterPack = false;

  SourceLocation EndLoc;

  SmallVector<ParmVarDecl *, 8> Params;

  if (ParamInfo.getNumTypeObjects() == 0) {

    // C++11 [expr.prim.lambda]p4:

    //   If a lambda-expression does not include a lambda-declarator, it is as

    //   if the lambda-declarator were ().

    FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention(

        /*IsVariadic=*/false, /*IsCXXMethod=*/true));

    EPI.HasTrailingReturn = true;

    EPI.TypeQuals.addConst();

    LangAS AS = getDefaultCXXMethodAddrSpace();

    if (AS != LangAS::Default)

      EPI.TypeQuals.addAddressSpace(AS);

    // C++1y [expr.prim.lambda]:

    //   The lambda return type is 'auto', which is replaced by the

    //   trailing-return type if provided and/or deduced from 'return'

    //   statements

    // We don't do this before C++1y, because we don't support deduced return

    // types there.

    QualType DefaultTypeForNoTrailingReturn =

        getLangOpts().CPlusPlus14 ? 
Context.getAutoDeductType()883

                                  : 
Context.DependentTy478
;

    QualType MethodTy =

        Context.getFunctionType(DefaultTypeForNoTrailingReturn, None, EPI);

    MethodTyInfo = Context.getTrivialTypeSourceInfo(MethodTy);

    ExplicitParams = false;

    ExplicitResultType = false;

    EndLoc = Intro.Range.getEnd();

  } else {

    assert(ParamInfo.isFunctionDeclarator() &&

           "lambda-declarator is a function");

    DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo();

    // C++11 [expr.prim.lambda]p5:

    //   This function call operator is declared const (9.3.1) if and only if

    //   the lambda-expression's parameter-declaration-clause is not followed

    //   by mutable. It is neither virtual nor declared volatile. [...]

    if (!FTI.hasMutableQualifier()) {

      FTI.getOrCreateMethodQualifiers().SetTypeQual(DeclSpec::TQ_const,

                                                    SourceLocation());

    }

    MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope);

    assert(MethodTyInfo && "no type from lambda-declarator");

    EndLoc = ParamInfo.getSourceRange().getEnd();

    ExplicitResultType = FTI.hasTrailingReturnType();

    if (FTIHasNonVoidParameters(FTI)) {

      Params.reserve(FTI.NumParams);

      for (unsigned i = 0, e = FTI.NumParams; i != e; 
++i2.59k
)

        Params.push_back(cast<ParmVarDecl>(FTI.Params[i].Param));

    }

    // Check for unexpanded parameter packs in the method type.

    if (MethodTyInfo->getType()->containsUnexpandedParameterPack())

      DiagnoseUnexpandedParameterPack(Intro.Range.getBegin(), MethodTyInfo,

                                      UPPC_DeclarationType);

  }

  CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, MethodTyInfo,

                                                 KnownDependent, Intro.Default);

  CXXMethodDecl *Method =

      startLambdaDefinition(Class, Intro.Range, MethodTyInfo, EndLoc, Params,

                            ParamInfo.getDeclSpec().getConstexprSpecifier(),

                            ParamInfo.getTrailingRequiresClause());

  if (ExplicitParams)

    CheckCXXDefaultArguments(Method);

  // This represents the function body for the lambda function, check if we

  // have to apply optnone due to a pragma.

  AddRangeBasedOptnone(Method);

  // code_seg attribute on lambda apply to the method.

  if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))

    Method->addAttr(A);

  // Attributes on the lambda apply to the method.

  ProcessDeclAttributes(CurScope, Method, ParamInfo);

  // CUDA lambdas get implicit attributes based on the scope in which they're

  // declared.

  if (getLangOpts().CUDA)

    CUDASetLambdaAttrs(Method);

  // Number the lambda for linkage purposes if necessary.

  handleLambdaNumbering(Class, Method);

  // Introduce the function call operator as the current declaration context.

  PushDeclContext(CurScope, Method);

  // Build the lambda scope.

  buildLambdaScope(LSI, Method, Intro.Range, Intro.Default, Intro.DefaultLoc,

                   ExplicitParams, ExplicitResultType, !Method->isConst());