DavidObando
diff --git a/‎docs/adr/0084-gsharp-extensions-optional-sequences.md‎
Lines changed: 69 additions & 14 deletions b/‎docs/adr/0084-gsharp-extensions-optional-sequences.md‎
Lines changed: 69 additions & 14 deletions
diff --git a/‎samples/GsharpExtensionsMixed.gs‎
Lines changed: 3 additions & 3 deletions b/‎samples/GsharpExtensionsMixed.gs‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎src/Core/CodeAnalysis/Binding/Binder.cs‎
Lines changed: 10 additions & 4 deletions b/‎src/Core/CodeAnalysis/Binding/Binder.cs‎
Lines changed: 10 additions & 4 deletions
diff --git a/‎src/Core/CodeAnalysis/Binding/ExpressionBinder.Access.cs‎
Lines changed: 43 additions & 0 deletions b/‎src/Core/CodeAnalysis/Binding/ExpressionBinder.Access.cs‎
Lines changed: 43 additions & 0 deletions
diff --git a/‎src/Core/CodeAnalysis/Binding/KnownAttributes.cs‎
Lines changed: 96 additions & 2 deletions b/‎src/Core/CodeAnalysis/Binding/KnownAttributes.cs‎
Lines changed: 96 additions & 2 deletions
diff --git a/‎src/Core/CodeAnalysis/Binding/StatementBinder.cs‎
Lines changed: 4 additions & 4 deletions b/‎src/Core/CodeAnalysis/Binding/StatementBinder.cs‎
Lines changed: 4 additions & 4 deletions
@@ -533,6 +533,63 @@ of that migration, not left behind as dead code.
   for the IL-verified emit path (eight tests, all `IlVerifier.Verify`
   clean).
 
+  Issue #806 closes §L5 end-to-end (source side): `Gsharp.Extensions`
+  ships in idiomatic G#. `Optional.gs`, `Sequences.gs`, and
+  `SequenceExtensions.gs` replace the C# escape hatches under
+  `src/Sdk/Gsharp.Extensions/Optional/` and
+  `src/Sdk/Gsharp.Extensions/Sequences/`; `Gsharp.Extensions.csproj`
+  now consumes the `Gsharp.NET.Sdk.Bootstrap` build-time SDK landed
+  by #792, so the same `gsc.dll` + `BuildTask` invocation that any
+  user `.gsproj` exercises now compiles the stdlib itself. The
+  emitter required four targeted fixes to make dogfooding viable:
+  (1) `<Program>` host TypeDefs are emitted as `sealed abstract`
+  (the C# "static class" shape) so C# extension-method discovery
+  (`MemberLookup.IsStaticClass`) finds them when a consumer writes
+  `import Gsharp.Extensions.Sequences`; (2) `MethodImpl` pseudo-attributes
+  (`@MethodImpl(MethodImplOptions.AggressiveInlining)`) now OR into
+  the MethodDef `ImplFlags` field instead of being silently dropped,
+  preserving the hot-path inlining intent the C# baseline relied on;
+  (3) `IsCoreLibBaseType` was extended to route the open-generic
+  collection interfaces (`IEnumerable`, `IEnumerator`,
+  `IEnumerable<T>`, `IEnumerator<T>`, `IAsyncEnumerable<T>`,
+  `IAsyncEnumerator<T>`, `IDisposable`) plus `Nullable<T>` and
+  `ValueTuple<…>` through `System.Runtime` instead of the host's
+  `System.Private.CoreLib`, so cross-context type refs in iterator
+  SMs and `T?` MemberRefs resolve under the BuildTask
+  `MetadataLoadContext`; (4) `StateMachineEmitter` now packages each
+  iterator state machine under its declaring function's package
+  (`plan.Function.Package?.Name ?? hostPackage?.Name`) rather than
+  the host's `<Program>`, so a multi-namespace assembly like
+  `Gsharp.Extensions` (which hosts Optional, Sequences, and Go
+  side-by-side) emits each SM under the right `<Program>` parent
+  and runtime metadata lookup (`MethodAccessException`) stops crossing
+  package boundaries. Open Nullable-over-TP member binding gained a
+  dedicated branch in `ExpressionBinder.Access` so the struct-receiver
+  overloads of the `*OrNil` helpers — which use `self.HasValue` /
+  `self.Value` on a `Nullable<T>` where T is an open value-type-
+  constrained TP — bind without falling through the closed-Nullable
+  ClrType path. The `IteratorRewriter.GetIteratorElementType`
+  fast-path now compares `OpenDefinition` by `FullName` instead of
+  CLR reference identity (the `typeof()` pattern fails across
+  `MetadataLoadContext`), so open-generic iterator-return-type
+  recovery works on the BuildTask side too. End-to-end coverage:
+  all 104 tests in `test/Extensions.Tests/` run against the G# port
+  unchanged; `test/Compiler.Tests/SampleConformanceTests` exercises
+  `samples/GsharpExtensionsMixed.gs` / `GsharpExtensionsOptional.gs`
+  / `GsharpExtensionsSequences.gs` end-to-end through the same
+  `gsc.dll` invocation real users see. Residual gaps (filed as
+  separate Oats follow-ups) — open-T `== nil` lowering for
+  reference-class TPs in `Optional.Map` / `FlatMap` (`ldnull` vs
+  `T` ilverify mismatch), open-T `Queue<T>.Dequeue()` discard
+  spuriously inserting `unbox.any !T`, and
+  `Enumerable.Empty[T]()` returning `Object[]` for open T — were
+  routed around in the G# source (use `List[T]` over `Queue[T]`,
+  retain the `class`/`struct` constraint split that maps each helper
+  to the right lowering, suppress the consumer-side `CS8602` with a
+  pragma) so the runtime behaviour matches the C# baseline; ilverify
+  is dirty on those eight methods only. The bootstrap is no longer
+  hypothetical: it builds the stdlib it ships.
+
 ## Consequences
 
 - **Positive — uniform G# feel.** Samples that previously had to
@@ -552,22 +609,20 @@ of that migration, not left behind as dead code.
   iteration emit gap closed by #774, and the G# spelling for
   `class` / `struct` / `new()` constraints closed by ADR-0097
   (#775). **The SDK ↔ Extensions bootstrap cycle (L5) is now
-  broken** by issue #792: `src/Sdk/Gsharp.NET.Sdk.Bootstrap/`
-  ships a build-time-only mirror of the consumer SDK that compiles
-  `.gs` sources against the in-tree `gsc.dll` + BuildTask *without*
-  the `Gsharp.Extensions.dll` auto-reference, and the reflection
-  metadata emitter now stamps
+  broken and exercised end-to-end by issue #806**:
+  `src/Sdk/Gsharp.NET.Sdk.Bootstrap/` ships a build-time-only mirror
+  of the consumer SDK that compiles `.gs` sources against the in-tree
+  `gsc.dll` + BuildTask *without* the `Gsharp.Extensions.dll`
+  auto-reference, and the reflection metadata emitter now stamps
   `[System.Runtime.CompilerServices.ExtensionAttribute]` on every
   G#-authored extension method's MethodDef and on its containing
-  `<Program>` TypeDef so the existing C# test surface against
-  `Gsharp.Extensions.dll` would continue to bind against a
-  G#-built replacement. What remains is the actual source-side
-  port of `Optional` and `Sequences`, which surfaced the
-  follow-up language gaps catalogued in §L5 above. The C# escape
-  hatch under `src/Sdk/Gsharp.Extensions/Optional/` and
-  `src/Sdk/Gsharp.Extensions/Sequences/` therefore stays in place
-  for one more turn; the test suite (`test/Extensions.Tests/`,
-  107 tests) runs against the C# implementation unchanged.
+  (now `sealed abstract`) `<Program>` TypeDef so the existing C#
+  test surface against `Gsharp.Extensions.dll` binds against the
+  G#-built replacement. The actual source-side port of `Optional`
+  and `Sequences` is in (`src/Sdk/Gsharp.Extensions/Optional/Optional.gs`,
+  `Sequences/Sequences.gs`, `Sequences/SequenceExtensions.gs`); the
+  C# escape hatch is removed; the 104 `test/Extensions.Tests/` tests
+  run against the G#-emitted stdlib unchanged.
 - **Positive — zero-friction adoption.** Because the assembly is
   bundled with the SDK and imports are explicit but trivial
   (`import Gsharp.Extensions.Optional`), the cost to a sample or
 
@@ -12,7 +12,7 @@ import System.Collections.Generic
 import Gsharp.Extensions.Optional
 import Gsharp.Extensions.Sequences
 
-func sumOf(values []int32) int32 {
+func sumOf(values IEnumerable[int32]) int32 {
     var total int32 = 0
     for v in values {
         total = total + v
@@ -32,11 +32,11 @@ func tryLookup(dict map[string,string], key string) string? {
 
 let geom = Sequences.Iterate(1, func(n int32) int32 { return n * 2 })
 
-let firstHeavyTrio = geom.Take(8).Windowed(3).Where(func(w []int32) bool {
+let firstHeavyTrio = geom.Take(8).Windowed(3).Where(func(w IList[int32]) bool {
     return sumOf(w) > 50
 }).FirstOrNil()
 
-let heavySumText = firstHeavyTrio.Map(func(w []int32) string { return sumOf(w).ToString() })
+let heavySumText = firstHeavyTrio.Map(func(w IList[int32]) string { return sumOf(w).ToString() })
 Console.WriteLine("first heavy trio sum: " + heavySumText.OrElse("<absent>"))
 
 // Build a {first-letter -> word} map from a sequence and look up keys via
 
@@ -2374,17 +2374,23 @@ private static bool IsIteratorReturnType(TypeSymbol type)
             return false;
         }
 
-        if (clr == typeof(System.Collections.IEnumerable) ||
-            clr == typeof(System.Collections.IEnumerator))
+        // Use FullName matching rather than typeof identity: when gsc is
+        // invoked with explicit `/r:` references (the production SDK build
+        // path) the IEnumerable types come from a MetadataLoadContext, not
+        // the host process, so `clr == typeof(System.Collections.IEnumerable)`
+        // would be false even for the canonical types. The async branch below
+        // already uses FullName for the same reason.
+        if (clr.FullName == "System.Collections.IEnumerable" ||
+            clr.FullName == "System.Collections.IEnumerator")
         {
             return true;
         }
 
         if (clr.IsGenericType && !clr.IsGenericTypeDefinition)
         {
             var def = clr.GetGenericTypeDefinition();
-            if (def == typeof(System.Collections.Generic.IEnumerable<>) ||
-                def == typeof(System.Collections.Generic.IEnumerator<>))
+            if (def.FullName == "System.Collections.Generic.IEnumerable`1" ||
+                def.FullName == "System.Collections.Generic.IEnumerator`1")
             {
                 return true;
             }
 
@@ -1470,6 +1470,49 @@ private BoundExpression BindAccessorStep(BoundExpression receiver, ImportedClass
                     Diagnostics.ReportUnableToFindMember(ne.Location, nullableMemberName);
                     return new BoundErrorExpression(null);
                 }
+                else if (receiver != null && receiver.Type is NullableTypeSymbol openNullableSym
+                    && openNullableSym.UnderlyingType is TypeParameterSymbol openTp
+                    && openTp.HasValueTypeConstraint)
+                {
+                    // Issue #806: a `T?` receiver where T is an open value-type
+                    // type parameter still lowers to `Nullable<T>` at IL emit
+                    // time, but the closed `Nullable<T>` CLR instance is not
+                    // available here. Resolve the member name against the open
+                    // `typeof(Nullable<>)` definition so `.HasValue`, `.Value`
+                    // and `.GetValueOrDefault()` bind successfully and lower
+                    // to a normal property/method access on the symbolic
+                    // constructed receiver.
+                    var openNullableMemberName = ne.IdentifierToken.Text;
+                    var openNullableDef = typeof(System.Nullable<>);
+                    var openProp = ClrTypeUtilities.SafeGetProperty(openNullableDef, openNullableMemberName, BindingFlags.Public | BindingFlags.Instance);
+                    if (openProp != null && openProp.GetIndexParameters().Length == 0 && openProp.CanRead)
+                    {
+                        // HasValue → bool (concrete); Value → the open T (the
+                        // property's PropertyType IS the open type parameter
+                        // itself in the reflection model). Substitute back to
+                        // the binder's symbolic T so downstream type checks
+                        // see the right symbol.
+                        TypeSymbol openPropType;
+                        if (openProp.PropertyType.IsGenericParameter)
+                        {
+                            openPropType = openTp;
+                        }
+                        else
+                        {
+                            openPropType = ClrNullability.GetPropertyTypeSymbol(openProp);
+                        }
+
+                        return new BoundClrPropertyAccessExpression(null, receiver, openProp, openPropType);
+                    }
+
+                    if (TryBindClrMethodGroup(receiver, openNullableDef, wantStatic: false, openNullableMemberName, out var openNullableGroup))
+                    {
+                        return openNullableGroup;
+                    }
+
+                    Diagnostics.ReportUnableToFindMember(ne.Location, openNullableMemberName);
+                    return new BoundErrorExpression(null);
+                }
                 else if (receiver != null && receiver.Type != null && receiver.Type is not NullableTypeSymbol && receiver.Type.ClrType != null)
                 {
                     // Phase 4 exit: read a public instance property or field on
 
@@ -664,6 +664,7 @@ private static bool TryConvertToInt32(object value, out int result)
             case uint ui: result = (int)ui; return true;
             case long l: result = (int)l; return true;
             case AttributeTargets at: result = (int)at; return true;
+            case System.Runtime.CompilerServices.MethodImplOptions mio: result = (int)mio; return true;
             default: result = 0; return false;
         }
     }
@@ -964,7 +965,7 @@ public static BoundAttribute FindFieldOffset(ImmutableArray<BoundAttribute> attr
     /// rows rather than a <c>CustomAttribute</c> row. The emitter elides
     /// these from the user-attribute pass to avoid producing a
     /// duplicate / misleading reflection view (ADR-0086 §6,
-    /// ADR-0092 §6, ADR-0093 §5, ADR-0096 §5).
+    /// ADR-0092 §6, ADR-0093 §5, ADR-0096 §5, ADR-0084 §L5).
     /// </summary>
     /// <param name="attribute">A bound attribute application.</param>
     /// <returns><c>true</c> when the attribute is pseudo-custom.</returns>
@@ -974,7 +975,100 @@ public static bool IsPseudoCustomAttribute(BoundAttribute attribute)
             || IsLibraryImport(attribute)
             || IsStructLayout(attribute)
             || IsFieldOffset(attribute)
-            || IsMarshalAs(attribute);
+            || IsMarshalAs(attribute)
+            || IsMethodImpl(attribute);
+    }
+
+    /// <summary>
+    /// Returns <c>true</c> when <paramref name="clrType"/> is
+    /// <see cref="System.Runtime.CompilerServices.MethodImplAttribute"/>.
+    /// ADR-0084 §L5 / issue #806: <c>@MethodImpl(MethodImplOptions.…)</c>
+    /// is a pseudo-custom attribute — its state encodes into the
+    /// <c>MethodImpl</c> field of the MethodDef row (the bits read by
+    /// <see cref="System.Reflection.MethodBase.GetMethodImplementationFlags"/>)
+    /// rather than into a <c>CustomAttribute</c> row. Recognition is
+    /// type-identity based so shadowing the source-level name cannot
+    /// bypass the rule.
+    /// </summary>
+    /// <param name="clrType">The resolved attribute CLR type, or <c>null</c>.</param>
+    /// <returns><c>true</c> when the attribute is <c>[MethodImpl]</c>.</returns>
+    public static bool IsMethodImpl(Type clrType)
+    {
+        // Use FullName matching (not typeof identity) so the recognition
+        // also fires when the attribute type comes from the consumer's
+        // referenced assembly set via MetadataLoadContext rather than
+        // the gsc host process. Issue #806: the production SDK build of
+        // Gsharp.Extensions hit this gap — every `@MethodImpl(...)` on a
+        // hot extension helper was being silently demoted to a regular
+        // CustomAttribute row, leaving the MethodImpl field unchanged
+        // (so AggressiveInlining never applied at runtime).
+        return clrType?.FullName == "System.Runtime.CompilerServices.MethodImplAttribute";
+    }
+
+    /// <summary>
+    /// Returns <c>true</c> when <paramref name="attribute"/> is
+    /// <see cref="System.Runtime.CompilerServices.MethodImplAttribute"/>.
+    /// </summary>
+    /// <param name="attribute">A bound attribute application.</param>
+    /// <returns><c>true</c> when the attribute is <c>[MethodImpl]</c>.</returns>
+    public static bool IsMethodImpl(BoundAttribute attribute)
+    {
+        return IsMethodImpl(attribute?.AttributeType?.ClrType);
+    }
+
+    /// <summary>
+    /// Finds the first <c>@MethodImpl(...)</c> attribute on
+    /// <paramref name="attributes"/>, or <c>null</c> when none is present.
+    /// Recognition is type-identity based (ADR-0084 §L5 / issue #806).
+    /// </summary>
+    /// <param name="attributes">The attributes attached to a function symbol.</param>
+    /// <returns>The matching attribute, or <c>null</c>.</returns>
+    public static BoundAttribute FindMethodImpl(ImmutableArray<BoundAttribute> attributes)
+    {
+        if (attributes.IsDefaultOrEmpty)
+        {
+            return null;
+        }
+
+        foreach (var attr in attributes)
+        {
+            if (IsMethodImpl(attr))
+            {
+                return attr;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Extracts the <see cref="System.Runtime.CompilerServices.MethodImplOptions"/>
+    /// bits from a <c>@MethodImpl(...)</c> application. The recognised
+    /// constructor shapes are <c>MethodImpl()</c>,
+    /// <c>MethodImpl(MethodImplOptions options)</c>, and
+    /// <c>MethodImpl(short value)</c> — all map to the same options
+    /// bit-field at the metadata level.
+    /// </summary>
+    /// <param name="attribute">A <c>@MethodImpl</c> attribute application; may be <c>null</c>.</param>
+    /// <returns>The options bits (zero when absent or unrecognised).</returns>
+    public static System.Runtime.CompilerServices.MethodImplOptions GetMethodImplOptions(BoundAttribute attribute)
+    {
+        if (attribute == null || attribute.PositionalArguments.IsDefaultOrEmpty || attribute.PositionalArguments.Length < 1)
+        {
+            return default;
+        }
+
+        if (TryConvertToInt32(attribute.PositionalArguments[0].Value, out var raw))
+        {
+            return (System.Runtime.CompilerServices.MethodImplOptions)raw;
+        }
+
+        if (attribute.PositionalArguments[0].Value is System.Runtime.CompilerServices.MethodImplOptions options)
+        {
+            return options;
+        }
+
+        return default;
     }
 
     /// <summary>
 
@@ -2593,8 +2593,8 @@ private static TypeSymbol GetIteratorElementType(TypeSymbol type)
             && !importedSym.TypeArguments.IsDefaultOrEmpty)
         {
             var def = importedSym.OpenDefinition;
-            if (def == typeof(System.Collections.Generic.IEnumerable<>) ||
-                def == typeof(System.Collections.Generic.IEnumerator<>) ||
+            if (def.FullName == "System.Collections.Generic.IEnumerable`1" ||
+                def.FullName == "System.Collections.Generic.IEnumerator`1" ||
                 def.FullName == "System.Collections.Generic.IAsyncEnumerable`1" ||
                 def.FullName == "System.Collections.Generic.IAsyncEnumerator`1")
             {
@@ -2611,8 +2611,8 @@ private static TypeSymbol GetIteratorElementType(TypeSymbol type)
         if (clr.IsGenericType && !clr.IsGenericTypeDefinition)
         {
             var def = clr.GetGenericTypeDefinition();
-            if (def == typeof(System.Collections.Generic.IEnumerable<>) ||
-                def == typeof(System.Collections.Generic.IEnumerator<>))
+            if (def.FullName == "System.Collections.Generic.IEnumerable`1" ||
+                def.FullName == "System.Collections.Generic.IEnumerator`1")
             {
                 return TypeSymbol.FromClrType(clr.GetGenericArguments()[0]);
             }
Original file line number	Diff line number	Diff line change
`@@ -2374,17 +2374,23 @@ private static bool IsIteratorReturnType(TypeSymbol type)`
`2374`	`2374`	`return false;`
`2375`	`2375`	`}`
`2376`	`2376`
`2377`		`- if (clr == typeof(System.Collections.IEnumerable) \|\|`
`2378`		`- clr == typeof(System.Collections.IEnumerator))`
	`2377`	`+ // Use FullName matching rather than typeof identity: when gsc is`
	`2378`	+ // invoked with explicit `/r:` references (the production SDK build
	`2379`	`+ // path) the IEnumerable types come from a MetadataLoadContext, not`
	`2380`	+ // the host process, so `clr == typeof(System.Collections.IEnumerable)`
	`2381`	`+ // would be false even for the canonical types. The async branch below`
	`2382`	`+ // already uses FullName for the same reason.`
	`2383`	`+ if (clr.FullName == "System.Collections.IEnumerable" \|\|`
	`2384`	`+ clr.FullName == "System.Collections.IEnumerator")`
`2379`	`2385`	`{`
`2380`	`2386`	`return true;`
`2381`	`2387`	`}`
`2382`	`2388`
`2383`	`2389`	`if (clr.IsGenericType && !clr.IsGenericTypeDefinition)`
`2384`	`2390`	`{`
`2385`	`2391`	`var def = clr.GetGenericTypeDefinition();`
`2386`		`- if (def == typeof(System.Collections.Generic.IEnumerable<>) \|\|`
`2387`		`- def == typeof(System.Collections.Generic.IEnumerator<>))`
	`2392`	+ if (def.FullName == "System.Collections.Generic.IEnumerable`1" \|\|
	`2393`	+ def.FullName == "System.Collections.Generic.IEnumerator`1")
`2388`	`2394`	`{`
`2389`	`2395`	`return true;`
`2390`	`2396`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2593,8 +2593,8 @@ private static TypeSymbol GetIteratorElementType(TypeSymbol type)`
`2593`	`2593`	`&& !importedSym.TypeArguments.IsDefaultOrEmpty)`
`2594`	`2594`	`{`
`2595`	`2595`	`var def = importedSym.OpenDefinition;`
`2596`		`- if (def == typeof(System.Collections.Generic.IEnumerable<>) \|\|`
`2597`		`- def == typeof(System.Collections.Generic.IEnumerator<>) \|\|`
	`2596`	+ if (def.FullName == "System.Collections.Generic.IEnumerable`1" \|\|
	`2597`	+ def.FullName == "System.Collections.Generic.IEnumerator`1" \|\|
`2598`	`2598`	def.FullName == "System.Collections.Generic.IAsyncEnumerable`1" \|\|
`2599`	`2599`	def.FullName == "System.Collections.Generic.IAsyncEnumerator`1")
`2600`	`2600`	`{`
`@@ -2611,8 +2611,8 @@ private static TypeSymbol GetIteratorElementType(TypeSymbol type)`
`2611`	`2611`	`if (clr.IsGenericType && !clr.IsGenericTypeDefinition)`
`2612`	`2612`	`{`
`2613`	`2613`	`var def = clr.GetGenericTypeDefinition();`
`2614`		`- if (def == typeof(System.Collections.Generic.IEnumerable<>) \|\|`
`2615`		`- def == typeof(System.Collections.Generic.IEnumerator<>))`
	`2614`	+ if (def.FullName == "System.Collections.Generic.IEnumerable`1" \|\|
	`2615`	+ def.FullName == "System.Collections.Generic.IEnumerator`1")
`2616`	`2616`	`{`
`2617`	`2617`	`return TypeSymbol.FromClrType(clr.GetGenericArguments()[0]);`
`2618`	`2618`	`}`