protected override void Initialize()
{
_body = Build(_engine, _statement.Body);
if (_statement.Init != null)
{
if (_statement.Init.Type == Nodes.VariableDeclaration)
{
var d = (VariableDeclaration)_statement.Init;
if (d.Kind != VariableDeclarationKind.Var)
{
_boundNames = new List <string>();
d.GetBoundNames(_boundNames);
}
_initStatement = new JintVariableDeclaration(_engine, d);
_shouldCreatePerIterationEnvironment = d.Kind == VariableDeclarationKind.Let;
}
else
{
_initExpression = JintExpression.Build(_engine, (Expression)_statement.Init);
}
}
if (_statement.Test != null)
{
_test = JintExpression.Build(_engine, _statement.Test);
}
if (_statement.Update != null)
{
_increment = JintExpression.Build(_engine, _statement.Update);
}
}
protected override void Initialize(EvaluationContext context)
{
var engine = context.Engine;
_switchBlock = new JintSwitchBlock(_statement.Cases);
_discriminant = JintExpression.Build(engine, _statement.Discriminant);
}
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);
}
}
internal Completion Execute(EvaluationContext context)
{
if (Function.Expression)
{
_bodyExpression ??= JintExpression.Build(_engine, (Expression)Function.Body);
var jsValue = _bodyExpression?.GetValue(context).Value ?? Undefined.Instance;
return(new Completion(CompletionType.Return, jsValue, Function.Body.Location));
}
var blockStatement = (BlockStatement)Function.Body;
_bodyStatementList ??= new JintStatementList(blockStatement, blockStatement.Body);
return(_bodyStatementList.Execute(context));
}
public override string ToString()
{
var name = TypeConverter.ToString(Function.Get(CommonProperties.Name));
if (string.IsNullOrWhiteSpace(name))
{
if (Expression is not null)
{
name = JintExpression.ToString(Expression._expression);
}
}
return(name ?? "(anonymous)");
}
private static bool TryGetComputedPropertyKey <T>(T expression, Engine engine, out JsValue propertyKey)
where T : Expression
{
if (expression.Type == Nodes.Identifier ||
expression.Type == Nodes.CallExpression ||
expression.Type == Nodes.BinaryExpression ||
expression.Type == Nodes.UpdateExpression ||
expression is StaticMemberExpression)
{
propertyKey = TypeConverter.ToPropertyKey(JintExpression.Build(engine, expression).GetValue());
return(true);
}
propertyKey = string.Empty;
return(false);
}
protected override void Initialize(EvaluationContext context)
{
_lhsKind = LhsKind.Assignment;
var engine = context.Engine;
if (_leftNode is VariableDeclaration variableDeclaration)
{
_lhsKind = variableDeclaration.Kind == VariableDeclarationKind.Var
? LhsKind.VarBinding
: LhsKind.LexicalBinding;
var variableDeclarationDeclaration = variableDeclaration.Declarations[0];
var id = variableDeclarationDeclaration.Id;
if (_lhsKind == LhsKind.LexicalBinding)
{
_tdzNames = new List <string>(1);
id.GetBoundNames(_tdzNames);
}
if (id is BindingPattern bindingPattern)
{
_destructuring = true;
_assignmentPattern = bindingPattern;
}
else
{
var identifier = (Identifier)id;
_expr = new JintIdentifierExpression(identifier);
}
}
else if (_leftNode is BindingPattern bindingPattern)
{
_destructuring = true;
_assignmentPattern = bindingPattern;
}
else if (_leftNode is MemberExpression memberExpression)
{
_expr = new JintMemberExpression(memberExpression);
}
else
{
_expr = new JintIdentifierExpression((Identifier)_leftNode);
}
_body = Build(_forBody);
_right = JintExpression.Build(engine, _rightExpression);
}
protected override void Initialize(EvaluationContext context)
{
if (_statement.Declaration is ClassDeclaration classDeclaration)
{
_classDefinition = new ClassDefinition(className: classDeclaration.Id?.Name, classDeclaration.SuperClass, classDeclaration.Body);
}
else if (_statement.Declaration is FunctionDeclaration functionDeclaration)
{
_functionDeclaration = new JintFunctionDeclarationStatement(functionDeclaration);
}
else if (_statement.Declaration is AssignmentExpression assignmentExpression)
{
_assignmentExpression = JintAssignmentExpression.Build(context.Engine, assignmentExpression);
}
else
{
_simpleExpression = JintExpression.Build(context.Engine, (Expression)_statement.Declaration);
}
}
protected override void Initialize(EvaluationContext context)
{
if (_statement.Declaration != null)
{
switch (_statement.Declaration)
{
case Expression e:
_declarationExpression = JintExpression.Build(context.Engine, e);
break;
case Statement s:
_declarationStatement = Build(s);
break;
default:
ExceptionHelper.ThrowNotSupportedException($"Statement {_statement.Declaration.Type} is not supported in an export declaration.");
break;
}
}
}
private static bool TryGetComputedPropertyKey <T>(T expression, Engine engine, out JsValue propertyKey)
where T : Expression
{
if (expression.Type is Nodes.Identifier
or Nodes.CallExpression
or Nodes.BinaryExpression
or Nodes.UpdateExpression
or Nodes.AssignmentExpression
or Nodes.UnaryExpression
or Nodes.MemberExpression
or Nodes.LogicalExpression
or Nodes.ConditionalExpression
or Nodes.ArrowFunctionExpression
or Nodes.FunctionExpression)
{
var context = engine._activeEvaluationContext;
propertyKey = TypeConverter.ToPropertyKey(JintExpression.Build(engine, expression).GetValue(context).Value);
return(true);
}
propertyKey = string.Empty;
return(false);
}
protected override void Initialize()
{
_declarations = new ResolvedDeclaration[_statement.Declarations.Count];
for (var i = 0; i < _declarations.Length; i++)
{
var declaration = _statement.Declarations[i];
JintExpression left = null;
JintExpression init = null;
BindingPattern bindingPattern = null;
if (declaration.Id is BindingPattern bp)
{
bindingPattern = bp;
}
else
{
left = JintExpression.Build(_engine, declaration.Id);
}
if (declaration.Init != null)
{
init = JintExpression.Build(_engine, declaration.Init);
}
var leftIdentifier = left as JintIdentifierExpression;
_declarations[i] = new ResolvedDeclaration
{
Left = left,
LeftPattern = bindingPattern,
LeftIdentifierExpression = leftIdentifier,
EvalOrArguments = leftIdentifier?.HasEvalOrArguments == true,
Init = init
};
}
}
protected override void Initialize(EvaluationContext context)
{
_expression = JintExpression.Build(context.Engine, _statement.Expression);
}
public JintImportExpression(Import expression) : base(expression)
{
_initialized = false;
_importExpression = null !;
}
public JintIfStatement(Engine engine, IfStatement statement) : base(engine, statement)
{
_statementConsequent = Build(engine, _statement.Consequent);
_test = JintExpression.Build(engine, _statement.Test);
_alternate = _statement.Alternate != null?Build(engine, _statement.Alternate) : null;
}
public JintExpressionStatement(Engine engine, ExpressionStatement statement) : base(engine, statement)
{
_expression = JintExpression.Build(engine, statement.Expression);
}
protected override void Initialize(EvaluationContext context)
{
_labelSetName = _statement.LabelSet?.Name;
_body = Build(_statement.Body);
_test = JintExpression.Build(context.Engine, _statement.Test);
}
/// <summary>
/// https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset
/// </summary>
private Completion BodyEvaluation(
JintExpression lhs,
JintStatement stmt,
IIterator iteratorRecord,
IterationKind iterationKind,
LhsKind lhsKind,
IteratorKind iteratorKind = IteratorKind.Sync)
{
var oldEnv = _engine.ExecutionContext.LexicalEnvironment;
var v = Undefined.Instance;
var destructuring = _destructuring;
string lhsName = null;
var completionType = CompletionType.Normal;
var close = false;
try
{
while (true)
{
LexicalEnvironment iterationEnv = null;
if (!iteratorRecord.TryIteratorStep(out var nextResult))
{
close = true;
return(new Completion(CompletionType.Normal, v, null, Location));
}
if (iteratorKind == IteratorKind.Async)
{
// nextResult = await nextResult;
}
var nextValue = nextResult.Get(CommonProperties.Value);
close = true;
Reference lhsRef = null;
if (lhsKind != LhsKind.LexicalBinding)
{
if (!destructuring)
{
lhsRef = (Reference)lhs.Evaluate();
}
}
else
{
iterationEnv = LexicalEnvironment.NewDeclarativeEnvironment(_engine, oldEnv);
if (_tdzNames != null)
{
BindingInstantiation(iterationEnv);
}
_engine.UpdateLexicalEnvironment(iterationEnv);
if (!destructuring)
{
if (lhsName == null)
{
lhsName = ((Identifier)((VariableDeclaration)_leftNode).Declarations[0].Id).Name;
}
lhsRef = _engine.ResolveBinding(lhsName);
}
}
if (!destructuring)
{
// If lhsRef is an abrupt completion, then
// Let status be lhsRef.
if (lhsKind == LhsKind.LexicalBinding)
{
lhsRef.InitializeReferencedBinding(nextValue);
}
else
{
_engine.PutValue(lhsRef, nextValue);
}
}
else
{
BindingPatternAssignmentExpression.ProcessPatterns(
_engine,
_assignmentPattern,
nextValue,
iterationEnv,
checkObjectPatternPropertyReference: _lhsKind != LhsKind.VarBinding);
if (lhsKind == LhsKind.Assignment)
{
// DestructuringAssignmentEvaluation of assignmentPattern using nextValue as the argument.
}
else if (lhsKind == LhsKind.VarBinding)
{
// BindingInitialization for lhs passing nextValue and undefined as the arguments.
}
else
{
// BindingInitialization for lhs passing nextValue and iterationEnv as arguments
}
}
var result = stmt.Execute();
_engine.UpdateLexicalEnvironment(oldEnv);
if (!ReferenceEquals(result.Value, null))
{
v = result.Value;
}
if (result.Type == CompletionType.Break && (result.Identifier == null || result.Identifier == _statement?.LabelSet?.Name))
{
return(new Completion(CompletionType.Normal, v, null, Location));
}
if (result.Type != CompletionType.Continue || (result.Identifier != null && result.Identifier != _statement?.LabelSet?.Name))
{
if (result.Type != CompletionType.Normal)
{
return(result);
}
}
}
}
catch
{
completionType = CompletionType.Throw;
throw;
}
finally
{
if (close)
{
iteratorRecord.Close(completionType);
}
_engine.UpdateLexicalEnvironment(oldEnv);
}
}
protected override void Initialize(EvaluationContext context)
{
_argument = _statement.Argument != null
? JintExpression.Build(context.Engine, _statement.Argument)
: null;
}
public JintDoWhileStatement(Engine engine, DoWhileStatement statement) : base(engine, statement)
{
_body = Build(_engine, statement.Body);
_test = JintExpression.Build(engine, statement.Test);
_labelSetName = statement.LabelSet?.Name;
}
protected override void Initialize(EvaluationContext context)
{
var expression = ((Import)_expression).Source;
_importExpression = Build(context.Engine, expression !);
}
public JintWhileStatement(Engine engine, WhileStatement statement) : base(engine, statement)
{
_labelSetName = _statement?.LabelSet?.Name;
_body = Build(engine, statement.Body);
_test = JintExpression.Build(engine, statement.Test);
}
protected override void Initialize(EvaluationContext context)
{
_statementConsequent = Build(_statement.Consequent);
_test = JintExpression.Build(context.Engine, _statement.Test);
_alternate = _statement.Alternate != null?Build(_statement.Alternate) : null;
}
protected override void Initialize()
{
_switchBlock = new JintSwitchBlock(_engine, _statement.Cases);
_discriminant = JintExpression.Build(_engine, _statement.Discriminant);
}
public JintWithStatement(Engine engine, WithStatement statement) : base(engine, statement)
{
_body = Build(engine, statement.Body);
_object = JintExpression.Build(engine, _statement.Object);
}
/// <summary>
/// https://tc39.es/ecma262/#sec-runtime-semantics-forin-div-ofbodyevaluation-lhs-stmt-iterator-lhskind-labelset
/// </summary>
private Completion BodyEvaluation(
EvaluationContext context,
JintExpression lhs,
JintStatement stmt,
IteratorInstance iteratorRecord,
IterationKind iterationKind,
LhsKind lhsKind,
IteratorKind iteratorKind = IteratorKind.Sync)
{
var engine = context.Engine;
var oldEnv = engine.ExecutionContext.LexicalEnvironment;
var v = Undefined.Instance;
var destructuring = _destructuring;
string lhsName = null;
var completionType = CompletionType.Normal;
var close = false;
try
{
while (true)
{
EnvironmentRecord iterationEnv = null;
if (!iteratorRecord.TryIteratorStep(out var nextResult))
{
close = true;
return(new Completion(CompletionType.Normal, v, null, Location));
}
if (iteratorKind == IteratorKind.Async)
{
// nextResult = await nextResult;
ExceptionHelper.ThrowNotImplementedException("await");
}
var nextValue = nextResult.Get(CommonProperties.Value);
close = true;
var lhsRef = new ExpressionResult();
if (lhsKind != LhsKind.LexicalBinding)
{
if (!destructuring)
{
lhsRef = lhs.Evaluate(context);
}
}
else
{
iterationEnv = JintEnvironment.NewDeclarativeEnvironment(engine, oldEnv);
if (_tdzNames != null)
{
BindingInstantiation(iterationEnv);
}
engine.UpdateLexicalEnvironment(iterationEnv);
if (!destructuring)
{
var identifier = (Identifier)((VariableDeclaration)_leftNode).Declarations[0].Id;
lhsName ??= identifier.Name;
lhsRef = new ExpressionResult(ExpressionCompletionType.Normal, engine.ResolveBinding(lhsName), identifier.Location);
}
}
if (context.DebugMode)
{
context.Engine.DebugHandler.OnStep(_leftNode);
}
var status = new Completion();
if (!destructuring)
{
if (lhsRef.IsAbrupt())
{
close = true;
status = new Completion(lhsRef);
}
else if (lhsKind == LhsKind.LexicalBinding)
{
((Reference)lhsRef.Value).InitializeReferencedBinding(nextValue);
}
else
{
engine.PutValue((Reference)lhsRef.Value, nextValue);
}
}
else
{
status = BindingPatternAssignmentExpression.ProcessPatterns(
context,
_assignmentPattern,
nextValue,
iterationEnv,
checkObjectPatternPropertyReference: _lhsKind != LhsKind.VarBinding);
if (lhsKind == LhsKind.Assignment)
{
// DestructuringAssignmentEvaluation of assignmentPattern using nextValue as the argument.
}
else if (lhsKind == LhsKind.VarBinding)
{
// BindingInitialization for lhs passing nextValue and undefined as the arguments.
}
else
{
// BindingInitialization for lhs passing nextValue and iterationEnv as arguments
}
}
if (status.IsAbrupt())
{
engine.UpdateLexicalEnvironment(oldEnv);
if (_iterationKind == IterationKind.AsyncIterate)
{
iteratorRecord.Close(status.Type);
return(status);
}
if (iterationKind == IterationKind.Enumerate)
{
return(status);
}
iteratorRecord.Close(status.Type);
return(status);
}
var result = stmt.Execute(context);
engine.UpdateLexicalEnvironment(oldEnv);
if (!ReferenceEquals(result.Value, null))
{
v = result.Value;
}
if (result.Type == CompletionType.Break && (result.Target == null || result.Target == _statement?.LabelSet?.Name))
{
completionType = CompletionType.Normal;
return(new Completion(CompletionType.Normal, v, null, Location));
}
if (result.Type != CompletionType.Continue || (result.Target != null && result.Target != _statement?.LabelSet?.Name))
{
completionType = result.Type;
if (result.IsAbrupt())
{
close = true;
return(result);
}
}
}
}
catch
{
completionType = CompletionType.Throw;
throw;
}
finally
{
if (close)
{
try
{
iteratorRecord.Close(completionType);
}
catch
{
// if we already have and exception, use it
if (completionType != CompletionType.Throw)
{
throw;
}
}
}
engine.UpdateLexicalEnvironment(oldEnv);
}
}
public JintReturnStatement(Engine engine, ReturnStatement statement) : base(engine, statement)
{
_argument = _statement.Argument != null
? JintExpression.Build(engine, _statement.Argument)
: null;
}
protected override void Initialize(EvaluationContext context)
{
_body = Build(_statement.Body);
_object = JintExpression.Build(context.Engine, _statement.Object);
}
protected override void Initialize()
{
_argument = JintExpression.Build(_engine, _statement.Argument);
}
