Revert

WoofWare.PawPrint.Domain/Assembly.fs

@@ -423,8 +423,8 @@ module Assembly =
     let rec resolveTypeRef
         (assemblies : ImmutableDictionary<string, DumpedAssembly>)
         (referencedInAssembly : DumpedAssembly)
-        (target : TypeRef)
         (genericArgs : ImmutableArray<TypeDefn>)
+        (target : TypeRef)
         : TypeResolutionResult
         =
         match target.ResolutionScope with
@@ -495,7 +495,7 @@ module Assembly =
         | None ->
 
         match assy.TypeRef ns name with
-        | Some typeRef -> resolveTypeRef assemblies assy typeRef genericArgs
+        | Some typeRef -> resolveTypeRef assemblies assy genericArgs typeRef
         | None ->
 
         match assy.ExportedType (Some ns) name with
@@ -532,7 +532,7 @@ module DumpedAssembly =
             | Some (BaseTypeInfo.TypeRef r) ->
                 let assy = loadedAssemblies.[source.FullName]
                 // TODO: generics
-                match Assembly.resolveTypeRef loadedAssemblies assy assy.TypeRefs.[r] ImmutableArray.Empty with
+                match Assembly.resolveTypeRef loadedAssemblies assy ImmutableArray.Empty assy.TypeRefs.[r] with
                 | TypeResolutionResult.FirstLoadAssy _ ->
                     failwith
                         "seems pretty unlikely that we could have constructed this object without loading its base type"
@@ -560,3 +560,35 @@ module DumpedAssembly =
             | None -> ResolvedBaseType.Object
 
         go source baseTypeInfo
+
+    let typeInfoToTypeDefn
+        (bct : BaseClassTypes<DumpedAssembly>)
+        (assemblies : ImmutableDictionary<string, DumpedAssembly>)
+        (ti : TypeInfo<TypeDefn, TypeDefn>)
+        =
+        ti
+        |> TypeInfo.toTypeDefn
+            bct
+            (fun n -> assemblies.[n.FullName])
+            _.Name
+            (fun x y -> x.TypeDefs.[y])
+            (fun x y ->
+                let r = x.TypeRefs.[y] |> Assembly.resolveTypeRef assemblies x ImmutableArray.Empty
+
+                match r with
+                | TypeResolutionResult.FirstLoadAssy assemblyReference -> failwith "todo"
+                | TypeResolutionResult.Resolved (dumpedAssembly, typeInfo) ->
+                    let result =
+                        typeInfo |> TypeInfo.mapGeneric (fun typeDef -> failwith "TODO: generics")
+
+                    dumpedAssembly, result
+            )
+
+    let typeInfoToTypeDefn'
+        (bct : BaseClassTypes<DumpedAssembly>)
+        (assemblies : ImmutableDictionary<string, DumpedAssembly>)
+        (ti : TypeInfo<GenericParamFromMetadata, TypeDefn>)
+        =
+        ti
+        |> TypeInfo.mapGeneric (fun (par, _) -> TypeDefn.GenericTypeParameter par.SequenceNumber)
+        |> typeInfoToTypeDefn bct assemblies

WoofWare.PawPrint.Domain/TypeConcretisation.fs

@@ -420,7 +420,7 @@ module TypeConcretization =
 
         // First try to resolve without loading new assemblies
         let resolutionResult =
-            Assembly.resolveTypeRef ctx.LoadedAssemblies currentAssy typeRef ImmutableArray.Empty
+            Assembly.resolveTypeRef ctx.LoadedAssemblies currentAssy ImmutableArray.Empty typeRef
 
         match resolutionResult with
         | TypeResolutionResult.Resolved (targetAssy, typeInfo) -> (targetAssy, typeInfo), ctx
@@ -437,7 +437,7 @@ module TypeConcretization =
 
                 // Now try to resolve again with the loaded assembly
                 let resolutionResult2 =
-                    Assembly.resolveTypeRef newCtx.LoadedAssemblies currentAssy typeRef ImmutableArray.Empty
+                    Assembly.resolveTypeRef newCtx.LoadedAssemblies currentAssy ImmutableArray.Empty typeRef
 
                 match resolutionResult2 with
                 | TypeResolutionResult.Resolved (targetAssy, typeInfo) -> (targetAssy, typeInfo), newCtx
@@ -608,14 +608,14 @@ module TypeConcretization =
 
     /// Concretize a type in a specific generic context
     let rec concretizeType
-        (ctx : ConcretizationContext<'corelib>)
+        (ctx : ConcretizationContext<DumpedAssembly>)
         (loadAssembly :
             AssemblyName -> AssemblyReferenceHandle -> ImmutableDictionary<string, DumpedAssembly> * DumpedAssembly)
         (assembly : AssemblyName)
         (typeGenerics : ImmutableArray<ConcreteTypeHandle>)
         (methodGenerics : ImmutableArray<ConcreteTypeHandle>)
         (typeDefn : TypeDefn)
-        : ConcreteTypeHandle * ConcretizationContext<'corelib>
+        : ConcreteTypeHandle * ConcretizationContext<DumpedAssembly>
         =
 
         let key = (assembly, typeDefn)
@@ -705,7 +705,7 @@ module TypeConcretization =
         | _ -> failwithf "TODO: Concretization of %A not implemented" typeDefn
 
     and private concretizeGenericInstantiation
-        (ctx : ConcretizationContext<'corelib>)
+        (ctx : ConcretizationContext<DumpedAssembly>)
         (loadAssembly :
             AssemblyName -> AssemblyReferenceHandle -> ImmutableDictionary<string, DumpedAssembly> * DumpedAssembly)
         (assembly : AssemblyName)
@@ -713,7 +713,7 @@ module TypeConcretization =
         (methodGenerics : ImmutableArray<ConcreteTypeHandle>)
         (genericDef : TypeDefn)
         (args : ImmutableArray<TypeDefn>)
-        : ConcreteTypeHandle * ConcretizationContext<'corelib>
+        : ConcreteTypeHandle * ConcretizationContext<DumpedAssembly>
         =
         // First, concretize all type arguments
         let argHandles, ctxAfterArgs =
@@ -864,14 +864,14 @@ module Concretization =
 
     /// Helper to concretize an array of types
     let private concretizeTypeArray
-        (ctx : TypeConcretization.ConcretizationContext<'corelib>)
+        (ctx : TypeConcretization.ConcretizationContext<DumpedAssembly>)
         (loadAssembly :
             AssemblyName -> AssemblyReferenceHandle -> ImmutableDictionary<string, DumpedAssembly> * DumpedAssembly)
         (assembly : AssemblyName)
         (typeArgs : ImmutableArray<ConcreteTypeHandle>)
         (methodArgs : ImmutableArray<ConcreteTypeHandle>)
         (types : ImmutableArray<TypeDefn>)
-        : ImmutableArray<ConcreteTypeHandle> * TypeConcretization.ConcretizationContext<'corelib>
+        : ImmutableArray<ConcreteTypeHandle> * TypeConcretization.ConcretizationContext<DumpedAssembly>
         =
 
         let handles = ImmutableArray.CreateBuilder types.Length
@@ -888,14 +888,14 @@ module Concretization =
 
     /// Helper to concretize a method signature
     let private concretizeMethodSignature
-        (ctx : TypeConcretization.ConcretizationContext<'corelib>)
+        (ctx : TypeConcretization.ConcretizationContext<DumpedAssembly>)
         (loadAssembly :
             AssemblyName -> AssemblyReferenceHandle -> ImmutableDictionary<string, DumpedAssembly> * DumpedAssembly)
         (assembly : AssemblyName)
         (typeArgs : ImmutableArray<ConcreteTypeHandle>)
         (methodArgs : ImmutableArray<ConcreteTypeHandle>)
         (signature : TypeMethodSignature<TypeDefn>)
-        : TypeMethodSignature<ConcreteTypeHandle> * TypeConcretization.ConcretizationContext<'corelib>
+        : TypeMethodSignature<ConcreteTypeHandle> * TypeConcretization.ConcretizationContext<DumpedAssembly>
         =
 
         // Concretize return type
@@ -1157,8 +1157,7 @@ module Concretization =
                 // Recursively convert generic arguments
                 let genericArgs =
                     concreteType.Generics
-                    |> Seq.map (fun h -> concreteHandleToTypeDefn baseClassTypes h concreteTypes assemblies)
-                    |> ImmutableArray.CreateRange
+                    |> ImmutableArray.map (fun h -> concreteHandleToTypeDefn baseClassTypes h concreteTypes assemblies)
 
                 let baseDef =
                     TypeDefn.FromDefinition (concreteType.Definition, concreteType.Assembly.FullName, signatureTypeKind)

WoofWare.PawPrint.Domain/TypeInfo.fs

@@ -348,10 +348,10 @@ module TypeInfo =
 
     let rec resolveBaseType<'corelib, 'generic, 'field>
         (baseClassTypes : BaseClassTypes<'corelib>)
+        (sourceAssy : 'corelib)
         (getName : 'corelib -> AssemblyName)
         (getTypeDef : 'corelib -> TypeDefinitionHandle -> TypeInfo<'generic, 'field>)
-        (getTypeRef : 'corelib -> TypeReferenceHandle -> TypeInfo<'generic, 'field>)
-        (sourceAssembly : AssemblyName)
+        (getTypeRef : 'corelib -> TypeReferenceHandle -> 'corelib * TypeInfo<'generic, 'field>)
         (value : BaseTypeInfo option)
         : ResolvedBaseType
         =
@@ -361,40 +361,48 @@ module TypeInfo =
 
         match value with
         | BaseTypeInfo.TypeDef typeDefinitionHandle ->
-            match isBaseType baseClassTypes getName sourceAssembly typeDefinitionHandle with
+            match isBaseType baseClassTypes getName (getName sourceAssy) typeDefinitionHandle with
             | Some x -> x
             | None ->
                 let baseType = getTypeDef baseClassTypes.Corelib typeDefinitionHandle
-                resolveBaseType baseClassTypes getName getTypeDef getTypeRef sourceAssembly baseType.BaseType
+                resolveBaseType baseClassTypes sourceAssy getName getTypeDef getTypeRef baseType.BaseType
         | BaseTypeInfo.TypeRef typeReferenceHandle ->
-            let typeRef = getTypeRef baseClassTypes.Corelib typeReferenceHandle
-            failwith $"{typeRef}"
+            let targetAssy, typeRef = getTypeRef sourceAssy typeReferenceHandle
+
+            match isBaseType baseClassTypes getName (getName targetAssy) typeRef.TypeDefHandle with
+            | Some x -> x
+            | None ->
+                let baseType = getTypeDef baseClassTypes.Corelib typeRef.TypeDefHandle
+                resolveBaseType baseClassTypes sourceAssy getName getTypeDef getTypeRef baseType.BaseType
         | BaseTypeInfo.TypeSpec typeSpecificationHandle -> failwith "todo"
         | BaseTypeInfo.ForeignAssemblyType (assemblyName, typeDefinitionHandle) ->
             resolveBaseType
                 baseClassTypes
+                sourceAssy
                 getName
                 getTypeDef
                 getTypeRef
-                assemblyName
                 (Some (BaseTypeInfo.TypeDef typeDefinitionHandle))
 
     let toTypeDefn
         (baseClassTypes : BaseClassTypes<'corelib>)
+        (assemblies : AssemblyName -> 'corelib)
         (getName : 'corelib -> AssemblyName)
         (getTypeDef : 'corelib -> TypeDefinitionHandle -> TypeInfo<'generic, 'field>)
-        (getTypeRef : 'corelib -> TypeReferenceHandle -> TypeInfo<'generic, 'field>)
+        (getTypeRef : 'corelib -> TypeReferenceHandle -> 'corelib * TypeInfo<'generic, 'field>)
         (ty : TypeInfo<TypeDefn, TypeDefn>)
         : TypeDefn
         =
         let stk =
-            match resolveBaseType baseClassTypes getName getTypeDef getTypeRef ty.Assembly ty.BaseType with
+            match resolveBaseType baseClassTypes (assemblies ty.Assembly) getName getTypeDef getTypeRef ty.BaseType with
             | ResolvedBaseType.Enum
             | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
             | ResolvedBaseType.Object
             | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
 
         let defn =
+            // The only allowed construction of FromDefinition!
+            // All other constructions should use DumpedAssembly.typeInfoToTypeDefn.
             TypeDefn.FromDefinition (ComparableTypeDefinitionHandle.Make ty.TypeDefHandle, ty.Assembly.FullName, stk)
 
         if ty.Generics.IsEmpty then

WoofWare.PawPrint.Test/TestPureCases.fs

@@ -48,7 +48,7 @@ module TestPureCases =
             }
             {
                 FileName = "ResizeArray.cs"
-                ExpectedReturnCode = 109
+                ExpectedReturnCode = 114
                 NativeImpls = MockEnv.make ()
             }
             {
@@ -61,6 +61,16 @@ module TestPureCases =
                 ExpectedReturnCode = 0
                 NativeImpls = MockEnv.make ()
             }
+            {
+                FileName = "AdvancedStructLayout.cs"
+                ExpectedReturnCode = 0
+                NativeImpls = MockEnv.make ()
+            }
+            {
+                FileName = "OverlappingStructs.cs"
+                ExpectedReturnCode = 0
+                NativeImpls = MockEnv.make ()
+            }
         ]
 
     let cases : EndToEndTestCase list =
@@ -183,11 +193,12 @@ module TestPureCases =
         use peImage = new MemoryStream (image)
 
         try
+            let realResult = RealRuntime.executeWithRealRuntime [||] image
+            realResult.ExitCode |> shouldEqual case.ExpectedReturnCode
+
             let terminalState, terminatingThread =
                 Program.run loggerFactory (Some case.FileName) peImage dotnetRuntimes case.NativeImpls []
 
-            let realResult = RealRuntime.executeWithRealRuntime [||] image
-
             let exitCode =
                 match terminalState.ThreadState.[terminatingThread].MethodState.EvaluationStack.Values with
                 | [] -> failwith "expected program to return a value, but it returned void"
@@ -198,7 +209,6 @@ module TestPureCases =
 
             exitCode |> shouldEqual realResult.ExitCode
 
-            exitCode |> shouldEqual case.ExpectedReturnCode
         with _ ->
             for message in messages () do
                 System.Console.Error.WriteLine $"{message}"

WoofWare.PawPrint.Test/sourcesPure/InitializeArray.cs

@@ -8,7 +8,7 @@ namespace HelloWorldApp
         {
             int[] array = new[] { 1, 2, 3 };
 
-            if (array.Sum() != 60)
+            if (array.Sum() != 6)
             {
                 return 1;
             }

WoofWare.PawPrint.Test/sourcesPure/Initobj.cs

@@ -124,9 +124,12 @@ public class TestInitobj
         {
             ObjectRef = new object(),
             StringRef = "Hello",
-            ArrayRef = new int[] { 1, 2, 3 },
+            ArrayRef = new int[3],
             ValueField = 42
         };
+        c.ArrayRef[0] = 1;
+        c.ArrayRef[1] = 2;
+        c.ArrayRef[2] = 3;
 
         // Verify initial values
         if (c.ObjectRef == null) return 30;

WoofWare.PawPrint.Test/sourcesPure/OverlappingStructs.cs

@@ -191,7 +191,7 @@ public class StructLayoutTests
 
     static int TestStructPassing()
     {
-        var s = new SequentialStruct { A = 500, B = 50, C = 5000 };
+        var s = new SequentialStruct { A = 500, B = 50, C = 5005 };
         int result = ProcessSequential(s);
         if (result != 555) return 50; // 500 + 50 + 5 (C % 1000)
 

WoofWare.PawPrint.Test/sourcesPure/UnsafeAs.cs

@@ -273,3 +273,4 @@ public class TestUnsafeAs
         return 0;
     }
 }
+

WoofWare.PawPrint/BasicCliType.fs

@@ -139,6 +139,18 @@ module CliRuntimePointerSource =
             let a = ofManagedPointerSource a
             CliRuntimePointerSource.Field (a, ind)
 
+    let rec toManagedPointerSource (ptrSource : CliRuntimePointerSource) : ManagedPointerSource =
+        match ptrSource with
+        | CliRuntimePointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
+            ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar)
+        | CliRuntimePointerSource.Argument (sourceThread, methodFrame, whichVar) ->
+            ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar)
+        | CliRuntimePointerSource.Heap managedHeapAddress -> ManagedPointerSource.Heap managedHeapAddress
+        | CliRuntimePointerSource.Null -> ManagedPointerSource.Null
+        | CliRuntimePointerSource.ArrayIndex (arr, ind) -> ManagedPointerSource.ArrayIndex (arr, ind)
+        | CliRuntimePointerSource.Field (a, ind) ->
+            let a = toManagedPointerSource a
+            ManagedPointerSource.Field (a, ind)
 
 type CliRuntimePointer =
     | Unmanaged of int64

WoofWare.PawPrint/EvalStack.fs

@@ -320,7 +320,7 @@ module EvalStackValue =
                 | CliRuntimePointerSource.Heap addr -> EvalStackValue.ObjectRef addr
                 | CliRuntimePointerSource.Null -> EvalStackValue.ManagedPointer ManagedPointerSource.Null
                 | CliRuntimePointerSource.Field (source, fieldName) ->
-                    ManagedPointerSource.Field (failwith "TODO", fieldName)
+                    ManagedPointerSource.Field (CliRuntimePointerSource.toManagedPointerSource source, fieldName)
                     |> EvalStackValue.ManagedPointer
         | CliType.ValueType fields ->
             // TODO: this is a bit dubious; we're being a bit sloppy with possibly-overlapping fields here

WoofWare.PawPrint/IlMachineState.fs

@@ -284,7 +284,7 @@ module IlMachineState =
         (state : IlMachineState)
         : IlMachineState * DumpedAssembly * WoofWare.PawPrint.TypeInfo<TypeDefn, TypeDefn>
         =
-        match Assembly.resolveTypeRef state._LoadedAssemblies referencedInAssembly target typeGenericArgs with
+        match Assembly.resolveTypeRef state._LoadedAssemblies referencedInAssembly typeGenericArgs target with
         | TypeResolutionResult.Resolved (assy, typeDef) -> state, assy, typeDef
         | TypeResolutionResult.FirstLoadAssy loadFirst ->
             let state, _, _ =
@@ -335,36 +335,8 @@ module IlMachineState =
                             assy
                             state
 
-                    // If the resolved argument has generics, create a GenericInstantiation
-                    // Otherwise, create a FromDefinition
                     let preservedArg =
-                        let baseType =
-                            resolvedArg.BaseType
-                            |> DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies assy.Name
-
-                        let signatureTypeKind =
-                            match baseType with
-                            | ResolvedBaseType.Enum
-                            | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
-                            | ResolvedBaseType.Object -> SignatureTypeKind.Class
-                            | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
-
-                        if resolvedArg.Generics.IsEmpty then
-                            TypeDefn.FromDefinition (
-                                ComparableTypeDefinitionHandle.Make resolvedArg.TypeDefHandle,
-                                assy.Name.FullName,
-                                signatureTypeKind
-                            )
-                        else
-                            // Preserve the generic instantiation
-                            let genericDef =
-                                TypeDefn.FromDefinition (
-                                    ComparableTypeDefinitionHandle.Make resolvedArg.TypeDefHandle,
-                                    assy.Name.FullName,
-                                    signatureTypeKind
-                                )
-
-                            TypeDefn.GenericInstantiation (genericDef, resolvedArg.Generics)
+                        DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies resolvedArg
 
                     args'.Add preservedArg
 
@@ -448,25 +420,23 @@ module IlMachineState =
         // Convert ConcreteTypeHandle to TypeDefn
         let typeGenericArgsAsDefn =
             typeGenericArgs
-            |> Seq.map (fun handle ->
+            |> ImmutableArray.map (fun handle ->
                 Concretization.concreteHandleToTypeDefn
                     baseClassTypes
                     handle
                     state.ConcreteTypes
                     state._LoadedAssemblies
             )
-            |> ImmutableArray.CreateRange
 
         let methodGenericArgsAsDefn =
             methodGenericArgs
-            |> Seq.map (fun handle ->
+            |> ImmutableArray.map (fun handle ->
                 Concretization.concreteHandleToTypeDefn
                     baseClassTypes
                     handle
                     state.ConcreteTypes
                     state._LoadedAssemblies
             )
-            |> ImmutableArray.CreateRange
 
         resolveTypeFromDefn loggerFactory baseClassTypes sign typeGenericArgsAsDefn methodGenericArgsAsDefn assy state
 
@@ -546,13 +516,13 @@ module IlMachineState =
     /// Concretize a ConcreteType<TypeDefn> to get a ConcreteTypeHandle for static field access
     let concretizeFieldDeclaringType
         (loggerFactory : ILoggerFactory)
-        (baseClassTypes : BaseClassTypes<'corelib>)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
         (declaringType : ConcreteType<TypeDefn>)
         (state : IlMachineState)
         : ConcreteTypeHandle * IlMachineState
         =
         // Create a concretization context from the current state
-        let ctx : TypeConcretization.ConcretizationContext<'corelib> =
+        let ctx : TypeConcretization.ConcretizationContext<_> =
             {
                 InProgress = ImmutableDictionary.Empty
                 ConcreteTypes = state.ConcreteTypes
@@ -1484,6 +1454,48 @@ module IlMachineState =
     let getSyncBlock (addr : ManagedHeapAddress) (state : IlMachineState) : SyncBlock =
         state.ManagedHeap |> ManagedHeap.getSyncBlock addr
 
+    let getFieldValue (obj : ManagedPointerSource) (fieldName : string) (state : IlMachineState) : CliType =
+        match obj with
+        | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
+            getLocalVariable sourceThread methodFrame whichVar state
+            |> CliType.getField fieldName
+        | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) -> failwith "todo"
+        | ManagedPointerSource.Heap addr ->
+            ManagedHeap.get addr state.ManagedHeap
+            |> AllocatedNonArrayObject.DereferenceField fieldName
+        | ManagedPointerSource.ArrayIndex (arr, index) -> getArrayValue arr index state |> CliType.getField fieldName
+        | ManagedPointerSource.Field (src, fieldName) -> failwith "todo"
+        | ManagedPointerSource.Null -> failwith "TODO: throw NRE"
+
+    let setFieldValue
+        (obj : ManagedPointerSource)
+        (v : CliType)
+        (fieldName : string)
+        (state : IlMachineState)
+        : IlMachineState
+        =
+        match obj with
+        | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
+            let v =
+                getLocalVariable sourceThread methodFrame whichVar state
+                |> CliType.withFieldSet fieldName v
+
+            state |> setLocalVariable sourceThread methodFrame whichVar v
+        | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) -> failwith "todo"
+        | ManagedPointerSource.Heap addr ->
+            let newValue =
+                ManagedHeap.get addr state.ManagedHeap
+                |> AllocatedNonArrayObject.SetField fieldName v
+
+            { state with
+                ManagedHeap = ManagedHeap.set addr newValue state.ManagedHeap
+            }
+        | ManagedPointerSource.ArrayIndex (arr, index) ->
+            let v = getArrayValue arr index state |> CliType.withFieldSet fieldName v
+            state |> setArrayValue arr v index
+        | ManagedPointerSource.Field (managedPointerSource, fieldName) -> failwith "todo"
+        | ManagedPointerSource.Null -> failwith "TODO: throw NRE"
+
     let executeDelegateConstructor (instruction : MethodState) (state : IlMachineState) : IlMachineState =
         // We've been called with arguments already popped from the stack into local arguments.
         let constructing = instruction.Arguments.[0]
@@ -1666,42 +1678,7 @@ module IlMachineState =
         : IlMachineState * TypeDefn
         =
         let defn = activeAssy.TypeDefs.[typeDef]
-
-        let baseType =
-            defn.BaseType
-            |> DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies defn.Assembly
-
-        let signatureTypeKind =
-            match baseType with
-            | ResolvedBaseType.Enum
-            | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
-            | ResolvedBaseType.Object -> SignatureTypeKind.Class
-            | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
-
-        let result =
-            if defn.Generics.IsEmpty then
-                TypeDefn.FromDefinition (
-                    ComparableTypeDefinitionHandle.Make defn.TypeDefHandle,
-                    defn.Assembly.FullName,
-                    signatureTypeKind
-                )
-            else
-                // Preserve the generic instantiation by converting GenericParameters to TypeDefn.GenericTypeParameter
-                let genericDef =
-                    TypeDefn.FromDefinition (
-                        ComparableTypeDefinitionHandle.Make defn.TypeDefHandle,
-                        defn.Assembly.FullName,
-                        signatureTypeKind
-                    )
-
-                let genericArgs =
-                    defn.Generics
-                    |> Seq.mapi (fun i _ -> TypeDefn.GenericTypeParameter i)
-                    |> ImmutableArray.CreateRange
-
-                TypeDefn.GenericInstantiation (genericDef, genericArgs)
-
-        state, result
+        state, DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies defn
 
     let lookupTypeRef
         (loggerFactory : ILoggerFactory)
@@ -1729,25 +1706,4 @@ module IlMachineState =
         let state, assy, resolved =
             resolveTypeFromRef loggerFactory activeAssy ref typeGenerics state
 
-        let baseType =
-            resolved.BaseType
-            |> DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies assy.Name
-
-        let signatureTypeKind =
-            match baseType with
-            | ResolvedBaseType.Enum
-            | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
-            | ResolvedBaseType.Object -> SignatureTypeKind.Class
-            | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
-
-        let result =
-            TypeDefn.FromDefinition (
-                ComparableTypeDefinitionHandle.Make resolved.TypeDefHandle,
-                assy.Name.FullName,
-                signatureTypeKind
-            )
-
-        if resolved.Generics.IsEmpty then
-            state, result, assy
-        else
-            failwith "TODO: add generics"
+        state, DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies resolved, assy

WoofWare.PawPrint/IlMachineStateExecution.fs

@@ -17,11 +17,7 @@ module IlMachineStateExecution =
         =
         match esv with
         | EvalStackValue.Int32 _ ->
-            TypeDefn.FromDefinition (
-                ComparableTypeDefinitionHandle.Make baseClassTypes.Int32.TypeDefHandle,
-                baseClassTypes.Corelib.Name.FullName,
-                SignatureTypeKind.ValueType
-            )
+            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.Int32
             |> IlMachineState.concretizeType
                 baseClassTypes
                 state
@@ -29,11 +25,7 @@ module IlMachineStateExecution =
                 ImmutableArray.Empty
                 ImmutableArray.Empty
         | EvalStackValue.Int64 _ ->
-            TypeDefn.FromDefinition (
-                ComparableTypeDefinitionHandle.Make baseClassTypes.Int64.TypeDefHandle,
-                baseClassTypes.Corelib.Name.FullName,
-                SignatureTypeKind.ValueType
-            )
+            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.Int64
             |> IlMachineState.concretizeType
                 baseClassTypes
                 state
@@ -42,11 +34,7 @@ module IlMachineStateExecution =
                 ImmutableArray.Empty
         | EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
         | EvalStackValue.Float _ ->
-            TypeDefn.FromDefinition (
-                ComparableTypeDefinitionHandle.Make baseClassTypes.Double.TypeDefHandle,
-                baseClassTypes.Corelib.Name.FullName,
-                SignatureTypeKind.ValueType
-            )
+            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.Double
             |> IlMachineState.concretizeType
                 baseClassTypes
                 state
@@ -579,30 +567,8 @@ module IlMachineStateExecution =
                             typeDef.Name
                         )
 
-                        // TypeDef won't have any generics; it would be a TypeSpec if it did
-                        // Create a TypeDefn from the TypeDef handle
                         let baseTypeDefn =
-                            let baseTypeDef = sourceAssembly.TypeDefs.[typeDefinitionHandle]
-
-                            let baseType =
-                                baseTypeDef.BaseType
-                                |> DumpedAssembly.resolveBaseType
-                                    baseClassTypes
-                                    state._LoadedAssemblies
-                                    sourceAssembly.Name
-
-                            let signatureTypeKind =
-                                match baseType with
-                                | ResolvedBaseType.Enum
-                                | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
-                                | ResolvedBaseType.Object
-                                | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
-
-                            TypeDefn.FromDefinition (
-                                ComparableTypeDefinitionHandle.Make typeDefinitionHandle,
-                                sourceAssembly.Name.FullName,
-                                signatureTypeKind
-                            )
+                            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies typeDef
 
                         // Concretize the base type
                         let state, baseTypeHandle =
@@ -640,22 +606,8 @@ module IlMachineStateExecution =
 
                         // Create a TypeDefn from the resolved TypeRef
                         let baseTypeDefn =
-                            let baseType =
-                                targetType.BaseType
-                                |> DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies assy.Name
-
-                            let signatureTypeKind =
-                                match baseType with
-                                | ResolvedBaseType.Enum
-                                | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
-                                | ResolvedBaseType.Object
-                                | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
-
-                            TypeDefn.FromDefinition (
-                                ComparableTypeDefinitionHandle.Make targetType.TypeDefHandle,
-                                assy.Name.FullName,
-                                signatureTypeKind
-                            )
+                            targetType
+                            |> DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies
 
                         // Concretize the base type
                         let state, baseTypeHandle =

WoofWare.PawPrint/Intrinsics.fs

@@ -76,6 +76,7 @@ module Intrinsics =
                         | [ field ] -> go field.ContentsEval
                         | _ -> failwith $"TODO: %O{vt}"
                     | EvalStackValue.ManagedPointer ManagedPointerSource.Null -> failwith "TODO: throw NRE"
+                    | EvalStackValue.ObjectRef addr
                     | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr) -> Some addr
                     | s -> failwith $"TODO: called with unrecognised arg %O{s}"
 
@@ -228,7 +229,10 @@ module Intrinsics =
                 let arg1 = ManagedHeap.get arg1 state.ManagedHeap
                 let arg2 = ManagedHeap.get arg2 state.ManagedHeap
 
-                if AllocatedNonArrayObject.DereferenceField "_firstChar" arg1 <> AllocatedNonArrayObject.DereferenceField "_firstChar" arg2 then
+                if
+                    AllocatedNonArrayObject.DereferenceField "_firstChar" arg1
+                    <> AllocatedNonArrayObject.DereferenceField "_firstChar" arg2
+                then
                     state
                     |> IlMachineState.pushToEvalStack (CliType.ofBool false) currentThread
                     |> IlMachineState.advanceProgramCounter currentThread

WoofWare.PawPrint/ManagedHeap.fs

@@ -17,6 +17,29 @@ type AllocatedNonArrayObject =
         // TODO: this is wrong, it doesn't account for overlapping fields
         f.Fields |> List.find (fun f -> f.Name = name) |> _.Contents
 
+    static member SetField (name : string) (v : CliType) (f : AllocatedNonArrayObject) : AllocatedNonArrayObject =
+        // TODO: this is wrong, it doesn't account for overlapping fields
+        let contents =
+            {
+                Name = name
+                Contents = v
+                Offset = None
+            }
+
+        { f with
+            Fields =
+                f.Fields
+                |> List.replaceWhere (fun f ->
+                    if f.Name = name then
+                        Some
+                            { contents with
+                                Offset = f.Offset
+                            }
+                    else
+                        None
+                )
+        }
+
 type AllocatedArray =
     {
         Length : int
@@ -125,6 +148,12 @@ module ManagedHeap =
         // TODO: arrays too
         heap.NonArrayObjects.[alloc]
 
+    let set (alloc : ManagedHeapAddress) (v : AllocatedNonArrayObject) (heap : ManagedHeap) : ManagedHeap =
+        // TODO: arrays too
+        { heap with
+            NonArrayObjects = heap.NonArrayObjects |> Map.add alloc v
+        }
+
     let setArrayValue (alloc : ManagedHeapAddress) (offset : int) (v : CliType) (heap : ManagedHeap) : ManagedHeap =
         let newArrs =
             heap.Arrays

WoofWare.PawPrint/NullaryIlOp.fs

@@ -112,7 +112,7 @@ module NullaryIlOp =
                 }
             | ManagedPointerSource.Heap managedHeapAddress -> failwith "todo"
             | ManagedPointerSource.ArrayIndex _ -> failwith "todo"
-            | Field (managedPointerSource, fieldName) -> failwith "todo"
+            | ManagedPointerSource.Field (managedPointerSource, fieldName) -> failwith "todo"
         | EvalStackValue.ObjectRef managedHeapAddress -> failwith "todo"
 
     let internal ldElem

WoofWare.PawPrint/Program.fs

@@ -16,11 +16,7 @@ module Program =
         : ManagedHeapAddress * IlMachineState
         =
         let state, stringType =
-            TypeDefn.FromDefinition (
-                ComparableTypeDefinitionHandle.Make corelib.String.TypeDefHandle,
-                corelib.Corelib.Name.FullName,
-                SignatureTypeKind.Class
-            )
+            DumpedAssembly.typeInfoToTypeDefn' corelib state._LoadedAssemblies corelib.String
             |> IlMachineState.concretizeType
                 corelib
                 state
@@ -126,7 +122,7 @@ module Program =
                 let rec go state =
                     // Resolve the type reference to find which assembly it's in
                     match
-                        Assembly.resolveTypeRef state._LoadedAssemblies currentAssembly typeRef ImmutableArray.Empty
+                        Assembly.resolveTypeRef state._LoadedAssemblies currentAssembly ImmutableArray.Empty typeRef
                     with
                     | TypeResolutionResult.FirstLoadAssy assyRef ->
                         // Need to load this assembly first

WoofWare.PawPrint/UnaryConstIlOp.fs

@@ -107,8 +107,8 @@ module internal UnaryConstIlOp =
                 | EvalStackValue.NativeInt i -> not (NativeIntSource.isZero i)
                 | EvalStackValue.Float f -> failwith "TODO: Brfalse_s float semantics undocumented"
                 | EvalStackValue.ManagedPointer ManagedPointerSource.Null -> false
+                | EvalStackValue.ObjectRef _
                 | EvalStackValue.ManagedPointer _ -> true
-                | EvalStackValue.ObjectRef _ -> failwith "TODO: Brfalse_s ObjectRef comparison unimplemented"
                 | EvalStackValue.UserDefinedValueType _ ->
                     failwith "TODO: Brfalse_s UserDefinedValueType comparison unimplemented"
 
@@ -129,8 +129,8 @@ module internal UnaryConstIlOp =
                 | EvalStackValue.NativeInt i -> not (NativeIntSource.isZero i)
                 | EvalStackValue.Float f -> failwith "TODO: Brtrue_s float semantics undocumented"
                 | EvalStackValue.ManagedPointer ManagedPointerSource.Null -> false
-                | EvalStackValue.ManagedPointer _
-                | EvalStackValue.ObjectRef _ -> true
+                | EvalStackValue.ObjectRef _
+                | EvalStackValue.ManagedPointer _ -> true
                 | EvalStackValue.UserDefinedValueType _ ->
                     failwith "TODO: Brtrue_s UserDefinedValueType comparison unimplemented"
 
@@ -422,7 +422,7 @@ module internal UnaryConstIlOp =
                 | EvalStackValue.Float v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
                 | EvalStackValue.NativeInt v1, EvalStackValue.NativeInt v2 -> v1 <> v2
                 | EvalStackValue.ManagedPointer ptr1, EvalStackValue.ManagedPointer ptr2 -> ptr1 <> ptr2
-                | EvalStackValue.ObjectRef p1, EvalStackValue.ObjectRef p2 -> p1 <> p2
+                | EvalStackValue.ObjectRef ptr1, EvalStackValue.ObjectRef ptr2 -> ptr1 <> ptr2
                 | _, _ -> failwith $"TODO {value1} {value2} (see table III.4)"
 
             state

WoofWare.PawPrint/UnaryMetadataIlOp.fs

@@ -455,22 +455,10 @@ module internal UnaryMetadataIlOp =
                     let activeAssy = state.ActiveAssembly thread
                     let ty = activeAssy.TypeDefs.[td]
 
-                    let baseTy =
-                        DumpedAssembly.resolveBaseType
-                            baseClassTypes
-                            state._LoadedAssemblies
-                            activeAssy.Name
-                            ty.BaseType
+                    let result =
+                        DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies ty
 
-                    let sigType =
-                        match baseTy with
-                        | ResolvedBaseType.Enum
-                        | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
-                        | ResolvedBaseType.Object -> SignatureTypeKind.Class
-                        | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
-
-                    state,
-                    TypeDefn.FromDefinition (ComparableTypeDefinitionHandle.Make td, activeAssy.Name.FullName, sigType)
+                    state, result
                 | MetadataToken.TypeSpecification handle ->
                     state, state.ActiveAssembly(thread).TypeSpecs.[handle].Signature
                 | MetadataToken.TypeReference handle ->
@@ -482,22 +470,7 @@ module internal UnaryMetadataIlOp =
                             ImmutableArray.Empty
                             state
 
-                    let baseTy =
-                        DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies assy.Name resol.BaseType
-
-                    let sigType =
-                        match baseTy with
-                        | ResolvedBaseType.Enum
-                        | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
-                        | ResolvedBaseType.Object -> SignatureTypeKind.Class
-                        | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
-
-                    state,
-                    TypeDefn.FromDefinition (
-                        ComparableTypeDefinitionHandle.Make resol.TypeDefHandle,
-                        assy.Name.FullName,
-                        sigType
-                    )
+                    state, DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies resol
                 | m -> failwith $"unexpected metadata token {m} in IsInst"
 
             let state, targetConcreteType =
@@ -515,6 +488,7 @@ module internal UnaryMetadataIlOp =
                     // null IsInstance check always succeeds and results in a null reference
                     EvalStackValue.ManagedPointer ManagedPointerSource.Null
                 | EvalStackValue.ManagedPointer (ManagedPointerSource.LocalVariable _) -> failwith "TODO"
+                | EvalStackValue.ObjectRef addr
                 | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr) ->
                     match state.ManagedHeap.NonArrayObjects.TryGetValue addr with
                     | true, v ->
@@ -822,8 +796,11 @@ module internal UnaryMetadataIlOp =
                     IlMachineState.pushToEvalStack currentValue thread state
                 | EvalStackValue.ManagedPointer ManagedPointerSource.Null ->
                     failwith "TODO: raise NullReferenceException"
-                | EvalStackValue.ManagedPointer (ManagedPointerSource.Field _) ->
-                    failwith "TODO: get a field on a field ptr"
+                | EvalStackValue.ManagedPointer (ManagedPointerSource.Field (src, fieldName)) ->
+                    let currentValue =
+                        IlMachineState.getFieldValue src fieldName state |> CliType.getField field.Name
+
+                    IlMachineState.pushToEvalStack currentValue thread state
                 | EvalStackValue.UserDefinedValueType vt ->
                     let result = vt |> EvalStackValueUserType.DereferenceField field.Name
 
@@ -834,70 +811,51 @@ module internal UnaryMetadataIlOp =
             |> Tuple.withRight WhatWeDid.Executed
 
         | Ldflda ->
+            let ptr, state = IlMachineState.popEvalStack thread state
+
+            let ptr =
+                match ptr with
+                | Int32 _
+                | Int64 _
+                | Float _ -> failwith "expected pointer type"
+                | NativeInt nativeIntSource -> failwith "todo"
+                | ManagedPointer src -> src
+                | ObjectRef addr -> ManagedPointerSource.Heap addr
+                | UserDefinedValueType evalStackValueUserType -> failwith "todo"
+
             let state, field =
                 match metadataToken with
                 | MetadataToken.FieldDefinition f ->
-                    let field = activeAssy.Fields.[f]
-                    // Map the field to have TypeDefn type parameters
-                    let mappedField =
-                        field |> FieldInfo.mapTypeGenerics (fun i _ -> TypeDefn.GenericTypeParameter i)
+                    let field =
+                        activeAssy.Fields.[f]
+                        |> FieldInfo.mapTypeGenerics (fun _ -> failwith "no generics allowed on FieldDefinition")
 
-                    state, mappedField
-                | MetadataToken.MemberReference m ->
-                    let state, _, resolved, _ =
+                    state, field
+                | MetadataToken.MemberReference mr ->
+                    let state, assyName, field, _ =
+                        // TODO: generics
                         IlMachineState.resolveMember
                             loggerFactory
                             baseClassTypes
                             thread
                             activeAssy
                             ImmutableArray.Empty
-                            m
+                            mr
                             state
 
-                    match resolved with
+                    match field with
+                    | Choice1Of2 _method -> failwith "member reference was unexpectedly a method"
                     | Choice2Of2 field -> state, field
-                    | Choice1Of2 _ -> failwith "Expected field in Ldflda but got method"
-                | _ -> failwith $"Unexpected in Ldflda: {metadataToken}"
+                | t -> failwith $"Unexpectedly asked to load from a non-field: {t}"
 
-            let source, state = IlMachineState.popEvalStack thread state
-
-            // Ldflda needs to return a pointer to the field within the object/struct
-            let toPush =
-                match source with
-                | EvalStackValue.ObjectRef heapAddr ->
-                    // For object references, we need to create a pointer to the field
-                    // TODO: The current ManagedPointerSource doesn't have a case for field pointers
-                    // We're using Heap pointer for now, but this doesn't capture the field offset
-                    // This will need to be enhanced to support field-specific pointers
-                    ManagedPointerSource.Heap heapAddr |> EvalStackValue.ManagedPointer
-                | EvalStackValue.ManagedPointer ptr ->
-                    // If we already have a managed pointer, we need to handle field access
-                    // through that pointer. For now, return the same pointer type
-                    // TODO: This needs to track the field offset within the pointed-to object
-                    match ptr with
-                    | ManagedPointerSource.Null -> failwith "TODO: NullReferenceException in Ldflda"
-                    | _ -> ptr |> EvalStackValue.ManagedPointer
-                | EvalStackValue.NativeInt (NativeIntSource.ManagedPointer ptr) ->
-                    // Unmanaged pointer input produces unmanaged pointer output
-                    // TODO: This also needs field offset tracking
-                    match ptr with
-                    | ManagedPointerSource.Null -> failwith "TODO: NullReferenceException in Ldflda"
-                    | _ -> ptr |> NativeIntSource.ManagedPointer |> EvalStackValue.NativeInt
-                | EvalStackValue.NativeInt (NativeIntSource.Verbatim _) ->
-                    // Native int that's not from a managed pointer
-                    // This represents an unmanaged pointer scenario
-                    failwith "TODO: Ldflda with unmanaged pointer - not allowed in verifiable code"
-                | EvalStackValue.UserDefinedValueType vt ->
-                    // For value types on the stack, we need to store them somewhere
-                    // and return a pointer to the field
-                    // This is complex because we need to materialize the value type
-                    failwith "TODO: Ldflda on value type - need to allocate temporary storage and create field pointer"
-                | _ -> failwith $"unexpected Ldflda source: {source}"
+            let result =
+                ManagedPointerSource.Field (ptr, field.Name) |> EvalStackValue.ManagedPointer
 
             state
-            |> IlMachineState.pushToEvalStack' toPush thread
+            |> IlMachineState.pushToEvalStack' result thread
             |> IlMachineState.advanceProgramCounter thread
             |> Tuple.withRight WhatWeDid.Executed
+
         | Ldsfld ->
             let state, field =
                 match metadataToken with
@@ -1026,12 +984,7 @@ module internal UnaryMetadataIlOp =
                 | _ -> failwith $"expected heap allocation for array, got {arr}"
 
             let elementType =
-                TypeInfo.toTypeDefn
-                    baseClassTypes
-                    _.Name
-                    (fun x y -> x.TypeDefs.[y])
-                    (fun x y -> x.TypeRefs.[y] |> failwithf "%+A")
-                    elementType
+                DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies elementType
 
             let state, zeroOfType =
                 IlMachineState.cliTypeZeroOf
@@ -1100,12 +1053,18 @@ module internal UnaryMetadataIlOp =
             IlMachineState.pushToEvalStack toPush thread state
             |> IlMachineState.advanceProgramCounter thread
             |> Tuple.withRight WhatWeDid.Executed
+
         | Initobj ->
-            let addr, state = IlMachineState.popEvalStack thread state
+            let popped, state = IlMachineState.popEvalStack thread state
             let declaringTypeGenerics = currentMethod.DeclaringType.Generics
 
-            let state, assy, ty =
+            let state, assy, targetType =
                 match metadataToken with
+                | MetadataToken.TypeDefinition defn ->
+                    state,
+                    activeAssy,
+                    activeAssy.TypeDefs.[defn]
+                    |> TypeInfo.mapGeneric (fun (p, _) -> TypeDefn.GenericTypeParameter p.SequenceNumber)
                 | MetadataToken.TypeSpecification spec ->
                     let state, assy, ty =
                         IlMachineState.resolveTypeFromSpecConcrete
@@ -1118,68 +1077,47 @@ module internal UnaryMetadataIlOp =
                             state
 
                     state, assy, ty
-                | MetadataToken.TypeDefinition defn ->
-                    let state, assy, ty =
-                        IlMachineState.resolveTypeFromDefnConcrete
-                            loggerFactory
-                            baseClassTypes
-                            defn
-                            activeAssy
-                            declaringTypeGenerics
-                            currentMethod.Generics
-                            state
+                | x -> failwith $"TODO: Ldelem element type resolution unimplemented for {x}"
 
-                    state, assy, ty
-                | x -> failwith $"unexpected in Initobj: %O{x}"
+            let targetType =
+                targetType
+                |> DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies
+
+            let state, zeroOfType =
+                IlMachineState.cliTypeZeroOf
+                    loggerFactory
+                    baseClassTypes
+                    assy
+                    targetType
+                    declaringTypeGenerics
+                    ImmutableArray.Empty
+                    state
 
             let state =
-                match addr with
+                match popped with
+                | EvalStackValue.Int32 _
+                | EvalStackValue.Int64 _
+                | EvalStackValue.NativeInt _
+                | EvalStackValue.Float _ -> failwith "unexpectedly not an address"
+                | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr)
+                | EvalStackValue.ObjectRef addr -> failwith "todo"
                 | EvalStackValue.ManagedPointer src ->
                     match src with
-                    | ManagedPointerSource.Null -> failwith "TODO: probably NRE here"
-                    | ManagedPointerSource.Heap _ -> failwith "TODO: heap"
                     | ManagedPointerSource.LocalVariable (thread, frame, var) ->
-                        // Create zero-initialized fields based on the type info
-                        let state, zeroFields =
-                            ((state, []), ty.Fields)
-                            ||> List.fold (fun (state, acc) field ->
-                                // Concretize the field type
-                                let state, fieldHandle =
-                                    IlMachineState.concretizeType
-                                        baseClassTypes
-                                        state
-                                        assy.Name
-                                        declaringTypeGenerics
-                                        currentMethod.Generics
-                                        field.Signature
-
-                                // Get zero value for the field type
-                                let zero, state =
-                                    IlMachineState.cliTypeZeroOfHandle state baseClassTypes fieldHandle
-
-                                let field =
-                                    {
-                                        Name = field.Name
-                                        Contents = zero
-                                        Offset = field.Offset
-                                    }
-
-                                state, field :: acc
-                            )
-                            |> fun (state, fields) -> state, List.rev fields
-
-                        // Create the value type with zero-initialized fields
-                        let newValue = zeroFields |> CliValueType.OfFields |> CliType.ValueType
-
-                        state |> IlMachineState.setLocalVariable thread frame var newValue
-                    | ManagedPointerSource.Argument (thread, frame, arg) -> failwith "TODO: Argument"
-                    | ManagedPointerSource.ArrayIndex (arr, index) -> failwith "todo: array index"
-                    | Field (managedPointerSource, fieldName) -> failwith "todo"
-                | addr -> failwith $"Bad address in Initobj: {addr}"
+                        state |> IlMachineState.setLocalVariable thread frame var zeroOfType
+                    | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) -> failwith "todo"
+                    | ManagedPointerSource.ArrayIndex (arr, index) ->
+                        state |> IlMachineState.setArrayValue arr zeroOfType index
+                    | ManagedPointerSource.Field (managedPointerSource, fieldName) ->
+                        state |> IlMachineState.setFieldValue managedPointerSource zeroOfType fieldName
+                    | ManagedPointerSource.Null -> failwith "runtime error: unexpectedly Initobj'ing null"
+                    | ManagedPointerSource.Heap _ -> failwith "logic error"
+                | EvalStackValue.UserDefinedValueType evalStackValueUserType -> failwith "todo"
 
             state
             |> IlMachineState.advanceProgramCounter thread
             |> Tuple.withRight WhatWeDid.Executed
+
         | Ldsflda ->
 
             // TODO: check whether we should throw FieldAccessException
@@ -1342,25 +1280,8 @@ module internal UnaryMetadataIlOp =
                             methodGenerics
                             state
 
-                    let stk =
-                        match
-                            DumpedAssembly.resolveBaseType
-                                baseClassTypes
-                                state._LoadedAssemblies
-                                assy.Name
-                                typeDefn.BaseType
-                        with
-                        | ResolvedBaseType.ValueType
-                        | ResolvedBaseType.Enum -> SignatureTypeKind.ValueType
-                        | ResolvedBaseType.Delegate
-                        | ResolvedBaseType.Object -> SignatureTypeKind.Class
-
                     let typeDefn =
-                        TypeDefn.FromDefinition (
-                            ComparableTypeDefinitionHandle.Make typeDefn.TypeDefHandle,
-                            assy.Name.FullName,
-                            stk
-                        )
+                        DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies typeDefn
 
                     let state, handle =
                         IlMachineState.concretizeType
@@ -1419,7 +1340,9 @@ module internal UnaryMetadataIlOp =
 
                     IlMachineState.pushToEvalStack (CliType.ValueType vt) thread state
                 | MetadataToken.TypeDefinition h ->
-                    let state, typeDefn = IlMachineState.lookupTypeDefn baseClassTypes state activeAssy h
+                    let state, typeDefn =
+                        IlMachineState.lookupTypeDefn baseClassTypes state activeAssy h
+
                     handleTypeToken typeDefn state
                 | _ -> failwith $"Unexpected metadata token %O{metadataToken} in LdToken"
 

WoofWare.PawPrint/UnaryStringTokenIlOp.fs

@@ -64,11 +64,7 @@ module internal UnaryStringTokenIlOp =
                         ]
 
                     let state, stringType =
-                        TypeDefn.FromDefinition (
-                            ComparableTypeDefinitionHandle.Make baseClassTypes.String.TypeDefHandle,
-                            baseClassTypes.Corelib.Name.FullName,
-                            SignatureTypeKind.Class
-                        )
+                        DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.String
                         |> IlMachineState.concretizeType
                             baseClassTypes
                             state