public override Completion Evaluate(Interpreter interpreter)
{
var envBase = interpreter.GetThisEnvironment();
if (!(envBase is FunctionEnvironmentRecord env))
{
throw new InvalidOperationException("Invalid This Environment type for Super");
}
var actualThisComp = env.GetThisBinding();
if (actualThisComp.IsAbrupt())
{
return(actualThisComp);
}
var actualThis = actualThisComp.value !;
var propertyNameComp = superIndexerExpression.Evaluate(interpreter).GetValue();
if (propertyNameComp.IsAbrupt())
{
return(propertyNameComp);
}
var propertyNameValue = propertyNameComp.value !;
var propertyKey = propertyNameValue.ToPropertyKey();
if (propertyKey.IsAbrupt())
{
return(propertyKey);
}
return(SuperHelper.MakeSuperPropertyReference(actualThis, propertyKey.Other !, IsStrictMode));
}
public override Completion Evaluate(Interpreter interpreter)
{
var baseValueComp = indexedMemberExpression.Evaluate(interpreter).GetValue();
if (baseValueComp.IsAbrupt())
{
return(baseValueComp);
}
var baseValue = baseValueComp.value !;
var propertyNameComp = indexerExpression.Evaluate(interpreter).GetValue();
if (propertyNameComp.IsAbrupt())
{
return(propertyNameComp);
}
var propertyNameValue = propertyNameComp.value !;
var coercible = baseValue.RequireObjectCoercible();
if (coercible.IsAbrupt())
{
return(coercible);
}
var propertyKey = propertyNameValue.ToPropertyKey();
if (propertyKey.IsAbrupt())
{
return(propertyKey);
}
return(Completion.NormalCompletion(new ReferenceValue(baseValue, propertyKey.Other !, IsStrictMode)));
}
public override Completion LabelledEvaluate(Interpreter interpreter, List <string> labels)
{
IValue V = UndefinedValue.Instance;
while (true)
{
var conditionComp = whileExpression.Evaluate(interpreter);
var condition = conditionComp.GetValue();
if (condition.IsAbrupt())
{
return(condition);
}
if (!condition.value !.ToBoolean().boolean)
{
return(Completion.NormalCompletion(V));
}
var stmtResult = doStatement.Evaluate(interpreter);
if (!LoopContinues(stmtResult, labels))
{
return(stmtResult.UpdateEmpty(V));
}
if (stmtResult.value != null)
{
V = stmtResult.value;
}
}
}
public override Completion Evaluate(Interpreter interpreter)
{
var exprComp = expression.Evaluate(interpreter).GetValue();
if (exprComp.IsAbrupt())
{
return(exprComp);
}
return(new Completion(CompletionType.Throw, exprComp.value, null));
}
public override Completion Evaluate(Interpreter interpreter)
{
if (hasElse)
{
var conditionComp = conditionExpression.Evaluate(interpreter).GetValue();
if (conditionComp.IsAbrupt())
{
return(conditionComp);
}
var condition = conditionComp.value !.ToBoolean();
Completion stmtCompletion;
if (condition.boolean)
{
stmtCompletion = trueStatement.Evaluate(interpreter);
}
else
{
stmtCompletion = falseStatement !.Evaluate(interpreter);
}
return(stmtCompletion.UpdateEmpty(UndefinedValue.Instance));
}
else
{
var conditionComp = conditionExpression.Evaluate(interpreter).GetValue();
if (conditionComp.IsAbrupt())
{
return(conditionComp);
}
var condition = conditionComp.value !.ToBoolean();
if (!condition.boolean)
{
return(Completion.NormalCompletion(UndefinedValue.Instance));
}
else
{
var stmtCompletion = trueStatement.Evaluate(interpreter);
return(stmtCompletion.UpdateEmpty(UndefinedValue.Instance));
}
}
}
public override Completion Evaluate(Interpreter interpreter)
{
var switchComp = switchExpression.Evaluate(interpreter).GetValue();
if (switchComp.IsAbrupt())
{
return(switchComp);
}
var switchValue = switchComp.value;
var oldEnv = interpreter.RunningExecutionContext().LexicalEnvironment;
var blockEnv = oldEnv.NewDeclarativeEnvironment();
Block.BlockDeclarationInstantiation(caseBlock, blockEnv);
interpreter.RunningExecutionContext().LexicalEnvironment = blockEnv;
var R = caseBlock.CaseBlockEvaluation(switchValue !);
interpreter.RunningExecutionContext().LexicalEnvironment = oldEnv;
return(R);
}
protected static CompletionOr <IteratorRecord?> ForInOfHeadEvaluation(IEnumerable <string> TDZNames, AbstractExpression expr, IterationKind iterationKind)
{
var oldEnv = Interpreter.Instance().RunningExecutionContext().LexicalEnvironment;
if (TDZNames.Any())
{
if (TDZNames.Distinct().Count() < TDZNames.Count())
{
throw new InvalidOperationException("Spec 13.7.5.12 step 2a");
}
var TDZ = oldEnv.NewDeclarativeEnvironment();
var TDZEnvRec = TDZ.EnvironmentRecord;
foreach (var name in TDZNames)
{
TDZEnvRec.CreateMutableBinding(name, false);
}
Interpreter.Instance().RunningExecutionContext().LexicalEnvironment = TDZ;
}
var exprRef = expr.Evaluate(Interpreter.Instance());
Interpreter.Instance().RunningExecutionContext().LexicalEnvironment = oldEnv;
var exprValue = exprRef.GetValue();
if (exprValue.IsAbrupt())
{
return(exprValue.WithEmpty <IteratorRecord?>());
}
if (iterationKind == IterationKind.Enumerate)
{
if (exprValue.value == UndefinedValue.Instance || exprValue.value == NullValue.Instance)
{
return(new Completion(CompletionType.Break, null, null).WithEmpty <IteratorRecord?>());
}
var obj = exprValue.value !.ToObject().value as Object;
return(obj !.EnumerateObjectProperties());
}
else
{
return((exprValue.value !.ToObject().value as Object) !.GetIterator());
}
}
public override Completion Evaluate(Interpreter interpreter)
{
return(expression.Evaluate(interpreter).GetValue());
}
