Rename: Tracebacks -> Traceback

src/Lua/Exceptions.cs

@@ -44,39 +44,39 @@ public class LuaParseException(string? chunkName, SourcePosition position, strin
     public override string Message => $"{ChunkName ?? "<anonymous.lua>"}:{(Position == null ? "" : $"{Position.Value}:")} {base.Message}";
 }
 
-public class LuaRuntimeException(Tracebacks tracebacks, string message) : LuaException(message)
+public class LuaRuntimeException(Traceback traceback, string message) : LuaException(message)
 {
-    public Tracebacks Tracebacks { get; } = tracebacks;
+    public Traceback Traceback { get; } = traceback;
 
-    public static void AttemptInvalidOperation(Tracebacks tracebacks, string op, LuaValue a, LuaValue b)
+    public static void AttemptInvalidOperation(Traceback traceback, string op, LuaValue a, LuaValue b)
     {
-        throw new LuaRuntimeException(tracebacks, $"attempt to {op} a '{a.Type}' with a '{b.Type}'");
+        throw new LuaRuntimeException(traceback, $"attempt to {op} a '{a.Type}' with a '{b.Type}'");
     }
 
-    public static void AttemptInvalidOperation(Tracebacks tracebacks, string op, LuaValue a)
+    public static void AttemptInvalidOperation(Traceback traceback, string op, LuaValue a)
     {
-        throw new LuaRuntimeException(tracebacks, $"attempt to {op} a '{a.Type}' value");
+        throw new LuaRuntimeException(traceback, $"attempt to {op} a '{a.Type}' value");
     }
 
-    public static void BadArgument(Tracebacks tracebacks, int argumentId, string functionName)
+    public static void BadArgument(Traceback traceback, int argumentId, string functionName)
     {
-        throw new LuaRuntimeException(tracebacks, $"bad argument #{argumentId} to '{functionName}' (value expected)");
+        throw new LuaRuntimeException(traceback, $"bad argument #{argumentId} to '{functionName}' (value expected)");
     }
 
-    public static void BadArgument(Tracebacks tracebacks, int argumentId, string functionName, LuaValueType[] expected)
+    public static void BadArgument(Traceback traceback, int argumentId, string functionName, LuaValueType[] expected)
     {
-        throw new LuaRuntimeException(tracebacks, $"bad argument #{argumentId} to '{functionName}' ({string.Join(" or ", expected)} expected)");
+        throw new LuaRuntimeException(traceback, $"bad argument #{argumentId} to '{functionName}' ({string.Join(" or ", expected)} expected)");
     }
 
-    public static void BadArgument(Tracebacks tracebacks, int argumentId, string functionName, string expected, string actual)
+    public static void BadArgument(Traceback traceback, int argumentId, string functionName, string expected, string actual)
     {
-        throw new LuaRuntimeException(tracebacks, $"bad argument #{argumentId} to '{functionName}' ({expected} expected, got {actual})");
+        throw new LuaRuntimeException(traceback, $"bad argument #{argumentId} to '{functionName}' ({expected} expected, got {actual})");
     }
 
-    public override string Message => $"{Tracebacks.RootChunkName}:{Tracebacks.LastPosition.Line}: {base.Message}{(Tracebacks.StackFrames.Length > 0 ? $"\n{Tracebacks}" : "")}";
+    public override string Message => $"{Traceback.RootChunkName}:{Traceback.LastPosition.Line}: {base.Message}{(Traceback.StackFrames.Length > 0 ? $"\n{Traceback}" : "")}";
 }
 
-public class LuaAssertionException(Tracebacks tracebacks, string message) : LuaRuntimeException(tracebacks, message)
+public class LuaAssertionException(Traceback traceback, string message) : LuaRuntimeException(traceback, message)
 {
     public override string ToString()
     {

src/Lua/LuaFunction.cs

@@ -28,7 +28,7 @@ public abstract partial class LuaFunction
         }
         catch (Exception ex) when (ex is not (LuaException or OperationCanceledException))
         {
-            throw new LuaRuntimeException(thread.GetTracebacks(), ex.Message);
+            throw new LuaRuntimeException(thread.GetTraceback(), ex.Message);
         }
         finally
         {

src/Lua/LuaFunctionExecutionContext.cs

@@ -20,7 +20,7 @@ public readonly record struct LuaFunctionExecutionContext
             return thread.GetStackValues().Slice(thread.GetCurrentFrame().Base, ArgumentCount);
         }
     }
-    
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public LuaValue ReadArgument(int index)
     {
@@ -39,11 +39,11 @@ public readonly record struct LuaFunctionExecutionContext
             var thread = State.CurrentThread;
             if (LuaValue.TryGetLuaValueType(typeof(T), out var type))
             {
-                LuaRuntimeException.BadArgument(State.GetTracebacks(), index + 1, thread.GetCurrentFrame().Function.Name, type.ToString(), arg.Type.ToString());
+                LuaRuntimeException.BadArgument(State.GetTraceback(), index + 1, thread.GetCurrentFrame().Function.Name, type.ToString(), arg.Type.ToString());
             }
             else
             {
-                LuaRuntimeException.BadArgument(State.GetTracebacks(), index + 1, thread.GetCurrentFrame().Function.Name, typeof(T).Name, arg.Type.ToString());
+                LuaRuntimeException.BadArgument(State.GetTraceback(), index + 1, thread.GetCurrentFrame().Function.Name, typeof(T).Name, arg.Type.ToString());
             }
         }
 
@@ -54,7 +54,7 @@ public readonly record struct LuaFunctionExecutionContext
     {
         if (ArgumentCount <= index)
         {
-            LuaRuntimeException.BadArgument(State.GetTracebacks(), index + 1, State.CurrentThread.GetCurrentFrame().Function.Name);
+            LuaRuntimeException.BadArgument(State.GetTraceback(), index + 1, State.CurrentThread.GetCurrentFrame().Function.Name);
         }
     }
 }

src/Lua/LuaMainThread.cs

@@ -16,6 +16,6 @@ public sealed class LuaMainThread : LuaThread
 
     public override ValueTask Yield(LuaFunctionExecutionContext context, CancellationToken cancellationToken = default)
     {
-        throw new LuaRuntimeException(context.State.GetTracebacks(), "attempt to yield from outside a coroutine");
+        throw new LuaRuntimeException(context.State.GetTraceback(), "attempt to yield from outside a coroutine");
     }
 }

src/Lua/LuaState.cs

@@ -74,9 +74,9 @@ public sealed class LuaState
         return new LuaCoroutine(this, function, isProtectedMode);
     }
 
-    public Tracebacks GetTracebacks()
+    public Traceback GetTraceback()
     {
-        return MainThread.GetTracebacks();
+        return MainThread.GetTraceback();
     }
 
     internal UpValue GetOrAddUpValue(LuaThread thread, int registerIndex)

src/Lua/LuaThread.cs

@@ -24,7 +24,7 @@ public abstract class LuaThread
         return stack.AsSpan();
     }
 
-    internal Tracebacks GetTracebacks()
+    internal Traceback GetTraceback()
     {
         return new()
         {

src/Lua/LuaValue.cs

@@ -356,7 +356,7 @@ public readonly struct LuaValue : IEquatable<LuaValue>
         {
             if (!metamethod.TryRead<LuaFunction>(out var func))
             {
-                LuaRuntimeException.AttemptInvalidOperation(context.State.GetTracebacks(), "call", metamethod);
+                LuaRuntimeException.AttemptInvalidOperation(context.State.GetTraceback(), "call", metamethod);
             }
 
             context.State.Push(this);

src/Lua/Runtime/LuaVirtualMachine.cs

@@ -279,7 +279,7 @@ public static partial class LuaVirtualMachine
                         {
                             stack.UnsafeGet(RA) = valueB % valueC;
                         }
-                        else if (vb.TryGetMetamethod(Metamethods.Mod, out var metamethod)  || vc.TryGetMetamethod(Metamethods.Mod, out metamethod))
+                        else if (vb.TryGetMetamethod(Metamethods.Mod, out var metamethod) || vc.TryGetMetamethod(Metamethods.Mod, out metamethod))
                         {
                             if (!metamethod.TryRead<LuaFunction>(out var func))
                             {
@@ -548,7 +548,7 @@ public static partial class LuaVirtualMachine
                         var vb = RK(stack, chunk, instruction.B, frame.Base);
                         var vc = RK(stack, chunk, instruction.C, frame.Base);
                         var compareResult = false;
-                        
+
                         if (vb.TryRead<double>(out var valueB) && vc.TryRead<double>(out var valueC))
                         {
                             compareResult = valueB < valueC;
@@ -668,7 +668,7 @@ public static partial class LuaVirtualMachine
                         if (!va.TryRead<LuaFunction>(out var func))
                         {
                             if (va.TryGetMetamethod(Metamethods.Call, out var metamethod) && metamethod.TryRead<LuaFunction>(out func))
-                            {   
+                            {
                             }
                             else
                             {
@@ -790,7 +790,7 @@ public static partial class LuaVirtualMachine
                         var iterator = stack.UnsafeGet(RA).Read<LuaFunction>();
 
                         var nextBase = RA + 3 + instruction.C;
-                        
+
                         var resultBuffer = ArrayPool<LuaValue>.Shared.Rent(1024);
                         resultBuffer.AsSpan().Clear();
                         try
@@ -1030,7 +1030,7 @@ public static partial class LuaVirtualMachine
         return (newBase, argumentCount);
     }
 
-    static Tracebacks GetTracebacks(LuaState state, Chunk chunk, int pc)
+    static Traceback GetTracebacks(LuaState state, Chunk chunk, int pc)
     {
         var frame = state.CurrentThread.GetCurrentFrame();
         state.CurrentThread.PushCallStackFrame(frame with
@@ -1039,7 +1039,7 @@ public static partial class LuaVirtualMachine
             ChunkName = chunk.Name,
             RootChunkName = chunk.GetRoot().Name,
         });
-        var tracebacks = state.GetTracebacks();
+        var tracebacks = state.GetTraceback();
         state.CurrentThread.PopCallStackFrame();
 
         return tracebacks;

src/Lua/Runtime/Tracebacks.cs

@@ -2,7 +2,7 @@ using Lua.CodeAnalysis;
 
 namespace Lua.Runtime;
 
-public class Tracebacks
+public class Traceback
 {
     public required CallStackFrame[] StackFrames { get; init; }
 

src/Lua/Standard/Basic/AssertFunction.cs

@@ -17,7 +17,7 @@ public sealed class AssertFunction : LuaFunction
                 message = context.ReadArgument<string>(1);
             }
 
-            throw new LuaAssertionException(context.State.GetTracebacks(), message);
+            throw new LuaAssertionException(context.State.GetTraceback(), message);
         }
 
         return new(0);

src/Lua/Standard/Basic/ErrorFunction.cs

@@ -11,6 +11,6 @@ public sealed class ErrorFunction : LuaFunction
             ? "(error object is a nil value)"
             : context.Arguments[0].ToString();
 
-        throw new LuaRuntimeException(context.State.GetTracebacks(), obj!);
+        throw new LuaRuntimeException(context.State.GetTraceback(), obj!);
     }
 }

src/Lua/Standard/Basic/IPairsFunction.cs

@@ -16,7 +16,7 @@ public sealed class IPairsFunction : LuaFunction
         {
             if (!metamethod.TryRead<LuaFunction>(out var function))
             {
-                LuaRuntimeException.AttemptInvalidOperation(context.State.GetTracebacks(), "call", metamethod);
+                LuaRuntimeException.AttemptInvalidOperation(context.State.GetTraceback(), "call", metamethod);
             }
 
             return function.InvokeAsync(context, buffer, cancellationToken);

src/Lua/Standard/Basic/LoadFunction.cs

@@ -37,7 +37,7 @@ public sealed class LoadFunction : LuaFunction
             }
             else
             {
-                LuaRuntimeException.BadArgument(context.State.GetTracebacks(), 1, Name);
+                LuaRuntimeException.BadArgument(context.State.GetTraceback(), 1, Name);
                 return default; // dummy
             }
         }

src/Lua/Standard/Basic/PairsFunction.cs

@@ -16,7 +16,7 @@ public sealed class PairsFunction : LuaFunction
         {
             if (!metamethod.TryRead<LuaFunction>(out var function))
             {
-                LuaRuntimeException.AttemptInvalidOperation(context.State.GetTracebacks(), "call", metamethod);
+                LuaRuntimeException.AttemptInvalidOperation(context.State.GetTraceback(), "call", metamethod);
             }
 
             return function.InvokeAsync(context, buffer, cancellationToken);

src/Lua/Standard/Basic/RawLenFunction.cs

@@ -20,7 +20,7 @@ public sealed class RawLenFunction : LuaFunction
         }
         else
         {
-            LuaRuntimeException.BadArgument(context.State.GetTracebacks(), 2, Name, [LuaValueType.String, LuaValueType.Table]);
+            LuaRuntimeException.BadArgument(context.State.GetTraceback(), 2, Name, [LuaValueType.String, LuaValueType.Table]);
         }
 
         return new(1);

src/Lua/Standard/Basic/SelectFunction.cs

@@ -8,12 +8,12 @@ public sealed class SelectFunction : LuaFunction
     protected override ValueTask<int> InvokeAsyncCore(LuaFunctionExecutionContext context, Memory<LuaValue> buffer, CancellationToken cancellationToken)
     {
         var arg0 = context.ReadArgument(0);
-        
+
         if (arg0.TryRead<double>(out var d))
         {
             if (!MathEx.IsInteger(d))
             {
-                throw new LuaRuntimeException(context.State.GetTracebacks(), "bad argument #1 to 'select' (number has no integer representation)");
+                throw new LuaRuntimeException(context.State.GetTraceback(), "bad argument #1 to 'select' (number has no integer representation)");
             }
 
             var index = (int)d;
@@ -30,7 +30,7 @@ public sealed class SelectFunction : LuaFunction
         }
         else
         {
-            LuaRuntimeException.BadArgument(context.State.GetTracebacks(), 1, Name, "number", arg0.Type.ToString());
+            LuaRuntimeException.BadArgument(context.State.GetTraceback(), 1, Name, "number", arg0.Type.ToString());
             return default;
         }
     }

src/Lua/Standard/Basic/SetMetatableFunction.cs

@@ -15,12 +15,12 @@ public sealed class SetMetatableFunction : LuaFunction
 
         if (arg1.Type is not (LuaValueType.Nil or LuaValueType.Table))
         {
-            LuaRuntimeException.BadArgument(context.State.GetTracebacks(), 2, Name, [LuaValueType.Nil, LuaValueType.Table]);
+            LuaRuntimeException.BadArgument(context.State.GetTraceback(), 2, Name, [LuaValueType.Nil, LuaValueType.Table]);
         }
 
         if (arg0.Metatable != null && arg0.Metatable.TryGetValue(Metamethods.Metatable, out _))
         {
-            throw new LuaRuntimeException(context.State.GetTracebacks(), "cannot change a protected metatable");
+            throw new LuaRuntimeException(context.State.GetTraceback(), "cannot change a protected metatable");
         }
         else if (arg1.Type is LuaValueType.Nil)
         {

src/Lua/Standard/Basic/ToNumberFunction.cs

@@ -16,7 +16,7 @@ public sealed class ToNumberFunction : LuaFunction
 
         if (arg1 < 2 || arg1 > 36)
         {
-            throw new LuaRuntimeException(context.State.GetTracebacks(), "bad argument #2 to 'tonumber' (base out of range)");
+            throw new LuaRuntimeException(context.State.GetTraceback(), "bad argument #2 to 'tonumber' (base out of range)");
         }
 
         if (arg0.Type is LuaValueType.Number)