feat(kernel): R7b C# walker — csharp module, tree-sitter-c-sharp 0.23.5 pin, csharp default-routed (#1378)

Second R7b port, checklist-first recipe (docs/design/csharp-kernel-port-checklist.md; parity passed FIRST RUN again). No grammar bump — the #717 vendored wasm verified table-identical to crate 0.23.5 (ABI 15, STATE_COUNT 8053, node-kind + field tables); first port with no grammar-prep step. The #237 #if-blanking preParse stays TS-side via the existing route-point hoist. Walker preserves bug-for-bug: the single-namespace-node quirks (second namespace nests under the first, nested namespaces leave no trace, import refs hang off the namespace node), raw member-access callee texts (this./base./literal receivers, multi-line fluent chains) with unconditional chain re-encode, deliberate emission holes (property accessor/expression bodies, ctor initializers, delegates/events/ operators/indexers/local functions, top-level locals), garbage extends refs ((repo) primary-ctor args, BaseDto(Name) record bases, enum : byte), the alias- import moduleName quirks, nameof-as-call, CSHARP fn-ref spec (+= subscription, this.X bare-name form, argument layer, initializer lists), C# type-ref engine (nested-generic returnType failure included), and value-ref shadow pruning. Gates: sweeps 0-diff serilog 211/216 / Newtonsoft.Json 914/945 / jellyfin 2104/2105 (deferrals match the survey's per-repo predictions — both-arm #if damage; default --max-deferral 0.1 holds, no c/cpp exemption); full-init dumps byte-identical ×3 (14.0k/109.1k/210.8k lines); kernel-csharp-parity suite (torture ×3 + CRLF variants + 8 micro-pins + defer) + csharp grammar-parity row; full suite 2,608 ×2 under CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += csharp (11 langs). Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-07-20 13:46:12 -05:00
parent f1ca991943
commit 286e9ccc2d
15 changed files with 2890 additions and 6 deletions
@@ -0,0 +1,181 @@
+#define TORTURE_FLAG
+global using GlobalNs.Thing;
+using System;
+using System.Collections.Generic;
+using static System.Math;
+
+namespace Torture.Alpha
+{
+    using System.Text;
+
+    namespace Inner
+    {
+        public class Deep { }
+    }
+
+    /// <summary>Doc line.</summary>
+    /// <remarks>Second doc line over an attribute.</remarks>
+    [Serializable]
+    public class TortureClass : Widget
+    {
+#pragma warning disable 168
+        public const int MaxItems = 10;
+        public static readonly string DefaultName = "x";
+        private const int LOCAL_SHADOWED = 5;
+        private Widget A, B;
+        private readonly int _count;
+        private static int counter;
+        private IRepo _repo;
+        private ServiceCollection builder;
+        private int status;
+        private List<Action<int>> Table = new() { TargetCb };
+
+#nullable enable
+        public string Name { get; set; }
+        public Widget Parent { get; init; }
+        public List<Widget> Items { get; }
+        public int Computed => MaxItems + 1;
+        public Widget Made { get; } = new();
+        public int Accessored { get { return Lookup(1); } set { Store(value); } }
+        public Action A2 { get; } = () => Register(HandleThing);
+
+        public event Action Changed;
+        public event Action Custom
+        {
+            add { Register(HandleThing); }
+            remove { Unregister(value); }
+        }
+
+        public static TortureClass operator +(TortureClass a, TortureClass b) { return Combine(a, b); }
+        public static explicit operator int(TortureClass t) { return Score(t); }
+        public int this[int idx] { get { return Lookup(idx); } }
+        ~TortureClass() { Cleanup(); }
+
+        public TortureClass(int seed) : base(Compute(seed)) { Init(seed); }
+        public TortureClass() => Init(0);
+
+        void IDisposable.Dispose() { Cleanup(); }
+
+        protected internal void PI() { }
+        private protected void PP() { }
+
+        public async Task Waity() { await Task.Delay(1); }
+
+        public int Sum() => Compute(1) + 2;
+
+        private void HandleThing(int v) { }
+        private static void StaticHandler() { }
+        private void OnClick() { }
+        private void Handler() { }
+        private static void TargetCb(int n) { }
+        private static int Compute(int v) { return v; }
+        private static Widget Mk() { return null; }
+
+        public void Wire(Widget button, int status)
+        {
+            Register(HandleThing);
+            Register(this.HandleThing);
+            Register(C.StaticHandler);
+            button.Click += OnClick;
+            this.status = status;
+            Del d = Handler;
+            Action g = () => Register(HandleThing);
+        }
+
+        public void CallsZoo(Widget p, MyDel myDel, HttpRequest request)
+        {
+            Helper();
+            Generic<int>(5);
+            this.Run(1);
+            base.Method();
+            _repo.Save(2);
+            var svcs = builder
+                .Services
+                .AddSingleton<IRepo, Repo>();
+            "lit".ToUpper();
+            request?.Method();
+            p!.Force();
+            Foo.Create(1).Bar();
+            GetThing().Bar();
+            (myDel)(3);
+            var n = nameof(Widget);
+        }
+
+        public void Reads(User u)
+        {
+            DoThing(Constants.MAX);
+            var x = ReadType.ReadAsDouble;
+            var y = Outer.Inner.DEEP;
+            var age = u.Age;
+            Console.WriteLine(x);
+        }
+
+        public void News()
+        {
+            var a = new Widget(1) { Name = Mk() };
+            var b = new Ns.Foo<int>();
+            Widget c = new();
+            var d = new { X = 1 };
+            var e = new Widget[10];
+            var f = new[] { Mk() };
+        }
+
+        public IEnumerable<int> Query(List<int> items)
+        {
+            var q = from x in items where Check(x) select Map(x);
+            var s = items.Count switch { 0 => One(), _ => Other() };
+            var msg = $"Hello {NameOf(this)}";
+            var raw = """raw text""";
+            var verb = @"verbatim\path";
+            int[] coll = [First(), Second()];
+            return q;
+        }
+
+        public int WithLocal()
+        {
+            int Local(int v) { return Compute(v); }
+            return Local(2);
+        }
+
+        public Task<List<Widget>> Fetch(Widget? maybe, Widget[] arr, (int Code, Widget Payload) pair, List<Widget> list, Sys.ICloneable c, dynamic dyn, String s, int nn) { return null; }
+        public Task<Widget> Single() { return null; }
+        public Ns.Foo Qual() { return null; }
+
+        public int Reader()
+        {
+            var LOCAL_SHADOWED = 1;
+            return MaxItems + LOCAL_SHADOWED;
+        }
+
+        public string Reader2() => DefaultName.Trim();
+    }
+
+    public class Client : ClientBase<Widget>, Sys.ICloneable, IThing { }
+
+    public partial class PartialHost { partial void Hook(); }
+    public partial class PartialHost { partial void Hook() { } }
+
+    public interface IWidgetRepo<T> where T : IEntity
+    {
+        Task<T> Get(int id);
+        string Label { get; }
+        int Compute(int x) => x + 1;
+    }
+
+    public enum ReadType : byte
+    {
+        [Obsolete] ReadAsInt = 1,
+        ReadAsDouble,
+    }
+
+    public struct Point3 { public int X; }
+
+    #region grouped
+    public class Grouped { }
+    #endregion
+}
+
+namespace Torture.Beta
+{
+    public class Other { }
+}
@@ -0,0 +1,24 @@
+using Coll = System.Collections.Generic.Dictionary<string, int>;
+using Short = SomeType;
+using System;
+
+namespace Torture.Scoped;
+
+/// <summary>A positional record with base args.</summary>
+public record UserDto(string Name, int Age) : BaseDto(Name), IThing;
+
+public readonly record struct Money(decimal Amount);
+
+public record struct Pointish(int X, int Y);
+
+public record Empty;
+
+public record Bodied(string Label) : BaseDto(Label)
+{
+    public string Loud() { return Shout(Label); }
+}
+
+public class Svc(IRepo repo, ICache cache) : Base(repo), IThing
+{
+    public void Go() { repo.Save(1); }
+}
@@ -0,0 +1,13 @@
+using System;
+
+var builder = CreateBuilder(args);
+Run(builder);
+var w = new Widget();
+DoWork(w);
+int Helper(int x) => Compute(x);
+Helper(3);
+
+partial class Program
+{
+    static void Main2() { Console.WriteLine("hi"); }
+}