Reduce Engine references in expressions (#1293)

Jint.Tests/Runtime/EngineLimitTests.cs

@@ -10,7 +10,7 @@ public class EngineLimitTests
     public void ShouldAllowReasonableCallStackDepth()
     {
 #if RELEASE
-        const int FunctionNestingCount = 990;
+        const int FunctionNestingCount = 1000;
 #else
         const int FunctionNestingCount = 570;
 #endif

Jint/EsprimaExtensions.cs

@@ -72,7 +72,7 @@ namespace Jint
                 or Nodes.YieldExpression)
             {
                 var context = engine._activeEvaluationContext;
-                return JintExpression.Build(engine, expression).GetValue(context!);
+                return JintExpression.Build(expression).GetValue(context!);
             }
 
             return JsValue.Undefined;

Jint/Native/Function/ClassDefinition.cs

@@ -88,7 +88,7 @@ namespace Jint.Native.Function
             else
             {
                 engine.UpdateLexicalEnvironment(classScope);
-                var superclass = JintExpression.Build(engine, _superClass).GetValue(context);
+                var superclass = JintExpression.Build(_superClass).GetValue(context);
                 engine.UpdateLexicalEnvironment(env);
 
                 if (superclass.IsNull())

Jint/Runtime/Environments/FunctionEnvironmentRecord.cs

@@ -360,7 +360,7 @@ namespace Jint.Runtime.Environments
             if (argument.IsUndefined())
             {
                 var expression = right.As<Expression>();
-                var jintExpression = JintExpression.Build(_engine, expression);
+                var jintExpression = JintExpression.Build(expression);
 
                 var oldEnv = _engine.ExecutionContext.LexicalEnvironment;
                 var paramVarEnv = JintEnvironment.NewDeclarativeEnvironment(_engine, oldEnv);

Jint/Runtime/ExceptionHelper.cs

@@ -2,6 +2,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Runtime.ExceptionServices;
 using Esprima;
+using Esprima.Ast;
 using Jint.Native;
 using Jint.Native.Error;
 using Jint.Runtime.CallStack;
@@ -57,9 +58,9 @@ namespace Jint.Runtime
         }
 
         [DoesNotReturn]
-        public static void ThrowTypeErrorNoEngine(string? message = null)
+        public static void ThrowTypeErrorNoEngine(string? message = null, Node? source = null)
         {
-            throw new TypeErrorException(message);
+            throw new TypeErrorException(message, source);
         }
 
         [DoesNotReturn]

Jint/Runtime/Interpreter/EvaluationContext.cs

@@ -18,6 +18,15 @@ internal sealed class EvaluationContext
         _shouldRunBeforeExecuteStatementChecks = engine._constraints.Length > 0 || engine._isDebugMode;
     }
 
+    // for fast evaluation checks only
+    public EvaluationContext()
+    {
+        Engine = null!;
+        ResumedCompletion = default; // TODO later
+        OperatorOverloadingAllowed = false;
+        _shouldRunBeforeExecuteStatementChecks = false;
+    }
+
     public readonly Engine Engine;
     public readonly Completion ResumedCompletion;
     public bool DebugMode => Engine._isDebugMode;

Jint/Runtime/Interpreter/Expressions/BindingPatternAssignmentExpression.cs

@@ -21,7 +21,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         protected override void Initialize(EvaluationContext context)
         {
-            _right = Build(context.Engine, ((AssignmentExpression) _expression).Right);
+            _right = Build(((AssignmentExpression) _expression).Right);
         }
 
         protected override object EvaluateInternal(EvaluationContext context)
@@ -239,7 +239,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
                         if (value.IsUndefined())
                         {
-                            var jintExpression = Build(engine, assignmentPattern.Right);
+                            var jintExpression = Build(assignmentPattern.Right);
                             var completion = jintExpression.GetValue(context);
                             if (context.IsAbrupt())
                             {
@@ -308,7 +308,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                     var identifier = p.Key as Identifier;
                     if (identifier == null || p.Computed)
                     {
-                        var keyExpression = Build(context.Engine, p.Key);
+                        var keyExpression = Build(p.Key);
                         var value = keyExpression.GetValue(context);
                         if (context.IsAbrupt())
                         {
@@ -327,7 +327,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                         source.TryGetValue(sourceKey, out var value);
                         if (value.IsUndefined())
                         {
-                            var jintExpression = Build(context.Engine, assignmentPattern.Right);
+                            var jintExpression = Build(assignmentPattern.Right);
                             var completion = jintExpression.GetValue(context);
                             if (context.IsAbrupt())
                             {

Jint/Runtime/Interpreter/Expressions/JintArrayExpression.cs

@@ -25,7 +25,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 var expr = node.Elements[n];
                 if (expr != null)
                 {
-                    var expression = Build(engine, expr);
+                    var expression = Build(expr);
                     _expressions[n] = expression;
                     _hasSpreads |= expr.Type == Nodes.SpreadElement;
                 }

Jint/Runtime/Interpreter/Expressions/JintArrowFunctionExpression.cs

@@ -8,7 +8,7 @@ namespace Jint.Runtime.Interpreter.Expressions
     {
         private readonly JintFunctionDefinition _function;
 
-        public JintArrowFunctionExpression(Engine engine, ArrowFunctionExpression function) : base(function)
+        public JintArrowFunctionExpression(ArrowFunctionExpression function) : base(function)
         {
             _function = new JintFunctionDefinition(function);
         }

Jint/Runtime/Interpreter/Expressions/JintAssignmentExpression.cs

@@ -13,14 +13,14 @@ namespace Jint.Runtime.Interpreter.Expressions
         private readonly JintExpression _right;
         private readonly AssignmentOperator _operator;
 
-        private JintAssignmentExpression(Engine engine, AssignmentExpression expression) : base(expression)
+        private JintAssignmentExpression(AssignmentExpression expression) : base(expression)
         {
-            _left = Build(engine, (Expression) expression.Left);
-            _right = Build(engine, expression.Right);
+            _left = Build((Expression) expression.Left);
+            _right = Build(expression.Right);
             _operator = expression.Operator;
         }
 
-        internal static JintExpression Build(Engine engine, AssignmentExpression expression)
+        internal static JintExpression Build(AssignmentExpression expression)
         {
             if (expression.Operator == AssignmentOperator.Assign)
             {
@@ -32,7 +32,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 return new SimpleAssignmentExpression(expression);
             }
 
-            return new JintAssignmentExpression(engine, expression);
+            return new JintAssignmentExpression(expression);
         }
 
         protected override object EvaluateInternal(EvaluationContext context)
@@ -345,11 +345,11 @@ namespace Jint.Runtime.Interpreter.Expressions
             protected override void Initialize(EvaluationContext context)
             {
                 var assignmentExpression = (AssignmentExpression) _expression;
-                _left = Build(context.Engine, (Expression) assignmentExpression.Left);
+                _left = Build((Expression) assignmentExpression.Left);
                 _leftIdentifier = _left as JintIdentifierExpression;
                 _evalOrArguments = _leftIdentifier?.HasEvalOrArguments == true;
 
-                _right = Build(context.Engine, assignmentExpression.Right);
+                _right = Build(assignmentExpression.Right);
             }
 
             protected override object EvaluateInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintBinaryExpression.cs

@@ -17,15 +17,20 @@ namespace Jint.Runtime.Interpreter.Expressions
         private readonly record struct OperatorKey(string? OperatorName, Type Left, Type Right);
         private static readonly ConcurrentDictionary<OperatorKey, MethodDescriptor> _knownOperators = new();
 
-        private readonly JintExpression _left;
-        private readonly JintExpression _right;
+        private JintExpression _left = null!;
+        private JintExpression _right = null!;
 
-        private JintBinaryExpression(Engine engine, BinaryExpression expression) : base(expression)
+        private JintBinaryExpression(BinaryExpression expression) : base(expression)
         {
             // TODO check https://tc39.es/ecma262/#sec-applystringornumericbinaryoperator
+            _initialized = false;
+        }
 
-            _left = Build(engine, expression.Left);
-            _right = Build(engine, expression.Right);
+        protected override void Initialize(EvaluationContext context)
+        {
+            var expression = (BinaryExpression) _expression;
+            _left = Build(expression.Left);
+            _right = Build(expression.Right);
         }
 
         internal static bool TryOperatorOverloading(
@@ -76,46 +81,46 @@ namespace Jint.Runtime.Interpreter.Expressions
             return false;
         }
 
-        internal static JintExpression Build(Engine engine, BinaryExpression expression)
+        internal static JintExpression Build(BinaryExpression expression)
         {
             JintBinaryExpression? result = null;
             switch (expression.Operator)
             {
                 case BinaryOperator.StrictlyEqual:
-                    result = new StrictlyEqualBinaryExpression(engine, expression);
+                    result = new StrictlyEqualBinaryExpression(expression);
                     break;
                 case BinaryOperator.StrictlyNotEqual:
-                    result = new StrictlyNotEqualBinaryExpression(engine, expression);
+                    result = new StrictlyNotEqualBinaryExpression(expression);
                     break;
                 case BinaryOperator.Less:
-                    result = new LessBinaryExpression(engine, expression);
+                    result = new LessBinaryExpression(expression);
                     break;
                 case BinaryOperator.Greater:
-                    result = new GreaterBinaryExpression(engine, expression);
+                    result = new GreaterBinaryExpression(expression);
                     break;
                 case BinaryOperator.Plus:
-                    result = new PlusBinaryExpression(engine, expression);
+                    result = new PlusBinaryExpression(expression);
                     break;
                 case BinaryOperator.Minus:
-                    result = new MinusBinaryExpression(engine, expression);
+                    result = new MinusBinaryExpression(expression);
                     break;
                 case BinaryOperator.Times:
-                    result = new TimesBinaryExpression(engine, expression);
+                    result = new TimesBinaryExpression(expression);
                     break;
                 case BinaryOperator.Divide:
-                    result = new DivideBinaryExpression(engine, expression);
+                    result = new DivideBinaryExpression(expression);
                     break;
                 case BinaryOperator.Equal:
-                    result = new EqualBinaryExpression(engine, expression);
+                    result = new EqualBinaryExpression(expression);
                     break;
                 case BinaryOperator.NotEqual:
-                    result = new EqualBinaryExpression(engine, expression, invert: true);
+                    result = new EqualBinaryExpression(expression, invert: true);
                     break;
                 case BinaryOperator.GreaterOrEqual:
-                    result = new CompareBinaryExpression(engine, expression, leftFirst: true);
+                    result = new CompareBinaryExpression(expression, leftFirst: true);
                     break;
                 case BinaryOperator.LessOrEqual:
-                    result = new CompareBinaryExpression(engine, expression, leftFirst: false);
+                    result = new CompareBinaryExpression(expression, leftFirst: false);
                     break;
                 case BinaryOperator.BitwiseAnd:
                 case BinaryOperator.BitwiseOr:
@@ -123,19 +128,19 @@ namespace Jint.Runtime.Interpreter.Expressions
                 case BinaryOperator.LeftShift:
                 case BinaryOperator.RightShift:
                 case BinaryOperator.UnsignedRightShift:
-                    result = new BitwiseBinaryExpression(engine, expression);
+                    result = new BitwiseBinaryExpression(expression);
                     break;
                 case BinaryOperator.InstanceOf:
-                    result = new InstanceOfBinaryExpression(engine, expression);
+                    result = new InstanceOfBinaryExpression(expression);
                     break;
                 case BinaryOperator.Exponentiation:
-                    result = new ExponentiationBinaryExpression(engine, expression);
+                    result = new ExponentiationBinaryExpression(expression);
                     break;
                 case BinaryOperator.Modulo:
-                    result = new ModuloBinaryExpression(engine, expression);
+                    result = new ModuloBinaryExpression(expression);
                     break;
                 case BinaryOperator.In:
-                    result = new InBinaryExpression(engine, expression);
+                    result = new InBinaryExpression(expression);
                     break;
                 default:
                     ExceptionHelper.ThrowArgumentOutOfRangeException(nameof(expression.Operator), "cannot handle operator");
@@ -153,8 +158,15 @@ namespace Jint.Runtime.Interpreter.Expressions
                 if (lval is not null && rval is not null)
                 {
                     // we have fixed result
-                    var context = new EvaluationContext(engine);
-                    return new JintConstantExpression(expression, result.GetValue(context));
+                    try
+                    {
+                        var context = new EvaluationContext();
+                        return new JintConstantExpression(expression, result.GetValue(context));
+                    }
+                    catch
+                    {
+                        // probably caused an error and error reporting doesn't work without engine
+                    }
                 }
             }
 
@@ -167,17 +179,17 @@ namespace Jint.Runtime.Interpreter.Expressions
             return left._type != InternalTypes.BigInt && right._type != InternalTypes.BigInt;
         }
 
-        internal static void AssertValidBigIntArithmeticOperands(EvaluationContext context, JsValue left, JsValue right)
+        internal static void AssertValidBigIntArithmeticOperands(JsValue left, JsValue right)
         {
             if (left.Type != right.Type)
             {
-                ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Cannot mix BigInt and other types, use explicit conversions");
+                ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions");
             }
         }
 
         private sealed class StrictlyEqualBinaryExpression : JintBinaryExpression
         {
-            public StrictlyEqualBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public StrictlyEqualBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -192,7 +204,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class StrictlyNotEqualBinaryExpression : JintBinaryExpression
         {
-            public StrictlyNotEqualBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public StrictlyNotEqualBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -206,7 +218,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class LessBinaryExpression : JintBinaryExpression
         {
-            public LessBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public LessBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -229,7 +241,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class GreaterBinaryExpression : JintBinaryExpression
         {
-            public GreaterBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public GreaterBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -252,7 +264,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class PlusBinaryExpression : JintBinaryExpression
         {
-            public PlusBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public PlusBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -285,7 +297,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 }
                 else
                 {
-                    AssertValidBigIntArithmeticOperands(context, lprim, rprim);
+                    AssertValidBigIntArithmeticOperands(lprim, rprim);
                     result = JsBigInt.Create(TypeConverter.ToBigInt(lprim) + TypeConverter.ToBigInt(rprim));
                 }
 
@@ -295,7 +307,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class MinusBinaryExpression : JintBinaryExpression
         {
-            public MinusBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public MinusBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -333,7 +345,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class TimesBinaryExpression : JintBinaryExpression
         {
-            public TimesBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public TimesBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -363,7 +375,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                     }
                     else
                     {
-                        AssertValidBigIntArithmeticOperands(context, leftNumeric, rightNumeric);
+                        AssertValidBigIntArithmeticOperands(leftNumeric, rightNumeric);
                         result = JsBigInt.Create(leftNumeric.AsBigInt() * rightNumeric.AsBigInt());
                     }
                 }
@@ -374,7 +386,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class DivideBinaryExpression : JintBinaryExpression
         {
-            public DivideBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public DivideBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -399,7 +411,7 @@ namespace Jint.Runtime.Interpreter.Expressions
         {
             private readonly bool _invert;
 
-            public EqualBinaryExpression(Engine engine, BinaryExpression expression, bool invert = false) : base(engine, expression)
+            public EqualBinaryExpression(BinaryExpression expression, bool invert = false) : base(expression)
             {
                 _invert = invert;
             }
@@ -428,7 +440,7 @@ namespace Jint.Runtime.Interpreter.Expressions
         {
             private readonly bool _leftFirst;
 
-            public CompareBinaryExpression(Engine engine, BinaryExpression expression, bool leftFirst) : base(engine, expression)
+            public CompareBinaryExpression(BinaryExpression expression, bool leftFirst) : base(expression)
             {
                 _leftFirst = leftFirst;
             }
@@ -454,7 +466,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class InstanceOfBinaryExpression : JintBinaryExpression
         {
-            public InstanceOfBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public InstanceOfBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -468,7 +480,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class ExponentiationBinaryExpression : JintBinaryExpression
         {
-            public ExponentiationBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public ExponentiationBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -572,7 +584,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 }
                 else
                 {
-                    AssertValidBigIntArithmeticOperands(context, left, right);
+                    AssertValidBigIntArithmeticOperands(left, right);
 
                     var exponent = right.AsBigInt();
                     if (exponent < 0)
@@ -593,7 +605,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class InBinaryExpression : JintBinaryExpression
         {
-            public InBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public InBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -614,7 +626,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         private sealed class ModuloBinaryExpression : JintBinaryExpression
         {
-            public ModuloBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public ModuloBinaryExpression(BinaryExpression expression) : base(expression)
             {
             }
 
@@ -683,7 +695,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 }
                 else
                 {
-                    AssertValidBigIntArithmeticOperands(context, left, right);
+                    AssertValidBigIntArithmeticOperands(left, right);
 
                     var n = TypeConverter.ToBigInt(left);
                     var d = TypeConverter.ToBigInt(right);
@@ -727,7 +739,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
             private readonly BinaryOperator _operator;
 
-            public BitwiseBinaryExpression(Engine engine, BinaryExpression expression) : base(engine, expression)
+            public BitwiseBinaryExpression(BinaryExpression expression) : base(expression)
             {
                 _operator = expression.Operator;
             }
@@ -748,7 +760,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
                 if (lnum.Type != rnum.Type)
                 {
-                    ExceptionHelper.ThrowTypeError(context.Engine.Realm);
+                    ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions", _left._expression);
                 }
 
                 if (AreIntegerOperands(lnum, rnum))
@@ -785,10 +797,10 @@ namespace Jint.Runtime.Interpreter.Expressions
                     return result;
                 }
 
-                return EvaluateNonInteger(context.Engine.Realm, lnum, rnum);
+                return EvaluateNonInteger(lnum, rnum);
             }
 
-            private JsValue EvaluateNonInteger(Realm realm, JsValue left, JsValue right)
+            private JsValue EvaluateNonInteger(JsValue left, JsValue right)
             {
                 switch (_operator)
                 {
@@ -844,7 +856,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                         {
                             return JsNumber.Create((uint) TypeConverter.ToInt32(left) >> (int) (TypeConverter.ToUint32(right) & 0x1F));
                         }
-                        ExceptionHelper.ThrowTypeError(realm);
+                        ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions", _left._expression);
                         return null;
                     }
 

Jint/Runtime/Interpreter/Expressions/JintCallExpression.cs

@@ -29,7 +29,7 @@ namespace Jint.Runtime.Interpreter.Expressions
             var expression = (CallExpression) _expression;
             ref readonly var expressionArguments = ref expression.Arguments;
 
-            _calleeExpression = Build(engine, expression.Callee);
+            _calleeExpression = Build(expression.Callee);
             var cachedArgumentsHolder = new CachedArgumentsHolder
             {
                 JintArguments = new JintExpression[expressionArguments.Count]
@@ -44,7 +44,7 @@ namespace Jint.Runtime.Interpreter.Expressions
             for (var i = 0; i < expressionArguments.Count; i++)
             {
                 var expressionArgument = expressionArguments[i];
-                cachedArgumentsHolder.JintArguments[i] = Build(engine, expressionArgument);
+                cachedArgumentsHolder.JintArguments[i] = Build(expressionArgument);
                 cacheable &= expressionArgument.Type == Nodes.Literal;
                 _hasSpreads |= CanSpread(expressionArgument);
                 if (expressionArgument is ArrayExpression ae)

Jint/Runtime/Interpreter/Expressions/JintConditionalExpression.cs

@@ -8,11 +8,11 @@ namespace Jint.Runtime.Interpreter.Expressions
         private readonly JintExpression _consequent;
         private readonly JintExpression _alternate;
 
-        public JintConditionalExpression(Engine engine, ConditionalExpression expression) : base(expression)
+        public JintConditionalExpression(ConditionalExpression expression) : base(expression)
         {
-            _test = Build(engine, expression.Test);
-            _consequent = Build(engine, expression.Consequent);
-            _alternate = Build(engine, expression.Alternate);
+            _test = Build(expression.Test);
+            _consequent = Build(expression.Consequent);
+            _alternate = Build(expression.Alternate);
         }
 
         protected override object EvaluateInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintExpression.cs

@@ -101,24 +101,24 @@ namespace Jint.Runtime.Interpreter.Expressions
             }
         }
 
-        protected internal static JintExpression Build(Engine engine, Expression expression)
+        protected internal static JintExpression Build(Expression expression)
         {
             var result = expression.Type switch
             {
-                Nodes.AssignmentExpression => JintAssignmentExpression.Build(engine, (AssignmentExpression) expression),
+                Nodes.AssignmentExpression => JintAssignmentExpression.Build((AssignmentExpression) expression),
                 Nodes.ArrayExpression => new JintArrayExpression((ArrayExpression) expression),
-                Nodes.ArrowFunctionExpression => new JintArrowFunctionExpression(engine, (ArrowFunctionExpression) expression),
-                Nodes.BinaryExpression => JintBinaryExpression.Build(engine, (BinaryExpression) expression),
+                Nodes.ArrowFunctionExpression => new JintArrowFunctionExpression((ArrowFunctionExpression) expression),
+                Nodes.BinaryExpression => JintBinaryExpression.Build((BinaryExpression) expression),
                 Nodes.CallExpression => new JintCallExpression((CallExpression) expression),
-                Nodes.ConditionalExpression => new JintConditionalExpression(engine, (ConditionalExpression) expression),
+                Nodes.ConditionalExpression => new JintConditionalExpression((ConditionalExpression) expression),
                 Nodes.FunctionExpression => new JintFunctionExpression((FunctionExpression) expression),
                 Nodes.Identifier => new JintIdentifierExpression((Identifier) expression),
                 Nodes.Literal => JintLiteralExpression.Build((Literal) expression),
                 Nodes.LogicalExpression => ((BinaryExpression) expression).Operator switch
                 {
                     BinaryOperator.LogicalAnd => new JintLogicalAndExpression((BinaryExpression) expression),
-                    BinaryOperator.LogicalOr => new JintLogicalOrExpression(engine, (BinaryExpression) expression),
-                    BinaryOperator.NullishCoalescing => new NullishCoalescingExpression(engine, (BinaryExpression) expression),
+                    BinaryOperator.LogicalOr => new JintLogicalOrExpression((BinaryExpression) expression),
+                    BinaryOperator.NullishCoalescing => new NullishCoalescingExpression((BinaryExpression) expression),
                     _ => null
                 },
                 Nodes.MemberExpression => new JintMemberExpression((MemberExpression) expression),
@@ -127,8 +127,8 @@ namespace Jint.Runtime.Interpreter.Expressions
                 Nodes.SequenceExpression => new JintSequenceExpression((SequenceExpression) expression),
                 Nodes.ThisExpression => new JintThisExpression((ThisExpression) expression),
                 Nodes.UpdateExpression => new JintUpdateExpression((UpdateExpression) expression),
-                Nodes.UnaryExpression => JintUnaryExpression.Build(engine, (UnaryExpression) expression),
-                Nodes.SpreadElement => new JintSpreadExpression(engine, (SpreadElement) expression),
+                Nodes.UnaryExpression => JintUnaryExpression.Build((UnaryExpression) expression),
+                Nodes.SpreadElement => new JintSpreadExpression((SpreadElement) expression),
                 Nodes.TemplateLiteral => new JintTemplateLiteralExpression((TemplateLiteral) expression),
                 Nodes.TaggedTemplateExpression => new JintTaggedTemplateExpression((TaggedTemplateExpression) expression),
                 Nodes.ClassExpression => new JintClassExpression((ClassExpression) expression),
@@ -163,7 +163,7 @@ namespace Jint.Runtime.Interpreter.Expressions
             }
             else
             {
-                JintBinaryExpression.AssertValidBigIntArithmeticOperands(context, left, right);
+                JintBinaryExpression.AssertValidBigIntArithmeticOperands(left, right);
                 var x = TypeConverter.ToBigInt(left);
                 var y = TypeConverter.ToBigInt(right);
 

Jint/Runtime/Interpreter/Expressions/JintImportExpression.cs

@@ -16,7 +16,7 @@ internal sealed class JintImportExpression : JintExpression
     protected override void Initialize(EvaluationContext context)
     {
         var expression = ((Import) _expression).Source;
-        _importExpression = Build(context.Engine, expression);
+        _importExpression = Build(expression);
     }
 
     /// <summary>

Jint/Runtime/Interpreter/Expressions/JintLogicalAndExpression.cs

@@ -16,8 +16,8 @@ namespace Jint.Runtime.Interpreter.Expressions
         protected override void Initialize(EvaluationContext context)
         {
             var expression = (BinaryExpression) _expression;
-            _left = Build(context.Engine, expression.Left);
-            _right = Build(context.Engine, expression.Right);
+            _left = Build(expression.Left);
+            _right = Build(expression.Right);
         }
 
         protected override object EvaluateInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintLogicalOrExpression.cs

@@ -8,10 +8,10 @@ namespace Jint.Runtime.Interpreter.Expressions
         private readonly JintExpression _left;
         private readonly JintExpression _right;
 
-        public JintLogicalOrExpression(Engine engine, BinaryExpression expression) : base(expression)
+        public JintLogicalOrExpression(BinaryExpression expression) : base(expression)
         {
-            _left = Build(engine, expression.Left);
-            _right = Build(engine, expression.Right);
+            _left = Build(expression.Left);
+            _right = Build(expression.Right);
         }
 
         protected override object EvaluateInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintMemberExpression.cs

@@ -23,7 +23,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         protected override void Initialize(EvaluationContext context)
         {
-            _objectExpression = Build(context.Engine, _memberExpression.Object);
+            _objectExpression = Build(_memberExpression.Object);
 
             if (!_memberExpression.Computed)
             {
@@ -36,7 +36,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
             if (_determinedProperty is null)
             {
-                _propertyExpression = Build(context.Engine, _memberExpression.Property);
+                _propertyExpression = Build(_memberExpression.Property);
             }
         }
 

Jint/Runtime/Interpreter/Expressions/JintNewExpression.cs

@@ -16,10 +16,8 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         protected override void Initialize(EvaluationContext context)
         {
-            var engine = context.Engine;
-
             var expression = (NewExpression) _expression;
-            _calleeExpression = Build(engine, expression.Callee);
+            _calleeExpression = Build(expression.Callee);
 
             if (expression.Arguments.Count <= 0)
             {
@@ -30,7 +28,7 @@ namespace Jint.Runtime.Interpreter.Expressions
             for (var i = 0; i < _jintArguments.Length; i++)
             {
                 var argument = expression.Arguments[i];
-                _jintArguments[i] = Build(engine, argument);
+                _jintArguments[i] = Build(argument);
                 _hasSpreads |= argument.Type == Nodes.SpreadElement;
             }
         }

Jint/Runtime/Interpreter/Expressions/JintObjectExpression.cs

@@ -93,7 +93,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                     if (p.Kind is PropertyKind.Init)
                     {
                         var propertyValue = p.Value;
-                        _valueExpressions[i] = Build(engine, (Expression) propertyValue);
+                        _valueExpressions[i] = Build((Expression) propertyValue);
                         _canBuildFast &= !propertyValue.IsFunctionDefinition();
                     }
                     else
@@ -105,7 +105,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 {
                     _canBuildFast = false;
                     _properties[i] = null;
-                    _valueExpressions[i] = Build(engine, spreadElement.Argument);
+                    _valueExpressions[i] = Build(spreadElement.Argument);
                 }
                 else
                 {

Jint/Runtime/Interpreter/Expressions/JintSequenceExpression.cs

@@ -14,13 +14,12 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         protected override void Initialize(EvaluationContext context)
         {
-            var engine = context.Engine;
             var expression = (SequenceExpression) _expression;
             ref readonly var expressions = ref expression.Expressions;
             var temp = new JintExpression[expressions.Count];
             for (var i = 0; i < (uint) temp.Length; i++)
             {
-                temp[i] = Build(engine, expressions[i]);
+                temp[i] = Build(expressions[i]);
             }
 
             _expressions = temp;

Jint/Runtime/Interpreter/Expressions/JintSpreadExpression.cs

@@ -9,9 +9,9 @@ namespace Jint.Runtime.Interpreter.Expressions
         private readonly JintExpression _argument;
         private readonly string? _argumentName;
 
-        public JintSpreadExpression(Engine engine, SpreadElement expression) : base(expression)
+        public JintSpreadExpression(SpreadElement expression) : base(expression)
         {
-            _argument = Build(engine, expression.Argument);
+            _argument = Build(expression.Argument);
             _argumentName = (expression.Argument as Identifier)?.Name;
         }
 

Jint/Runtime/Interpreter/Expressions/JintTaggedTemplateExpression.cs

@@ -21,10 +21,9 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         protected override void Initialize(EvaluationContext context)
         {
-            var engine = context.Engine;
-            _tagIdentifier = Build(engine, _taggedTemplateExpression.Tag);
+            _tagIdentifier = Build(_taggedTemplateExpression.Tag);
             _quasi = new JintTemplateLiteralExpression(_taggedTemplateExpression.Quasi);
-            _quasi.DoInitialize(context);
+            _quasi.DoInitialize();
         }
 
         protected override object EvaluateInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintTemplateLiteralExpression.cs

@@ -17,17 +17,16 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         protected override void Initialize(EvaluationContext context)
         {
-            DoInitialize(context);
+            DoInitialize();
         }
 
-        internal void DoInitialize(EvaluationContext context)
+        internal void DoInitialize()
         {
-            var engine = context.Engine;
             _expressions = new JintExpression[_templateLiteralExpression.Expressions.Count];
             for (var i = 0; i < _templateLiteralExpression.Expressions.Count; i++)
             {
                 var exp = _templateLiteralExpression.Expressions[i];
-                _expressions[i] = Build(engine, exp);
+                _expressions[i] = Build(exp);
             }
 
             _initialized = true;

Jint/Runtime/Interpreter/Expressions/JintUnaryExpression.cs

@@ -19,26 +19,33 @@ namespace Jint.Runtime.Interpreter.Expressions
         private readonly JintExpression _argument;
         private readonly UnaryOperator _operator;
 
-        private JintUnaryExpression(Engine engine, UnaryExpression expression) : base(expression)
+        private JintUnaryExpression(UnaryExpression expression) : base(expression)
         {
-            _argument = Build(engine, expression.Argument);
+            _argument = Build(expression.Argument);
             _operator = expression.Operator;
         }
 
-        internal static JintExpression Build(Engine engine, UnaryExpression expression)
+        internal static JintExpression Build(UnaryExpression expression)
         {
+            if (expression.AssociatedData is JsValue cached)
+            {
+                return new JintConstantExpression(expression, cached);
+            }
+
             if (expression.Operator == UnaryOperator.Minus
                 && expression.Argument is Literal literal)
             {
                 var value = JintLiteralExpression.ConvertToJsValue(literal);
-                if (!(value is null))
+                if (value is not null)
                 {
                     // valid for caching
-                    return new JintConstantExpression(expression, EvaluateMinus(value));
+                    var evaluatedValue = EvaluateMinus(value);
+                    expression.AssociatedData = evaluatedValue;
+                    return new JintConstantExpression(expression, evaluatedValue);
                 }
             }
 
-            return new JintUnaryExpression(engine, expression);
+            return new JintUnaryExpression(expression);
         }
 
         public override JsValue GetValue(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintUpdateExpression.cs

@@ -23,7 +23,7 @@ namespace Jint.Runtime.Interpreter.Expressions
         {
             var expression = (UpdateExpression) _expression;
             _prefix = expression.Prefix;
-            _argument = Build(context.Engine, expression.Argument);
+            _argument = Build(expression.Argument);
             if (expression.Operator == UnaryOperator.Increment)
             {
                 _change = 1;

Jint/Runtime/Interpreter/Expressions/NullishCoalescingExpression.cs

@@ -10,9 +10,9 @@ namespace Jint.Runtime.Interpreter.Expressions
         private readonly JintExpression? _right;
         private readonly JsValue? _constant;
 
-        public NullishCoalescingExpression(Engine engine, BinaryExpression expression) : base(expression)
+        public NullishCoalescingExpression(BinaryExpression expression) : base(expression)
         {
-            _left = Build(engine, expression.Left);
+            _left = Build(expression.Left);
 
             // we can create a fast path for common literal case like variable ?? 0
             if (expression.Right is Literal l)
@@ -21,7 +21,7 @@ namespace Jint.Runtime.Interpreter.Expressions
             }
             else
             {
-                _right = Build(engine, expression.Right);
+                _right = Build(expression.Right);
             }
         }
 

Jint/Runtime/Interpreter/JintFunctionDefinition.cs

@@ -38,7 +38,7 @@ internal sealed class JintFunctionDefinition
         if (Function.Expression)
         {
             // https://tc39.es/ecma262/#sec-runtime-semantics-evaluateconcisebody
-            _bodyExpression ??= JintExpression.Build(context.Engine, (Expression) Function.Body);
+            _bodyExpression ??= JintExpression.Build((Expression) Function.Body);
             var jsValue = _bodyExpression.GetValue(context).Clone();
             result = new Completion(CompletionType.Return, jsValue, Function.Body);
         }

Jint/Runtime/Interpreter/JintStatementList.cs

@@ -126,21 +126,22 @@ namespace Jint.Runtime.Interpreter
             }
             if (exception is TypeErrorException typeErrorException)
             {
-                return CreateThrowCompletion(context.Engine.Realm.Intrinsics.TypeError, typeErrorException, s!);
+                var node = typeErrorException.Node ?? s!._statement;
+                return CreateThrowCompletion(context.Engine.Realm.Intrinsics.TypeError, typeErrorException, node);
             }
             if (exception is RangeErrorException rangeErrorException)
             {
-                return CreateThrowCompletion(context.Engine.Realm.Intrinsics.RangeError, rangeErrorException, s!);
+                return CreateThrowCompletion(context.Engine.Realm.Intrinsics.RangeError, rangeErrorException, s!._statement);
             }
 
             // should not happen unless there's problem in the engine
             throw exception;
         }
 
-        private static Completion CreateThrowCompletion(ErrorConstructor errorConstructor, Exception e, JintStatement s)
+        private static Completion CreateThrowCompletion(ErrorConstructor errorConstructor, Exception e, SyntaxElement s)
         {
             var error = errorConstructor.Construct(new JsValue[] { e.Message });
-            return new Completion(CompletionType.Throw, error, s._statement);
+            return new Completion(CompletionType.Throw, error, s);
         }
 
         private static Completion CreateThrowCompletion(JintStatement? s, JavaScriptException v)

Jint/Runtime/Interpreter/Statements/JintDoWhileStatement.cs

@@ -20,7 +20,7 @@ namespace Jint.Runtime.Interpreter.Statements
         protected override void Initialize(EvaluationContext context)
         {
             _body = new ProbablyBlockStatement(_statement.Body);
-            _test = JintExpression.Build(context.Engine, _statement.Test);
+            _test = JintExpression.Build(_statement.Test);
             _labelSetName = _statement.LabelSet?.Name;
         }
 

Jint/Runtime/Interpreter/Statements/JintExportDefaultDeclaration.cs

@@ -30,11 +30,11 @@ internal sealed class JintExportDefaultDeclaration : JintStatement<ExportDefault
         }
         else if (_statement.Declaration is AssignmentExpression assignmentExpression)
         {
-            _assignmentExpression = JintAssignmentExpression.Build(context.Engine, assignmentExpression);
+            _assignmentExpression = JintAssignmentExpression.Build(assignmentExpression);
         }
         else
         {
-            _simpleExpression = JintExpression.Build(context.Engine, (Expression) _statement.Declaration);
+            _simpleExpression = JintExpression.Build((Expression) _statement.Declaration);
         }
     }
 

Jint/Runtime/Interpreter/Statements/JintExpressionStatement.cs

@@ -13,7 +13,7 @@ internal sealed class JintExpressionStatement : JintStatement<ExpressionStatemen
 
     protected override void Initialize(EvaluationContext context)
     {
-        _expression = JintExpression.Build(context.Engine, _statement.Expression);
+        _expression = JintExpression.Build(_statement.Expression);
     }
 
     protected override Completion ExecuteInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Statements/JintForInForOfStatement.cs

@@ -88,7 +88,7 @@ namespace Jint.Runtime.Interpreter.Statements
             }
 
             _body = new ProbablyBlockStatement(_forBody);
-            _right = JintExpression.Build(engine, _rightExpression);
+            _right = JintExpression.Build(_rightExpression);
         }
 
         protected override Completion ExecuteInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Statements/JintForStatement.cs

@@ -45,18 +45,18 @@ namespace Jint.Runtime.Interpreter.Statements
                 }
                 else
                 {
-                    _initExpression = JintExpression.Build(engine, (Expression) _statement.Init);
+                    _initExpression = JintExpression.Build((Expression) _statement.Init);
                 }
             }
 
             if (_statement.Test != null)
             {
-                _test = JintExpression.Build(engine, _statement.Test);
+                _test = JintExpression.Build(_statement.Test);
             }
 
             if (_statement.Update != null)
             {
-                _increment = JintExpression.Build(engine, _statement.Update);
+                _increment = JintExpression.Build(_statement.Update);
             }
         }
 

Jint/Runtime/Interpreter/Statements/JintIfStatement.cs

@@ -16,7 +16,7 @@ namespace Jint.Runtime.Interpreter.Statements
         protected override void Initialize(EvaluationContext context)
         {
             _statementConsequent = new ProbablyBlockStatement(_statement.Consequent);
-            _test = JintExpression.Build(context.Engine, _statement.Test);
+            _test = JintExpression.Build(_statement.Test);
             _alternate = _statement.Alternate != null ? new ProbablyBlockStatement(_statement.Alternate) : null;
         }
 

Jint/Runtime/Interpreter/Statements/JintReturnStatement.cs

@@ -18,7 +18,7 @@ internal sealed class JintReturnStatement : JintStatement<ReturnStatement>
     protected override void Initialize(EvaluationContext context)
     {
         _argument = _statement.Argument != null
-            ? JintExpression.Build(context.Engine, _statement.Argument)
+            ? JintExpression.Build(_statement.Argument)
             : null;
     }
 

Jint/Runtime/Interpreter/Statements/JintSwitchBlock.cs

@@ -128,7 +128,7 @@ namespace Jint.Runtime.Interpreter.Statements
 
                 if (switchCase.Test != null)
                 {
-                    Test = JintExpression.Build(engine, switchCase.Test);
+                    Test = JintExpression.Build(switchCase.Test);
                 }
             }
         }

Jint/Runtime/Interpreter/Statements/JintSwitchStatement.cs

@@ -17,9 +17,8 @@ namespace Jint.Runtime.Interpreter.Statements
 
         protected override void Initialize(EvaluationContext context)
         {
-            var engine = context.Engine;
             _switchBlock = new JintSwitchBlock(_statement.Cases);
-            _discriminant = JintExpression.Build(engine, _statement.Discriminant);
+            _discriminant = JintExpression.Build(_statement.Discriminant);
         }
 
         protected override Completion ExecuteInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Statements/JintThrowStatement.cs

@@ -16,7 +16,7 @@ namespace Jint.Runtime.Interpreter.Statements
 
         protected override void Initialize(EvaluationContext context)
         {
-            _argument = JintExpression.Build(context.Engine, _statement.Argument);
+            _argument = JintExpression.Build(_statement.Argument);
         }
 
         protected override Completion ExecuteInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Statements/JintVariableDeclaration.cs

@@ -41,12 +41,12 @@ namespace Jint.Runtime.Interpreter.Statements
                 }
                 else
                 {
-                    left = JintExpression.Build(engine, (Identifier) declaration.Id);
+                    left = JintExpression.Build((Identifier) declaration.Id);
                 }
 
                 if (declaration.Init != null)
                 {
-                    init = JintExpression.Build(engine, declaration.Init);
+                    init = JintExpression.Build(declaration.Init);
                 }
 
                 var leftIdentifier = left as JintIdentifierExpression;

Jint/Runtime/Interpreter/Statements/JintWhileStatement.cs

@@ -21,7 +21,7 @@ namespace Jint.Runtime.Interpreter.Statements
         {
             _labelSetName = _statement.LabelSet?.Name;
             _body = new ProbablyBlockStatement(_statement.Body);
-            _test = JintExpression.Build(context.Engine, _statement.Test);
+            _test = JintExpression.Build(_statement.Test);
         }
 
         protected override Completion ExecuteInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Statements/JintWithStatement.cs

@@ -19,7 +19,7 @@ namespace Jint.Runtime.Interpreter.Statements
         protected override void Initialize(EvaluationContext context)
         {
             _body = new ProbablyBlockStatement(_statement.Body);
-            _object = JintExpression.Build(context.Engine, _statement.Object);
+            _object = JintExpression.Build(_statement.Object);
         }
 
         protected override Completion ExecuteInternal(EvaluationContext context)

Jint/Runtime/TypeErrorException.cs

@@ -1,3 +1,5 @@
+using Esprima.Ast;
+
 namespace Jint.Runtime
 {
     /// <summary>
@@ -5,8 +7,11 @@ namespace Jint.Runtime
     /// </summary>
     internal sealed class TypeErrorException : JintException
     {
-        public TypeErrorException(string? message) : base(message)
+        public TypeErrorException(string? message, Node? node) : base(message)
         {
+            Node = node;
         }
+
+        public Node? Node { get; }
     }
 }