From c7c951153140dd1c9321d6668b88e3ef253d05bf Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Wed, 8 Jul 2026 23:49:57 -0700
Subject: [PATCH 01/11] =?UTF-8?q?feat(types):=20#99=20seam=20=E2=80=94=20r?=
 =?UTF-8?q?esolve=20ambient=20lib=20types=20(Symbol,=20SymbolConstructor)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

First increment of #99 (lib.d.ts modeling), seam-first: a single TryResolveLibType
switch, consulted by both ResolveTypeNameCore (for the type) and ReportUnknownTypeName
(so the name isn't flagged TS2304), resolves TYPE-position lib names SharpTS doesn't
yet parse from the vendored .d.ts files. Checked AFTER user declarations so a user
interface of the same name wins. A later increment backs this switch with a real
lib.d.ts loader.

Covers the Symbol family: SymbolConstructor -> the existing WellKnownSymbolTypes shape;
Symbol -> a new member-less wrapper interface (a symbol value is assignable to it, but
it is not assignable back to the symbol primitive). Flips symbolProperty55, symbolType15.
---
 TypeSystem/TypeChecker.Statements.cs  |  2 ++
 TypeSystem/TypeChecker.TypeParsing.cs | 22 ++++++++++++++++++++++
 TypeSystem/WellKnownSymbolTypes.cs    | 13 +++++++++++++
 3 files changed, 37 insertions(+)

diff --git a/TypeSystem/TypeChecker.Statements.cs b/TypeSystem/TypeChecker.Statements.cs
index 584a9e9f..dbcbcb62 100644
--- a/TypeSystem/TypeChecker.Statements.cs
+++ b/TypeSystem/TypeChecker.Statements.cs
@@ -297,6 +297,8 @@ private void ReportUnknownTypeName(string? annotation, TypeNode? annotationNode,
         if (_environment.GetTypeAlias(name) is not null) return;
         if (_environment.GetGenericTypeAlias(name) is not null) return;
         if (_openTypeVariablesInScope?.Contains(name) == true) return;
+        // #99 lib-type seam: an ambient lib.d.ts type name (e.g. Symbol/SymbolConstructor) is known.
+        if (TryResolveLibType(name) is not null) return;
 
         throw new TypeCheckException($" Cannot find name '{name}'.", line, tsCode: "TS2304");
     }
diff --git a/TypeSystem/TypeChecker.TypeParsing.cs b/TypeSystem/TypeChecker.TypeParsing.cs
index 09b176b5..98ff9e89 100644
--- a/TypeSystem/TypeChecker.TypeParsing.cs
+++ b/TypeSystem/TypeChecker.TypeParsing.cs
@@ -232,9 +232,31 @@ private TypeInfo ResolveTypeNameCore(string typeName)
             return enumType;
         }
 
+        // #99 lib-type seam: ambient lib.d.ts TYPE-position names SharpTS doesn't load from the
+        // .d.ts files yet (checked AFTER user declarations above, so a user interface of the same
+        // name wins). A later increment backs this with a real lib.d.ts loader.
+        if (TryResolveLibType(typeName) is { } libType)
+        {
+            return libType;
+        }
+
         return new TypeInfo.Any();
     }
 
+    /// <summary>
+    /// The #99 lib-type seam: resolves the ambient TYPE-position names that lib.d.ts declares but
+    /// SharpTS doesn't yet parse from the vendored .d.ts files, to their modeled <see cref="TypeInfo"/>.
+    /// Consulted by both <see cref="ResolveTypeNameCore"/> (for the type) and
+    /// <c>ReportUnknownTypeName</c> (so these names aren't flagged TS2304). Increment 1 covers the
+    /// Symbol family; a later increment replaces this switch with content loaded from lib.d.ts.
+    /// </summary>
+    private static TypeInfo? TryResolveLibType(string name) => name switch
+    {
+        "SymbolConstructor" => WellKnownSymbolTypes.SymbolConstructor,
+        "Symbol" => WellKnownSymbolTypes.SymbolWrapper,
+        _ => null
+    };
+
     /// <summary>
     /// Simplifies an intersection type according to TypeScript semantics:
     /// - Conflicting primitives (string &amp; number) = never
diff --git a/TypeSystem/WellKnownSymbolTypes.cs b/TypeSystem/WellKnownSymbolTypes.cs
index ef7333fd..7a700d60 100644
--- a/TypeSystem/WellKnownSymbolTypes.cs
+++ b/TypeSystem/WellKnownSymbolTypes.cs
@@ -74,6 +74,19 @@ public static class WellKnownSymbolTypes
     /// CheckGet) before generic member lookup ever consults this type, so adding it here doesn't
     /// change those paths — only genuine "use Symbol as a plain value" sites.
     /// </summary>
+    /// <summary>
+    /// The global `Symbol` WRAPPER object type (lib's `interface Symbol`), as it appears in TYPE
+    /// position (`var s: Symbol`). Distinct from the `symbol` primitive: a `symbol` value IS
+    /// assignable to this wrapper (an object-like target — the wrapper is modeled member-less so a
+    /// symbol satisfies it without SharpTS having to model symbol's apparent toString/valueOf), but
+    /// the wrapper is NOT assignable back to the `symbol` primitive (TS2322 "'symbol' is a primitive,
+    /// but 'Symbol' is a wrapper object").
+    /// </summary>
+    public static readonly TypeInfo.Interface SymbolWrapper = new(
+        "Symbol",
+        FrozenDictionary<string, TypeInfo>.Empty,
+        FrozenSet<string>.Empty);
+
     public static readonly TypeInfo.Interface SymbolConstructor = new(
         "SymbolConstructor",
         new Dictionary<string, TypeInfo>

From b189af24993d35c4c6512437489f4ca33b9a5b1c Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Wed, 8 Jul 2026 23:49:57 -0700
Subject: [PATCH 02/11] =?UTF-8?q?test(conformance):=20update=20baseline=20?=
 =?UTF-8?q?=E2=80=94=20symbolProperty55=20+=20symbolType15=20now=20pass?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 SharpTS.TypeScriptConformance/baselines/interpreted.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/SharpTS.TypeScriptConformance/baselines/interpreted.txt b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
index a9f1658e..f5cd1bf7 100644
--- a/SharpTS.TypeScriptConformance/baselines/interpreted.txt
+++ b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
@@ -132,7 +132,7 @@ tests/cases/conformance/es6/Symbols/symbolProperty51.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty52.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty53.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty54.ts Pass
-tests/cases/conformance/es6/Symbols/symbolProperty55.ts Fail
+tests/cases/conformance/es6/Symbols/symbolProperty55.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty56.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty57.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty58.ts Pass
@@ -149,7 +149,7 @@ tests/cases/conformance/es6/Symbols/symbolType11.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType12.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType13.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType14.ts Pass
-tests/cases/conformance/es6/Symbols/symbolType15.ts Fail
+tests/cases/conformance/es6/Symbols/symbolType15.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType16.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType17.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType18.ts Pass

From 3be1b33ef0850f7190f2090d1822843a0f08f99a Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 00:50:52 -0700
Subject: [PATCH 03/11] =?UTF-8?q?feat(types):=20#99=20incr=202a=20?=
 =?UTF-8?q?=E2=80=94=20lib.d.ts=20loader=20(parse=20embedded=20lib=20->=20?=
 =?UTF-8?q?TypeInfo)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The real-loader foundation for #99 increment 2. LibTypeLoader parses ambient lib
declarations embedded as libdefs/*.d.ts resources (the vendored TypeScript lib is a
dev-only submodule, so it must be embedded to work at runtime) and resolves them to
modeled TypeInfo via a throwaway checker's new ExtractLibTypes (PreRegister into a
fresh env, diagnostics suppressed, extracted by name). Built once, cached process-wide.

TryResolveLibType now sources SymbolConstructor from the LOADED lib instead of a
hand-modeled shape (Symbol stays hand-modeled — the wrapper needs a member-less shape
a symbol can satisfy, which the loaded interface can't give until primitive apparent
members are modeled). No baseline change (symbolProperty55/symbolType15 still pass);
this is the pipeline that later increments fill from the real es5.d.ts + resolve the
primitive-vs-interface tension to flip the remaining lib tests.

Full xUnit 15452/0, conformance 252 Pass (0 regressions).
---
 SharpTS.csproj                        |  6 ++++
 TypeSystem/LibTypeLoader.cs           | 49 +++++++++++++++++++++++++++
 TypeSystem/TypeChecker.TypeParsing.cs | 16 ++++++---
 TypeSystem/TypeChecker.cs             | 24 +++++++++++++
 libdefs/lib.core.d.ts                 | 22 ++++++++++++
 5 files changed, 112 insertions(+), 5 deletions(-)
 create mode 100644 TypeSystem/LibTypeLoader.cs
 create mode 100644 libdefs/lib.core.d.ts

diff --git a/SharpTS.csproj b/SharpTS.csproj
index 4f53df48..e708acf1 100644
--- a/SharpTS.csproj
+++ b/SharpTS.csproj
@@ -44,6 +44,12 @@
     <None Remove="stdlib\**\*.ts" />
   </ItemGroup>
 
+  <!-- Ambient lib type declarations parsed by LibTypeLoader into the type checker (#99). -->
+  <ItemGroup>
+    <EmbeddedResource Include="libdefs\**\*.d.ts" />
+    <None Remove="libdefs\**\*.d.ts" />
+  </ItemGroup>
+
   <!-- Exclude test, example, benchmark, and SDK projects from this compilation.
        This list is hand-maintained and load-bearing: because this project sits at
        the repo root, the SDK's default **/*.cs glob would otherwise pull in every
diff --git a/TypeSystem/LibTypeLoader.cs b/TypeSystem/LibTypeLoader.cs
new file mode 100644
index 00000000..49173281
--- /dev/null
+++ b/TypeSystem/LibTypeLoader.cs
@@ -0,0 +1,49 @@
+using System.Collections.Frozen;
+using SharpTS.Parsing;
+
+namespace SharpTS.TypeSystem;
+
+/// <summary>
+/// #99 increment 2 — the lib.d.ts loader. Parses the ambient TypeScript lib declarations embedded as
+/// <c>libdefs/*.d.ts</c> resources and resolves them to modeled <see cref="TypeInfo"/>, so the type
+/// checker resolves lib names (e.g. <c>SymbolConstructor</c>) from real declarations instead of
+/// hand-modeled shapes. Built once and cached process-wide (the lib types are the same for every
+/// checker instance). A later increment expands the embedded sources toward the full vendored
+/// <c>external/typescript/src/lib/*.d.ts</c>.
+/// </summary>
+internal static class LibTypeLoader
+{
+    private static FrozenDictionary<string, TypeInfo>? _types;
+
+    /// <summary>Ambient lib type name → its resolved <see cref="TypeInfo"/>.</summary>
+    public static FrozenDictionary<string, TypeInfo> Types => _types ??= Build();
+
+    public static bool TryGet(string name, out TypeInfo type)
+    {
+        if (Types.TryGetValue(name, out var t)) { type = t; return true; }
+        type = null!;
+        return false;
+    }
+
+    private static FrozenDictionary<string, TypeInfo> Build()
+    {
+        var statements = new List<Stmt>();
+        var assembly = typeof(LibTypeLoader).Assembly;
+        foreach (var resourceName in assembly.GetManifestResourceNames())
+        {
+            if (!resourceName.Contains("libdefs") || !resourceName.EndsWith(".d.ts"))
+                continue;
+            using var stream = assembly.GetManifestResourceStream(resourceName);
+            if (stream is null) continue;
+            using var reader = new StreamReader(stream);
+            var parseResult = new Parser(new Lexer(reader.ReadToEnd()).ScanTokens()).Parse();
+            if (parseResult.IsSuccess)
+                statements.AddRange(parseResult.Statements);
+        }
+        // Resolve to TypeInfo via a throwaway checker; its diagnostics are discarded (lib sources are
+        // trusted). Empty-dict on any failure so a broken embed degrades to the prior hand-modeling.
+        return statements.Count > 0
+            ? new TypeChecker().ExtractLibTypes(statements)
+            : FrozenDictionary<string, TypeInfo>.Empty;
+    }
+}
diff --git a/TypeSystem/TypeChecker.TypeParsing.cs b/TypeSystem/TypeChecker.TypeParsing.cs
index 98ff9e89..59365f09 100644
--- a/TypeSystem/TypeChecker.TypeParsing.cs
+++ b/TypeSystem/TypeChecker.TypeParsing.cs
@@ -250,12 +250,18 @@ private TypeInfo ResolveTypeNameCore(string typeName)
     /// <c>ReportUnknownTypeName</c> (so these names aren't flagged TS2304). Increment 1 covers the
     /// Symbol family; a later increment replaces this switch with content loaded from lib.d.ts.
     /// </summary>
-    private static TypeInfo? TryResolveLibType(string name) => name switch
+    private static TypeInfo? TryResolveLibType(string name)
     {
-        "SymbolConstructor" => WellKnownSymbolTypes.SymbolConstructor,
-        "Symbol" => WellKnownSymbolTypes.SymbolWrapper,
-        _ => null
-    };
+        // Names loaded from the embedded lib.d.ts (e.g. SymbolConstructor) — the real declarations.
+        if (LibTypeLoader.TryGet(name, out var libType)) return libType;
+        // Names still hand-modeled (the wrapper types need behavior the loaded shape can't yet give —
+        // a symbol must satisfy `Symbol` without SharpTS modeling the primitive's apparent members).
+        return name switch
+        {
+            "Symbol" => WellKnownSymbolTypes.SymbolWrapper,
+            _ => null
+        };
+    }
 
     /// <summary>
     /// Simplifies an intersection type according to TypeScript semantics:
diff --git a/TypeSystem/TypeChecker.cs b/TypeSystem/TypeChecker.cs
index 723d880e..f699c63d 100644
--- a/TypeSystem/TypeChecker.cs
+++ b/TypeSystem/TypeChecker.cs
@@ -1035,6 +1035,30 @@ private bool IsLenientModule()
     /// Full validation happens later during CheckStmt.
     /// Note: Classes are NOT pre-registered to avoid breaking inheritance checking with MutableClass.
     /// </summary>
+    /// <summary>
+    /// #99: register a set of ambient lib declarations into this (throwaway) checker's environment and
+    /// return the resolved interfaces/type-aliases keyed by name. Diagnostics are suppressed — lib
+    /// sources are trusted. Used by <see cref="LibTypeLoader"/> to turn parsed <c>libdefs/*.d.ts</c>
+    /// into modeled <see cref="TypeInfo"/>. Interfaces reference each other through the environment
+    /// (pre-registered above), so no recursion back into the loader.
+    /// </summary>
+    internal System.Collections.Frozen.FrozenDictionary<string, TypeInfo> ExtractLibTypes(List<Stmt> statements)
+    {
+        _suppressDiagnostics++;
+        try
+        {
+            PreRegisterTypeDeclarations(statements);
+            var result = new Dictionary<string, TypeInfo>();
+            foreach (var stmt in statements)
+            {
+                if (stmt is Stmt.Interface itf && _environment.Get(itf.Name.Lexeme) is { } t)
+                    result[itf.Name.Lexeme] = t;
+            }
+            return result.ToFrozenDictionary();
+        }
+        finally { _suppressDiagnostics--; }
+    }
+
     private void PreRegisterTypeDeclarations(IEnumerable<Stmt> statements)
     {
         foreach (var stmt in statements)
diff --git a/libdefs/lib.core.d.ts b/libdefs/lib.core.d.ts
new file mode 100644
index 00000000..23f6e54a
--- /dev/null
+++ b/libdefs/lib.core.d.ts
@@ -0,0 +1,22 @@
+// Ambient lib type declarations loaded by LibTypeLoader (#99 increment 2). Embedded as a resource
+// so it is available at runtime — the full vendored TypeScript lib.d.ts is a dev-only submodule.
+// A faithful (member types simplified to `symbol` for now) subset, expanded toward the real
+// external/typescript/src/lib/*.d.ts in later #99 increments.
+
+interface SymbolConstructor {
+    readonly iterator: symbol;
+    readonly asyncIterator: symbol;
+    readonly hasInstance: symbol;
+    readonly isConcatSpreadable: symbol;
+    readonly match: symbol;
+    readonly matchAll: symbol;
+    readonly replace: symbol;
+    readonly search: symbol;
+    readonly species: symbol;
+    readonly split: symbol;
+    readonly toPrimitive: symbol;
+    readonly toStringTag: symbol;
+    readonly unscopables: symbol;
+    for(key: string): symbol;
+    keyFor(sym: symbol): string | undefined;
+}

From 51ac4e5ec660ee689acfa3820919cb810f356dea Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 01:18:01 -0700
Subject: [PATCH 04/11] =?UTF-8?q?feat(types):=20#99=20incr=202b=20?=
 =?UTF-8?q?=E2=80=94=20loaded=20lib=20wrapper=20interfaces=20for=20impleme?=
 =?UTF-8?q?nts/extends?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

First test flipped by the lib loader. A wrapper name (String/Number/Boolean)
resolves to the primitive in type position, so 'class C implements String' and
'interface I extends String' saw a non-interface and reported spurious TS2304/TS2312.
Now the implements and interface-extends resolution consult LibTypeLoader when the
name isn't a user interface, using the (currently member-less) lib wrapper interface
as a valid implements/extends target. 'var s: String' still resolves to the primitive,
so no assignability change there.

Flips stringLiteralTypeIsSubtypeOfString. Full xUnit 15452/0, conformance 253 Pass.
---
 TypeSystem/TypeChecker.Statements.Classes.cs    | 7 +++++++
 TypeSystem/TypeChecker.Statements.Interfaces.cs | 4 ++++
 libdefs/lib.core.d.ts                           | 9 +++++++++
 3 files changed, 20 insertions(+)

diff --git a/TypeSystem/TypeChecker.Statements.Classes.cs b/TypeSystem/TypeChecker.Statements.Classes.cs
index b13590aa..57407579 100644
--- a/TypeSystem/TypeChecker.Statements.Classes.cs
+++ b/TypeSystem/TypeChecker.Statements.Classes.cs
@@ -554,6 +554,13 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
                 var interfaceToken = classStmt.Interfaces[i];
                 TypeInfo? itfTypeInfo = _environment.Get(interfaceToken.Lexeme);
 
+                // #99: a lib wrapper type (`implements String`) resolves to the primitive in type
+                // position, not an interface — consult the loaded lib for a real interface so it's a
+                // valid implements target rather than a spurious "not an interface" (TS2304).
+                if (itfTypeInfo is not TypeInfo.Interface and not TypeInfo.GenericInterface
+                    && LibTypeLoader.TryGet(interfaceToken.Lexeme, out var libImplements))
+                    itfTypeInfo = libImplements;
+
                 // Get type arguments for this interface if provided
                 List<string>? typeArgs = classStmt.InterfaceTypeArgs != null && i < classStmt.InterfaceTypeArgs.Count
                     ? classStmt.InterfaceTypeArgs[i]
diff --git a/TypeSystem/TypeChecker.Statements.Interfaces.cs b/TypeSystem/TypeChecker.Statements.Interfaces.cs
index ad555789..b2c8877e 100644
--- a/TypeSystem/TypeChecker.Statements.Interfaces.cs
+++ b/TypeSystem/TypeChecker.Statements.Interfaces.cs
@@ -396,6 +396,10 @@ private void CheckInterfaceDeclaration(Stmt.Interface interfaceStmt)
                 var extendType = ResolveAnnotation(
                     extendTypeName,
                     interfaceStmt.ExtendsNodes != null && i < interfaceStmt.ExtendsNodes.Count ? interfaceStmt.ExtendsNodes[i] : null)!;
+                // #99: `interface I extends String` — the wrapper name resolves to the primitive; use
+                // the loaded lib interface so it's a valid extends target (not a spurious TS2312).
+                if (extendType is not TypeInfo.Interface && LibTypeLoader.TryGet(extendTypeName, out var libExtends))
+                    extendType = libExtends;
                 if (extendType is TypeInfo.Interface extendInterface)
                 {
                     extendsList.Add(extendInterface);
diff --git a/libdefs/lib.core.d.ts b/libdefs/lib.core.d.ts
index 23f6e54a..55588e46 100644
--- a/libdefs/lib.core.d.ts
+++ b/libdefs/lib.core.d.ts
@@ -3,6 +3,15 @@
 // A faithful (member types simplified to `symbol` for now) subset, expanded toward the real
 // external/typescript/src/lib/*.d.ts in later #99 increments.
 
+// The primitive WRAPPER object types, as they appear in `implements`/`extends` position
+// (`class C implements String`, `interface I extends String`). Modeled member-less for now — enough
+// to be a valid implements/extends target (a class/interface trivially satisfies an empty base);
+// a later increment fills their real methods once the string/number/boolean primitives model their
+// apparent members so the primitive can satisfy the wrapper.
+interface String { }
+interface Number { }
+interface Boolean { }
+
 interface SymbolConstructor {
     readonly iterator: symbol;
     readonly asyncIterator: symbol;

From 9072b8b7098dec7a29d25c8b3f461dadb7a27de4 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 01:18:01 -0700
Subject: [PATCH 05/11] =?UTF-8?q?test(conformance):=20update=20baseline=20?=
 =?UTF-8?q?=E2=80=94=20stringLiteralTypeIsSubtypeOfString=20now=20passes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 SharpTS.TypeScriptConformance/baselines/interpreted.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/SharpTS.TypeScriptConformance/baselines/interpreted.txt b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
index f5cd1bf7..3ad1f71d 100644
--- a/SharpTS.TypeScriptConformance/baselines/interpreted.txt
+++ b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
@@ -245,7 +245,7 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/undefine
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/unionTypesAssignability.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/enumIsNotASubtypeOfAnythingButNumber.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/nullIsSubtypeOfEverythingButUndefined.ts Pass
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/stringLiteralTypeIsSubtypeOfString.ts Fail
+tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/stringLiteralTypeIsSubtypeOfString.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfAny.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts Pass
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints.ts Pass

From 4c98f9c0cdc7f4a0575432a869cd6dfb69808cc8 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 01:44:36 -0700
Subject: [PATCH 06/11] fix(types): check implements method compat against
 INFERRED return types (TS2416)

'class C implements I' validation runs before the method-body pass, so an
un-annotated method (e.g. '[Symbol.toPrimitive]() { return "" }') had a
<inferred> (~any) return type that hid a mismatch with the interface. Capture the
resolved interfaces during that pass and re-check un-annotated method return types
against them at the end of class-checking (after inference is published), reporting
TS2416 at the method's own line. Only un-annotated methods are re-checked, so
annotated ones aren't double-reported.

Flips symbolProperty24. Full xUnit 15452/0, conformance 254 Pass.
---
 TypeSystem/TypeChecker.Statements.Classes.cs | 11 ++++++-
 TypeSystem/TypeChecker.Validation.cs         | 32 ++++++++++++++++++++
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/TypeSystem/TypeChecker.Statements.Classes.cs b/TypeSystem/TypeChecker.Statements.Classes.cs
index 57407579..cba49011 100644
--- a/TypeSystem/TypeChecker.Statements.Classes.cs
+++ b/TypeSystem/TypeChecker.Statements.Classes.cs
@@ -547,6 +547,9 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
         }
 
         // Validate implemented interfaces (skip for generic classes - validated at instantiation)
+        // Resolved interfaces are captured so an un-annotated method's INFERRED return type can be
+        // re-checked against them after the body pass (this validation runs before inference).
+        List<TypeInfo.Interface> implementsForRecheck = [];
         if (classStmt.Interfaces != null && classTypeParams == null)
         {
             for (int i = 0; i < classStmt.Interfaces.Count; i++)
@@ -620,6 +623,7 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
                 }
 
                 ValidateInterfaceImplementation(classTypeForBody, interfaceType, classStmt.Name.Lexeme, classStmt.Name.Line);
+                implementsForRecheck.Add(interfaceType);
             }
         }
 
@@ -1113,7 +1117,12 @@ TypeInfo.Function BuildMethodFuncType(Stmt.Function method)
         // `[Symbol.x]()` method carries its inferred return type rather than the <inferred> placeholder
         // it held at the string-index check earlier (ValidateClassPropertiesAgainstIndex).
         mutableClass.ResetFrozenCache();
-        ValidateClassMembersAgainstSymbolIndex(classStmt, mutableClass.Freeze());
+        var finalizedClass = mutableClass.Freeze();
+        ValidateClassMembersAgainstSymbolIndex(classStmt, finalizedClass);
+        // Re-check implemented-interface method compatibility now that un-annotated method return
+        // types are inferred (the pre-inference pass above saw a <inferred> placeholder — TS2416).
+        if (implementsForRecheck.Count > 0)
+            RecheckImplementsInferredReturns(classStmt, finalizedClass, implementsForRecheck);
     }
 
     /// <summary>
diff --git a/TypeSystem/TypeChecker.Validation.cs b/TypeSystem/TypeChecker.Validation.cs
index 26288096..ca34c00b 100644
--- a/TypeSystem/TypeChecker.Validation.cs
+++ b/TypeSystem/TypeChecker.Validation.cs
@@ -103,6 +103,38 @@ private void ValidateInterfaceImplementation(TypeInfo.Class classType, TypeInfo.
         }
     }
 
+    /// <summary>
+    /// Re-checks that an un-annotated method implementing an interface member has a compatible
+    /// INFERRED return type (TS2416), reported at the method's own line. The normal implements
+    /// validation runs before the body pass, when an un-annotated return is still a <c>&lt;inferred&gt;</c>
+    /// placeholder (≈ any) that hides the mismatch; this runs after inference. Only un-annotated
+    /// implementations are considered, so annotated methods (already checked) aren't double-reported.
+    /// </summary>
+    private void RecheckImplementsInferredReturns(Stmt.Class classStmt, TypeInfo.Class classType, List<TypeInfo.Interface> interfaces)
+    {
+        foreach (var method in classStmt.Methods)
+        {
+            if (method.ReturnType != null || method.Body == null) continue;
+            string name = method.ComputedKey != null
+                ? (TryGetWellKnownSymbolMemberName(method.ComputedKey) ?? method.Name.Lexeme)
+                : method.Name.Lexeme;
+            if (FindMemberInClass(classType, name) is not TypeInfo.Function actualFunc) continue;
+            int line = method.ComputedKey != null ? (TryGetExprLine(method.ComputedKey) ?? method.Name.Line) : method.Name.Line;
+            foreach (var itf in interfaces)
+            {
+                if (itf.GetAllMembers().FirstOrDefault(m => m.Key == name).Value is TypeInfo.Function expectedFunc
+                    && !IsCompatible(expectedFunc.ReturnType, actualFunc.ReturnType))
+                {
+                    string display = name.StartsWith("@@") ? $"[Symbol.{name[2..]}]" : name;
+                    RecordTypeError(new TypeCheckException(
+                        $" Property '{display}' in type '{classStmt.Name.Lexeme}' is not assignable to the same property in base type '{itf.Name}'.",
+                        line: line, tsCode: "TS2416"));
+                    break;
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// The built-in iterable-protocol interfaces a class may legally list in its <c>implements</c>
     /// clause. These are NOT user-declared <c>interface</c>s (so they are absent from the type

From 735efa5c4c465a8d717226d6c20e1a99e90fe5e1 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 01:44:37 -0700
Subject: [PATCH 07/11] =?UTF-8?q?test(conformance):=20update=20baseline=20?=
 =?UTF-8?q?=E2=80=94=20symbolProperty24=20now=20passes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 SharpTS.TypeScriptConformance/baselines/interpreted.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/SharpTS.TypeScriptConformance/baselines/interpreted.txt b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
index 3ad1f71d..747b315f 100644
--- a/SharpTS.TypeScriptConformance/baselines/interpreted.txt
+++ b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
@@ -98,7 +98,7 @@ tests/cases/conformance/es6/Symbols/symbolProperty20.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty21.ts Fail
 tests/cases/conformance/es6/Symbols/symbolProperty22.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty23.ts Pass
-tests/cases/conformance/es6/Symbols/symbolProperty24.ts Fail
+tests/cases/conformance/es6/Symbols/symbolProperty24.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty25.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty26.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty27.ts Pass

From 7f638666dbadd7e4d43561c970103d6f042bec74 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 02:04:01 -0700
Subject: [PATCH 08/11] fix(types): flag symbol == non-symbol-primitive
 comparison as no-overlap (TS2367)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A symbol can never equal a boolean/number/string/bigint, so ==/!=/===/!== between
them is unintentional (TS2367). Scoped to the case where exactly one operand is a
symbol and the other is a concrete primitive — symbol vs symbol / vs any / vs a
union that could hold a symbol is left untouched, so no broad no-overlap sweep.

Flips symbolType9. Full xUnit 15452/0, conformance 255 Pass.
---
 TypeSystem/TypeChecker.Operators.cs | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/TypeSystem/TypeChecker.Operators.cs b/TypeSystem/TypeChecker.Operators.cs
index a853fca1..14ce05c8 100644
--- a/TypeSystem/TypeChecker.Operators.cs
+++ b/TypeSystem/TypeChecker.Operators.cs
@@ -26,7 +26,7 @@ private TypeInfo CheckBinary(Expr.Binary binary)
             OperatorDescriptor.Plus => CheckPlusOperator(left, right, line),
             OperatorDescriptor.Arithmetic or OperatorDescriptor.Power => CheckArithmeticBinary(left, right, line),
             OperatorDescriptor.Comparison => CheckComparisonBinary(left, right, binary.Operator.Lexeme, line),
-            OperatorDescriptor.Equality => new TypeInfo.Primitive(TokenType.TYPE_BOOLEAN),
+            OperatorDescriptor.Equality => CheckEqualityBinary(left, right, line),
             OperatorDescriptor.Bitwise or OperatorDescriptor.BitwiseShift => CheckBitwiseBinary(left, right, line),
             OperatorDescriptor.UnsignedRightShift => CheckUnsignedShiftBinary(left, right, line),
             OperatorDescriptor.In => CheckInOperator(right, line),
@@ -51,6 +51,31 @@ private TypeInfo CheckInOperator(TypeInfo right, int line)
         return new TypeInfo.Primitive(TokenType.TYPE_BOOLEAN);
     }
 
+    /// <summary>
+    /// Equality (<c>==</c>/<c>!=</c>/<c>===</c>/<c>!==</c>). tsc's "no overlap" check (TS2367) is broad,
+    /// but only the symbol-vs-non-symbol-primitive slice is implemented here (scoped to keep other
+    /// comparisons untouched): a <c>symbol</c> can never equal a <c>boolean</c>/<c>number</c>/
+    /// <c>string</c>/<c>bigint</c>, so comparing them is flagged unintentional. A symbol vs symbol / vs
+    /// <c>any</c> / vs a union that could hold a symbol is fine.
+    /// </summary>
+    private TypeInfo CheckEqualityBinary(TypeInfo left, TypeInfo right, int line)
+    {
+        bool leftSym = left is TypeInfo.Symbol or TypeInfo.UniqueSymbol;
+        bool rightSym = right is TypeInfo.Symbol or TypeInfo.UniqueSymbol;
+        if (leftSym != rightSym)
+        {
+            TypeInfo other = leftSym ? right : left;
+            if (other is TypeInfo.Primitive or TypeInfo.String or TypeInfo.NumberLiteral
+                or TypeInfo.StringLiteral or TypeInfo.BooleanLiteral or TypeInfo.BigInt or TypeInfo.BigIntLiteral)
+            {
+                throw new TypeCheckException(
+                    $"This comparison appears to be unintentional because the types '{left}' and '{right}' have no overlap.",
+                    line > 0 ? line : null, tsCode: "TS2367");
+            }
+        }
+        return new TypeInfo.Primitive(TokenType.TYPE_BOOLEAN);
+    }
+
     /// <summary>
     /// True if this type is Any, Inferred, or a Union containing an Any/Inferred arm.
     /// A union that includes 'any' is effectively permissive (JS semantics); operators

From f8dea28d95dc22bb725bf4e34e3d4c3f895ed608 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 02:04:01 -0700
Subject: [PATCH 09/11] =?UTF-8?q?test(conformance):=20update=20baseline=20?=
 =?UTF-8?q?=E2=80=94=20symbolType9=20now=20passes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 SharpTS.TypeScriptConformance/baselines/interpreted.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/SharpTS.TypeScriptConformance/baselines/interpreted.txt b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
index 747b315f..081da04a 100644
--- a/SharpTS.TypeScriptConformance/baselines/interpreted.txt
+++ b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
@@ -162,7 +162,7 @@ tests/cases/conformance/es6/Symbols/symbolType5.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType6.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType7.ts Pass
 tests/cases/conformance/es6/Symbols/symbolType8.ts Pass
-tests/cases/conformance/es6/Symbols/symbolType9.ts Fail
+tests/cases/conformance/es6/Symbols/symbolType9.ts Pass
 tests/cases/conformance/esnext/logicalAssignment/logicalAssignment11.ts Pass
 tests/cases/conformance/types/conditional/conditionalTypes1.ts Pass
 tests/cases/conformance/types/conditional/conditionalTypes2.ts Pass

From 465ac9a3c021f0a93aad350497352d8f6cd120a1 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 12:22:27 -0700
Subject: [PATCH 10/11] fix(types): excess-property check on fresh
 object-literal call arguments (TS2353)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Excess-property checking ran for assignments but not call arguments — a fresh
object literal passed to a typed parameter with extra properties was accepted.
Wire CheckExcessProperties into both the non-generic argument loop and the generic
call path (which skipped argument validation entirely), scoped to direct object
literals (tsc's fresh-literal rule). Also: CheckExcessProperties now flattens a
generic interface argument (I<T>) to its concrete members, and attributes TS2353 to
the offending property's own line (not the enclosing statement's) so a multi-line
call argument reports correctly.

Flips symbolProperty21. Full xUnit 15452/0, conformance 256 Pass.
---
 TypeSystem/TypeChecker.Calls.cs               | 14 +++++++++
 .../TypeChecker.Compatibility.Structural.cs   | 30 +++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/TypeSystem/TypeChecker.Calls.cs b/TypeSystem/TypeChecker.Calls.cs
index 730ddc27..1cc068f7 100644
--- a/TypeSystem/TypeChecker.Calls.cs
+++ b/TypeSystem/TypeChecker.Calls.cs
@@ -97,6 +97,13 @@ private TypeInfo CheckCall(Expr.Call call)
             var instantiatedFunc = InstantiateGenericFunction(genericFunc, typeArgs);
             if (instantiatedFunc is TypeInfo.Function instFunc)
             {
+                // Excess-property check for fresh object-literal args against the instantiated
+                // parameter types (the generic path otherwise skips argument validation).
+                for (int ai = 0; ai < call.Arguments.Count && ai < instFunc.ParamTypes.Count; ai++)
+                {
+                    if (call.Arguments[ai] is Expr.ObjectLiteral && argTypes[ai] is TypeInfo.Record argRec)
+                        CheckExcessProperties(argRec, instFunc.ParamTypes[ai], call.Arguments[ai]);
+                }
                 return instFunc.ReturnType;
             }
             return new TypeInfo.Any();
@@ -211,6 +218,13 @@ private TypeInfo CheckCall(Expr.Call call)
                         {
                             argType = CheckExpr(arg);
                         }
+                        // Excess-property check for a FRESH object-literal argument (tsc's fresh-literal
+                        // rule) against its parameter type — mirrors the assignment path.
+                        if (arg is Expr.ObjectLiteral && argType is TypeInfo.Record argExcessRecord
+                            && paramIndex < regularParamCount)
+                        {
+                            CheckExcessProperties(argExcessRecord, funcType.ParamTypes[paramIndex], arg);
+                        }
                         if (paramIndex < regularParamCount)
                         {
                             // Check against regular parameter. An optional/default-valued parameter
diff --git a/TypeSystem/TypeChecker.Compatibility.Structural.cs b/TypeSystem/TypeChecker.Compatibility.Structural.cs
index 10e16c82..71acf899 100644
--- a/TypeSystem/TypeChecker.Compatibility.Structural.cs
+++ b/TypeSystem/TypeChecker.Compatibility.Structural.cs
@@ -100,6 +100,15 @@ private void CheckExcessProperties(TypeInfo.Record actual, TypeInfo expected, Ex
             hasStringIndex = cls.StringIndexType != null;
             hasNumberIndex = cls.NumberIndexType != null;
         }
+        else if (expected is TypeInfo.InstantiatedGeneric ig && FlattenInstantiatedInterface(ig) is { } flatIface)
+        {
+            // A generic interface argument (`I<number>`) flattens to its concrete members so a fresh
+            // object literal passed to a generic function is excess-checked too.
+            foreach (var member in flatIface.GetAllMembers())
+                expectedKeys.Add(member.Key);
+            hasStringIndex = flatIface.StringIndexType != null;
+            hasNumberIndex = flatIface.NumberIndexType != null;
+        }
         else
         {
             // For other types (primitives, unions, etc.), skip excess property check
@@ -136,11 +145,32 @@ private void CheckExcessProperties(TypeInfo.Record actual, TypeInfo expected, Ex
             throw new TypeCheckException(
                 $"Object literal may only specify known properties. " +
                 $"Excess {(excessKeys.Count == 1 ? "property" : "properties")}: {excessList}",
+                line: ExcessPropertyLine(sourceExpr, excessKeys[0]),
                 tsCode: "TS2353"
             );
         }
     }
 
+    /// <summary>The source line of an excess property (for TS2353 attribution) — the offending
+    /// property's own line rather than the enclosing statement's, which matters when the object
+    /// literal spans multiple lines (e.g. a multi-line call argument). Null if it can't be located.</summary>
+    private static int? ExcessPropertyLine(Expr sourceExpr, string excessKey)
+    {
+        if (sourceExpr is not Expr.ObjectLiteral obj) return null;
+        foreach (var prop in obj.Properties)
+        {
+            if (prop.Key is { } key && GetAccessorMemberName(key) == excessKey)
+                return key switch
+                {
+                    Expr.IdentifierKey id => id.Name.Line,
+                    Expr.LiteralKey lit => lit.Literal.Line,
+                    Expr.ComputedKey ck => TryGetExprLine(ck.Expression),
+                    _ => null
+                };
+        }
+        return null;
+    }
+
     private TypeInfo? GetMemberType(TypeInfo type, string name)
     {
         if (type is TypeInfo.Record record)

From 82433b7c3e909f9d9bd18c5c09317241e2c0d9c2 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick206@gmail.com>
Date: Thu, 9 Jul 2026 12:22:27 -0700
Subject: [PATCH 11/11] =?UTF-8?q?test(conformance):=20update=20baseline=20?=
 =?UTF-8?q?=E2=80=94=20symbolProperty21=20now=20passes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 SharpTS.TypeScriptConformance/baselines/interpreted.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/SharpTS.TypeScriptConformance/baselines/interpreted.txt b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
index 081da04a..2522c0b4 100644
--- a/SharpTS.TypeScriptConformance/baselines/interpreted.txt
+++ b/SharpTS.TypeScriptConformance/baselines/interpreted.txt
@@ -95,7 +95,7 @@ tests/cases/conformance/es6/Symbols/symbolProperty18.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty19.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty2.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty20.ts Pass
-tests/cases/conformance/es6/Symbols/symbolProperty21.ts Fail
+tests/cases/conformance/es6/Symbols/symbolProperty21.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty22.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty23.ts Pass
 tests/cases/conformance/es6/Symbols/symbolProperty24.ts Pass