Errors carry real line numbers, server names, and procedure context: line/procedure stamp ambiently at the dispatch catch boundary, proc-body errors report CREATE-relative lines with a schema-qualified Procedure via BodyLineOffset threading, THROW re-raise preserves the original diagnostics, ERROR_LINE/ERROR_PROCEDURE match the exception, and Server mirrors real SqlClient's split: the in-process exception reports the connection data source while the TDS ERROR/INFO tokens carry @@ServerName, which SqlClient overrides client-side exactly like the real driver.

Author: RyanLamansky

CLAUDE.md

@@ -130,6 +130,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **`PIVOT` / `UNPIVOT`** — PIVOT desugars to grouped conditional aggregation (implicit grouping = inner columns minus FOR + aggregate-arg), UNPIVOT is a NULL-skipping unfold; both attach as a postfix FROM-source wrapper on the derived-table `LateralPlan` seam → [`pivot.md`](docs/claude/pivot.md).
 - **UPDATE / DELETE / INSERT…SELECT / SELECT…INTO / rowversion** (`@@DBTS` / `MIN_ACTIVE_ROWVERSION`) **/ identity helpers** (`@@IDENTITY` / `SCOPE_IDENTITY` / `IDENT_CURRENT`/`_INCR`/`_SEED`) **/ `@@ROWCOUNT` / `ROWCOUNT_BIG` / OUTPUT / MERGE** → [`dml.md`](docs/claude/dml.md).
 - **Variables, control flow (IF/WHILE/BREAK/CONTINUE/RETURN), TRY/CATCH+THROW+ERROR_*, `@@ERROR` / `@@TRANCOUNT` / `XACT_STATE`, PRINT, WAITFOR** → [`control-flow.md`](docs/claude/control-flow.md).
+- **Error diagnostics** — `SimulatedSqlException` / `SimulatedError` line number (statement-start for runtime/bind, token line for syntax, CREATE-relative for proc bodies), `Server` (= data source), schema-qualified `Procedure`; `ERROR_LINE` / `ERROR_PROCEDURE` parity; TDS ERROR/INFO token server field (`SIMULATED`) → [`errors.md`](docs/claude/errors.md).
 - **Cursors** (`DECLARE … CURSOR` / `OPEN` / `FETCH` / `CLOSE` / `DEALLOCATE`, STATIC / KEYSET / DYNAMIC sensitivity, scroll fetches, `@@FETCH_STATUS` / `@@CURSOR_ROWS` / `CURSOR_STATUS`, `WHERE CURRENT OF`; GLOBAL / LOCAL scope + scope-aware resolution, cursor variables (`DECLARE @c CURSOR` / `SET @c = CURSOR …` refcounted, cursor OUTPUT proc params), `FOR UPDATE OF` gating (Msg 16932), SCROLL_LOCKS cursor-scoped U locks + OPTIMISTIC conflict detection (Msg 16947/16934), TYPE_WARNING (Msg 16956)) → [`cursors.md`](docs/claude/cursors.md).
 - **CTE shapes / recursive-CTE error handling** → [`ctes.md`](docs/claude/ctes.md).
 - **JSON** (JSON_VALUE / JSON_QUERY / JSON_MODIFY / JSON_OBJECT / JSON_ARRAY / JSON_OBJECTAGG / JSON_ARRAYAGG / JSON_PATH_EXISTS / ISJSON / OPENJSON) → [`json.md`](docs/claude/json.md).

SqlServerSimulator.Tests.SqlClient/ErrorSurfaceTests.cs

@@ -97,6 +97,25 @@ public async Task AfterError_SameConnection_StillExecutes()
         AreEqual(1, await ok.ExecuteScalarAsync(TestContext.CancellationToken));
     }
 
+    [TestMethod]
+    public async Task Error_CarriesBatchRelativeLineNumber()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        var ex = await Assert.ThrowsAsync<SqlException>(async () =>
+        {
+            await using var command = new SqlCommand("declare @x int\nset @x = 1 / 0", connection);
+            _ = await command.ExecuteNonQueryAsync(TestContext.CancellationToken);
+        });
+
+        // The failing SET is the batch's second line; the wire ERROR token
+        // carries that line and SqlClient surfaces it on LineNumber.
+        AreEqual(2, ex.LineNumber);
+        AreEqual(2, ex.Errors[0].LineNumber);
+    }
+
     [TestMethod]
     public async Task MissingTable_Number208()
     {

SqlServerSimulator.Tests.SqlClient/InfoMessageTests.cs

@@ -52,6 +52,31 @@ public async Task RaiseError_LowSeverity_ArrivesAsInfoMessage()
         Contains("warn", messages);
     }
 
+    [TestMethod]
+    public async Task Print_InfoToken_CarriesBatchRelativeLineNumber()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+        var lines = new List<int>();
+        connection.InfoMessage += (_, e) =>
+        {
+            foreach (SqlError error in e.Errors)
+                lines.Add(error.LineNumber);
+        };
+
+        await using var command = new SqlCommand("select 1\nprint 'hello'", connection);
+        await using (var reader = await command.ExecuteReaderAsync(TestContext.CancellationToken))
+        {
+            while (await reader.NextResultAsync(TestContext.CancellationToken))
+            {
+            }
+        }
+
+        // PRINT is the batch's second line; the INFO token carries that line.
+        AreEqual(2, lines.Single());
+    }
+
     // The go-sqlcmd shakedown (2026-07-14) exposed a token-stream desync when
     // an INFO token shares a SQLBatch response with a result set: SqlClient
     // hung until command timeout on every mixed shape below (go-mssqldb

SqlServerSimulator.Tests/ErrorDiagnosticsTests.cs

@@ -0,0 +1,114 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Line-number, server-name, and procedure attribution on
+/// <see cref="SimulatedSqlException"/>, mirroring the values real SqlClient
+/// surfaces (probe-confirmed against SQL Server 2025, 2026-07-18). Semantics:
+/// runtime / bind errors report the failing statement's start line, syntax
+/// errors (severity 15) report the offending token's line, procedure-body
+/// errors report a line relative to the whole <c>CREATE</c> statement plus the
+/// schema-qualified procedure name, and dynamic SQL reports a line relative to
+/// the dynamic batch. <see cref="SimulatedError.Server"/> matches the
+/// connection data source (real <c>SqlException.Server</c> carries the data
+/// source, not <c>@@SERVERNAME</c>). See <c>docs/claude/errors.md</c>.
+/// </summary>
+[TestClass]
+public sealed class ErrorDiagnosticsTests
+{
+    [TestMethod]
+    public void RuntimeError_ReportsFailingStatementStartLine()
+        => AreEqual(2, new Simulation().AssertSqlError("declare @x int\nset @x = 1 / 0", 8134).LineNumber);
+
+    /// <summary>
+    /// The SET spans lines 2-3; the divide-by-zero token sits on line 3, but
+    /// the reported line is the statement start (line 2), matching real.
+    /// </summary>
+    [TestMethod]
+    public void RuntimeError_SpanningLines_ReportsStatementStartNotExpressionLine()
+        => AreEqual(2, new Simulation().AssertSqlError("declare @x int\nset @x =\n 1 / 0", 8134).LineNumber);
+
+    [TestMethod]
+    public void BindError_MissingTable_ReportsStatementStartLine()
+        => AreEqual(2, new Simulation().AssertSqlError("declare @x int\nselect * from no_such_table_xyz", 208).LineNumber);
+
+    [TestMethod]
+    public void ConstraintViolation_ReportsFailingInsertLine()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int primary key); insert t values (1)");
+        AreEqual(2, sim.AssertSqlError("declare @x int\ninsert t values (1)", 2627).LineNumber);
+    }
+
+    /// <summary>
+    /// Severity-15 syntax errors report the token line, not the statement
+    /// start: the batch's first statement is on line 1, the bad token on 2.
+    /// </summary>
+    [TestMethod]
+    public void SyntaxError_ReportsOffendingTokenLine()
+        => AreEqual(2, new Simulation().AssertSqlError("declare @x int\nselect )", 102).LineNumber);
+
+    [TestMethod]
+    public void Error_ServerMatchesConnectionDataSource()
+    {
+        var sim = new Simulation();
+        using var connection = sim.CreateDbConnection();
+        var ex = sim.AssertSqlError("select 1 / 0", 8134);
+        AreEqual(connection.DataSource, ex.Server);
+        AreEqual(connection.DataSource, ex.Errors[0].Server);
+    }
+
+    [TestMethod]
+    public void TopLevelError_HasNoProcedure()
+        => IsEmpty(new Simulation().AssertSqlError("select 1 / 0", 8134).Procedure);
+
+    [TestMethod]
+    public void ProcedureBodyError_ReportsCreateRelativeLineAndQualifiedName()
+    {
+        var sim = new Simulation();
+        sim.ExecuteBatches("create procedure dbo.p_boom as\nbegin\n declare @x int\n set @x = 1 / 0\nend");
+        var ex = sim.AssertSqlError("exec dbo.p_boom", 8134);
+        // CREATE line 1, BEGIN line 2, DECLARE line 3, failing SET line 4.
+        AreEqual(4, ex.LineNumber);
+        AreEqual("dbo.p_boom", ex.Procedure);
+    }
+
+    [TestMethod]
+    public void NestedProcedureError_ReportsInnermostFrame()
+    {
+        var sim = new Simulation();
+        sim.ExecuteBatches(
+            "create procedure dbo.inner_boom as\nbegin\n declare @x int\n set @x = 1 / 0\nend",
+            "create procedure dbo.outer_p as\nbegin\n exec dbo.inner_boom\nend");
+        var ex = sim.AssertSqlError("exec dbo.outer_p", 8134);
+        AreEqual("dbo.inner_boom", ex.Procedure);
+        AreEqual(4, ex.LineNumber);
+    }
+
+    [TestMethod]
+    public void DynamicSql_ReportsLineRelativeToDynamicBatch_NoProcedure()
+    {
+        var ex = new Simulation().AssertSqlError("exec('declare @x int\nset @x = 1 / 0')", 8134);
+        AreEqual(2, ex.LineNumber);
+        IsEmpty(ex.Procedure);
+    }
+
+    [TestMethod]
+    public void ThrowValueForm_ReportsThrowStatementLine()
+    {
+        var ex = new Simulation().AssertSqlError("declare @x int\nthrow 51000, N'boom', 1", 51000);
+        AreEqual(2, ex.LineNumber);
+    }
+
+    [TestMethod]
+    public void ThrowReRaise_PreservesOriginalErrorLine()
+    {
+        // A bare THROW; re-raising a divide-by-zero from line 3 preserves that
+        // line rather than reporting the THROW's own line (probe-confirmed).
+        var ex = new Simulation().AssertSqlError(
+            "declare @x int\nbegin try\n set @x = 1 / 0\nend try\nbegin catch\n throw\nend catch",
+            8134);
+        AreEqual(3, ex.LineNumber);
+    }
+}

SqlServerSimulator.Tests/TryCatchTests.cs

@@ -74,11 +74,25 @@ public void ErrorLine_SingleLineBatch_Returns1()
         => AreEqual(1, new Simulation().ExecuteScalar(
             "begin try select cast('abc' as int) end try begin catch select error_line() end catch"));
 
-    // ERROR_LINE multi-line fidelity: line tracking is approximate (uses
-    // the dispatching statement's start-line token); some constant-folded
-    // expressions can throw at a position the dispatch wrap doesn't see, so
-    // the line surfaces as 1. Acceptable approximation today — fix needs
-    // per-error line carry-through on SimulatedSqlException.
+    /// <summary>
+    /// The failing SET is on batch line 3; ERROR_LINE() reports it, not the
+    /// TRY / batch start.
+    /// </summary>
+    [TestMethod]
+    public void ErrorLine_MultiLineBatch_ReportsFailingStatementLine()
+        => AreEqual(3, new Simulation().ExecuteScalar(
+            "declare @x int\nbegin try\nset @x = cast('abc' as int)\nend try begin catch select error_line() end catch"));
+
+    [TestMethod]
+    public void ErrorLine_MatchesExceptionLineNumber()
+    {
+        // ERROR_LINE() reports the same line the surfaced exception carries.
+        var sim = new Simulation();
+        var caught = sim.AssertSqlError("declare @x int\nset @x = cast('abc' as int)", 245);
+        AreEqual(2, caught.LineNumber);
+        AreEqual(2, sim.ExecuteScalar(
+            "declare @x int\nbegin try set @x = cast('abc' as int) end try begin catch select error_line() end catch"));
+    }
 
     [TestMethod]
     public void ErrorProcedure_OutsideProc_ReturnsNull()

SqlServerSimulator/Errors/SimulatedSqlException.SyntaxErrors.cs

@@ -287,6 +287,22 @@ internal static SimulatedSqlException ThrowMustBeInsideCatch() =>
     internal static SimulatedSqlException ThrowRaised(int number, string message, byte state) =>
         new(message, number, 16, state) { TerminatesBatch = true };
 
+    /// <summary>
+    /// The no-argument <c>THROW;</c> re-raise form, reconstructed from the
+    /// enclosing CATCH's in-flight error. Unlike the value form, real SQL
+    /// Server preserves the <em>original</em> error's line and procedure
+    /// (probe-confirmed: a <c>THROW;</c> re-raising a divide-by-zero from line
+    /// 2 still reports line 2, not the <c>THROW</c> statement's line), so this
+    /// pre-stamps them and marks the exception resolved to keep the enclosing
+    /// dispatch frame from overwriting with the <c>THROW</c> statement's line.
+    /// </summary>
+    internal static SimulatedSqlException ThrowReRaised(int number, string message, byte state, int line, string? procedure)
+    {
+        var exception = new SimulatedSqlException(message, number, 16, state) { TerminatesBatch = true };
+        exception.PreserveDiagnostics(line, procedure);
+        return exception;
+    }
+
     /// <summary>
     /// Mimics SQL Server error 2787: a <c>RAISERROR</c> format string contains
     /// a specifier the runtime doesn't accept. Real SQL Server's RAISERROR

SqlServerSimulator/Errors/SimulatedSqlException.cs

@@ -36,7 +36,7 @@ public sealed partial class SimulatedSqlException : DbException
     private const string SourceName = "Core Microsoft SqlClient Data Provider";
 
     private SimulatedSqlException(string message, int number, byte @class, byte state)
-        : this(message, new SimulatedError(@class, lineNumber: 0, message, number, procedure: "", server: "", source: SourceName, state))
+        : this(message, new SimulatedError(@class, lineNumber: 0, message, number, procedure: "", server: SimulatedDbConnection.DataSourceName, source: SourceName, state))
     {
     }
 
@@ -49,7 +49,7 @@ private SimulatedSqlException(string message, params ReadOnlySpan<SimulatedError
         SimulatedError first;
         if (errors.Length == 0)
         {
-            first = new SimulatedError(@class: 0, lineNumber: 0, base.Message, number: 0, procedure: "", server: "", source: SourceName, state: 0);
+            first = new SimulatedError(@class: 0, lineNumber: 0, base.Message, number: 0, procedure: "", server: SimulatedDbConnection.DataSourceName, source: SourceName, state: 0);
             this.Errors = new SimulatedErrorCollection([first]);
         }
         else
@@ -118,6 +118,70 @@ private SimulatedSqlException(string message, params ReadOnlySpan<SimulatedError
     /// </summary>
     internal bool TerminatesBatch { get; private init; }
 
+    /// <summary>
+    /// Guards <see cref="ResolveDiagnostics"/> against re-stamping. An error
+    /// born inside a nested body (procedure / dynamic-SQL batch) is resolved at
+    /// its own dispatch frame's catch boundary; as it propagates outward each
+    /// enclosing frame must leave the already-resolved line / procedure alone.
+    /// </summary>
+    private bool diagnosticsResolved;
+
+    /// <summary>
+    /// Pre-stamps a known line / procedure and marks this exception resolved so
+    /// the enclosing dispatch frame's <see cref="ResolveDiagnostics"/> leaves
+    /// it untouched. Used by the <c>THROW;</c> re-raise, which carries the
+    /// original error's captured line rather than the re-raising statement's.
+    /// </summary>
+    internal void PreserveDiagnostics(int line, string? procedure)
+    {
+        this.diagnosticsResolved = true;
+        foreach (var error in this.Errors)
+        {
+            error.LineNumber = line;
+            if (procedure is { Length: > 0 } && error.Procedure.Length == 0)
+                error.Procedure = procedure;
+        }
+    }
+
+    /// <summary>
+    /// Stamps the batch-relative line, server, and enclosing-procedure context
+    /// onto this exception's <see cref="Errors"/> the first time an enclosing
+    /// dispatch frame catches it — the ambient-capture point the static error
+    /// factories can't reach. Runs once (subsequent enclosing frames no-op via
+    /// <see cref="diagnosticsResolved"/>), so the innermost frame — where the
+    /// error was actually born — wins, matching SQL Server's innermost-frame
+    /// attribution for nested procedure calls (probe-confirmed).
+    /// </summary>
+    /// <param name="baseLine">
+    /// The line to attribute when an error carries none of its own: the failing
+    /// statement's start line for runtime / bind errors, or the parser's
+    /// current-token line for syntax errors (severity 15). An error that
+    /// already carries a line (a re-raised <c>THROW;</c> preserving the
+    /// original) keeps it.
+    /// </param>
+    /// <param name="lineOffset">
+    /// Newline count preceding a procedure body's start within its
+    /// <c>CREATE</c> text, added so a body error reports the line relative to
+    /// the whole definition (probe-confirmed). Zero for top-level and
+    /// dynamic-SQL batches.
+    /// </param>
+    /// <param name="procedure">
+    /// Schema-qualified name of the enclosing procedure body, or empty for
+    /// top-level / dynamic-SQL batches.
+    /// </param>
+    internal void ResolveDiagnostics(int baseLine, int lineOffset, string procedure)
+    {
+        if (this.diagnosticsResolved)
+            return;
+        this.diagnosticsResolved = true;
+        foreach (var error in this.Errors)
+        {
+            error.LineNumber = (error.LineNumber == 0 ? baseLine : error.LineNumber) + lineOffset;
+            if (procedure.Length != 0 && error.Procedure.Length == 0)
+                error.Procedure = procedure;
+        }
+    }
+
     /// <summary>
     /// Aggregates the errors gathered while draining a batch to completion
     /// into a single exception, mirroring how real SqlClient surfaces every

SqlServerSimulator/Network/TdsSession.Cursors.cs

@@ -213,7 +213,7 @@ private void OpenAndAnnounce(
         {
             _ = connection.Cursors.Remove(name);
             foreach (var error in ex.Errors)
-                writer.WriteErrorOrInfo(Tds.TokenError, error.Number, error.State, error.Class, error.Message, error.Server, error.Procedure, error.LineNumber);
+                writer.WriteErrorOrInfo(Tds.TokenError, error.Number, error.State, error.Class, error.Message, TdsSession.ServerName, error.Procedure, error.LineNumber);
             writer.WriteErrorOrInfo(Tds.TokenError, 16945, 2, 16, "The cursor was not declared.", "SIMULATED", "", 1);
 
             // Echo the requested option values; the handle comes back zero.
@@ -373,7 +373,7 @@ private void CursorOp(TdsRpcRequest request, TdsTokenWriter writer, bool moreReq
         catch (SimulatedSqlException ex)
         {
             foreach (var error in ex.Errors)
-                writer.WriteErrorOrInfo(Tds.TokenError, error.Number, error.State, error.Class, error.Message, error.Server, error.Procedure, error.LineNumber);
+                writer.WriteErrorOrInfo(Tds.TokenError, error.Number, error.State, error.Class, error.Message, TdsSession.ServerName, error.Procedure, error.LineNumber);
             writer.WriteReturnStatus(ex.Errors[0].Number);
             this.CompleteCursorRpc(writer, moreRequests, error: true);
             return;

SqlServerSimulator/Network/TdsSession.cs

@@ -393,13 +393,23 @@ private void ResetConnection()
         this.connection = fresh;
     }
 
+    /// <summary>
+    /// The server-name field carried by every ERROR / INFO token — the
+    /// server's own name (<c>@@SERVERNAME</c> / <c>SERVERPROPERTY('ServerName')</c>),
+    /// which a real SQL Server writes into these tokens and which token-rendering
+    /// clients (sqlcmd) display. Distinct from <see cref="SimulatedError.Server"/>
+    /// (the connection data source that SqlClient surfaces on
+    /// <c>SqlException.Server</c>); SqlClient ignores this token field.
+    /// </summary>
+    internal const string ServerName = "SIMULATED";
+
     /// <summary>Writes all queued info messages as INFO tokens; true when any were written.</summary>
     private bool FlushInfoMessages(TdsTokenWriter writer)
     {
         var any = false;
         while (this.pendingInfoMessages.TryDequeue(out var error))
         {
-            writer.WriteErrorOrInfo(Tds.TokenInfo, error.Number, error.State, error.Class, error.Message, error.Server, error.Procedure, error.LineNumber);
+            writer.WriteErrorOrInfo(Tds.TokenInfo, error.Number, error.State, error.Class, error.Message, ServerName, error.Procedure, error.LineNumber);
             any = true;
         }
 
@@ -409,7 +419,7 @@ private bool FlushInfoMessages(TdsTokenWriter writer)
     private static void WriteErrors(TdsTokenWriter writer, SimulatedSqlException exception)
     {
         foreach (var error in exception.Errors)
-            writer.WriteErrorOrInfo(Tds.TokenError, error.Number, error.State, error.Class, error.Message, error.Server, error.Procedure, error.LineNumber);
+            writer.WriteErrorOrInfo(Tds.TokenError, error.Number, error.State, error.Class, error.Message, ServerName, error.Procedure, error.LineNumber);
     }
 
     /// <summary>Skips the ALL_HEADERS section and decodes the UCS-2 batch text.</summary>