internal static JsValue AssignToIdentifier(
Engine engine,
JintIdentifierExpression left,
JintExpression right,
bool hasEvalOrArguments)
{
var env = engine.ExecutionContext.LexicalEnvironment;
var strict = StrictModeScope.IsStrictModeCode;
if (LexicalEnvironment.TryGetIdentifierEnvironmentWithBindingValue(
env,
left._expressionName,
strict,
out var environmentRecord,
out _))
{
if (strict && hasEvalOrArguments)
{
ExceptionHelper.ThrowSyntaxError(engine);
}
var rval = right.GetValue().Clone();
if (right._expression.IsFunctionWithName())
{
((FunctionInstance)rval).SetFunctionName(left._expressionName.StringValue);
}
environmentRecord.SetMutableBinding(left._expressionName, rval, strict);
return(rval);
}
return(null);
}
public JintCallExpression(Engine engine, CallExpression expression) : base(engine, expression)
{
_initialized = false;
_isDebugMode = engine.Options.IsDebugMode;
_maxRecursionDepth = engine.Options.MaxRecursionDepth;
_calleeExpression = Build(engine, expression.Callee);
}
protected override void Initialize(EvaluationContext context)
{
var expression = (BinaryExpression)_expression;
_left = Build(context.Engine, expression.Left);
_right = Build(context.Engine, expression.Right);
}
protected override void Initialize(EvaluationContext context)
{
var engine = context.Engine;
_tagIdentifier = Build(engine, _taggedTemplateExpression.Tag);
_quasi = new JintTemplateLiteralExpression(_taggedTemplateExpression.Quasi);
_quasi.DoInitialize(context);
}
protected override void Initialize(EvaluationContext context)
{
var engine = context.Engine;
var expression = (CallExpression)_expression;
_calleeExpression = Build(engine, expression.Callee);
var cachedArgumentsHolder = new CachedArgumentsHolder
{
JintArguments = new JintExpression[expression.Arguments.Count]
};
protected override void Initialize()
{
var assignmentExpression = ((AssignmentExpression)_expression);
_left = Build(_engine, assignmentExpression.Left);
_leftIdentifier = _left as JintIdentifierExpression;
_evalOrArguments = _leftIdentifier?.HasEvalOrArguments == true;
_right = Build(_engine, assignmentExpression.Right);
}
private JsValue NamedEvaluation(EvaluationContext context, JintExpression expression)
{
var rval = expression.GetValue(context).Value;
if (expression._expression.IsAnonymousFunctionDefinition() && _left._expression.Type == Nodes.Identifier)
{
((FunctionInstance)rval).SetFunctionName(((Identifier)_left._expression).Name);
}
return(rval);
}
public NullishCoalescingExpression(Engine engine, BinaryExpression expression) : base(expression)
{
_left = Build(engine, expression.Left);
// we can create a fast path for common literal case like variable ?? 0
if (expression.Right is Literal l)
{
_constant = JintLiteralExpression.ConvertToJsValue(l);
}
else
{
_right = Build(engine, expression.Right);
}
}
protected override void Initialize()
{
var expression = (NewExpression)_expression;
_calleeExpression = Build(_engine, expression.Callee);
if (expression.Arguments.Count <= 0)
{
return;
}
_jintArguments = new JintExpression[expression.Arguments.Count];
for (var i = 0; i < _jintArguments.Length; i++)
{
var argument = expression.Arguments[i];
_jintArguments[i] = Build(_engine, argument);
_hasSpreads |= argument.Type == Nodes.SpreadElement;
}
}
protected override void Initialize(EvaluationContext context)
{
_memberExpression = (MemberExpression)_expression;
_objectExpression = Build(context.Engine, _memberExpression.Object);
if (!_memberExpression.Computed)
{
_determinedProperty = ((Identifier)_memberExpression.Property).Name;
}
else if (_memberExpression.Property.Type == Nodes.Literal)
{
_determinedProperty = JintLiteralExpression.ConvertToJsValue((Literal)_memberExpression.Property);
}
if (_determinedProperty is null)
{
_propertyExpression = Build(context.Engine, _memberExpression.Property);
}
}
protected override void Initialize()
{
var expression = (MemberExpression)_expression;
_objectExpression = Build(_engine, expression.Object);
_objectIdentifierExpression = _objectExpression as JintIdentifierExpression;
_objectThisExpression = _objectExpression as JintThisExpression;
if (!expression.Computed)
{
_determinedProperty = ((Identifier)expression.Property).Name;
}
else if (expression.Property.Type == Nodes.Literal)
{
_determinedProperty = JintLiteralExpression.ConvertToJsValue((Literal)expression.Property);
}
if (_determinedProperty is null)
{
_propertyExpression = Build(_engine, expression.Property);
}
}
internal static ExpressionResult?AssignToIdentifier(
EvaluationContext context,
JintIdentifierExpression left,
JintExpression right,
bool hasEvalOrArguments)
{
var engine = context.Engine;
var env = engine.ExecutionContext.LexicalEnvironment;
var strict = StrictModeScope.IsStrictModeCode;
if (JintEnvironment.TryGetIdentifierEnvironmentWithBinding(
env,
left._expressionName,
out var environmentRecord))
{
if (strict && hasEvalOrArguments)
{
ExceptionHelper.ThrowSyntaxError(engine.Realm);
}
var completion = right.GetValue(context);
if (completion.IsAbrupt())
{
return(completion);
}
var rval = completion.Value.Clone();
if (right._expression.IsFunctionDefinition())
{
((FunctionInstance)rval).SetFunctionName(left._expressionName.StringValue);
}
environmentRecord.SetMutableBinding(left._expressionName, rval, strict);
return(new Completion(CompletionType.Normal, rval, default));
}
return(null);
}
protected override void Initialize()
{
var expression = (UpdateExpression)_expression;
_prefix = expression.Prefix;
_argument = Build(_engine, expression.Argument);
if (expression.Operator == UnaryOperator.Increment)
{
_change = 1;
}
else if (expression.Operator == UnaryOperator.Decrement)
{
_change = -1;
}
else
{
ExceptionHelper.ThrowArgumentException();
}
_leftIdentifier = _argument as JintIdentifierExpression;
_evalOrArguments = _leftIdentifier?.HasEvalOrArguments == true;
}
public JintLogicalAndExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
{
_left = Build(engine, expression.Left);
_right = Build(engine, expression.Right);
}
public JintConditionalExpression(Engine engine, ConditionalExpression expression) : base(expression)
{
_test = Build(engine, expression.Test);
_consequent = Build(engine, expression.Consequent);
_alternate = Build(engine, expression.Alternate);
}
private JintUnaryExpression(Engine engine, UnaryExpression expression) : base(engine, expression)
{
_argument = Build(engine, expression.Argument);
_operator = expression.Operator;
}
protected override void Initialize(EvaluationContext context)
{
_right = Build(context.Engine, ((AssignmentExpression)_expression).Right);
}
private JintBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
{
_left = Build(engine, expression.Left);
_right = Build(engine, expression.Right);
_operatorType = expression.Operator;
}
protected override void Initialize()
{
_tagIdentifier = Build(_engine, _taggedTemplateExpression.Tag);
_quasi = (JintTemplateLiteralExpression)Build(_engine, _taggedTemplateExpression.Quasi);
_quasi.DoInitialize();
}
protected override void Initialize()
{
_right = Build(_engine, ((AssignmentExpression)_expression).Right);
}
private JintAssignmentExpression(Engine engine, AssignmentExpression expression) : base(engine, expression)
{
_left = Build(engine, expression.Left);
_right = Build(engine, expression.Right);
_operator = expression.Operator;
}
public JintSpreadExpression(Engine engine, SpreadElement expression) : base(expression)
{
_argument = Build(engine, expression.Argument);
_argumentName = (expression.Argument as Identifier)?.Name;
}