/*

 * Copyright (c) Meta Platforms, Inc. and affiliates.

 *

 * This source code is licensed under the MIT license found in the

 * LICENSE file in the root directory of this source tree.

 */

#include "ESTreeIRGen.h"

#include "llvh/ADT/SmallString.h"

#include <variant>

namespace hermes {

namespace irgen {

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

// FunctionContext

FunctionContext::FunctionContext(

    ESTreeIRGen *irGen,

    Function *function,

    sem::FunctionInfo *semInfo)

    : irGen_(irGen),

      semInfo_(semInfo),

      oldContext_(irGen->functionContext_),

      builderSaveState_(irGen->Builder),

      function(function),

      anonymousIDs_(function->getContext().getStringTable()),

      enterFunctionScope(this) {

  setupFunctionScope(&enterFunctionScope);

  irGen->functionContext_ = this;

  irGen->currentIRScopeDesc_ = function->getFunctionScopeDesc();

  // Temporarily set the current IR scope to nullptr. IRGen should materialize

  // currentIRScopeDesc_ before trying to access it.

  irGen->currentIRScope_ = nullptr;

  // Initialize it to LiteralUndefined by default to avoid corner cases.

  this->capturedNewTarget = irGen->Builder.getLiteralUndefined();

  if (semInfo_) {

    // Allocate the label table. Each label definition will be encountered in

    // the AST before it is referenced (because of the nature of JavaScript), at

    // which point we will initialize the GotoLabel structure with basic blocks

    // targets.

    labels_.resize(semInfo_->labelCount);

  }

}

void FunctionContext::setupFunctionScope(EnterBlockScope *scope) {

  functionScope = &scope->blockScope_;

  blockScope = functionScope;

}

FunctionContext::~FunctionContext() {

  irGen_->functionContext_ = oldContext_;

  irGen_->Builder.setCurrentSourceLevelScope(irGen_->currentIRScopeDesc_);

}

Identifier FunctionContext::genAnonymousLabelName(llvh::StringRef hint) {

  return anonymousIDs_.next(hint);

}

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

// EnterBlockScope

EnterBlockScope::EnterBlockScope(FunctionContext *currentContext)

    : currentContext_(currentContext),

      oldIRScopeDesc_(currentContext->irGen_->currentIRScopeDesc_),

      oldIRScope_(currentContext->irGen_->currentIRScope_),

      oldBlockScope_(currentContext->blockScope),

      blockScope_(currentContext->irGen_->nameTable_) {

  currentContext->blockScope = &blockScope_;

}

EnterBlockScope::~EnterBlockScope() {

  ESTreeIRGen *irgen = currentContext_->irGen_;

  currentContext_->blockScope = oldBlockScope_;

  irgen->currentIRScope_ = oldIRScope_;

  irgen->currentIRScopeDesc_ = oldIRScopeDesc_;

  irgen->Builder.setCurrentSourceLevelScope(irgen->currentIRScopeDesc_);

}

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

// ESTreeIRGen

void ESTreeIRGen::genFunctionDeclaration(

    ESTree::FunctionDeclarationNode *func) {

  // Find the name of the function.

  Identifier functionName = getNameFieldFromID(func->_id);

  LLVM_DEBUG(llvh::dbgs() << "IRGen function \"" << functionName << "\".\n");

  Function *newFunc = func->_async

      ? genAsyncFunction(functionName, nullptr, func)

      : func->_generator ? genGeneratorFunction(functionName, nullptr, func)

                         : genES5Function(functionName, nullptr, func);

  functionForDecl[func] = {newFunc, AlreadyEmitted::No};

}

void ESTreeIRGen::emitCreateFunction(ESTree::FunctionDeclarationNode *func) {

  Identifier functionName = getNameFieldFromID(func->_id);

  auto it = functionForDecl.find(func);

  assert(it != functionForDecl.end() && "all inner functions should be known");

  if (it->second.second == AlreadyEmitted::Yes) {

    return;

  }

  it->second.second = AlreadyEmitted::Yes;

  auto *funcStorage = nameTable_.lookup(functionName);

  assert(

      funcStorage && "function declaration variable should have been hoisted");

  // Store the newly created closure into a frame variable with the same name.

  auto *newClosure =

      Builder.createCreateFunctionInst(it->second.first, currentIRScope_);

  emitStore(newClosure, funcStorage, true);

}

void ESTreeIRGen::hoistCreateFunctions(ESTree::Node *containingNode) {

  const auto &closures = curFunction()->getSemInfo()->closures;

  auto it = closures.find(containingNode);

  if (it == closures.end()) {

    return;

  }

  for (ESTree::FunctionDeclarationNode *funcDecl : *it->second) {

    emitCreateFunction(funcDecl);

  }

}

Value *ESTreeIRGen::genFunctionExpression(

    ESTree::FunctionExpressionNode *FE,

    Identifier nameHint) {

  LLVM_DEBUG(

      llvh::dbgs()

      << "Creating anonymous closure. "

      << Builder.getInsertionBlock()->getParent()->getInternalName() << ".\n");

  std::variant<std::monostate, NameTableScopeTy, EnterBlockScope> newScope;

  if (!Mod->getContext().getCodeGenerationSettings().enableBlockScoping) {

    newScope.emplace<NameTableScopeTy>(nameTable_);

  } else {

    newScope.emplace<EnterBlockScope>(curFunction());

    newDeclarativeEnvironment();

  }

  Variable *tempClosureVar = nullptr;

  Identifier originalNameIden = nameHint;

  if (FE->_id) {

    if (!Mod->getContext().getCodeGenerationSettings().enableBlockScoping) {

      auto closureName = genAnonymousLabelName("closure");

      tempClosureVar = Builder.createVariable(

          curFunction()->function->getFunctionScopeDesc(),

          Variable::DeclKind::Var,

          closureName);

      // Insert the synthesized variable into the name table, so it can be

      // looked up internally as well.

      nameTable_.insertIntoScope(

          curFunction()->functionScope,

          tempClosureVar->getName(),

          tempClosureVar);

      // Alias the lexical name to the synthesized variable.

      originalNameIden = getNameFieldFromID(FE->_id);

      nameTable_.insert(originalNameIden, tempClosureVar);

    } else {

      // Use the expression's ID for its closure name, as well as its variable

      // name -- which is OK because we're in a new scope.

      originalNameIden = getNameFieldFromID(FE->_id);

      auto closureName = genAnonymousLabelName(originalNameIden.str());

      tempClosureVar = Builder.createVariable(

          currentIRScopeDesc_, Variable::DeclKind::Const, closureName);

      // ES2023 dictates that function expression's ID are non-strict immutable

      // bindings.

      tempClosureVar->setStrictImmutableBinding(false);

      nameTable_.insertIntoScope(

          curFunction()->blockScope, originalNameIden, tempClosureVar);

    }

  }

  Function *newFunc = FE->_async

      ? genAsyncFunction(originalNameIden, tempClosureVar, FE)

      : FE->_generator

      ? genGeneratorFunction(originalNameIden, tempClosureVar, FE)

      : genES5Function(originalNameIden, tempClosureVar, FE);

  Value *closure = Builder.createCreateFunctionInst(newFunc, currentIRScope_);

  if (tempClosureVar)

    emitStore(closure, tempClosureVar, true);

  return closure;

}

Value *ESTreeIRGen::genArrowFunctionExpression(

    ESTree::ArrowFunctionExpressionNode *AF,

    Identifier nameHint) {

  LLVM_DEBUG(

      llvh::dbgs()

      << "Creating arrow function. "

      << Builder.getInsertionBlock()->getParent()->getInternalName() << ".\n");

  if (AF->_async) {

    Builder.getModule()->getContext().getSourceErrorManager().error(

        AF->getSourceRange(), Twine("async functions are unsupported"));

    return Builder.getLiteralUndefined();

  }

  auto *newFunc = Builder.createFunction(

      newScopeDesc(),

      genAnonymousFunctionNameIfNeeded(nameHint),

      Function::DefinitionKind::ES6Arrow,

      ESTree::isStrict(AF->strictness),

      AF->sourceVisibility,

      AF->getSourceRange());

  {

    FunctionContext newFunctionContext{this, newFunc, AF->getSemInfo()};

    // Propagate captured "this", "new.target" and "arguments" from parents.

    auto *prev = curFunction()->getPreviousContext();

    curFunction()->capturedThis = prev->capturedThis;

    curFunction()->capturedNewTarget = prev->capturedNewTarget;

    curFunction()->capturedArguments = prev->capturedArguments;

    emitFunctionPreamble(Builder.createBasicBlock(newFunc));

    emitTopLevelDeclarations(AF, AF->_body, DoEmitParameters::YesMultiScopes);

    genFunctionBody(AF->_body);

    emitFunctionEpilogue(Builder.getLiteralUndefined());

  }

  // Emit CreateFunctionInst after we have restored the builder state.

  return Builder.createCreateFunctionInst(newFunc, currentIRScope_);

}

namespace {

ESTree::NodeKind getLazyFunctionKind(ESTree::FunctionLikeNode *node) {

  if (node->isMethodDefinition) {

    // This is not a regular function expression but getter/setter.

    // If we want to reparse it later, we have to start from an

    // identifier and not from a 'function' keyword.

    return ESTree::NodeKind::Property;

  }

  return node->getKind();

}

} // namespace

Function *ESTreeIRGen::genES5Function(

    Identifier originalName,

    Variable *lazyClosureAlias,

    ESTree::FunctionLikeNode *functionNode,

    bool isGeneratorInnerFunction) {

  assert(functionNode && "Function AST cannot be null");

  auto *body = ESTree::getBlockStatement(functionNode);

  assert(body && "body of ES5 function cannot be null");

  Function *newFunction = isGeneratorInnerFunction

      ? Builder.createGeneratorInnerFunction(

            newScopeDesc(),

            genAnonymousFunctionNameIfNeeded(originalName),

            Function::DefinitionKind::ES5Function,

            ESTree::isStrict(functionNode->strictness),

            functionNode->getSourceRange(),

            /* insertBefore */ nullptr)

      : Builder.createFunction(

            newScopeDesc(),

            genAnonymousFunctionNameIfNeeded(originalName),

            Function::DefinitionKind::ES5Function,

            ESTree::isStrict(functionNode->strictness),

            functionNode->sourceVisibility,

            functionNode->getSourceRange(),

            /* isGlobal */ false,

            /* insertBefore */ nullptr);

  newFunction->setLazyClosureAlias(lazyClosureAlias);

  if (auto *bodyBlock = llvh::dyn_cast<ESTree::BlockStatementNode>(body)) {

    if (bodyBlock->isLazyFunctionBody) {

      assert(

          !isGeneratorInnerFunction &&

          "generator inner function should be included with outer function");

      setupLazyScope(functionNode, newFunction, body);

      return newFunction;

    }

  }

  FunctionContext newFunctionContext{

      this, newFunction, functionNode->getSemInfo()};

  if (isGeneratorInnerFunction) {

    // StartGeneratorInst

    // ResumeGeneratorInst

    // at the beginning of the function, to allow for the first .next() call.

    auto *initGenBB = Builder.createBasicBlock(newFunction);

    Builder.setInsertionBlock(initGenBB);

    Builder.createStartGeneratorInst();

    auto *prologueBB = Builder.createBasicBlock(newFunction);

    auto *prologueResumeIsReturn = Builder.createAllocStackInst(

        genAnonymousLabelName("isReturn_prologue"));

    genResumeGenerator(GenFinally::No, prologueResumeIsReturn, prologueBB);

    if (hasSimpleParams(functionNode)) {

      // If there are simple params, then we don't need an extra yield/resume.

      // They can simply be initialized on the first call to `.next`.

      Builder.setInsertionBlock(prologueBB);

      emitFunctionPreamble(prologueBB);

      initCaptureStateInES5Function();

      emitTopLevelDeclarations(

          functionNode, body, DoEmitParameters::YesMultiScopes);

    } else {

      // If there are non-simple params, then we must add a new yield/resume.

      // The `.next()` call will occur once in the outer function, before

      // the iterator is returned to the caller of the `function*`.

      auto *entryPointBB = Builder.createBasicBlock(newFunction);

      auto *entryPointResumeIsReturn =

          Builder.createAllocStackInst(genAnonymousLabelName("isReturn_entry"));

      // Initialize parameters.

      Builder.setInsertionBlock(prologueBB);

      emitFunctionPreamble(prologueBB);

      initCaptureStateInES5Function();

      emitTopLevelDeclarations(

          functionNode, body, DoEmitParameters::YesMultiScopes);

      Builder.createSaveAndYieldInst(

          Builder.getLiteralUndefined(), entryPointBB);

      // Actual entry point of function from the caller's perspective.

      Builder.setInsertionBlock(entryPointBB);

      genResumeGenerator(

          GenFinally::No,

          entryPointResumeIsReturn,

          Builder.createBasicBlock(newFunction));

    }

  } else {

    emitFunctionPreamble(Builder.createBasicBlock(newFunction));

    initCaptureStateInES5Function();

    emitTopLevelDeclarations(

        functionNode, body, DoEmitParameters::YesMultiScopes);

  }

  genFunctionBody(body);

  emitFunctionEpilogue(Builder.getLiteralUndefined());

  return curFunction()->function;

}

Function *ESTreeIRGen::genGeneratorFunction(

    Identifier originalName,

    Variable *lazyClosureAlias,

    ESTree::FunctionLikeNode *functionNode) {

  assert(functionNode && "Function AST cannot be null");

  if (!Builder.getModule()->getContext().isGeneratorEnabled()) {

    Builder.getModule()->getContext().getSourceErrorManager().error(

        functionNode->getSourceRange(), "generator compilation is disabled");

  }

  // Build the outer function which creates the generator.

  // Does not have an associated source range.

  auto *outerFn = Builder.createGeneratorFunction(

      newScopeDesc(),

      genAnonymousFunctionNameIfNeeded(originalName),

      Function::DefinitionKind::ES5Function,

      ESTree::isStrict(functionNode->strictness),

      functionNode->sourceVisibility,

      functionNode->getSourceRange(),

      /* insertBefore */ nullptr);

  outerFn->setLazyClosureAlias(lazyClosureAlias);

  auto *body = ESTree::getBlockStatement(functionNode);

  if (auto *bodyBlock = llvh::dyn_cast<ESTree::BlockStatementNode>(body)) {

    if (bodyBlock->isLazyFunctionBody) {

      setupLazyScope(functionNode, outerFn, body);

      return outerFn;

    }

  }

  {

    FunctionContext outerFnContext{this, outerFn, functionNode->getSemInfo()};

    // Build the inner function. This must be done in the outerFnContext

    // since it's lexically considered a child function.

    auto *innerFn = genES5Function(

        genAnonymousLabelName(originalName.isValid() ? originalName.str() : ""),

        nullptr,

        functionNode,

        true);

    emitFunctionPreamble(Builder.createBasicBlock(outerFn));

    initCaptureStateInES5Function();

    emitTopLevelDeclarations(

        functionNode,

        ESTree::getBlockStatement(functionNode),

        DoEmitParameters::No);

    // Create a generator function, which will store the arguments.

    auto *gen = Builder.createCreateGeneratorInst(innerFn, currentIRScope_);

    if (!hasSimpleParams(functionNode)) {

      // If there are non-simple params, step the inner function once to

      // initialize them.

      Value *next = Builder.createLoadPropertyInst(gen, "next");

      Builder.createCallInst(CallInst::kNoTextifiedCallee, next, gen, {});

    }

    emitFunctionEpilogue(gen);

  }

  return outerFn;

}

void ESTreeIRGen::setupLazyScope(

    ESTree::FunctionLikeNode *functionNode,

    Function *function,

    ESTree::BlockStatementNode *bodyBlock) {

  assert(

      bodyBlock->isLazyFunctionBody &&

      "setupLazyScope can only be used with lazy function bodies");

  // Set the AST position and variable context so we can continue later.

  // Save the scope chain starting from function's parent (i.e., the last

  // materialized scope).

  function->setLazyScope(

      saveScopeChain(function->getFunctionScopeDesc()->getParent()));

  auto &lazySource = function->getLazySource();

  lazySource.bufferId = bodyBlock->bufferId;

  lazySource.nodeKind = getLazyFunctionKind(functionNode);

  lazySource.functionRange = functionNode->getSourceRange();

  lazySource.paramYield = bodyBlock->paramYield;

  lazySource.paramAwait = bodyBlock->paramAwait;

  // Set the function's .length.

  function->setExpectedParamCountIncludingThis(

      countExpectedArgumentsIncludingThis(functionNode));

}

Function *ESTreeIRGen::genAsyncFunction(

    Identifier originalName,

    Variable *lazyClosureAlias,

    ESTree::FunctionLikeNode *functionNode) {

  assert(functionNode && "Function AST cannot be null");

  if (!Builder.getModule()->getContext().isGeneratorEnabled()) {

    Builder.getModule()->getContext().getSourceErrorManager().error(

        functionNode->getSourceRange(),

        "async function compilation requires enabling generator");

  }

  auto *asyncFn = Builder.createAsyncFunction(

      newScopeDesc(),

      genAnonymousFunctionNameIfNeeded(originalName),

      Function::DefinitionKind::ES5Function,

      ESTree::isStrict(functionNode->strictness),

      functionNode->sourceVisibility,

      functionNode->getSourceRange(),

      /* insertBefore */ nullptr);

  // Setup lazy compilation

  asyncFn->setLazyClosureAlias(lazyClosureAlias);

  auto *body = ESTree::getBlockStatement(functionNode);

  if (auto *bodyBlock = llvh::dyn_cast<ESTree::BlockStatementNode>(body)) {

    if (bodyBlock->isLazyFunctionBody) {

      setupLazyScope(functionNode, asyncFn, body);

      return asyncFn;

    }

  }

  {

    FunctionContext asyncFnContext{this, asyncFn, functionNode->getSemInfo()};

    // Build the inner generator. This must be done in the outerFnContext

    // since it's lexically considered a child function.

    auto *gen = genGeneratorFunction(

        genAnonymousLabelName(originalName.isValid() ? originalName.str() : ""),

        lazyClosureAlias,

        functionNode);

    // The outer async function need not emit code for parameters.

    // It would simply delegate `arguments` object down to inner generator.

    // This avoid emitting code e.g. destructuring parameters twice.

    emitFunctionPreamble(Builder.createBasicBlock(asyncFn));

    initCaptureStateInES5Function();

    emitTopLevelDeclarations(

        functionNode,

        ESTree::getBlockStatement(functionNode),

        DoEmitParameters::No);

    auto *genClosure = Builder.createCreateFunctionInst(gen, currentIRScope_);

    auto *thisArg = curFunction()->function->getThisParameter();

    auto *argumentsList = curFunction()->createArgumentsInst;

    auto *spawnAsyncClosure = Builder.createGetBuiltinClosureInst(

        BuiltinMethod::HermesBuiltin_spawnAsync);

    auto *res = Builder.createCallInst(

        CallInst::kNoTextifiedCallee,

        spawnAsyncClosure,

        Builder.getLiteralUndefined(),

        {genClosure, thisArg, argumentsList});

    emitFunctionEpilogue(res);

  }

  return asyncFn;

}

void ESTreeIRGen::initCaptureStateInES5Function() {

  // Capture "this", "new.target" and "arguments" if there are inner arrows.

  if (!curFunction()->getSemInfo()->containsArrowFunctions)

    return;

  // "this".

  curFunction()->capturedThis = Builder.createVariable(

      currentIRScopeDesc_,

      Variable::DeclKind::Var,

      genAnonymousLabelName("this"));

  emitStore(

      Builder.getFunction()->getThisParameter(),

      curFunction()->capturedThis,

      true);

  // "new.target".

  curFunction()->capturedNewTarget = Builder.createVariable(

      currentIRScopeDesc_,

      Variable::DeclKind::Var,

      genAnonymousLabelName("new.target"));

  emitStore(

      Builder.createGetNewTargetInst(), curFunction()->capturedNewTarget, true);

  // "arguments".

  if (curFunction()->getSemInfo()->containsArrowFunctionsUsingArguments) {

    curFunction()->capturedArguments = Builder.createVariable(

        currentIRScopeDesc_,

        Variable::DeclKind::Var,

        genAnonymousLabelName("arguments"));

    emitStore(

        curFunction()->createArgumentsInst,

        curFunction()->capturedArguments,

        true);

  }

}

void ESTreeIRGen::emitFunctionPreamble(BasicBlock *entry) {

  auto *newFunc = curFunction()->function;

  Builder.setLocation(newFunc->getSourceRange().Start);

  Builder.setCurrentSourceLevelScope(nullptr);

  BasicBlock *realEntry = &newFunc->front();

  if (realEntry->empty()) {

    Builder.setInsertionBlock(realEntry);

  } else {

    Builder.setInsertionPoint(&realEntry->front());

  }

  // Create the function scope.

  currentIRScope_ =

      Builder.createCreateScopeInst(newFunc->getFunctionScopeDesc());

  // Start pumping instructions into the entry basic block.

  Builder.setInsertionBlock(entry);

  Builder.setCurrentSourceLevelScope(newFunc->getFunctionScopeDesc());

  // Always insert a CreateArgumentsInst. We will delete it later if it is

  // unused.

  curFunction()->createArgumentsInst = Builder.createCreateArgumentsInst();

  // Always create the "this" parameter. It needs to be created before we

  // initialized the ES5 capture state.

  Builder.createThisParameter(newFunc);

}

void ESTreeIRGen::emitTopLevelDeclarations(

    ESTree::FunctionLikeNode *funcNode,

    ESTree::Node *body,

    DoEmitParameters doEmitParameters) {

  // There is a lot happening in this function w.r.t. function scopes, but that

  // can be summarizes as follows:

  //

  //    topLevelScope = Scope();                                #1

  //    currentScope = topLevelScope

  //

  //    if !isStrict and hasParamExpressions:

  //        paramExpressionScope = InnerScope(currentScope)

  //        currentScope = paramExpressionScope                 #2

  //

  //    << emit parameter expressions >>

  //

  //    if hasParamExpressions:

  //       varScope = InnerScope(currentScope)

  //       currentScope = varScope                              #3

  //

  //    << emit var declarations >>

  //

  //    if !isStrict:

  //       lexicalScope = InnerScope(currentScope)              #4

  //       currentScope = lexicalScope

  //

  //    << emit lexical declarations >>

  //

  // Thus at the end of this method, currentIRScopeDesc_ (i.e., currentScope

  // above) should be

  //

  // 1. !isStrict and !hasParamExpressions:

  //        currentIRScopeDesc_ == lexicalScope

  //        lexicalScope.parent == topLevelScope

  //        paramExpressionScope == null

  //        varScope == null

  // 2. !isStrict and hasParamExpressions:

  //        currentIRScopeDesc_ == lexicalScope

  //        lexicalScope.parent == varScope

  //        varScope.parent == paramExpressionScope

  //        paramExpressionScope.parent == topLevelScope

  // 3. isStrict and !hasParamExpressions:

  //        currentIRScopeDesc_ == topLevelScope

  //        paramExpressionScope == null

  //        varScope == null

  //        lexicalScope == null

  // 4. isStrict and hasParamExpressions:

  //        currentIRScopeDesc_ == varScope

  //        varScope.parent == topLevelScope

  //        paramExpressionScope == null

  //        lexicalScope == null

  //

  // The following variables are used to assert those conditions.

  ScopeDesc *topLevelScope = currentIRScopeDesc_;

  ScopeDesc *paramExpressionScope{};

  ScopeDesc *varScope{};

  ScopeDesc *lexicalScope{};

  if (!Mod->getContext().getCodeGenerationSettings().enableBlockScoping) {

    if (doEmitParameters == DoEmitParameters::YesMultiScopes) {

      // Block scoping is disabled, so there's no point in emitting separate

      // scopes.

      doEmitParameters = DoEmitParameters::Yes;

    }

  }

  const bool hasParamExpressions = ESTree::hasParamExpressions(funcNode);

  if (doEmitParameters == DoEmitParameters::YesMultiScopes) {

    if (!ESTree::isStrict(funcNode->strictness) && hasParamExpressions) {

      curFunction()->enterOptionalFunctionScope(

          &FunctionContext::enterParamScope);

      newDeclarativeEnvironment();

      paramExpressionScope = currentIRScopeDesc_;

    }

  }

  if (doEmitParameters != DoEmitParameters::No) {

    // Create function parameters, register them in the scope, and initialize

    // them with their income values.

    emitParameters(funcNode, hasParamExpressions);

  } else {

    curFunction()->function->setExpectedParamCountIncludingThis(

        countExpectedArgumentsIncludingThis(funcNode));

  }

  auto *semInfo = curFunction()->getSemInfo();

  if (doEmitParameters != DoEmitParameters::YesMultiScopes ||

      !hasParamExpressions) {

    // Create variable declarations for each of the hoisted variables and

    // functions. Initialize them to undefined.

    for (const sem::FunctionInfo::VarDecl &decl : semInfo->varScoped) {

      createNewBinding(

          currentIRScopeDesc_,

          decl.kind,

          decl.identifier,

          decl.needsInitializer);

    }

  } else {

    curFunction()->enterOptionalFunctionScope(&FunctionContext::enterVarScope);

    newDeclarativeEnvironment();

    varScope = currentIRScopeDesc_;

    for (const sem::FunctionInfo::VarDecl &decl : semInfo->varScoped) {

      Value *init = nameTable_.lookup(getNameFieldFromID(decl.identifier));

      if (init) {

        init = emitLoad(init);

      }

      createNewBinding(

          currentIRScopeDesc_,

          decl.kind,

          decl.identifier,

          decl.needsInitializer,

          init);

    }

  }

  if (doEmitParameters == DoEmitParameters::YesMultiScopes) {

    if (!ESTree::isStrict(funcNode->strictness)) {

      curFunction()->enterOptionalFunctionScope(

          &FunctionContext::enterTopLevelLexicalDeclarationsScope);

      newDeclarativeEnvironment();

      lexicalScope = currentIRScopeDesc_;

    }

  }

  // Now that scope creation is completed, ensure that the expectations hold:

  if (doEmitParameters == DoEmitParameters::YesMultiScopes) {

    (void)topLevelScope;

    (void)paramExpressionScope;

    (void)varScope;

    (void)lexicalScope;

    if (!ESTree::isStrict(funcNode->strictness)) {

      if (!hasParamExpressions) {

        // 1. !isStrict and !hasParamExpressions:

        assert(currentIRScopeDesc_ == lexicalScope);

        assert(lexicalScope->getParent() == topLevelScope);

        assert(paramExpressionScope == nullptr);

        assert(varScope == nullptr);

      } else {

        // 2. !isStrict and hasParamExpressions:

        assert(currentIRScopeDesc_ == lexicalScope);

        assert(lexicalScope->getParent() == varScope);

        assert(varScope->getParent() == paramExpressionScope);

        assert(paramExpressionScope->getParent() == topLevelScope);

      }

    } else {

      if (!hasParamExpressions) {

        // 3. isStrict and !hasParamExpressions:

        assert(currentIRScopeDesc_ == topLevelScope);

        assert(paramExpressionScope == nullptr);

        assert(varScope == nullptr);

        assert(lexicalScope == nullptr);

      } else {

        // 4. isStrict and hasParamExpressions:

        assert(currentIRScopeDesc_ == varScope);

        assert(varScope->getParent() == topLevelScope);

        assert(paramExpressionScope == nullptr);

        assert(lexicalScope == nullptr);

      }

    }

  }

  // Now create variable declarations for each scoped variable/function in body.

  // let/const bindings are initialized to empty, and functions to undefined.

  createScopeBindings(currentIRScopeDesc_, body);

  // Generate the code for import declarations before generating the rest of the

  // body.

  for (ESTree::ImportDeclarationNode *importDecl : semInfo->imports) {

    genImportDeclaration(importDecl);

  }

  // Generate all closures declared in body. Any hoisted

  // functions from inner scopes have already been declared.

  genFunctionDeclarations(body);

  // Pre-hoists all functions that are defined within body (but not in

  // BlockStatments in it).

  hoistCreateFunctions(body);

}

void ESTreeIRGen::genFunctionDeclarations(ESTree::Node *containingNode) {

  auto *semInfo = curFunction()->getSemInfo();

  auto it = semInfo->closures.find(containingNode);

  if (it != semInfo->closures.end()) {

    for (ESTree::FunctionDeclarationNode *fd : *it->second) {

      genFunctionDeclaration(fd);

    }

  }

}

void ESTreeIRGen::createScopeBindings(

    ScopeDesc *scopeDesc,

    ESTree::Node *containingNode) {

  auto *semInfo = curFunction()->getSemInfo();

  auto it = semInfo->lexicallyScoped.find(containingNode);

  if (it != semInfo->lexicallyScoped.end()) {

    for (const sem::FunctionInfo::VarDecl &decl : *it->second) {

      LLVM_DEBUG(

          llvh::dbgs() << "creating binding " << decl.identifier->_name

                       << " in scope " << scopeDesc << "\n");

      createNewBinding(

          scopeDesc, decl.kind, decl.identifier, decl.needsInitializer);

      if (Mod->getContext().getCodeGenerationSettings().enableBlockScoping) {

        if (decl.kind != VarDecl::Kind::Var && scopeDesc->isGlobalScope() &&

            llvh::isa<ESTree::ProgramNode>(containingNode)) {

          // The newly created Variable is a const/let declaration, so the

          // running program must check whether it is a valid name. For example,

          //

          // let undefined;

          //

          // is an invalid global let declaration because undefined is a

          // restricted global name.

          IRBuilder::ScopedLocationChange slc(

              Builder, decl.identifier->getSourceRange().Start);

          Builder.createThrowIfHasRestrictedGlobalPropertyInst(

              decl.identifier->_name->str());

        }

      }

    }

  }

}

void ESTreeIRGen::createNewBinding(

    ScopeDesc *scopeDesc,

    VarDecl::Kind kind,

    ESTree::Node *id,

    bool needsInitializer,

    Value *init) {

  Identifier name = getNameFieldFromID(id);

  auto res = declareVariableOrGlobalProperty(scopeDesc, kind, name);

  // If this is not a frame variable or it was already declared, skip.

  auto *var = llvh::dyn_cast<Variable>(res.first);

  if (!needsInitializer || !var || !res.second)

    return;

  if (!init) {

    init = var->getObeysTDZ() ? (Literal *)Builder.getLiteralEmpty()

                              : (Literal *)Builder.getLiteralUndefined();

  }

  // Otherwise, initialize it to undefined or empty, depending on TDZ.

  Builder.createStoreFrameInst(init, var, currentIRScope_);

}

void ESTreeIRGen::emitParameters(

    ESTree::FunctionLikeNode *funcNode,

    bool hasParamExpressions) {

  auto *newFunc = curFunction()->function;

  LLVM_DEBUG(llvh::dbgs() << "IRGen function parameters.\n");

  if (!Mod->getContext().getCodeGenerationSettings().enableBlockScoping) {

    // Disable parameter TDZ if block scoping support is disabled.

    hasParamExpressions = false;

  }

  llvh::SmallVector<Variable *, 4> tdzParams;

  // Create a variable for every parameter.

  Value *empty = Builder.getLiteralEmpty();

  Variable::DeclKind paramKind =

      hasParamExpressions ? Variable::DeclKind::Let : Variable::DeclKind::Var;

  for (auto paramDecl : funcNode->getSemInfo()->paramNames) {

    Identifier paramName = getNameFieldFromID(paramDecl.identifier);

    LLVM_DEBUG(llvh::dbgs() << "Adding parameter: " << paramName << "\n");

    auto *paramStorage = Builder.createVariable(

        newFunc->getFunctionScopeDesc(), paramKind, paramName);

    if (hasParamExpressions) {

      // funcNode has parameter expressions, thus the parameters are first

      // copied to tdz variables which need to be initialized to empty.

      Builder.createStoreFrameInst(empty, paramStorage, currentIRScope_);

      // Also keep track of all created Variables to copy them into regular Var

      // declarations.

      tdzParams.push_back(paramStorage);

    }

    // Register the storage for the parameter.

    nameTable_.insert(paramName, paramStorage);

  }

  uint32_t paramIndex = uint32_t{0} - 1;

  for (auto &elem : ESTree::getParams(funcNode)) {

    ESTree::Node *param = &elem;

    ESTree::Node *init = nullptr;

    ++paramIndex;

    if (auto *rest = llvh::dyn_cast<ESTree::RestElementNode>(param)) {

      createLRef(rest->_argument, true)

          .emitStore(genBuiltinCall(

              BuiltinMethod::HermesBuiltin_copyRestArgs,

              Builder.getLiteralNumber(paramIndex)));

      break;

    }

    // Unpack the optional initialization.

    if (auto *assign = llvh::dyn_cast<ESTree::AssignmentPatternNode>(param)) {

      param = assign->_left;

      init = assign->_right;

    }

    Identifier formalParamName = llvh::isa<ESTree::IdentifierNode>(param)

        ? getNameFieldFromID(param)

        : genAnonymousLabelName("param");

    auto *formalParam = Builder.createParameter(newFunc, formalParamName);

    createLRef(param, true)

        .emitStore(

            emitOptionalInitialization(formalParam, init, formalParamName));

  }

  // Now copy the TDZ parameters to Var declarations. This improves codegen by

  // removing tdz checks when accessing the parameters.

  assert(

      (tdzParams.empty() || hasParamExpressions) &&

      "funcNode does not have param expressions, so it doesn't"

      " need tdz params.");

  for (Variable *oldParamStorage : tdzParams) {

    auto *paramStorage = Builder.createVariable(

        newFunc->getFunctionScopeDesc(),

        Variable::DeclKind::Let,

        oldParamStorage->getName());

    constexpr bool declInit = true;

    emitStore(emitLoad(oldParamStorage), paramStorage, declInit);

    nameTable_.setInCurrentScope(oldParamStorage->getName(), paramStorage);

  }

  newFunc->setExpectedParamCountIncludingThis(

      countExpectedArgumentsIncludingThis(funcNode));

}

uint32_t ESTreeIRGen::countExpectedArgumentsIncludingThis(

    ESTree::FunctionLikeNode *funcNode) {

  // Start at 1 to account for "this".

  uint32_t count = 1;

  for (auto &param : ESTree::getParams(funcNode)) {

    if (llvh::isa<ESTree::AssignmentPatternNode>(param)) {

      // Found an initializer, stop counting expected arguments.

      break;

    }

    ++count;

  }

  return count;

}

void ESTreeIRGen::emitFunctionEpilogue(Value *returnValue) {

  if (returnValue) {

    Builder.setLocation(SourceErrorManager::convertEndToLocation(

        Builder.getFunction()->getSourceRange()));

    Builder.createReturnInst(returnValue);

  }

  // Delete CreateArgumentsInst if it is unused.

  if (!curFunction()->createArgumentsInst->hasUsers())

    curFunction()->createArgumentsInst->eraseFromParent();

  curFunction()->function->clearStatementCount();

}

void ESTreeIRGen::genDummyFunction(Function *dummy) {

  IRBuilder builder{dummy};

  builder.createThisParameter(dummy);

  BasicBlock *firstBlock = builder.createBasicBlock(dummy);

  builder.setInsertionBlock(firstBlock);

  builder.createUnreachableInst();

  builder.createReturnInst(builder.getLiteralUndefined());

}

/// Generate a function which immediately throws the specified SyntaxError

/// message.

Function *ESTreeIRGen::genSyntaxErrorFunction(

    Module *M,

    ScopeDesc *scopeDesc,

    Identifier originalName,

    SMRange sourceRange,

    llvh::StringRef error) {

  IRBuilder builder{M};

  Function *function = builder.createFunction(

      scopeDesc,

      originalName,

      Function::DefinitionKind::ES5Function,

      true,

      SourceVisibility::Sensitive,

      sourceRange,

      false);

  builder.createThisParameter(function);

  BasicBlock *firstBlock = builder.createBasicBlock(function);