Implementation of JS stack trace

nilproject · nilproject · commit 511c1cd7d98c · 2022-08-09T13:37:26.000+03:00
diff --git a/NiL.JS/Core/CallStackMarker.cs b/NiL.JS/Core/CallStackMarker.cs
@@ -0,0 +1,23 @@
+﻿namespace NiL.JS.Core
+{
+    internal readonly struct CallStackMarker
+    {
+        public int Index { get; }
+
+        public CallStackMarker(int index)
+        {
+            Index = index;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is CallStackMarker marker &&
+                   Index == marker.Index;
+        }
+
+        public override int GetHashCode()
+        {
+            return -2134847229 + Index.GetHashCode();
+        }
+    }
+}
diff --git a/NiL.JS/Core/Context.cs b/NiL.JS/Core/Context.cs
@@ -98,6 +98,7 @@ public static Context CurrentContext
         internal JSValue _thisBind;
         internal Function _owner;
         internal Context _parent;
+        internal string _sourceCode;
         internal IDictionary<string, JSValue> _variables;
         internal bool _strict;
         internal VariableDescriptor[] _definedVariables;
@@ -630,6 +631,7 @@ public JSValue Eval(string code, JSValue thisBind, bool suppressScopeCreation =
                 var oldThisBind = ThisBind;
                 var runContextOfEval = context.Activate();
                 context._thisBind = thisBind;
+                context._sourceCode = code;
                 try
                 {
                     return body.Evaluate(context) ?? context._lastResult ?? JSValue.notExists;
diff --git a/NiL.JS/Core/Functions/MethodProxy.cs b/NiL.JS/Core/Functions/MethodProxy.cs
@@ -221,9 +221,9 @@ private RestPrmsConverter makeRestPrmsArrayCreator()
             };
 
             var lambda = Expression.Lambda<RestPrmsConverter>(
-                Expression.Block(new[] { argumentIndex, resultArray, resultArrayIndex, tempValue }, tree), 
+                Expression.Block(new[] { argumentIndex, resultArray, resultArrayIndex, tempValue }, tree),
                 context, arguments, argumentsObjectPrm);
-            
+
             return lambda.Compile();
         }
 
@@ -480,30 +480,16 @@ private object invokeMethod(JSValue targetValue, Expressions.Expression[] argume
         {
             object value;
             var target = GetTargetObject(targetValue, _hardTarget);
-            try
+            if (_parameters.Length == 0 && argumentsSource != null)
             {
-                if (_parameters.Length == 0 && argumentsSource != null)
-                {
-                    for (var i = 0; i < argumentsSource.Length; i++)
-                        argumentsSource[i].Evaluate(initiator);
-                }
-
-                value = _fastWrapper(target, initiator, argumentsSource, argumentsObject);
-
-                if (_returnConverter != null)
-                    value = _returnConverter.From(value);
+                for (var i = 0; i < argumentsSource.Length; i++)
+                    argumentsSource[i].Evaluate(initiator);
             }
-            catch (Exception e)
-            {
-                while (e.InnerException != null)
-                    e = e.InnerException;
 
-                if (e is JSException)
-                    throw e;
+            value = _fastWrapper(target, initiator, argumentsSource, argumentsObject);
 
-                ExceptionHelper.Throw(new TypeError(e.Message), e);
-                throw;
-            }
+            if (_returnConverter != null)
+                value = _returnConverter.From(value);
 
             return value;
         }
diff --git a/NiL.JS/Core/JSException.cs b/NiL.JS/Core/JSException.cs
@@ -12,6 +12,8 @@ namespace NiL.JS.Core
 #endif
     public sealed class JSException : Exception
     {
+        private string _stackTraceOverride;
+
         public JSValue Error { get; }
         public CodeNode ExceptionMaker { get; }
         public string Code { get; internal set; }
@@ -49,6 +51,8 @@ public JSException(Error avatar, Exception innerException)
             Error = Context.CurrentGlobalContext.ProxyValue(avatar);
         }
 
+        public override string StackTrace => _stackTraceOverride ?? base.StackTrace;
+
         public override string Message
         {
             get
@@ -74,5 +78,10 @@ public override string Message
                 return result;
             }
         }
+
+        internal void InternalSetStackTrace(string stackTrace)
+        {
+            _stackTraceOverride = stackTrace;
+        }
     }
 }
diff --git a/NiL.JS/ExceptionHelper.cs b/NiL.JS/ExceptionHelper.cs
@@ -76,12 +76,12 @@ internal static void ThrowVariableIsNotDefined(string variableName, CodeNode exc
             Throw(new ReferenceError(string.Format(Strings.VariableNotDefined, variableName)), exceptionMaker, code);
         }
 
-        private static string GetCode(Context context)
+        internal static string GetCode(Context context)
         {
-            var code = context.RootContext._owner?._functionDefinition?._body?.Code;
-            if (code == null)
-                code = context._module?.Script.Code;
-            return code;
+            while (context != null && context._sourceCode == null)
+                context = context._parent;
+
+            return context?._sourceCode ?? Script.CurrentScript?.Code;
         }
 
         /// <exception cref="NiL.JS.Core.JSException">
diff --git a/NiL.JS/Expressions/Call.cs b/NiL.JS/Expressions/Call.cs
@@ -168,10 +168,32 @@ public override JSValue Evaluate(Context context)
             if (_callMode == CallMode.Construct)
                 targetObject = null;
 
-            if ((function._attributes & JSValueAttributesInternal.Eval) != 0)
-                return callEval(context);
+            try
+            {
+                if ((function._attributes & JSValueAttributesInternal.Eval) != 0)
+                    return callEval(context);
+
+                return func.InternalInvoke(targetObject, _arguments, context, _withSpread, _callMode != 0);
+            }
+            catch (Exception e)
+            {
+                foreach(var item in e.Data.Values)
+                {
+                    if ((item as Tuple<Context, CodeCoordinates>).Item1 == context)
+                        throw;
+                }
 
-            return func.InternalInvoke(targetObject, _arguments, context, _withSpread, _callMode != 0);
+                e.Data.Add(
+                    new CallStackMarker(e.Data.Count), 
+                    Tuple.Create(
+                        context, 
+                        CodeCoordinates.FromTextPosition(
+                            ExceptionHelper.GetCode(context), 
+                            Position, 
+                            Length)));
+
+                throw;
+            }
         }
 
         private JSValue callEval(Context context)
diff --git a/NiL.JS/Script.cs b/NiL.JS/Script.cs
@@ -7,6 +7,11 @@ namespace NiL.JS
 {
     public sealed class Script
     {
+        [ThreadStatic]
+        private static readonly Stack<Script> _scriptsStack = new Stack<Script>();
+
+        internal static Script CurrentScript => _scriptsStack.Count > 0 ? _scriptsStack.Peek() : null;
+
         public string Code { get; private set; }
         public CodeBlock Root { get; private set; }
 
@@ -28,7 +33,7 @@ public static Script Parse(string code, CompilerMessageCallback messageCallback
                     Code = ""
                 };
             }
-            
+
             var internalCallback = messageCallback != null ?
                 (level, position, length, message) => messageCallback(level, CodeCoordinates.FromTextPosition(code, position, length), message)
                 : null as InternalCompilerMessageCallback;
@@ -62,6 +67,9 @@ public JSValue Evaluate(Context context)
             if (Code == "")
                 return JSValue.Undefined;
 
+            lock (_scriptsStack)
+                _scriptsStack.Push(this);
+
             try
             {
                 context.Activate();
@@ -72,6 +80,9 @@ public JSValue Evaluate(Context context)
                 for (var i = 0; i < Root._variables.Length; i++)
                     Root._variables[i].cacheContext = null;
                 context.Deactivate();
+
+                lock (_scriptsStack)
+                    _scriptsStack.Pop();
             }
         }
     }
diff --git a/NiL.JS/Statements/CodeBlock.cs b/NiL.JS/Statements/CodeBlock.cs
@@ -345,13 +345,16 @@ private void evaluateWithScope(Context context, int i, bool clearSuspendData)
 
         private void evaluateLines(Context context, int i, bool clearSuspendData)
         {
-            for (var ls = _lines; i < ls.Length; i++)
+            var ls = _lines;
+            try
             {
-                if (context._debugging)
-                    context.raiseDebugger(_lines[i]);
-                var t = ls[i].Evaluate(context);
-                if (t != null)
-                    context._lastResult = t;
+                for (; i < ls.Length; i++)
+                {
+                    if (context._debugging)
+                        context.raiseDebugger(_lines[i]);
+                    var t = ls[i].Evaluate(context);
+                    if (t != null)
+                        context._lastResult = t;
 #if DEBUG && !(PORTABLE || NETCORE)
                 if (!context.Running)
                     if (System.Diagnostics.Debugger.IsAttached)
@@ -388,18 +391,38 @@ private void evaluateLines(Context context, int i, bool clearSuspendData)
                     else
                         throw new ApplicationException("Boolean.True has been rewitten");
 #endif
-                if (context._executionMode != ExecutionMode.Regular)
-                {
-                    if (context._executionMode == ExecutionMode.Suspend)
+                    if (context._executionMode != ExecutionMode.Regular)
                     {
-                        context.SuspendData[this] = new SuspendData { Context = context, LineIndex = i };
+                        if (context._executionMode == ExecutionMode.Suspend)
+                        {
+                            context.SuspendData[this] = new SuspendData { Context = context, LineIndex = i };
+                        }
+
+                        break;
                     }
 
-                    break;
+                    if (clearSuspendData)
+                        context.SuspendData.Clear();
+                }
+            }
+            catch (Exception e)
+            {
+                foreach (var item in e.Data.Values)
+                {
+                    if ((item as Tuple<Context, CodeCoordinates>).Item1 == context)
+                        throw;
                 }
 
-                if (clearSuspendData)
-                    context.SuspendData.Clear();
+                e.Data.Add(
+                    new CallStackMarker(e.Data.Count),
+                    Tuple.Create(
+                        context,
+                        CodeCoordinates.FromTextPosition(
+                            ExceptionHelper.GetCode(context),
+                            ls[i].Position,
+                            ls[i].Length)));
+
+                throw;
             }
         }
 
diff --git a/NiL.JS/Statements/TryCatch.cs b/NiL.JS/Statements/TryCatch.cs
@@ -1,9 +1,9 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using NiL.JS.BaseLibrary;
 using NiL.JS.Core;
-using NiL.JS.Core.Interop;
 using NiL.JS.Expressions;
 
 namespace NiL.JS.Statements
@@ -128,7 +128,49 @@ public override JSValue Evaluate(Context context)
             }
             catch (Exception e)
             {
-                if (this._catch)
+                var stackTrace = new List<string>();
+
+                var innerEx = e;
+                while (innerEx != null)
+                {
+                    var isOurException = false;
+                    for (var i = innerEx.Data.Count; i-- > 0;)
+                    {
+                        var item = innerEx.Data[new CallStackMarker(i)] as Tuple<Context, CodeCoordinates>;
+                        if (item == null)
+                            continue;
+
+                        isOurException = true;
+                        stackTrace.Add("   at " + (item.Item1?._owner?.name ?? "<unknown function>") + ": line " + item.Item2.Line);
+                    }
+
+                    if (!isOurException)
+                        stackTrace.Add(innerEx.StackTrace);
+
+                    innerEx = innerEx.InnerException;
+                }
+
+                if (e is TargetInvocationException targetInvocationException)
+                {
+                    var baseException = targetInvocationException.GetBaseException();
+                    if (baseException is JSException jsEx)
+                    {
+                        e = baseException;
+                    }
+                    else
+                    {
+                        jsEx = new JSException(new TypeError(e.Message), e);
+                        e = jsEx;
+                    }
+
+                    if (stackTrace.Count > 0)
+                    {
+                        stackTrace.Reverse();
+                        jsEx.InternalSetStackTrace(string.Join(Environment.NewLine, stackTrace));
+                    }
+                }
+
+                if (_catch)
                 {
                     if (catchBody != null)
                         catchHandler(context, e);

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@ namespace NiL.JS.Core`
`12`	`12`	`#endif`
`13`	`13`	`public sealed class JSException : Exception`
`14`	`14`	`{`
	`15`	`+ private string _stackTraceOverride;`
	`16`	`+`
`15`	`17`	`public JSValue Error { get; }`
`16`	`18`	`public CodeNode ExceptionMaker { get; }`
`17`	`19`	`public string Code { get; internal set; }`
`@@ -49,6 +51,8 @@ public JSException(Error avatar, Exception innerException)`
`49`	`51`	`Error = Context.CurrentGlobalContext.ProxyValue(avatar);`
`50`	`52`	`}`
`51`	`53`
	`54`	`+ public override string StackTrace => _stackTraceOverride ?? base.StackTrace;`
	`55`	`+`
`52`	`56`	`public override string Message`
`53`	`57`	`{`
`54`	`58`	`get`
`@@ -74,5 +78,10 @@ public override string Message`
`74`	`78`	`return result;`
`75`	`79`	`}`
`76`	`80`	`}`
	`81`	`+`
	`82`	`+ internal void InternalSetStackTrace(string stackTrace)`
	`83`	`+ {`
	`84`	`+ _stackTraceOverride = stackTrace;`
	`85`	`+ }`
`77`	`86`	`}`
`78`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,12 +76,12 @@ internal static void ThrowVariableIsNotDefined(string variableName, CodeNode exc`
`76`	`76`	`Throw(new ReferenceError(string.Format(Strings.VariableNotDefined, variableName)), exceptionMaker, code);`
`77`	`77`	`}`
`78`	`78`
`79`		`- private static string GetCode(Context context)`
	`79`	`+ internal static string GetCode(Context context)`
`80`	`80`	`{`
`81`		`- var code = context.RootContext._owner?._functionDefinition?._body?.Code;`
`82`		`- if (code == null)`
`83`		`- code = context._module?.Script.Code;`
`84`		`- return code;`
	`81`	`+ while (context != null && context._sourceCode == null)`
	`82`	`+ context = context._parent;`
	`83`	`+`
	`84`	`+ return context?._sourceCode ?? Script.CurrentScript?.Code;`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`/// <exception cref="NiL.JS.Core.JSException">`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,11 @@ namespace NiL.JS`
`7`	`7`	`{`
`8`	`8`	`public sealed class Script`
`9`	`9`	`{`
	`10`	`+ [ThreadStatic]`
	`11`	`+ private static readonly Stack<Script> _scriptsStack = new Stack<Script>();`
	`12`	`+`
	`13`	`+ internal static Script CurrentScript => _scriptsStack.Count > 0 ? _scriptsStack.Peek() : null;`
	`14`	`+`
`10`	`15`	`public string Code { get; private set; }`
`11`	`16`	`public CodeBlock Root { get; private set; }`
`12`	`17`
`@@ -28,7 +33,7 @@ public static Script Parse(string code, CompilerMessageCallback messageCallback`
`28`	`33`	`Code = ""`
`29`	`34`	`};`
`30`	`35`	`}`
`31`		`-`
	`36`	`+`
`32`	`37`	`var internalCallback = messageCallback != null ?`
`33`	`38`	`(level, position, length, message) => messageCallback(level, CodeCoordinates.FromTextPosition(code, position, length), message)`
`34`	`39`	`: null as InternalCompilerMessageCallback;`
`@@ -62,6 +67,9 @@ public JSValue Evaluate(Context context)`
`62`	`67`	`if (Code == "")`
`63`	`68`	`return JSValue.Undefined;`
`64`	`69`
	`70`	`+ lock (_scriptsStack)`
	`71`	`+ _scriptsStack.Push(this);`
	`72`	`+`
`65`	`73`	`try`
`66`	`74`	`{`
`67`	`75`	`context.Activate();`
`@@ -72,6 +80,9 @@ public JSValue Evaluate(Context context)`
`72`	`80`	`for (var i = 0; i < Root._variables.Length; i++)`
`73`	`81`	`Root._variables[i].cacheContext = null;`
`74`	`82`	`context.Deactivate();`
	`83`	`+`
	`84`	`+ lock (_scriptsStack)`
	`85`	`+ _scriptsStack.Pop();`
`75`	`86`	`}`
`76`	`87`	`}`
`77`	`88`	`}`