fix(binder,emit): implicit []T to IEnumerable[T] at static-call slots (#829)

Closes #821. The slice-to-interface implicit conversion (#570) and the
sequence-vs-slice receiver-call extension (#774) both classified slice
arguments correctly when the target interface's ClrType was a fully
closed live-runtime instantiation. At static-method / free-function
argument slots, the target's ClrType could be the type-erased open-
definition form because Binder.SubstituteType keeps the erased ClrType
on ImportedTypeSymbol.GetConstructed when MakeGenericType cannot close
across reflection contexts (open def in MetadataLoadContext vs live
runtime element type). The real substituted G# types live on
ImportedTypeSymbol.TypeArguments, but neither the binder's
slice-to-interface classifier nor the emitter's reference-compatibility
walk consulted them, so the call site was rejected with GS0155 (binder)
or GS9998 (emitter) depending on the path.

Three localized fixes:

- Conversion.SliceImplementsInterface: extends the slice-to-interface
  arm to fall back to the target's symbolic TypeArguments and the open
  definition's FullName when the constructed CLR target is erased,
  matching slice-array interface arguments by leaf FullName so the
  invariance guarantee is preserved.
- MethodBodyEmitter.IsReferenceCompatible: mirrors the binder fallback
  so the emit-time reference upcast recognises the slice argument as
  CLR-equivalent to the erased ImportedTypeSymbol target and emits a
  no-op IL conversion.
- ReflectionMetadataEmitter.GetErasedObjectArgs: routes erased-object
  generic instantiation through emitCtx.CoreObjectType when the open
  definition lives outside the host runtime, fixing
  "This type 'System.Object' was not loaded by the MetadataLoadContext"
  failures when synthesizing the receiver TypeSpec for a call whose
  parameter is a constructed CLR interface.

Restores the original IEnumerable[T] signatures on Sequences.Indexed /
Sequences.Pairwise in samples/TupleSequenceIterators.gs (the workaround
for #813 was the sequence[T] spelling).

Tests:
- Binder: 9 new tests covering issue repro plus IEnumerable[T] /
  IList[T] / ICollection[T] / IReadOnlyList[T] at static-method and
  free-function argument slots, plus negative variance guards.
- Emit: 7 new IL-verified CompileAndRun tests for the same shapes.
- Interpreter: 6 new closed-instantiation tests through GSharpRepl.

Related: #774 (open-generic receiver iteration), #813 (tuple-element
iterator state machines, source of the workaround being reverted),
#706 (parent / per-PR series).

Verified:
- dotnet test GSharp.sln green (5,253 passed, 1 skip baseline regen).
- ilverify clean (IlVerifier in every new emit test).
- website docs build clean (npm run build).

Author: DavidObando

samples/TupleSequenceIterators.gs

@@ -14,7 +14,7 @@ import System.Collections.Generic
 class Sequences {
     shared {
         // `(int32, T)` element type — the issue's `Indexed` spelling.
-        func Indexed[T](source sequence[T]) sequence[(int32, T)] {
+        func Indexed[T](source IEnumerable[T]) sequence[(int32, T)] {
             var index = 0
             for v in source {
                 yield (index, v)
@@ -23,7 +23,7 @@ class Sequences {
         }
 
         // `(T, T)` element type — the issue's `Pairwise` spelling.
-        func Pairwise[T](source sequence[T]) sequence[(T, T)] {
+        func Pairwise[T](source IEnumerable[T]) sequence[(T, T)] {
             var first = true
             var prev T = default(T)
             for v in source {

src/Core/CodeAnalysis/Binding/Conversion.cs

@@ -462,7 +462,7 @@ public static Conversion Classify(TypeSymbol from, TypeSymbol to)
         if (from is SliceTypeSymbol sliceForIface && to?.ClrType != null && to.ClrType.IsInterface)
         {
             if (sliceForIface.ClrType != null
-                && ClrTypeUtilities.ImplementsInterfaceByName(sliceForIface.ClrType, to.ClrType))
+                && SliceImplementsInterface(sliceForIface, to))
             {
                 return Conversion.Implicit;
             }
@@ -733,4 +733,86 @@ private static bool IsTupleClrEquivalent(TypeSymbol a, TypeSymbol b)
 
         return false;
     }
+
+    /// <summary>
+    /// Issue #821: cross-context-safe slice-to-interface check. When the
+    /// target is a constructed <see cref="ImportedTypeSymbol"/> whose
+    /// <c>ClrType</c> is the type-erased open-definition form (because
+    /// <see cref="Type.MakeGenericType(Type[])"/> could not be closed at
+    /// substitution time — typically because the open definition lives in a
+    /// <see cref="System.Reflection.MetadataLoadContext"/> while the
+    /// substituted argument types live in the live runtime) the symbolic
+    /// <see cref="ImportedTypeSymbol.TypeArguments"/> carry the real
+    /// substituted G# types. Match against those, not the erased CLR
+    /// arguments, so the slice still classifies as implicitly convertible to
+    /// the constructed interface.
+    /// </summary>
+    /// <param name="slice">The source slice type.</param>
+    /// <param name="targetInterface">The constructed interface target.</param>
+    /// <returns><see langword="true"/> when the slice's backing array
+    /// implements the target interface.</returns>
+    private static bool SliceImplementsInterface(SliceTypeSymbol slice, TypeSymbol targetInterface)
+    {
+        // Cheap path: the target's CLR generic arguments are already the
+        // properly substituted closed form. Defer to the existing
+        // by-name interface walk.
+        if (ClrTypeUtilities.ImplementsInterfaceByName(slice.ClrType, targetInterface.ClrType))
+        {
+            return true;
+        }
+
+        if (targetInterface is not ImportedTypeSymbol imported
+            || imported.OpenDefinition is null
+            || imported.TypeArguments.IsDefaultOrEmpty)
+        {
+            return false;
+        }
+
+        // Cross-context fallback: walk the slice's backing CLR array
+        // interfaces and match each generic argument against the symbolic
+        // TypeArguments by ClrType FullName, which is assembly-qualifier
+        // free for leaf types (System.Int32, System.String, …) and so
+        // compares correctly across reflection contexts.
+        var openDef = imported.OpenDefinition;
+        foreach (var iface in slice.ClrType.GetInterfaces())
+        {
+            if (!iface.IsGenericType)
+            {
+                continue;
+            }
+
+            if (!string.Equals(
+                    iface.GetGenericTypeDefinition().FullName,
+                    openDef.FullName,
+                    StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            var ifaceArgs = iface.GetGenericArguments();
+            if (ifaceArgs.Length != imported.TypeArguments.Length)
+            {
+                continue;
+            }
+
+            var allMatch = true;
+            for (var i = 0; i < ifaceArgs.Length; i++)
+            {
+                var symbolic = imported.TypeArguments[i];
+                if (symbolic?.ClrType is null
+                    || !string.Equals(ifaceArgs[i].FullName, symbolic.ClrType.FullName, StringComparison.Ordinal))
+                {
+                    allMatch = false;
+                    break;
+                }
+            }
+
+            if (allMatch)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

src/Core/CodeAnalysis/Emit/MethodBodyEmitter.cs

@@ -532,6 +532,58 @@ private static bool IsReferenceCompatible(TypeSymbol a, TypeSymbol b)
             return true;
         }
 
+        // Issue #821: cross-context slice-to-constructed-interface widening
+        // where the target is an <see cref="ImportedTypeSymbol"/> whose
+        // <c>ClrType</c> is the type-erased open-definition form (because
+        // <c>MakeGenericType</c> at substitution time could not produce a
+        // closed CLR type — the open def lives in a MetadataLoadContext while
+        // the arguments live in the host runtime). Match the slice's backing
+        // <c>T[]</c> interfaces against the open definition's full name and
+        // the symbolic <c>TypeArguments</c> by leaf-FullName so the CLR
+        // no-op upcast classifies correctly. Mirrors the binder fallback in
+        // <see cref="Conversion.SliceImplementsInterface"/>.
+        if (a is SliceTypeSymbol aSlice
+            && aSlice.ClrType != null
+            && b is ImportedTypeSymbol bImported
+            && bImported.OpenDefinition is { } bOpenDef
+            && !bImported.TypeArguments.IsDefaultOrEmpty)
+        {
+            foreach (var iface in aSlice.ClrType.GetInterfaces())
+            {
+                if (!iface.IsGenericType
+                    || !string.Equals(
+                        iface.GetGenericTypeDefinition().FullName,
+                        bOpenDef.FullName,
+                        StringComparison.Ordinal))
+                {
+                    continue;
+                }
+
+                var ifaceArgs = iface.GetGenericArguments();
+                if (ifaceArgs.Length != bImported.TypeArguments.Length)
+                {
+                    continue;
+                }
+
+                var allMatch = true;
+                for (var i = 0; i < ifaceArgs.Length; i++)
+                {
+                    var symbolic = bImported.TypeArguments[i];
+                    if (symbolic?.ClrType is null
+                        || !string.Equals(ifaceArgs[i].FullName, symbolic.ClrType.FullName, StringComparison.Ordinal))
+                    {
+                        allMatch = false;
+                        break;
+                    }
+                }
+
+                if (allMatch)
+                {
+                    return true;
+                }
+            }
+        }
+
         return false;
     }
 

src/Core/CodeAnalysis/Emit/ReflectionMetadataEmitter.cs

@@ -5445,6 +5445,59 @@ private static bool TryUnify(TypeSymbol formal, TypeSymbol actual, TypeParameter
             }
         }
 
+        // Issue #821: when the formal is a constructed CLR generic
+        // interface that the actual's backing array satisfies — e.g.
+        // `IEnumerable[T]` / `IList[T]` / `ICollection[T]` /
+        // `IReadOnlyList[T]` (any interface implemented by `T[]`) — and
+        // the actual is a `[]T` slice or `[N]T` fixed-length array,
+        // bridge their generic arguments by locating the matching
+        // interface instantiation on the actual's backing CLR `T[]` and
+        // recursing into the element-type slot. Mirrors the binder's
+        // slice-to-interface classifier (#570) and the
+        // `sequence[T]`-vs-slice/array arm above (#774/#814) at the
+        // static-method / free-function argument-slot inference path so
+        // generic-method-spec construction can recover `T` from a
+        // slice argument when the type parameter only appears in an
+        // interface-typed formal parameter (no `T` in the return).
+        if (formal is ImportedTypeSymbol formalImported
+            && formalImported.ClrType is { IsInterface: true, IsGenericType: true } formalIface
+            && !formalImported.TypeArguments.IsDefaultOrEmpty
+            && (actual is SliceTypeSymbol || actual is ArrayTypeSymbol)
+            && actual?.ClrType is { IsArray: true } actualClrArray)
+        {
+            Type matched = null;
+            foreach (var iface in actualClrArray.GetInterfaces())
+            {
+                if (iface.IsGenericType
+                    && ClrTypeUtilities.AreSame(
+                        iface.GetGenericTypeDefinition(),
+                        formalIface.GetGenericTypeDefinition()))
+                {
+                    matched = iface;
+                    break;
+                }
+            }
+
+            if (matched != null)
+            {
+                var matchedArgs = matched.GetGenericArguments();
+                if (formalImported.TypeArguments.Length == matchedArgs.Length)
+                {
+                    for (int i = 0; i < formalImported.TypeArguments.Length; i++)
+                    {
+                        if (TryUnify(
+                                formalImported.TypeArguments[i],
+                                TypeSymbol.FromClrType(matchedArgs[i]),
+                                tp,
+                                out inferred))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
         var formalArgs = GetGenericTypeArguments(formal);
         var actualArgs = GetGenericTypeArguments(actual);
         if (!formalArgs.IsDefaultOrEmpty && !actualArgs.IsDefaultOrEmpty
@@ -6274,7 +6327,7 @@ private bool TryCreateMemberReferenceForConstructedSymbolicContainer(
         // null ClrType (issue #774), or an AsyncSequenceTypeSymbol with
         // null ClrType.
         var symbolicView = ImportedTypeSymbol.GetConstructed(
-            openDefinition.MakeGenericType(GetErasedObjectArgs(openDefinition)),
+            openDefinition.MakeGenericType(this.GetErasedObjectArgs(openDefinition)),
             openDefinition,
             typeArguments);
 
@@ -6380,18 +6433,39 @@ private static bool TryNormalizeToSymbolicContainer(
         }
     }
 
-    private static Type[] GetErasedObjectArgs(Type openDefinition)
+    // Issue #821: choose the right erased `object` for an open generic
+    // definition's MakeGenericType call. The open def may live in a
+    // MetadataLoadContext (reference-pack assemblies); passing a live
+    // `typeof(object)` to its MakeGenericType raises ArgumentException with
+    // "type was not loaded by the MetadataLoadContext that loaded the
+    // generic type or method." Use `emitCtx.CoreObjectType`, which is the
+    // System.Object resolved through the active reference context, when the
+    // open def lives outside the host runtime.
+    private Type[] GetErasedObjectArgs(Type openDefinition)
     {
         var parameters = openDefinition.GetGenericArguments();
         var result = new Type[parameters.Length];
+        var coreObject = ChooseErasedObjectType(openDefinition);
         for (var i = 0; i < parameters.Length; i++)
         {
-            result[i] = typeof(object);
+            result[i] = coreObject;
         }
 
         return result;
     }
 
+    private Type ChooseErasedObjectType(Type openDefinition)
+    {
+        // Same context as the open def → cheap path.
+        var hostObject = typeof(object);
+        if (openDefinition?.Assembly == hostObject.Assembly)
+        {
+            return hostObject;
+        }
+
+        return this.emitCtx.CoreObjectType ?? hostObject;
+    }
+
     private static MethodInfo ResolveMethodOnOpenDefinition(Type openDefinition, MethodInfo method)
     {
         if (openDefinition == null)