public Program(IEnumerable <StatementListItem> body, SourceType sourceType, HoistingScope hoistingScope, bool strict)
{
Type = Nodes.Program;
Body = body;
SourceType = sourceType;
HoistingScope = hoistingScope;
Strict = strict;
}
public Program(NodeList <IStatementListItem> body, SourceType sourceType, HoistingScope hoistingScope, bool strict) :
base(Nodes.Program)
{
Body = body;
SourceType = sourceType;
HoistingScope = hoistingScope;
Strict = strict;
}
public ArrowFunctionExpression(List <INode> parameters, INode body, bool expression, HoistingScope hoistingScope)
{
Type = Nodes.ArrowFunctionExpression;
Id = null;
Params = parameters;
Body = body;
Generator = false;
Expression = expression;
HoistingScope = hoistingScope;
}
public JintSwitchCase(Engine engine, SwitchCase switchCase)
{
Consequent = new JintStatementList(null, switchCase.Consequent);
LexicalDeclarations = HoistingScope.GetLexicalDeclarations(switchCase);
if (switchCase.Test != null)
{
Test = JintExpression.Build(engine, switchCase.Test);
}
}
public FunctionExpression(
Identifier id,
NodeList <INode> parameters,
BlockStatement body,
bool generator,
HoistingScope hoistingScope,
bool strict) :
base(Nodes.FunctionExpression)
{
Id = id;
Params = parameters;
Body = body;
Generator = generator;
Expression = false;
HoistingScope = hoistingScope;
Strict = strict;
}
public FunctionExpression(
Identifier id,
IEnumerable <INode> parameters,
BlockStatement body,
bool generator,
HoistingScope hoistingScope,
bool strict
)
{
Type = Nodes.FunctionExpression;
Id = id;
Params = parameters;
Body = body;
Generator = generator;
Expression = false;
HoistingScope = hoistingScope;
Strict = strict;
}
internal SourceTextModuleRecord(Engine engine, Realm realm, Module source, string location, bool async)
: base(engine, realm, source, location, async)
{
_source = source;
// https://tc39.es/ecma262/#sec-parsemodule
_importMeta = _realm.Intrinsics.Object.Construct(1);
_importMeta.DefineOwnProperty("url", new PropertyDescriptor(location, PropertyFlag.ConfigurableEnumerableWritable));
HoistingScope.GetImportsAndExports(
_source,
out _requestedModules,
out _importEntries,
out _localExportEntries,
out _indirectExportEntries,
out _starExportEntries);
//ToDo async modules
}
private State DoInitialize(FunctionInstance functionInstance)
{
var state = new State();
ProcessParameters(Function, state, out var hasArguments);
var hoistingScope = HoistingScope.GetFunctionLevelDeclarations(Function, collectVarNames: true, collectLexicalNames: true);
var functionDeclarations = hoistingScope._functionDeclarations;
var lexicalNames = hoistingScope._lexicalNames;
state.VarNames = hoistingScope._varNames;
LinkedList <JintFunctionDefinition> functionsToInitialize = null;
if (functionDeclarations != null)
{
functionsToInitialize = new LinkedList <JintFunctionDefinition>();
for (var i = functionDeclarations.Count - 1; i >= 0; i--)
{
var d = functionDeclarations[i];
var fn = d.Id.Name;
if (state.FunctionNames.Add(fn))
{
functionsToInitialize.AddFirst(new JintFunctionDefinition(_engine, d));
}
}
}
state.FunctionsToInitialize = functionsToInitialize;
const string ParameterNameArguments = "arguments";
state.ArgumentsObjectNeeded = true;
if (functionInstance._thisMode == FunctionThisMode.Lexical)
{
state.ArgumentsObjectNeeded = false;
}
else if (hasArguments)
{
state.ArgumentsObjectNeeded = false;
}
else if (!state.HasParameterExpressions)
{
if (state.FunctionNames.Contains(ParameterNameArguments) ||
lexicalNames?.Contains(ParameterNameArguments) == true)
{
state.ArgumentsObjectNeeded = false;
}
}
var parameterBindings = new HashSet <Key>(state.ParameterNames);
if (state.ArgumentsObjectNeeded)
{
parameterBindings.Add(KnownKeys.Arguments);
}
state.ParameterBindings = parameterBindings;
var varsToInitialize = new List <State.VariableValuePair>();
if (!state.HasParameterExpressions)
{
var instantiatedVarNames = state.VarNames != null
? new HashSet <Key>(state.ParameterBindings)
: new HashSet <Key>();
for (var i = 0; i < state.VarNames?.Count; i++)
{
var n = state.VarNames[i];
if (instantiatedVarNames.Add(n))
{
varsToInitialize.Add(new State.VariableValuePair
{
Name = n
});
}
}
}
else
{
var instantiatedVarNames = state.VarNames != null
? new HashSet <Key>(state.ParameterBindings)
: null;
for (var i = 0; i < state.VarNames?.Count; i++)
{
var n = state.VarNames[i];
if (instantiatedVarNames.Add(n))
{
JsValue initialValue = null;
if (!state.ParameterBindings.Contains(n) || state.FunctionNames.Contains(n))
{
initialValue = JsValue.Undefined;
}
varsToInitialize.Add(new State.VariableValuePair
{
Name = n,
InitialValue = initialValue
});
}
}
}
state.VarsToInitialize = varsToInitialize;
if (hoistingScope._lexicalDeclarations != null)
{
var _lexicalDeclarations = hoistingScope._lexicalDeclarations;
var lexicalDeclarationsCount = _lexicalDeclarations.Count;
var declarations = new State.LexicalVariableDeclaration[lexicalDeclarationsCount];
for (var i = 0; i < lexicalDeclarationsCount; i++)
{
var d = _lexicalDeclarations[i];
var boundNames = new List <string>();
d.GetBoundNames(boundNames);
declarations[i] = new State.LexicalVariableDeclaration
{
IsConstantDeclaration = d.IsConstantDeclaration(),
BoundNames = boundNames
};
}
state.LexicalDeclarations = declarations;
}
return(state);
}
protected override void Initialize()
{
_statementList = new JintStatementList(_engine, _statement, _statement.Body);
_lexicalDeclarations = HoistingScope.GetLexicalDeclarations(_statement);
}
protected override void Initialize(EvaluationContext context)
{
_statementList = new JintStatementList(_statement, _statement.Body);
_lexicalDeclarations = HoistingScope.GetLexicalDeclarations(_statement);
}
/// <summary>
/// https://tc39.es/ecma262/#sec-source-text-module-record-initialize-environment
/// </summary>
protected override void InitializeEnvironment()
{
for (var i = 0; i < _indirectExportEntries.Count; i++)
{
var e = _indirectExportEntries[i];
var resolution = ResolveExport(e.ExportName);
if (resolution is null || resolution == ResolvedBinding.Ambiguous)
{
ExceptionHelper.ThrowSyntaxError(_realm, "Ambiguous import statement for identifier: " + e.ExportName);
}
}
var realm = _realm;
var env = JintEnvironment.NewModuleEnvironment(_engine, realm.GlobalEnv);
_environment = env;
if (_importEntries != null)
{
for (var i = 0; i < _importEntries.Count; i++)
{
var ie = _importEntries[i];
var importedModule = _engine._host.ResolveImportedModule(this, ie.ModuleRequest);
if (ie.ImportName == "*")
{
var ns = GetModuleNamespace(importedModule);
env.CreateImmutableBinding(ie.LocalName, true);
env.InitializeBinding(ie.LocalName, ns);
}
else
{
var resolution = importedModule.ResolveExport(ie.ImportName);
if (resolution is null || resolution == ResolvedBinding.Ambiguous)
{
ExceptionHelper.ThrowSyntaxError(_realm, "Ambiguous import statement for identifier " + ie.ImportName);
}
if (resolution.BindingName == "*namespace*")
{
var ns = GetModuleNamespace(resolution.Module);
env.CreateImmutableBinding(ie.LocalName, true);
env.InitializeBinding(ie.LocalName, ns);
}
else
{
env.CreateImportBinding(ie.LocalName, resolution.Module, resolution.BindingName);
}
}
}
}
var moduleContext = new ExecutionContext(this, _environment, _environment, null, realm, null);
_context = moduleContext;
_engine.EnterExecutionContext(_context);
var hoistingScope = HoistingScope.GetModuleLevelDeclarations(_source);
var varDeclarations = hoistingScope._variablesDeclarations;
var declaredVarNames = new HashSet <string>();
if (varDeclarations != null)
{
var boundNames = new List <string>();
for (var i = 0; i < varDeclarations.Count; i++)
{
var d = varDeclarations[i];
boundNames.Clear();
d.GetBoundNames(boundNames);
for (var j = 0; j < boundNames.Count; j++)
{
var dn = boundNames[j];
if (declaredVarNames.Add(dn))
{
env.CreateMutableBinding(dn, false);
env.InitializeBinding(dn, Undefined);
}
}
}
}
var lexDeclarations = hoistingScope._lexicalDeclarations;
if (lexDeclarations != null)
{
var boundNames = new List <string>();
for (var i = 0; i < lexDeclarations.Count; i++)
{
var d = lexDeclarations[i];
boundNames.Clear();
d.GetBoundNames(boundNames);
for (var j = 0; j < boundNames.Count; j++)
{
var dn = boundNames[j];
if (d.IsConstantDeclaration())
{
env.CreateImmutableBinding(dn, true);
}
else
{
env.CreateMutableBinding(dn, false);
}
}
}
}
var functionDeclarations = hoistingScope._functionDeclarations;
if (functionDeclarations != null)
{
for (var i = 0; i < functionDeclarations.Count; i++)
{
var d = functionDeclarations[i];
var fn = d.Id?.Name ?? "*default*";
var fd = new JintFunctionDefinition(_engine, d);
env.CreateMutableBinding(fn, true);
var fo = realm.Intrinsics.Function.InstantiateFunctionObject(fd, env);
if (fn == "*default*")
{
fo.SetFunctionName("default");
}
env.InitializeBinding(fn, fo);
}
}
_engine.LeaveExecutionContext();
}
