@tsonic/dotnet 0.7.3 → 0.7.6

package/System.Linq/internal/metadata.json

@@ -4897,7 +4897,13 @@
           "isSealed": false,
           "arity": 1,
           "parameterCount": 2,
-          "isExtensionMethod": true
+          "isExtensionMethod": true,
+          "parameterModifiers": [
+            {
+              "index": 1,
+              "modifier": "out"
+            }
+          ]
         },
         {
           "stableId": "System.Linq:System.Linq.Enumerable::LongCount(IEnumerable_1):System.Int64",

package/System.Linq.Expressions/bindings.json

@@ -25889,7 +25889,13 @@
           "parameterCount": 2,
           "declaringClrType": "System.Linq.Expressions.Expression",
           "declaringAssemblyName": "System.Linq.Expressions",
-          "isExtensionMethod": false
+          "isExtensionMethod": false,
+          "parameterModifiers": [
+            {
+              "index": 1,
+              "modifier": "out"
+            }
+          ]
         },
         {
           "stableId": "System.Linq.Expressions:System.Linq.Expressions.Expression::GetActionType(System.Type[]):System.Type",
@@ -25917,7 +25923,13 @@
           "parameterCount": 2,
           "declaringClrType": "System.Linq.Expressions.Expression",
           "declaringAssemblyName": "System.Linq.Expressions",
-          "isExtensionMethod": false
+          "isExtensionMethod": false,
+          "parameterModifiers": [
+            {
+              "index": 1,
+              "modifier": "out"
+            }
+          ]
         },
         {
           "stableId": "System.Linq.Expressions:System.Linq.Expressions.Expression::GetDelegateType(System.Type[]):System.Type",

package/System.Linq.Expressions/internal/index.d.ts

@@ -6,7 +6,7 @@
 import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';
 
 // Import support types from @tsonic/types
-import type { ptr, ref } from "@tsonic/types";
+import type { ptr } from "@tsonic/types";
 
 // Import types from other namespaces
 import type { IEnumerable_1 } from "../../System.Collections.Generic/internal/index.js";
@@ -16,31 +16,6 @@ import type { CallSiteBinder, DebugInfoGenerator } from "../../System.Runtime.Co
 import * as System_Internal from "../../System/internal/index.js";
 import type { Boolean as ClrBoolean, Delegate, Enum, Func_2, Guid, IComparable, IConvertible, IFormatProvider, IFormattable, Int32, ISpanFormattable, Object as ClrObject, String as ClrString, Type, TypeCode } from "../../System/internal/index.js";
 
-// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
-// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
-// Value positions (parameters, return types) use lowercase primitives for ergonomics
-export type CLROf<T> =
-    T extends sbyte ? System_Internal.SByte :
-    T extends short ? System_Internal.Int16 :
-    T extends int ? System_Internal.Int32 :
-    T extends long ? System_Internal.Int64 :
-    T extends int128 ? System_Internal.Int128 :
-    T extends nint ? System_Internal.IntPtr :
-    T extends byte ? System_Internal.Byte :
-    T extends ushort ? System_Internal.UInt16 :
-    T extends uint ? System_Internal.UInt32 :
-    T extends ulong ? System_Internal.UInt64 :
-    T extends uint128 ? System_Internal.UInt128 :
-    T extends nuint ? System_Internal.UIntPtr :
-    T extends half ? System_Internal.Half :
-    T extends float ? System_Internal.Single :
-    T extends double ? System_Internal.Double :
-    T extends decimal ? System_Internal.Decimal :
-    T extends char ? System_Internal.Char :
-    T extends boolean ? System_Internal.Boolean :
-    T extends string ? System_Internal.String :
-    T; // Identity fallback for non-primitive types
-
 export enum ExpressionType {
     add = 0,
     addChecked = 1,
@@ -302,13 +277,13 @@ export const DynamicExpression: {
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression): DynamicExpression;
-    dynamic(binder: CallSiteBinder, returnType: Type, arguments: Expression[]): DynamicExpression;
+    dynamic(binder: CallSiteBinder, returnType: Type, ...arguments: Expression[]): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arguments: IEnumerable_1<Expression>): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression): DynamicExpression;
-    makeDynamic(delegateType: Type, binder: CallSiteBinder, arguments: Expression[]): DynamicExpression;
+    makeDynamic(delegateType: Type, binder: CallSiteBinder, ...arguments: Expression[]): DynamicExpression;
 };
 
 
@@ -387,26 +362,26 @@ export const Expression: {
     andAssign(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     andAssign(left: Expression, right: Expression): BinaryExpression;
     arrayAccess(array: Expression, indexes: IEnumerable_1<Expression>): IndexExpression;
-    arrayAccess(array: Expression, indexes: Expression[]): IndexExpression;
+    arrayAccess(array: Expression, ...indexes: Expression[]): IndexExpression;
     arrayIndex(array: Expression, indexes: IEnumerable_1<Expression>): MethodCallExpression;
     arrayIndex(array: Expression, index: Expression): BinaryExpression;
-    arrayIndex(array: Expression, indexes: Expression[]): MethodCallExpression;
+    arrayIndex(array: Expression, ...indexes: Expression[]): MethodCallExpression;
     arrayLength(array: Expression): UnaryExpression;
     assign(left: Expression, right: Expression): BinaryExpression;
     bind(member: MemberInfo, expression: Expression): MemberAssignment;
     bind(propertyAccessor: MethodInfo, expression: Expression): MemberAssignment;
     block(expressions: IEnumerable_1<Expression>): BlockExpression;
     block(variables: IEnumerable_1<ParameterExpression>, expressions: IEnumerable_1<Expression>): BlockExpression;
-    block(variables: IEnumerable_1<ParameterExpression>, expressions: Expression[]): BlockExpression;
+    block(variables: IEnumerable_1<ParameterExpression>, ...expressions: Expression[]): BlockExpression;
     block(arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression, arg4: Expression): BlockExpression;
     block(arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression): BlockExpression;
     block(arg0: Expression, arg1: Expression, arg2: Expression): BlockExpression;
     block(arg0: Expression, arg1: Expression): BlockExpression;
-    block(expressions: Expression[]): BlockExpression;
+    block(...expressions: Expression[]): BlockExpression;
     block(type_: Type, expressions: IEnumerable_1<Expression>): BlockExpression;
     block(type_: Type, variables: IEnumerable_1<ParameterExpression>, expressions: IEnumerable_1<Expression>): BlockExpression;
-    block(type_: Type, variables: IEnumerable_1<ParameterExpression>, expressions: Expression[]): BlockExpression;
-    block(type_: Type, expressions: Expression[]): BlockExpression;
+    block(type_: Type, variables: IEnumerable_1<ParameterExpression>, ...expressions: Expression[]): BlockExpression;
+    block(type_: Type, ...expressions: Expression[]): BlockExpression;
     break_(target: LabelTarget, value: Expression, type_: Type): GotoExpression;
     break_(target: LabelTarget, value: Expression): GotoExpression;
     break_(target: LabelTarget, type_: Type): GotoExpression;
@@ -414,17 +389,17 @@ export const Expression: {
     call(instance: Expression, method: MethodInfo, arguments: IEnumerable_1<Expression>): MethodCallExpression;
     call(instance: Expression, method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression): MethodCallExpression;
     call(instance: Expression, method: MethodInfo, arg0: Expression, arg1: Expression): MethodCallExpression;
-    call(instance: Expression, method: MethodInfo, arguments: Expression[]): MethodCallExpression;
+    call(instance: Expression, method: MethodInfo, ...arguments: Expression[]): MethodCallExpression;
     call(instance: Expression, method: MethodInfo): MethodCallExpression;
-    call(instance: Expression, methodName: string, typeArguments: Type[], arguments: Expression[]): MethodCallExpression;
+    call(instance: Expression, methodName: string, typeArguments: Type[], ...arguments: Expression[]): MethodCallExpression;
     call(method: MethodInfo, arguments: IEnumerable_1<Expression>): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression, arg4: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression, arg3: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression, arg2: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression, arg1: Expression): MethodCallExpression;
     call(method: MethodInfo, arg0: Expression): MethodCallExpression;
-    call(method: MethodInfo, arguments: Expression[]): MethodCallExpression;
-    call(type_: Type, methodName: string, typeArguments: Type[], arguments: Expression[]): MethodCallExpression;
+    call(method: MethodInfo, ...arguments: Expression[]): MethodCallExpression;
+    call(type_: Type, methodName: string, typeArguments: Type[], ...arguments: Expression[]): MethodCallExpression;
     catch_(variable: ParameterExpression, body: Expression, filter: Expression): CatchBlock;
     catch_(variable: ParameterExpression, body: Expression): CatchBlock;
     catch_(type_: Type, body: Expression, filter: Expression): CatchBlock;
@@ -456,9 +431,9 @@ export const Expression: {
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression, arg1: Expression): DynamicExpression;
     dynamic(binder: CallSiteBinder, returnType: Type, arg0: Expression): DynamicExpression;
-    dynamic(binder: CallSiteBinder, returnType: Type, arguments: Expression[]): DynamicExpression;
+    dynamic(binder: CallSiteBinder, returnType: Type, ...arguments: Expression[]): DynamicExpression;
     elementInit(addMethod: MethodInfo, arguments: IEnumerable_1<Expression>): ElementInit;
-    elementInit(addMethod: MethodInfo, arguments: Expression[]): ElementInit;
+    elementInit(addMethod: MethodInfo, ...arguments: Expression[]): ElementInit;
     empty(): DefaultExpression;
     equal(left: Expression, right: Expression, liftToNull: boolean, method: MethodInfo): BinaryExpression;
     equal(left: Expression, right: Expression): BinaryExpression;
@@ -470,9 +445,9 @@ export const Expression: {
     field(expression: Expression, field: FieldInfo): MemberExpression;
     field(expression: Expression, fieldName: string): MemberExpression;
     field(expression: Expression, type_: Type, fieldName: string): MemberExpression;
-    getActionType(typeArgs: Type[]): Type;
-    getDelegateType(typeArgs: Type[]): Type;
-    getFuncType(typeArgs: Type[]): Type;
+    getActionType(...typeArgs: Type[]): Type;
+    getDelegateType(...typeArgs: Type[]): Type;
+    getFuncType(...typeArgs: Type[]): Type;
     goto(target: LabelTarget, value: Expression, type_: Type): GotoExpression;
     goto(target: LabelTarget, value: Expression): GotoExpression;
     goto(target: LabelTarget, type_: Type): GotoExpression;
@@ -486,7 +461,7 @@ export const Expression: {
     increment(expression: Expression, method: MethodInfo): UnaryExpression;
     increment(expression: Expression): UnaryExpression;
     invoke(expression: Expression, arguments: IEnumerable_1<Expression>): InvocationExpression;
-    invoke(expression: Expression, arguments: Expression[]): InvocationExpression;
+    invoke(expression: Expression, ...arguments: Expression[]): InvocationExpression;
     isFalse(expression: Expression, method: MethodInfo): UnaryExpression;
     isFalse(expression: Expression): UnaryExpression;
     isTrue(expression: Expression, method: MethodInfo): UnaryExpression;
@@ -499,20 +474,20 @@ export const Expression: {
     label(type_: Type): LabelTarget;
     lambda<TDelegate>(body: Expression, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda<TDelegate>(body: Expression, tailCall: boolean, parameters: ParameterExpression[]): Expression_1<TDelegate>;
-    lambda(body: Expression, tailCall: boolean, parameters: ParameterExpression[]): LambdaExpression;
+    lambda<TDelegate>(body: Expression, tailCall: boolean, ...parameters: ParameterExpression[]): Expression_1<TDelegate>;
+    lambda(body: Expression, tailCall: boolean, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda<TDelegate>(body: Expression, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda<TDelegate>(body: Expression, parameters: ParameterExpression[]): Expression_1<TDelegate>;
-    lambda(body: Expression, parameters: ParameterExpression[]): LambdaExpression;
+    lambda<TDelegate>(body: Expression, ...parameters: ParameterExpression[]): Expression_1<TDelegate>;
+    lambda(body: Expression, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda<TDelegate>(body: Expression, name: string, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, name: string, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     lambda<TDelegate>(body: Expression, name: string, parameters: IEnumerable_1<ParameterExpression>): Expression_1<TDelegate>;
     lambda(body: Expression, name: string, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     lambda(delegateType: Type, body: Expression, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda(delegateType: Type, body: Expression, tailCall: boolean, parameters: ParameterExpression[]): LambdaExpression;
+    lambda(delegateType: Type, body: Expression, tailCall: boolean, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda(delegateType: Type, body: Expression, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
-    lambda(delegateType: Type, body: Expression, parameters: ParameterExpression[]): LambdaExpression;
+    lambda(delegateType: Type, body: Expression, ...parameters: ParameterExpression[]): LambdaExpression;
     lambda(delegateType: Type, body: Expression, name: string, tailCall: boolean, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     lambda(delegateType: Type, body: Expression, name: string, parameters: IEnumerable_1<ParameterExpression>): LambdaExpression;
     leftShift(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
@@ -525,15 +500,15 @@ export const Expression: {
     lessThanOrEqual(left: Expression, right: Expression, liftToNull: boolean, method: MethodInfo): BinaryExpression;
     lessThanOrEqual(left: Expression, right: Expression): BinaryExpression;
     listBind(member: MemberInfo, initializers: IEnumerable_1<ElementInit>): MemberListBinding;
-    listBind(member: MemberInfo, initializers: ElementInit[]): MemberListBinding;
+    listBind(member: MemberInfo, ...initializers: ElementInit[]): MemberListBinding;
     listBind(propertyAccessor: MethodInfo, initializers: IEnumerable_1<ElementInit>): MemberListBinding;
-    listBind(propertyAccessor: MethodInfo, initializers: ElementInit[]): MemberListBinding;
+    listBind(propertyAccessor: MethodInfo, ...initializers: ElementInit[]): MemberListBinding;
     listInit(newExpression: NewExpression, initializers: IEnumerable_1<ElementInit>): ListInitExpression;
     listInit(newExpression: NewExpression, initializers: IEnumerable_1<Expression>): ListInitExpression;
-    listInit(newExpression: NewExpression, initializers: ElementInit[]): ListInitExpression;
-    listInit(newExpression: NewExpression, initializers: Expression[]): ListInitExpression;
+    listInit(newExpression: NewExpression, ...initializers: ElementInit[]): ListInitExpression;
+    listInit(newExpression: NewExpression, ...initializers: Expression[]): ListInitExpression;
     listInit(newExpression: NewExpression, addMethod: MethodInfo, initializers: IEnumerable_1<Expression>): ListInitExpression;
-    listInit(newExpression: NewExpression, addMethod: MethodInfo, initializers: Expression[]): ListInitExpression;
+    listInit(newExpression: NewExpression, addMethod: MethodInfo, ...initializers: Expression[]): ListInitExpression;
     loop(body: Expression, break_: LabelTarget, continue_: LabelTarget): LoopExpression;
     loop(body: Expression, break_: LabelTarget): LoopExpression;
     loop(body: Expression): LoopExpression;
@@ -546,7 +521,7 @@ export const Expression: {
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression, arg2: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression, arg1: Expression): DynamicExpression;
     makeDynamic(delegateType: Type, binder: CallSiteBinder, arg0: Expression): DynamicExpression;
-    makeDynamic(delegateType: Type, binder: CallSiteBinder, arguments: Expression[]): DynamicExpression;
+    makeDynamic(delegateType: Type, binder: CallSiteBinder, ...arguments: Expression[]): DynamicExpression;
     makeGoto(kind: GotoExpressionKind, target: LabelTarget, value: Expression, type_: Type): GotoExpression;
     makeIndex(instance: Expression, indexer: PropertyInfo, arguments: IEnumerable_1<Expression>): IndexExpression;
     makeMemberAccess(expression: Expression, member: MemberInfo): MemberExpression;
@@ -554,11 +529,11 @@ export const Expression: {
     makeUnary(unaryType: ExpressionType, operand: Expression, type_: Type, method: MethodInfo): UnaryExpression;
     makeUnary(unaryType: ExpressionType, operand: Expression, type_: Type): UnaryExpression;
     memberBind(member: MemberInfo, bindings: IEnumerable_1<MemberBinding>): MemberMemberBinding;
-    memberBind(member: MemberInfo, bindings: MemberBinding[]): MemberMemberBinding;
+    memberBind(member: MemberInfo, ...bindings: MemberBinding[]): MemberMemberBinding;
     memberBind(propertyAccessor: MethodInfo, bindings: IEnumerable_1<MemberBinding>): MemberMemberBinding;
-    memberBind(propertyAccessor: MethodInfo, bindings: MemberBinding[]): MemberMemberBinding;
+    memberBind(propertyAccessor: MethodInfo, ...bindings: MemberBinding[]): MemberMemberBinding;
     memberInit(newExpression: NewExpression, bindings: IEnumerable_1<MemberBinding>): MemberInitExpression;
-    memberInit(newExpression: NewExpression, bindings: MemberBinding[]): MemberInitExpression;
+    memberInit(newExpression: NewExpression, ...bindings: MemberBinding[]): MemberInitExpression;
     modulo(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     modulo(left: Expression, right: Expression): BinaryExpression;
     moduloAssign(left: Expression, right: Expression, method: MethodInfo, conversion: LambdaExpression): BinaryExpression;
@@ -579,15 +554,15 @@ export const Expression: {
     negateChecked(expression: Expression, method: MethodInfo): UnaryExpression;
     negateChecked(expression: Expression): UnaryExpression;
     new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>, members: IEnumerable_1<MemberInfo>): NewExpression;
-    new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>, members: MemberInfo[]): NewExpression;
+    new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>, ...members: MemberInfo[]): NewExpression;
     new_(constructor_: ConstructorInfo, arguments: IEnumerable_1<Expression>): NewExpression;
-    new_(constructor_: ConstructorInfo, arguments: Expression[]): NewExpression;
+    new_(constructor_: ConstructorInfo, ...arguments: Expression[]): NewExpression;
     new_(constructor_: ConstructorInfo): NewExpression;
     new_(type_: Type): NewExpression;
     newArrayBounds(type_: Type, bounds: IEnumerable_1<Expression>): NewArrayExpression;
-    newArrayBounds(type_: Type, bounds: Expression[]): NewArrayExpression;
+    newArrayBounds(type_: Type, ...bounds: Expression[]): NewArrayExpression;
     newArrayInit(type_: Type, initializers: IEnumerable_1<Expression>): NewArrayExpression;
-    newArrayInit(type_: Type, initializers: Expression[]): NewArrayExpression;
+    newArrayInit(type_: Type, ...initializers: Expression[]): NewArrayExpression;
     not(expression: Expression, method: MethodInfo): UnaryExpression;
     not(expression: Expression): UnaryExpression;
     notEqual(left: Expression, right: Expression, liftToNull: boolean, method: MethodInfo): BinaryExpression;
@@ -618,9 +593,9 @@ export const Expression: {
     preIncrementAssign(expression: Expression): UnaryExpression;
     property(expression: Expression, propertyAccessor: MethodInfo): MemberExpression;
     property(instance: Expression, indexer: PropertyInfo, arguments: IEnumerable_1<Expression>): IndexExpression;
-    property(instance: Expression, indexer: PropertyInfo, arguments: Expression[]): IndexExpression;
+    property(instance: Expression, indexer: PropertyInfo, ...arguments: Expression[]): IndexExpression;
     property(expression: Expression, property: PropertyInfo): MemberExpression;
-    property(instance: Expression, propertyName: string, arguments: Expression[]): IndexExpression;
+    property(instance: Expression, propertyName: string, ...arguments: Expression[]): IndexExpression;
     property(expression: Expression, propertyName: string): MemberExpression;
     property(expression: Expression, type_: Type, propertyName: string): MemberExpression;
     propertyOrField(expression: Expression, propertyOrFieldName: string): MemberExpression;
@@ -639,7 +614,7 @@ export const Expression: {
     rightShiftAssign(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     rightShiftAssign(left: Expression, right: Expression): BinaryExpression;
     runtimeVariables(variables: IEnumerable_1<ParameterExpression>): RuntimeVariablesExpression;
-    runtimeVariables(variables: ParameterExpression[]): RuntimeVariablesExpression;
+    runtimeVariables(...variables: ParameterExpression[]): RuntimeVariablesExpression;
     subtract(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     subtract(left: Expression, right: Expression): BinaryExpression;
     subtractAssign(left: Expression, right: Expression, method: MethodInfo, conversion: LambdaExpression): BinaryExpression;
@@ -650,26 +625,26 @@ export const Expression: {
     subtractAssignChecked(left: Expression, right: Expression): BinaryExpression;
     subtractChecked(left: Expression, right: Expression, method: MethodInfo): BinaryExpression;
     subtractChecked(left: Expression, right: Expression): BinaryExpression;
-    switch_(switchValue: Expression, defaultBody: Expression, cases: SwitchCase[]): SwitchExpression;
+    switch_(switchValue: Expression, defaultBody: Expression, ...cases: SwitchCase[]): SwitchExpression;
     switch_(switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: IEnumerable_1<SwitchCase>): SwitchExpression;
-    switch_(switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: SwitchCase[]): SwitchExpression;
-    switch_(switchValue: Expression, cases: SwitchCase[]): SwitchExpression;
+    switch_(switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, ...cases: SwitchCase[]): SwitchExpression;
+    switch_(switchValue: Expression, ...cases: SwitchCase[]): SwitchExpression;
     switch_(type_: Type, switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: IEnumerable_1<SwitchCase>): SwitchExpression;
-    switch_(type_: Type, switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, cases: SwitchCase[]): SwitchExpression;
+    switch_(type_: Type, switchValue: Expression, defaultBody: Expression, comparison: MethodInfo, ...cases: SwitchCase[]): SwitchExpression;
     switchCase(body: Expression, testValues: IEnumerable_1<Expression>): SwitchCase;
-    switchCase(body: Expression, testValues: Expression[]): SwitchCase;
+    switchCase(body: Expression, ...testValues: Expression[]): SwitchCase;
     symbolDocument(fileName: string, language: Guid, languageVendor: Guid, documentType: Guid): SymbolDocumentInfo;
     symbolDocument(fileName: string, language: Guid, languageVendor: Guid): SymbolDocumentInfo;
     symbolDocument(fileName: string, language: Guid): SymbolDocumentInfo;
     symbolDocument(fileName: string): SymbolDocumentInfo;
     throw_(value: Expression, type_: Type): UnaryExpression;
     throw_(value: Expression): UnaryExpression;
-    tryCatch(body: Expression, handlers: CatchBlock[]): TryExpression;
-    tryCatchFinally(body: Expression, finally_: Expression, handlers: CatchBlock[]): TryExpression;
+    tryCatch(body: Expression, ...handlers: CatchBlock[]): TryExpression;
+    tryCatchFinally(body: Expression, finally_: Expression, ...handlers: CatchBlock[]): TryExpression;
     tryFault(body: Expression, fault: Expression): TryExpression;
     tryFinally(body: Expression, finally_: Expression): TryExpression;
-    tryGetActionType(typeArgs: Type[], actionType: { value: ref<Type> }): boolean;
-    tryGetFuncType(typeArgs: Type[], funcType: { value: ref<Type> }): boolean;
+    tryGetActionType(typeArgs: Type[], actionType: Type): boolean;
+    tryGetFuncType(typeArgs: Type[], funcType: Type): boolean;
     typeAs(expression: Expression, type_: Type): UnaryExpression;
     typeEqual(expression: Expression, type_: Type): TypeBinaryExpression;
     typeIs(expression: Expression, type_: Type): TypeBinaryExpression;

package/System.Linq.Expressions/internal/metadata.json

@@ -5398,7 +5398,13 @@
           "isSealed": false,
           "arity": 0,
           "parameterCount": 2,
-          "isExtensionMethod": false
+          "isExtensionMethod": false,
+          "parameterModifiers": [
+            {
+              "index": 1,
+              "modifier": "out"
+            }
+          ]
         },
         {
           "stableId": "System.Linq.Expressions:System.Linq.Expressions.Expression::GetActionType(System.Type[]):System.Type",
@@ -5430,7 +5436,13 @@
           "isSealed": false,
           "arity": 0,
           "parameterCount": 2,
-          "isExtensionMethod": false
+          "isExtensionMethod": false,
+          "parameterModifiers": [
+            {
+              "index": 1,
+              "modifier": "out"
+            }
+          ]
         },
         {
           "stableId": "System.Linq.Expressions:System.Linq.Expressions.Expression::GetDelegateType(System.Type[]):System.Type",

package/System.Linq.Expressions.Interpreter/internal/index.d.ts

@@ -9,34 +9,9 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 import * as System_Internal from "../../System/internal/index.js";
 import type { Boolean as ClrBoolean, Int32, Object as ClrObject, String as ClrString, Type } from "../../System/internal/index.js";
 
-// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
-// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
-// Value positions (parameters, return types) use lowercase primitives for ergonomics
-export type CLROf<T> =
-    T extends sbyte ? System_Internal.SByte :
-    T extends short ? System_Internal.Int16 :
-    T extends int ? System_Internal.Int32 :
-    T extends long ? System_Internal.Int64 :
-    T extends int128 ? System_Internal.Int128 :
-    T extends nint ? System_Internal.IntPtr :
-    T extends byte ? System_Internal.Byte :
-    T extends ushort ? System_Internal.UInt16 :
-    T extends uint ? System_Internal.UInt32 :
-    T extends ulong ? System_Internal.UInt64 :
-    T extends uint128 ? System_Internal.UInt128 :
-    T extends nuint ? System_Internal.UIntPtr :
-    T extends half ? System_Internal.Half :
-    T extends float ? System_Internal.Single :
-    T extends double ? System_Internal.Double :
-    T extends decimal ? System_Internal.Decimal :
-    T extends char ? System_Internal.Char :
-    T extends boolean ? System_Internal.Boolean :
-    T extends string ? System_Internal.String :
-    T; // Identity fallback for non-primitive types
-
 export interface LightLambda$instance {
-    run(arguments: unknown[]): unknown;
-    runVoid(arguments: unknown[]): unknown;
+    run(...arguments: unknown[]): unknown;
+    runVoid(...arguments: unknown[]): unknown;
 }
 
 

package/System.Linq.Expressions.d.ts

@@ -14,7 +14,6 @@ import type { Boolean as ClrBoolean, Delegate, Enum, Func_2, Guid, IComparable,
 
 // Public API exports (curated - no internal $instance/$views leakage)
 export { BinaryExpression as BinaryExpression } from './System.Linq.Expressions/internal/index.js';
-export { Expression as Expression_0 } from './System.Linq.Expressions/internal/index.js';
 export { BlockExpression as BlockExpression } from './System.Linq.Expressions/internal/index.js';
 export { CatchBlock as CatchBlock } from './System.Linq.Expressions/internal/index.js';
 export { ConditionalExpression as ConditionalExpression } from './System.Linq.Expressions/internal/index.js';
@@ -33,7 +32,6 @@ export { InvocationExpression as InvocationExpression } from './System.Linq.Expr
 export { LabelExpression as LabelExpression } from './System.Linq.Expressions/internal/index.js';
 export { LabelTarget as LabelTarget } from './System.Linq.Expressions/internal/index.js';
 export { LambdaExpression as LambdaExpression } from './System.Linq.Expressions/internal/index.js';
-export { Expression_1 as Expression } from './System.Linq.Expressions/internal/index.js';
 export { ListInitExpression as ListInitExpression } from './System.Linq.Expressions/internal/index.js';
 export { LoopExpression as LoopExpression } from './System.Linq.Expressions/internal/index.js';
 export { MemberAssignment as MemberAssignment } from './System.Linq.Expressions/internal/index.js';
@@ -56,3 +54,14 @@ export { TypeBinaryExpression as TypeBinaryExpression } from './System.Linq.Expr
 export { UnaryExpression as UnaryExpression } from './System.Linq.Expressions/internal/index.js';
 export { DynamicExpressionVisitor as DynamicExpressionVisitor } from './System.Linq.Expressions/internal/index.js';
 export { DynamicExpression as DynamicExpression } from './System.Linq.Expressions/internal/index.js';
+
+// Multi-arity family sentinel (detects unspecified type parameters)
+declare const __unspecified: unique symbol;
+export type __ = typeof __unspecified;
+
+export type Expression<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.Expression :
+  Internal.Expression_1<T1>;
+

package/System.Linq.d.ts

@@ -25,19 +25,44 @@ export { Lookup_2 as Lookup } from './System.Linq/internal/index.js';
 export type IOrderedEnumerable<TElement> = Internal.IOrderedEnumerable_1<TElement>;
 export { AsyncEnumerable$instance as AsyncEnumerable } from './System.Linq/internal/index.js';
 export type IOrderedAsyncEnumerable<TElement> = Internal.IOrderedAsyncEnumerable_1<TElement>;
-export type IQueryable_0 = Internal.IQueryable;
-export type IQueryable<T> = Internal.IQueryable_1<T>;
 export type IQueryProvider = Internal.IQueryProvider;
-export type IOrderedQueryable_0 = Internal.IOrderedQueryable;
-export type IOrderedQueryable<T> = Internal.IOrderedQueryable_1<T>;
 export { OrderedParallelQuery_1 as OrderedParallelQuery } from './System.Linq/internal/index.js';
-export { ParallelQuery as ParallelQuery_0 } from './System.Linq/internal/index.js';
-export { ParallelQuery_1 as ParallelQuery } from './System.Linq/internal/index.js';
 export { ParallelEnumerable$instance as ParallelEnumerable } from './System.Linq/internal/index.js';
 export { ParallelExecutionMode as ParallelExecutionMode } from './System.Linq/internal/index.js';
 export { ParallelMergeOptions as ParallelMergeOptions } from './System.Linq/internal/index.js';
-export { EnumerableExecutor as EnumerableExecutor_0 } from './System.Linq/internal/index.js';
-export { EnumerableExecutor_1 as EnumerableExecutor } from './System.Linq/internal/index.js';
-export { EnumerableQuery as EnumerableQuery_0 } from './System.Linq/internal/index.js';
-export { EnumerableQuery_1 as EnumerableQuery } from './System.Linq/internal/index.js';
 export { Queryable$instance as Queryable } from './System.Linq/internal/index.js';
+
+// Multi-arity family sentinel (detects unspecified type parameters)
+declare const __unspecified: unique symbol;
+export type __ = typeof __unspecified;
+
+export type EnumerableExecutor<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.EnumerableExecutor :
+  Internal.EnumerableExecutor_1<T1>;
+
+export type EnumerableQuery<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.EnumerableQuery :
+  Internal.EnumerableQuery_1<T1>;
+
+export type IOrderedQueryable<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.IOrderedQueryable :
+  Internal.IOrderedQueryable_1<T1>;
+
+export type IQueryable<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.IQueryable :
+  Internal.IQueryable_1<T1>;
+
+export type ParallelQuery<
+  T1 = __,
+> =
+  [T1] extends [__] ? Internal.ParallelQuery :
+  Internal.ParallelQuery_1<T1>;
+