simplify things before merging ILDecoder into FEC

dadhi · dadhi · commit fae0be3547f2 · 2025-04-26T16:06:24.000+02:00
diff --git a/src/FastExpressionCompiler.ILDecoder/ILReader.cs b/src/FastExpressionCompiler.ILDecoder/ILReader.cs
@@ -77,92 +77,77 @@ private ILInstruction Next(ref int position)
             case OperandType.ShortInlineBrTarget:
                 {
                     // 8-bit integer branch target
-                    var shortDelta = ReadSByte(ref position);
-                    return new ShortInlineBrTargetInstruction(offset, opCode, shortDelta);
+                    return new ShortInlineBrTargetInstruction(offset, opCode, ReadSByte(ref position));
                 }
             case OperandType.InlineBrTarget:
                 {
                     // 32-bit integer branch target
-                    var delta = ReadInt32(ref position);
-                    return new InlineBrTargetInstruction(offset, opCode, delta);
+                    return new InlineBrTargetInstruction(offset, opCode, ReadInt32(ref position));
                 }
             case OperandType.ShortInlineI:
                 {
                     // 8-bit integer: 001F  ldc.i4.s, FE12  unaligned.
-                    var int8 = ReadByte(ref position);
-                    return new ShortInlineIInstruction(offset, opCode, int8);
+                    return new ShortInlineIInstruction(offset, opCode, ReadByte(ref position));
                 }
             case OperandType.InlineI:
                 {
                     // 32-bit integer
-                    var int32 = ReadInt32(ref position);
-                    return new InlineIInstruction(offset, opCode, int32);
+                    return new InlineIInstruction(offset, opCode, ReadInt32(ref position));
                 }
             case OperandType.InlineI8:
                 {
                     // 64-bit integer
-                    var int64 = ReadInt64(ref position);
-                    return new InlineI8Instruction(offset, opCode, int64);
+                    return new InlineI8Instruction(offset, opCode, ReadInt64(ref position));
                 }
             case OperandType.ShortInlineR:
                 {
                     // 32-bit IEEE floating point number
-                    var float32 = ReadSingle(ref position);
-                    return new ShortInlineRInstruction(offset, opCode, float32);
+                    return new ShortInlineRInstruction(offset, opCode, ReadSingle(ref position));
                 }
             case OperandType.InlineR:
                 {
                     // 64-bit IEEE floating point number
-                    var float64 = ReadDouble(ref position);
-                    return new InlineRInstruction(offset, opCode, float64);
+                    return new InlineRInstruction(offset, opCode, ReadDouble(ref position));
                 }
             case OperandType.ShortInlineVar:
                 {
                     // 8-bit integer containing the ordinal of a local variable or an argument
-                    var index8 = ReadByte(ref position);
-                    return new ShortInlineVarInstruction(offset, opCode, index8);
+                    return new ShortInlineVarInstruction(offset, opCode, ReadByte(ref position));
                 }
             case OperandType.InlineVar:
                 {
                     // 16-bit integer containing the ordinal of a local variable or an argument
-                    var index16 = ReadUInt16(ref position);
-                    return new InlineVarInstruction(offset, opCode, index16);
+                    return new InlineVarInstruction(offset, opCode, ReadUInt16(ref position));
                 }
             case OperandType.InlineString:
                 {
                     // 32-bit metadata string token
-                    var token = ReadInt32(ref position);
-                    return new InlineStringInstruction(offset, opCode, token, _resolver);
+                    return new InlineStringInstruction(offset, opCode, ReadInt32(ref position), _resolver);
                 }
             case OperandType.InlineSig:
                 {
                     // 32-bit metadata signature token
-                    var token = ReadInt32(ref position);
-                    return new InlineSigInstruction(offset, opCode, token, _resolver);
+                    return new InlineSigInstruction(offset, opCode, ReadInt32(ref position), _resolver);
                 }
             case OperandType.InlineMethod:
                 {
                     // 32-bit metadata token
-                    var token = ReadInt32(ref position);
-                    return new InlineMethodInstruction(offset, opCode, token, _resolver);
+                    return new InlineMethodInstruction(offset, opCode, ReadInt32(ref position), _resolver);
                 }
             case OperandType.InlineField:
                 {
                     // 32-bit metadata token
-                    var token = ReadInt32(ref position);
-                    return new InlineFieldInstruction(_resolver, offset, opCode, token);
+                    return new InlineFieldInstruction(_resolver, offset, opCode, ReadInt32(ref position));
                 }
             case OperandType.InlineType:
                 {
                     // 32-bit metadata token
-                    var token = ReadInt32(ref position);
-                    return new InlineTypeInstruction(offset, opCode, token, _resolver);
+                    return new InlineTypeInstruction(offset, opCode, ReadInt32(ref position), _resolver);
                 }
             case OperandType.InlineTok:
                 {
                     // FieldRef, MethodRef, or TypeRef token
-                    var token = ReadInt32(ref position);
-                    return new InlineTokInstruction(offset, opCode, token, _resolver);
+                    return new InlineTokInstruction(offset, opCode, ReadInt32(ref position), _resolver);
                 }
             case OperandType.InlineSwitch:
                 {
@@ -240,4 +225,4 @@ private double ReadDouble(ref int position)
         position += 8;
         return value;
     }
-}
+}
diff --git a/src/FastExpressionCompiler.ILDecoder/ILReaderFactory.cs b/src/FastExpressionCompiler.ILDecoder/ILReaderFactory.cs
@@ -292,4 +292,5 @@ public static string TypeToCode(this Type type,
 
         return printType?.Invoke(arrayType ?? type, s.ToString()) ?? s.ToString();
     }
-}
+}
+
diff --git a/src/FastExpressionCompiler/FastExpressionCompiler.cs b/src/FastExpressionCompiler/FastExpressionCompiler.cs
@@ -9083,6 +9083,28 @@ internal static StringBuilder AppendName(this StringBuilder sb, object parOrTarg
         internal static StringBuilder AppendLabelName(this StringBuilder sb, LabelTarget target, ref SmallList4<NamedWithIndex> named) =>
             sb.AppendName(target, target.Name, target.Type.ToCode(stripNamespace: true), ref named);
 
+        /// <summary>Returns the standard name (alias) for the well-known primitive type, e.g. Int16 -> short</summary>
+        public static string GetPrimitiveTypeNameAliasOrNull(this Type type) =>
+            Type.GetTypeCode(type) switch
+            {
+                TypeCode.Byte => "byte",
+                TypeCode.SByte => "sbyte",
+                TypeCode.Int16 => "short",
+                TypeCode.Int32 => "int",
+                TypeCode.Int64 => "long",
+                TypeCode.UInt16 => "ushort",
+                TypeCode.UInt32 => "uint",
+                TypeCode.UInt64 => "ulong",
+                TypeCode.Single => "float",
+                TypeCode.Double => "double",
+                TypeCode.Boolean => "bool",
+                TypeCode.Char => "char",
+                TypeCode.String => "string",
+                _ => type == typeof(void) ? "void" :
+                    type == typeof(object) ? "object" :
+                    null
+            };
+
         // todo: @simplify add `addTypeof = false` or use `AppendTypeOf` generally
         /// <summary>Converts the <paramref name="type"/> into the proper C# representation.</summary>
         public static string ToCode(this Type type,
@@ -9108,29 +9130,7 @@ public static string ToCode(this Type type,
                 type = type.GetElementType();
             }
 
-            // the default handling of the built-in types
-            string buildInTypeString = null;
-            if (type == typeof(void))
-                buildInTypeString = "void";
-            else if (type == typeof(object))
-                buildInTypeString = "object";
-            else if (type == typeof(bool))
-                buildInTypeString = "bool";
-            else if (type == typeof(int))
-                buildInTypeString = "int";
-            else if (type == typeof(short))
-                buildInTypeString = "short";
-            else if (type == typeof(byte))
-                buildInTypeString = "byte";
-            else if (type == typeof(double))
-                buildInTypeString = "double";
-            else if (type == typeof(float))
-                buildInTypeString = "float";
-            else if (type == typeof(char))
-                buildInTypeString = "char";
-            else if (type == typeof(string))
-                buildInTypeString = "string";
-
+            var buildInTypeString = type.GetPrimitiveTypeNameAliasOrNull();
             if (buildInTypeString != null)
             {
                 if (arrayType != null)

Original file line number	Diff line number	Diff line change
`@@ -77,92 +77,77 @@ private ILInstruction Next(ref int position)`
`77`	`77`	`case OperandType.ShortInlineBrTarget:`
`78`	`78`	`{`
`79`	`79`	`// 8-bit integer branch target`
`80`		`- var shortDelta = ReadSByte(ref position);`
`81`		`- return new ShortInlineBrTargetInstruction(offset, opCode, shortDelta);`
	`80`	`+ return new ShortInlineBrTargetInstruction(offset, opCode, ReadSByte(ref position));`
`82`	`81`	`}`
`83`	`82`	`case OperandType.InlineBrTarget:`
`84`	`83`	`{`
`85`	`84`	`// 32-bit integer branch target`
`86`		`- var delta = ReadInt32(ref position);`
`87`		`- return new InlineBrTargetInstruction(offset, opCode, delta);`
	`85`	`+ return new InlineBrTargetInstruction(offset, opCode, ReadInt32(ref position));`
`88`	`86`	`}`
`89`	`87`	`case OperandType.ShortInlineI:`
`90`	`88`	`{`
`91`	`89`	`// 8-bit integer: 001F ldc.i4.s, FE12 unaligned.`
`92`		`- var int8 = ReadByte(ref position);`
`93`		`- return new ShortInlineIInstruction(offset, opCode, int8);`
	`90`	`+ return new ShortInlineIInstruction(offset, opCode, ReadByte(ref position));`
`94`	`91`	`}`
`95`	`92`	`case OperandType.InlineI:`
`96`	`93`	`{`
`97`	`94`	`// 32-bit integer`
`98`		`- var int32 = ReadInt32(ref position);`
`99`		`- return new InlineIInstruction(offset, opCode, int32);`
	`95`	`+ return new InlineIInstruction(offset, opCode, ReadInt32(ref position));`
`100`	`96`	`}`
`101`	`97`	`case OperandType.InlineI8:`
`102`	`98`	`{`
`103`	`99`	`// 64-bit integer`
`104`		`- var int64 = ReadInt64(ref position);`
`105`		`- return new InlineI8Instruction(offset, opCode, int64);`
	`100`	`+ return new InlineI8Instruction(offset, opCode, ReadInt64(ref position));`
`106`	`101`	`}`
`107`	`102`	`case OperandType.ShortInlineR:`
`108`	`103`	`{`
`109`	`104`	`// 32-bit IEEE floating point number`
`110`		`- var float32 = ReadSingle(ref position);`
`111`		`- return new ShortInlineRInstruction(offset, opCode, float32);`
	`105`	`+ return new ShortInlineRInstruction(offset, opCode, ReadSingle(ref position));`
`112`	`106`	`}`
`113`	`107`	`case OperandType.InlineR:`
`114`	`108`	`{`
`115`	`109`	`// 64-bit IEEE floating point number`
`116`		`- var float64 = ReadDouble(ref position);`
`117`		`- return new InlineRInstruction(offset, opCode, float64);`
	`110`	`+ return new InlineRInstruction(offset, opCode, ReadDouble(ref position));`
`118`	`111`	`}`
`119`	`112`	`case OperandType.ShortInlineVar:`
`120`	`113`	`{`
`121`	`114`	`// 8-bit integer containing the ordinal of a local variable or an argument`
`122`		`- var index8 = ReadByte(ref position);`
`123`		`- return new ShortInlineVarInstruction(offset, opCode, index8);`
	`115`	`+ return new ShortInlineVarInstruction(offset, opCode, ReadByte(ref position));`
`124`	`116`	`}`
`125`	`117`	`case OperandType.InlineVar:`
`126`	`118`	`{`
`127`	`119`	`// 16-bit integer containing the ordinal of a local variable or an argument`
`128`		`- var index16 = ReadUInt16(ref position);`
`129`		`- return new InlineVarInstruction(offset, opCode, index16);`
	`120`	`+ return new InlineVarInstruction(offset, opCode, ReadUInt16(ref position));`
`130`	`121`	`}`
`131`	`122`	`case OperandType.InlineString:`
`132`	`123`	`{`
`133`	`124`	`// 32-bit metadata string token`
`134`		`- var token = ReadInt32(ref position);`
`135`		`- return new InlineStringInstruction(offset, opCode, token, _resolver);`
	`125`	`+ return new InlineStringInstruction(offset, opCode, ReadInt32(ref position), _resolver);`
`136`	`126`	`}`
`137`	`127`	`case OperandType.InlineSig:`
`138`	`128`	`{`
`139`	`129`	`// 32-bit metadata signature token`
`140`		`- var token = ReadInt32(ref position);`
`141`		`- return new InlineSigInstruction(offset, opCode, token, _resolver);`
	`130`	`+ return new InlineSigInstruction(offset, opCode, ReadInt32(ref position), _resolver);`
`142`	`131`	`}`
`143`	`132`	`case OperandType.InlineMethod:`
`144`	`133`	`{`
`145`	`134`	`// 32-bit metadata token`
`146`		`- var token = ReadInt32(ref position);`
`147`		`- return new InlineMethodInstruction(offset, opCode, token, _resolver);`
	`135`	`+ return new InlineMethodInstruction(offset, opCode, ReadInt32(ref position), _resolver);`
`148`	`136`	`}`
`149`	`137`	`case OperandType.InlineField:`
`150`	`138`	`{`
`151`	`139`	`// 32-bit metadata token`
`152`		`- var token = ReadInt32(ref position);`
`153`		`- return new InlineFieldInstruction(_resolver, offset, opCode, token);`
	`140`	`+ return new InlineFieldInstruction(_resolver, offset, opCode, ReadInt32(ref position));`
`154`	`141`	`}`
`155`	`142`	`case OperandType.InlineType:`
`156`	`143`	`{`
`157`	`144`	`// 32-bit metadata token`
`158`		`- var token = ReadInt32(ref position);`
`159`		`- return new InlineTypeInstruction(offset, opCode, token, _resolver);`
	`145`	`+ return new InlineTypeInstruction(offset, opCode, ReadInt32(ref position), _resolver);`
`160`	`146`	`}`
`161`	`147`	`case OperandType.InlineTok:`
`162`	`148`	`{`
`163`	`149`	`// FieldRef, MethodRef, or TypeRef token`
`164`		`- var token = ReadInt32(ref position);`
`165`		`- return new InlineTokInstruction(offset, opCode, token, _resolver);`
	`150`	`+ return new InlineTokInstruction(offset, opCode, ReadInt32(ref position), _resolver);`
`166`	`151`	`}`
`167`	`152`	`case OperandType.InlineSwitch:`
`168`	`153`	`{`
`@@ -240,4 +225,4 @@ private double ReadDouble(ref int position)`
`240`	`225`	`position += 8;`
`241`	`226`	`return value;`
`242`	`227`	`}`
`243`		`-}`
	`228`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -292,4 +292,5 @@ public static string TypeToCode(this Type type,`
`292`	`292`
`293`	`293`	`return printType?.Invoke(arrayType ?? type, s.ToString()) ?? s.ToString();`
`294`	`294`	`}`
`295`		`-}`
	`295`	`+}`
	`296`	`+`