internal ScriptFunctionInstance(
Engine engine,
JintFunctionDefinition function,
LexicalEnvironment scope,
FunctionThisMode thisMode)
: base(engine, function, scope, thisMode)
{
_function = function;
_prototype = _engine.Function.PrototypeObject;
_length = new LazyPropertyDescriptor(() => JsNumber.Create(function.Initialize(engine, this).Length), PropertyFlag.Configurable);
var proto = new ObjectInstanceWithConstructor(engine, this)
{
_prototype = _engine.Object.PrototypeObject
};
_prototypeDescriptor = new PropertyDescriptor(proto, PropertyFlag.OnlyWritable);
if (!function.Strict && !engine._isStrict)
{
DefineOwnProperty(CommonProperties.Arguments, engine._callerCalleeArgumentsThrowerConfigurable);
DefineOwnProperty(CommonProperties.Caller, new PropertyDescriptor(Undefined, PropertyFlag.Configurable));
}
}
protected FunctionInstance(
Engine engine,
JintFunctionDefinition function,
LexicalEnvironment scope,
FunctionThisMode thisMode)
: this(engine, !(string.IsNullOrEmpty(function.Name) || function.Name.Trim() == "") ? new JsString(function.Name) : null, thisMode)
{
_functionDefinition = function;
_environment = scope;
}
internal FunctionInstance(
Engine engine,
JintFunctionDefinition function,
LexicalEnvironment scope,
FunctionThisMode thisMode)
: this(engine, !string.IsNullOrWhiteSpace(function.Name) ? new JsString(function.Name) : null, thisMode)
{
_functionDefinition = function;
_environment = scope;
}
internal ArrowFunctionInstance(
Engine engine,
JintFunctionDefinition function,
LexicalEnvironment scope,
bool strict)
: base(engine, function, scope, strict ? FunctionThisMode.Strict : FunctionThisMode.Lexical)
{
_function = function;
PreventExtensions();
_prototype = Engine.Function.PrototypeObject;
_length = new LazyPropertyDescriptor(() => JsNumber.Create(function.Initialize(engine, this).Length), PropertyFlag.Configurable);
}
/// <summary>
/// https://tc39.es/ecma262/#sec-runtime-semantics-instantiatefunctionobject
/// </summary>
internal FunctionInstance InstantiateFunctionObject(JintFunctionDefinition functionDeclaration, EnvironmentRecord env)
{
var functionObject = new ScriptFunctionInstance(
Engine,
functionDeclaration,
env,
functionDeclaration.ThisMode)
{
_realm = _realm
};
functionObject.MakeConstructor();
return(functionObject);
}
internal ScriptFunctionInstance(
Engine engine,
JintFunctionDefinition function,
EnvironmentRecord scope,
FunctionThisMode thisMode,
ObjectInstance proto = null)
: base(engine, engine.Realm, function, scope, thisMode)
{
_prototype = proto ?? _engine.Realm.Intrinsics.Function.PrototypeObject;
_length = new LazyPropertyDescriptor(null, _ => JsNumber.Create(function.Initialize(this).Length), PropertyFlag.Configurable);
if (!function.Strict && !engine._isStrict && function.Function is not ArrowFunctionExpression)
{
DefineOwnProperty(CommonProperties.Arguments, new GetSetPropertyDescriptor.ThrowerPropertyDescriptor(engine, PropertyFlag.Configurable | PropertyFlag.CustomJsValue));
DefineOwnProperty(CommonProperties.Caller, new PropertyDescriptor(Undefined, PropertyFlag.Configurable));
}
}
public JintArrowFunctionExpression(Engine engine, ArrowFunctionExpression function)
: base(ArrowParameterPlaceHolder.Empty)
{
_function = new JintFunctionDefinition(engine, function);
}
/// <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();
}
