Upgrade to Esprima 3.0.0-beta-7 (#1289)

Jint.Benchmark/DromaeoBenchmark.cs

@@ -1,11 +1,12 @@
 using BenchmarkDotNet.Attributes;
+using Esprima.Ast;
 
 namespace Jint.Benchmark;
 
 [MemoryDiagnoser]
 public class DromaeoBenchmark
 {
-    public static readonly Dictionary<string, string> files = new Dictionary<string, string>
+    private static readonly Dictionary<string, string> _files = new()
     {
         {"dromaeo-3d-cube", null},
         {"dromaeo-core-eval", null},
@@ -15,14 +16,18 @@ public class DromaeoBenchmark
         {"dromaeo-string-base64", null}
     };
 
+    private Dictionary<string, Script> _prepared = new();
+
     private Engine engine;
 
     [GlobalSetup]
     public void Setup()
     {
-        foreach (var fileName in files.Keys.ToList())
+        foreach (var fileName in _files.Keys)
         {
-            files[fileName] = File.ReadAllText($"Scripts/{fileName}.js");
+            var script = File.ReadAllText($"Scripts/{fileName}.js");
+            _files[fileName] = script;
+            _prepared[fileName] = Engine.PrepareScript(script);
         }
 
         engine = new Engine()
@@ -40,9 +45,12 @@ var prep = function (fn) { fn(); };
     [ParamsSource(nameof(FileNames))]
     public string FileName { get; set; }
 
+    [Params(true, false)]
+    public bool Prepared { get; set; }
+
     public IEnumerable<string> FileNames()
     {
-        foreach (var entry in files)
+        foreach (var entry in _files)
         {
             yield return entry.Key;
         }
@@ -51,6 +59,13 @@ var prep = function (fn) { fn(); };
     [Benchmark]
     public void Run()
     {
-        engine.Execute(files[FileName]);
+        if (Prepared)
+        {
+            engine.Execute(_prepared[FileName]);
+        }
+        else
+        {
+            engine.Execute(_files[FileName]);
+        }
     }
 }

Jint.Benchmark/SingleScriptBenchmark.cs

@@ -1,5 +1,4 @@
 using BenchmarkDotNet.Attributes;
-using Esprima;
 using Esprima.Ast;
 
 namespace Jint.Benchmark;
@@ -16,7 +15,7 @@ public abstract class SingleScriptBenchmark
     public void Setup()
     {
         _script = File.ReadAllText($"Scripts/{FileName}");
-        _parsedScript = new JavaScriptParser().ParseScript(_script);
+        _parsedScript = Engine.PrepareScript(_script);
     }
 
     [Benchmark]

Jint.Tests.Test262/TestHarness.cs

@@ -1,5 +1,3 @@
-using Esprima;
-
 namespace Jint.Tests.Test262;
 
 /// <summary>
@@ -12,7 +10,8 @@ public partial class TestHarness
         foreach (var file in State.HarnessFiles)
         {
             var source = file.Program;
-            State.Sources[Path.GetFileName(file.FileName)] = new JavaScriptParser().ParseScript(source, source: file.FileName);
+            var script = Engine.PrepareScript(source, source: file.FileName);
+            State.Sources[Path.GetFileName(file.FileName)] = script;
         }
 
         return Task.CompletedTask;

Jint.Tests/Runtime/EngineTests.cs

@@ -1050,7 +1050,7 @@ namespace Jint.Tests.Runtime
             {
                 Assert.Equal(1, e.LineNumber);
                 Assert.Equal(9, e.Column);
-                Assert.Equal("jQuery.js", e.SourceText);
+                Assert.Equal("jQuery.js", e.SourceLocation);
             }
         }
         #region DateParsingAndStrings

Jint/Engine.Ast.cs

@@ -0,0 +1,58 @@
+using Esprima;
+using Esprima.Ast;
+using Jint.Runtime.Environments;
+using Jint.Runtime.Interpreter;
+using Jint.Runtime.Interpreter.Expressions;
+
+namespace Jint;
+
+public partial class Engine
+{
+
+    /// <summary>
+    /// Prepares a script for the engine that includes static analysis data to speed up execution during run-time.
+    /// </summary>
+    /// <remarks>
+    /// Returned instance is reusable and thread-safe. You should prepare scripts only once and then reuse them.
+    /// </remarks>
+    public static Script PrepareScript(string script, string? source = null)
+    {
+        var astAnalyzer = new AstAnalyzer();
+        var options = ParserOptions.Default with { OnNodeCreated = astAnalyzer.NodeVisitor };
+
+        return new JavaScriptParser(options).ParseScript(script, source);
+    }
+
+    private sealed class AstAnalyzer
+    {
+        private readonly Dictionary<string, EnvironmentRecord.BindingName> _bindingNames = new();
+
+        public void NodeVisitor(Node node)
+        {
+            switch (node.Type)
+            {
+                case Nodes.Identifier:
+                    {
+                        var name = ((Identifier) node).Name;
+
+                        if (!_bindingNames.TryGetValue(name, out var bindingName))
+                        {
+                            _bindingNames[name] = bindingName = new EnvironmentRecord.BindingName(name);
+                        }
+
+                        node.AssociatedData = bindingName;
+                        break;
+                    }
+                case Nodes.Literal:
+                    node.AssociatedData = JintLiteralExpression.ConvertToJsValue((Literal) node);
+                    break;
+                case Nodes.ArrowFunctionExpression:
+                case Nodes.FunctionDeclaration:
+                case Nodes.FunctionExpression:
+                    var function = (IFunction) node;
+                    node.AssociatedData = JintFunctionDefinition.BuildState(function);
+                    break;
+            }
+        }
+    }
+}

Jint/Engine.cs

@@ -832,7 +832,7 @@ namespace Jint
                         }
 
                         declaredFunctionNames.Add(fn);
-                        functionToInitialize.AddFirst(new JintFunctionDefinition(this, d));
+                        functionToInitialize.AddFirst(new JintFunctionDefinition(d));
                     }
                 }
             }
@@ -931,7 +931,7 @@ namespace Jint
             var env = (FunctionEnvironmentRecord) ExecutionContext.LexicalEnvironment;
             var strict = _isStrict || StrictModeScope.IsStrictModeCode;
 
-            var configuration = func.Initialize(functionInstance);
+            var configuration = func.Initialize();
             var parameterNames = configuration.ParameterNames;
             var hasDuplicates = configuration.HasDuplicates;
             var simpleParameterList = configuration.IsSimpleParameterList;
@@ -942,7 +942,7 @@ namespace Jint
             env.InitializeParameters(parameterNames, hasDuplicates, arguments);
 
             ArgumentsInstance? ao = null;
-            if (configuration.ArgumentsObjectNeeded)
+            if (configuration.ArgumentsObjectNeeded || _isDebugMode)
             {
                 if (strict || !simpleParameterList)
                 {
@@ -1153,7 +1153,7 @@ namespace Jint
                         }
 
                         declaredFunctionNames.Add(fn);
-                        functionsToInitialize.AddFirst(new JintFunctionDefinition(this, d));
+                        functionsToInitialize.AddFirst(new JintFunctionDefinition(d));
                     }
                 }
             }

Jint/EsprimaExtensions.cs

@@ -288,7 +288,7 @@ namespace Jint
                 ExceptionHelper.ThrowSyntaxError(engine.Realm);
             }
 
-            var definition = new JintFunctionDefinition(engine, function);
+            var definition = new JintFunctionDefinition(function);
             var closure = intrinsics.Function.OrdinaryFunctionCreate(prototype, definition, definition.ThisMode, scope, privateScope);
             closure.MakeMethod(obj);
 

Jint/HoistingScope.cs

@@ -3,7 +3,7 @@ using Jint.Runtime.Modules;
 
 namespace Jint
 {
-    internal readonly struct HoistingScope
+    internal sealed class HoistingScope
     {
         internal readonly List<FunctionDeclaration>? _functionDeclarations;
 
@@ -14,7 +14,8 @@ namespace Jint
         internal readonly List<string>? _lexicalNames;
         internal readonly bool _hasArgumentsReference;
 
-        private HoistingScope(List<FunctionDeclaration>? functionDeclarations,
+        private HoistingScope(
+            List<FunctionDeclaration>? functionDeclarations,
             List<Key>? varNames,
             List<VariableDeclaration>? variableDeclarations,
             List<Declaration>? lexicalDeclarations,
@@ -46,17 +47,12 @@ namespace Jint
                 false);
         }
 
-        public static HoistingScope GetFunctionLevelDeclarations(
-            bool strict,
-            IFunction node,
-            bool collectVarNames = false,
-            bool collectLexicalNames = false,
-            bool checkArgumentsReference = false)
+        public static HoistingScope GetFunctionLevelDeclarations(bool strict, IFunction node)
         {
-            var treeWalker = new ScriptWalker(strict, collectVarNames, collectLexicalNames, checkArgumentsReference);
+            var treeWalker = new ScriptWalker(strict, collectVarNames: true, collectLexicalNames: true, checkArgumentsReference: true);
             treeWalker.Visit(node.Body, null);
 
-            if (checkArgumentsReference && !treeWalker._hasArgumentsReference)
+            if (!treeWalker._hasArgumentsReference)
             {
                 ref readonly var parameters = ref node.Params;
                 for (var i = 0; i < parameters.Count; ++i)

Jint/Jint.csproj

@@ -11,7 +11,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Esprima" Version="3.0.0-beta-6" />
+    <PackageReference Include="Esprima" Version="3.0.0-beta-7" />
     <PackageReference Include="IsExternalInit" Version="1.0.2" PrivateAssets="all" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="all" />
     <PackageReference Include="Nullable" Version="1.3.0" PrivateAssets="all" />

Jint/Native/Function/FunctionConstructor.cs

@@ -187,7 +187,7 @@ namespace Jint.Native.Function
             var scope = realmF.GlobalEnv;
             PrivateEnvironmentRecord? privateScope = null;
 
-            var definition = new JintFunctionDefinition(_engine, function);
+            var definition = new JintFunctionDefinition(function);
             FunctionInstance F = OrdinaryFunctionCreate(proto, definition, function.Strict ? FunctionThisMode.Strict : FunctionThisMode.Global, scope, privateScope);
             F.SetFunctionName(_functionNameAnonymous, force: true);
 

Jint/Native/Function/FunctionInstance.cs

@@ -30,7 +30,7 @@ namespace Jint.Native.Function
             Engine engine,
             Realm realm,
             JsString? name)
-            : this(engine, realm, name, FunctionThisMode.Global, ObjectClass.Function)
+            : this(engine, realm, name, FunctionThisMode.Global)
         {
         }
 

Jint/Native/Function/ScriptFunctionInstance.cs

@@ -23,7 +23,7 @@ namespace Jint.Native.Function
             ObjectInstance? proto = null)
             : this(
                 engine,
-                new JintFunctionDefinition(engine, functionDeclaration),
+                new JintFunctionDefinition(functionDeclaration),
                 scope,
                 strict ? FunctionThisMode.Strict : FunctionThisMode.Global,
                 proto)
@@ -39,7 +39,7 @@ namespace Jint.Native.Function
             : 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);
+            _length = new LazyPropertyDescriptor(null, _ => JsNumber.Create(function.Initialize().Length), PropertyFlag.Configurable);
 
             if (!function.Strict
                 && !engine._isStrict

Jint/Native/JsNumber.cs

@@ -93,7 +93,7 @@ namespace Jint.Native
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static JsNumber Create(double value)
+        public static JsNumber Create(double value)
         {
             // we expect zero to be on the fast path of integer mostly
             var temp = _intToJsValue;
@@ -136,7 +136,7 @@ namespace Jint.Native
             return new JsNumber(value);
         }
 
-        internal static JsNumber Create(byte value)
+        public static JsNumber Create(byte value)
         {
             return _intToJsValue[value];
         }
@@ -151,7 +151,7 @@ namespace Jint.Native
             return new JsNumber(value);
         }
 
-        internal static JsNumber Create(int value)
+        public static JsNumber Create(int value)
         {
             var temp = _intToJsValue;
             if ((uint) value < (uint) temp.Length)
@@ -188,7 +188,7 @@ namespace Jint.Native
             return new JsNumber(value);
         }
 
-        internal static JsNumber Create(long value)
+        public static JsNumber Create(long value)
         {
             if ((ulong) value < (ulong) _intToJsValue.Length)
             {

Jint/Native/RegExp/RegExpConstructor.cs

@@ -104,11 +104,11 @@ namespace Jint.Native.RegExp
 
             try
             {
-                var parserOptions = new ParserOptions();
-                var scanner = new Scanner("/" + p + "/" + flags, parserOptions);
+                var options = new ScannerOptions();
+                var scanner = new Scanner("/" + p + "/" + flags, options);
 
                 // seems valid
-                r.Value = scanner.ParseRegex(p, f, parserOptions.RegexTimeout);
+                r.Value = scanner.ParseRegex(p, f, options.RegexTimeout);
 
                 var timeout = _engine.Options.Constraints.RegexTimeout;
                 if (timeout.Ticks > 0)

Jint/Runtime/Environments/DeclarativeEnvironmentRecord.cs

@@ -24,13 +24,13 @@ namespace Jint.Runtime.Environments
             return _dictionary is not null && _dictionary.ContainsKey(name);
         }
 
-        internal sealed override bool HasBinding(in BindingName name)
+        internal sealed override bool HasBinding(BindingName name)
         {
             return _dictionary is not null &&_dictionary.ContainsKey(name.Key);
         }
 
         internal override bool TryGetBinding(
-            in BindingName name,
+            BindingName name,
             bool strict,
             out Binding binding,
             [NotNullWhen(true)] out JsValue? value)
@@ -71,7 +71,7 @@ namespace Jint.Runtime.Environments
             _dictionary.SetOrUpdateValue(name, static (current, value) => current.ChangeValue(value), value);
         }
 
-        internal sealed override void SetMutableBinding(in BindingName name, JsValue value, bool strict)
+        internal sealed override void SetMutableBinding(BindingName name, JsValue value, bool strict)
         {
             SetMutableBinding(name.Key.Name, value, strict);
         }

Jint/Runtime/Environments/EnvironmentRecord.cs

@@ -25,10 +25,10 @@ namespace Jint.Runtime.Environments
         /// <returns><c>true</c> if it does and <c>false</c> if it does not.</returns>
         public abstract bool HasBinding(string name);
 
-        internal abstract bool HasBinding(in BindingName name);
+        internal abstract bool HasBinding(BindingName name);
 
         internal abstract bool TryGetBinding(
-            in BindingName name,
+            BindingName name,
             bool strict,
             out Binding binding,
             [NotNullWhen(true)] out JsValue? value);
@@ -62,7 +62,7 @@ namespace Jint.Runtime.Environments
         /// <param name="strict">The identify strict mode references.</param>
         public abstract void SetMutableBinding(string name, JsValue value, bool strict);
 
-        internal abstract void SetMutableBinding(in BindingName name, JsValue value, bool strict);
+        internal abstract void SetMutableBinding(BindingName name, JsValue value, bool strict);
 
         /// <summary>
         /// Returns the value of an already existing binding from an environment record.
@@ -122,15 +122,23 @@ namespace Jint.Runtime.Environments
         /// Helper to cache JsString/Key when environments use different lookups.
         /// </summary>
         [DebuggerDisplay("\"{Key.Name}\"")]
-        internal readonly struct BindingName
+        internal sealed class BindingName
         {
             public readonly Key Key;
             public readonly JsString StringValue;
+            public readonly bool HasEvalOrArguments;
+            public readonly JsValue? CalculatedValue;
 
             public BindingName(string value)
             {
-                Key = (Key) value;
+                var key = (Key) value;
+                Key = key;
                 StringValue = JsString.Create(value);
+                HasEvalOrArguments = key == KnownKeys.Eval || key == KnownKeys.Arguments;
+                if (key == KnownKeys.Undefined)
+                {
+                    CalculatedValue = Undefined;
+                }
             }
         }
     }

Jint/Runtime/Environments/GlobalEnvironmentRecord.cs

@@ -45,7 +45,7 @@ namespace Jint.Runtime.Environments
             return _global.HasProperty(new JsString(name));
         }
 
-        internal override bool HasBinding(in BindingName name)
+        internal override bool HasBinding(BindingName name)
         {
             if (_declarativeRecord.HasBinding(name))
             {
@@ -61,7 +61,7 @@ namespace Jint.Runtime.Environments
         }
 
         internal override bool TryGetBinding(
-            in BindingName name,
+            BindingName name,
             bool strict,
             out Binding binding,
             [NotNullWhen(true)] out JsValue? value)
@@ -93,7 +93,7 @@ namespace Jint.Runtime.Environments
 
         [MethodImpl(MethodImplOptions.NoInlining)]
         private bool TryGetBindingForGlobalParent(
-            in BindingName name,
+            BindingName name,
             [NotNullWhen(true)] out JsValue? value)
         {
             value = default;
@@ -177,7 +177,7 @@ namespace Jint.Runtime.Environments
             }
         }
 
-        internal override void SetMutableBinding(in BindingName name, JsValue value, bool strict)
+        internal override void SetMutableBinding(BindingName name, JsValue value, bool strict)
         {
             if (_declarativeRecord.HasBinding(name))
             {

Jint/Runtime/Environments/ModuleEnvironmentRecord.cs

@@ -47,7 +47,7 @@ internal sealed class ModuleEnvironmentRecord : DeclarativeEnvironmentRecord
         return base.GetBindingValue(name, strict);
     }
 
-    internal override bool TryGetBinding(in BindingName name, bool strict, out Binding binding, [NotNullWhen(true)] out JsValue? value)
+    internal override bool TryGetBinding(BindingName name, bool strict, out Binding binding, [NotNullWhen(true)] out JsValue? value)
     {
         if (_importBindings.TryGetValue(name.Key, out var indirectBinding))
         {

Jint/Runtime/Environments/ObjectEnvironmentRecord.cs

@@ -45,7 +45,7 @@ namespace Jint.Runtime.Environments
             return !IsBlocked(name);
         }
 
-        internal override bool HasBinding(in BindingName name)
+        internal override bool HasBinding(BindingName name)
         {
             var foundBinding = HasProperty(name.StringValue);
 
@@ -68,7 +68,7 @@ namespace Jint.Runtime.Environments
         }
 
         internal override bool TryGetBinding(
-            in BindingName name,
+            BindingName name,
             bool strict,
             out Binding binding,
             [NotNullWhen(true)] out JsValue? value)
@@ -145,7 +145,7 @@ namespace Jint.Runtime.Environments
             _bindingObject.Set(jsString, value);
         }
 
-        internal override void SetMutableBinding(in BindingName name, JsValue value, bool strict)
+        internal override void SetMutableBinding(BindingName name, JsValue value, bool strict)
         {
             if (strict && !_bindingObject.HasProperty(name.StringValue))
             {

Jint/Runtime/Interpreter/Expressions/JintArrowFunctionExpression.cs

@@ -10,7 +10,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
         public JintArrowFunctionExpression(Engine engine, ArrowFunctionExpression function) : base(function)
         {
-            _function = new JintFunctionDefinition(engine, function);
+            _function = new JintFunctionDefinition(function);
         }
 
         protected override ExpressionResult EvaluateInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintAssignmentExpression.cs

@@ -393,7 +393,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 var strict = StrictModeScope.IsStrictModeCode;
                 if (JintEnvironment.TryGetIdentifierEnvironmentWithBinding(
                     env,
-                    left._expressionName,
+                    left.Identifier,
                     out var environmentRecord))
                 {
                     if (strict && hasEvalOrArguments)
@@ -411,10 +411,10 @@ namespace Jint.Runtime.Interpreter.Expressions
 
                     if (right._expression.IsFunctionDefinition())
                     {
-                        ((FunctionInstance) rval).SetFunctionName(left._expressionName.StringValue);
+                        ((FunctionInstance) rval).SetFunctionName(left.Identifier.StringValue);
                     }
 
-                    environmentRecord.SetMutableBinding(left._expressionName, rval, strict);
+                    environmentRecord.SetMutableBinding(left.Identifier, rval, strict);
                     return ExpressionResult.Normal(rval, completion._source);
                 }
 

Jint/Runtime/Interpreter/Expressions/JintExpression.cs

@@ -177,7 +177,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                 Nodes.BinaryExpression => JintBinaryExpression.Build(engine, (BinaryExpression) expression),
                 Nodes.CallExpression => new JintCallExpression((CallExpression) expression),
                 Nodes.ConditionalExpression => new JintConditionalExpression(engine, (ConditionalExpression) expression),
-                Nodes.FunctionExpression => new JintFunctionExpression(engine, (FunctionExpression) 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

Jint/Runtime/Interpreter/Expressions/JintFunctionExpression.cs

@@ -8,9 +8,9 @@ namespace Jint.Runtime.Interpreter.Expressions
     {
         private readonly JintFunctionDefinition _function;
 
-        public JintFunctionExpression(Engine engine, FunctionExpression function) : base(function)
+        public JintFunctionExpression(FunctionExpression function) : base(function)
         {
-            _function = new JintFunctionDefinition(engine, function);
+            _function = new JintFunctionDefinition(function);
         }
 
         protected override ExpressionResult EvaluateInternal(EvaluationContext context)

Jint/Runtime/Interpreter/Expressions/JintIdentifierExpression.cs

@@ -1,3 +1,5 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using Esprima.Ast;
 using Jint.Native;
 using Jint.Native.Argument;
@@ -7,31 +9,27 @@ namespace Jint.Runtime.Interpreter.Expressions
 {
     internal sealed class JintIdentifierExpression : JintExpression
     {
-        internal readonly EnvironmentRecord.BindingName _expressionName;
-        private readonly JsValue? _calculatedValue;
-
         public JintIdentifierExpression(Identifier expression) : base(expression)
         {
-            _expressionName = new EnvironmentRecord.BindingName(expression.Name);
-            if (expression.Name == "undefined")
-            {
-                _calculatedValue = JsValue.Undefined;
-            }
         }
 
-        public bool HasEvalOrArguments
-            => _expressionName.Key == KnownKeys.Eval || _expressionName.Key == KnownKeys.Arguments;
+        internal EnvironmentRecord.BindingName Identifier
+        {
+            get => (EnvironmentRecord.BindingName) (_expression.AssociatedData ??= new EnvironmentRecord.BindingName(((Identifier) _expression).Name));
+        }
+
+        public bool HasEvalOrArguments => Identifier.HasEvalOrArguments;
 
         protected override ExpressionResult EvaluateInternal(EvaluationContext context)
         {
             var engine = context.Engine;
             var env = engine.ExecutionContext.LexicalEnvironment;
             var strict = StrictModeScope.IsStrictModeCode;
-            var identifierEnvironment = JintEnvironment.TryGetIdentifierEnvironmentWithBinding(env, _expressionName, out var temp)
+            var identifierEnvironment = JintEnvironment.TryGetIdentifierEnvironmentWithBinding(env, Identifier, out var temp)
                 ? temp
                 : JsValue.Undefined;
 
-            return NormalCompletion(engine._referencePool.Rent(identifierEnvironment, _expressionName.StringValue, strict, thisValue: null));
+            return NormalCompletion(engine._referencePool.Rent(identifierEnvironment, Identifier.StringValue, strict, thisValue: null));
         }
 
         public override Completion GetValue(EvaluationContext context)
@@ -39,9 +37,9 @@ namespace Jint.Runtime.Interpreter.Expressions
             // need to notify correct node when taking shortcut
             context.LastSyntaxElement = _expression;
 
-            if (_calculatedValue is not null)
+            if (Identifier.CalculatedValue is not null)
             {
-                return new(CompletionType.Normal, _calculatedValue, _expression);
+                return new(CompletionType.Normal, Identifier.CalculatedValue, _expression);
             }
 
             var strict = StrictModeScope.IsStrictModeCode;
@@ -50,19 +48,19 @@ namespace Jint.Runtime.Interpreter.Expressions
 
             if (JintEnvironment.TryGetIdentifierEnvironmentWithBindingValue(
                 env,
-                _expressionName,
+                Identifier,
                 strict,
                 out _,
                 out var value))
             {
                 if (value is null)
                 {
-                    ExceptionHelper.ThrowReferenceError(engine.Realm, _expressionName.Key.Name + " has not been initialized");
+                    ThrowNotInitialized(engine);
                 }
             }
             else
             {
-                var reference = engine._referencePool.Rent(JsValue.Undefined, _expressionName.StringValue, strict, thisValue: null);
+                var reference = engine._referencePool.Rent(JsValue.Undefined, Identifier.StringValue, strict, thisValue: null);
                 value = engine.GetValue(reference, true);
             }
 
@@ -74,5 +72,12 @@ namespace Jint.Runtime.Interpreter.Expressions
 
             return new(CompletionType.Normal, value, _expression);
         }
+
+        [DoesNotReturn]
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void ThrowNotInitialized(Engine engine)
+        {
+            ExceptionHelper.ThrowReferenceError(engine.Realm, Identifier.Key.Name + " has not been initialized");
+        }
     }
 }

Jint/Runtime/Interpreter/Expressions/JintLiteralExpression.cs

@@ -7,16 +7,19 @@ namespace Jint.Runtime.Interpreter.Expressions
 {
     internal sealed class JintLiteralExpression : JintExpression
     {
+        private static readonly object _nullMarker = new();
+
         private JintLiteralExpression(Literal expression) : base(expression)
         {
         }
 
         internal static JintExpression Build(Literal expression)
         {
-            var constantValue = ConvertToJsValue(expression);
-            if (constantValue is not null)
+            var value = expression.AssociatedData ??= ConvertToJsValue(expression) ?? _nullMarker;
+
+            if (value is JsValue constant)
             {
-                return new JintConstantExpression(expression, constantValue);
+                return new JintConstantExpression(expression, constant);
             }
 
             return new JintLiteralExpression(expression);

Jint/Runtime/Interpreter/Expressions/JintMemberExpression.cs

@@ -50,12 +50,12 @@ namespace Jint.Runtime.Interpreter.Expressions
             var engine = context.Engine;
             if (_objectExpression is JintIdentifierExpression identifierExpression)
             {
-                baseReferenceName = identifierExpression._expressionName.Key.Name;
+                baseReferenceName = identifierExpression.Identifier.Key.Name;
                 var strict = isStrictModeCode;
                 var env = engine.ExecutionContext.LexicalEnvironment;
                 JintEnvironment.TryGetIdentifierEnvironmentWithBindingValue(
                     env,
-                    identifierExpression._expressionName,
+                    identifierExpression.Identifier,
                     strict,
                     out _,
                     out baseValue);

Jint/Runtime/Interpreter/Expressions/JintObjectExpression.cs

@@ -47,7 +47,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                     ExceptionHelper.ThrowSyntaxError(engine.Realm);
                 }
 
-                _functionDefinition = new JintFunctionDefinition(engine, function);
+                _functionDefinition = new JintFunctionDefinition(function);
                 return _functionDefinition;
             }
         }
@@ -90,7 +90,7 @@ namespace Jint.Runtime.Interpreter.Expressions
 
                     _properties[i] = new ObjectProperty(propName, p);
 
-                    if (p.Kind is PropertyKind.Init or PropertyKind.Data)
+                    if (p.Kind is PropertyKind.Init)
                     {
                         var propertyValue = p.Value;
                         _valueExpressions[i] = Build(engine, (Expression) propertyValue);
@@ -193,7 +193,7 @@ namespace Jint.Runtime.Interpreter.Expressions
                     propName = TypeConverter.ToPropertyKey(completion.Value);
                 }
 
-                if (property.Kind == PropertyKind.Init || property.Kind == PropertyKind.Data)
+                if (property.Kind == PropertyKind.Init)
                 {
                     var expr = _valueExpressions[i];
                     var completion = expr.GetValue(context);

Jint/Runtime/Interpreter/Expressions/JintUpdateExpression.cs

@@ -118,7 +118,7 @@ namespace Jint.Runtime.Interpreter.Expressions
         private JsValue? UpdateIdentifier(EvaluationContext context)
         {
             var strict = StrictModeScope.IsStrictModeCode;
-            var name = _leftIdentifier!._expressionName;
+            var name = _leftIdentifier!.Identifier;
             var engine = context.Engine;
             var env = engine.ExecutionContext.LexicalEnvironment;
             if (JintEnvironment.TryGetIdentifierEnvironmentWithBindingValue(

Jint/Runtime/Interpreter/JintFunctionDefinition.cs

@@ -11,28 +11,21 @@ namespace Jint.Runtime.Interpreter;
 /// </summary>
 internal sealed class JintFunctionDefinition
 {
-    private readonly Engine _engine;
-
     private JintExpression? _bodyExpression;
     private JintStatementList? _bodyStatementList;
 
     public readonly string? Name;
-    public readonly bool Strict;
     public readonly IFunction Function;
 
-    private State? _state;
-
-    public JintFunctionDefinition(
-        Engine engine,
-        IFunction function)
+    public JintFunctionDefinition(IFunction function)
     {
-        _engine = engine;
         Function = function;
         Name = !string.IsNullOrEmpty(function.Id?.Name) ? function.Id!.Name : null;
-        Strict = function.Strict;
     }
 
-    public FunctionThisMode ThisMode => Strict ? FunctionThisMode.Strict : FunctionThisMode.Global;
+    public bool Strict => Function.Strict;
+
+    public FunctionThisMode ThisMode => Function.Strict ? FunctionThisMode.Strict : FunctionThisMode.Global;
 
     /// <summary>
     /// https://tc39.es/ecma262/#sec-ordinarycallevaluatebody
@@ -41,11 +34,11 @@ internal sealed class JintFunctionDefinition
     internal Completion EvaluateBody(EvaluationContext context, FunctionInstance functionObject, JsValue[] argumentsList)
     {
         Completion result;
-        var argumentsInstance = _engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
+        var argumentsInstance = context.Engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
         if (Function.Expression)
         {
             // https://tc39.es/ecma262/#sec-runtime-semantics-evaluateconcisebody
-            _bodyExpression ??= JintExpression.Build(_engine, (Expression) Function.Body);
+            _bodyExpression ??= JintExpression.Build(context.Engine, (Expression) Function.Body);
             var jsValue = _bodyExpression.GetValue(context).GetValueOrDefault().Clone();
             result = new Completion(CompletionType.Return, jsValue, null, Function.Body);
         }
@@ -76,9 +69,11 @@ internal sealed class JintFunctionDefinition
         return default;
     }
 
-    internal State Initialize(FunctionInstance functionInstance)
+    internal State Initialize()
     {
-        return _state ??= DoInitialize(functionInstance);
+        var node = (Node) Function;
+        var state = (State) (node.AssociatedData ??= BuildState(Function));
+        return state;
     }
 
     internal sealed class State
@@ -110,19 +105,13 @@ internal sealed class JintFunctionDefinition
         }
     }
 
-    private State DoInitialize(FunctionInstance functionInstance)
+    internal static State BuildState(IFunction function)
     {
         var state = new State();
 
-        ProcessParameters(Function, state, out var hasArguments);
-
-        var hoistingScope = HoistingScope.GetFunctionLevelDeclarations(
-            Strict,
-            Function,
-            collectVarNames: true,
-            collectLexicalNames: true,
-            checkArgumentsReference: true);
+        ProcessParameters(function, state, out var hasArguments);
 
+        var hoistingScope = HoistingScope.GetFunctionLevelDeclarations(function.Strict, function);
         var functionDeclarations = hoistingScope._functionDeclarations;
         var lexicalNames = hoistingScope._lexicalNames;
         state.VarNames = hoistingScope._varNames;
@@ -138,7 +127,7 @@ internal sealed class JintFunctionDefinition
                 var fn = d.Id!.Name;
                 if (state.FunctionNames.Add(fn))
                 {
-                    functionsToInitialize.AddFirst(new JintFunctionDefinition(_engine, d));
+                    functionsToInitialize.AddFirst(new JintFunctionDefinition(d));
                 }
             }
         }
@@ -148,7 +137,13 @@ internal sealed class JintFunctionDefinition
         const string ParameterNameArguments = "arguments";
 
         state.ArgumentsObjectNeeded = true;
-        if (functionInstance._thisMode == FunctionThisMode.Lexical)
+        var thisMode = function.Strict ? FunctionThisMode.Strict : FunctionThisMode.Global;
+        if (function.Type == Nodes.ArrowFunctionExpression)
+        {
+            thisMode = FunctionThisMode.Lexical;
+        }
+
+        if (thisMode == FunctionThisMode.Lexical)
         {
             state.ArgumentsObjectNeeded = false;
         }
@@ -165,7 +160,7 @@ internal sealed class JintFunctionDefinition
             }
         }
 
-        if (state.ArgumentsObjectNeeded && !_engine._isDebugMode)
+        if (state.ArgumentsObjectNeeded)
         {
             // just one extra check...
             state.ArgumentsObjectNeeded = hoistingScope._hasArgumentsReference;
@@ -179,7 +174,6 @@ internal sealed class JintFunctionDefinition
 
         state.ParameterBindings = parameterBindings;
 
-
         var varsToInitialize = new List<State.VariableValuePair>();
         if (!state.HasParameterExpressions)
         {

Jint/Runtime/Interpreter/JintStatementList.cs

@@ -188,7 +188,7 @@ namespace Jint.Runtime.Interpreter
 
                 if (d is FunctionDeclaration functionDeclaration)
                 {
-                    var definition = new JintFunctionDefinition(engine, functionDeclaration);
+                    var definition = new JintFunctionDefinition(functionDeclaration);
                     var fn = definition.Name!;
                     var fo = env._engine.Realm.Intrinsics.Function.InstantiateFunctionObject(definition, env, privateEnv);
                     env.InitializeBinding(fn, fo);

Jint/Runtime/KnownKeys.cs

@@ -1,12 +1,12 @@
-namespace Jint.Runtime
+namespace Jint.Runtime;
+
+internal static class KnownKeys
 {
-    internal static class KnownKeys
-    {
-        internal static readonly Key Arguments = "arguments";
-        internal static readonly Key Caller = "caller";
-        internal static readonly Key Eval = "eval";
-        internal static readonly Key Length = "length";
-        internal static readonly Key Done = "done";
-        internal static readonly Key Value = "value";
-    }
+    internal static readonly Key Arguments = "arguments";
+    internal static readonly Key Caller = "caller";
+    internal static readonly Key Eval = "eval";
+    internal static readonly Key Length = "length";
+    internal static readonly Key Done = "done";
+    internal static readonly Key Value = "value";
+    internal static readonly Key Undefined = "undefined";
 }

Jint/Runtime/Modules/SourceTextModuleRecord.cs

@@ -316,7 +316,7 @@ internal class SourceTextModuleRecord : CyclicModuleRecord
             {
                 var d = functionDeclarations[i];
                 var fn = d.Id?.Name ?? "*default*";
-                var fd = new JintFunctionDefinition(_engine, d);
+                var fd = new JintFunctionDefinition(d);
                 env.CreateMutableBinding(fn, true);
                 // TODO private scope
                 var fo = realm.Intrinsics.Function.InstantiateFunctionObject(fd, env, privateScope: null);