Default source to "<anonymous>" in PrepareScript/PrepareModule (#2379)

PrepareScript and PrepareModule passed null source through to the parser
as-is, while Evaluate/Execute defaulted null source to "<anonymous>".
This inconsistency meant nodes from prepared scripts had
Location.SourceFile == null instead of "<anonymous>", causing breakpoint
matching issues when debugging tools used the source identifier.

Fixes #2378

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: lahma

Jint.Tests/Runtime/Debugger/BreakPointTests.cs

@@ -133,6 +133,95 @@ public void BreakPointBreaksAtPosition()
         Assert.True(didBreak);
     }
 
+    [Fact]
+    public void BreakPointBreaksAtPositionWithPreparedScript()
+    {
+        string script = @"let x = 1, y = 2;
+if (x === 1)
+{
+x++; y *= 2;
+}";
+
+        var engine = new Engine(options => options.DebugMode());
+
+        bool didBreak = false;
+        engine.Debugger.Break += (sender, info) =>
+        {
+            Assert.Equal(4, info.Location.Start.Line);
+            Assert.Equal(5, info.Location.Start.Column);
+            didBreak = true;
+            return StepMode.None;
+        };
+
+        engine.Debugger.BreakPoints.Set(new BreakPoint(4, 5));
+        var prepared = Engine.PrepareScript(script);
+        engine.Execute(prepared);
+        Assert.True(didBreak);
+    }
+
+    [Fact]
+    public void BreakPointBreaksInCorrectSourceWithPreparedScript()
+    {
+        string script1 = @"let x = 1, y = 2;
+if (x === 1)
+{
+x++; y *= 2;
+}";
+
+        string script2 = @"function test(x)
+{
+return x + 2;
+}";
+
+        string script3 = @"const z = 3;
+test(z);";
+
+        var engine = new Engine(options => { options.DebugMode(); });
+
+        engine.Debugger.BreakPoints.Set(new BreakPoint("script2", 3, 0));
+
+        bool didBreak = false;
+        engine.Debugger.Break += (sender, info) =>
+        {
+            Assert.Equal("script2", info.Location.SourceFile);
+            Assert.Equal(3, info.Location.Start.Line);
+            Assert.Equal(0, info.Location.Start.Column);
+            didBreak = true;
+            return StepMode.None;
+        };
+
+        engine.Execute(Engine.PrepareScript(script1, "script1"));
+        Assert.False(didBreak);
+
+        engine.Execute(Engine.PrepareScript(script2, "script2"));
+        Assert.False(didBreak);
+
+        engine.Execute(Engine.PrepareScript(script3, "script3"));
+        Assert.True(didBreak);
+    }
+
+    [Fact]
+    public void BreakPointBreaksWithPreparedScriptDefaultSource()
+    {
+        string script = @"let x = 1;
+x++;";
+
+        var engine = new Engine(options => options.DebugMode());
+
+        bool didBreak = false;
+        engine.Debugger.Break += (sender, info) =>
+        {
+            Assert.Equal("<anonymous>", info.Location.SourceFile);
+            didBreak = true;
+            return StepMode.None;
+        };
+
+        engine.Debugger.BreakPoints.Set(new BreakPoint("<anonymous>", 2, 0));
+        var prepared = Engine.PrepareScript(script);
+        engine.Execute(prepared);
+        Assert.True(didBreak);
+    }
+
     [Fact]
     public void BreakPointBreaksInCorrectSource()
     {

Jint.Tests/Runtime/ScriptModulePreparationTests.ScriptPreparation.cs

@@ -80,15 +80,15 @@ public void CompiledRegexShouldProduceSameResultAsNonCompiled()
     public void PrepareScriptShouldNotLeakAcornimaException()
     {
         var ex = Assert.Throws<ScriptPreparationException>(() => Engine.PrepareScript("class A { } A().#nonexistent = 1;"));
-        ex.Message.Should().Be("Could not prepare script: Private field '#nonexistent' must be declared in an enclosing class (1:17)");
+        ex.Message.Should().Be("Could not prepare script: Private field '#nonexistent' must be declared in an enclosing class (<anonymous>:1:17)");
         ex.InnerException.Should().BeOfType<SyntaxErrorException>();
     }
 
     [Fact]
     public void PrepareModuleShouldNotLeakAcornimaException()
     {
         var ex = Assert.Throws<ScriptPreparationException>(() => Engine.PrepareModule("class A { } A().#nonexistent = 1;"));
-        ex.Message.Should().Be("Could not prepare script: Private field '#nonexistent' must be declared in an enclosing class (1:17)");
+        ex.Message.Should().Be("Could not prepare script: Private field '#nonexistent' must be declared in an enclosing class (<anonymous>:1:17)");
         ex.InnerException.Should().BeOfType<SyntaxErrorException>();
     }
 }

Jint/Engine.Ast.cs

@@ -17,6 +17,7 @@ public partial class Engine
     /// </remarks>
     public static Prepared<Script> PrepareScript(string code, string? source = null, bool strict = false, ScriptPreparationOptions? options = null)
     {
+        source ??= "<anonymous>";
         options ??= ScriptPreparationOptions.Default;
 
         var astAnalyzer = new AstAnalyzer(options);
@@ -53,6 +54,7 @@ public static Prepared<Script> PrepareScript(string code, string? source = null,
     /// </remarks>
     public static Prepared<Module> PrepareModule(string code, string? source = null, ModulePreparationOptions? options = null)
     {
+        source ??= "<anonymous>";
         options ??= ModulePreparationOptions.Default;
 
         var astAnalyzer = new AstAnalyzer(options);