Make it much harder to omit tests (#127)

CLAUDE.md

@@ -42,8 +42,13 @@ dotnet fantomas .
 ```
 
 ### Running the Application
+A playground C# file is in CSharpExample/Class1.cs.
+This environment is convenient for running WoofWare.PawPrint against a standalone DLL.
+Interpolate the appropriate strings like `{Platform}` as necessary depending on the current environment and the output of the `dotnet publish`.
+
 ```bash
-dotnet publish --self-contained --runtime-id osx-arm64 CSharpExample/ && dotnet run --project WoofWare.PawPrint.App/WoofWare.PawPrint.App.fsproj -- CSharpExample/bin/Debug/net9.0/osx-arm64/publish/CSharpExample.dll
+dotnet publish --self-contained --runtime {Platform} CSharpExample/
+dotnet run --project WoofWare.PawPrint.App/WoofWare.PawPrint.App.fsproj -- CSharpExample/bin/{Configuration}/{Framework}/{Platform}/publish/CSharpExample.dll
 ```
 
 ## Architecture
@@ -63,9 +68,11 @@ dotnet publish --self-contained --runtime-id osx-arm64 CSharpExample/ && dotnet
 
 **WoofWare.PawPrint.Test**
 - Uses NUnit as the test framework
-- Test cases are defined in `TestCases.fs`
-- C# source files in `sources/` are compiled and executed by the runtime as test cases
+- Test cases are defined in `TestPureCases.fs` and `TestImpureCases.fs`
+- C# source files in `sources{Pure,Impure}/` are compiled and executed by the runtime as test cases; files in `sourcesPure` are automatically turned into test cases with no further action (see TestPureCases.fs for the mechanism)
 - `TestHarness.fs` provides infrastructure for running test assemblies through the interpreter
+- Run all tests with `dotnet run --project WoofWare.PawPrint.Test/WoofWare.PawPrint.Test.fsproj -- --no-spinner` (note the additional `--`)
+- Run a specific test with `dotnet run --project WoofWare.PawPrint.Test/WoofWare.PawPrint.Test.fsproj -- --filter-test-case StringWithinTestName --no-spinner`
 
 **WoofWare.PawPrint.App**
 - Entry point application for running the interpreter
@@ -81,15 +88,17 @@ dotnet publish --self-contained --runtime-id osx-arm64 CSharpExample/ && dotnet
 
 * Functions should be fully type-annotated, to give the most helpful error messages on type mismatches.
 * Generally, prefer to fully-qualify discriminated union cases in `match` statements.
+* ALWAYS fully-qualify enum cases when constructing them and matching on them (e.g., `PrimitiveType.Int16` not `Int16`).
 * When writing a "TODO" `failwith`, specify in the error message what the condition is that triggers the failure, so that a failing run can easily be traced back to its cause.
+* If a field name begins with an underscore (like `_LoadedAssemblies`), do not mutate it directly. Only mutate it via whatever intermediate methods have been defined for that purpose (like `WithLoadedAssembly`).
 
 ### Development Workflow
 
 When adding new IL instruction support:
 1. Add the instruction to `IlOp.fs`
 2. Implement execution logic in `AbstractMachine.fs`
-3. Add a test case in `sources/` (C# file) that exercises the instruction
-4. Add the test case to `TestCases.fs`
+3. Add a test case in `sourcesPure/` or `sourcesImpure/` (C# file) that exercises the instruction, remembering also to add the file as an EmbeddedResource in WoofWare.PawPrint.Test.fsproj
+4. Add the test case to `TestPureCases.fs` or `TestImpureCases.fs`
 5. Run tests to verify implementation
 
 The project uses deterministic builds and treats warnings as errors to maintain code quality.
@@ -98,3 +107,121 @@ It strongly prefers to avoid special-casing to get around problems, but instead
 ### Common Gotchas
 
 * I've named several types in such a way as to overlap with built-in types, e.g. MethodInfo is in both WoofWare.PawPrint and System.Reflection.Metadata namespaces. Build errors can usually be fixed by fully-qualifying the type.
+
+## Type Concretization System
+
+### Overview
+
+Type concretization converts abstract type definitions (`TypeDefn`) to concrete runtime types (`ConcreteTypeHandle`). This is essential because IL operations need exact types at runtime, including all generic instantiations. The system separates type concretization from IL execution, ensuring types are properly loaded before use.
+
+### Key Concepts
+
+#### Generic Parameters
+- **Common error**: "Generic type/method parameter X out of range" probably means you're missing the proper generic context: some caller has passed the wrong list of generics through somewhere.
+
+#### Assembly Context
+TypeRefs must be resolved in the context of the assembly where they're defined, not where they're used. When resolving a TypeRef, always use the assembly that contains the TypeRef in its metadata.
+
+### Common Scenarios and Solutions
+
+#### Nested Generic Contexts
+When inside `Array.Empty<T>()` calling `AsRef<T>`, the `T` refers to the outer method's generic parameter. Pass the current executing method's generics as context:
+```fsharp
+let currentMethod = state.ThreadState.[thread].MethodState.ExecutingMethod
+concretizeMethodWithTypeGenerics ... currentMethod.Generics state
+```
+
+#### Field Access in Generic Contexts
+When accessing `EmptyArray<T>.Value` from within `Array.Empty<T>()`, use both type and method generics:
+```fsharp
+let contextTypeGenerics = currentMethod.DeclaringType.Generics
+let contextMethodGenerics = currentMethod.Generics
+```
+
+#### Call vs CallMethod
+- `callMethodInActiveAssembly` expects unconcretized methods and does concretization internally
+- `callMethod` expects already-concretized methods
+- The refactoring changed to concretizing before calling to ensure types are loaded
+
+### Common Pitfalls
+
+1. **Don't create new generic parameters when they already exist**. It's *very rarely* correct to instantiate `TypeDefn.Generic{Type,Method}Parameter` yourself:
+   ```fsharp
+   // Wrong: field.DeclaringType.Generics |> List.mapi (fun i _ -> TypeDefn.GenericTypeParameter i)
+   // Right: field.DeclaringType.Generics
+   ```
+
+2. **Assembly loading context**: The `loadAssembly` function expects the assembly that contains the reference as the first parameter, not the target assembly
+
+3. **Type forwarding**: Use `Assembly.resolveTypeRef` which handles type forwarding and exported types correctly
+
+### Key Files for Type System
+
+- **TypeConcretisation.fs**: Core type concretization logic
+  - `concretizeType`: Main entry point
+  - `concretizeGenericInstantiation`: Handles generic instantiations like `List<T>`
+  - `ConcretizationContext`: Tracks state during concretization
+
+- **IlMachineState.fs**:
+  - `concretizeMethodForExecution`: Prepares methods for execution
+  - `concretizeFieldForExecution`: Prepares fields for access
+  - Manages the flow of generic contexts through execution
+
+- **Assembly.fs**:
+  - `resolveTypeRef`: Resolves type references across assemblies
+  - `resolveTypeFromName`: Handles type forwarding and exported types
+  - `resolveTypeFromExport`: Follows type forwarding chains
+
+### Debugging Type Concretization Issues
+
+When encountering errors:
+1. Check the generic context (method name, generic parameters)
+2. Verify the assembly context being used
+3. Identify the TypeDefn variant being concretized
+4. Add logging to see generic contexts: `failwithf "Failed to concretize: %A" typeDefn`
+5. Check if you're in a generic method calling another generic method
+6. Verify TypeRefs are being resolved in the correct assembly
+
+## Common Type System Patterns
+
+### Creating TypeDefn from Type Metadata
+
+When you need to create a `TypeDefn` from type metadata (e.g., from a `TypeInfo`), there's a common pattern that involves:
+1. Resolving the base type to determine `SignatureTypeKind`
+2. Creating the base `TypeDefn.FromDefinition`
+3. For generic types, creating a `GenericInstantiation` with type parameters
+
+This pattern is implemented in `UnaryMetadataIlOp.lookupTypeDefn`. Example usage:
+```fsharp
+let state, typeDefn =
+    UnaryMetadataIlOp.lookupTypeDefn
+        baseClassTypes
+        state
+        activeAssembly
+        typeDefHandle
+```
+
+### Field Signature Comparison in Generic Contexts
+
+When comparing field signatures in generic contexts (e.g., when resolving member references), signatures must be concretized before comparison. This ensures generic type parameters are properly substituted:
+
+```fsharp
+// Concretize both signatures before comparing
+let state, concreteFieldSig = concretizeType ... fieldSig
+let state, fieldSigConcrete = concretizeType ... fi.Signature
+if fieldSigConcrete = concreteFieldSig then ...
+```
+
+### Static vs Instance Fields
+
+When constructing objects with `Newobj`:
+- Only instance fields should be included in the object
+- Static fields belong to the type, not instances
+- Filter using: `field.Attributes.HasFlag FieldAttributes.Static`
+
+Example:
+```fsharp
+let instanceFields =
+    ctorType.Fields
+    |> List.filter (fun field -> not (field.Attributes.HasFlag FieldAttributes.Static))
+```

CSharpExample/CSharpExample.csproj

@@ -4,6 +4,13 @@
       <TargetFramework>net9.0</TargetFramework>
       <OutputType>Exe</OutputType>
       <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+      <WarningsAsErrors>false</WarningsAsErrors>
+      <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+      <EnableDefaultItems>false</EnableDefaultItems>
     </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="Class1.cs" />
+  </ItemGroup>
+
 </Project>

WoofWare.PawPrint.Domain/Assembly.fs

@@ -45,7 +45,7 @@ type DumpedAssembly =
         /// Dictionary of all type definitions in this assembly, keyed by their handle.
         /// </summary>
         TypeDefs :
-            IReadOnlyDictionary<TypeDefinitionHandle, WoofWare.PawPrint.TypeInfo<WoofWare.PawPrint.GenericParameter>>
+            IReadOnlyDictionary<TypeDefinitionHandle, WoofWare.PawPrint.TypeInfo<GenericParamFromMetadata, TypeDefn>>
 
         /// <summary>
         /// Dictionary of all type references in this assembly, keyed by their handle.
@@ -64,7 +64,7 @@ type DumpedAssembly =
         Methods :
             IReadOnlyDictionary<
                 MethodDefinitionHandle,
-                WoofWare.PawPrint.MethodInfo<FakeUnit, WoofWare.PawPrint.GenericParameter>
+                WoofWare.PawPrint.MethodInfo<GenericParamFromMetadata, GenericParamFromMetadata, TypeDefn>
              >
 
         /// <summary>
@@ -75,7 +75,8 @@ type DumpedAssembly =
         /// <summary>
         /// Dictionary of all field definitions in this assembly, keyed by their handle.
         /// </summary>
-        Fields : IReadOnlyDictionary<FieldDefinitionHandle, WoofWare.PawPrint.FieldInfo<FakeUnit>>
+        Fields :
+            IReadOnlyDictionary<FieldDefinitionHandle, WoofWare.PawPrint.FieldInfo<GenericParamFromMetadata, TypeDefn>>
 
         /// <summary>
         /// The entry point method of the assembly, if one exists.
@@ -143,7 +144,7 @@ type DumpedAssembly =
         /// Internal lookup for type definitions by namespace and name.
         /// </summary>
         _TypeDefsLookup :
-            ImmutableDictionary<string * string, WoofWare.PawPrint.TypeInfo<WoofWare.PawPrint.GenericParameter>>
+            ImmutableDictionary<string * string, WoofWare.PawPrint.TypeInfo<GenericParamFromMetadata, TypeDefn>>
     }
 
     static member internal BuildExportedTypesLookup
@@ -199,7 +200,7 @@ type DumpedAssembly =
     static member internal BuildTypeDefsLookup
         (logger : ILogger)
         (name : AssemblyName)
-        (typeDefs : WoofWare.PawPrint.TypeInfo<WoofWare.PawPrint.GenericParameter> seq)
+        (typeDefs : WoofWare.PawPrint.TypeInfo<GenericParamFromMetadata, TypeDefn> seq)
         =
         let result = ImmutableDictionary.CreateBuilder ()
         let keys = HashSet ()
@@ -230,7 +231,7 @@ type DumpedAssembly =
     member this.TypeDef
         (``namespace`` : string)
         (name : string)
-        : WoofWare.PawPrint.TypeInfo<WoofWare.PawPrint.GenericParameter> option
+        : WoofWare.PawPrint.TypeInfo<GenericParamFromMetadata, TypeDefn> option
         =
         match this._TypeDefsLookup.TryGetValue ((``namespace``, name)) with
         | false, _ -> None
@@ -247,13 +248,13 @@ type DumpedAssembly =
 
 type TypeResolutionResult =
     | FirstLoadAssy of WoofWare.PawPrint.AssemblyReference
-    | Resolved of DumpedAssembly * TypeInfo<TypeDefn>
+    | Resolved of DumpedAssembly * TypeInfo<TypeDefn, TypeDefn>
 
     override this.ToString () : string =
         match this with
         | TypeResolutionResult.FirstLoadAssy a -> $"FirstLoadAssy(%s{a.Name.FullName})"
         | TypeResolutionResult.Resolved (assy, ty) ->
-            $"Resolved(%s{assy.Name.FullName}: {string<TypeInfo<TypeDefn>> ty})"
+            $"Resolved(%s{assy.Name.FullName}: {string<TypeInfo<TypeDefn, TypeDefn>> ty})"
 
 [<RequireQualifiedAccess>]
 module Assembly =
@@ -422,51 +423,54 @@ module Assembly =
     let rec resolveTypeRef
         (assemblies : ImmutableDictionary<string, DumpedAssembly>)
         (referencedInAssembly : DumpedAssembly)
+        (genericArgs : ImmutableArray<TypeDefn>)
         (target : TypeRef)
-        (genericArgs : ImmutableArray<TypeDefn> option)
         : TypeResolutionResult
         =
         match target.ResolutionScope with
         | TypeRefResolutionScope.Assembly r ->
-            let assemblyRef = referencedInAssembly.AssemblyReferences.[r]
+            match referencedInAssembly.AssemblyReferences.TryGetValue r with
+            | false, _ ->
+                failwithf
+                    "AssemblyReferenceHandle %A not found in assembly %s. Available references: %A"
+                    r
+                    referencedInAssembly.Name.FullName
+                    (referencedInAssembly.AssemblyReferences.Keys |> Seq.toList)
+            | true, assemblyRef ->
+
             let assemblyName = assemblyRef.Name
 
             match assemblies.TryGetValue assemblyName.FullName with
             | false, _ -> TypeResolutionResult.FirstLoadAssy assemblyRef
             | true, assy ->
 
-            let nsPath = target.Namespace.Split '.' |> Array.toList
+                let nsPath = target.Namespace.Split '.' |> Array.toList
 
-            let targetNs = assy.NonRootNamespaces.[nsPath]
+                let targetNs = assy.NonRootNamespaces.[nsPath]
 
-            let targetType =
-                targetNs.TypeDefinitions
-                |> Seq.choose (fun td ->
-                    let ty = assy.TypeDefs.[td]
+                let targetType =
+                    targetNs.TypeDefinitions
+                    |> Seq.choose (fun td ->
+                        let ty = assy.TypeDefs.[td]
 
-                    if ty.Name = target.Name && ty.Namespace = target.Namespace then
-                        Some ty
-                    else
-                        None
-                )
-                |> Seq.toList
-
-            match targetType with
-            | [ t ] ->
-                let t =
-                    t
-                    |> TypeInfo.mapGeneric (fun _ param ->
-                        match genericArgs with
-                        | None -> failwith "got a generic TypeRef but no generic args in context"
-                        | Some genericArgs -> genericArgs.[param.SequenceNumber]
+                        if ty.Name = target.Name && ty.Namespace = target.Namespace then
+                            Some ty
+                        else
+                            None
                     )
+                    |> Seq.toList
 
-                TypeResolutionResult.Resolved (assy, t)
-            | _ :: _ :: _ -> failwith $"Multiple matching type definitions! {nsPath} {target.Name}"
-            | [] ->
-                match assy.ExportedType (Some target.Namespace) target.Name with
-                | None -> failwith $"Failed to find type {nsPath} {target.Name} in {assy.Name.FullName}!"
-                | Some ty -> resolveTypeFromExport assy assemblies ty genericArgs
+                match targetType with
+                | [ t ] ->
+                    let t =
+                        t |> TypeInfo.mapGeneric (fun (param, md) -> genericArgs.[param.SequenceNumber])
+
+                    TypeResolutionResult.Resolved (assy, t)
+                | _ :: _ :: _ -> failwith $"Multiple matching type definitions! {nsPath} {target.Name}"
+                | [] ->
+                    match assy.ExportedType (Some target.Namespace) target.Name with
+                    | None -> failwith $"Failed to find type {nsPath} {target.Name} in {assy.Name.FullName}!"
+                    | Some ty -> resolveTypeFromExport assy assemblies ty genericArgs
         | k -> failwith $"Unexpected: {k}"
 
     and resolveTypeFromName
@@ -474,7 +478,7 @@ module Assembly =
         (assemblies : ImmutableDictionary<string, DumpedAssembly>)
         (ns : string option)
         (name : string)
-        (genericArgs : ImmutableArray<TypeDefn> option)
+        (genericArgs : ImmutableArray<TypeDefn>)
         : TypeResolutionResult
         =
         match ns with
@@ -485,17 +489,13 @@ module Assembly =
         | Some typeDef ->
             let typeDef =
                 typeDef
-                |> TypeInfo.mapGeneric (fun _ param ->
-                    match genericArgs with
-                    | None -> failwith<TypeDefn> $"tried to resolve generic type {ns}.{name} but no generics in scope"
-                    | Some genericArgs -> genericArgs.[param.SequenceNumber]
-                )
+                |> TypeInfo.mapGeneric (fun (param, md) -> genericArgs.[param.SequenceNumber])
 
             TypeResolutionResult.Resolved (assy, typeDef)
         | 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
@@ -506,7 +506,7 @@ module Assembly =
         (fromAssembly : DumpedAssembly)
         (assemblies : ImmutableDictionary<string, DumpedAssembly>)
         (ty : WoofWare.PawPrint.ExportedType)
-        (genericArgs : ImmutableArray<TypeDefn> option)
+        (genericArgs : ImmutableArray<TypeDefn>)
         : TypeResolutionResult
         =
         match ty.Data 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] None 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,36 @@ module DumpedAssembly =
             | None -> ResolvedBaseType.Object
 
         go source baseTypeInfo
+
+    let typeInfoToTypeDefn
+        (bct : BaseClassTypes<DumpedAssembly>)
+        (assemblies : ImmutableDictionary<string, DumpedAssembly>)
+        (ti : TypeInfo<TypeDefn, 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/ComparableFieldDefinitionHandle.fs

@@ -0,0 +1,37 @@
+namespace WoofWare.PawPrint
+
+open System
+open System.Reflection.Metadata
+
+[<CustomEquality>]
+[<CustomComparison>]
+type ComparableFieldDefinitionHandle =
+    private
+        {
+            _Inner : FieldDefinitionHandle
+        }
+
+    override this.Equals other =
+        match other with
+        | :? ComparableFieldDefinitionHandle as other -> this._Inner.GetHashCode () = other._Inner.GetHashCode ()
+        | _ -> false
+
+    override this.GetHashCode () : int = this._Inner.GetHashCode ()
+
+    interface IComparable<ComparableFieldDefinitionHandle> with
+        member this.CompareTo (other : ComparableFieldDefinitionHandle) : int =
+            this._Inner.GetHashCode().CompareTo (other._Inner.GetHashCode ())
+
+    interface IComparable with
+        member this.CompareTo (other : obj) : int =
+            match other with
+            | :? ComparableFieldDefinitionHandle as other ->
+                (this :> IComparable<ComparableFieldDefinitionHandle>).CompareTo other
+            | _ -> failwith "invalid comparison"
+
+    static member Make (h : FieldDefinitionHandle) =
+        {
+            _Inner = h
+        }
+
+    member this.Get = this._Inner

WoofWare.PawPrint.Domain/ComparableTypeDefinitionHandle.fs

@@ -11,7 +11,7 @@ type ComparableTypeDefinitionHandle =
             _Inner : TypeDefinitionHandle
         }
 
-    override this.Equals (other) =
+    override this.Equals other =
         match other with
         | :? ComparableTypeDefinitionHandle as other -> this._Inner.GetHashCode () = other._Inner.GetHashCode ()
         | _ -> false

WoofWare.PawPrint.Domain/ConcreteType.fs

@@ -1,6 +1,6 @@
 namespace WoofWare.PawPrint
 
-open System
+open System.Collections.Immutable
 open System.Reflection
 open System.Reflection.Metadata
 
@@ -16,20 +16,42 @@ module FakeUnit =
 
 /// A type which has been concretised, runtime-representable, etc.
 [<CustomEquality>]
-[<CustomComparison>]
-type ConcreteType<'typeGeneric when 'typeGeneric : comparison and 'typeGeneric :> IComparable<'typeGeneric>> =
+[<NoComparison>]
+type ConcreteType<'typeGeneric> =
     private
         {
+            /// Do not use this, because it's intended to be private; use the accessor `.Assembly : AssemblyName`
+            /// instead.
             _AssemblyName : AssemblyName
+            /// Do not use this, because it's intended to be private; use the accessor `.Definition` instead.
             _Definition : ComparableTypeDefinitionHandle
+            /// Do not use this, because it's intended to be private; use the accessor `.Name` instead.
             _Name : string
-            _Generics : 'typeGeneric list
+            /// Do not use this, because it's intended to be private; use the accessor `.Namespace` instead.
+            _Namespace : string
+            /// Do not use this, because it's intended to be private; use the accessor `.Generics` instead.
+            _Generics : ImmutableArray<'typeGeneric>
         }
 
+    override this.ToString () : string =
+        let basic = $"%s{this.Assembly.Name}.%s{this.Namespace}.%s{this.Name}"
+
+        let generics =
+            if this.Generics.IsEmpty then
+                ""
+            else
+                this.Generics
+                |> Seq.map string
+                |> String.concat ", "
+                |> fun x -> "<" + x + ">"
+
+        basic + generics
+
     member this.Assembly : AssemblyName = this._AssemblyName
     member this.Definition : ComparableTypeDefinitionHandle = this._Definition
-    member this.Generics : 'typeGeneric list = this._Generics
+    member this.Generics : ImmutableArray<'typeGeneric> = this._Generics
     member this.Name = this._Name
+    member this.Namespace = this._Namespace
 
     override this.Equals (other : obj) : bool =
         match other with
@@ -42,72 +64,31 @@ type ConcreteType<'typeGeneric when 'typeGeneric : comparison and 'typeGeneric :
     override this.GetHashCode () : int =
         hash (this._AssemblyName.FullName, this._Definition, this._Generics)
 
-    interface IComparable<ConcreteType<'typeGeneric>> with
-        member this.CompareTo (other : ConcreteType<'typeGeneric>) : int =
-            let comp = this._AssemblyName.FullName.CompareTo other._AssemblyName.FullName
-
-            if comp = 0 then
-                let comp =
-                    (this._Definition :> IComparable<ComparableTypeDefinitionHandle>).CompareTo other._Definition
-
-                if comp = 0 then
-                    let thisGen = (this._Generics : 'typeGeneric list) :> IComparable<'typeGeneric list>
-                    thisGen.CompareTo other._Generics
-                else
-                    comp
-            else
-                comp
-
-    interface IComparable with
-        member this.CompareTo other =
-            match other with
-            | :? ConcreteType<'typeGeneric> as other ->
-                (this :> IComparable<ConcreteType<'typeGeneric>>).CompareTo other
-            | _ -> failwith "bad comparison"
-
-type RuntimeConcreteType = ConcreteType<TypeDefn>
-
 [<RequireQualifiedAccess>]
 module ConcreteType =
     let make
         (assemblyName : AssemblyName)
-        (name : string)
         (defn : TypeDefinitionHandle)
-        (generics : TypeDefn list)
-        : RuntimeConcreteType
+        (ns : string)
+        (name : string)
+        (genericParam : ImmutableArray<GenericParamFromMetadata>)
+        : ConcreteType<GenericParamFromMetadata>
         =
         {
             _AssemblyName = assemblyName
             _Definition = ComparableTypeDefinitionHandle.Make defn
             _Name = name
-            _Generics = generics
+            _Namespace = ns
+            _Generics = genericParam
         }
 
-    let make'
-        (assemblyName : AssemblyName)
-        (defn : TypeDefinitionHandle)
-        (name : string)
-        (genericParamCount : int)
-        : ConcreteType<FakeUnit>
-        =
-        {
-            _AssemblyName = assemblyName
-            _Definition = ComparableTypeDefinitionHandle.Make defn
-            _Name = name
-            _Generics = List.replicate genericParamCount FakeUnit.FakeUnit
-        }
-
-    let mapGeneric<'a, 'b
-        when 'a : comparison and 'a :> IComparable<'a> and 'b : equality and 'b : comparison and 'b :> IComparable<'b>>
-        (f : int -> 'a -> 'b)
-        (x : ConcreteType<'a>)
-        : ConcreteType<'b>
-        =
-        let generics = x._Generics |> List.mapi f
+    let mapGeneric<'a, 'b> (f : int -> 'a -> 'b) (x : ConcreteType<'a>) : ConcreteType<'b> =
+        let generics = x._Generics |> Seq.mapi f |> ImmutableArray.CreateRange
 
         {
             _AssemblyName = x._AssemblyName
             _Definition = x._Definition
             _Generics = generics
             _Name = x._Name
+            _Namespace = x._Namespace
         }

WoofWare.PawPrint.Domain/Constants.fs

@@ -0,0 +1,16 @@
+namespace WoofWare.PawPrint
+
+[<AutoOpen>]
+module Constants =
+
+    [<Literal>]
+    let SIZEOF_INT = 4
+
+    [<Literal>]
+    let SIZEOF_OBJ = 8
+
+    [<Literal>]
+    let DEFAULT_STRUCT_ALIGNMENT = 8
+
+    [<Literal>]
+    let NATIVE_INT_SIZE = 8

WoofWare.PawPrint.Domain/FieldInfo.fs

@@ -1,6 +1,5 @@
 namespace WoofWare.PawPrint
 
-open System
 open System.Reflection
 open System.Reflection.Metadata
 
@@ -8,7 +7,7 @@ open System.Reflection.Metadata
 /// Represents detailed information about a field in a .NET assembly.
 /// This is a strongly-typed representation of FieldDefinition from System.Reflection.Metadata.
 /// </summary>
-type FieldInfo<'typeGeneric when 'typeGeneric : comparison and 'typeGeneric :> IComparable<'typeGeneric>> =
+type FieldInfo<'typeGeneric, 'fieldGeneric> =
     {
         /// <summary>
         /// The metadata token handle that uniquely identifies this field in the assembly.
@@ -26,15 +25,22 @@ type FieldInfo<'typeGeneric when 'typeGeneric : comparison and 'typeGeneric :> I
         /// <summary>
         /// The type of the field.
         /// </summary>
-        Signature : TypeDefn
+        Signature : 'fieldGeneric
 
         /// <summary>
         /// The attributes applied to this field, including visibility, static/instance,
         /// literal, and other characteristics.
         /// </summary>
         Attributes : FieldAttributes
+
+        /// Static fields don't have an offset at all; also, instance fields which don't have an explicit offset (but
+        /// which of course do have one implicitly, which is most fields) are None here.
+        Offset : int option
     }
 
+    member this.HasFieldRVA = this.Attributes.HasFlag FieldAttributes.HasFieldRVA
+    member this.IsStatic = this.Attributes.HasFlag FieldAttributes.Static
+
     override this.ToString () : string =
         $"%s{this.DeclaringType.Assembly.Name}.{this.DeclaringType.Name}.%s{this.Name}"
 
@@ -45,16 +51,26 @@ module FieldInfo =
         (assembly : AssemblyName)
         (handle : FieldDefinitionHandle)
         (def : FieldDefinition)
-        : FieldInfo<FakeUnit>
+        : FieldInfo<GenericParamFromMetadata, TypeDefn>
         =
         let name = mr.GetString def.Name
         let fieldSig = def.DecodeSignature (TypeDefn.typeProvider assembly, ())
         let declaringType = def.GetDeclaringType ()
-        let typeGenerics = mr.GetTypeDefinition(declaringType).GetGenericParameters().Count
-        let declaringTypeName = mr.GetString (mr.GetTypeDefinition(declaringType).Name)
+
+        let decType = mr.GetTypeDefinition declaringType
+
+        let typeGenerics = decType.GetGenericParameters () |> GenericParameter.readAll mr
+
+        let declaringTypeNamespace = mr.GetString decType.Namespace
+        let declaringTypeName = mr.GetString decType.Name
 
         let declaringType =
-            ConcreteType.make' assembly declaringType declaringTypeName typeGenerics
+            ConcreteType.make assembly declaringType declaringTypeNamespace declaringTypeName typeGenerics
+
+        let offset =
+            match def.GetOffset () with
+            | -1 -> None
+            | s -> Some s
 
         {
             Name = name
@@ -62,14 +78,10 @@ module FieldInfo =
             DeclaringType = declaringType
             Handle = handle
             Attributes = def.Attributes
+            Offset = offset
         }
 
-    let mapTypeGenerics<'a, 'b
-        when 'a :> IComparable<'a> and 'a : comparison and 'b :> IComparable<'b> and 'b : comparison>
-        (f : int -> 'a -> 'b)
-        (input : FieldInfo<'a>)
-        : FieldInfo<'b>
-        =
+    let mapTypeGenerics<'a, 'b, 'field> (f : int -> 'a -> 'b) (input : FieldInfo<'a, 'field>) : FieldInfo<'b, 'field> =
         let declaringType = input.DeclaringType |> ConcreteType.mapGeneric f
 
         {
@@ -78,5 +90,5 @@ module FieldInfo =
             DeclaringType = declaringType
             Signature = input.Signature
             Attributes = input.Attributes
-
+            Offset = input.Offset
         }

WoofWare.PawPrint.Domain/GenericParameter.fs

@@ -0,0 +1,85 @@
+namespace WoofWare.PawPrint
+
+open System.Collections.Immutable
+open System.Reflection
+open System.Reflection.Metadata
+
+type GenericVariance =
+    | Covariant
+    | Contravariant
+
+type GenericConstraint =
+    | Reference
+    | NonNullableValue
+
+type GenericParamMetadata =
+    {
+        Variance : GenericVariance option
+        Constraint : GenericConstraint option
+        RequiresParameterlessConstructor : bool
+    }
+
+/// <summary>
+/// Represents a generic type or method parameter definition.
+/// Corresponds to GenericParameter in System.Reflection.Metadata.
+/// </summary>
+type GenericParameter =
+    {
+        /// <summary>The name of the generic parameter (e.g., 'T', 'TKey', etc.).</summary>
+        Name : string
+
+        /// <summary>
+        /// The zero-based index of the generic parameter in the generic parameter list.
+        /// For example, in Dictionary&lt;TKey, TValue&rt;, TKey has index 0 and TValue has index 1.
+        /// </summary>
+        SequenceNumber : int
+    }
+
+type GenericParamFromMetadata = GenericParameter * GenericParamMetadata
+
+[<RequireQualifiedAccess>]
+module GenericParameter =
+    let readAll
+        (metadata : MetadataReader)
+        (param : GenericParameterHandleCollection)
+        : GenericParamFromMetadata ImmutableArray
+        =
+        param
+        |> Seq.map (fun param ->
+            let param = metadata.GetGenericParameter param
+
+            let requiresParamlessCons =
+                param.Attributes.HasFlag GenericParameterAttributes.DefaultConstructorConstraint
+
+            let constr =
+                if param.Attributes.HasFlag GenericParameterAttributes.NotNullableValueTypeConstraint then
+                    Some GenericConstraint.NonNullableValue
+                elif param.Attributes.HasFlag GenericParameterAttributes.ReferenceTypeConstraint then
+                    Some GenericConstraint.Reference
+                else
+                    None
+
+            let variance =
+                if param.Attributes.HasFlag GenericParameterAttributes.Contravariant then
+                    Some GenericVariance.Contravariant
+                elif param.Attributes.HasFlag GenericParameterAttributes.Covariant then
+                    Some GenericVariance.Covariant
+                else
+                    None
+
+            let md =
+                {
+                    Variance = variance
+                    Constraint = constr
+                    RequiresParameterlessConstructor = requiresParamlessCons
+                }
+
+            let p =
+                {
+                    Name = metadata.GetString param.Name
+                    SequenceNumber = param.Index
+                }
+
+            p, md
+        )
+        |> ImmutableArray.CreateRange

WoofWare.PawPrint.Domain/IlOp.fs

@@ -78,6 +78,9 @@ type NullaryIlOp =
     | Not
     | Shr
     | Shr_un
+    /// Shifts an integer value to the left (in zeroes) by a specified number of bits, pushing the result onto the evaluation stack.
+    /// Top of stack is number of bits to be shifted.
+    /// Inserts a zero bit in the lowest positions.
     | Shl
     | Conv_ovf_i
     | Conv_ovf_u
@@ -123,6 +126,7 @@ type NullaryIlOp =
     | Localloc
     /// Dereferences the pointer on top of the stack, and pushes the target to the stack as a type O (object reference).
     | Ldind_ref
+    /// Stores an object reference value at a supplied address.
     | Stind_ref
     | Stind_I
     | Stind_I1
@@ -166,18 +170,25 @@ type NullaryIlOp =
     | Ldelem_u8
     | Ldelem_r4
     | Ldelem_r8
+    /// Loads the element containing an object reference at a specified array index onto the top of the evaluation stack as type O (object reference).
     | Ldelem_ref
+    /// Replaces the array element at a given index with the nativeint value on the evaluation stack.
     | Stelem_i
+    /// Replaces the array element at a given index with the int8 value on the evaluation stack.
     | Stelem_i1
     | Stelem_u1
+    /// Replaces the array element at a given index with the int16 value on the evaluation stack.
     | Stelem_i2
     | Stelem_u2
+    /// Replaces the array element at a given index with the int32 value on the evaluation stack.
     | Stelem_i4
     | Stelem_u4
+    /// Replaces the array element at a given index with the int64 value on the evaluation stack.
     | Stelem_i8
     | Stelem_u8
     | Stelem_r4
     | Stelem_r8
+    /// Replaces the array element at a given index with the object ref value (type O) on the evaluation stack.
     | Stelem_ref
     | Cpblk
     | Initblk
@@ -384,6 +395,7 @@ type UnaryConstIlOp =
     | Bge_un_s of int8
     | Bgt_un_s of int8
     | Ble_un_s of int8
+    /// Transfers control to a target instruction if the first value is less than the second value.
     | Blt_un_s of int8
     | Bne_un of int32
     | Bge_un of int32
@@ -529,6 +541,7 @@ type UnaryMetadataTokenIlOp =
     | Newobj
     | Newarr
     | Box
+    /// Loads the address of the array element at a specified array index onto the top of the evaluation stack as type "managed pointer"
     | Ldelema
     | Isinst
     /// Pop value from stack; pop object ref from stack; set specified field on that object to that value.

WoofWare.PawPrint.Domain/ImmutableArray.fs

@@ -0,0 +1,22 @@
+namespace WoofWare.PawPrint
+
+open System.Collections.Immutable
+
+[<RequireQualifiedAccess>]
+module internal ImmutableArray =
+
+    let inline map ([<InlineIfLambda>] f : 'a -> 'b) (arr : ImmutableArray<'a>) : ImmutableArray<'b> =
+        let b = ImmutableArray.CreateBuilder ()
+
+        for i in arr do
+            b.Add (f i)
+
+        b.ToImmutable ()
+
+    let inline mapi ([<InlineIfLambda>] f : int -> 'a -> 'b) (arr : ImmutableArray<'a>) : ImmutableArray<'b> =
+        let b = ImmutableArray.CreateBuilder ()
+
+        for i = 0 to arr.Length - 1 do
+            b.Add (f i arr.[i])
+
+        b.ToImmutable ()

WoofWare.PawPrint.Domain/MethodInfo.fs

@@ -52,40 +52,6 @@ module Parameter =
 
         result.ToImmutable ()
 
-/// <summary>
-/// Represents a generic type or method parameter definition.
-/// Corresponds to GenericParameter in System.Reflection.Metadata.
-/// </summary>
-type GenericParameter =
-    {
-        /// <summary>The name of the generic parameter (e.g., 'T', 'TKey', etc.).</summary>
-        Name : string
-
-        /// <summary>
-        /// The zero-based index of the generic parameter in the generic parameter list.
-        /// For example, in Dictionary&lt;TKey, TValue&rt;, TKey has index 0 and TValue has index 1.
-        /// </summary>
-        SequenceNumber : int
-    }
-
-[<RequireQualifiedAccess>]
-module GenericParameter =
-    let readAll
-        (metadata : MetadataReader)
-        (param : GenericParameterHandleCollection)
-        : GenericParameter ImmutableArray
-        =
-        param
-        |> Seq.map (fun param ->
-            let param = metadata.GetGenericParameter param
-
-            {
-                Name = metadata.GetString param.Name
-                SequenceNumber = param.Index
-            }
-        )
-        |> ImmutableArray.CreateRange
-
 type ExceptionOffset =
     {
         TryLength : int
@@ -117,7 +83,7 @@ type ExceptionRegion =
         | ExceptionRegionKind.Fault -> ExceptionRegion.Fault offset
         | _ -> raise (ArgumentOutOfRangeException ())
 
-type MethodInstructions =
+type MethodInstructions<'methodVars> =
     {
         /// <summary>
         /// The IL instructions that compose the method body, along with their offset positions.
@@ -137,12 +103,14 @@ type MethodInstructions =
         /// </summary>
         LocalsInit : bool
 
-        LocalVars : ImmutableArray<TypeDefn> option
+        LocalVars : ImmutableArray<'methodVars> option
 
         ExceptionRegions : ImmutableArray<ExceptionRegion>
     }
 
-    static member OnlyRet : MethodInstructions =
+[<RequireQualifiedAccess>]
+module MethodInstructions =
+    let onlyRet () : MethodInstructions<'methodVars> =
         let op = IlOp.Nullary NullaryIlOp.Ret
 
         {
@@ -153,12 +121,20 @@ type MethodInstructions =
             ExceptionRegions = ImmutableArray.Empty
         }
 
+    let setLocalVars<'a, 'b> (v : ImmutableArray<'b> option) (s : MethodInstructions<'a>) : MethodInstructions<'b> =
+        {
+            Instructions = s.Instructions
+            Locations = s.Locations
+            LocalsInit = s.LocalsInit
+            LocalVars = v
+            ExceptionRegions = s.ExceptionRegions
+        }
+
 /// <summary>
 /// Represents detailed information about a method in a .NET assembly.
 /// This is a strongly-typed representation of MethodDefinition from System.Reflection.Metadata.
 /// </summary>
-type MethodInfo<'typeGenerics, 'methodGenerics
-    when 'typeGenerics :> IComparable<'typeGenerics> and 'typeGenerics : comparison> =
+type MethodInfo<'typeGenerics, 'methodGenerics, 'methodVars> =
     {
         /// <summary>
         /// The type that declares this method, along with its assembly information.
@@ -178,7 +154,7 @@ type MethodInfo<'typeGenerics, 'methodGenerics
         ///
         /// There may be no instructions for this method, e.g. if it's an `InternalCall`.
         /// </summary>
-        Instructions : MethodInstructions option
+        Instructions : MethodInstructions<'methodVars> option
 
         /// <summary>
         /// The parameters of this method.
@@ -193,7 +169,12 @@ type MethodInfo<'typeGenerics, 'methodGenerics
         /// <summary>
         /// The signature of the method, including return type and parameter types.
         /// </summary>
-        Signature : TypeMethodSignature<TypeDefn>
+        Signature : TypeMethodSignature<'methodVars>
+
+        /// <summary>
+        /// The signature as it was read from assembly metadata.
+        /// </summary>
+        RawSignature : TypeMethodSignature<TypeDefn>
 
         /// <summary>
         /// Custom attributes defined on the method. I've never yet seen one of these in practice.
@@ -226,9 +207,12 @@ type MethodInfo<'typeGenerics, 'methodGenerics
     member this.IsPinvokeImpl : bool =
         this.MethodAttributes.HasFlag MethodAttributes.PinvokeImpl
 
-    member this.IsJITIntrinsic
+[<RequireQualifiedAccess>]
+module MethodInfo =
+    let isJITIntrinsic
         (getMemberRefParentType : MemberReferenceHandle -> TypeRef)
-        (methodDefs : IReadOnlyDictionary<MethodDefinitionHandle, MethodInfo<FakeUnit, GenericParameter>>)
+        (methodDefs : IReadOnlyDictionary<MethodDefinitionHandle, MethodInfo<'a, 'b, 'c>>)
+        (this : MethodInfo<'d, 'e, 'f>)
         : bool
         =
         this.CustomAttributes
@@ -248,47 +232,68 @@ type MethodInfo<'typeGenerics, 'methodGenerics
             | con -> failwith $"TODO: {con}"
         )
 
-[<RequireQualifiedAccess>]
-module MethodInfo =
-    let mapTypeGenerics<'a, 'b, 'methodGen
-        when 'a :> IComparable<'a> and 'a : comparison and 'b : comparison and 'b :> IComparable<'b>>
-        (f : int -> 'a -> 'b)
-        (m : MethodInfo<'a, 'methodGen>)
-        : MethodInfo<'b, 'methodGen>
+    let mapTypeGenerics<'a, 'b, 'methodGen, 'vars>
+        (f : 'a -> 'b)
+        (m : MethodInfo<'a, 'methodGen, 'vars>)
+        : MethodInfo<'b, 'methodGen, 'vars>
         =
         {
-            DeclaringType = m.DeclaringType |> ConcreteType.mapGeneric f
+            DeclaringType = m.DeclaringType |> ConcreteType.mapGeneric (fun _ -> f)
             Handle = m.Handle
             Name = m.Name
             Instructions = m.Instructions
             Parameters = m.Parameters
             Generics = m.Generics
             Signature = m.Signature
+            RawSignature = m.RawSignature
             CustomAttributes = m.CustomAttributes
             MethodAttributes = m.MethodAttributes
             ImplAttributes = m.ImplAttributes
             IsStatic = m.IsStatic
         }
 
-    let mapMethodGenerics<'a, 'b, 'typeGen when 'typeGen :> IComparable<'typeGen> and 'typeGen : comparison>
+    let mapMethodGenerics<'a, 'b, 'vars, 'typeGen>
         (f : int -> 'a -> 'b)
-        (m : MethodInfo<'typeGen, 'a>)
-        : MethodInfo<'typeGen, 'b>
+        (m : MethodInfo<'typeGen, 'a, 'vars>)
+        : MethodInfo<'typeGen, 'b, 'vars>
         =
+        let generics = m.Generics |> Seq.mapi f |> ImmutableArray.CreateRange
+
         {
             DeclaringType = m.DeclaringType
             Handle = m.Handle
             Name = m.Name
             Instructions = m.Instructions
             Parameters = m.Parameters
-            Generics = m.Generics |> Seq.mapi f |> ImmutableArray.CreateRange
+            Generics = generics
             Signature = m.Signature
+            RawSignature = m.RawSignature
             CustomAttributes = m.CustomAttributes
             MethodAttributes = m.MethodAttributes
             ImplAttributes = m.ImplAttributes
             IsStatic = m.IsStatic
         }
 
+    let setMethodVars
+        (vars2 : MethodInstructions<'vars2> option)
+        (signature : TypeMethodSignature<'vars2>)
+        (m : MethodInfo<'typeGen, 'methodGen, 'vars1>)
+        : MethodInfo<'typeGen, 'methodGen, 'vars2>
+        =
+        {
+            DeclaringType = m.DeclaringType
+            Handle = m.Handle
+            Name = m.Name
+            Instructions = vars2
+            Parameters = m.Parameters
+            Generics = m.Generics
+            Signature = signature
+            RawSignature = m.RawSignature
+            CustomAttributes = m.CustomAttributes
+            MethodAttributes = m.MethodAttributes
+            ImplAttributes = m.ImplAttributes
+            IsStatic = m.IsStatic
+        }
 
     type private Dummy = class end
 
@@ -637,7 +642,7 @@ module MethodInfo =
         (peReader : PEReader)
         (metadataReader : MetadataReader)
         (methodHandle : MethodDefinitionHandle)
-        : MethodInfo<FakeUnit, GenericParameter> option
+        : MethodInfo<GenericParamFromMetadata, GenericParamFromMetadata, TypeDefn> option
         =
         let logger = loggerFactory.CreateLogger "MethodInfo"
         let assemblyName = metadataReader.GetAssemblyDefinition().GetAssemblyName ()
@@ -671,11 +676,15 @@ module MethodInfo =
 
         let declaringType = methodDef.GetDeclaringType ()
 
-        let declaringTypeName =
-            metadataReader.GetString (metadataReader.GetTypeDefinition(declaringType).Name)
+        let declaringDefn = metadataReader.GetTypeDefinition (declaringType)
+
+        let declaringTypeNamespace = metadataReader.GetString declaringDefn.Namespace
+
+        let declaringTypeName = metadataReader.GetString declaringDefn.Name
 
         let declaringTypeGenericParams =
-            metadataReader.GetTypeDefinition(declaringType).GetGenericParameters().Count
+            metadataReader.GetTypeDefinition(declaringType).GetGenericParameters ()
+            |> GenericParameter.readAll metadataReader
 
         let attrs =
             let result = ImmutableArray.CreateBuilder ()
@@ -696,7 +705,12 @@ module MethodInfo =
             GenericParameter.readAll metadataReader (methodDef.GetGenericParameters ())
 
         let declaringType =
-            ConcreteType.make' assemblyName declaringType declaringTypeName declaringTypeGenericParams
+            ConcreteType.make
+                assemblyName
+                declaringType
+                declaringTypeNamespace
+                declaringTypeName
+                declaringTypeGenericParams
 
         {
             DeclaringType = declaringType
@@ -706,6 +720,7 @@ module MethodInfo =
             Parameters = methodParams
             Generics = methodGenericParams
             Signature = typeSig
+            RawSignature = typeSig
             MethodAttributes = methodDef.Attributes
             CustomAttributes = attrs
             IsStatic = not methodSig.Header.IsInstance
@@ -715,7 +730,7 @@ module MethodInfo =
 
     let rec resolveBaseType
         (methodGenerics : TypeDefn ImmutableArray option)
-        (executingMethod : MethodInfo<TypeDefn, 'methodGen>)
+        (executingMethod : MethodInfo<TypeDefn, 'methodGen, 'vars>)
         (td : TypeDefn)
         : ResolvedBaseType
         =

WoofWare.PawPrint.Domain/MethodSpec.fs

@@ -15,6 +15,17 @@ type MethodSpec =
         /// </summary>
         Method : MetadataToken
 
+        /// <summary>
+        /// The actual type arguments for generic instantiation.
+        /// </summary>
+        /// <example>
+        /// For <c>Volatile.Read&lt;System.IO.TextWriter&gt;</c>, the <c>Signature</c> is <c>[System.IO.TextWriter]</c>.
+        /// </example>
+        /// <remarks>
+        /// The contents might themselves be <c>TypeDefn.GenericMethodParameter</c>, for example.
+        /// This happens when the method is itself being called from within a generic method, and the generic parameters
+        /// of the spec are being instantiated with generic parameters from the caller.
+        /// </remarks>
         Signature : TypeDefn ImmutableArray
     }
 

WoofWare.PawPrint.Domain/TypeDefn.fs

@@ -6,6 +6,8 @@ open System.Reflection.Metadata
 open System.Reflection.Metadata.Ecma335
 open Microsoft.FSharp.Core
 
+[<RequireQualifiedAccess>]
+[<NoComparison>]
 type ResolvedBaseType =
     | Enum
     | ValueType
@@ -55,6 +57,34 @@ module TypeMethodSignature =
             RequiredParameterCount = p.RequiredParameterCount
         }
 
+    let map<'a, 'b, 'state>
+        (state : 'state)
+        (f : 'state -> 'a -> 'state * 'b)
+        (signature : TypeMethodSignature<'a>)
+        : 'state * TypeMethodSignature<'b>
+        =
+        let state, ret = f state signature.ReturnType
+
+        let state, pars =
+            ((state, []), signature.ParameterTypes)
+            ||> List.fold (fun (state, acc) par ->
+                let state, result = f state par
+                state, result :: acc
+            )
+
+        let pars = List.rev pars
+
+        let answer =
+            {
+                Header = signature.Header
+                ReturnType = ret
+                ParameterTypes = pars
+                GenericParameterCount = signature.GenericParameterCount
+                RequiredParameterCount = signature.RequiredParameterCount
+            }
+
+        state, answer
+
 /// See I.8.2.2
 type PrimitiveType =
     | Boolean
@@ -121,6 +151,28 @@ type PrimitiveType =
         | PrimitiveType.UIntPtr -> "uintptr"
         | PrimitiveType.Object -> "obj"
 
+[<RequireQualifiedAccess>]
+module PrimitiveType =
+    let sizeOf (pt : PrimitiveType) : int =
+        match pt with
+        | PrimitiveType.Boolean -> 1
+        | PrimitiveType.Char -> 2
+        | PrimitiveType.SByte -> 1
+        | PrimitiveType.Byte -> 1
+        | PrimitiveType.Int16 -> 2
+        | PrimitiveType.UInt16 -> 2
+        | PrimitiveType.Int32 -> 4
+        | PrimitiveType.UInt32 -> 4
+        | PrimitiveType.Int64 -> 8
+        | PrimitiveType.UInt64 -> 8
+        | PrimitiveType.Single -> 4
+        | PrimitiveType.Double -> 8
+        | PrimitiveType.String -> 8
+        | PrimitiveType.TypedReference -> failwith "todo"
+        | PrimitiveType.IntPtr -> NATIVE_INT_SIZE
+        | PrimitiveType.UIntPtr -> NATIVE_INT_SIZE
+        | PrimitiveType.Object -> 8
+
 type TypeDefn =
     | PrimitiveType of PrimitiveType
     // TODO: array shapes
@@ -134,7 +186,21 @@ type TypeDefn =
     | FromDefinition of ComparableTypeDefinitionHandle * assemblyFullName : string * SignatureTypeKind
     | GenericInstantiation of generic : TypeDefn * args : ImmutableArray<TypeDefn>
     | FunctionPointer of TypeMethodSignature<TypeDefn>
+    /// <summary>
+    /// A class/interface generic.
+    /// </summary>
+    /// <example>
+    /// The type <c>List&lt;T&gt;</c> has a generic parameter; an instance method on that <c>List</c> would refer to
+    /// <c>T</c> as <c>GenericTypeParameter 0</c>.
+    /// </example>
     | GenericTypeParameter of index : int
+    /// <summary>
+    /// A method generic.
+    /// </summary>
+    /// <example>
+    /// The method <c>List.map&lt;'a, 'b&gt;</c> takes two generic parameters; those are referred to as
+    /// <c>GenericMethodParameter 0</c> and <c>GenericMethodParameter 1</c> respectively.
+    /// </example>
     | GenericMethodParameter of index : int
     /// Not really a type: this indicates the *absence* of a return value.
     | Void

WoofWare.PawPrint.Domain/TypeInfo.fs

@@ -1,5 +1,6 @@
 namespace WoofWare.PawPrint
 
+open System
 open System.Collections.Generic
 open System.Collections.Immutable
 open System.Reflection
@@ -19,11 +20,24 @@ type MethodImplParsed =
     | MethodImplementation of MethodImplementationHandle
     | MethodDefinition of MethodDefinitionHandle
 
+type InterfaceImplementation =
+    {
+        /// TypeDefinition, TypeReference, or TypeSpecification
+        InterfaceHandle : MetadataToken
+
+        /// The assembly which InterfaceHandle is relative to
+        RelativeToAssembly : AssemblyName
+    }
+
+type Layout =
+    | Default
+    | Custom of size : int * packingSize : int
+
 /// <summary>
 /// Represents detailed information about a type definition in a .NET assembly.
 /// This is a strongly-typed representation of TypeDefinition from System.Reflection.Metadata.
 /// </summary>
-type TypeInfo<'generic> =
+type TypeInfo<'generic, 'fieldGeneric> =
     {
         /// <summary>The namespace containing the type.</summary>
         Namespace : string
@@ -34,7 +48,7 @@ type TypeInfo<'generic> =
         /// <summary>
         /// All methods defined within this type.
         /// </summary>
-        Methods : WoofWare.PawPrint.MethodInfo<FakeUnit, WoofWare.PawPrint.GenericParameter> list
+        Methods : WoofWare.PawPrint.MethodInfo<GenericParamFromMetadata, GenericParamFromMetadata, TypeDefn> list
 
         /// <summary>
         /// Method implementation mappings for this type, often used for interface implementations
@@ -45,7 +59,7 @@ type TypeInfo<'generic> =
         /// <summary>
         /// Fields defined in this type.
         /// </summary>
-        Fields : WoofWare.PawPrint.FieldInfo<FakeUnit> list
+        Fields : WoofWare.PawPrint.FieldInfo<GenericParamFromMetadata, 'fieldGeneric> list
 
         /// <summary>
         /// The base type that this type inherits from, or None for types that don't have a base type
@@ -71,6 +85,8 @@ type TypeInfo<'generic> =
         /// </summary>
         TypeDefHandle : TypeDefinitionHandle
 
+        DeclaringType : TypeDefinitionHandle
+
         /// <summary>
         /// The assembly in which this type is defined.
         /// </summary>
@@ -79,13 +95,40 @@ type TypeInfo<'generic> =
         Generics : 'generic ImmutableArray
 
         Events : EventDefn ImmutableArray
+
+        ImplementedInterfaces : InterfaceImplementation ImmutableArray
+
+        Layout : Layout
     }
 
+    member this.IsInterface = this.TypeAttributes.HasFlag TypeAttributes.Interface
+
+    member this.IsNested =
+        [
+            TypeAttributes.NestedPublic
+            TypeAttributes.NestedPrivate
+            TypeAttributes.NestedFamily
+            TypeAttributes.NestedAssembly
+            TypeAttributes.NestedFamANDAssem
+            TypeAttributes.NestedFamORAssem
+        ]
+        |> List.exists this.TypeAttributes.HasFlag
+
     override this.ToString () =
         $"%s{this.Assembly.Name}.%s{this.Namespace}.%s{this.Name}"
 
+    static member NominallyEqual
+        (a : TypeInfo<'generic, 'fieldGeneric>)
+        (b : TypeInfo<'generic, 'fieldGeneric>)
+        : bool
+        =
+        a.Assembly.FullName = b.Assembly.FullName
+        && a.Namespace = b.Namespace
+        && a.Name = b.Name
+        && a.Generics = b.Generics
+
 type TypeInfoEval<'ret> =
-    abstract Eval<'a> : TypeInfo<'a> -> 'ret
+    abstract Eval<'a, 'field> : TypeInfo<'a, 'field> -> 'ret
 
 type TypeInfoCrate =
     abstract Apply<'ret> : TypeInfoEval<'ret> -> 'ret
@@ -97,13 +140,13 @@ type TypeInfoCrate =
 
 [<RequireQualifiedAccess>]
 module TypeInfoCrate =
-    let make<'a> (t : TypeInfo<'a>) =
+    let make<'a, 'field> (t : TypeInfo<'a, 'field>) : TypeInfoCrate =
         { new TypeInfoCrate with
             member _.Apply e = e.Eval t
 
             member this.ToString () =
                 { new TypeInfoEval<_> with
-                    member _.Eval this = string<TypeInfo<_>> this
+                    member _.Eval this = string<TypeInfo<_, _>> this
                 }
                 |> this.Apply
 
@@ -119,33 +162,48 @@ module TypeInfoCrate =
 type BaseClassTypes<'corelib> =
     {
         Corelib : 'corelib
-        String : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Boolean : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Char : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        SByte : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Byte : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Int16 : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        UInt16 : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Int32 : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        UInt32 : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Int64 : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        UInt64 : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Single : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Double : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Array : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Enum : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        ValueType : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        DelegateType : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        Object : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        RuntimeMethodHandle : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        RuntimeFieldHandle : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        RuntimeTypeHandle : TypeInfo<WoofWare.PawPrint.GenericParameter>
-        RuntimeType : TypeInfo<WoofWare.PawPrint.GenericParameter>
+        String : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Boolean : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Char : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        SByte : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Byte : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Int16 : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        UInt16 : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Int32 : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        UInt32 : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Int64 : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        UInt64 : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Single : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Double : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Array : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Enum : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        ValueType : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        DelegateType : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Object : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        RuntimeMethodHandle : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        RuntimeFieldHandle : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        RuntimeTypeHandle : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        RuntimeFieldInfoStub : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        RuntimeFieldHandleInternal : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        RuntimeType : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        Void : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        TypedReference : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        IntPtr : TypeInfo<GenericParamFromMetadata, TypeDefn>
+        UIntPtr : TypeInfo<GenericParamFromMetadata, TypeDefn>
     }
 
 [<RequireQualifiedAccess>]
 module TypeInfo =
-    let withGenerics<'a, 'b> (gen : 'b ImmutableArray) (t : TypeInfo<'a>) : TypeInfo<'b> =
+    let rec fullName (get : TypeDefinitionHandle -> TypeInfo<_, _>) (ty : TypeInfo<'a, 'b>) =
+        if ty.IsNested then
+            let parent = get ty.DeclaringType |> fullName get
+            $"%s{parent}.{ty.Name}"
+        else if not (String.IsNullOrEmpty ty.Namespace) then
+            $"{ty.Namespace}.{ty.Name}"
+        else
+            ty.Name
+
+    let withGenerics<'a, 'b, 'field> (gen : 'b ImmutableArray) (t : TypeInfo<'a, 'field>) : TypeInfo<'b, 'field> =
         {
             Namespace = t.Namespace
             Name = t.Name
@@ -156,13 +214,16 @@ module TypeInfo =
             TypeAttributes = t.TypeAttributes
             Attributes = t.Attributes
             TypeDefHandle = t.TypeDefHandle
+            DeclaringType = t.DeclaringType
             Assembly = t.Assembly
             Generics = gen
             Events = t.Events
+            ImplementedInterfaces = t.ImplementedInterfaces
+            Layout = t.Layout
         }
 
-    let mapGeneric<'a, 'b> (f : int -> 'a -> 'b) (t : TypeInfo<'a>) : TypeInfo<'b> =
-        withGenerics (t.Generics |> Seq.mapi f |> ImmutableArray.CreateRange) t
+    let mapGeneric<'a, 'b, 'field> (f : 'a -> 'b) (t : TypeInfo<'a, 'field>) : TypeInfo<'b, 'field> =
+        withGenerics (t.Generics |> ImmutableArray.map f) t
 
     let internal read
         (loggerFactory : ILoggerFactory)
@@ -170,9 +231,10 @@ module TypeInfo =
         (thisAssembly : AssemblyName)
         (metadataReader : MetadataReader)
         (typeHandle : TypeDefinitionHandle)
-        : TypeInfo<WoofWare.PawPrint.GenericParameter>
+        : TypeInfo<GenericParamFromMetadata, TypeDefn>
         =
         let typeDef = metadataReader.GetTypeDefinition typeHandle
+        let declaringType = typeDef.GetDeclaringType ()
         let methods = typeDef.GetMethods ()
 
         let methodImpls =
@@ -239,6 +301,28 @@ module TypeInfo =
 
             result.ToImmutable ()
 
+        let interfaces =
+            let result = ImmutableArray.CreateBuilder ()
+
+            for i in typeDef.GetInterfaceImplementations () do
+                let impl = metadataReader.GetInterfaceImplementation i
+
+                {
+                    InterfaceHandle = MetadataToken.ofEntityHandle impl.Interface
+                    RelativeToAssembly = thisAssembly
+                }
+                |> result.Add
+
+            result.ToImmutable ()
+
+        let layout =
+            let l = typeDef.GetLayout ()
+
+            if l.IsDefault then
+                Layout.Default
+            else
+                Layout.Custom (size = l.Size, packingSize = l.PackingSize)
+
         {
             Namespace = ns
             Name = name
@@ -252,6 +336,9 @@ module TypeInfo =
             Assembly = thisAssembly
             Generics = genericParams
             Events = events
+            ImplementedInterfaces = interfaces
+            DeclaringType = declaringType
+            Layout = layout
         }
 
     let isBaseType<'corelib>
@@ -275,12 +362,12 @@ module TypeInfo =
         else
             None
 
-    let rec resolveBaseType<'corelib, 'generic>
+    let rec resolveBaseType<'corelib, 'generic, 'field>
         (baseClassTypes : BaseClassTypes<'corelib>)
+        (sourceAssy : 'corelib)
         (getName : 'corelib -> AssemblyName)
-        (getTypeDef : 'corelib -> TypeDefinitionHandle -> TypeInfo<'generic>)
-        (getTypeRef : 'corelib -> TypeReferenceHandle -> TypeInfo<'generic>)
-        (sourceAssembly : AssemblyName)
+        (getTypeDef : 'corelib -> TypeDefinitionHandle -> TypeInfo<'generic, 'field>)
+        (getTypeRef : 'corelib -> TypeReferenceHandle -> 'corelib * TypeInfo<'generic, 'field>)
         (value : BaseTypeInfo option)
         : ResolvedBaseType
         =
@@ -290,37 +377,52 @@ 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
-        (corelib : BaseClassTypes<'corelib>)
+        (baseClassTypes : BaseClassTypes<'corelib>)
+        (assemblies : AssemblyName -> 'corelib)
         (getName : 'corelib -> AssemblyName)
-        (getTypeDef : 'corelib -> TypeDefinitionHandle -> TypeInfo<'generic>)
-        (getTypeRef : 'corelib -> TypeReferenceHandle -> TypeInfo<'generic>)
-        (ty : TypeInfo<'generic>)
+        (getTypeDef : 'corelib -> TypeDefinitionHandle -> TypeInfo<'generic, 'field>)
+        (getTypeRef : 'corelib -> TypeReferenceHandle -> 'corelib * TypeInfo<'generic, 'field>)
+        (ty : TypeInfo<TypeDefn, TypeDefn>)
         : TypeDefn
         =
         let stk =
-            match resolveBaseType corelib 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 -> SignatureTypeKind.Class
-            | ResolvedBaseType.Delegate -> failwith "todo"
+            | ResolvedBaseType.Object
+            | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
 
-        TypeDefn.FromDefinition (ComparableTypeDefinitionHandle.Make ty.TypeDefHandle, ty.Assembly.FullName, stk)
+        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
+            defn
+        else
+            let generics = ty.Generics
+            TypeDefn.GenericInstantiation (defn, generics)

WoofWare.PawPrint.Domain/WoofWare.PawPrint.Domain.fsproj

@@ -7,13 +7,17 @@
 
     <ItemGroup>
         <Compile Include="StringToken.fs" />
+        <Compile Include="Constants.fs" />
+        <Compile Include="ImmutableArray.fs" />
         <Compile Include="Tokens.fs" />
         <Compile Include="TypeRef.fs" />
         <Compile Include="IlOp.fs" />
         <Compile Include="CustomAttribute.fs" />
+        <Compile Include="GenericParameter.fs" />
         <Compile Include="AssemblyReference.fs" />
         <Compile Include="EventDefn.fs" />
         <Compile Include="ComparableTypeDefinitionHandle.fs" />
+        <Compile Include="ComparableFieldDefinitionHandle.fs" />
         <Compile Include="ComparableSignatureHeader.fs" />
         <Compile Include="TypeDefn.fs" />
         <Compile Include="ConcreteType.fs" />
@@ -26,6 +30,7 @@
         <Compile Include="ExportedType.fs" />
         <Compile Include="TypeSpec.fs" />
         <Compile Include="Assembly.fs" />
+        <Compile Include="TypeConcretisation.fs" />
     </ItemGroup>
 
     <ItemGroup>

WoofWare.PawPrint.Test/RealRuntime.fs

@@ -0,0 +1,18 @@
+namespace WoofWare.PawPrint.Test
+
+/// Result of executing the program using the real .NET runtime.
+type RealRuntimeResult =
+    {
+        ExitCode : int
+    }
+
+[<RequireQualifiedAccess>]
+module RealRuntime =
+    /// Execute an assembly using the real .NET runtime and capture the result.
+    let executeWithRealRuntime (args : string[]) (assemblyBytes : byte array) : RealRuntimeResult =
+        let assy = System.Reflection.Assembly.Load assemblyBytes
+        let result = assy.EntryPoint.Invoke ((null : obj), [| args |]) |> unbox<int>
+
+        {
+            ExitCode = result
+        }

WoofWare.PawPrint.Test/Roslyn.fs

@@ -32,7 +32,7 @@ module Roslyn =
             |> Array.map (fun path -> MetadataReference.CreateFromFile path :> MetadataReference)
 
         let compilationOptions =
-            CSharpCompilationOptions(OutputKind.ConsoleApplication).WithAllowUnsafe (true)
+            CSharpCompilationOptions(OutputKind.ConsoleApplication).WithAllowUnsafe true
 
         let compilation =
             CSharpCompilation.Create (

WoofWare.PawPrint.Test/TestCases.fs

@@ -1,278 +0,0 @@
-namespace WoofWare.Pawprint.Test
-
-open System.Collections.Immutable
-open System.IO
-open FsUnitTyped
-open NUnit.Framework
-open WoofWare.DotnetRuntimeLocator
-open WoofWare.PawPrint
-open WoofWare.PawPrint.ExternImplementations
-open WoofWare.PawPrint.Test
-
-[<TestFixture>]
-[<Parallelizable(ParallelScope.All)>]
-module TestCases =
-    let assy = typeof<RunResult>.Assembly
-
-    let unimplemented =
-        [
-            {
-                FileName = "Threads.cs"
-                ExpectedReturnCode = 3
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain = []
-            }
-            {
-                FileName = "ComplexTryCatch.cs"
-                ExpectedReturnCode = 14
-                NativeImpls = NativeImpls.PassThru ()
-                LocalVariablesOfMain =
-                    [
-                        4
-                        20
-                        115
-                        12
-                        1
-                        10
-                        2
-                        112
-                        12
-                        1111
-                        42
-                        99
-                        25
-                        50
-                        123
-                        20
-                        35
-                        5
-                        11111
-                        100001
-                    ]
-                    |> List.map (fun i -> CliType.Numeric (CliNumericType.Int32 i))
-            }
-            {
-                FileName = "WriteLine.cs"
-                ExpectedReturnCode = 1
-                NativeImpls = NativeImpls.PassThru ()
-                LocalVariablesOfMain = []
-            }
-            {
-                FileName = "ResizeArray.cs"
-                ExpectedReturnCode = 109
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain = [ CliType.Numeric (CliNumericType.Int32 10) ]
-            }
-        ]
-
-    let cases : TestCase list =
-        [
-            {
-                FileName = "NoOp.cs"
-                ExpectedReturnCode = 1
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain = [ CliType.Numeric (CliNumericType.Int32 1) ]
-            }
-            {
-                FileName = "Ldind.cs"
-                ExpectedReturnCode = 0
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain =
-                    [
-                        // `failures`
-                        CliType.Numeric (CliNumericType.Int32 0)
-                        // Return value
-                        CliType.Numeric (CliNumericType.Int32 0)
-                    ]
-            }
-            {
-                FileName = "CustomDelegate.cs"
-                ExpectedReturnCode = 8
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain =
-                    [
-                        // filter
-                        CliType.ObjectRef (Some (ManagedHeapAddress 2))
-                        // result
-                        CliType.OfBool true
-                        // result, cloned for "if(result)" check
-                        CliType.OfBool true
-                        // ret
-                        CliType.Numeric (CliNumericType.Int32 8)
-                    ]
-            }
-            {
-                FileName = "ArgumentOrdering.cs"
-                ExpectedReturnCode = 42
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain =
-                    [
-                        // localVar
-                        CliType.Numeric (CliNumericType.Int32 42)
-                        // t
-                        CliType.ValueType [ CliType.Numeric (CliNumericType.Int32 42) ]
-                        // return value
-                        CliType.Numeric (CliNumericType.Int32 42)
-                    ]
-            }
-            {
-                FileName = "BasicLock.cs"
-                ExpectedReturnCode = 1
-                NativeImpls =
-                    let mock = MockEnv.make ()
-
-                    { mock with
-                        System_Threading_Monitor = System_Threading_Monitor.passThru
-                    }
-                LocalVariablesOfMain =
-                    [
-                        // Four variables:
-                        // locker
-                        CliType.ObjectRef (Some (ManagedHeapAddress 2))
-                        // a copy of locker, taken so that the contents of the implicit `finally` have a stable copy
-                        CliType.ObjectRef (Some (ManagedHeapAddress 2))
-                        // out param of `ReliableEnter`
-                        CliType.OfBool true
-                        // return value
-                        CliType.Numeric (CliNumericType.Int32 1)
-                    ]
-            }
-            {
-                FileName = "TriangleNumber.cs"
-                ExpectedReturnCode = 10
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain =
-                    [
-                        // answer
-                        CliType.Numeric (CliNumericType.Int32 10)
-                        // i
-                        CliType.Numeric (CliNumericType.Int32 5)
-                        // End-loop condition
-                        CliType.OfBool false
-                        // Ret
-                        CliType.Numeric (CliNumericType.Int32 10)
-                    ]
-            }
-            {
-                FileName = "InstaQuit.cs"
-                ExpectedReturnCode = 1
-                NativeImpls =
-                    let mock = MockEnv.make ()
-
-                    { mock with
-                        System_Environment =
-                            { System_EnvironmentMock.Empty with
-                                GetProcessorCount =
-                                    fun thread state ->
-                                        let state =
-                                            state |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 1) thread
-
-                                        (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
-                                _Exit =
-                                    fun thread state ->
-                                        let state = state |> IlMachineState.loadArgument thread 0
-                                        ExecutionResult.Terminated (state, thread)
-                            }
-                    }
-                LocalVariablesOfMain = []
-            }
-            {
-                FileName = "ExceptionWithNoOpFinally.cs"
-                ExpectedReturnCode = 3
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain =
-                    [
-                        // Variable 1 is `x`, variable 2 is the implicit return value
-                        4
-                        3
-                    ]
-                    |> List.map (fun i -> CliType.Numeric (CliNumericType.Int32 i))
-            }
-            {
-                FileName = "ExceptionWithNoOpCatch.cs"
-                ExpectedReturnCode = 10
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain = [ CliType.Numeric (CliNumericType.Int32 10) ]
-            }
-            {
-                FileName = "TryCatchWithThrowInBody.cs"
-                ExpectedReturnCode = 4
-                NativeImpls = MockEnv.make ()
-                LocalVariablesOfMain =
-                    [
-                        // one variable is x, one variable is the return value which also happens to have the same value
-                        4
-                        4
-                    ]
-                    |> List.map (fun i -> CliType.Numeric (CliNumericType.Int32 i))
-            }
-        ]
-
-    [<TestCaseSource(nameof cases)>]
-    let ``Can evaluate C# files`` (case : TestCase) : unit =
-        let source = Assembly.getEmbeddedResourceAsString case.FileName assy
-        let image = Roslyn.compile [ source ]
-        let messages, loggerFactory = LoggerFactory.makeTest ()
-
-        let dotnetRuntimes =
-            DotnetRuntime.SelectForDll assy.Location |> ImmutableArray.CreateRange
-
-        use peImage = new MemoryStream (image)
-
-        try
-            let terminalState, terminatingThread =
-                Program.run loggerFactory (Some case.FileName) peImage dotnetRuntimes case.NativeImpls []
-
-            let exitCode =
-                match terminalState.ThreadState.[terminatingThread].MethodState.EvaluationStack.Values with
-                | [] -> failwith "expected program to return a value, but it returned void"
-                | head :: _ ->
-                    match head with
-                    | EvalStackValue.Int32 i -> i
-                    | ret -> failwith $"expected program to return an int, but it returned %O{ret}"
-
-            exitCode |> shouldEqual case.ExpectedReturnCode
-
-            let finalVariables =
-                terminalState.ThreadState.[terminatingThread].MethodState.LocalVariables
-                |> Seq.toList
-
-            finalVariables |> shouldEqual case.LocalVariablesOfMain
-
-        with _ ->
-            for message in messages () do
-                System.Console.Error.WriteLine $"{message}"
-
-            reraise ()
-
-    [<TestCaseSource(nameof unimplemented)>]
-    [<Explicit "not yet implemented">]
-    let ``Can evaluate C# files, unimplemented`` (case : TestCase) : unit =
-        let source = Assembly.getEmbeddedResourceAsString case.FileName assy
-        let image = Roslyn.compile [ source ]
-        let messages, loggerFactory = LoggerFactory.makeTest ()
-
-        let dotnetRuntimes =
-            DotnetRuntime.SelectForDll assy.Location |> ImmutableArray.CreateRange
-
-        use peImage = new MemoryStream (image)
-
-        try
-            let terminalState, terminatingThread =
-                Program.run loggerFactory (Some case.FileName) peImage dotnetRuntimes case.NativeImpls []
-
-            let exitCode =
-                match terminalState.ThreadState.[terminatingThread].MethodState.EvaluationStack.Values with
-                | [] -> failwith "expected program to return a value, but it returned void"
-                | head :: _ ->
-                    match head with
-                    | EvalStackValue.Int32 i -> i
-                    | ret -> failwith $"expected program to return an int, but it returned %O{ret}"
-
-            exitCode |> shouldEqual case.ExpectedReturnCode
-
-        with _ ->
-            for message in messages () do
-                System.Console.Error.WriteLine $"{message}"
-
-            reraise ()

WoofWare.PawPrint.Test/TestHarness.fs

@@ -25,10 +25,9 @@ module MockEnv =
             System_Threading_Monitor = System_Threading_MonitorMock.Empty
         }
 
-type TestCase =
+type EndToEndTestCase =
     {
         FileName : string
         ExpectedReturnCode : int
         NativeImpls : NativeImpls
-        LocalVariablesOfMain : CliType list
     }

WoofWare.PawPrint.Test/TestHelloWorld.fs

@@ -1,47 +0,0 @@
-namespace WoofWare.Pawprint.Test
-
-open System
-open System.Collections.Immutable
-open System.IO
-open FsUnitTyped
-open NUnit.Framework
-open WoofWare.PawPrint
-open WoofWare.PawPrint.ExternImplementations
-open WoofWare.PawPrint.Test
-open WoofWare.DotnetRuntimeLocator
-
-[<TestFixture>]
-module TestHelloWorld =
-    let assy = typeof<RunResult>.Assembly
-
-    [<Test ; Explicit "This test doesn't run yet">]
-    let ``Can run Hello World`` () : unit =
-        let source = Assembly.getEmbeddedResourceAsString "WriteLine.cs" assy
-        let image = Roslyn.compile [ source ]
-        let messages, loggerFactory = LoggerFactory.makeTest ()
-
-        let dotnetRuntimes =
-            DotnetRuntime.SelectForDll assy.Location |> ImmutableArray.CreateRange
-
-        let impls = NativeImpls.PassThru ()
-
-        try
-            use peImage = new MemoryStream (image)
-
-            let terminalState, terminatingThread =
-                Program.run loggerFactory (Some "HelloWorld.cs") peImage dotnetRuntimes impls []
-
-            let exitCode =
-                match terminalState.ThreadState.[terminatingThread].MethodState.EvaluationStack.Values with
-                | [] -> failwith "expected program to return 1, but it returned void"
-                | head :: _ ->
-                    match head with
-                    | EvalStackValue.Int32 i -> i
-                    | _ -> failwith "TODO"
-
-            exitCode |> shouldEqual 0
-        with _ ->
-            for m in messages () do
-                Console.Error.WriteLine $"{m}"
-
-            reraise ()

WoofWare.PawPrint.Test/TestImpureCases.fs

@@ -0,0 +1,87 @@
+namespace WoofWare.Pawprint.Test
+
+open System
+open System.Collections.Immutable
+open System.IO
+open FsUnitTyped
+open NUnit.Framework
+open WoofWare.DotnetRuntimeLocator
+open WoofWare.PawPrint
+open WoofWare.PawPrint.ExternImplementations
+open WoofWare.PawPrint.Test
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.All)>]
+module TestImpureCases =
+    let assy = typeof<RunResult>.Assembly
+
+    let unimplemented =
+        [
+            {
+                FileName = "WriteLine.cs"
+                ExpectedReturnCode = 1
+                NativeImpls = NativeImpls.PassThru ()
+            }
+        ]
+
+    let cases : EndToEndTestCase list =
+        [
+            {
+                FileName = "InstaQuit.cs"
+                ExpectedReturnCode = 1
+                NativeImpls =
+                    let mock = MockEnv.make ()
+
+                    { mock with
+                        System_Environment =
+                            { System_EnvironmentMock.Empty with
+                                GetProcessorCount =
+                                    fun thread state ->
+                                        let state =
+                                            state |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 1) thread
+
+                                        (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
+                                _Exit =
+                                    fun thread state ->
+                                        let state = state |> IlMachineState.loadArgument thread 0
+                                        ExecutionResult.Terminated (state, thread)
+                            }
+                    }
+            }
+        ]
+
+    let runTest (case : EndToEndTestCase) : unit =
+        let source = Assembly.getEmbeddedResourceAsString case.FileName assy
+        let image = Roslyn.compile [ source ]
+        let messages, loggerFactory = LoggerFactory.makeTest ()
+
+        let dotnetRuntimes =
+            DotnetRuntime.SelectForDll assy.Location |> ImmutableArray.CreateRange
+
+        use peImage = new MemoryStream (image)
+
+        try
+            let terminalState, terminatingThread =
+                Program.run loggerFactory (Some case.FileName) peImage dotnetRuntimes case.NativeImpls []
+
+            let exitCode =
+                match terminalState.ThreadState.[terminatingThread].MethodState.EvaluationStack.Values with
+                | [] -> failwith "expected program to return a value, but it returned void"
+                | head :: _ ->
+                    match head with
+                    | EvalStackValue.Int32 i -> i
+                    | ret -> failwith $"expected program to return an int, but it returned %O{ret}"
+
+            exitCode |> shouldEqual case.ExpectedReturnCode
+        with _ ->
+            for message in messages () do
+                System.Console.Error.WriteLine $"{message}"
+
+            reraise ()
+
+    [<TestCaseSource(nameof unimplemented)>]
+    [<Explicit>]
+    let ``Can evaluate C# files, unimplemented`` (case : EndToEndTestCase) = runTest case
+
+    [<TestCaseSource(nameof cases)>]
+    let ``Can evaluate C# files`` (case : EndToEndTestCase) = runTest case

WoofWare.PawPrint.Test/TestPureCases.fs

@@ -0,0 +1,152 @@
+namespace WoofWare.Pawprint.Test
+
+open System
+open System.Collections.Immutable
+open System.IO
+open FsUnitTyped
+open NUnit.Framework
+open WoofWare.DotnetRuntimeLocator
+open WoofWare.PawPrint
+open WoofWare.PawPrint.ExternImplementations
+open WoofWare.PawPrint.Test
+
+[<TestFixture>]
+[<Parallelizable(ParallelScope.All)>]
+module TestPureCases =
+    let assy = typeof<RunResult>.Assembly
+
+    let unimplemented =
+        [
+            "CrossAssemblyTypes.cs"
+            "OverlappingStructs.cs"
+            "AdvancedStructLayout.cs"
+            "InitializeArray.cs"
+            "Threads.cs"
+            "ComplexTryCatch.cs"
+            "ResizeArray.cs"
+            "LdtokenField.cs"
+            "GenericEdgeCases.cs"
+            "UnsafeAs.cs"
+        ]
+        |> Set.ofList
+
+    let requiresMocks =
+        let empty = MockEnv.make ()
+
+        [
+            "BasicLock.cs",
+            (1,
+             { empty with
+                 System_Threading_Monitor = System_Threading_Monitor.passThru
+             })
+        ]
+        |> Map.ofList
+
+    let customExitCodes =
+        [
+            "NoOp.cs", 1
+            "CustomDelegate.cs", 8
+            "ExceptionWithNoOpFinally.cs", 3
+            "ExceptionWithNoOpCatch.cs", 10
+            "TryCatchWithThrowInBody.cs", 4
+            "ResizeArray.cs", 114
+            "Threads.cs", 3
+            "TriangleNumber.cs", 10
+        ]
+        |> Map.ofList
+
+    let allPure =
+        assy.GetManifestResourceNames ()
+        |> Seq.choose (fun res ->
+            let s = "WoofWare.PawPrint.Test.sourcesPure."
+
+            if res.StartsWith (s, StringComparison.OrdinalIgnoreCase) then
+                res.Substring s.Length |> Some
+            else
+                None
+        )
+        |> Set.ofSeq
+
+    let simpleCases : string list =
+        allPure
+        |> Seq.filter (fun s ->
+            (customExitCodes.ContainsKey s
+             || requiresMocks.ContainsKey s
+             || unimplemented.Contains s)
+            |> not
+        )
+        |> Seq.toList
+
+    let runTest (case : EndToEndTestCase) : unit =
+        let source = Assembly.getEmbeddedResourceAsString case.FileName assy
+        let image = Roslyn.compile [ source ]
+        let messages, loggerFactory = LoggerFactory.makeTest ()
+
+        let dotnetRuntimes =
+            DotnetRuntime.SelectForDll assy.Location |> ImmutableArray.CreateRange
+
+        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 exitCode =
+                match terminalState.ThreadState.[terminatingThread].MethodState.EvaluationStack.Values with
+                | [] -> failwith "expected program to return a value, but it returned void"
+                | head :: _ ->
+                    match head with
+                    | EvalStackValue.Int32 i -> i
+                    | ret -> failwith $"expected program to return an int, but it returned %O{ret}"
+
+            exitCode |> shouldEqual realResult.ExitCode
+
+        with _ ->
+            for message in messages () do
+                System.Console.Error.WriteLine $"{message}"
+
+            reraise ()
+
+    [<TestCaseSource(nameof simpleCases)>]
+    let ``Standard tests`` (fileName : string) =
+        {
+            FileName = fileName
+            ExpectedReturnCode = 0
+            NativeImpls = MockEnv.make ()
+        }
+        |> runTest
+
+    [<TestCaseSource(nameof customExitCodes)>]
+    let ``Custom exit code tests`` (KeyValue (fileName : string, exitCode : int)) =
+        if unimplemented.Contains fileName then
+            Assert.Inconclusive ()
+
+        {
+            FileName = fileName
+            ExpectedReturnCode = exitCode
+            NativeImpls = MockEnv.make ()
+        }
+        |> runTest
+
+    [<TestCaseSource(nameof requiresMocks)>]
+    let ``Tests which require mocks`` (KeyValue (fileName : string, (exitCode : int, mock : NativeImpls))) =
+        {
+            FileName = fileName
+            ExpectedReturnCode = exitCode
+            NativeImpls = mock
+        }
+        |> runTest
+
+
+    [<TestCaseSource(nameof unimplemented)>]
+    [<Explicit>]
+    let ``Can evaluate C# files, unimplemented`` (fileName : string) =
+        {
+            FileName = fileName
+            ExpectedReturnCode = 0
+            NativeImpls = MockEnv.make ()
+        }
+        |> runTest

WoofWare.PawPrint.Test/WoofWare.PawPrint.Test.fsproj

@@ -4,32 +4,20 @@
     <TargetFramework>net9.0</TargetFramework>
     <IsPackable>false</IsPackable>
     <OutputType>Exe</OutputType>
-    <IsTestProject>true</IsTestProject>
-    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
-    <EnableNUnitRunner>true</EnableNUnitRunner>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="LoggerFactory.fs" />
     <Compile Include="Assembly.fs" />
     <Compile Include="Roslyn.fs" />
+    <Compile Include="RealRuntime.fs" />
     <Compile Include="TestHarness.fs"/>
-    <Compile Include="TestCases.fs" />
-    <Compile Include="TestHelloWorld.fs" />
-    <EmbeddedResource Include="sources\BasicLock.cs" />
-    <EmbeddedResource Include="sources\NoOp.cs" />
-    <EmbeddedResource Include="sources\ExceptionWithNoOpCatch.cs" />
-    <EmbeddedResource Include="sources\ExceptionWithNoOpFinally.cs" />
-    <EmbeddedResource Include="sources\TryCatchWithThrowInBody.cs" />
-    <EmbeddedResource Include="sources\ComplexTryCatch.cs" />
-    <EmbeddedResource Include="sources\TriangleNumber.cs" />
-    <EmbeddedResource Include="sources\WriteLine.cs" />
-    <EmbeddedResource Include="sources\InstaQuit.cs" />
-    <EmbeddedResource Include="sources\Threads.cs" />
-    <EmbeddedResource Include="sources\ResizeArray.cs" />
-    <EmbeddedResource Include="sources\ArgumentOrdering.cs" />
-    <EmbeddedResource Include="sources\CustomDelegate.cs" />
-    <EmbeddedResource Include="sources\Ldind.cs" />
+    <Compile Include="TestPureCases.fs" />
+    <Compile Include="TestImpureCases.fs" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="sourcesPure\*.cs" />
+    <EmbeddedResource Include="sourcesImpure\*.cs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -37,14 +25,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="FsUnit" Version="7.0.1"/>
-    <PackageReference Include="NUnit3TestAdapter" Version="5.0.0"/>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0"/>
-    <PackageReference Include="NUnit" Version="4.3.2"/>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0"/>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.2" />
+    <PackageReference Include="NUnit" Version="4.4.0"/>
+    <PackageReference Include="NUnit3TestAdapter" Version="5.1.0"/>
+    <PackageReference Include="FsUnit" Version="7.1.1"/>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0"/>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.6" />
     <PackageReference Include="WoofWare.DotnetRuntimeLocator" Version="0.3.2"/>
   </ItemGroup>
-
 </Project>
 

WoofWare.PawPrint.Test/sources/ArgumentOrdering.cs

@@ -1,19 +0,0 @@
-public class Program
-{
-    public struct TestStruct
-    {
-        public int Value;
-
-        public TestStruct(ref int x)
-        {
-            Value = x;
-        }
-    }
-
-    public static int Main(string[] args)
-    {
-        int localVar = 42;
-        TestStruct t = new TestStruct(ref localVar);
-        return t.Value;
-    }
-}

WoofWare.PawPrint.Test/sourcesPure/AdvancedStructLayout.cs

@@ -0,0 +1,480 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+
+public class StructLayoutTestsAdvanced
+{
+    // Test structs
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct PointerTestStruct
+    {
+        public int A;
+        public byte B;
+        public short C;
+        public int D;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    unsafe struct FixedBufferStruct
+    {
+        public int Header;
+        public fixed byte Buffer[64];
+        public int Footer;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    unsafe struct NestedFixedStruct
+    {
+        public fixed int IntArray[4];
+        public fixed double DoubleArray[2];
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    struct MarshalStringStruct
+    {
+        public int Id;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+        public string Name;
+        public double Value;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct MarshalArrayStruct
+    {
+        public int Count;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
+        public int[] Values;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct BlittableStruct
+    {
+        public int X;
+        public double Y;
+        public long Z;
+    }
+
+    ref struct RefStruct
+    {
+        public int Value;
+        public Span<int> Span;
+
+        public RefStruct(int value)
+        {
+            Value = value;
+            Span = new Span<int>(new int[] { value, value * 2, value * 3 });
+        }
+    }
+
+    readonly struct ReadOnlyStruct
+    {
+        public readonly int X;
+        public readonly int Y;
+
+        public ReadOnlyStruct(int x, int y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        public int Sum => X + Y;
+    }
+
+    readonly ref struct ReadOnlyRefStruct
+    {
+        public readonly int Value;
+        public readonly ReadOnlySpan<byte> Data;
+
+        public ReadOnlyRefStruct(int value, ReadOnlySpan<byte> data)
+        {
+            Value = value;
+            Data = data;
+        }
+    }
+
+    struct Generic<T> where T : struct
+    {
+        public T Value;
+        public int Index;
+
+        public Generic(T value, int index)
+        {
+            Value = value;
+            Index = index;
+        }
+    }
+
+    struct DoubleGeneric<T, U>
+    {
+        public T First;
+        public U Second;
+    }
+
+    interface IIndexable
+    {
+        int GetIndex();
+        void SetIndex(int value);
+    }
+
+    struct StructWithInterface : IIndexable
+    {
+        public int Index;
+        public string Data;
+
+        public int GetIndex() => Index;
+        public void SetIndex(int value) => Index = value;
+    }
+
+    interface IMutable
+    {
+        void Mutate();
+    }
+
+    struct MutableStruct : IMutable
+    {
+        public int Counter;
+
+        public void Mutate()
+        {
+            Counter++;
+        }
+    }
+
+    struct RefReturnStruct
+    {
+        public int A;
+        public int B;
+        public int C;
+
+        public static ref int GetRef(ref RefReturnStruct s, int index)
+        {
+            if (index == 0) return ref s.A;
+            if (index == 1) return ref s.B;
+            return ref s.C;
+        }
+    }
+
+    static unsafe int TestUnsafePointers()
+    {
+        var s = new PointerTestStruct { A = 0x12345678, B = 0xAB, C = 0x1234, D = unchecked((int)0xDEADBEEF) };
+
+        // Test sizeof
+        int size = sizeof(PointerTestStruct);
+        if (size == 0) return 1;
+
+        // Test pointer access
+        PointerTestStruct* ptr = &s;
+        if (ptr->A != 0x12345678) return 2;
+        if (ptr->B != 0xAB) return 3;
+        if (ptr->C != 0x1234) return 4;
+        if (ptr->D != unchecked((int)0xDEADBEEF)) return 5;
+
+        // Test pointer arithmetic and casting
+        byte* bytePtr = (byte*)ptr;
+        int* intPtr = (int*)bytePtr;
+        if (*intPtr != 0x12345678) return 6; // First int field
+
+        // Verify field offsets
+        int* dPtr = &(ptr->D);
+        int* aPtr = &(ptr->A);
+        long ptrDiff = (byte*)dPtr - (byte*)aPtr;
+        if (ptrDiff < 8) return 7; // D should be at least 8 bytes from A
+
+        // Test modification through pointer
+        ptr->A = 999;
+        if (s.A != 999) return 8;
+
+        return 0;
+    }
+
+    static unsafe int TestFixedBuffers()
+    {
+        var f = new FixedBufferStruct();
+        f.Header = 0xFEED;
+        f.Footer = 0xBEEF;
+
+        // Test fixed buffer access
+        for (int i = 0; i < 64; i++)
+        {
+            f.Buffer[i] = (byte)(i % 256);
+        }
+
+        if (f.Header != 0xFEED) return 10;
+        if (f.Footer != 0xBEEF) return 11;
+
+        // Verify buffer contents
+        for (int i = 0; i < 64; i++)
+        {
+            if (f.Buffer[i] != (byte)(i % 256)) return 12;
+        }
+
+        // Test pointer to fixed buffer
+        byte* bufPtr = f.Buffer;
+        bufPtr[0] = 255;
+        if (f.Buffer[0] != 255) return 13;
+
+        // Test nested fixed arrays
+        var n = new NestedFixedStruct();
+        n.IntArray[0] = 100;
+        n.IntArray[3] = 400;
+        n.DoubleArray[0] = 1.5;
+        n.DoubleArray[1] = 2.5;
+
+        if (n.IntArray[0] != 100) return 14;
+        if (n.IntArray[3] != 400) return 15;
+        if (Math.Abs(n.DoubleArray[0] - 1.5) > 0.0001) return 16;
+        if (Math.Abs(n.DoubleArray[1] - 2.5) > 0.0001) return 17;
+
+        return 0;
+    }
+
+    static unsafe int TestMarshaling()
+    {
+        // Test string marshaling
+        var ms = new MarshalStringStruct
+        {
+            Id = 42,
+            Name = "TestString",
+            Value = 3.14159
+        };
+
+        if (ms.Id != 42) return 20;
+        if (ms.Name != "TestString") return 21;
+        if (Math.Abs(ms.Value - 3.14159) > 0.00001) return 22;
+
+        // Test Marshal.SizeOf
+        int marshalSize = Marshal.SizeOf(typeof(MarshalStringStruct));
+        if (marshalSize == 0) return 23;
+
+        // Test array marshaling
+        var ma = new MarshalArrayStruct
+        {
+            Count = 5,
+            Values = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }
+        };
+
+        if (ma.Count != 5) return 24;
+        if (ma.Values.Length != 8) return 25;
+        if (ma.Values[7] != 8) return 26;
+
+        // Test StructureToPtr and PtrToStructure
+        var blittable = new BlittableStruct { X = 100, Y = 200.5, Z = 300 };
+        IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BlittableStruct)));
+        try
+        {
+            Marshal.StructureToPtr(blittable, ptr, false);
+            var recovered = (BlittableStruct)Marshal.PtrToStructure(ptr, typeof(BlittableStruct));
+
+            if (recovered.X != 100) return 27;
+            if (Math.Abs(recovered.Y - 200.5) > 0.00001) return 28;
+            if (recovered.Z != 300) return 29;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(ptr);
+        }
+
+        return 0;
+    }
+
+    static int TestRefStructs()
+    {
+        // Test ref struct
+        var rs = new RefStruct(10);
+        if (rs.Value != 10) return 30;
+        if (rs.Span.Length != 3) return 31;
+        if (rs.Span[0] != 10) return 32;
+        if (rs.Span[1] != 20) return 33;
+        if (rs.Span[2] != 30) return 34;
+
+        // Modify through span
+        rs.Span[0] = 100;
+        if (rs.Span[0] != 100) return 35;
+
+        // Test readonly struct
+        var ros = new ReadOnlyStruct(5, 7);
+        if (ros.X != 5) return 36;
+        if (ros.Y != 7) return 37;
+        if (ros.Sum != 12) return 38;
+
+        // Verify immutability - create new instance
+        var ros2 = new ReadOnlyStruct(10, 20);
+        if (ros.X != 5) return 39; // Original should be unchanged
+
+        // Test readonly ref struct
+        byte[] data = { 1, 2, 3, 4 };
+        var rors = new ReadOnlyRefStruct(42, new ReadOnlySpan<byte>(data));
+        if (rors.Value != 42) return 40;
+        if (rors.Data.Length != 4) return 41;
+        if (rors.Data[3] != 4) return 42;
+
+        return 0;
+    }
+
+    static int TestGenerics()
+    {
+        // Test single generic parameter
+        var g1 = new Generic<int>(42, 1);
+        if (g1.Value != 42) return 50;
+        if (g1.Index != 1) return 51;
+
+        var g2 = new Generic<double>(3.14, 2);
+        if (Math.Abs(g2.Value - 3.14) > 0.00001) return 52;
+        if (g2.Index != 2) return 53;
+
+        // Test with custom struct
+        var inner = new ReadOnlyStruct(10, 20);
+        var g3 = new Generic<ReadOnlyStruct>(inner, 3);
+        if (g3.Value.X != 10) return 54;
+        if (g3.Value.Y != 20) return 55;
+        if (g3.Index != 3) return 56;
+
+        // Test double generic
+        var dg = new DoubleGeneric<int, string> { First = 100, Second = "test" };
+        if (dg.First != 100) return 57;
+        if (dg.Second != "test") return 58;
+
+        // Test with different type combinations
+        var dg2 = new DoubleGeneric<double, long> { First = 2.718, Second = long.MaxValue };
+        if (Math.Abs(dg2.First - 2.718) > 0.00001) return 59;
+        if (dg2.Second != long.MaxValue) return 60;
+
+        return 0;
+    }
+
+    static int TestByRefReturns()
+    {
+        var r = new RefReturnStruct { A = 10, B = 20, C = 30 };
+
+        // Test ref return
+        ref int refA = ref RefReturnStruct.GetRef(ref r, 0);
+        if (refA != 10) return 70;
+
+        // Modify through ref
+        refA = 100;
+        if (r.A != 100) return 71;
+
+        ref int refB = ref RefReturnStruct.GetRef(ref r, 1);
+        refB = 200;
+        if (r.B != 200) return 72;
+
+        ref int refC = ref RefReturnStruct.GetRef(ref r, 2);
+        refC = 300;
+        if (r.C != 300) return 73;
+
+        // Test ref local
+        ref int localRef = ref r.A;
+        localRef = 1000;
+        if (r.A != 1000) return 74;
+
+        // Test that ref points to actual field
+        localRef = 2000;
+        if (refA != 2000) return 75; // Both should see the change
+
+        return 0;
+    }
+
+    static int TestStructInterfaces()
+    {
+        // Test struct implementing interface
+        var s = new StructWithInterface { Index = 42, Data = "test" };
+        if (s.GetIndex() != 42) return 80;
+
+        s.SetIndex(100);
+        if (s.Index != 100) return 81;
+
+        // Test boxing to interface
+        IIndexable boxed = s; // Boxing occurs here
+        if (boxed.GetIndex() != 100) return 82;
+
+        // Modify through interface (modifies boxed copy)
+        boxed.SetIndex(200);
+        if (boxed.GetIndex() != 200) return 83;
+        if (s.Index != 100) return 84; // Original should be unchanged
+
+        // Test mutable interface
+        var m = new MutableStruct { Counter = 0 };
+        m.Mutate();
+        if (m.Counter != 1) return 85;
+
+        // Box to interface and mutate
+        IMutable boxedMutable = m; // Boxing
+        boxedMutable.Mutate();
+        if (m.Counter != 1) return 86; // Original unchanged
+
+        // Cast back to see boxed mutation
+        var unboxed = (MutableStruct)boxedMutable;
+        if (unboxed.Counter != 2) return 87;
+
+        // Direct interface call on boxed struct maintains state
+        boxedMutable.Mutate();
+        boxedMutable.Mutate();
+        var unboxed2 = (MutableStruct)boxedMutable;
+        if (unboxed2.Counter != 4) return 88;
+
+        return 0;
+    }
+
+    static unsafe int TestCombinedScenarios()
+    {
+        // Test generic with fixed buffer struct
+        var f = new FixedBufferStruct();
+        f.Header = 999;
+        f.Buffer[0] = 123;
+        f.Footer = 111;
+
+        var generic = new Generic<FixedBufferStruct>(f, 42);
+        if (generic.Value.Header != 999) return 90;
+        if (generic.Value.Buffer[0] != 123) return 91;
+        if (generic.Value.Footer != 111) return 92;
+        if (generic.Index != 42) return 93;
+
+        // Test marshaling with generic
+        var marshalable = new BlittableStruct { X = 10, Y = 20.0, Z = 30 };
+        var genericMarshal = new Generic<BlittableStruct>(marshalable, 5);
+
+        if (genericMarshal.Value.X != 10) return 94;
+        if (Math.Abs(genericMarshal.Value.Y - 20.0) > 0.00001) return 95;
+        if (genericMarshal.Value.Z != 30) return 96;
+
+        return 0;
+    }
+
+    public static int Main(string[] argv)
+    {
+        int result = 0;
+
+        unsafe
+        {
+            result = TestUnsafePointers();
+            if (result != 0) return result;
+
+            result = TestFixedBuffers();
+            if (result != 0) return result;
+        }
+
+        result = TestMarshaling();
+        if (result != 0) return result;
+
+        result = TestRefStructs();
+        if (result != 0) return result;
+
+        result = TestGenerics();
+        if (result != 0) return result;
+
+        result = TestByRefReturns();
+        if (result != 0) return result;
+
+        result = TestStructInterfaces();
+        if (result != 0) return result;
+
+        unsafe
+        {
+            result = TestCombinedScenarios();
+            if (result != 0) return result;
+        }
+
+        return 0; // All tests passed
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/ArgumentOrdering.cs

@@ -0,0 +1,49 @@
+public class Program
+{
+    public struct TestStruct
+    {
+        public int Value;
+
+        public TestStruct(ref int x)
+        {
+            Value = x;
+        }
+    }
+
+    public struct Calculator
+    {
+        private int baseValue;
+
+        public Calculator(int initial)
+        {
+            baseValue = initial;
+        }
+
+        public int Add(int a, int b, int c)
+        {
+            return baseValue + a + b + c;
+        }
+
+        public int SubtractIsh(int a, int b)
+        {
+            return baseValue - a + b;
+        }
+    }
+
+    public static int Main(string[] args)
+    {
+        int localVar = 42;
+        TestStruct t = new TestStruct(ref localVar);
+        if (t.Value != 42) return 1;
+
+        Calculator calc = new Calculator(10);
+        int addResult = calc.Add(1, 2, 3);  // Should be 10 + 1 + 2 + 3 = 16
+        if (addResult != 16) return 2;
+
+        // Test 2: Verify order matters
+        int subResult = calc.SubtractIsh(3, 2);  // Should be 10 - 3 + 2 = 9
+        if (subResult != 9) return 3;
+
+        return 0;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/CrossAssemblyTypes.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.Collections;
+
+// Test cross-assembly type resolution using standard library types
+public class CrossAssemblyTypeTest
+{
+    public static int TestSystemTypes()
+    {
+        // Test various System types to ensure proper assembly resolution
+        
+        // System.DateTime
+        var date = new DateTime(2023, 1, 1);
+        if (date.Year != 2023) return 1;
+        
+        // System.Guid
+        var guid = Guid.Empty;
+        if (guid != Guid.Empty) return 2;
+        
+        // System.TimeSpan
+        var timeSpan = TimeSpan.FromMinutes(30);
+        if (timeSpan.TotalMinutes != 30) return 3;
+        
+        return 0;
+    }
+    
+    public static int TestCollectionTypes()
+    {
+        // Test various collection types from different assemblies
+        
+        // Dictionary<TKey, TValue>
+        var dict = new Dictionary<string, int>();
+        dict["test"] = 42;
+        if (dict["test"] != 42) return 1;
+        
+        // HashSet<T>
+        var hashSet = new HashSet<int>();
+        hashSet.Add(1);
+        hashSet.Add(2);
+        hashSet.Add(1); // duplicate
+        if (hashSet.Count != 2) return 2;
+        
+        // Queue<T>
+        var queue = new Queue<string>();
+        queue.Enqueue("first");
+        queue.Enqueue("second");
+        if (queue.Dequeue() != "first") return 3;
+        
+        return 0;
+    }
+    
+    public static int TestGenericInterfaces()
+    {
+        // Test generic interfaces across assemblies
+        
+        var list = new List<int> { 1, 2, 3 };
+        
+        // IEnumerable<T>
+        IEnumerable<int> enumerable = list;
+        int count = 0;
+        foreach (int item in enumerable)
+        {
+            count++;
+        }
+        if (count != 3) return 1;
+        
+        // ICollection<T>
+        ICollection<int> collection = list;
+        if (collection.Count != 3) return 2;
+        
+        // IList<T>
+        IList<int> ilist = list;
+        if (ilist[0] != 1) return 3;
+        
+        return 0;
+    }
+}
+
+// Test Array.Empty<T> which was mentioned in the diff as a specific case
+public class ArrayEmptyTest
+{
+    public static int TestArrayEmpty()
+    {
+        // Test Array.Empty<T> for different types
+        var emptyInts = Array.Empty<int>();
+        var emptyStrings = Array.Empty<string>();
+        
+        if (emptyInts.Length != 0) return 1;
+        if (emptyStrings.Length != 0) return 2;
+        
+        // Verify they are different instances for different types
+        // but same instance for same type
+        var emptyInts2 = Array.Empty<int>();
+        if (!ReferenceEquals(emptyInts, emptyInts2)) return 3;
+        
+        return 0;
+    }
+}
+
+class Program
+{
+    static int Main(string[] args)
+    {
+        int result;
+        
+        result = CrossAssemblyTypeTest.TestSystemTypes();
+        if (result != 0) return 100 + result;
+        
+        result = CrossAssemblyTypeTest.TestCollectionTypes();
+        if (result != 0) return 200 + result;
+        
+        result = CrossAssemblyTypeTest.TestGenericInterfaces();
+        if (result != 0) return 300 + result;
+        
+        result = ArrayEmptyTest.TestArrayEmpty();
+        if (result != 0) return 400 + result;
+        
+        return 0; // All tests passed
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/Floats.cs

@@ -0,0 +1,216 @@
+// Thanks Gemini 2.5 Pro
+
+using System;
+
+public class Program
+{
+    /// <summary>
+    /// Main entry point for the test harness. It runs test suites for float and double comparisons.
+    /// </summary>
+    /// <returns>0 if all tests pass, otherwise a non-zero error code indicating the first failed test.</returns>
+    public static int Main(string[] args)
+    {
+        int result;
+
+        result = FloatCompareTests.RunTests();
+        if (result != 0)
+        {
+            return result;
+        }
+
+        result = DoubleCompareTests.RunTests();
+        if (result != 0)
+        {
+            return result;
+        }
+
+        return 0; // Success
+    }
+}
+
+/// <summary>
+/// Contains a suite of tests for System.Single (float) comparisons.
+/// Each test corresponds to a specific CIL comparison instruction.
+/// </summary>
+public class FloatCompareTests
+{
+    private static int testCounter = 100; // Start error codes at 100 for this suite
+
+    /// <summary>
+    /// Checks a boolean condition. If the condition is false, it prints a failure message
+    /// and returns a unique error code.
+    /// </summary>
+    /// <param name="condition">The boolean result of the test.</param>
+    /// <param name="testName">A descriptive name for the test case.</param>
+    /// <returns>0 if the test passes, otherwise a unique non-zero error code.</returns>
+    private static int Check(bool condition, string testName)
+    {
+        testCounter++;
+        if (!condition)
+        {
+            return testCounter;
+        }
+        return 0;
+    }
+
+    /// <summary>
+    /// Runs all float comparison tests.
+    /// </summary>
+    /// <returns>0 if all tests pass, otherwise the error code of the first failing test.</returns>
+    public static int RunTests()
+    {
+        float pz = 0.0f;
+        float nz = -0.0f;
+        float one = 1.0f;
+        float negOne = -1.0f;
+        float two = 2.0f;
+        float pInf = float.PositiveInfinity;
+        float nInf = float.NegativeInfinity;
+        float nan = float.NaN;
+        float subnormal = BitConverter.ToSingle(new byte[] { 1, 0, 0, 0 }, 0); // Smallest positive subnormal
+
+        int result;
+
+        // --- Ceq Tests (==) ---
+        result = Check(one == one, "1.0f == 1.0f"); if (result != 0) return result;
+        result = Check(!(one == two), "!(1.0f == 2.0f)"); if (result != 0) return result;
+        result = Check(pz == nz, "0.0f == -0.0f"); if (result != 0) return result;
+        result = Check(pInf == pInf, "+Inf == +Inf"); if (result != 0) return result;
+        result = Check(nInf == nInf, "-Inf == -Inf"); if (result != 0) return result;
+        result = Check(!(pInf == nInf), "!(+Inf == -Inf)"); if (result != 0) return result;
+        result = Check(!(nan == nan), "!(NaN == NaN)"); if (result != 0) return result;
+        result = Check(!(nan == one), "!(NaN == 1.0f)"); if (result != 0) return result;
+        result = Check(!(one == nan), "!(1.0f == NaN)"); if (result != 0) return result;
+
+        // --- Cgt Tests (>) ---
+        result = Check(two > one, "2.0f > 1.0f"); if (result != 0) return result;
+        result = Check(!(one > two), "!(1.0f > 2.0f)"); if (result != 0) return result;
+        result = Check(!(one > one), "!(1.0f > 1.0f)"); if (result != 0) return result;
+        result = Check(pInf > one, "+Inf > 1.0f"); if (result != 0) return result;
+        result = Check(!(nInf > one), "!( -Inf > 1.0f)"); if (result != 0) return result;
+        result = Check(pInf > nInf, "+Inf > -Inf"); if (result != 0) return result;
+        result = Check(!(nan > one), "!(NaN > 1.0f)"); if (result != 0) return result;
+        result = Check(!(one > nan), "!(1.0f > NaN)"); if (result != 0) return result;
+        result = Check(one > subnormal, "1.0f > subnormal"); if (result != 0) return result;
+
+        // --- Cgt.un Tests (unordered >) ---
+        // cgt.un is equivalent to !(a <= b) for floats
+        result = Check(!(two <= one), "cgt.un: 2.0f > 1.0f"); if (result != 0) return result;
+        result = Check(one > pz, "cgt.un: 1.0f > 0.0f"); if (result != 0) return result;
+        result = Check(!(nan <= one), "cgt.un: NaN > 1.0f"); if (result != 0) return result;
+        result = Check(!(one <= nan), "cgt.un: 1.0f > NaN"); if (result != 0) return result;
+        result = Check(!(nan <= nan), "cgt.un: NaN > NaN"); if (result != 0) return result;
+
+
+        // --- Clt Tests (<) ---
+        result = Check(one < two, "1.0f < 2.0f"); if (result != 0) return result;
+        result = Check(!(two < one), "!(2.0f < 1.0f)"); if (result != 0) return result;
+        result = Check(!(one < one), "!(1.0f < 1.0f)"); if (result != 0) return result;
+        result = Check(one < pInf, "1.0f < +Inf"); if (result != 0) return result;
+        result = Check(nInf < one, "-Inf < 1.0f"); if (result != 0) return result;
+        result = Check(nInf < pInf, "-Inf < +Inf"); if (result != 0) return result;
+        result = Check(!(nan < one), "!(NaN < 1.0f)"); if (result != 0) return result;
+        result = Check(!(one < nan), "!(1.0f < NaN)"); if (result != 0) return result;
+        result = Check(subnormal < one, "subnormal < 1.0f"); if (result != 0) return result;
+
+        // --- Clt.un Tests (unordered <) ---
+        // clt.un is equivalent to !(a >= b) for floats
+        result = Check(one < two, "clt.un: 1.0f < 2.0f"); if (result != 0) return result;
+        result = Check(!(one >= nan), "clt.un: 1.0f < NaN"); if (result != 0) return result;
+        result = Check(!(nan >= one), "clt.un: NaN < 1.0f"); if (result != 0) return result;
+        result = Check(!(nan >= nan), "clt.un: NaN < NaN"); if (result != 0) return result;
+
+        // --- C# >= (bge) and <= (ble) ---
+        result = Check(one >= one, "1.0f >= 1.0f"); if (result != 0) return result;
+        result = Check(two >= one, "2.0f >= 1.0f"); if (result != 0) return result;
+        result = Check(!(nan >= one), "!(NaN >= 1.0f)"); if (result != 0) return result;
+        result = Check(one <= one, "1.0f <= 1.0f"); if (result != 0) return result;
+        result = Check(one <= two, "1.0f <= 2.0f"); if (result != 0) return result;
+        result = Check(!(nan <= one), "!(NaN <= 1.0f)"); if (result != 0) return result;
+        result = Check(pz >= nz, "0.0f >= -0.0f"); if (result != 0) return result;
+        result = Check(pz <= nz, "0.0f <= -0.0f"); if (result != 0) return result;
+
+        return 0; // Success
+    }
+}
+
+/// <summary>
+/// Contains a suite of tests for System.Double comparisons.
+/// </summary>
+public class DoubleCompareTests
+{
+    private static int testCounter = 200; // Start error codes at 200 for this suite
+
+    private static int Check(bool condition, string testName)
+    {
+        testCounter++;
+        if (!condition)
+        {
+            return testCounter;
+        }
+        return 0;
+    }
+
+    public static int RunTests()
+    {
+        double pz = 0.0;
+        double nz = -0.0;
+        double one = 1.0;
+        double negOne = -1.0;
+        double two = 2.0;
+        double pInf = double.PositiveInfinity;
+        double nInf = double.NegativeInfinity;
+        double nan = double.NaN;
+        double subnormal = BitConverter.Int64BitsToDouble(1); // Smallest positive subnormal
+
+        int result;
+
+        // --- Ceq Tests (==) ---
+        result = Check(one == one, "1.0 == 1.0"); if (result != 0) return result;
+        result = Check(!(one == two), "!(1.0 == 2.0)"); if (result != 0) return result;
+        result = Check(pz == nz, "0.0 == -0.0"); if (result != 0) return result;
+        result = Check(pInf == pInf, "+Inf == +Inf"); if (result != 0) return result;
+        result = Check(nInf == nInf, "-Inf == -Inf"); if (result != 0) return result;
+        result = Check(!(pInf == nInf), "!(+Inf == -Inf)"); if (result != 0) return result;
+        result = Check(!(nan == nan), "!(NaN == NaN)"); if (result != 0) return result;
+
+        // --- Cgt Tests (>) ---
+        result = Check(two > one, "2.0 > 1.0"); if (result != 0) return result;
+        result = Check(!(one > one), "!(1.0 > 1.0)"); if (result != 0) return result;
+        result = Check(pInf > one, "+Inf > 1.0"); if (result != 0) return result;
+        result = Check(!(nInf > one), "!(-Inf > 1.0)"); if (result != 0) return result;
+        result = Check(pInf > nInf, "+Inf > -Inf"); if (result != 0) return result;
+        result = Check(!(nan > one), "!(NaN > 1.0)"); if (result != 0) return result;
+        result = Check(one > subnormal, "1.0 > subnormal"); if (result != 0) return result;
+
+        // --- Cgt.un Tests (unordered >) ---
+        result = Check(one > pz, "cgt.un: 1.0 > 0.0"); if (result != 0) return result;
+        result = Check(!(nan <= one), "cgt.un: NaN > 1.0"); if (result != 0) return result;
+        result = Check(!(one <= nan), "cgt.un: 1.0 > NaN"); if (result != 0) return result;
+
+        // --- Clt Tests (<) ---
+        result = Check(one < two, "1.0 < 2.0"); if (result != 0) return result;
+        result = Check(!(one < one), "!(1.0 < 1.0)"); if (result != 0) return result;
+        result = Check(nInf < one, "-Inf < 1.0"); if (result != 0) return result;
+        result = Check(!(pInf < one), "!(+Inf < 1.0)"); if (result != 0) return result;
+        result = Check(nInf < pInf, "-Inf < +Inf"); if (result != 0) return result;
+        result = Check(!(nan < one), "!(NaN < 1.0)"); if (result != 0) return result;
+        result = Check(subnormal < one, "subnormal < 1.0"); if (result != 0) return result;
+
+        // --- Clt.un Tests (unordered <) ---
+        result = Check(one < two, "clt.un: 1.0 < 2.0"); if (result != 0) return result;
+        result = Check(!(one >= nan), "clt.un: 1.0 < NaN"); if (result != 0) return result;
+        result = Check(!(nan >= one), "clt.un: NaN < 1.0"); if (result != 0) return result;
+
+        // --- C# >= (bge) and <= (ble) ---
+        result = Check(one >= one, "1.0 >= 1.0"); if (result != 0) return result;
+        result = Check(two >= one, "2.0 >= 1.0"); if (result != 0) return result;
+        result = Check(!(nan >= one), "!(NaN >= 1.0)"); if (result != 0) return result;
+        result = Check(one <= one, "1.0 <= 1.0"); if (result != 0) return result;
+        result = Check(one <= two, "1.0 <= 2.0"); if (result != 0) return result;
+        result = Check(!(nan <= one), "!(NaN <= 1.0)"); if (result != 0) return result;
+        result = Check(pz >= nz, "0.0 >= -0.0"); if (result != 0) return result;
+
+        return 0; // Success
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/GenericEdgeCases.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+
+// Test edge cases with generic parameters as mentioned in the diff
+public class GenericParameterEdgeCases
+{
+    // Test method with multiple generic parameters
+    public static T2 Convert<T1, T2>(T1 input, Func<T1, T2> converter)
+    {
+        return converter(input);
+    }
+    
+    // Test nested generic method calls
+    public static List<T> WrapInList<T>(T item)
+    {
+        var list = new List<T>();
+        list.Add(item);
+        return list;
+    }
+    
+    public static int TestMultipleGenericParameters()
+    {
+        // Test Convert method with different type combinations
+        string result1 = Convert<int, string>(42, x => x.ToString());
+        if (result1 != "42") return 1;
+        
+        int result2 = Convert<string, int>("123", x => int.Parse(x));
+        if (result2 != 123) return 2;
+        
+        return 0;
+    }
+    
+    public static int TestNestedGenericMethodCalls()
+    {
+        // Test calling generic method from within another generic method
+        var intList = WrapInList<int>(42);
+        if (intList.Count != 1) return 1;
+        if (intList[0] != 42) return 2;
+        
+        var stringList = WrapInList<string>("test");
+        if (stringList.Count != 1) return 3;
+        if (stringList[0] != "test") return 4;
+        
+        return 0;
+    }
+}
+
+// Test deeply nested generic types
+public class DeepNestingTest
+{
+    public static int TestDeeplyNestedGenerics()
+    {
+        // Test Dictionary<string, List<Dictionary<int, string>>>
+        var complexType = new Dictionary<string, List<Dictionary<int, string>>>();
+        
+        var innerDict = new Dictionary<int, string>();
+        innerDict[1] = "one";
+        innerDict[2] = "two";
+        
+        var listOfDicts = new List<Dictionary<int, string>>();
+        listOfDicts.Add(innerDict);
+        
+        complexType["test"] = listOfDicts;
+        
+        if (complexType["test"].Count != 1) return 1;
+        if (complexType["test"][0][1] != "one") return 2;
+        if (complexType["test"][0][2] != "two") return 3;
+        
+        return 0;
+    }
+}
+
+// Test generic constraints and inheritance scenarios
+public class GenericConstraintTest<T> where T : class
+{
+    private T value;
+    
+    public GenericConstraintTest(T val)
+    {
+        value = val;
+    }
+    
+    public bool IsNull()
+    {
+        return value == null;
+    }
+    
+    public static int TestGenericConstraints()
+    {
+        var test = new GenericConstraintTest<string>("hello");
+        if (test.IsNull()) return 1;
+        
+        var nullTest = new GenericConstraintTest<string>(null);
+        if (!nullTest.IsNull()) return 2;
+        
+        return 0;
+    }
+}
+
+// Test generic field access scenarios mentioned in the diff
+public class GenericFieldAccess<T>
+{
+    public static T DefaultValue = default(T);
+    
+    public static int TestStaticGenericField()
+    {
+        // Test that static fields work correctly with generics
+        if (GenericFieldAccess<int>.DefaultValue != 0) return 1;
+        
+        // Test that different instantiations have different static fields
+        GenericFieldAccess<int>.DefaultValue = 42;
+        if (GenericFieldAccess<int>.DefaultValue != 42) return 2;
+        if (GenericFieldAccess<string>.DefaultValue != null) return 3;
+        
+        return 0;
+    }
+}
+
+class Program
+{
+    static int Main(string[] args)
+    {
+        int result;
+        
+        result = GenericParameterEdgeCases.TestMultipleGenericParameters();
+        if (result != 0) return 100 + result;
+        
+        result = GenericParameterEdgeCases.TestNestedGenericMethodCalls();
+        if (result != 0) return 200 + result;
+        
+        result = DeepNestingTest.TestDeeplyNestedGenerics();
+        if (result != 0) return 300 + result;
+        
+        result = GenericConstraintTest<string>.TestGenericConstraints();
+        if (result != 0) return 400 + result;
+        
+        result = GenericFieldAccess<int>.TestStaticGenericField();
+        if (result != 0) return 500 + result;
+        
+        return 0; // All tests passed
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/InitializeArray.cs

@@ -0,0 +1,19 @@
+using System.Linq;
+
+namespace HelloWorldApp
+{
+    class Program
+    {
+        static int Main(string[] args)
+        {
+            int[] array = new[] { 1, 2, 3 };
+
+            if (array.Sum() != 6)
+            {
+                return 1;
+            }
+
+            return 0;
+        }
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/Initobj.cs

@@ -0,0 +1,503 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+public class TestInitobj
+{
+    // Simple struct with various primitive types
+    private struct SimpleStruct
+    {
+        public int IntField;
+        public bool BoolField;
+        public char CharField;
+        public double DoubleField;
+        public byte ByteField;
+    }
+
+    // Nested struct
+    private struct NestedStruct
+    {
+        public SimpleStruct Inner;
+        public int OuterField;
+    }
+
+    // Struct with arrays and references
+    private struct ComplexStruct
+    {
+        public object ObjectRef;
+        public string StringRef;
+        public int[] ArrayRef;
+        public int ValueField;
+    }
+
+    // Generic struct
+    private struct GenericStruct<T>
+    {
+        public T Value;
+        public int Count;
+    }
+
+    // Struct for field tests
+    private struct StructWithStructField
+    {
+        public SimpleStruct NestedField;
+        public int OtherField;
+    }
+
+    // Class with struct field for heap test
+    private class ClassWithStructField
+    {
+        public SimpleStruct StructField;
+        public int IntField;
+    }
+
+    // Test 1: Initialize simple struct with local variable
+    public static int Test1()
+    {
+        SimpleStruct s = new SimpleStruct
+        {
+            IntField = 42,
+            BoolField = true,
+            CharField = 'X',
+            DoubleField = 3.14,
+            ByteField = 255
+        };
+
+        // Verify initial values
+        if (s.IntField != 42) return 1;
+        if (s.BoolField != true) return 2;
+        if (s.CharField != 'X') return 3;
+        if (s.DoubleField != 3.14) return 4;
+        if (s.ByteField != 255) return 5;
+
+        // Use default to reset the struct (generates initobj)
+        s = default(SimpleStruct);
+
+        // Verify all fields are zeroed
+        if (s.IntField != 0) return 6;
+        if (s.BoolField != false) return 7;
+        if (s.CharField != '\0') return 8;
+        if (s.DoubleField != 0.0) return 9;
+        if (s.ByteField != 0) return 10;
+
+        return 0;
+    }
+
+    // Test 2: Initialize nested struct
+    public static int Test2()
+    {
+        NestedStruct n = new NestedStruct
+        {
+            Inner = new SimpleStruct
+            {
+                IntField = 100,
+                BoolField = true,
+                CharField = 'A',
+                DoubleField = 1.23,
+                ByteField = 128
+            },
+            OuterField = 999
+        };
+
+        // Verify initial values
+        if (n.Inner.IntField != 100) return 20;
+        if (n.OuterField != 999) return 21;
+
+        // Reset using default keyword (which should generate initobj)
+        n = default(NestedStruct);
+
+        // Verify all fields are zeroed
+        if (n.Inner.IntField != 0) return 22;
+        if (n.Inner.BoolField != false) return 23;
+        if (n.Inner.CharField != '\0') return 24;
+        if (n.Inner.DoubleField != 0.0) return 25;
+        if (n.Inner.ByteField != 0) return 26;
+        if (n.OuterField != 0) return 27;
+
+        return 0;
+    }
+
+    // Test 3: Initialize struct with reference types
+    public static int Test3()
+    {
+        ComplexStruct c = new ComplexStruct
+        {
+            ObjectRef = new object(),
+            StringRef = "Hello",
+            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;
+        if (c.StringRef != "Hello") return 31;
+        if (c.ArrayRef == null || c.ArrayRef.Length != 3) return 32;
+        if (c.ValueField != 42) return 33;
+
+        // Reset using default
+        c = default(ComplexStruct);
+
+        // Verify references are null and value is zero
+        if (c.ObjectRef != null) return 34;
+        if (c.StringRef != null) return 35;
+        if (c.ArrayRef != null) return 36;
+        if (c.ValueField != 0) return 37;
+
+        return 0;
+    }
+
+    // Test 4: Initialize generic struct
+    public static int Test4()
+    {
+        GenericStruct<int> gi = new GenericStruct<int>
+        {
+            Value = 123,
+            Count = 456
+        };
+
+        if (gi.Value != 123) return 40;
+        if (gi.Count != 456) return 41;
+
+        gi = default(GenericStruct<int>);
+
+        if (gi.Value != 0) return 42;
+        if (gi.Count != 0) return 43;
+
+        // Test with reference type
+        GenericStruct<string> gs = new GenericStruct<string>
+        {
+            Value = "Test",
+            Count = 789
+        };
+
+        if (gs.Value != "Test") return 44;
+        if (gs.Count != 789) return 45;
+
+        gs = default(GenericStruct<string>);
+
+        if (gs.Value != null) return 46;
+        if (gs.Count != 0) return 47;
+
+        return 0;
+    }
+
+    // Test 5: Initialize struct in array element using ref
+    public static int Test5()
+    {
+        SimpleStruct[] array = new SimpleStruct[3];
+
+        // Set values in first element
+        array[0].IntField = 111;
+        array[0].BoolField = true;
+        array[0].CharField = 'Z';
+
+        if (array[0].IntField != 111) return 50;
+        if (array[0].BoolField != true) return 51;
+        if (array[0].CharField != 'Z') return 52;
+
+        // Reset first element using default assignment
+        array[0] = default(SimpleStruct);
+
+        if (array[0].IntField != 0) return 53;
+        if (array[0].BoolField != false) return 54;
+        if (array[0].CharField != '\0') return 55;
+
+        // Also test with ref local
+        array[1].IntField = 222;
+        ref SimpleStruct secondElement = ref array[1];
+        secondElement = default(SimpleStruct);
+
+        if (array[1].IntField != 0) return 56;
+
+        return 0;
+    }
+
+    // Test 6: Initialize struct through method parameter
+    public static int Test6()
+    {
+        SimpleStruct s = new SimpleStruct
+        {
+            IntField = 200,
+            BoolField = true,
+            CharField = 'M',
+            DoubleField = 2.71,
+            ByteField = 64
+        };
+
+        ResetStruct(ref s);
+
+        if (s.IntField != 0) return 60;
+        if (s.BoolField != false) return 61;
+        if (s.CharField != '\0') return 62;
+        if (s.DoubleField != 0.0) return 63;
+        if (s.ByteField != 0) return 64;
+
+        return 0;
+    }
+
+    private static void ResetStruct(ref SimpleStruct s)
+    {
+        s = default(SimpleStruct);
+    }
+
+    // Test 7: Initialize multiple structs
+    public static int Test7()
+    {
+        SimpleStruct s1 = new SimpleStruct { IntField = 1 };
+        SimpleStruct s2 = new SimpleStruct { IntField = 2 };
+        SimpleStruct s3 = new SimpleStruct { IntField = 3 };
+
+        if (s1.IntField != 1) return 70;
+        if (s2.IntField != 2) return 71;
+        if (s3.IntField != 3) return 72;
+
+        s1 = default(SimpleStruct);
+        s2 = default(SimpleStruct);
+        s3 = default(SimpleStruct);
+
+        if (s1.IntField != 0) return 73;
+        if (s2.IntField != 0) return 74;
+        if (s3.IntField != 0) return 75;
+
+        return 0;
+    }
+
+    // Test 8: Initialize struct passed as argument (tests Argument case)
+    public static int Test8()
+    {
+        SimpleStruct s = new SimpleStruct
+        {
+            IntField = 333,
+            BoolField = true,
+            CharField = 'Q',
+            DoubleField = 4.56,
+            ByteField = 77
+        };
+
+        int result = InitializeArgumentStruct(ref s);
+        if (result != 0) return result;
+
+        // Verify struct was reset
+        if (s.IntField != 0) return 80;
+        if (s.BoolField != false) return 81;
+        if (s.CharField != '\0') return 82;
+        if (s.DoubleField != 0.0) return 83;
+        if (s.ByteField != 0) return 84;
+
+        return 0;
+    }
+
+    private static int InitializeArgumentStruct(ref SimpleStruct arg)
+    {
+        // Verify initial values
+        if (arg.IntField != 333) return 85;
+        if (arg.BoolField != true) return 86;
+
+        // Reset using default - this should use initobj on the argument
+        arg = default(SimpleStruct);
+
+        return 0;
+    }
+
+    // Test 9: Initialize struct field (tests Field case)
+    public static int Test9()
+    {
+        StructWithStructField container = new StructWithStructField
+        {
+            NestedField = new SimpleStruct
+            {
+                IntField = 444,
+                BoolField = true,
+                CharField = 'F',
+                DoubleField = 7.89,
+                ByteField = 88
+            },
+            OtherField = 555
+        };
+
+        // Verify initial values
+        if (container.NestedField.IntField != 444) return 90;
+        if (container.OtherField != 555) return 91;
+
+        // Reset the nested field using ref
+        ref SimpleStruct fieldRef = ref container.NestedField;
+        fieldRef = default(SimpleStruct);
+
+        // Verify nested field was reset but other field unchanged
+        if (container.NestedField.IntField != 0) return 92;
+        if (container.NestedField.BoolField != false) return 93;
+        if (container.NestedField.CharField != '\0') return 94;
+        if (container.NestedField.DoubleField != 0.0) return 95;
+        if (container.NestedField.ByteField != 0) return 96;
+        if (container.OtherField != 555) return 97;
+
+        return 0;
+    }
+
+    // Test 10: Initialize struct in heap-allocated object (tests Heap case)
+    public static int Test10()
+    {
+        ClassWithStructField obj = new ClassWithStructField
+        {
+            StructField = new SimpleStruct
+            {
+                IntField = 666,
+                BoolField = true,
+                CharField = 'H',
+                DoubleField = 9.99,
+                ByteField = 99
+            },
+            IntField = 777
+        };
+
+        // Verify initial values
+        if (obj.StructField.IntField != 666) return 100;
+        if (obj.IntField != 777) return 101;
+
+        // Reset the struct field
+        obj.StructField = default(SimpleStruct);
+
+        // Verify struct field was reset but other field unchanged
+        if (obj.StructField.IntField != 0) return 102;
+        if (obj.StructField.BoolField != false) return 103;
+        if (obj.StructField.CharField != '\0') return 104;
+        if (obj.StructField.DoubleField != 0.0) return 105;
+        if (obj.StructField.ByteField != 0) return 106;
+        if (obj.IntField != 777) return 107;
+
+        return 0;
+    }
+
+    // Test 11: Initialize struct through unsafe pointer manipulation
+    public static unsafe int Test11()
+    {
+        SimpleStruct s = new SimpleStruct
+        {
+            IntField = 888,
+            BoolField = true,
+            CharField = 'P',
+            DoubleField = 11.11,
+            ByteField = 111
+        };
+
+        // Get a pointer to the struct
+        SimpleStruct* ptr = &s;
+
+        // Initialize through pointer
+        *ptr = default(SimpleStruct);
+
+        // Verify all fields are zeroed
+        if (s.IntField != 0) return 110;
+        if (s.BoolField != false) return 111;
+        if (s.CharField != '\0') return 112;
+        if (s.DoubleField != 0.0) return 113;
+        if (s.ByteField != 0) return 114;
+
+        return 0;
+    }
+
+    // Test 12: Initialize struct through Unsafe.AsRef
+    public static int Test12()
+    {
+        SimpleStruct s = new SimpleStruct
+        {
+            IntField = 999,
+            BoolField = true,
+            CharField = 'U',
+            DoubleField = 12.34,
+            ByteField = 200
+        };
+
+        // Use Unsafe to get a ref and initialize it
+        ref SimpleStruct sRef = ref s;
+        sRef = default(SimpleStruct);
+
+        // Verify all fields are zeroed
+        if (s.IntField != 0) return 120;
+        if (s.BoolField != false) return 121;
+        if (s.CharField != '\0') return 122;
+        if (s.DoubleField != 0.0) return 123;
+        if (s.ByteField != 0) return 124;
+
+        return 0;
+    }
+
+    // Test 13: Initialize readonly struct
+    public static int Test13()
+    {
+        ReadonlyStruct ros = new ReadonlyStruct(100, true);
+
+        // Verify initial values through properties
+        if (ros.IntValue != 100) return 130;
+        if (ros.BoolValue != true) return 131;
+
+        // Reset using default
+        ros = default(ReadonlyStruct);
+
+        // Verify zeroed
+        if (ros.IntValue != 0) return 132;
+        if (ros.BoolValue != false) return 133;
+
+        return 0;
+    }
+
+    private readonly struct ReadonlyStruct
+    {
+        public readonly int IntValue;
+        public readonly bool BoolValue;
+
+        public ReadonlyStruct(int i, bool b)
+        {
+            IntValue = i;
+            BoolValue = b;
+        }
+    }
+
+    public static int Main(string[] argv)
+    {
+        var result = Test1();
+        if (result != 0) return result;
+
+        result = Test2();
+        if (result != 0) return result;
+
+        result = Test3();
+        if (result != 0) return result;
+
+        result = Test4();
+        if (result != 0) return result;
+
+        result = Test5();
+        if (result != 0) return result;
+
+        result = Test6();
+        if (result != 0) return result;
+
+        result = Test7();
+        if (result != 0) return result;
+
+        result = Test8();
+        if (result != 0) return result;
+
+        result = Test9();
+        if (result != 0) return result;
+
+        result = Test10();
+        if (result != 0) return result;
+
+        result = Test11();
+        if (result != 0) return result;
+
+        result = Test12();
+        if (result != 0) return result;
+
+        result = Test13();
+        if (result != 0) return result;
+
+        // All tests passed
+        return 0;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/InterfaceDispatch.cs

@@ -0,0 +1,339 @@
+using System;
+
+public class InterfaceDispatchTests
+{
+    public static int Main(string[] argv)
+    {
+        int result = 0;
+
+        result |= TestBasicInterface();
+        result |= TestExplicitImplementation() << 1;
+        result |= TestMultipleInterfaces() << 2;
+        result |= TestInterfaceInheritance() << 3;
+        result |= TestDiamondInheritance() << 4;
+        result |= TestGenericInterface() << 5;
+        result |= TestCovariantInterface() << 6;
+        result |= TestReimplementation() << 7;
+        // TODO
+        /*
+        result |= TestStructInterface() << 8;
+        result |= TestNullDispatch() << 9;
+        */
+        result |= TestSharedMethodSignature() << 10;
+
+        return result;
+    }
+
+    // Test 1: Basic interface dispatch
+    static int TestBasicInterface()
+    {
+        ISimple obj = new SimpleImpl();
+        return obj.GetValue() == 42 ? 0 : 1;
+    }
+
+    // Test 2: Explicit interface implementation
+    static int TestExplicitImplementation()
+    {
+        var obj = new ExplicitImpl();
+        IExplicit iface = obj;
+
+        // Direct call should return 10, interface call should return 20
+        if (obj.GetValue() != 10) return 1;
+        if (iface.GetValue() != 20) return 1;
+
+        return 0;
+    }
+
+    // Test 3: Multiple interfaces
+    static int TestMultipleInterfaces()
+    {
+        var obj = new MultiImpl();
+        IFirst first = obj;
+        ISecond second = obj;
+
+        if (first.GetFirst() != 1) return 1;
+        if (second.GetSecond() != 2) return 1;
+
+        return 0;
+    }
+
+    // Test 4: Interface inheritance
+    static int TestInterfaceInheritance()
+    {
+        IDerived obj = new DerivedImpl();
+        IBase baseIface = obj;
+
+        if (baseIface.GetBase() != 100) return 1;
+        if (obj.GetDerived() != 200) return 1;
+
+        return 0;
+    }
+
+    // Test 5: Diamond inheritance pattern
+    static int TestDiamondInheritance()
+    {
+        var obj = new DiamondImpl();
+        ILeft left = obj;
+        IRight right = obj;
+        IDiamond diamond = obj;
+
+        if (left.GetValue() != 300) return 1;
+        if (right.GetValue() != 300) return 1;
+        if (diamond.GetDiamondValue() != 400) return 1;
+
+        return 0;
+    }
+
+    // Test 6: Generic interface dispatch
+    static int TestGenericInterface()
+    {
+        IGeneric<int> intObj = new GenericImpl<int>();
+        IGeneric<string> strObj = new GenericImpl<string>();
+
+        if (intObj.Process(5) != 3) return 1;
+        if (strObj.Process("test") != 5) return 1;
+
+        return 0;
+    }
+
+    // Test 7: Covariant interface dispatch
+    static int TestCovariantInterface()
+    {
+        ICovariant<string> strCov = new CovariantImpl();
+        ICovariant<object> objCov = strCov; // Covariance allows this
+
+        object result = objCov.Get();
+        if (!(result is string s && s == "covariant")) return 1;
+
+        return 0;
+    }
+
+    // Test 8: Interface reimplementation in derived class
+    static int TestReimplementation()
+    {
+        BaseClass baseObj = new DerivedClass();
+        IReimpl iface = baseObj;
+
+        // Should call derived implementation
+        if (iface.Method() != 500) return 1;
+
+        // Now test with base reference
+        BaseClass pureBase = new BaseClass();
+        IReimpl baseIface = pureBase;
+        if (baseIface.Method() != 600) return 1;
+
+        return 0;
+    }
+
+    // Test 9: Struct implementing interface
+    static int TestStructInterface()
+    {
+        StructImpl s = new StructImpl { Value = 700 };
+        ISimple boxed = s; // Boxing happens here
+
+        if (boxed.GetValue() != 700) return 1;
+
+        // Verify boxing created a copy
+        s.Value = 800;
+        if (boxed.GetValue() != 700) return 1; // Should still be 700
+
+        return 0;
+    }
+
+    // Test 10: Null dispatch (should throw)
+    static int TestNullDispatch()
+    {
+        ISimple nullRef = null;
+        try
+        {
+            nullRef.GetValue();
+            return 1; // Should have thrown
+        }
+        catch (NullReferenceException)
+        {
+            return 0; // Expected
+        }
+    }
+
+    // Test 11: Same method signature on multiple unrelated interfaces
+    static int TestSharedMethodSignature()
+    {
+        var obj = new SharedMethodImpl();
+        IReader reader = obj;
+        IScanner scanner = obj;
+
+        // Both interfaces should be satisfied by the single implementation
+        if (reader.Read() != "shared") return 1;
+        if (scanner.Read() != "shared") return 1;
+
+        // Also test with explicit + implicit combination
+        var mixed = new MixedSharedImpl();
+        IReader readerMixed = mixed;
+        IScanner scannerMixed = mixed;
+
+        if (readerMixed.Read() != "explicit-reader") return 1;
+        if (scannerMixed.Read() != "implicit-scanner") return 1;
+        if (mixed.Read() != "implicit-scanner") return 1; // Public method
+
+        return 0;
+    }
+
+    // Test interfaces and implementations
+
+    interface ISimple
+    {
+        int GetValue();
+    }
+
+    class SimpleImpl : ISimple
+    {
+        public int GetValue() => 42;
+    }
+
+    interface IExplicit
+    {
+        int GetValue();
+    }
+
+    class ExplicitImpl : IExplicit
+    {
+        public int GetValue() => 10;
+        int IExplicit.GetValue() => 20;
+    }
+
+    interface IFirst
+    {
+        int GetFirst();
+    }
+
+    interface ISecond
+    {
+        int GetSecond();
+    }
+
+    class MultiImpl : IFirst, ISecond
+    {
+        public int GetFirst() => 1;
+        public int GetSecond() => 2;
+    }
+
+    interface IBase
+    {
+        int GetBase();
+    }
+
+    interface IDerived : IBase
+    {
+        int GetDerived();
+    }
+
+    class DerivedImpl : IDerived
+    {
+        public int GetBase() => 100;
+        public int GetDerived() => 200;
+    }
+
+    interface ICommon
+    {
+        int GetValue();
+    }
+
+    interface ILeft : ICommon
+    {
+    }
+
+    interface IRight : ICommon
+    {
+    }
+
+    interface IDiamond : ILeft, IRight
+    {
+        int GetDiamondValue();
+    }
+
+    class DiamondImpl : IDiamond
+    {
+        public int GetValue() => 300;
+        public int GetDiamondValue() => 400;
+    }
+
+    interface IGeneric<T>
+    {
+        int Process(T value);
+    }
+
+    class GenericImpl<T> : IGeneric<T>
+    {
+        public int Process(T value)
+        {
+            if (typeof(T) == typeof(int))
+            {
+                return 3;
+            }
+
+            if (typeof(T) == typeof(string))
+            {
+                return 5;
+            }
+
+            return 0;
+        }
+    }
+
+    interface ICovariant<out T>
+    {
+        T Get();
+    }
+
+    class CovariantImpl : ICovariant<string>
+    {
+        public string Get() => "covariant";
+    }
+
+    interface IReimpl
+    {
+        int Method();
+    }
+
+    class BaseClass : IReimpl
+    {
+        public virtual int Method() => 600;
+    }
+
+    class DerivedClass : BaseClass, IReimpl
+    {
+        public override int Method() => 500;
+    }
+
+    struct StructImpl : ISimple
+    {
+        public int Value;
+        public int GetValue() => Value;
+    }
+
+    interface IReader
+    {
+        string Read();
+    }
+
+    interface IScanner
+    {
+        string Read();  // Same signature as IReader.Read()
+    }
+
+    // Single implicit implementation satisfies both interfaces
+    class SharedMethodImpl : IReader, IScanner
+    {
+        public string Read() => "shared";
+    }
+
+    // Mixed: explicit for one, implicit for the other
+    class MixedSharedImpl : IReader, IScanner
+    {
+        // Explicit implementation for IReader
+        string IReader.Read() => "explicit-reader";
+
+        // Implicit implementation (public) - satisfies IScanner
+        public string Read() => "implicit-scanner";
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/Ldelema.cs

@@ -0,0 +1,66 @@
+using System;
+
+/// <summary>
+/// A simple value type used for testing ldelema.
+/// </summary>
+public struct TestStruct
+{
+    public int Value;
+}
+
+public class Program
+{
+    /// <summary>
+    /// Modifies a TestStruct instance by reference. Calling this with an array element
+    /// (e.g., `ModifyStruct(ref array[i], ...)` ) will cause the C# compiler to
+    /// generate an `ldelema` instruction.
+    /// </summary>
+    /// <param name="s">A reference to the TestStruct to modify.</param>
+    /// <param name="newValue">The new value to assign.</param>
+    public static void ModifyStruct(ref TestStruct s, int newValue)
+    {
+        s.Value = newValue;
+    }
+
+    /// <summary>
+    /// Modifies a string reference.
+    /// </summary>
+    /// <param name="s">A reference to a string variable.</param>
+    /// <param name="newValue">The new string to assign.</param>
+    public static void ModifyStringRef(ref string s, string newValue)
+    {
+        s = newValue;
+    }
+
+    /// <summary>
+    /// Main entry point for the ldelema test.
+    /// </summary>
+    /// <returns>0 if all tests pass, otherwise a non-zero error code.</returns>
+    public static int Main(string[] args)
+    {
+        // --- Test 1: Modifying a value type element in an array ---
+        TestStruct[] structArray = new TestStruct[5];
+        structArray[2].Value = 100;
+
+        // This call should generate an `ldelema` instruction to get the address of structArray[2].
+        ModifyStruct(ref structArray[2], 999);
+
+        if (structArray[2].Value != 999)
+        {
+            return 301; // Unique error code for this test
+        }
+
+        // --- Test 2: Modifying a reference type element in an array ---
+        string[] stringArray = new string[] { "alpha", "beta", "gamma" };
+
+        // This call should also generate an `ldelema` instruction.
+        ModifyStringRef(ref stringArray[1], "zeta");
+
+        if (stringArray[1] != "zeta")
+        {
+            return 302; // Unique error code for this test
+        }
+
+        return 0; // Success
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/Ldind.cs

@@ -39,7 +39,7 @@ unsafe class LdindTest
         failures += TestTruncation();
 
         // Test with managed pointers (ref)
-        // failures += TestManagedPointers();
+        failures += TestManagedPointers();
 
         // Test Ldind.i (native int)
         failures += TestLdindI();
@@ -325,7 +325,10 @@ unsafe class LdindTest
         }
 
         // Test with array element
-        int[] array = { 10, 20, 30 };
+        int[] array = new int[3];
+        array[0] = 10;
+        array[1] = 20;
+        array[2] = 30;
         ref int element = ref array[1];
         if (element != 20)
         {

WoofWare.PawPrint.Test/sourcesPure/LdtokenField.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace LdtokenFieldTest
+{
+    class Program
+    {
+        // Various field types to test ldtoken with
+        public static int StaticIntField = 42;
+        public string InstanceStringField = "test";
+        private readonly double PrivateReadonlyField = 3.14;
+        internal decimal InternalField;
+        protected bool ProtectedField;
+        public static readonly DateTime StaticReadonlyField = DateTime.MinValue;
+
+        // Generic type fields
+        public GenericClass<int>.NestedClass<string> GenericField;
+
+        static int Main(string[] args)
+        {
+            int testsFailed = 0;
+
+            // Test 1: Static field via FieldInfo
+            FieldInfo staticField = typeof(Program).GetField(nameof(StaticIntField));
+            if (staticField == null || staticField.FieldType != typeof(int))
+            {
+                testsFailed++;
+            }
+
+            // Test 2: Instance field via FieldInfo
+            FieldInfo instanceField = typeof(Program).GetField(nameof(InstanceStringField));
+            if (instanceField == null || instanceField.FieldType != typeof(string))
+            {
+                testsFailed++;
+            }
+
+            // Test 3: Private field via FieldInfo with binding flags
+            FieldInfo privateField = typeof(Program).GetField("PrivateReadonlyField",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+            if (privateField == null || privateField.FieldType != typeof(double))
+            {
+                testsFailed++;
+            }
+
+            // Test 4: Using RuntimeFieldHandle directly
+            RuntimeFieldHandle handle = staticField.FieldHandle;
+            FieldInfo fieldFromHandle = FieldInfo.GetFieldFromHandle(handle);
+            if (!ReferenceEquals(fieldFromHandle, staticField))
+            {
+                testsFailed++;
+            }
+
+            // Test 5: Field from generic type
+            Type genericType = typeof(GenericClass<>);
+            FieldInfo genericFieldInfo = genericType.GetField("GenericField");
+            if (genericFieldInfo == null)
+            {
+                testsFailed++;
+            }
+
+            // Test 6: Field from nested type
+            Type nestedType = typeof(OuterClass.InnerClass);
+            FieldInfo nestedField = nestedType.GetField("NestedField");
+            if (nestedField == null || nestedField.FieldType != typeof(int))
+            {
+                testsFailed++;
+            }
+
+            // Test 7: Field handle with generic context
+            Type constructedGeneric = typeof(GenericClass<int>);
+            FieldInfo constructedField = constructedGeneric.GetField("GenericField");
+            RuntimeFieldHandle genericHandle = constructedField.FieldHandle;
+            FieldInfo reconstructed = FieldInfo.GetFieldFromHandle(genericHandle, constructedGeneric.TypeHandle);
+            if (reconstructed.DeclaringType != constructedGeneric)
+            {
+                testsFailed++;
+            }
+
+            // Test 8: Struct field
+            Type structType = typeof(TestStruct);
+            FieldInfo structField = structType.GetField("StructField");
+            if (structField == null || structField.FieldType != typeof(long))
+            {
+                testsFailed++;
+            }
+
+            // Test 9: Volatile field
+            FieldInfo volatileField = typeof(VolatileFieldClass).GetField("VolatileField");
+            if (volatileField == null || !volatileField.GetRequiredCustomModifiers().Any(t => t == typeof(IsVolatile)))
+            {
+                testsFailed++;
+            }
+
+            return testsFailed;
+        }
+    }
+
+    // Supporting types for testing
+    public class GenericClass<T>
+    {
+        public T GenericField;
+
+        public class NestedClass<U>
+        {
+            public U NestedGenericField;
+        }
+    }
+
+    public class OuterClass
+    {
+        public class InnerClass
+        {
+            public int NestedField = 100;
+        }
+    }
+
+    public struct TestStruct
+    {
+        public long StructField;
+    }
+
+    public class VolatileFieldClass
+    {
+        public volatile int VolatileField;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/OverlappingStructs.cs

@@ -0,0 +1,364 @@
+using System;
+using System.Runtime.InteropServices;
+
+public class StructLayoutTests
+{
+    // Test structs with various layouts
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct SequentialStruct
+    {
+        public int A;
+        public byte B;
+        public long C;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    struct ExplicitUnion
+    {
+        [FieldOffset(0)] public int AsInt;
+        [FieldOffset(0)] public float AsFloat;
+        [FieldOffset(0)] public byte Byte0;
+        [FieldOffset(1)] public byte Byte1;
+        [FieldOffset(2)] public byte Byte2;
+        [FieldOffset(3)] public byte Byte3;
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size = 16)]
+    struct FixedSizeStruct
+    {
+        [FieldOffset(0)] public long First;
+        [FieldOffset(8)] public int Second;
+        [FieldOffset(12)] public short Third;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    struct PackedStruct
+    {
+        public byte A;
+        public int B;
+        public byte C;
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    struct AutoLayoutStruct
+    {
+        public int X;
+        public string Y;
+        public double Z;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    struct NestedUnion
+    {
+        [FieldOffset(0)] public ExplicitUnion Inner;
+        [FieldOffset(0)] public long AsLong;
+        [FieldOffset(4)] public int UpperInt;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    struct LargeUnion
+    {
+        [FieldOffset(0)] public long Long1;
+        [FieldOffset(8)] public long Long2;
+        [FieldOffset(0)] public double Double1;
+        [FieldOffset(8)] public double Double2;
+        [FieldOffset(0)] public decimal AsDecimal;
+    }
+
+    // Static fields for testing
+    static SequentialStruct staticSequential;
+    static ExplicitUnion staticUnion;
+    static FixedSizeStruct staticFixed;
+
+    // Instance fields for testing
+    class FieldContainer
+    {
+        public SequentialStruct instanceSequential;
+        public ExplicitUnion instanceUnion;
+        public PackedStruct instancePacked;
+        public NestedUnion instanceNested;
+    }
+
+    static int TestSequentialLayout()
+    {
+        var s = new SequentialStruct { A = 42, B = 255, C = long.MaxValue };
+
+        // Test field access
+        if (s.A != 42) return 1;
+        if (s.B != 255) return 2;
+        if (s.C != long.MaxValue) return 3;
+
+        // Test copy semantics
+        var s2 = s;
+        s2.A = 100;
+        if (s.A != 42) return 4; // Should be unchanged (value type)
+        if (s2.A != 100) return 5;
+
+        // Test static field storage
+        staticSequential = s;
+        if (staticSequential.A != 42) return 6;
+        if (staticSequential.C != long.MaxValue) return 7;
+
+        return 0;
+    }
+
+    static int TestExplicitUnion()
+    {
+        var u = new ExplicitUnion();
+
+        // Test overlapping int/float
+        u.AsInt = 0x3F800000; // IEEE 754 representation of 1.0f
+        if (Math.Abs(u.AsFloat - 1.0f) > 0.0001f) return 10;
+
+        // Test byte-level access
+        u.AsInt = 0x12345678;
+        bool isLittleEndian = BitConverter.IsLittleEndian;
+        if (isLittleEndian)
+        {
+            if (u.Byte0 != 0x78) return 11;
+            if (u.Byte1 != 0x56) return 12;
+            if (u.Byte2 != 0x34) return 13;
+            if (u.Byte3 != 0x12) return 14;
+        }
+        else
+        {
+            if (u.Byte0 != 0x12) return 11;
+            if (u.Byte1 != 0x34) return 12;
+            if (u.Byte2 != 0x56) return 13;
+            if (u.Byte3 != 0x78) return 14;
+        }
+
+        // Test static field
+        staticUnion = u;
+        if (staticUnion.AsInt != 0x12345678) return 15;
+
+        return 0;
+    }
+
+    static int TestFixedSizeStruct()
+    {
+        var f = new FixedSizeStruct { First = -1, Second = 42, Third = 1000 };
+
+        if (f.First != -1) return 20;
+        if (f.Second != 42) return 21;
+        if (f.Third != 1000) return 22;
+
+        // Test size is respected
+        int size = Marshal.SizeOf(typeof(FixedSizeStruct));
+        if (size != 16) return 23;
+
+        staticFixed = f;
+        if (staticFixed.Second != 42) return 24;
+
+        return 0;
+    }
+
+    static int TestPackedStruct()
+    {
+        var p = new PackedStruct { A = 1, B = 0x12345678, C = 2 };
+
+        if (p.A != 1) return 30;
+        if (p.B != 0x12345678) return 31;
+        if (p.C != 2) return 32;
+
+        // Packed struct should be 6 bytes (1 + 4 + 1)
+        int size = Marshal.SizeOf(typeof(PackedStruct));
+        if (size != 6) return 33;
+
+        return 0;
+    }
+
+    static int TestInstanceFields()
+    {
+        var container = new FieldContainer();
+
+        container.instanceSequential = new SequentialStruct { A = 111, B = 222, C = 333 };
+        if (container.instanceSequential.A != 111) return 40;
+
+        container.instanceUnion = new ExplicitUnion { AsInt = unchecked((int)0xDEADBEEF) };
+        if (container.instanceUnion.AsInt != unchecked((int)0xDEADBEEF)) return 41;
+
+        container.instancePacked = new PackedStruct { A = 10, B = 20, C = 30 };
+        if (container.instancePacked.B != 20) return 42;
+
+        container.instanceNested = new NestedUnion();
+        container.instanceNested.Inner.AsInt = 100;
+        if (container.instanceNested.Inner.AsInt != 100) return 43;
+
+        return 0;
+    }
+
+    static int TestStructPassing()
+    {
+        var s = new SequentialStruct { A = 500, B = 50, C = 5005 };
+        int result = ProcessSequential(s);
+        if (result != 555) return 50; // 500 + 50 + 5 (C % 1000)
+
+        var u = new ExplicitUnion { AsInt = 1000 };
+        u = TransformUnion(u);
+        if (u.AsInt != 2000) return 51;
+
+        return 0;
+    }
+
+    static int ProcessSequential(SequentialStruct s)
+    {
+        return s.A + s.B + (int)(s.C % 1000);
+    }
+
+    static ExplicitUnion TransformUnion(ExplicitUnion u)
+    {
+        u.AsInt *= 2;
+        return u;
+    }
+
+    static int TestNestedUnion()
+    {
+        var n = new NestedUnion();
+        n.Inner.AsInt = 0x12345678;
+
+        // Lower 32 bits should match Inner.AsInt
+        if ((n.AsLong & 0xFFFFFFFF) != 0x12345678) return 60;
+
+        // Modify upper int
+        n.UpperInt = unchecked((int)0xABCDEF00);
+
+        // Check both parts
+        if (n.Inner.AsInt != 0x12345678) return 61;
+        if (n.UpperInt != unchecked((int)0xABCDEF00)) return 62;
+
+        return 0;
+    }
+
+    static int TestLargeUnion()
+    {
+        var l = new LargeUnion();
+
+        // Test double/long overlap
+        l.Double1 = 1.0;
+        l.Double2 = 2.0;
+
+        // IEEE 754: 1.0 = 0x3FF0000000000000
+        if (l.Long1 != 0x3FF0000000000000) return 70;
+        // IEEE 754: 2.0 = 0x4000000000000000
+        if (l.Long2 != 0x4000000000000000) return 71;
+
+        // Test decimal overlap (decimal is 128 bits)
+        l.AsDecimal = 42m;
+        // Just verify it doesn't crash and maintains some structure
+        if (l.AsDecimal != 42m) return 72;
+
+        return 0;
+    }
+
+    static int TestAutoLayout()
+    {
+        // Auto layout structs can't use FieldOffset, but we can still test basic functionality
+        var a = new AutoLayoutStruct { X = 100, Y = "test", Z = 3.14159 };
+
+        if (a.X != 100) return 80;
+        if (a.Y != "test") return 81;
+        if (Math.Abs(a.Z - 3.14159) > 0.00001) return 82;
+
+        // Test copy
+        var a2 = a;
+        a2.X = 200;
+        if (a.X != 100) return 83; // Original should be unchanged
+        if (a2.X != 200) return 84;
+
+        return 0;
+    }
+
+    static int TestStructArray()
+    {
+        var arr = new ExplicitUnion[3];
+        arr[0].AsInt = 10;
+        arr[1].AsInt = 20;
+        arr[2].AsInt = 30;
+
+        if (arr[0].AsInt != 10) return 90;
+        if (arr[1].AsInt != 20) return 91;
+        if (arr[2].AsInt != 30) return 92;
+
+        // Modify through float view
+        arr[1].AsFloat = 2.5f;
+        if (Math.Abs(arr[1].AsFloat - 2.5f) > 0.0001f) return 93;
+
+        return 0;
+    }
+
+    static int TestBoxingUnboxing()
+    {
+        ExplicitUnion u = new ExplicitUnion { AsInt = 999 };
+        object boxed = u; // Box
+        ExplicitUnion unboxed = (ExplicitUnion)boxed; // Unbox
+
+        if (unboxed.AsInt != 999) return 100;
+
+        // Modify original, boxed should remain unchanged
+        u.AsInt = 111;
+        ExplicitUnion fromBoxed = (ExplicitUnion)boxed;
+        if (fromBoxed.AsInt != 999) return 101; // Should still be 999
+
+        return 0;
+    }
+
+    static int TestDefaultValues()
+    {
+        // Test that default struct initialization zeroes memory
+        var s = new SequentialStruct();
+        if (s.A != 0) return 110;
+        if (s.B != 0) return 111;
+        if (s.C != 0) return 112;
+
+        var u = new ExplicitUnion();
+        if (u.AsInt != 0) return 113;
+        if (u.AsFloat != 0.0f) return 114;
+
+        return 0;
+    }
+
+    public static int Main(string[] argv)
+    {
+        int result = 0;
+
+        result = TestExplicitUnion();
+        if (result != 0) return result;
+
+        result = TestSequentialLayout();
+        if (result != 0) return result;
+
+        result = TestFixedSizeStruct();
+        if (result != 0) return result;
+
+        result = TestPackedStruct();
+        if (result != 0) return result;
+
+        result = TestInstanceFields();
+        if (result != 0) return result;
+
+        result = TestStructPassing();
+        if (result != 0) return result;
+
+        result = TestNestedUnion();
+        if (result != 0) return result;
+
+        result = TestLargeUnion();
+        if (result != 0) return result;
+
+        result = TestAutoLayout();
+        if (result != 0) return result;
+
+        result = TestStructArray();
+        if (result != 0) return result;
+
+        result = TestBoxingUnboxing();
+        if (result != 0) return result;
+
+        result = TestDefaultValues();
+        if (result != 0) return result;
+
+        return 0; // All tests passed
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/Sizeof.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Runtime.InteropServices;
+
+unsafe public class Program
+{
+    public struct SmallStruct
+    {
+        public byte Value;
+    }
+
+    public struct MediumStruct
+    {
+        public int MediumValue1;
+        public int MediumValue2;
+    }
+
+    public struct LargeStruct
+    {
+        public long LongValue1;
+        public long LongValue2;
+        public long LongValue3;
+        public long LongValue4;
+    }
+
+    public struct NestedStruct
+    {
+        public SmallStruct Small;
+        public MediumStruct Medium;
+        public int Extra;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    public struct UnionStruct
+    {
+        [FieldOffset(0)]
+        public int AsInt;
+        [FieldOffset(0)]
+        public float AsFloat;
+    }
+
+    public static int Main(string[] args)
+    {
+        // Test 1: Basic primitive types
+        if (sizeof(byte) != 1) return 1;
+        if (sizeof(sbyte) != 1) return 2;
+        if (sizeof(short) != 2) return 3;
+        if (sizeof(ushort) != 2) return 4;
+        if (sizeof(int) != 4) return 5;
+        if (sizeof(uint) != 4) return 6;
+        if (sizeof(long) != 8) return 7;
+        if (sizeof(ulong) != 8) return 8;
+        if (sizeof(float) != 4) return 9;
+        if (sizeof(double) != 8) return 10;
+        if (sizeof(char) != 2) return 11;
+        if (sizeof(bool) != 1) return 12;
+
+        // Test 2: Struct sizes
+        if (sizeof(SmallStruct) != 1) return 13;
+        if (sizeof(MediumStruct) != 8) return 14;
+        if (sizeof(LargeStruct) != 32) return 15;
+
+        // Test 3: Nested struct size
+        // SmallStruct (1) + padding (3) + MediumStruct (8) + int (4) = 16
+        if (sizeof(NestedStruct) != 16) return 16;
+
+        // Test 4: Union struct size
+        if (sizeof(UnionStruct) != 4) return 17;
+
+        // Test 5: Enum size (underlying type is int)
+        if (sizeof(DayOfWeek) != 4) return 18;
+
+        // Test 6: Pointer types
+        unsafe
+        {
+            if (sizeof(IntPtr) != sizeof(void*)) return 19;
+            if (sizeof(UIntPtr) != sizeof(void*)) return 20;
+        }
+
+        // Test 7: Using sizeof in expressions
+        int totalSize = sizeof(int) + sizeof(long) + sizeof(byte);
+        if (totalSize != 13) return 21;
+
+        // Test 8: Array element size calculation
+        int arrayElementSize = sizeof(MediumStruct);
+        int arraySize = arrayElementSize * 3;
+        if (arraySize != 24) return 22;
+
+        // Test 9: Conditional using sizeof
+        bool is32Bit = sizeof(IntPtr) == 4;
+        bool is64Bit = sizeof(IntPtr) == 8;
+        if (!is32Bit && !is64Bit) return 23;
+        if (is32Bit && is64Bit) return 24;
+
+        // Test 10: Sizeof in switch statement
+        int result = 0;
+        switch (sizeof(int))
+        {
+            case 1:
+                result = 1;
+                break;
+            case 2:
+                result = 2;
+                break;
+            case 4:
+                result = 4;
+                break;
+            case 8:
+                result = 8;
+                break;
+            default:
+                result = -1;
+                break;
+        }
+        if (result != 4) return 25;
+
+        return 0;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/Sizeof2.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Runtime.InteropServices;
+
+unsafe public class Program
+{
+    // Test for empty struct (should be 1 byte, not 0)
+    public struct EmptyStruct
+    {
+    }
+
+    // Test for char alignment (should align to 2, not 1)
+    public struct CharStruct
+    {
+        public byte B;
+        public char C;  // Should be at offset 2, not 1
+    }
+
+    // Test for end padding
+    public struct NeedsEndPadding
+    {
+        public int X;
+        public byte Y;
+        // Should pad to 8 bytes total (multiple of 4)
+    }
+
+    // Test Pack=1 (no padding)
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct PackedStruct
+    {
+        public byte B;
+        public int I;   // At offset 1, not 4
+        public byte B2;
+        // Total 6 bytes, no padding
+    }
+
+    // Test Pack=2
+    [StructLayout(LayoutKind.Sequential, Pack = 2)]
+    public struct Pack2Struct
+    {
+        public byte B;
+        public int I;   // At offset 2 (2-byte aligned, not 4)
+        public byte B2;
+        // Should pad to 8 bytes (multiple of 2)
+    }
+
+    // Test custom size smaller than natural size
+    [StructLayout(LayoutKind.Sequential, Size = 12)]
+    public struct CustomSizeSmaller
+    {
+        public long L1;
+        public long L2;
+        // Natural size is 16, but Size=12 is ignored (12 < 16)
+    }
+
+    // Test custom size larger than natural size
+    [StructLayout(LayoutKind.Sequential, Size = 20)]
+    public struct CustomSizeLarger
+    {
+        public long L;
+        // Natural size is 8, custom size 20 should win
+    }
+
+    // Test custom size not multiple of alignment
+    [StructLayout(LayoutKind.Sequential, Size = 15)]
+    public struct CustomSizeOdd
+    {
+        public long L;
+        // Size=15 should be honored even though not multiple of 8
+    }
+
+    // Test Pack=0 (means default, not 0)
+    [StructLayout(LayoutKind.Sequential, Pack = 0)]
+    public struct Pack0Struct
+    {
+        public byte B;
+        public int I;  // Should be at offset 4 (default packing)
+    }
+
+    // Test both Pack and Size
+    [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 10)]
+    public struct PackAndSize
+    {
+        public byte B;
+        public int I;
+        // Natural packed size is 5, custom size 10 should win
+    }
+
+    // Test explicit with custom Size
+    [StructLayout(LayoutKind.Explicit, Size = 10)]
+    public struct ExplicitWithSize
+    {
+        [FieldOffset(0)]
+        public int I;
+        [FieldOffset(2)]
+        public short S;
+        // Max offset+size is 4, but Size=10 should win
+    }
+
+    public struct SmallStruct
+    {
+        public byte Value;
+    }
+
+    public struct MediumStruct
+    {
+        public int MediumValue1;
+        public int MediumValue2;
+    }
+
+    public struct LargeStruct
+    {
+        public long LongValue1;
+        public long LongValue2;
+        public long LongValue3;
+        public long LongValue4;
+    }
+
+    public struct NestedStruct
+    {
+        public SmallStruct Small;
+        public MediumStruct Medium;
+        public int Extra;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    public struct UnionStruct
+    {
+        [FieldOffset(0)]
+        public int AsInt;
+        [FieldOffset(0)]
+        public float AsFloat;
+    }
+
+    public static int Main(string[] args)
+    {
+        // Test 1: Basic primitive types
+        if (sizeof(byte) != 1) return 1;
+        if (sizeof(sbyte) != 1) return 2;
+        if (sizeof(short) != 2) return 3;
+        if (sizeof(ushort) != 2) return 4;
+        if (sizeof(int) != 4) return 5;
+        if (sizeof(uint) != 4) return 6;
+        if (sizeof(long) != 8) return 7;
+        if (sizeof(ulong) != 8) return 8;
+        if (sizeof(float) != 4) return 9;
+        if (sizeof(double) != 8) return 10;
+        if (sizeof(char) != 2) return 11;
+        if (sizeof(bool) != 1) return 12;
+
+        // Test 2: Struct sizes
+        if (sizeof(SmallStruct) != 1) return 13;
+        if (sizeof(MediumStruct) != 8) return 14;
+        if (sizeof(LargeStruct) != 32) return 15;
+
+        // Test 3: Nested struct size
+        // SmallStruct (1) + padding (3) + MediumStruct (8) + int (4) = 16
+        if (sizeof(NestedStruct) != 16) return 16;
+
+        // Test 4: Union struct size
+        if (sizeof(UnionStruct) != 4) return 17;
+
+        // Test 5: Enum size (underlying type is int)
+        if (sizeof(DayOfWeek) != 4) return 18;
+
+        // Test 6: Empty struct (should be 1, not 0)
+        if (sizeof(EmptyStruct) != 1) return 19;
+
+        // Test 7: Char alignment
+        // byte (1) + padding (1) + char (2) = 4
+        if (sizeof(CharStruct) != 4) return 20;
+
+        // Test 8: End padding
+        // int (4) + byte (1) + padding (3) = 8
+        if (sizeof(NeedsEndPadding) != 8) return 21;
+
+        // Test 9: Pack=1 removes all padding
+        // byte (1) + int (4) + byte (1) = 6
+        if (sizeof(PackedStruct) != 6) return 22;
+
+        // Test 10: Pack=2
+        // byte (1) + padding (1) + int (4) + byte (1) + padding (1) = 8
+        if (sizeof(Pack2Struct) != 8) return 23;
+
+        // Test 11: Custom size smaller than natural (ignored)
+        if (sizeof(CustomSizeSmaller) != 16) return 24;
+
+        // Test 12: Custom size larger than natural (honored)
+        if (sizeof(CustomSizeLarger) != 20) return 25;
+
+        // Test 13: Custom size not multiple of alignment (honored)
+        if (sizeof(CustomSizeOdd) != 15) return 26;
+
+        // Test 14: Pack=0 means default packing
+        // byte (1) + padding (3) + int (4) = 8
+        if (sizeof(Pack0Struct) != 8) return 27;
+
+        // Test 15: Pack and Size together
+        // Natural packed: byte (1) + int (4) = 5, but Size=10
+        if (sizeof(PackAndSize) != 10) return 28;
+
+        // Test 16: Explicit with Size
+        // Max used is 4, but Size=10
+        if (sizeof(ExplicitWithSize) != 10) return 29;
+
+        // Test 17: Pointer types
+        unsafe
+        {
+            if (sizeof(IntPtr) != sizeof(void*)) return 30;
+            if (sizeof(UIntPtr) != sizeof(void*)) return 31;
+        }
+
+        // Test 18: Using sizeof in expressions
+        int totalSize = sizeof(int) + sizeof(long) + sizeof(byte);
+        if (totalSize != 13) return 32;
+
+        // Test 19: Array element size calculation
+        int arrayElementSize = sizeof(MediumStruct);
+        int arraySize = arrayElementSize * 3;
+        if (arraySize != 24) return 33;
+
+        // Test 20: Complex nested struct with Pack
+        // byte (1) + CharStruct (4) + byte (1) = 6
+        if (sizeof(PackedNested) != 6) return 34;
+
+        return 0;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    struct PackedNested
+    {
+        public byte B;
+        public CharStruct C;
+        public byte B2;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/StaticVariables.cs

@@ -0,0 +1,54 @@
+public class GenericCounter<T>
+{
+    private static int count = 0;
+
+    public static void Increment()
+    {
+        count++;
+    }
+
+    public static int GetCount()
+    {
+        return count;
+    }
+
+    public static void Reset()
+    {
+        count = 0;
+    }
+}
+
+class Program
+{
+    static int Main(string[] argv)
+    {
+        // Test that different generic instantiations have separate static variables
+
+        // Initial state should be 0 for all
+        if (GenericCounter<int>.GetCount() != 0) return 1;
+        if (GenericCounter<string>.GetCount() != 0) return 2;
+
+        // Increment int version 3 times
+        GenericCounter<int>.Increment();
+        GenericCounter<int>.Increment();
+        GenericCounter<int>.Increment();
+
+        // Increment string version 2 times
+        GenericCounter<string>.Increment();
+        GenericCounter<string>.Increment();
+
+        // Verify counts are independent
+        if (GenericCounter<int>.GetCount() != 3) return 3;
+        if (GenericCounter<string>.GetCount() != 2) return 4;
+
+        // Reset int version only
+        GenericCounter<int>.Reset();
+
+        // Verify reset only affected int version
+        if (GenericCounter<int>.GetCount() != 0) return 5;
+        if (GenericCounter<string>.GetCount() != 2) return 6;
+
+        // Test passes - static variables are isolated per generic instantiation
+        return 0;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/TestOr.cs

@@ -0,0 +1,41 @@
+public class TestOr
+{
+    public static int Main(string[] args)
+    {
+        // Test 1: Bitwise OR with Int32
+        int a32 = 12;        // Binary: 1100
+        int b32 = 10;        // Binary: 1010
+        int result32 = a32 | b32;  // Should be 14 (Binary: 1110)
+        if (result32 != 14) return 1;
+
+        // Test 2: Bitwise OR with Int64
+        long a64 = 0x00FF00FFL;
+        long b64 = 0xFF00FF00L;
+        long result64 = a64 | b64;
+        if (result64 != 0xFFFFFFFFL) return 2;
+
+        // Test 3: Mixed bitwise OR (Int32 and native int)
+        int aMixed = 15;        // Binary: 1111
+        nint bMixed = 240;      // Binary: 11110000
+        nint resultMixed = aMixed | bMixed;  // Should be 255 (Binary: 11111111)
+        if (resultMixed != 255) return 3;
+
+        // Test 4: OR with itself
+        int self = 42;
+        int selfResult = self | self;
+        if (selfResult != 42) return 4;
+
+        // Test 5: OR with 0
+        int withZero = 123;
+        int zeroResult = withZero | 0;
+        if (zeroResult != 123) return 5;
+
+        // Test 6: Native int OR native int
+        nint nativeA = 0x0F;
+        nint nativeB = 0xF0;
+        nint nativeResult = nativeA | nativeB;  // Should be 0xFF
+        if (nativeResult != 0xFF) return 6;
+
+        return 0;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/TestShl.cs

@@ -0,0 +1,34 @@
+public class TestShl
+{
+    public static int Main(string[] args)
+    {
+        // Test 1: Shift Left with Int32
+        int value32 = 5;     // Binary: 0101
+        int shift32 = 2;
+        int result32 = value32 << shift32;  // Should be 20 (Binary: 10100)
+        if (result32 != 20) return 1;
+
+        // Test 2: Shift Left with Int64
+        long value64 = 7L;   // Binary: 0111
+        int shift64 = 3;
+        long result64 = value64 << shift64;  // Should be 56 (Binary: 111000)
+        if (result64 != 56L) return 2;
+
+        // Test 3: Shift by 0
+        int noShiftValue = 42;
+        int noShiftResult = noShiftValue << 0;
+        if (noShiftResult != 42) return 3;
+
+        // Test 4: Shift by 1
+        int singleShiftResult = noShiftValue << 1;
+        if (singleShiftResult != 84) return 4;
+
+        // Test 5: Shift with native int
+        nint nativeValue = 3;
+        int nativeShift = 4;
+        nint nativeResult = nativeValue << nativeShift;  // Should be 48
+        if (nativeResult != 48) return 5;
+
+        return 0;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/TestShr.cs

@@ -0,0 +1,35 @@
+public class TestShr
+{
+    public static int Main(string[] args)
+    {
+        // Test 1: Shift Right with Int32
+        int value32 = 20;    // Binary: 10100
+        int shift32 = 2;
+        int result32 = value32 >> shift32;  // Should be 5 (Binary: 0101)
+        if (result32 != 5) return 1;
+
+        // Test 2: Shift Right with Int64
+        long value64 = 56L;  // Binary: 111000
+        int shift64 = 3;
+        long result64 = value64 >> shift64;  // Should be 7 (Binary: 0111)
+        if (result64 != 7L) return 2;
+
+        // Test 3: Right shift preserving sign (negative number)
+        int negative = -16;
+        int negativeResult = negative >> 2;  // Should be -4
+        if (negativeResult != -4) return 3;
+
+        // Test 4: Shift by 0
+        int noShiftValue = 99;
+        int noShiftResult = noShiftValue >> 0;
+        if (noShiftResult != 99) return 4;
+
+        // Test 5: Shift with native int
+        nint nativeValue = 48;
+        int nativeShift = 4;
+        nint nativeResult = nativeValue >> nativeShift;  // Should be 3
+        if (nativeResult != 3) return 5;
+
+        return 0;
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/TypeConcretization.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+
+// Test basic type concretization
+public class BasicTypeTest
+{
+    public static int TestBasicTypes()
+    {
+        // Test primitive types
+        int i = 42;
+        string s = "hello";
+        bool b = true;
+        
+        if (i != 42) return 1;
+        if (s != "hello") return 2;
+        if (!b) return 3;
+        
+        return 0;
+    }
+}
+
+// Test generic type instantiation
+public class GenericTypeTest<T>
+{
+    private T value;
+    
+    public GenericTypeTest(T val)
+    {
+        value = val;
+    }
+    
+    public T GetValue()
+    {
+        return value;
+    }
+    
+    public static int TestGenericInstantiation()
+    {
+        var intTest = new GenericTypeTest<int>(123);
+        var stringTest = new GenericTypeTest<string>("test");
+        
+        if (intTest.GetValue() != 123) return 1;
+        if (stringTest.GetValue() != "test") return 2;
+        
+        return 0;
+    }
+}
+
+// Test nested generic types
+public class NestedGenericTest
+{
+    public static int TestNestedGenerics()
+    {
+        var listOfInts = new List<int>();
+        listOfInts.Add(1);
+        listOfInts.Add(2);
+        
+        if (listOfInts.Count != 2) return 1;
+        if (listOfInts[0] != 1) return 2;
+        if (listOfInts[1] != 2) return 3;
+        
+        var listOfLists = new List<List<int>>();
+        listOfLists.Add(listOfInts);
+        
+        if (listOfLists.Count != 1) return 4;
+        if (listOfLists[0].Count != 2) return 5;
+        
+        return 0;
+    }
+}
+
+// Test generic methods
+public class GenericMethodTest
+{
+    public static T Identity<T>(T input)
+    {
+        return input;
+    }
+    
+    public static int TestGenericMethods()
+    {
+        int intResult = Identity<int>(42);
+        string stringResult = Identity<string>("hello");
+        
+        if (intResult != 42) return 1;
+        if (stringResult != "hello") return 2;
+        
+        return 0;
+    }
+}
+
+class Program
+{
+    static int Main(string[] args)
+    {
+        int result;
+        
+        result = BasicTypeTest.TestBasicTypes();
+        if (result != 0) return 100 + result;
+        
+        result = GenericTypeTest<int>.TestGenericInstantiation();
+        if (result != 0) return 200 + result;
+        
+        result = NestedGenericTest.TestNestedGenerics();
+        if (result != 0) return 300 + result;
+        
+        result = GenericMethodTest.TestGenericMethods();
+        if (result != 0) return 400 + result;
+        
+        return 0; // All tests passed
+    }
+}

WoofWare.PawPrint.Test/sourcesPure/UnsafeAs.cs

@@ -0,0 +1,276 @@
+using System;
+using System.Runtime.CompilerServices;
+
+public class TestUnsafeAs
+{
+    private struct Int32Wrapper
+    {
+        public int Value;
+    }
+
+    private struct UInt32Wrapper
+    {
+        public uint Value;
+    }
+
+    private struct TwoInt16s
+    {
+        public short First;
+        public short Second;
+    }
+
+    private struct FourBytes
+    {
+        public byte B0;
+        public byte B1;
+        public byte B2;
+        public byte B3;
+    }
+
+    private enum TestEnum : int
+    {
+        Value1 = 0x12345678,
+        Value2 = -1
+    }
+
+    // Test 1: Int32 -> UInt32 reinterpretation
+    public static int Test1()
+    {
+        int original = -1;
+        ref uint reinterpreted = ref Unsafe.As<int, uint>(ref original);
+
+        if (reinterpreted != 0xFFFFFFFF)
+            return 1;
+
+        reinterpreted = 0x12345678;
+        if (original != 0x12345678)
+            return 2;
+
+        original = int.MinValue;
+        if (reinterpreted != 0x80000000)
+            return 3;
+
+        return 0;
+    }
+
+    // Test 2: Struct -> Struct reinterpretation
+    public static int Test2()
+    {
+        Int32Wrapper wrapper = new Int32Wrapper { Value = 0x01020304 };
+        ref FourBytes bytes = ref Unsafe.As<Int32Wrapper, FourBytes>(ref wrapper);
+
+        if (BitConverter.IsLittleEndian)
+        {
+            if (bytes.B0 != 0x04) return 10;
+            if (bytes.B1 != 0x03) return 11;
+            if (bytes.B2 != 0x02) return 12;
+            if (bytes.B3 != 0x01) return 13;
+        }
+        else
+        {
+            if (bytes.B0 != 0x01) return 14;
+            if (bytes.B1 != 0x02) return 15;
+            if (bytes.B2 != 0x03) return 16;
+            if (bytes.B3 != 0x04) return 17;
+        }
+
+        bytes.B0 = 0xFF;
+        int expectedValue = BitConverter.IsLittleEndian ? 0x010203FF : unchecked((int)0xFF020304);
+        if (wrapper.Value != expectedValue)
+            return 18;
+
+        return 0;
+    }
+
+    // Test 3: Int32 -> Two Int16s
+    public static int Test3()
+    {
+        int value = 0x12345678;
+        ref TwoInt16s halves = ref Unsafe.As<int, TwoInt16s>(ref value);
+
+        if (BitConverter.IsLittleEndian)
+        {
+            if (halves.First != unchecked((short)0x5678)) return 20;
+            if (halves.Second != 0x1234) return 21;
+        }
+        else
+        {
+            if (halves.First != 0x1234) return 22;
+            if (halves.Second != unchecked((short)0x5678)) return 23;
+        }
+
+        halves.First = -1;
+        int expectedValue = BitConverter.IsLittleEndian ? 0x1234FFFF : unchecked((int)0xFFFF5678);
+        if (value != expectedValue)
+            return 24;
+
+        return 0;
+    }
+
+    // Test 4: Array element reinterpretation
+    public static int Test4()
+    {
+        int[] intArray = new int[] { 0x01020304, 0x05060708 };
+        ref uint uintRef = ref Unsafe.As<int, uint>(ref intArray[0]);
+
+        if (uintRef != 0x01020304u)
+            return 30;
+
+        uintRef = 0xAABBCCDD;
+        if (intArray[0] != unchecked((int)0xAABBCCDD))
+            return 31;
+        if (intArray[1] != 0x05060708)
+            return 32;
+
+        return 0;
+    }
+
+    // Test 5: Bool -> Byte
+    public static int Test5()
+    {
+        bool trueValue = true;
+        bool falseValue = false;
+
+        ref byte trueByte = ref Unsafe.As<bool, byte>(ref trueValue);
+        ref byte falseByte = ref Unsafe.As<bool, byte>(ref falseValue);
+
+        if (trueByte != 1)
+            return 40;
+        if (falseByte != 0)
+            return 41;
+
+        // Modify through byte reference
+        trueByte = 0;
+        if (trueValue != false)
+            return 42;
+
+        falseByte = 1;
+        if (falseValue != true)
+            return 43;
+
+        return 0;
+    }
+
+    // Test 6: Char -> UInt16
+    public static int Test6()
+    {
+        char ch = 'A';
+        ref ushort asUInt16 = ref Unsafe.As<char, ushort>(ref ch);
+
+        if (asUInt16 != 65)
+            return 50;
+
+        asUInt16 = 0x03B1; // Greek lowercase alpha
+        if (ch != 'α')
+            return 51;
+
+        return 0;
+    }
+
+    // Test 7: Float -> Int32
+    public static int Test7()
+    {
+        float floatValue = 1.0f;
+        ref int intBits = ref Unsafe.As<float, int>(ref floatValue);
+
+        // IEEE 754: 1.0f = 0x3F800000
+        if (intBits != 0x3F800000)
+            return 60;
+
+        intBits = 0x40000000; // 2.0f in IEEE 754
+        if (floatValue != 2.0f)
+            return 61;
+
+        floatValue = -0.0f;
+        if (intBits != unchecked((int)0x80000000))
+            return 62;
+
+        return 0;
+    }
+
+    // Test 8: Double -> Int64
+    public static int Test8()
+    {
+        double doubleValue = 1.0;
+        ref long longBits = ref Unsafe.As<double, long>(ref doubleValue);
+
+        // IEEE 754: 1.0 = 0x3FF0000000000000
+        if (longBits != 0x3FF0000000000000L)
+            return 70;
+
+        longBits = 0x4000000000000000L; // 2.0 in IEEE 754
+        if (doubleValue != 2.0)
+            return 71;
+
+        return 0;
+    }
+
+    // Test 9: Enum -> Underlying type
+    public static int Test9()
+    {
+        TestEnum enumValue = TestEnum.Value1;
+        ref int underlying = ref Unsafe.As<TestEnum, int>(ref enumValue);
+
+        if (underlying != 0x12345678)
+            return 80;
+
+        underlying = -1;
+        if (enumValue != TestEnum.Value2)
+            return 81;
+
+        return 0;
+    }
+
+    // Test 10: Local variable reinterpretation
+    public static int Test10()
+    {
+        int local = unchecked((int)0xDEADBEEF);
+        ref uint localAsUint = ref Unsafe.As<int, uint>(ref local);
+
+        if (localAsUint != 0xDEADBEEF)
+            return 90;
+
+        localAsUint = 0xCAFEBABE;
+        if (local != unchecked((int)0xCAFEBABE))
+            return 91;
+
+        return 0;
+    }
+
+    public static int Main(string[] argv)
+    {
+        var result = Test1();
+        if (result != 0) return result;
+
+        result = Test2();
+        if (result != 0) return result;
+
+        result = Test3();
+        if (result != 0) return result;
+
+        result = Test4();
+        if (result != 0) return result;
+
+        result = Test5();
+        if (result != 0) return result;
+
+        result = Test6();
+        if (result != 0) return result;
+
+        result = Test7();
+        if (result != 0) return result;
+
+        result = Test8();
+        if (result != 0) return result;
+
+        result = Test9();
+        if (result != 0) return result;
+
+        result = Test10();
+        if (result != 0) return result;
+
+        // All tests passed
+        return 0;
+    }
+}
+

WoofWare.PawPrint/AbstractMachine.fs

@@ -1,6 +1,5 @@
 namespace WoofWare.PawPrint
 
-open System.Collections.Immutable
 open Microsoft.Extensions.Logging
 open Microsoft.FSharp.Core
 open WoofWare.PawPrint.ExternImplementations
@@ -43,7 +42,7 @@ module AbstractMachine =
                 | Some {
                            WasConstructingObj = Some _
                        } ->
-                    IlMachineState.executeDelegateConstructor instruction state
+                    IlMachineState.executeDelegateConstructor baseClassTypes instruction state
                     // can't advance the program counter here - there's no IL instructions executing!
                     |> IlMachineState.returnStackFrame loggerFactory baseClassTypes thread
                     |> Option.get
@@ -55,27 +54,24 @@ module AbstractMachine =
                     // We've been instructed to run a delegate.
                     let delegateToRunAddr =
                         match instruction.Arguments.[0] with
+                        | CliType.RuntimePointer (CliRuntimePointer.Managed (ManagedPointerSource.Heap addr))
                         | CliType.ObjectRef (Some addr) -> addr
                         | _ -> failwith "expected a managed object ref to delegate"
 
                     let delegateToRun = state.ManagedHeap.NonArrayObjects.[delegateToRunAddr]
 
-                    if delegateToRun.Fields.["_target"] <> CliType.ObjectRef None then
-                        failwith "TODO: delegate target wasn't None"
+                    let target =
+                        match delegateToRun |> AllocatedNonArrayObject.DereferenceField "_target" with
+                        | CliType.ObjectRef addr -> addr
+                        | x -> failwith $"TODO: delegate target wasn't an object ref: %O{x}"
 
                     let methodPtr =
-                        match delegateToRun.Fields.["_methodPtr"] with
+                        match delegateToRun |> AllocatedNonArrayObject.DereferenceField "_methodPtr" with
                         | CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.FunctionPointer mi)) -> mi
                         | d -> failwith $"unexpectedly not a method pointer in delegate invocation: {d}"
 
-                    let typeGenerics =
-                        instruction.ExecutingMethod.DeclaringType.Generics |> ImmutableArray.CreateRange
-
                     let methodGenerics = instruction.ExecutingMethod.Generics
 
-                    let methodPtr =
-                        methodPtr |> MethodInfo.mapTypeGenerics (fun i _ -> typeGenerics.[i])
-
                     // When we return, we need to go back up the stack
                     match state |> IlMachineState.returnStackFrame loggerFactory baseClassTypes thread with
                     | None -> failwith "unexpectedly nowhere to return from delegate"
@@ -86,23 +82,42 @@ module AbstractMachine =
                         (state, instruction.Arguments)
                         ||> Seq.fold (fun state arg -> IlMachineState.pushToEvalStack arg thread state)
 
+                    // The odd little calling convention strikes again: we push the `target` parameter on top of the
+                    // stack, although that doesn't actually happen in the CLR.
+                    // We'll pretend we're constructing an object, so that the calling convention gets respected in
+                    // `callMethod`.
+                    let state, constructing =
+                        match target with
+                        | None -> state, None
+                        | Some target ->
+                            let state =
+                                IlMachineState.pushToEvalStack (CliType.ObjectRef (Some target)) thread state
+
+                            state, Some target
+
                     let state, _ =
                         state.WithThreadSwitchedToAssembly methodPtr.DeclaringType.Assembly thread
 
                     // Don't advance the program counter again on return; that was already done by the Callvirt that
                     // caused this delegate to be invoked.
-                    let state, result =
-                        state
-                        |> IlMachineState.callMethodInActiveAssembly
+                    let currentThreadState = state.ThreadState.[thread]
+
+                    let state =
+                        IlMachineStateExecution.callMethod
                             loggerFactory
                             baseClassTypes
-                            thread
-                            false
-                            (Some methodGenerics)
-                            methodPtr
                             None
+                            constructing
+                            false
+                            false
+                            false
+                            methodGenerics
+                            methodPtr
+                            thread
+                            currentThreadState
+                            state
 
-                    ExecutionResult.Stepped (state, result)
+                    ExecutionResult.Stepped (state, WhatWeDid.Executed)
             | _ ->
 
             let outcome =
@@ -119,34 +134,47 @@ module AbstractMachine =
                   "Environment",
                   "GetProcessorCount",
                   [],
-                  TypeDefn.PrimitiveType PrimitiveType.Int32 ->
+                  ConcretePrimitive state.ConcreteTypes PrimitiveType.Int32 ->
                     let env = ISystem_Environment_Env.get impls
                     env.GetProcessorCount thread state
                 | "System.Private.CoreLib",
                   "System",
                   "Environment",
                   "_Exit",
-                  [ TypeDefn.PrimitiveType PrimitiveType.Int32 ],
-                  TypeDefn.Void ->
+                  [ ConcretePrimitive state.ConcreteTypes PrimitiveType.Int32 ],
+                  ConcreteVoid state.ConcreteTypes ->
                     let env = ISystem_Environment_Env.get impls
                     env._Exit thread state
                 | "System.Private.CoreLib",
                   "System.Threading",
                   "Monitor",
                   "ReliableEnter",
-                  [ TypeDefn.PrimitiveType PrimitiveType.Object
-                    TypeDefn.Byref (TypeDefn.PrimitiveType PrimitiveType.Boolean) ],
-                  TypeDefn.Void ->
+                  [ ConcretePrimitive state.ConcreteTypes PrimitiveType.Object
+                    ConcreteByref (ConcretePrimitive state.ConcreteTypes PrimitiveType.Boolean) ],
+                  ConcreteVoid state.ConcreteTypes ->
                     let env = ISystem_Threading_Monitor_Env.get impls
                     env.ReliableEnter thread state
                 | "System.Private.CoreLib",
                   "System.Threading",
                   "Monitor",
                   "Exit",
-                  [ TypeDefn.PrimitiveType PrimitiveType.Object ],
-                  TypeDefn.Void ->
+                  [ ConcretePrimitive state.ConcreteTypes PrimitiveType.Object ],
+                  ConcreteVoid state.ConcreteTypes ->
                     let env = ISystem_Threading_Monitor_Env.get impls
                     env.Exit thread state
+                | "System.Private.CoreLib",
+                  "System",
+                  "Type",
+                  "GetField",
+                  [ ConcretePrimitive state.ConcreteTypes PrimitiveType.String ; ty ],
+                  ret ->
+                    let ty = AllConcreteTypes.lookup ty state.ConcreteTypes |> Option.get
+                    let ret = AllConcreteTypes.lookup ret state.ConcreteTypes |> Option.get
+
+                    match ty.Namespace, ty.Name, ty.Generics.IsEmpty, ret.Namespace, ret.Name, ret.Generics.IsEmpty with
+                    | "System.Reflection", "BindingFlags", true, "System.Reflection", "FieldInfo", true ->
+                        failwith "TODO: GetField"
+                    | _ -> failwith "unexpected signature for Type.GetField"
                 | assy, ns, typeName, methName, param, retType ->
                     failwith
                         $"TODO: tried to IL-interpret a method in {assy} {ns}.{typeName} named {methName} with no implementation; {param} -> {retType}"
@@ -194,5 +222,5 @@ module AbstractMachine =
             |> ExecutionResult.Stepped
         | IlOp.Switch immutableArray -> failwith "TODO: Switch unimplemented"
         | IlOp.UnaryStringToken (unaryStringTokenIlOp, stringHandle) ->
-            UnaryStringTokenIlOp.execute baseClassTypes unaryStringTokenIlOp stringHandle state thread
+            UnaryStringTokenIlOp.execute loggerFactory baseClassTypes unaryStringTokenIlOp stringHandle state thread
             |> ExecutionResult.Stepped

WoofWare.PawPrint/AbstractMachineDomain.fs

@@ -14,6 +14,3 @@ type ManagedHeapAddress =
     override this.ToString () : string =
         match this with
         | ManagedHeapAddress.ManagedHeapAddress i -> $"<object #%i{i}>"
-
-[<Measure>]
-type typeHandle

WoofWare.PawPrint/BasicCliType.fs

@@ -3,7 +3,7 @@ namespace WoofWare.PawPrint
 open System
 open System.Collections.Immutable
 open System.Reflection
-open System.Reflection.Metadata
+open Checked
 
 /// Source:
 /// Table I.6: Data Types Directly Supported by the CLI
@@ -41,7 +41,10 @@ type ManagedPointerSource =
     | LocalVariable of sourceThread : ThreadId * methodFrame : int * whichVar : uint16
     | Argument of sourceThread : ThreadId * methodFrame : int * whichVar : uint16
     | Heap of ManagedHeapAddress
+    | ArrayIndex of arr : ManagedHeapAddress * index : int
+    | Field of ManagedPointerSource * fieldName : string
     | Null
+    | InterpretedAsType of ManagedPointerSource * ConcreteType<ConcreteTypeHandle>
 
     override this.ToString () =
         match this with
@@ -51,6 +54,9 @@ type ManagedPointerSource =
             $"<variable %i{var} in method frame %i{method} of thread %O{source}>"
         | ManagedPointerSource.Argument (source, method, var) ->
             $"<argument %i{var} in method frame %i{method} of thread %O{source}>"
+        | ManagedPointerSource.ArrayIndex (arr, index) -> $"<index %i{index} of array %O{arr}>"
+        | ManagedPointerSource.Field (source, name) -> $"<field %s{name} of %O{source}>"
+        | ManagedPointerSource.InterpretedAsType (src, ty) -> $"<%O{src} as %s{ty.Namespace}.%s{ty.Name}>"
 
 [<RequireQualifiedAccess>]
 type UnsignedNativeIntSource =
@@ -61,8 +67,9 @@ type UnsignedNativeIntSource =
 type NativeIntSource =
     | Verbatim of int64
     | ManagedPointer of ManagedPointerSource
-    | FunctionPointer of MethodInfo<FakeUnit, WoofWare.PawPrint.GenericParameter>
-    | TypeHandlePtr of int64<typeHandle>
+    | FunctionPointer of MethodInfo<ConcreteTypeHandle, ConcreteTypeHandle, ConcreteTypeHandle>
+    | TypeHandlePtr of ConcreteTypeHandle
+    | FieldHandlePtr of int64
 
     override this.ToString () : string =
         match this with
@@ -70,13 +77,15 @@ type NativeIntSource =
         | NativeIntSource.ManagedPointer ptr -> $"<managed pointer {ptr}>"
         | NativeIntSource.FunctionPointer methodDefinition ->
             $"<pointer to {methodDefinition.Name} in {methodDefinition.DeclaringType.Assembly.Name}>"
-        | NativeIntSource.TypeHandlePtr ptr -> $"<type ID %i{ptr}>"
+        | NativeIntSource.TypeHandlePtr ptr -> $"<type ID %O{ptr}>"
+        | NativeIntSource.FieldHandlePtr ptr -> $"<field ID %O{ptr}>"
 
 [<RequireQualifiedAccess>]
 module NativeIntSource =
     let isZero (n : NativeIntSource) : bool =
         match n with
         | NativeIntSource.Verbatim i -> i = 0L
+        | NativeIntSource.FieldHandlePtr _
         | NativeIntSource.TypeHandlePtr _ -> false
         | NativeIntSource.FunctionPointer _ -> failwith "TODO"
         | NativeIntSource.ManagedPointer src ->
@@ -88,6 +97,7 @@ module NativeIntSource =
         match n with
         | NativeIntSource.Verbatim i -> i >= 0L
         | NativeIntSource.FunctionPointer _ -> failwith "TODO"
+        | NativeIntSource.FieldHandlePtr _
         | NativeIntSource.TypeHandlePtr _ -> true
         | NativeIntSource.ManagedPointer _ -> true
 
@@ -112,28 +122,51 @@ type CliNumericType =
     | Float32 of float32
     | Float64 of float
 
-type CliValueType =
-    private
-    | Bool of byte
-    /// A UTF-16 code unit, i.e. two bytes. We store the most significant one first.
-    | Char of byte * byte
-    | UInt8 of uint8
-    | UInt16 of uint16
-    | Int8 of int8
-    | Int16 of int16
-    | Float32 of float32
-    | Float64 of float
+    static member SizeOf (t : CliNumericType) : int =
+        match t with
+        | CliNumericType.Int32 _ -> 4
+        | CliNumericType.Int64 _ -> 8
+        | CliNumericType.NativeInt _ -> 8
+        | CliNumericType.NativeFloat _ -> 8
+        | CliNumericType.Int8 _ -> 1
+        | CliNumericType.Int16 _ -> 2
+        | CliNumericType.UInt8 _ -> 1
+        | CliNumericType.UInt16 _ -> 2
+        | CliNumericType.Float32 _ -> 4
+        | CliNumericType.Float64 _ -> 8
 
-[<RequireQualifiedAccess>]
-type CliRuntimePointerSource =
-    | LocalVariable of sourceThread : ThreadId * methodFrame : int * whichVar : uint16
-    | Argument of sourceThread : ThreadId * methodFrame : int * whichVar : uint16
-    | Heap of ManagedHeapAddress
-    | Null
+    static member ToBytes (t : CliNumericType) : byte[] =
+        match t with
+        | CliNumericType.Int32 i -> BitConverter.GetBytes i
+        | CliNumericType.Int64 i -> BitConverter.GetBytes i
+        | CliNumericType.NativeInt src ->
+            match src with
+            | NativeIntSource.Verbatim i -> BitConverter.GetBytes i
+            | NativeIntSource.ManagedPointer src ->
+                match src with
+                | ManagedPointerSource.Null -> BitConverter.GetBytes 0L
+                | _ -> failwith "refusing to express pointer as bytes"
+            | NativeIntSource.FieldHandlePtr _ -> failwith "refusing to express FieldHandlePtr as bytes"
+            | NativeIntSource.FunctionPointer _ -> failwith "refusing to express FunctionPointer as bytes"
+            | NativeIntSource.TypeHandlePtr _ -> failwith "refusing to express TypeHandlePtr as bytes"
+        | CliNumericType.NativeFloat f -> BitConverter.GetBytes f
+        | CliNumericType.Int8 i -> BitConverter.GetBytes i
+        | CliNumericType.Int16 i -> BitConverter.GetBytes i
+        | CliNumericType.UInt8 i -> BitConverter.GetBytes i
+        | CliNumericType.UInt16 i -> BitConverter.GetBytes i
+        | CliNumericType.Float32 i -> BitConverter.GetBytes i
+        | CliNumericType.Float64 i -> BitConverter.GetBytes i
 
 type CliRuntimePointer =
-    | Unmanaged of int64
-    | Managed of CliRuntimePointerSource
+    | Verbatim of int64
+    | FieldRegistryHandle of int64
+    | Managed of ManagedPointerSource
+
+type SizeofResult =
+    {
+        Alignment : int
+        Size : int
+    }
 
 /// This is the kind of type that can be stored in arguments, local variables, statics, array elements, fields.
 type CliType =
@@ -149,15 +182,351 @@ type CliType =
     | RuntimePointer of CliRuntimePointer
     /// This is *not* a CLI type as such. I don't actually know its status. A value type is represented simply
     /// as a concatenated list of its fields.
-    | ValueType of CliType list
+    | ValueType of CliValueType
 
-    /// In fact any non-zero value will do for True, but we'll use 1
-    static member OfBool (b : bool) = CliType.Bool (if b then 1uy else 0uy)
+    static member SizeOf (t : CliType) : SizeofResult =
+        match t with
+        | CliType.Numeric ty ->
+            let size = CliNumericType.SizeOf ty
 
-    static member OfChar (c : char) =
-        CliType.Char (byte (int c / 256), byte (int c % 256))
+            {
+                Size = size
+                Alignment = size
+            }
+        | CliType.Bool _ ->
+            {
+                Size = 1
+                Alignment = 1
+            }
+        | CliType.Char _ ->
+            {
+                Size = 2
+                Alignment = 2
+            }
+        | CliType.ObjectRef _ ->
+            {
+                Size = 8
+                Alignment = 8
+            }
+        | CliType.RuntimePointer _ ->
+            {
+                Size = 8
+                Alignment = 8
+            }
+        | CliType.ValueType vt -> CliValueType.SizeOf vt
 
-    static member OfManagedObject (ptr : ManagedHeapAddress) = CliType.ObjectRef (Some ptr)
+    static member ToBytes (t : CliType) : byte[] =
+        match t with
+        | CliType.Numeric n -> CliNumericType.ToBytes n
+        | CliType.Bool b -> [| b |]
+        | CliType.Char (high, low) -> [| low ; high |]
+        | CliType.ObjectRef None -> Array.zeroCreate NATIVE_INT_SIZE
+        | CliType.ObjectRef (Some i) -> failwith "todo"
+        | CliType.RuntimePointer cliRuntimePointer -> failwith "todo"
+        | CliType.ValueType cvt -> CliValueType.ToBytes cvt
+
+    static member OfBytesAsType (targetType : ConcreteTypeHandle) (bytes : byte[]) : CliType = failwith "TODO"
+
+and CliField =
+    {
+        Name : string
+        Contents : CliType
+        /// "None" for "no explicit offset specified"; we expect most offsets to be None.
+        Offset : int option
+        Type : ConcreteTypeHandle
+    }
+
+and CliConcreteField =
+    private
+        {
+            Name : string
+            Contents : CliType
+            Offset : int
+            Size : int
+            Alignment : int
+            ConfiguredOffset : int option
+            EditedAtTime : uint64
+            Type : ConcreteTypeHandle
+        }
+
+    static member ToCliField (this : CliConcreteField) : CliField =
+        {
+            Offset = this.ConfiguredOffset
+            Contents = this.Contents
+            Name = this.Name
+            Type = this.Type
+        }
+
+and CliValueType =
+    private
+        {
+            _Fields : CliConcreteField list
+            Layout : Layout
+            /// We track dependency orderings between updates to overlapping fields with a monotonically increasing
+            /// timestamp.
+            NextTimestamp : uint64
+        }
+
+    static member private ComputeConcreteFields (layout : Layout) (fields : CliField list) : CliConcreteField list =
+        // Minimum size only matters for `sizeof` computation
+        let _minimumSize, packingSize =
+            match layout with
+            | Layout.Custom (size = size ; packingSize = packing) ->
+                size, if packing = 0 then DEFAULT_STRUCT_ALIGNMENT else packing
+            | Layout.Default -> 0, DEFAULT_STRUCT_ALIGNMENT
+
+        let seqFields, nonSeqFields =
+            fields |> List.partition (fun field -> field.Offset.IsNone)
+
+        match seqFields, nonSeqFields with
+        | [], [] -> []
+        | _ :: _, [] ->
+            // Sequential layout: compute offsets respecting alignment
+            let _, concreteFields =
+                ((0, []), seqFields)
+                ||> List.fold (fun (currentOffset, acc) field ->
+                    let size = CliType.SizeOf field.Contents
+                    let alignmentCap = min size.Alignment packingSize
+                    let error = currentOffset % alignmentCap
+
+                    let alignedOffset =
+                        if error > 0 then
+                            currentOffset + (alignmentCap - error)
+                        else
+                            currentOffset
+
+                    let concreteField =
+                        {
+                            Name = field.Name
+                            Contents = field.Contents
+                            Offset = alignedOffset
+                            Size = size.Size
+                            Alignment = size.Alignment
+                            ConfiguredOffset = field.Offset
+                            EditedAtTime = 0UL
+                            Type = field.Type
+                        }
+
+                    alignedOffset + size.Size, concreteField :: acc
+                )
+
+            List.rev concreteFields
+
+        | [], _ :: _ ->
+            // Explicit layout: use provided offsets
+            nonSeqFields
+            |> List.map (fun field ->
+                let size = CliType.SizeOf field.Contents
+
+                {
+                    Name = field.Name
+                    Contents = field.Contents
+                    Offset = field.Offset.Value
+                    Size = size.Size
+                    Alignment = size.Alignment
+                    ConfiguredOffset = field.Offset
+                    EditedAtTime = 0UL
+                    Type = field.Type
+                }
+            )
+
+        | _ :: _, _ :: _ -> failwith "unexpectedly mixed explicit and automatic layout of fields"
+
+    static member ToBytes (cvt : CliValueType) : byte[] =
+        let bytes = Array.zeroCreate<byte> (CliValueType.SizeOf(cvt).Size)
+
+        cvt._Fields
+        |> List.sortBy _.EditedAtTime
+        |> List.iter (fun candidateField ->
+            let fieldBytes : byte[] = CliType.ToBytes candidateField.Contents
+
+            for i = 0 to candidateField.Size - 1 do
+                bytes.[candidateField.Offset + i] <- fieldBytes.[i]
+        )
+
+        bytes
+
+    static member OfFields (layout : Layout) (f : CliField list) : CliValueType =
+        let fields = CliValueType.ComputeConcreteFields layout f
+
+        {
+            _Fields = fields
+            Layout = layout
+            NextTimestamp = 1UL
+        }
+
+    static member AddField (f : CliField) (vt : CliValueType) : CliValueType =
+        // Recompute all fields with the new one added
+        // TODO: the existence of this function at all is rather dubious, but it's there
+        // at the moment to support delegate types.
+        // The whole function is just a bodge and it will hopefully go away soon; I just don't know how.
+        let prevFields = vt._Fields |> List.map (fun f -> f.Name, f) |> Map.ofList
+
+        let allFields =
+            f
+            :: (vt._Fields
+                |> List.map (fun cf ->
+                    {
+                        Name = cf.Name
+                        Contents = cf.Contents
+                        Offset =
+                            match vt.Layout with
+                            | Layout.Default -> None
+                            | Layout.Custom _ -> Some cf.Offset
+                        Type = cf.Type
+                    }
+                ))
+
+        let newFields =
+            CliValueType.ComputeConcreteFields vt.Layout allFields
+            |> List.map (fun field ->
+                match Map.tryFind field.Name prevFields with
+                | Some prev ->
+                    { field with
+                        EditedAtTime = prev.EditedAtTime
+                    }
+                | None ->
+                    { field with
+                        EditedAtTime = vt.NextTimestamp
+                    }
+            )
+
+        {
+            _Fields = newFields
+            Layout = vt.Layout
+            NextTimestamp = vt.NextTimestamp + 1UL
+        }
+
+    /// Returns the offset and size.
+    static member GetFieldLayout (field : string) (cvt : CliValueType) : int * int =
+        let targetField =
+            cvt._Fields
+            |> List.tryFind (fun f -> f.Name = field)
+            |> Option.defaultWith (fun () -> failwithf $"Field '%s{field}' not found")
+
+        targetField.Offset, targetField.Size
+
+    // TODO: use DereferenceFieldAt for the implementation.
+    // We should eventually be able to dereference an arbitrary field of a struct
+    // as though it were any other field of any other type, to accommodate Unsafe.As.
+    static member DereferenceField (field : string) (cvt : CliValueType) : CliType =
+        let targetField =
+            cvt._Fields
+            |> List.tryFind (fun f -> f.Name = field)
+            |> Option.defaultWith (fun () -> failwithf $"Field '%s{field}' not found")
+
+        // Identify all fields that overlap with the target field's memory range
+        let targetStart = targetField.Offset
+        let targetEnd = targetField.Offset + targetField.Size
+
+        let affectedFields =
+            cvt._Fields
+            |> List.filter (fun f ->
+                let fieldStart = f.Offset
+                let fieldEnd = f.Offset + f.Size
+                // Fields overlap if their ranges intersect
+                fieldStart < targetEnd && targetStart < fieldEnd
+            )
+
+        match affectedFields with
+        | [] -> failwith "unexpectedly didn't dereference a field"
+        | [ f ] -> f.Contents
+        | fields ->
+            let bytes = CliValueType.ToBytes cvt
+
+            let fieldBytes =
+                bytes.[targetField.Offset .. targetField.Offset + targetField.Size - 1]
+
+            CliType.OfBytesAsType targetField.Type fieldBytes
+
+    static member FieldsAt (offset : int) (cvt : CliValueType) : CliConcreteField list =
+        cvt._Fields |> List.filter (fun f -> f.Offset = offset)
+
+    static member DereferenceFieldAt (offset : int) (size : int) (cvt : CliValueType) : CliType =
+        let targetField =
+            CliValueType.FieldsAt offset cvt |> List.tryFind (fun f -> f.Size = size)
+
+        match targetField with
+        | None -> failwith "TODO: couldn't find the field"
+        | Some f -> f.Contents
+
+    static member SizeOf (vt : CliValueType) : SizeofResult =
+        let minimumSize, packingSize =
+            match vt.Layout with
+            | Layout.Custom (size = size ; packingSize = packing) ->
+                size, if packing = 0 then DEFAULT_STRUCT_ALIGNMENT else packing
+            | Layout.Default -> 0, DEFAULT_STRUCT_ALIGNMENT
+
+        if vt._Fields.IsEmpty then
+            {
+                Size = minimumSize
+                Alignment = 1
+            }
+        else
+            // Now we can just use the precomputed offsets and sizes
+            let finalOffset, alignment =
+                vt._Fields
+                |> List.fold
+                    (fun (maxEnd, maxAlign) field ->
+                        let fieldEnd = field.Offset + field.Size
+                        let alignmentCap = min field.Alignment packingSize
+                        max maxEnd fieldEnd, max maxAlign alignmentCap
+                    )
+                    (0, 0)
+
+            let error = finalOffset % alignment
+
+            let size =
+                if error = 0 then
+                    finalOffset
+                else
+                    finalOffset + (alignment - error)
+
+            {
+                Size = max size minimumSize
+                Alignment = alignment
+            }
+
+    /// Sets the value of the specified field, *without* touching any overlapping fields.
+    /// `DereferenceField` handles resolving conflicts between overlapping fields.
+    static member WithFieldSet (field : string) (value : CliType) (cvt : CliValueType) : CliValueType =
+        {
+            Layout = cvt.Layout
+            _Fields =
+                cvt._Fields
+                |> List.replaceWhere (fun f ->
+                    if f.Name = field then
+                        { f with
+                            Contents = value
+                            EditedAtTime = cvt.NextTimestamp
+                        }
+                        |> Some
+                    else
+                        None
+                )
+            NextTimestamp = cvt.NextTimestamp + 1UL
+        }
+
+    /// To facilitate bodges. This function absolutely should not exist.
+    static member TryExactlyOneField (cvt : CliValueType) : CliField option =
+        match cvt._Fields with
+        | [] -> None
+        | [ x ] ->
+            if x.Offset = 0 then
+                Some (CliConcreteField.ToCliField x)
+            else
+                None
+        | _ -> None
+
+    /// To facilitate bodges. This function absolutely should not exist.
+    static member TrySequentialFields (cvt : CliValueType) : CliField list option =
+        let isNone, isSome =
+            cvt._Fields |> List.partition (fun field -> field.ConfiguredOffset.IsNone)
+
+        match isSome with
+        | [] -> Some (isNone |> List.map CliConcreteField.ToCliField)
+        | [ field ] when field.ConfiguredOffset = Some 0 -> Some [ CliConcreteField.ToCliField field ]
+        | _ -> None
 
 type CliTypeResolutionResult =
     | Resolved of CliType
@@ -165,8 +534,22 @@ type CliTypeResolutionResult =
 
 [<RequireQualifiedAccess>]
 module CliType =
+    /// In fact any non-zero value will do for True, but we'll use 1
+    let ofBool (b : bool) : CliType = CliType.Bool (if b then 1uy else 0uy)
 
-    let zeroOfPrimitive (primitiveType : PrimitiveType) : CliType =
+    let ofChar (c : char) : CliType =
+        CliType.Char (byte (int c / 256), byte (int c % 256))
+
+    let ofManagedObject (ptr : ManagedHeapAddress) : CliType = CliType.ObjectRef (Some ptr)
+
+    let sizeOf (ty : CliType) : int = CliType.SizeOf(ty).Size
+
+    let zeroOfPrimitive
+        (concreteTypes : AllConcreteTypes)
+        (corelib : BaseClassTypes<DumpedAssembly>)
+        (primitiveType : PrimitiveType)
+        : CliType
+        =
         match primitiveType with
         | PrimitiveType.Boolean -> CliType.Bool 0uy
         | PrimitiveType.Char -> CliType.Char (0uy, 0uy)
@@ -186,97 +569,301 @@ module CliType =
         | PrimitiveType.Double -> CliType.Numeric (CliNumericType.Float64 0.0)
         | PrimitiveType.String -> CliType.ObjectRef None
         | PrimitiveType.TypedReference -> failwith "todo"
-        | PrimitiveType.IntPtr -> CliType.RuntimePointer (CliRuntimePointer.Managed CliRuntimePointerSource.Null)
-        | PrimitiveType.UIntPtr -> CliType.RuntimePointer (CliRuntimePointer.Managed CliRuntimePointerSource.Null)
+        | PrimitiveType.IntPtr ->
+            {
+                Name = "_value"
+                Contents =
+                    CliType.Numeric (
+                        CliNumericType.NativeInt (NativeIntSource.ManagedPointer ManagedPointerSource.Null)
+                    )
+                Offset = None
+                Type =
+                    AllConcreteTypes.findExistingConcreteType
+                        concreteTypes
+                        (corelib.IntPtr.Assembly, corelib.IntPtr.Namespace, corelib.IntPtr.Name, ImmutableArray.Empty)
+                    |> Option.get
+            }
+            |> List.singleton
+            |> CliValueType.OfFields Layout.Default
+            |> CliType.ValueType
+        | PrimitiveType.UIntPtr ->
+            {
+                Name = "_value"
+                Contents =
+                    CliType.Numeric (
+                        CliNumericType.NativeInt (NativeIntSource.ManagedPointer ManagedPointerSource.Null)
+                    )
+                Offset = None
+                Type =
+                    AllConcreteTypes.findExistingConcreteType
+                        concreteTypes
+                        (corelib.UIntPtr.Assembly, corelib.UIntPtr.Namespace, corelib.UIntPtr.Name, ImmutableArray.Empty)
+                    |> Option.get
+            }
+            |> List.singleton
+            |> CliValueType.OfFields Layout.Default
+            |> CliType.ValueType
         | PrimitiveType.Object -> CliType.ObjectRef None
 
     let rec zeroOf
+        (concreteTypes : AllConcreteTypes)
         (assemblies : ImmutableDictionary<string, DumpedAssembly>)
         (corelib : BaseClassTypes<DumpedAssembly>)
-        (assy : DumpedAssembly)
-        (typeGenerics : TypeDefn ImmutableArray option)
-        (methodGenerics : TypeDefn ImmutableArray option)
-        (ty : TypeDefn)
-        : CliTypeResolutionResult
+        (handle : ConcreteTypeHandle)
+        : CliType * AllConcreteTypes
         =
-        match ty with
-        | TypeDefn.PrimitiveType primitiveType -> CliTypeResolutionResult.Resolved (zeroOfPrimitive primitiveType)
-        | TypeDefn.Array _ -> CliType.ObjectRef None |> CliTypeResolutionResult.Resolved
-        | TypeDefn.Pinned typeDefn -> failwith "todo"
-        | TypeDefn.Pointer _ ->
-            CliType.RuntimePointer (CliRuntimePointer.Managed CliRuntimePointerSource.Null)
-            |> CliTypeResolutionResult.Resolved
-        | TypeDefn.Byref _ -> CliType.ObjectRef None |> CliTypeResolutionResult.Resolved
-        | TypeDefn.OneDimensionalArrayLowerBoundZero _ -> CliType.ObjectRef None |> CliTypeResolutionResult.Resolved
-        | TypeDefn.Modified (original, afterMod, modificationRequired) -> failwith "todo"
-        | TypeDefn.FromReference (typeRef, signatureTypeKind) ->
-            match signatureTypeKind with
-            | SignatureTypeKind.Unknown -> failwith "todo"
-            | SignatureTypeKind.ValueType ->
-                match Assembly.resolveTypeRef assemblies assy typeRef typeGenerics with
-                | TypeResolutionResult.Resolved (sourceAssy, ty) ->
-                    let fields =
-                        ty.Fields
-                        |> List.filter (fun field -> not (field.Attributes.HasFlag FieldAttributes.Static))
-                        |> List.map (fun fi ->
-                            match zeroOf assemblies corelib sourceAssy typeGenerics methodGenerics fi.Signature with
-                            | CliTypeResolutionResult.Resolved ty -> Ok ty
-                            | CliTypeResolutionResult.FirstLoad a -> Error a
-                        )
-                        |> Result.allOkOrError
+        zeroOfWithVisited concreteTypes assemblies corelib handle Set.empty
 
-                    match fields with
-                    | Error (_, []) -> failwith "logic error"
-                    | Error (_, f :: _) -> CliTypeResolutionResult.FirstLoad f
-                    | Ok fields -> CliType.ValueType fields |> CliTypeResolutionResult.Resolved
-                | TypeResolutionResult.FirstLoadAssy assy -> CliTypeResolutionResult.FirstLoad assy
-            | SignatureTypeKind.Class -> CliType.ObjectRef None |> CliTypeResolutionResult.Resolved
-            | _ -> raise (ArgumentOutOfRangeException ())
-        | TypeDefn.FromDefinition (typeDefinitionHandle, _, signatureTypeKind) ->
-            let typeDef = assy.TypeDefs.[typeDefinitionHandle.Get]
+    and zeroOfWithVisited
+        (concreteTypes : AllConcreteTypes)
+        (assemblies : ImmutableDictionary<string, DumpedAssembly>)
+        (corelib : BaseClassTypes<DumpedAssembly>)
+        (handle : ConcreteTypeHandle)
+        (visited : Set<ConcreteTypeHandle>)
+        : CliType * AllConcreteTypes
+        =
 
-            if typeDef = corelib.Int32 then
-                zeroOfPrimitive PrimitiveType.Int32 |> CliTypeResolutionResult.Resolved
-            elif typeDef = corelib.Int64 then
-                zeroOfPrimitive PrimitiveType.Int64 |> CliTypeResolutionResult.Resolved
-            elif typeDef = corelib.UInt32 then
-                zeroOfPrimitive PrimitiveType.UInt32 |> CliTypeResolutionResult.Resolved
-            elif typeDef = corelib.UInt64 then
-                zeroOfPrimitive PrimitiveType.UInt64 |> CliTypeResolutionResult.Resolved
+        // Handle constructed types first
+        match handle with
+        | ConcreteTypeHandle.Byref _ ->
+            // Byref types are managed references - the zero value is a null reference
+            CliType.RuntimePointer (CliRuntimePointer.Managed ManagedPointerSource.Null), concreteTypes
+
+        | ConcreteTypeHandle.Pointer _ ->
+            // Pointer types are unmanaged pointers - the zero value is a null pointer
+            CliType.RuntimePointer (CliRuntimePointer.Managed ManagedPointerSource.Null), concreteTypes
+
+        | ConcreteTypeHandle.Concrete _ ->
+            // This is a concrete type - look it up in the mapping
+            let concreteType =
+                match AllConcreteTypes.lookup handle concreteTypes with
+                | Some ct -> ct
+                | None -> failwithf "ConcreteTypeHandle %A not found in AllConcreteTypes" handle
+
+            // Get the type definition from the assembly
+            let assembly = assemblies.[concreteType.Assembly.FullName]
+            let typeDef = assembly.TypeDefs.[concreteType.Definition.Get]
+
+            // Check if it's a primitive type by comparing with corelib types FIRST
+            if
+                concreteType.Assembly.FullName = corelib.Corelib.Name.FullName
+                && concreteType.Generics.IsEmpty
+            then
+                // Check against known primitive types
+                if TypeInfo.NominallyEqual typeDef corelib.Boolean then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Boolean, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Char then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Char, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.SByte then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.SByte, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Byte then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Byte, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Int16 then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Int16, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.UInt16 then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.UInt16, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Int32 then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Int32, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.UInt32 then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.UInt32, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Int64 then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Int64, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.UInt64 then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.UInt64, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Single then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Single, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Double then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Double, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.String then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.String, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Object then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.Object, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.IntPtr then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.IntPtr, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.UIntPtr then
+                    zeroOfPrimitive concreteTypes corelib PrimitiveType.UIntPtr, concreteTypes
+                elif TypeInfo.NominallyEqual typeDef corelib.Array then
+                    // Arrays are reference types
+                    CliType.ObjectRef None, concreteTypes
+                else if
+
+                    // Not a known primitive, now check for cycles
+                    Set.contains handle visited
+                then
+                    // We're in a cycle - return a default zero value for the type
+                    // Value types can't be self-referential unless they are specifically known to the
+                    // runtime - for example, System.Byte is a value type with a single field,
+                    // of type System.Byte.
+                    // Since we check for (nominal) equality against all such types in the first branch,
+                    // this code path is only hit with reference types.
+                    CliType.ObjectRef None, concreteTypes
+                else
+                    let visited = Set.add handle visited
+                    // Not a known primitive, check if it's a value type or reference type
+                    determineZeroForCustomType concreteTypes assemblies corelib handle concreteType typeDef visited
+            else if
+
+                // Not from corelib or has generics
+                concreteType.Assembly = corelib.Corelib.Name
+                && typeDef = corelib.Array
+                && concreteType.Generics.Length = 1
+            then
+                // This is an array type, so null is appropriate
+                CliType.ObjectRef None, concreteTypes
+            else if
+
+                // Custom type - now check for cycles
+                Set.contains handle visited
+            then
+                // We're in a cycle - return a default zero value for the type.
+                // Value types can't be self-referential unless they are specifically known to the
+                // runtime - for example, System.Byte is a value type with a single field,
+                // of type System.Byte.
+                // Since we check for (nominal) equality against all such types in the first branch,
+                // this code path is only hit with reference types.
+                CliType.ObjectRef None, concreteTypes
             else
-            // TODO: the rest
-            match signatureTypeKind with
-            | SignatureTypeKind.Unknown -> failwith "todo"
-            | SignatureTypeKind.ValueType ->
-                let fields =
-                    typeDef.Fields
-                    // oh lord, this is awfully ominous - I really don't want to store the statics here
-                    |> List.filter (fun field -> not (field.Attributes.HasFlag FieldAttributes.Static))
-                    |> List.map (fun fi ->
-                        match zeroOf assemblies corelib assy typeGenerics methodGenerics fi.Signature with
-                        | CliTypeResolutionResult.Resolved ty -> Ok ty
-                        | CliTypeResolutionResult.FirstLoad a -> Error a
-                    )
-                    |> Result.allOkOrError
+                let visited = Set.add handle visited
+                // Custom type - need to determine if it's a value type or reference type
+                determineZeroForCustomType concreteTypes assemblies corelib handle concreteType typeDef visited
 
-                match fields with
-                | Error (_, []) -> failwith "logic error"
-                | Error (_, f :: _) -> CliTypeResolutionResult.FirstLoad f
-                | Ok fields ->
+    and private determineZeroForCustomType
+        (concreteTypes : AllConcreteTypes)
+        (assemblies : ImmutableDictionary<string, DumpedAssembly>)
+        (corelib : BaseClassTypes<DumpedAssembly>)
+        (handle : ConcreteTypeHandle)
+        (concreteType : ConcreteType<ConcreteTypeHandle>)
+        (typeDef : WoofWare.PawPrint.TypeInfo<GenericParamFromMetadata, TypeDefn>)
+        (visited : Set<ConcreteTypeHandle>)
+        : CliType * AllConcreteTypes
+        =
 
-                CliType.ValueType fields |> CliTypeResolutionResult.Resolved
-            | SignatureTypeKind.Class -> CliType.ObjectRef None |> CliTypeResolutionResult.Resolved
-            | _ -> raise (ArgumentOutOfRangeException ())
-        | TypeDefn.GenericInstantiation (generic, args) ->
-            zeroOf assemblies corelib assy (Some args) methodGenerics generic
-        | TypeDefn.FunctionPointer typeMethodSignature -> failwith "todo"
-        | TypeDefn.GenericTypeParameter index ->
-            // TODO: can generics depend on other generics? presumably, so we pass the array down again
-            match typeGenerics with
-            | None -> failwith "asked for a type parameter of generic type, but no generics in scope"
-            | Some generics -> zeroOf assemblies corelib assy (Some generics) methodGenerics generics.[index]
-        | TypeDefn.GenericMethodParameter index ->
-            match methodGenerics with
-            | None -> failwith "asked for a method parameter of generic type, but no generics in scope"
-            | Some generics -> zeroOf assemblies corelib assy typeGenerics (Some generics) generics.[index]
-        | TypeDefn.Void -> failwith "should never construct an element of type Void"
+        // Determine if this is a value type by checking inheritance
+        let isValueType =
+            match DumpedAssembly.resolveBaseType corelib assemblies typeDef.Assembly typeDef.BaseType with
+            | ResolvedBaseType.ValueType
+            | ResolvedBaseType.Enum -> true
+            | ResolvedBaseType.Delegate -> false // Delegates are reference types
+            | ResolvedBaseType.Object -> false
+
+        if isValueType then
+            // It's a value type - need to create zero values for all non-static fields
+            let mutable currentConcreteTypes = concreteTypes
+
+            let vt =
+                typeDef.Fields
+                |> List.filter (fun field -> not (field.Attributes.HasFlag FieldAttributes.Static))
+                |> List.map (fun field ->
+                    // Need to concretize the field type with the concrete type's generics
+                    let fieldTypeDefn = field.Signature
+
+                    let fieldHandle, updatedConcreteTypes =
+                        concretizeFieldType currentConcreteTypes assemblies corelib concreteType fieldTypeDefn
+
+                    currentConcreteTypes <- updatedConcreteTypes
+
+                    let fieldZero, updatedConcreteTypes2 =
+                        zeroOfWithVisited currentConcreteTypes assemblies corelib fieldHandle visited
+
+                    currentConcreteTypes <- updatedConcreteTypes2
+
+                    {
+                        Name = field.Name
+                        Contents = fieldZero
+                        Offset = field.Offset
+                        Type = fieldHandle
+                    }
+                )
+                |> CliValueType.OfFields typeDef.Layout
+
+            CliType.ValueType vt, currentConcreteTypes
+        else
+            // It's a reference type
+            CliType.ObjectRef None, concreteTypes
+
+    and private concretizeFieldType
+        (concreteTypes : AllConcreteTypes)
+        (assemblies : ImmutableDictionary<string, DumpedAssembly>)
+        (corelib : BaseClassTypes<DumpedAssembly>)
+        (declaringType : ConcreteType<ConcreteTypeHandle>)
+        (fieldType : TypeDefn)
+        : ConcreteTypeHandle * AllConcreteTypes
+        =
+
+        // Create a concretization context
+        let ctx =
+            {
+                TypeConcretization.ConcretizationContext.InProgress = ImmutableDictionary.Empty
+                TypeConcretization.ConcretizationContext.ConcreteTypes = concreteTypes
+                TypeConcretization.ConcretizationContext.LoadedAssemblies = assemblies
+                TypeConcretization.ConcretizationContext.BaseTypes = corelib
+            }
+
+        // The field type might reference generic parameters of the declaring type
+        let methodGenerics = ImmutableArray.Empty // Fields don't have method generics
+
+        let loadAssembly =
+            { new IAssemblyLoad with
+                member _.LoadAssembly loaded assyName ref =
+                    match loaded.TryGetValue assyName.FullName with
+                    | true, currentAssy ->
+                        let targetAssyRef = currentAssy.AssemblyReferences.[ref]
+
+                        match loaded.TryGetValue targetAssyRef.Name.FullName with
+                        | true, targetAssy -> loaded, targetAssy
+                        | false, _ ->
+                            failwithf
+                                "Assembly %s not loaded when trying to resolve reference"
+                                targetAssyRef.Name.FullName
+                    | false, _ ->
+                        failwithf "Current assembly %s not loaded when trying to resolve reference" assyName.FullName
+            }
+
+        let handle, newCtx =
+            TypeConcretization.concretizeType
+                ctx
+                loadAssembly
+                declaringType.Assembly
+                declaringType.Generics
+                methodGenerics
+                fieldType
+
+        handle, newCtx.ConcreteTypes
+
+    let withFieldSet (field : string) (value : CliType) (c : CliType) : CliType =
+        match c with
+        | CliType.Numeric cliNumericType -> failwith "todo"
+        | CliType.Bool b -> failwith "todo"
+        | CliType.Char (high, low) -> failwith "todo"
+        | CliType.ObjectRef managedHeapAddressOption -> failwith "todo"
+        | CliType.RuntimePointer cliRuntimePointer -> failwith "todo"
+        | CliType.ValueType cvt -> CliValueType.WithFieldSet field value cvt |> CliType.ValueType
+
+    let getField (field : string) (value : CliType) : CliType =
+        match value with
+        | CliType.Numeric cliNumericType -> failwith "todo"
+        | CliType.Bool b -> failwith "todo"
+        | CliType.Char (high, low) -> failwith "todo"
+        | CliType.ObjectRef managedHeapAddressOption -> failwith "todo"
+        | CliType.RuntimePointer cliRuntimePointer -> failwith "todo"
+        | CliType.ValueType cvt -> CliValueType.DereferenceField field cvt
+
+    /// Returns the offset and size.
+    let getFieldLayout (field : string) (value : CliType) : int * int =
+        match value with
+        | CliType.Numeric cliNumericType -> failwith "todo"
+        | CliType.Bool b -> failwith "todo"
+        | CliType.Char (high, low) -> failwith "todo"
+        | CliType.ObjectRef managedHeapAddressOption -> failwith "todo"
+        | CliType.RuntimePointer cliRuntimePointer -> failwith "todo"
+        | CliType.ValueType cvt -> CliValueType.GetFieldLayout field cvt
+
+    /// Returns None if there isn't *exactly* one field that starts there. This rules out some valid programs.
+    let getFieldAt (offset : int) (value : CliType) : CliConcreteField option =
+        match value with
+        | CliType.Numeric cliNumericType -> failwith "todo"
+        | CliType.Bool b -> failwith "todo"
+        | CliType.Char (high, low) -> failwith "todo"
+        | CliType.ObjectRef managedHeapAddressOption -> failwith "todo"
+        | CliType.RuntimePointer cliRuntimePointer -> failwith "todo"
+        | CliType.ValueType cvt -> CliValueType.FieldsAt offset cvt |> List.tryExactlyOne

WoofWare.PawPrint/BinaryArithmetic.fs

@@ -0,0 +1,274 @@
+namespace WoofWare.PawPrint
+
+#nowarn "42"
+
+type IArithmeticOperation =
+    abstract Int32Int32 : int32 -> int32 -> int32
+    abstract Int32NativeInt : int32 -> nativeint -> nativeint
+    abstract NativeIntInt32 : nativeint -> int32 -> nativeint
+    abstract Int64Int64 : int64 -> int64 -> int64
+    abstract FloatFloat : float -> float -> float
+    abstract NativeIntNativeInt : nativeint -> nativeint -> nativeint
+    abstract Int32ManagedPtr : IlMachineState -> int32 -> ManagedPointerSource -> Choice<ManagedPointerSource, int>
+    abstract ManagedPtrInt32 : IlMachineState -> ManagedPointerSource -> int32 -> Choice<ManagedPointerSource, int>
+
+    abstract ManagedPtrManagedPtr :
+        IlMachineState -> ManagedPointerSource -> ManagedPointerSource -> Choice<ManagedPointerSource, nativeint>
+
+    abstract Name : string
+
+[<RequireQualifiedAccess>]
+module ArithmeticOperation =
+    let private addInt32ManagedPtr state v ptr =
+        match ptr with
+        | LocalVariable (sourceThread, methodFrame, whichVar) -> failwith "refusing to add to a local variable address"
+        | Argument (sourceThread, methodFrame, whichVar) -> failwith "refusing to add to an argument address"
+        | Heap managedHeapAddress -> failwith "refusing to add to a heap address"
+        | ArrayIndex (arr, index) -> failwith "TODO: arrays"
+        | Field (src, fieldName) ->
+            let obj = IlMachineState.dereferencePointer state src
+            let offset, _ = CliType.getFieldLayout fieldName obj
+
+            match CliType.getFieldAt (offset + v) obj with
+            | None -> failwith "TODO: couldn't identify field at offset"
+            | Some field ->
+                ManagedPointerSource.Field (src, CliConcreteField.ToCliField(field).Name)
+                |> Choice1Of2
+        | Null -> Choice2Of2 v
+        | InterpretedAsType (managedPointerSource, concreteType) -> failwith "todo"
+
+    let private mulInt32ManagedPtr (state : IlMachineState) v ptr =
+        if v = 0 then
+            Choice2Of2 0
+        elif v = 1 then
+            Choice1Of2 ptr
+        else
+
+        match ptr with
+        | ManagedPointerSource.Null -> Choice2Of2 0
+        | _ -> failwith "refusing to multiply pointers"
+
+    let add =
+        { new IArithmeticOperation with
+            member _.Int32Int32 a b = (# "add" a b : int32 #)
+            member _.Int64Int64 a b = (# "add" a b : int64 #)
+            member _.FloatFloat a b = (# "add" a b : float #)
+            member _.NativeIntNativeInt a b = (# "add" a b : nativeint #)
+            member _.Int32NativeInt a b = (# "add" a b : nativeint #)
+            member _.NativeIntInt32 a b = (# "add" a b : nativeint #)
+
+            member _.ManagedPtrManagedPtr _ ptr1 ptr2 =
+                match ptr1, ptr2 with
+                | ManagedPointerSource.Null, _ -> Choice1Of2 ptr2
+                | _, ManagedPointerSource.Null -> Choice1Of2 ptr1
+                | _, _ -> failwith "refusing to add two managed pointers"
+
+            member _.Int32ManagedPtr state val1 ptr2 = addInt32ManagedPtr state val1 ptr2
+            member _.ManagedPtrInt32 state ptr1 val2 = addInt32ManagedPtr state val2 ptr1
+
+            member _.Name = "add"
+        }
+
+    let sub =
+        { new IArithmeticOperation with
+            member _.Int32Int32 a b = (# "sub" a b : int32 #)
+            member _.Int64Int64 a b = (# "sub" a b : int64 #)
+            member _.FloatFloat a b = (# "sub" a b : float #)
+            member _.NativeIntNativeInt a b = (# "sub" a b : nativeint #)
+            member _.Int32NativeInt a b = (# "sub" a b : nativeint #)
+            member _.NativeIntInt32 a b = (# "sub" a b : nativeint #)
+
+            member _.ManagedPtrManagedPtr state ptr1 ptr2 =
+                match ptr1, ptr2 with
+                | ptr1, ManagedPointerSource.Null -> Choice1Of2 ptr1
+                | ManagedPointerSource.Null, _ -> failwith "refusing to create negative pointer"
+                | ManagedPointerSource.ArrayIndex (arr1, index1), ManagedPointerSource.ArrayIndex (arr2, index2) ->
+                    if arr1 <> arr2 then
+                        failwith "refusing to operate on pointers to different arrays"
+
+                    (index1 - index2) |> nativeint |> Choice2Of2
+                | ManagedPointerSource.ArrayIndex _, _ -> failwith $"refusing to operate on array index ptr vs %O{ptr2}"
+                | ManagedPointerSource.Argument _, _
+                | _, ManagedPointerSource.Argument _ ->
+                    failwith $"refusing to operate on pointers to arguments: %O{ptr1} and %O{ptr2}"
+                | ManagedPointerSource.Field (obj1, fieldName1), ManagedPointerSource.Field (obj2, fieldName2) ->
+                    if obj1 <> obj2 then
+                        failwith "refusing to operate on field pointers in different objects"
+
+                    let obj = IlMachineState.dereferencePointer state obj1
+
+                    let offset1, _ = CliType.getFieldLayout fieldName1 obj
+                    let offset2, _ = CliType.getFieldLayout fieldName2 obj
+
+                    (offset1 - offset2) |> nativeint |> Choice2Of2
+                | _, _ -> failwith "TODO"
+
+            member _.Int32ManagedPtr state val1 ptr2 =
+                match ptr2 with
+                | ManagedPointerSource.Null -> Choice2Of2 val1
+                | _ -> failwith "refusing to subtract a pointer"
+
+            member _.ManagedPtrInt32 state ptr1 val2 = failwith "TODO: subtract from pointer"
+
+            member _.Name = "sub"
+        }
+
+    let mul =
+        { new IArithmeticOperation with
+            member _.Int32Int32 a b = (# "mul" a b : int32 #)
+            member _.Int64Int64 a b = (# "mul" a b : int64 #)
+            member _.FloatFloat a b = (# "mul" a b : float #)
+            member _.NativeIntNativeInt a b = (# "mul" a b : nativeint #)
+            member _.Int32NativeInt a b = (# "mul" a b : nativeint #)
+            member _.NativeIntInt32 a b = (# "mul" a b : nativeint #)
+
+            member _.ManagedPtrManagedPtr _ ptr1 ptr2 =
+                match ptr1, ptr2 with
+                | ManagedPointerSource.Null, _ -> Choice2Of2 (nativeint 0)
+                | _, ManagedPointerSource.Null -> Choice2Of2 (nativeint 0)
+                | _, _ -> failwith "refusing to multiply two managed pointers"
+
+            member _.Int32ManagedPtr state a ptr = mulInt32ManagedPtr state a ptr
+            member _.ManagedPtrInt32 state ptr a = mulInt32ManagedPtr state a ptr
+
+            member _.Name = "mul"
+        }
+
+    let rem =
+        { new IArithmeticOperation with
+            member _.Int32Int32 a b = (# "rem" a b : int32 #)
+            member _.Int64Int64 a b = (# "rem" a b : int64 #)
+            member _.FloatFloat a b = (# "rem" a b : float #)
+            member _.NativeIntNativeInt a b = (# "rem" a b : nativeint #)
+            member _.Int32NativeInt a b = (# "rem" a b : nativeint #)
+            member _.NativeIntInt32 a b = (# "rem" a b : nativeint #)
+
+            member _.ManagedPtrManagedPtr _ ptr1 ptr2 = failwith "refusing to rem pointers"
+
+            member _.Int32ManagedPtr _ a ptr = failwith "refusing to rem pointer"
+
+            member _.ManagedPtrInt32 _ ptr a = failwith "refusing to rem pointer"
+
+            member _.Name = "mul"
+        }
+
+    let mulOvf =
+        { new IArithmeticOperation with
+            member _.Int32Int32 a b = (# "mul.ovf" a b : int32 #)
+            member _.Int64Int64 a b = (# "mul.ovf" a b : int64 #)
+            member _.FloatFloat a b = (# "mul.ovf" a b : float #)
+            member _.NativeIntNativeInt a b = (# "mul.ovf" a b : nativeint #)
+            member _.Int32NativeInt a b = (# "mul.ovf" a b : nativeint #)
+            member _.NativeIntInt32 a b = (# "mul.ovf" a b : nativeint #)
+
+            member _.ManagedPtrManagedPtr _ ptr1 ptr2 =
+                match ptr1, ptr2 with
+                | ManagedPointerSource.Null, _ -> Choice2Of2 (nativeint 0)
+                | _, ManagedPointerSource.Null -> Choice2Of2 (nativeint 0)
+                | _, _ -> failwith "refusing to multiply two managed pointers"
+
+            member _.Int32ManagedPtr state a ptr = mulInt32ManagedPtr state a ptr
+            member _.ManagedPtrInt32 state a ptr = mulInt32ManagedPtr state ptr a
+
+            member _.Name = "mul_ovf"
+        }
+
+    let div =
+        { new IArithmeticOperation with
+            member _.Int32Int32 a b = (# "div" a b : int32 #)
+            member _.Int64Int64 a b = (# "div" a b : int64 #)
+            member _.FloatFloat a b = (# "div" a b : float #)
+            member _.NativeIntNativeInt a b = (# "div" a b : nativeint #)
+            member _.Int32NativeInt a b = (# "div" a b : nativeint #)
+            member _.NativeIntInt32 a b = (# "div" a b : nativeint #)
+
+            member _.ManagedPtrManagedPtr _ ptr1 ptr2 =
+                match ptr1, ptr2 with
+                | ManagedPointerSource.Null, _ -> Choice2Of2 (nativeint 0)
+                | _, _ -> failwith "refusing to divide two managed pointers"
+
+            member _.Int32ManagedPtr _ a ptr =
+                if a = 0 then
+                    Choice2Of2 0
+                else
+                    failwith "refusing to divide pointers"
+
+            member _.ManagedPtrInt32 _ ptr a =
+                if a = 1 then
+                    Choice1Of2 ptr
+                else
+                    failwith "refusing to divide a pointer"
+
+            member _.Name = "div"
+        }
+
+[<RequireQualifiedAccess>]
+module BinaryArithmetic =
+    let execute
+        (op : IArithmeticOperation)
+        (state : IlMachineState)
+        (val1 : EvalStackValue)
+        (val2 : EvalStackValue)
+        : EvalStackValue
+        =
+        // see table at https://learn.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.add?view=net-9.0
+        match val1, val2 with
+        | EvalStackValue.Int32 val1, EvalStackValue.Int32 val2 -> op.Int32Int32 val1 val2 |> EvalStackValue.Int32
+        | EvalStackValue.Int32 val1, EvalStackValue.NativeInt val2 ->
+            let val2 =
+                match val2 with
+                | NativeIntSource.Verbatim n -> nativeint<int64> n
+                | v -> failwith $"refusing to operate on non-verbatim native int %O{v}"
+
+            op.Int32NativeInt val1 val2
+            |> int64<nativeint>
+            |> NativeIntSource.Verbatim
+            |> EvalStackValue.NativeInt
+        | EvalStackValue.Int32 val1, EvalStackValue.ManagedPointer val2 ->
+            match op.Int32ManagedPtr state val1 val2 with
+            | Choice1Of2 v -> EvalStackValue.ManagedPointer v
+            | Choice2Of2 i -> EvalStackValue.Int32 i
+        | EvalStackValue.Int32 val1, EvalStackValue.ObjectRef val2 -> failwith "" |> EvalStackValue.ObjectRef
+        | EvalStackValue.Int64 val1, EvalStackValue.Int64 val2 -> op.Int64Int64 val1 val2 |> EvalStackValue.Int64
+        | EvalStackValue.NativeInt val1, EvalStackValue.Int32 val2 ->
+            let val1 =
+                match val1 with
+                | NativeIntSource.Verbatim n -> nativeint<int64> n
+                | v -> failwith $"refusing to operate on non-verbatim native int %O{v}"
+
+            op.NativeIntInt32 val1 val2
+            |> int64<nativeint>
+            |> NativeIntSource.Verbatim
+            |> EvalStackValue.NativeInt
+        | EvalStackValue.NativeInt val1, EvalStackValue.NativeInt val2 ->
+            let val1 =
+                match val1 with
+                | NativeIntSource.Verbatim n -> nativeint<int64> n
+                | v -> failwith $"refusing to operate on non-verbatim native int %O{v}"
+
+            let val2 =
+                match val2 with
+                | NativeIntSource.Verbatim n -> nativeint<int64> n
+                | v -> failwith $"refusing to operate on non-verbatim native int %O{v}"
+
+            op.NativeIntNativeInt val1 val2
+            |> int64<nativeint>
+            |> NativeIntSource.Verbatim
+            |> EvalStackValue.NativeInt
+        | EvalStackValue.NativeInt val1, EvalStackValue.ManagedPointer val2 ->
+            failwith "" |> EvalStackValue.ManagedPointer
+        | EvalStackValue.NativeInt val1, EvalStackValue.ObjectRef val2 -> failwith "" |> EvalStackValue.ObjectRef
+        | EvalStackValue.Float val1, EvalStackValue.Float val2 -> op.FloatFloat val1 val2 |> EvalStackValue.Float
+        | EvalStackValue.ManagedPointer val1, EvalStackValue.NativeInt val2 ->
+            failwith "" |> EvalStackValue.ManagedPointer
+        | EvalStackValue.ObjectRef val1, EvalStackValue.NativeInt val2 -> failwith "" |> EvalStackValue.ObjectRef
+        | EvalStackValue.ManagedPointer val1, EvalStackValue.Int32 val2 ->
+            match op.ManagedPtrInt32 state val1 val2 with
+            | Choice1Of2 result -> EvalStackValue.ManagedPointer result
+            | Choice2Of2 result -> EvalStackValue.NativeInt (NativeIntSource.Verbatim (int64<int32> result))
+        | EvalStackValue.ObjectRef val1, EvalStackValue.Int32 val2 -> failwith "" |> EvalStackValue.ObjectRef
+        | EvalStackValue.ManagedPointer val1, EvalStackValue.ManagedPointer val2 ->
+            match op.ManagedPtrManagedPtr state val1 val2 with
+            | Choice1Of2 result -> EvalStackValue.ManagedPointer result
+            | Choice2Of2 result -> EvalStackValue.NativeInt (NativeIntSource.Verbatim (int64<nativeint> result))
+        | val1, val2 -> failwith $"invalid %s{op.Name} operation: {val1} and {val2}"

WoofWare.PawPrint/Corelib.fs

@@ -1,5 +1,8 @@
 namespace WoofWare.PawPrint
 
+open System.Collections.Immutable
+open System.Reflection.Metadata
+
 [<RequireQualifiedAccess>]
 module Corelib =
 
@@ -114,6 +117,41 @@ module Corelib =
             |> Seq.choose (fun (KeyValue (_, v)) -> if v.Name = "RuntimeFieldHandle" then Some v else None)
             |> Seq.exactlyOne
 
+        let voidType =
+            corelib.TypeDefs
+            |> Seq.choose (fun (KeyValue (_, v)) -> if v.Name = "Void" then Some v else None)
+            |> Seq.exactlyOne
+
+        let typedReferenceType =
+            corelib.TypeDefs
+            |> Seq.choose (fun (KeyValue (_, v)) -> if v.Name = "TypedReference" then Some v else None)
+            |> Seq.exactlyOne
+
+        let intPtrType =
+            corelib.TypeDefs
+            |> Seq.choose (fun (KeyValue (_, v)) -> if v.Name = "IntPtr" then Some v else None)
+            |> Seq.exactlyOne
+
+        let uintPtrType =
+            corelib.TypeDefs
+            |> Seq.choose (fun (KeyValue (_, v)) -> if v.Name = "UIntPtr" then Some v else None)
+            |> Seq.exactlyOne
+
+        let runtimeFieldInfoStubType =
+            corelib.TypeDefs
+            |> Seq.choose (fun (KeyValue (_, v)) -> if v.Name = "RuntimeFieldInfoStub" then Some v else None)
+            |> Seq.exactlyOne
+
+        let runtimeFieldHandleInternalType =
+            corelib.TypeDefs
+            |> Seq.choose (fun (KeyValue (_, v)) ->
+                if v.Name = "RuntimeFieldHandleInternal" then
+                    Some v
+                else
+                    None
+            )
+            |> Seq.exactlyOne
+
         {
             Corelib = corelib
             String = stringType
@@ -137,5 +175,89 @@ module Corelib =
             RuntimeTypeHandle = runtimeTypeHandleType
             RuntimeMethodHandle = runtimeMethodHandleType
             RuntimeFieldHandle = runtimeFieldHandleType
+            RuntimeFieldInfoStub = runtimeFieldInfoStubType
+            RuntimeFieldHandleInternal = runtimeFieldHandleInternalType
             RuntimeType = runtimeTypeType
+            Void = voidType
+            TypedReference = typedReferenceType
+            IntPtr = intPtrType
+            UIntPtr = uintPtrType
         }
+
+    let concretizeAll
+        (loaded : ImmutableDictionary<string, DumpedAssembly>)
+        (bct : BaseClassTypes<DumpedAssembly>)
+        (t : AllConcreteTypes)
+        : AllConcreteTypes
+        =
+        let ctx =
+            {
+                TypeConcretization.ConcretizationContext.InProgress = ImmutableDictionary.Empty
+                TypeConcretization.ConcretizationContext.ConcreteTypes = t
+                TypeConcretization.ConcretizationContext.LoadedAssemblies = loaded
+                TypeConcretization.ConcretizationContext.BaseTypes = bct
+            }
+
+        let loader =
+            { new IAssemblyLoad with
+                member _.LoadAssembly _ _ _ =
+                    failwith "should have already loaded this assembly"
+            }
+
+        let tys =
+            [
+                bct.String
+                bct.Boolean
+                bct.Char
+                bct.SByte
+                bct.Byte
+                bct.Int16
+                bct.UInt16
+                bct.Int32
+                bct.UInt32
+                bct.Int64
+                bct.UInt64
+                bct.Single
+                bct.Double
+                bct.Array
+                bct.Enum
+                bct.ValueType
+                bct.DelegateType
+                bct.Object
+                bct.RuntimeTypeHandle
+                bct.RuntimeMethodHandle
+                bct.RuntimeFieldHandle
+                bct.RuntimeFieldInfoStub
+                bct.RuntimeFieldHandleInternal
+                bct.RuntimeType
+                bct.Void
+                bct.TypedReference
+                bct.IntPtr
+                bct.UIntPtr
+            ]
+
+        (ctx, tys)
+        ||> List.fold (fun ctx ty ->
+            let stk =
+                match DumpedAssembly.resolveBaseType ctx.BaseTypes ctx.LoadedAssemblies ty.Assembly ty.BaseType with
+                | ResolvedBaseType.Enum
+                | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
+                | ResolvedBaseType.Object
+                | ResolvedBaseType.Delegate -> SignatureTypeKind.Class
+
+            let _handle, ctx =
+                TypeConcretization.concretizeType
+                    ctx
+                    loader
+                    ty.Assembly
+                    ImmutableArray.Empty
+                    ImmutableArray.Empty
+                    (TypeDefn.FromDefinition (
+                        ComparableTypeDefinitionHandle.Make ty.TypeDefHandle,
+                        ty.Assembly.FullName,
+                        stk
+                    ))
+
+            ctx
+        )
+        |> _.ConcreteTypes

WoofWare.PawPrint/EvalStack.fs

@@ -1,5 +1,7 @@
 namespace WoofWare.PawPrint
 
+#nowarn "42"
+
 /// See I.12.3.2.1 for definition
 type EvalStackValue =
     | Int32 of int32
@@ -8,9 +10,8 @@ type EvalStackValue =
     | Float of float
     | ManagedPointer of ManagedPointerSource
     | ObjectRef of ManagedHeapAddress
-    // Fraser thinks this isn't really a thing in CoreCLR
-    // | TransientPointer of TransientPointerSource
-    | UserDefinedValueType of EvalStackValue list
+    /// This doesn't match what the CLR does in reality, but we can work out whatever we need from it.
+    | UserDefinedValueType of CliValueType
 
     override this.ToString () =
         match this with
@@ -20,9 +21,7 @@ type EvalStackValue =
         | EvalStackValue.Float f -> $"Float(%f{f})"
         | EvalStackValue.ManagedPointer managedPointerSource -> $"Pointer(%O{managedPointerSource})"
         | EvalStackValue.ObjectRef managedHeapAddress -> $"ObjectRef(%O{managedHeapAddress})"
-        | EvalStackValue.UserDefinedValueType evalStackValues ->
-            let desc = evalStackValues |> List.map string<EvalStackValue> |> String.concat " | "
-            $"Struct(%s{desc})"
+        | EvalStackValue.UserDefinedValueType evalStackValues -> $"Struct(%O{evalStackValues})"
 
 [<RequireQualifiedAccess>]
 module EvalStackValue =
@@ -50,6 +49,7 @@ module EvalStackValue =
                     failwith "todo"
             | NativeIntSource.ManagedPointer _ -> failwith "TODO"
             | NativeIntSource.FunctionPointer _ -> failwith "TODO"
+            | NativeIntSource.FieldHandlePtr _ -> failwith "TODO"
             | NativeIntSource.TypeHandlePtr _ -> failwith "TODO"
         | EvalStackValue.Float f -> failwith "todo"
         | EvalStackValue.ManagedPointer managedPointerSource ->
@@ -78,7 +78,14 @@ module EvalStackValue =
         match value with
         | EvalStackValue.Int32 i -> Some (int64<int> i)
         | EvalStackValue.Int64 i -> Some i
-        | EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+        | EvalStackValue.NativeInt src ->
+            match src with
+            | NativeIntSource.Verbatim int64 -> Some int64
+            | NativeIntSource.ManagedPointer ManagedPointerSource.Null -> Some 0L
+            | NativeIntSource.ManagedPointer _
+            | NativeIntSource.FunctionPointer _
+            | NativeIntSource.TypeHandlePtr _
+            | NativeIntSource.FieldHandlePtr _ -> failwith "refusing to convert pointer to int64"
         | EvalStackValue.Float f -> failwith "todo"
         | EvalStackValue.ManagedPointer managedPointerSource -> failwith "todo"
         | EvalStackValue.ObjectRef managedHeapAddress -> failwith "todo"
@@ -87,14 +94,60 @@ module EvalStackValue =
     /// Then truncates to int64.
     let convToUInt64 (value : EvalStackValue) : int64 option =
         match value with
-        | EvalStackValue.Int32 i -> if i >= 0 then Some (int64 i) else failwith "TODO"
-        | EvalStackValue.Int64 int64 -> failwith "todo"
+        | EvalStackValue.Int32 i -> Some (int64 (uint32 i))
+        | EvalStackValue.Int64 int64 -> Some int64
         | EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
         | EvalStackValue.Float f -> failwith "todo"
         | EvalStackValue.ManagedPointer managedPointerSource -> failwith "todo"
         | EvalStackValue.ObjectRef managedHeapAddress -> failwith "todo"
         | EvalStackValue.UserDefinedValueType evalStackValues -> failwith "todo"
 
+    /// Then truncates to int32.
+    let convToUInt8 (value : EvalStackValue) : int32 option =
+        match value with
+        | EvalStackValue.Int32 (i : int32) ->
+            let v = (# "conv.u1" i : uint8 #)
+            Some (int32<uint8> v)
+        | EvalStackValue.Int64 int64 ->
+            let v = (# "conv.u1" int64 : uint8 #)
+            Some (int32<uint8> v)
+        | EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+        | EvalStackValue.Float f -> failwith "todo"
+        | EvalStackValue.ManagedPointer managedPointerSource -> failwith "todo"
+        | EvalStackValue.ObjectRef managedHeapAddress -> failwith "todo"
+        | EvalStackValue.UserDefinedValueType evalStackValues -> failwith "todo"
+
+    let rec ofCliType (v : CliType) : EvalStackValue =
+        match v with
+        | CliType.Numeric numeric ->
+            match numeric with
+            | CliNumericType.Int32 i -> EvalStackValue.Int32 i
+            | CliNumericType.Int64 i -> EvalStackValue.Int64 i
+            | CliNumericType.NativeInt i -> EvalStackValue.NativeInt i
+            // Sign-extend types int8 and int16
+            // Zero-extend unsigned int8/unsigned int16
+            | CliNumericType.Int8 b -> int32<int8> b |> EvalStackValue.Int32
+            | CliNumericType.UInt8 b -> int32<uint8> b |> EvalStackValue.Int32
+            | CliNumericType.Int16 s -> int32<int16> s |> EvalStackValue.Int32
+            | CliNumericType.UInt16 s -> int32<uint16> s |> EvalStackValue.Int32
+            | CliNumericType.Float32 f -> EvalStackValue.Float (float<float32> f)
+            | CliNumericType.Float64 f -> EvalStackValue.Float f
+            | CliNumericType.NativeFloat f -> EvalStackValue.Float f
+        | CliType.ObjectRef i ->
+            match i with
+            | None -> EvalStackValue.ManagedPointer ManagedPointerSource.Null
+            | Some i -> EvalStackValue.ManagedPointer (ManagedPointerSource.Heap i)
+        // Zero-extend bool/char
+        | CliType.Bool b -> int32 b |> EvalStackValue.Int32
+        | CliType.Char (high, low) -> int32 high * 256 + int32 low |> EvalStackValue.Int32
+        | CliType.RuntimePointer ptr ->
+            match ptr with
+            | CliRuntimePointer.Verbatim ptrInt -> NativeIntSource.Verbatim ptrInt |> EvalStackValue.NativeInt
+            | CliRuntimePointer.FieldRegistryHandle ptrInt ->
+                NativeIntSource.FieldHandlePtr ptrInt |> EvalStackValue.NativeInt
+            | CliRuntimePointer.Managed ptr -> ptr |> EvalStackValue.ManagedPointer
+        | CliType.ValueType fields -> EvalStackValue.UserDefinedValueType fields
+
     let rec toCliTypeCoerced (target : CliType) (popped : EvalStackValue) : CliType =
         match target with
         | CliType.Numeric numeric ->
@@ -102,7 +155,13 @@ module EvalStackValue =
             | CliNumericType.Int32 _ ->
                 match popped with
                 | EvalStackValue.Int32 i -> CliType.Numeric (CliNumericType.Int32 i)
-                | EvalStackValue.UserDefinedValueType [ popped ] -> toCliTypeCoerced target popped
+                | EvalStackValue.UserDefinedValueType popped ->
+                    let popped = CliValueType.DereferenceFieldAt 0 4 popped
+                    // TODO: when we have a general mechanism to coerce CliTypes to each other,
+                    // do that
+                    match popped with
+                    | CliType.Numeric (CliNumericType.Int32 i) -> CliType.Numeric (CliNumericType.Int32 i)
+                    | _ -> failwith "TODO"
                 | i -> failwith $"TODO: %O{i}"
             | CliNumericType.Int64 _ ->
                 match popped with
@@ -112,17 +171,34 @@ module EvalStackValue =
                     | NativeIntSource.Verbatim i -> CliType.Numeric (CliNumericType.Int64 i)
                     | NativeIntSource.ManagedPointer ptr -> failwith "TODO"
                     | NativeIntSource.FunctionPointer f -> failwith $"TODO: {f}"
-                    // CliType.Numeric (CliNumericType.ProvenanceTrackedNativeInt64 f)
+                    | NativeIntSource.FieldHandlePtr f -> failwith $"TODO: {f}"
                     | NativeIntSource.TypeHandlePtr f -> failwith $"TODO: {f}"
                 // CliType.Numeric (CliNumericType.TypeHandlePtr f)
                 | i -> failwith $"TODO: %O{i}"
             | CliNumericType.NativeInt _ ->
                 match popped with
-                | EvalStackValue.NativeInt s -> CliNumericType.NativeInt s
+                | EvalStackValue.NativeInt s -> CliNumericType.NativeInt s |> CliType.Numeric
                 | EvalStackValue.ManagedPointer ptrSrc ->
                     CliNumericType.NativeInt (NativeIntSource.ManagedPointer ptrSrc)
+                    |> CliType.Numeric
+                | EvalStackValue.UserDefinedValueType vt ->
+                    let popped = CliValueType.DereferenceFieldAt 0 NATIVE_INT_SIZE vt
+                    // TODO: when we have a general mechanism to coerce CliTypes to each other,
+                    // do that
+                    match popped with
+                    | CliType.Numeric (CliNumericType.NativeInt i) -> CliType.Numeric (CliNumericType.NativeInt i)
+                    | CliType.Numeric (CliNumericType.Int64 i) ->
+                        CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.Verbatim i))
+                    | CliType.RuntimePointer ptr ->
+                        match ptr with
+                        | CliRuntimePointer.Verbatim i ->
+                            CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.Verbatim i))
+                        | CliRuntimePointer.FieldRegistryHandle ptr ->
+                            CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.FieldHandlePtr ptr))
+                        | CliRuntimePointer.Managed src ->
+                            CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.ManagedPointer src))
+                    | _ -> failwith $"TODO: {popped}"
                 | _ -> failwith $"TODO: {popped}"
-                |> CliType.Numeric
             | CliNumericType.NativeFloat f -> failwith "todo"
             | CliNumericType.Int8 _ ->
                 match popped with
@@ -151,32 +227,29 @@ module EvalStackValue =
         | CliType.ObjectRef _ ->
             match popped with
             | EvalStackValue.ManagedPointer ptrSource ->
-                match ptrSource with
-                | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
-                    CliRuntimePointerSource.LocalVariable (sourceThread, methodFrame, whichVar)
-                    |> CliRuntimePointer.Managed
-                    |> CliType.RuntimePointer
-                | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) ->
-                    CliRuntimePointerSource.Argument (sourceThread, methodFrame, whichVar)
-                    |> CliRuntimePointer.Managed
-                    |> CliType.RuntimePointer
-                | ManagedPointerSource.Heap managedHeapAddress -> CliType.ObjectRef (Some managedHeapAddress)
-                | ManagedPointerSource.Null -> CliType.ObjectRef None
+                ptrSource |> CliRuntimePointer.Managed |> CliType.RuntimePointer
+            | EvalStackValue.ObjectRef ptr ->
+                ManagedPointerSource.Heap ptr
+                |> CliRuntimePointer.Managed
+                |> CliType.RuntimePointer
             | EvalStackValue.NativeInt nativeIntSource ->
                 match nativeIntSource with
                 | NativeIntSource.Verbatim 0L -> CliType.ObjectRef None
                 | NativeIntSource.Verbatim i -> failwith $"refusing to interpret verbatim native int {i} as a pointer"
                 | NativeIntSource.FunctionPointer _ -> failwith "TODO"
                 | NativeIntSource.TypeHandlePtr _ -> failwith "refusing to interpret type handle ID as an object ref"
+                | NativeIntSource.FieldHandlePtr _ -> failwith "refusing to interpret field handle ID as an object ref"
                 | NativeIntSource.ManagedPointer ptr ->
                     match ptr with
                     | ManagedPointerSource.Null -> CliType.ObjectRef None
                     | ManagedPointerSource.Heap s -> CliType.ObjectRef (Some s)
                     | _ -> failwith "TODO"
-            | EvalStackValue.UserDefinedValueType fields ->
-                match fields with
-                | [ esv ] -> toCliTypeCoerced target esv
-                | fields -> failwith $"TODO: don't know how to coerce struct of {fields} to a pointer"
+            | EvalStackValue.UserDefinedValueType obj ->
+                let popped = CliValueType.DereferenceFieldAt 0 NATIVE_INT_SIZE obj
+
+                match popped with
+                | CliType.ObjectRef r -> CliType.ObjectRef r
+                | _ -> failwith "TODO"
             | _ -> failwith $"TODO: {popped}"
         | CliType.Bool _ ->
             match popped with
@@ -188,36 +261,19 @@ module EvalStackValue =
             | i -> failwith $"TODO: %O{i}"
         | CliType.RuntimePointer _ ->
             match popped with
-            | EvalStackValue.ManagedPointer src ->
-                match src with
-                | ManagedPointerSource.Heap addr -> CliType.OfManagedObject addr
-                | ManagedPointerSource.Null -> CliType.ObjectRef None
-                | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, var) ->
-                    CliRuntimePointerSource.LocalVariable (sourceThread, methodFrame, var)
-                    |> CliRuntimePointer.Managed
-                    |> CliType.RuntimePointer
-                | ManagedPointerSource.Argument (sourceThread, methodFrame, var) ->
-                    CliRuntimePointerSource.Argument (sourceThread, methodFrame, var)
-                    |> CliRuntimePointer.Managed
-                    |> CliType.RuntimePointer
+            | EvalStackValue.ManagedPointer src -> src |> CliRuntimePointer.Managed |> CliType.RuntimePointer
             | EvalStackValue.NativeInt intSrc ->
                 match intSrc with
-                | NativeIntSource.Verbatim i -> CliType.RuntimePointer (CliRuntimePointer.Unmanaged i)
-                | NativeIntSource.ManagedPointer src ->
-                    match src with
-                    | ManagedPointerSource.Heap src ->
-                        CliType.RuntimePointer (CliRuntimePointer.Managed (CliRuntimePointerSource.Heap src))
-                    | ManagedPointerSource.Null ->
-                        CliType.RuntimePointer (CliRuntimePointer.Managed CliRuntimePointerSource.Null)
-                    | ManagedPointerSource.LocalVariable (a, b, c) ->
-                        CliType.RuntimePointer (
-                            CliRuntimePointer.Managed (CliRuntimePointerSource.LocalVariable (a, b, c))
-                        )
-                    | ManagedPointerSource.Argument (a, b, c) ->
-                        CliType.RuntimePointer (CliRuntimePointer.Managed (CliRuntimePointerSource.Argument (a, b, c)))
+                | NativeIntSource.Verbatim i -> CliType.RuntimePointer (CliRuntimePointer.Verbatim i)
+                | NativeIntSource.ManagedPointer src -> src |> CliRuntimePointer.Managed |> CliType.RuntimePointer
                 | NativeIntSource.FunctionPointer methodInfo ->
                     CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.FunctionPointer methodInfo))
                 | NativeIntSource.TypeHandlePtr int64 -> failwith "todo"
+                | NativeIntSource.FieldHandlePtr int64 -> failwith "todo"
+            | EvalStackValue.ObjectRef addr ->
+                ManagedPointerSource.Heap addr
+                |> CliRuntimePointer.Managed
+                |> CliType.RuntimePointer
             | _ -> failwith $"TODO: %O{popped}"
         | CliType.Char _ ->
             match popped with
@@ -226,56 +282,40 @@ module EvalStackValue =
                 let low = i % 256
                 CliType.Char (byte<int> high, byte<int> low)
             | popped -> failwith $"Unexpectedly wanted a char from {popped}"
-        | CliType.ValueType fields ->
+        | CliType.ValueType vt ->
             match popped with
-            | EvalStackValue.UserDefinedValueType popped ->
-                if fields.Length <> popped.Length then
-                    failwith "mismatch"
+            | EvalStackValue.UserDefinedValueType popped' ->
+                match CliValueType.TrySequentialFields vt, CliValueType.TrySequentialFields popped' with
+                | Some vt, Some popped ->
+                    if vt.Length <> popped.Length then
+                        failwith
+                            $"mismatch: popped value type {popped} (length %i{popped.Length}) into {vt} (length %i{vt.Length})"
 
-                List.map2 toCliTypeCoerced fields popped |> CliType.ValueType
+                    (vt, popped)
+                    ||> List.map2 (fun field1 popped ->
+                        if field1.Name <> popped.Name then
+                            failwith $"TODO: name mismatch, {field1.Name} vs {popped.Name}"
+
+                        if field1.Offset <> popped.Offset then
+                            failwith $"TODO: offset mismatch for {field1.Name}, {field1.Offset} vs {popped.Offset}"
+
+                        let contents = toCliTypeCoerced field1.Contents (ofCliType popped.Contents)
+
+                        {
+                            CliField.Name = field1.Name
+                            Contents = contents
+                            Offset = field1.Offset
+                            Type = field1.Type
+                        }
+                    )
+                    |> CliValueType.OfFields popped'.Layout
+                    |> CliType.ValueType
+                | _, _ -> failwith "TODO: overlapping fields going onto eval stack"
             | popped ->
-                match fields with
-                | [ target ] -> toCliTypeCoerced target popped
+                match CliValueType.TryExactlyOneField vt with
+                | Some field -> toCliTypeCoerced field.Contents popped
                 | _ -> failwith $"TODO: {popped} into value type {target}"
 
-    let rec ofCliType (v : CliType) : EvalStackValue =
-        match v with
-        | CliType.Numeric numeric ->
-            match numeric with
-            | CliNumericType.Int32 i -> EvalStackValue.Int32 i
-            | CliNumericType.Int64 i -> EvalStackValue.Int64 i
-            | CliNumericType.NativeInt i -> EvalStackValue.NativeInt i
-            // Sign-extend types int8 and int16
-            // Zero-extend unsigned int8/unsigned int16
-            | CliNumericType.Int8 b -> int32<int8> b |> EvalStackValue.Int32
-            | CliNumericType.UInt8 b -> int32<uint8> b |> EvalStackValue.Int32
-            | CliNumericType.Int16 s -> int32<int16> s |> EvalStackValue.Int32
-            | CliNumericType.UInt16 s -> int32<uint16> s |> EvalStackValue.Int32
-            | CliNumericType.Float32 f -> EvalStackValue.Float (float<float32> f)
-            | CliNumericType.Float64 f -> EvalStackValue.Float f
-            | CliNumericType.NativeFloat f -> EvalStackValue.Float f
-        | CliType.ObjectRef i ->
-            match i with
-            | None -> EvalStackValue.ManagedPointer ManagedPointerSource.Null
-            | Some i -> EvalStackValue.ManagedPointer (ManagedPointerSource.Heap i)
-        // Zero-extend bool/char
-        | CliType.Bool b -> int32 b |> EvalStackValue.Int32
-        | CliType.Char (high, low) -> int32 high * 256 + int32 low |> EvalStackValue.Int32
-        | CliType.RuntimePointer ptr ->
-            match ptr with
-            | CliRuntimePointer.Unmanaged ptrInt -> NativeIntSource.Verbatim ptrInt |> EvalStackValue.NativeInt
-            | CliRuntimePointer.Managed ptr ->
-                match ptr with
-                | CliRuntimePointerSource.LocalVariable (sourceThread, methodFrame, var) ->
-                    ManagedPointerSource.LocalVariable (sourceThread, methodFrame, var)
-                    |> EvalStackValue.ManagedPointer
-                | CliRuntimePointerSource.Argument (sourceThread, methodFrame, var) ->
-                    ManagedPointerSource.Argument (sourceThread, methodFrame, var)
-                    |> EvalStackValue.ManagedPointer
-                | CliRuntimePointerSource.Heap addr -> EvalStackValue.ObjectRef addr
-                | CliRuntimePointerSource.Null -> EvalStackValue.ManagedPointer ManagedPointerSource.Null
-        | CliType.ValueType fields -> fields |> List.map ofCliType |> EvalStackValue.UserDefinedValueType
-
 type EvalStack =
     {
         Values : EvalStackValue list
@@ -308,3 +348,5 @@ type EvalStack =
         let v = EvalStackValue.ofCliType v
 
         EvalStack.Push' v stack
+
+    static member PeekNthFromTop (n : int) (stack : EvalStack) : EvalStackValue option = stack.Values |> List.tryItem n

WoofWare.PawPrint/EvalStackValueComparisons.fs

@@ -0,0 +1,171 @@
+namespace WoofWare.PawPrint
+
+[<RequireQualifiedAccess>]
+module EvalStackValueComparisons =
+
+    let clt (var1 : EvalStackValue) (var2 : EvalStackValue) : bool =
+        match var1, var2 with
+        | EvalStackValue.Int64 var1, EvalStackValue.Int64 var2 -> var1 < var2
+        | EvalStackValue.Float var1, EvalStackValue.Float var2 -> var1 < var2
+        | EvalStackValue.ObjectRef var1, EvalStackValue.ObjectRef var2 ->
+            failwith $"Clt instruction invalid for comparing object refs, {var1} vs {var2}"
+        | EvalStackValue.ObjectRef var1, other -> failwith $"invalid comparison, ref %O{var1} vs %O{other}"
+        | other, EvalStackValue.ObjectRef var2 -> failwith $"invalid comparison, %O{other} vs ref %O{var2}"
+        | EvalStackValue.Float i, other -> failwith $"invalid comparison, float %f{i} vs %O{other}"
+        | other, EvalStackValue.Float i -> failwith $"invalid comparison, %O{other} vs float %f{i}"
+        | EvalStackValue.Int64 i, other -> failwith $"invalid comparison, int64 %i{i} vs %O{other}"
+        | other, EvalStackValue.Int64 i -> failwith $"invalid comparison, %O{other} vs int64 %i{i}"
+        | EvalStackValue.Int32 var1, EvalStackValue.Int32 var2 -> var1 < var2
+        | EvalStackValue.Int32 var1, EvalStackValue.NativeInt var2 ->
+            failwith "TODO: Clt Int32 vs NativeInt comparison unimplemented"
+        | EvalStackValue.Int32 i, other -> failwith $"invalid comparison, int32 %i{i} vs %O{other}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.Int32 var2 ->
+            failwith "TODO: Clt NativeInt vs Int32 comparison unimplemented"
+        | other, EvalStackValue.Int32 var2 -> failwith $"invalid comparison, {other} vs int32 {var2}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.NativeInt var2 -> NativeIntSource.isLess var1 var2
+        | EvalStackValue.NativeInt var1, other -> failwith $"invalid comparison, nativeint {var1} vs %O{other}"
+        | EvalStackValue.ManagedPointer managedPointerSource, NativeInt int64 ->
+            failwith "TODO: Clt ManagedPointer vs NativeInt comparison unimplemented"
+        | EvalStackValue.ManagedPointer managedPointerSource, ManagedPointer pointerSource ->
+            failwith "TODO: Clt ManagedPointer vs ManagedPointer comparison unimplemented"
+        | EvalStackValue.ManagedPointer managedPointerSource, UserDefinedValueType _ ->
+            failwith "TODO: Clt ManagedPointer vs UserDefinedValueType comparison unimplemented"
+        | EvalStackValue.UserDefinedValueType _, NativeInt int64 ->
+            failwith "TODO: Clt UserDefinedValueType vs NativeInt comparison unimplemented"
+        | EvalStackValue.UserDefinedValueType _, ManagedPointer managedPointerSource ->
+            failwith "TODO: Clt UserDefinedValueType vs ManagedPointer comparison unimplemented"
+        | EvalStackValue.UserDefinedValueType _, UserDefinedValueType _ ->
+            failwith "TODO: Clt UserDefinedValueType vs UserDefinedValueType comparison unimplemented"
+
+    let cgt (var1 : EvalStackValue) (var2 : EvalStackValue) : bool =
+        match var1, var2 with
+        | EvalStackValue.Int64 var1, EvalStackValue.Int64 var2 -> var1 > var2
+        | EvalStackValue.Float var1, EvalStackValue.Float var2 -> var1 > var2
+        | EvalStackValue.ObjectRef var1, EvalStackValue.ObjectRef var2 ->
+            failwith $"Cgt instruction invalid for comparing object refs, {var1} vs {var2}"
+        | EvalStackValue.ObjectRef var1, other -> failwith $"invalid comparison, ref %O{var1} vs %O{other}"
+        | other, EvalStackValue.ObjectRef var2 -> failwith $"invalid comparison, %O{other} vs ref %O{var2}"
+        | EvalStackValue.Float i, other -> failwith $"invalid comparison, float %f{i} vs %O{other}"
+        | other, EvalStackValue.Float i -> failwith $"invalid comparison, %O{other} vs float %f{i}"
+        | EvalStackValue.Int64 i, other -> failwith $"invalid comparison, int64 %i{i} vs %O{other}"
+        | other, EvalStackValue.Int64 i -> failwith $"invalid comparison, %O{other} vs int64 %i{i}"
+        | EvalStackValue.Int32 var1, EvalStackValue.Int32 var2 -> var1 > var2
+        | EvalStackValue.Int32 var1, EvalStackValue.NativeInt var2 ->
+            failwith "TODO: Cgt Int32 vs NativeInt comparison unimplemented"
+        | EvalStackValue.Int32 i, other -> failwith $"invalid comparison, int32 %i{i} vs %O{other}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.Int32 var2 ->
+            failwith "TODO: Cgt NativeInt vs Int32 comparison unimplemented"
+        | other, EvalStackValue.Int32 var2 -> failwith $"invalid comparison, {other} vs int32 {var2}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.NativeInt var2 -> NativeIntSource.isLess var1 var2
+        | EvalStackValue.NativeInt var1, other -> failwith $"invalid comparison, nativeint {var1} vs %O{other}"
+        | EvalStackValue.ManagedPointer managedPointerSource, NativeInt int64 ->
+            failwith "TODO: Cgt ManagedPointer vs NativeInt comparison unimplemented"
+        | EvalStackValue.ManagedPointer managedPointerSource, ManagedPointer pointerSource ->
+            failwith "TODO: Cgt ManagedPointer vs ManagedPointer comparison unimplemented"
+        | EvalStackValue.ManagedPointer managedPointerSource, UserDefinedValueType _ ->
+            failwith "TODO: Cgt ManagedPointer vs UserDefinedValueType comparison unimplemented"
+        | EvalStackValue.UserDefinedValueType _, NativeInt int64 ->
+            failwith "TODO: Cgt UserDefinedValueType vs NativeInt comparison unimplemented"
+        | EvalStackValue.UserDefinedValueType _, ManagedPointer managedPointerSource ->
+            failwith "TODO: Cgt UserDefinedValueType vs ManagedPointer comparison unimplemented"
+        | EvalStackValue.UserDefinedValueType _, UserDefinedValueType _ ->
+            failwith "TODO: Cgt UserDefinedValueType vs UserDefinedValueType comparison unimplemented"
+
+    let cgtUn (var1 : EvalStackValue) (var2 : EvalStackValue) : bool =
+        match var1, var2 with
+        | EvalStackValue.Int32 var1, EvalStackValue.Int32 var2 -> uint32 var1 > uint32 var2
+        | EvalStackValue.Int32 var1, EvalStackValue.NativeInt var2 ->
+            failwith "TODO: comparison of unsigned int32 with nativeint"
+        | EvalStackValue.Int32 _, _ -> failwith $"Cgt.un invalid for comparing %O{var1} with %O{var2}"
+        | EvalStackValue.Int64 var1, EvalStackValue.Int64 var2 -> uint64 var1 > uint64 var2
+        | EvalStackValue.Int64 _, _ -> failwith $"Cgt.un invalid for comparing %O{var1} with %O{var2}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.NativeInt var2 ->
+            failwith "TODO: comparison of unsigned nativeints"
+        | EvalStackValue.NativeInt var1, EvalStackValue.Int32 var2 ->
+            failwith "TODO: comparison of unsigned nativeint with int32"
+        | EvalStackValue.Float var1, EvalStackValue.Float var2 -> not (var1 <= var2)
+        | EvalStackValue.Float _, _ -> failwith $"Cgt.un invalid for comparing %O{var1} with %O{var2}"
+        | EvalStackValue.ManagedPointer var1, EvalStackValue.ManagedPointer var2 ->
+            // I'm going to be stricter than the spec and simply ban every pointer comparison except those with null,
+            // pending a strong argument to fully support this.
+            match var1, var2 with
+            | ManagedPointerSource.Null, ManagedPointerSource.Null -> false
+            | ManagedPointerSource.Null, _ -> true
+            | _, ManagedPointerSource.Null -> true
+            | _, _ -> failwith $"I've banned this case: {var1} vs {var2}"
+        | EvalStackValue.ObjectRef var1, EvalStackValue.ObjectRef var2 ->
+            // According to the spec, cgt.un is verifiable on ObjectRefs and is used to compare with null.
+            // A direct comparison between two object refs is not specified, so we treat it as a pointer comparison.
+            failwith "TODO"
+        | other1, other2 -> failwith $"Cgt.un instruction invalid for comparing {other1} vs {other2}"
+
+    let cltUn (var1 : EvalStackValue) (var2 : EvalStackValue) : bool =
+        match var1, var2 with
+        | EvalStackValue.Int32 var1, EvalStackValue.Int32 var2 -> uint32 var1 < uint32 var2
+        | EvalStackValue.Int32 var1, EvalStackValue.NativeInt var2 ->
+            failwith "TODO: comparison of unsigned int32 with nativeint"
+        | EvalStackValue.Int32 _, _ -> failwith $"Cgt.un invalid for comparing %O{var1} with %O{var2}"
+        | EvalStackValue.Int64 var1, EvalStackValue.Int64 var2 -> uint64 var1 < uint64 var2
+        | EvalStackValue.Int64 _, _ -> failwith $"Cgt.un invalid for comparing %O{var1} with %O{var2}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.NativeInt var2 ->
+            failwith "TODO: comparison of unsigned nativeints"
+        | EvalStackValue.NativeInt var1, EvalStackValue.Int32 var2 ->
+            failwith "TODO: comparison of unsigned nativeint with int32"
+        | EvalStackValue.Float var1, EvalStackValue.Float var2 -> not (var1 >= var2)
+        | EvalStackValue.Float _, _ -> failwith $"Cgt.un invalid for comparing %O{var1} with %O{var2}"
+        | EvalStackValue.ManagedPointer var1, EvalStackValue.ManagedPointer var2 -> failwith "TODO"
+        | EvalStackValue.ObjectRef var1, EvalStackValue.ObjectRef var2 ->
+            // According to the spec, cgt.un is verifiable on ObjectRefs and is used to compare with null.
+            // A direct comparison between two object refs is not specified, so we treat it as a pointer comparison.
+            failwith "TODO"
+        | other1, other2 -> failwith $"Cgt.un instruction invalid for comparing {other1} vs {other2}"
+
+    let rec ceq (var1 : EvalStackValue) (var2 : EvalStackValue) : bool =
+        // Table III.4
+        match var1, var2 with
+        | EvalStackValue.UserDefinedValueType var1, v ->
+            match CliValueType.TryExactlyOneField var1 with
+            | None -> failwith "TODO"
+            | Some var1 -> ceq (EvalStackValue.ofCliType var1.Contents) v
+        | u, EvalStackValue.UserDefinedValueType var2 ->
+            match CliValueType.TryExactlyOneField var2 with
+            | None -> failwith "TODO"
+            | Some var2 -> ceq u (EvalStackValue.ofCliType var2.Contents)
+        | EvalStackValue.Int32 var1, EvalStackValue.Int32 var2 -> var1 = var2
+        | EvalStackValue.Int32 var1, EvalStackValue.NativeInt var2 -> failwith "TODO: int32 CEQ nativeint"
+        | EvalStackValue.Int32 _, _ -> failwith $"bad ceq: Int32 vs {var2}"
+        | EvalStackValue.Int64 var1, EvalStackValue.Int64 var2 -> var1 = var2
+        | EvalStackValue.Int64 _, _ -> failwith $"bad ceq: Int64 vs {var2}"
+        | EvalStackValue.Float var1, EvalStackValue.Float var2 -> var1 = var2
+        | EvalStackValue.Float _, _ -> failwith $"bad ceq: Float vs {var2}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.NativeInt var2 ->
+            match var1, var2 with
+            | NativeIntSource.FunctionPointer f1, NativeIntSource.FunctionPointer f2 ->
+                if f1 = f2 then
+                    true
+                else
+                    failwith $"TODO(CEQ): nativeint vs nativeint, {f1} vs {f2}"
+            | NativeIntSource.TypeHandlePtr f1, NativeIntSource.TypeHandlePtr f2 -> f1 = f2
+            | NativeIntSource.Verbatim f1, NativeIntSource.Verbatim f2 -> f1 = f2
+            | NativeIntSource.ManagedPointer f1, NativeIntSource.ManagedPointer f2 -> f1 = f2
+            | _, _ -> failwith $"TODO (CEQ): nativeint vs nativeint, {var1} vs {var2}"
+        | EvalStackValue.NativeInt var1, EvalStackValue.Int32 var2 -> failwith $"TODO (CEQ): nativeint vs int32"
+        | EvalStackValue.NativeInt var1, EvalStackValue.ManagedPointer var2 ->
+            failwith $"TODO (CEQ): nativeint vs managed pointer"
+        | EvalStackValue.NativeInt _, _ -> failwith $"bad ceq: NativeInt vs {var2}"
+        | EvalStackValue.ObjectRef var1, EvalStackValue.ObjectRef var2 -> var1 = var2
+        | EvalStackValue.ManagedPointer src, EvalStackValue.ObjectRef var1
+        | EvalStackValue.ObjectRef var1, EvalStackValue.ManagedPointer src ->
+            match src with
+            | ManagedPointerSource.Heap src -> src = var1
+            | ManagedPointerSource.Null -> false
+            | ManagedPointerSource.Field _
+            | ManagedPointerSource.LocalVariable _
+            | ManagedPointerSource.Argument _ -> false
+            | ManagedPointerSource.ArrayIndex (arr, index) -> failwith "todo"
+            | ManagedPointerSource.InterpretedAsType (src, ty) -> failwith "todo"
+        | EvalStackValue.ObjectRef _, _ -> failwith $"bad ceq: ObjectRef vs {var2}"
+        | EvalStackValue.ManagedPointer var1, EvalStackValue.ManagedPointer var2 -> var1 = var2
+        | EvalStackValue.ManagedPointer var1, EvalStackValue.NativeInt var2 ->
+            failwith $"TODO (CEQ): managed pointer vs nativeint"
+        | EvalStackValue.ManagedPointer _, _ -> failwith $"bad ceq: ManagedPointer vs {var2}"

WoofWare.PawPrint/Exceptions.fs

@@ -1,29 +1,32 @@
 namespace WoofWare.PawPrint
 
+open System
 open System.Collections.Immutable
 
 /// Represents a location in the code where an exception occurred
-type ExceptionStackFrame =
+type ExceptionStackFrame<'typeGen, 'methodGen, 'methodVar
+    when 'typeGen : comparison and 'typeGen :> IComparable<'typeGen>> =
     {
-        Method : WoofWare.PawPrint.MethodInfo<TypeDefn, TypeDefn>
+        Method : WoofWare.PawPrint.MethodInfo<'typeGen, 'methodGen, 'methodVar>
         /// The number of bytes into the IL of the method we were in
         IlOffset : int
     }
 
 /// Represents a CLI exception being propagated
-type CliException =
+type CliException<'typeGen, 'methodGen, 'methodVar when 'typeGen : comparison and 'typeGen :> IComparable<'typeGen>> =
     {
         /// The exception object allocated on the heap
         ExceptionObject : ManagedHeapAddress
         /// Stack trace built during unwinding
-        StackTrace : ExceptionStackFrame list
+        StackTrace : ExceptionStackFrame<'typeGen, 'methodGen, 'methodVar> list
     }
 
 /// Represents what to do after executing a finally/filter block
-type ExceptionContinuation =
+type ExceptionContinuation<'typeGen, 'methodGen, 'methodVar
+    when 'typeGen : comparison and 'typeGen :> IComparable<'typeGen>> =
     | ResumeAfterFinally of targetPC : int
-    | PropagatingException of exn : CliException
-    | ResumeAfterFilter of handlerPC : int * exn : CliException
+    | PropagatingException of exn : CliException<'typeGen, 'methodGen, 'methodVar>
+    | ResumeAfterFilter of handlerPC : int * exn : CliException<'typeGen, 'methodGen, 'methodVar>
 
 /// Helper functions for exception handling
 [<RequireQualifiedAccess>]
@@ -31,7 +34,7 @@ module ExceptionHandling =
 
     /// Check if an exception type matches a catch handler type
     let private isExceptionAssignableTo
-        (exceptionTypeCrate : TypeInfoCrate)
+        (exceptionType : ConcreteTypeHandle)
         (catchTypeToken : MetadataToken)
         (assemblies : ImmutableDictionary<string, DumpedAssembly>)
         : bool
@@ -43,8 +46,8 @@ module ExceptionHandling =
     /// Also returns `isFinally : bool`: whether this is a `finally` block (as opposed to e.g. a `catch`).
     let findExceptionHandler
         (currentPC : int)
-        (exceptionTypeCrate : TypeInfoCrate)
-        (method : WoofWare.PawPrint.MethodInfo<TypeDefn, 'methodGeneric>)
+        (exceptionType : ConcreteTypeHandle)
+        (method : WoofWare.PawPrint.MethodInfo<'typeGen, 'methodGeneric, 'methodVar>)
         (assemblies : ImmutableDictionary<string, DumpedAssembly>)
         : (WoofWare.PawPrint.ExceptionRegion * bool) option // handler, isFinally
         =
@@ -59,7 +62,7 @@ module ExceptionHandling =
             | ExceptionRegion.Catch (typeToken, offset) ->
                 if currentPC >= offset.TryOffset && currentPC < offset.TryOffset + offset.TryLength then
                     // Check if exception type matches
-                    if isExceptionAssignableTo exceptionTypeCrate typeToken assemblies then
+                    if isExceptionAssignableTo exceptionType typeToken assemblies then
                         Some (region, false)
                     else
                         None
@@ -92,7 +95,7 @@ module ExceptionHandling =
     let findFinallyBlocksToRun
         (currentPC : int)
         (targetPC : int)
-        (method : WoofWare.PawPrint.MethodInfo<TypeDefn, 'methodGeneric>)
+        (method : WoofWare.PawPrint.MethodInfo<'typeGeneric, 'methodGeneric, 'methodVar>)
         : ExceptionOffset list
         =
         match method.Instructions with
@@ -122,7 +125,7 @@ module ExceptionHandling =
     /// Get the active exception regions at a given offset
     let getActiveRegionsAtOffset
         (offset : int)
-        (method : WoofWare.PawPrint.MethodInfo<TypeDefn, 'methodGeneric>)
+        (method : WoofWare.PawPrint.MethodInfo<'a, 'b, 'c>)
         : WoofWare.PawPrint.ExceptionRegion list
         =
         match method.Instructions with

WoofWare.PawPrint/ExternImplementations/System.Threading.Monitor.fs

@@ -62,6 +62,7 @@ module System_Threading_Monitor =
                     match lockObj with
                     | EvalStackValue.ManagedPointer ManagedPointerSource.Null ->
                         failwith "TODO: throw ArgumentNullException"
+                    | EvalStackValue.ObjectRef addr
                     | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr) ->
                         match IlMachineState.getSyncBlock addr state with
                         | SyncBlock.Free ->
@@ -82,10 +83,13 @@ module System_Threading_Monitor =
                     | ManagedPointerSource.Null -> failwith "logic error"
                     | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
                         state
-                        |> IlMachineState.setLocalVariable sourceThread methodFrame whichVar (CliType.OfBool true)
+                        |> IlMachineState.setLocalVariable sourceThread methodFrame whichVar (CliType.ofBool true)
                     | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) ->
                         failwith "not really expecting to *edit* an argument..."
                     | ManagedPointerSource.Heap addr -> failwith "todo: managed heap"
+                    | ManagedPointerSource.ArrayIndex _ -> failwith "todo: array index"
+                    | ManagedPointerSource.Field (managedPointerSource, fieldName) -> failwith "todo"
+                    | ManagedPointerSource.InterpretedAsType _ -> failwith "TODO"
 
                 (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
 
@@ -99,6 +103,7 @@ module System_Threading_Monitor =
                     match lockObj with
                     | EvalStackValue.ManagedPointer ManagedPointerSource.Null ->
                         failwith "TODO: throw ArgumentNullException"
+                    | EvalStackValue.ObjectRef addr
                     | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr) ->
                         match IlMachineState.getSyncBlock addr state with
                         | SyncBlock.Free -> failwith "TODO: throw SynchronizationLockException"

WoofWare.PawPrint/FieldHandleRegistry.fs

@@ -0,0 +1,196 @@
+namespace WoofWare.PawPrint
+
+open System.Collections.Immutable
+open System.Reflection
+open System.Reflection.Metadata
+
+type FieldHandle =
+    private
+        {
+            AssemblyFullName : string
+            DeclaringType : ConcreteTypeHandle
+            FieldHandle : ComparableFieldDefinitionHandle
+        }
+
+type FieldHandleRegistry =
+    private
+        {
+            FieldHandleToId : Map<FieldHandle, int64>
+            FieldHandleToField : Map<ManagedHeapAddress, FieldHandle>
+            FieldToHandle : Map<FieldHandle, ManagedHeapAddress>
+            NextHandle : int64
+        }
+
+[<RequireQualifiedAccess>]
+module FieldHandleRegistry =
+    let empty () =
+        {
+            FieldHandleToField = Map.empty
+            FieldToHandle = Map.empty
+            FieldHandleToId = Map.empty
+            NextHandle = 1L
+        }
+
+    /// Returns a (struct) System.RuntimeFieldHandle, with its contents (reference type) freshly allocated if necessary.
+    let getOrAllocate
+        (baseClassTypes : BaseClassTypes<'corelib>)
+        (allConcreteTypes : AllConcreteTypes)
+        (allocState : 'allocState)
+        (allocate : CliValueType -> 'allocState -> ManagedHeapAddress * 'allocState)
+        (declaringAssy : AssemblyName)
+        (declaringType : ConcreteTypeHandle)
+        (handle : FieldDefinitionHandle)
+        (reg : FieldHandleRegistry)
+        : CliType * FieldHandleRegistry * 'allocState
+        =
+
+        let runtimeFieldHandle (runtimeFieldInfoStub : ManagedHeapAddress) =
+            // RuntimeFieldHandle is a struct; it contains one field, an IRuntimeFieldInfo
+            // https://github.com/dotnet/runtime/blob/1d1bf92fcf43aa6981804dc53c5174445069c9e4/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs#L1048
+            // In practice we expect to use RuntimeFieldInfoStub for that IRuntimeFieldInfo:
+            // https://github.com/dotnet/runtime/blob/1d1bf92fcf43aa6981804dc53c5174445069c9e4/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs#L1157
+            let runtimeFieldHandleType = baseClassTypes.RuntimeFieldHandle
+            let field = runtimeFieldHandleType.Fields |> List.exactlyOne
+
+            if field.Name <> "m_ptr" then
+                failwith $"unexpected field name %s{field.Name} for BCL type RuntimeFieldHandle"
+
+            {
+                Name = "m_ptr"
+                Contents = CliType.ofManagedObject runtimeFieldInfoStub
+                Offset = None
+                Type =
+                    AllConcreteTypes.findExistingConcreteType
+                        allConcreteTypes
+                        (baseClassTypes.RuntimeFieldInfoStub.Assembly,
+                         baseClassTypes.RuntimeFieldInfoStub.Namespace,
+                         baseClassTypes.RuntimeFieldInfoStub.Name,
+                         ImmutableArray.Empty)
+                    |> Option.get
+            }
+            |> List.singleton
+            |> CliValueType.OfFields Layout.Default
+            |> CliType.ValueType
+
+        let handle =
+            {
+                AssemblyFullName = declaringAssy.FullName
+                FieldHandle = ComparableFieldDefinitionHandle.Make handle
+                DeclaringType = declaringType
+            }
+
+        match Map.tryFind handle reg.FieldToHandle with
+        | Some v -> runtimeFieldHandle v, reg, allocState
+        | None ->
+
+        let newHandle = reg.NextHandle
+
+        let runtimeFieldHandleInternal =
+            let field = baseClassTypes.RuntimeFieldHandleInternal.Fields |> List.exactlyOne
+
+            if field.Name <> "m_handle" then
+                failwith $"unexpected field name %s{field.Name} for BCL type RuntimeFieldHandleInternal"
+
+            match field.Signature with
+            | TypeDefn.PrimitiveType PrimitiveType.IntPtr -> ()
+            | s -> failwith $"bad sig: {s}"
+
+            // https://github.com/dotnet/runtime/blob/2b21c73fa2c32fa0195e4a411a435dda185efd08/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs#L1380
+            {
+                Name = "m_handle"
+                Contents = CliType.RuntimePointer (CliRuntimePointer.FieldRegistryHandle newHandle)
+                Offset = None // no struct layout was specified
+                Type =
+                    AllConcreteTypes.findExistingConcreteType
+                        allConcreteTypes
+                        (baseClassTypes.IntPtr.Assembly,
+                         baseClassTypes.IntPtr.Namespace,
+                         baseClassTypes.IntPtr.Name,
+                         ImmutableArray.Empty)
+                    |> Option.get
+            }
+            |> List.singleton
+            |> CliValueType.OfFields Layout.Default
+            |> CliType.ValueType
+
+        // https://github.com/dotnet/runtime/blob/1d1bf92fcf43aa6981804dc53c5174445069c9e4/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs#L1074
+        let runtimeFieldInfoStub =
+            let objType =
+                AllConcreteTypes.findExistingConcreteType
+                    allConcreteTypes
+                    (baseClassTypes.Object.Assembly,
+                     baseClassTypes.Object.Namespace,
+                     baseClassTypes.Object.Name,
+                     ImmutableArray.Empty)
+                |> Option.get
+
+            let intType =
+                AllConcreteTypes.findExistingConcreteType
+                    allConcreteTypes
+                    (baseClassTypes.Int32.Assembly,
+                     baseClassTypes.Int32.Namespace,
+                     baseClassTypes.Int32.Name,
+                     ImmutableArray.Empty)
+                |> Option.get
+
+            // LayoutKind.Sequential
+            [
+                // If we ever implement a GC, something should change here
+                {
+                    Name = "m_keepalive"
+                    Contents = CliType.ObjectRef None
+                    Offset = None
+                    Type = objType
+                }
+                {
+                    Name = "m_c"
+                    Contents = CliType.ObjectRef None
+                    Offset = None
+                    Type = objType
+                }
+                {
+                    Name = "m_d"
+                    Contents = CliType.ObjectRef None
+                    Offset = None
+                    Type = objType
+                }
+                {
+                    Name = "m_b"
+                    Contents = CliType.Numeric (CliNumericType.Int32 0)
+                    Offset = None
+                    Type = intType
+                }
+                {
+                    Name = "m_e"
+                    Contents = CliType.ObjectRef None
+                    Offset = None
+                    Type = objType
+                }
+                // RuntimeFieldHandleInternal: https://github.com/dotnet/runtime/blob/1d1bf92fcf43aa6981804dc53c5174445069c9e4/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs#L1048
+                {
+                    Name = "m_fieldHandle"
+                    Contents = runtimeFieldHandleInternal
+                    Offset = None
+                    Type =
+                        AllConcreteTypes.findExistingConcreteType
+                            allConcreteTypes
+                            (baseClassTypes.RuntimeFieldHandleInternal.Assembly,
+                             baseClassTypes.RuntimeFieldHandleInternal.Namespace,
+                             baseClassTypes.RuntimeFieldHandleInternal.Name,
+                             ImmutableArray.Empty)
+                        |> Option.get
+                }
+            ]
+            |> CliValueType.OfFields Layout.Default // explicitly sequential but no custom packing size
+
+        let alloc, state = allocate runtimeFieldInfoStub allocState
+
+        let reg =
+            {
+                FieldHandleToField = reg.FieldHandleToField |> Map.add alloc handle
+                FieldToHandle = reg.FieldToHandle |> Map.add handle alloc
+                FieldHandleToId = reg.FieldHandleToId |> Map.add handle newHandle
+                NextHandle = reg.NextHandle + 1L
+            }
+
+        runtimeFieldHandle alloc, reg, state

WoofWare.PawPrint/IlMachineStateExecution.fs

@@ -0,0 +1,811 @@
+namespace WoofWare.PawPrint
+
+open System
+open System.Collections.Immutable
+open System.Reflection
+open System.Reflection.Metadata
+open System.Runtime.CompilerServices
+open Microsoft.Extensions.Logging
+
+[<RequireQualifiedAccess>]
+module IlMachineStateExecution =
+    let getTypeOfObj
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
+        (state : IlMachineState)
+        (esv : EvalStackValue)
+        : IlMachineState * ConcreteTypeHandle
+        =
+        match esv with
+        | EvalStackValue.Int32 _ ->
+            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.Int32
+            |> IlMachineState.concretizeType
+                loggerFactory
+                baseClassTypes
+                state
+                baseClassTypes.Corelib.Name
+                ImmutableArray.Empty
+                ImmutableArray.Empty
+        | EvalStackValue.Int64 _ ->
+            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.Int64
+            |> IlMachineState.concretizeType
+                loggerFactory
+                baseClassTypes
+                state
+                baseClassTypes.Corelib.Name
+                ImmutableArray.Empty
+                ImmutableArray.Empty
+        | EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+        | EvalStackValue.Float _ ->
+            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.Double
+            |> IlMachineState.concretizeType
+                loggerFactory
+                baseClassTypes
+                state
+                baseClassTypes.Corelib.Name
+                ImmutableArray.Empty
+                ImmutableArray.Empty
+        | EvalStackValue.ManagedPointer src ->
+            match src with
+            | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) -> failwith "todo"
+            | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) -> failwith "todo"
+            | ManagedPointerSource.Heap addr ->
+                let o = ManagedHeap.get addr state.ManagedHeap
+                state, o.ConcreteType
+            | ManagedPointerSource.ArrayIndex (arr, index) -> failwith "todo"
+            | ManagedPointerSource.Null -> failwith "todo"
+            | ManagedPointerSource.Field (managedPointerSource, fieldName) -> failwith "todo"
+            | ManagedPointerSource.InterpretedAsType (src, ty) -> failwith "todo"
+        | EvalStackValue.ObjectRef addr ->
+            let o = ManagedHeap.get addr state.ManagedHeap
+            state, o.ConcreteType
+        | EvalStackValue.UserDefinedValueType tuples -> failwith "todo"
+
+    let isAssignableFrom
+        (objToCast : ConcreteTypeHandle)
+        (possibleTargetType : ConcreteTypeHandle)
+        (state : IlMachineState)
+        : bool
+        =
+        if objToCast = possibleTargetType then
+            true
+        else
+
+        let objToCast' = AllConcreteTypes.lookup objToCast state.ConcreteTypes |> Option.get
+
+        let possibleTargetType' =
+            AllConcreteTypes.lookup possibleTargetType state.ConcreteTypes |> Option.get
+
+        // TODO: null can be assigned to any reference type; might not be relevant here?
+
+        match possibleTargetType with
+        | ConcreteObj state.ConcreteTypes -> true
+        | ConcreteValueType state.ConcreteTypes when failwith "check if objToCast inherits ValueType" -> true
+        | _ ->
+            // Claude describes the algorithm here:
+            // https://claude.ai/chat/f15e23f6-a27b-4655-9e69-e4d445dd1249
+            failwith
+                $"TODO: check inheritance chain and interfaces: is {objToCast'} assignable from {possibleTargetType'}?"
+
+    let callMethod
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
+        (wasInitialising : ConcreteTypeHandle option)
+        (wasConstructing : ManagedHeapAddress option)
+        (performInterfaceResolution : bool)
+        (wasClassConstructor : bool)
+        (advanceProgramCounterOfCaller : bool)
+        (methodGenerics : ImmutableArray<ConcreteTypeHandle>)
+        (methodToCall : WoofWare.PawPrint.MethodInfo<ConcreteTypeHandle, ConcreteTypeHandle, ConcreteTypeHandle>)
+        (thread : ThreadId)
+        (threadState : ThreadState)
+        (state : IlMachineState)
+        : IlMachineState
+        =
+        let logger = loggerFactory.CreateLogger "CallMethod"
+        let activeAssy = state.ActiveAssembly thread
+
+        // Check for intrinsics first
+        let isIntrinsic =
+            MethodInfo.isJITIntrinsic
+                (fun handle ->
+                    match activeAssy.Members.[handle].Parent with
+                    | MetadataToken.TypeReference r -> activeAssy.TypeRefs.[r]
+                    | x -> failwith $"{x}"
+                )
+                activeAssy.Methods
+                methodToCall
+
+        match
+            if isIntrinsic then
+                Intrinsics.call loggerFactory baseClassTypes methodToCall thread state
+            else
+                None
+        with
+        | Some result -> result
+        | None ->
+
+        // Get zero values for all parameters
+        let state, argZeroObjects =
+            ((state, []), methodToCall.Signature.ParameterTypes)
+            ||> List.fold (fun (state, zeros) tyHandle ->
+                let zero, state = IlMachineState.cliTypeZeroOfHandle state baseClassTypes tyHandle
+                state, zero :: zeros
+            )
+
+        let argZeroObjects = List.rev argZeroObjects
+
+        let activeMethodState = threadState.MethodStates.[threadState.ActiveMethodState]
+
+        let state, methodToCall =
+            match methodToCall.Instructions, performInterfaceResolution, methodToCall.IsStatic with
+            | None, true, false ->
+                logger.LogDebug (
+                    "Identifying target of virtual call for {TypeName}.{MethodName}",
+                    methodToCall.DeclaringType.Name,
+                    methodToCall.Name
+                )
+                // This might be an interface implementation, or implemented by native code.
+                // If native code, we'll deal with that when we actually start implementing.
+
+                // Since we're not static, there's a `this` on the eval stack.
+                // It comes *below* all the arguments.
+                let callingObj =
+                    match
+                        activeMethodState.EvaluationStack
+                        |> EvalStack.PeekNthFromTop methodToCall.Parameters.Length
+                    with
+                    | None -> failwith "unexpectedly no `this` on the eval stack of instance method"
+                    | Some this -> this
+
+                let state, callingObjTyHandle =
+                    getTypeOfObj loggerFactory baseClassTypes state callingObj
+
+                let callingObjTy =
+                    let ty =
+                        AllConcreteTypes.lookup callingObjTyHandle state.ConcreteTypes |> Option.get
+
+                    state.LoadedAssembly(ty.Assembly).Value.TypeDefs.[ty.Definition.Get]
+
+                let declaringAssy = state.LoadedAssembly(methodToCall.DeclaringType.Assembly).Value
+
+                let methodDeclaringType =
+                    declaringAssy.TypeDefs.[methodToCall.DeclaringType.Definition.Get]
+
+                let interfaceExplicitNamedMethod =
+                    if methodDeclaringType.IsInterface then
+                        Some
+                            $"{TypeInfo.fullName (fun h -> declaringAssy.TypeDefs.[h]) methodDeclaringType}.{methodToCall.Name}"
+                    else
+                        None
+
+                // Does type `callingObjTy` implement this method? If so, this is probably a JIT intrinsic or
+                // is supplied by the runtime.
+                let selfImplementation, state =
+                    (state, callingObjTy.Methods)
+                    ||> List.mapFold (fun state meth ->
+                        if
+                            meth.Signature.GenericParameterCount
+                            <> methodToCall.Signature.GenericParameterCount
+                            || meth.Signature.RequiredParameterCount
+                               <> methodToCall.Signature.RequiredParameterCount
+                        then
+                            None, state
+                        else if
+
+                            meth.Name <> methodToCall.Name && Some meth.Name <> interfaceExplicitNamedMethod
+                        then
+                            None, state
+                        else
+
+                        // TODO: check if methodToCall's declaringtype is an interface; if so, check the possible prefixed name first
+
+                        let state, retType =
+                            meth.Signature.ReturnType
+                            |> IlMachineState.concretizeType
+                                loggerFactory
+                                baseClassTypes
+                                state
+                                meth.DeclaringType.Assembly
+                                methodToCall.DeclaringType.Generics
+                                methodToCall.Generics
+
+                        let paramTypes, state =
+                            (state, meth.Signature.ParameterTypes)
+                            ||> Seq.mapFold (fun state ty ->
+                                ty
+                                |> IlMachineState.concretizeType
+                                    loggerFactory
+                                    baseClassTypes
+                                    state
+                                    meth.DeclaringType.Assembly
+                                    methodToCall.DeclaringType.Generics
+                                    methodToCall.Generics
+                                |> fun (a, b) -> b, a
+                            )
+
+                        let paramTypes = List.ofSeq paramTypes
+
+                        if
+                            isAssignableFrom retType methodToCall.Signature.ReturnType state
+                            && paramTypes = methodToCall.Signature.ParameterTypes
+                        then
+                            Some (meth, Some meth.Name = interfaceExplicitNamedMethod), state
+                        else
+                            None, state
+                    )
+
+                let selfImplementation =
+                    selfImplementation
+                    |> List.choose id
+                    |> List.sortBy (fun (_, isInterface) -> if isInterface then -1 else 0)
+
+                match selfImplementation with
+                | (impl, true) :: l when (l |> List.forall (fun (_, b) -> not b)) ->
+                    logger.LogDebug "Found concrete implementation from an interface"
+
+                    let typeGenerics =
+                        AllConcreteTypes.lookup callingObjTyHandle state.ConcreteTypes
+                        |> Option.get
+                        |> _.Generics
+
+                    let state, meth, _ =
+                        IlMachineState.concretizeMethodWithAllGenerics
+                            loggerFactory
+                            baseClassTypes
+                            typeGenerics
+                            impl
+                            methodGenerics
+                            state
+
+                    state, meth
+                | [ impl, false ] ->
+                    logger.LogDebug "Found concrete implementation"
+                    // Yes, callingObjTy implements the method directly. No need to look up interfaces.
+                    let typeGenerics =
+                        AllConcreteTypes.lookup callingObjTyHandle state.ConcreteTypes
+                        |> Option.get
+                        |> _.Generics
+
+                    let state, meth, _ =
+                        IlMachineState.concretizeMethodWithAllGenerics
+                            loggerFactory
+                            baseClassTypes
+                            typeGenerics
+                            impl
+                            methodGenerics
+                            state
+
+                    state, meth
+                | _ :: _ ->
+                    selfImplementation
+                    |> List.map (fun (m, _) -> m.Name)
+                    |> String.concat ", "
+                    |> failwithf "multiple options: %s"
+                | [] ->
+
+                logger.LogDebug "No concrete implementation found; scanning interfaces"
+
+                // If not, what interfaces does it implement, and do any of those implement the method?
+                let possibleInterfaceMethods, state =
+                    (state, callingObjTy.ImplementedInterfaces)
+                    ||> Seq.mapFold (fun state impl ->
+                        let assy = state.LoadedAssembly impl.RelativeToAssembly |> Option.get
+
+                        let state, defn =
+                            match impl.InterfaceHandle with
+                            | MetadataToken.TypeDefinition defn ->
+                                let state, defn = IlMachineState.lookupTypeDefn baseClassTypes state assy defn
+
+                                let state, _, defn =
+                                    // TODO: generics
+                                    IlMachineState.resolveTypeFromDefn
+                                        loggerFactory
+                                        baseClassTypes
+                                        defn
+                                        ImmutableArray.Empty
+                                        ImmutableArray.Empty
+                                        assy
+                                        state
+
+                                state, defn
+                            | MetadataToken.TypeReference ty ->
+                                let state, defn, assy =
+                                    IlMachineState.lookupTypeRef loggerFactory baseClassTypes state assy Seq.empty ty
+
+                                state, failwith "TODO"
+                            | MetadataToken.TypeSpecification spec ->
+                                // TODO: generics
+                                let state, assy, defn =
+                                    IlMachineState.resolveTypeFromSpec
+                                        loggerFactory
+                                        baseClassTypes
+                                        spec
+                                        assy
+                                        ImmutableArray.Empty
+                                        ImmutableArray.Empty
+                                        state
+
+                                state, defn
+                            | handle -> failwith $"unexpected: {handle}"
+
+                        logger.LogDebug (
+                            "Interface {InterfaceName} (generics: {InterfaceGenerics})",
+                            defn.Name,
+                            defn.Generics
+                        )
+
+                        let s, state =
+                            defn.Methods
+                            |> Seq.filter (fun mi -> mi.Name = methodToCall.Name
+                            // TODO: also the rest of the signature
+                            )
+                            |> Seq.mapFold
+                                (fun state meth ->
+                                    // TODO: generics
+                                    let state, mi, _ =
+                                        IlMachineState.concretizeMethodForExecution
+                                            loggerFactory
+                                            baseClassTypes
+                                            thread
+                                            meth
+                                            None
+                                            (if defn.Generics.IsEmpty then None else Some defn.Generics)
+                                            state
+
+                                    mi, state
+                                )
+                                state
+
+                        s, state
+                    )
+
+                let possibleInterfaceMethods = possibleInterfaceMethods |> Seq.concat |> Seq.toList
+
+                match possibleInterfaceMethods with
+                | [] ->
+                    logger.LogDebug "No interface implementation found either"
+                    state, methodToCall
+                | [ meth ] ->
+                    logger.LogDebug (
+                        "Exactly one interface implementation found {DeclaringTypeNamespace}.{DeclaringTypeName}.{MethodName} ({MethodGenerics})",
+                        meth.DeclaringType.Namespace,
+                        meth.DeclaringType.Name,
+                        meth.Name,
+                        meth.Generics
+                    )
+
+                    state, meth
+                | _ -> failwith "TODO: handle overloads"
+            | _, _, true
+            | _, false, _
+            | Some _, _, _ -> state, methodToCall
+
+        // Helper to pop and coerce a single argument
+        let popAndCoerceArg zeroType methodState =
+            let value, newState = MethodState.popFromStack methodState
+            EvalStackValue.toCliTypeCoerced zeroType value, newState
+
+        // Collect arguments based on calling convention
+        let args, afterPop =
+            if methodToCall.IsStatic then
+                // Static method: pop args in reverse order
+                let args = ImmutableArray.CreateBuilder methodToCall.Parameters.Length
+                let mutable currentState = activeMethodState
+
+                for i = methodToCall.Parameters.Length - 1 downto 0 do
+                    let arg, newState = popAndCoerceArg argZeroObjects.[i] currentState
+                    args.Add arg
+                    currentState <- newState
+
+                args.Reverse ()
+                args.ToImmutable (), currentState
+            else
+                // Instance method: handle `this` pointer
+                let argCount = methodToCall.Parameters.Length
+                let args = ImmutableArray.CreateBuilder (argCount + 1)
+                let mutable currentState = activeMethodState
+
+                match wasConstructing with
+                | Some _ ->
+                    // Constructor: `this` is on top of stack, by our own odd little calling convention
+                    // where Newobj puts the object pointer on top
+                    let thisArg, newState =
+                        popAndCoerceArg
+                            (CliType.RuntimePointer (CliRuntimePointer.Managed ManagedPointerSource.Null))
+                            currentState
+
+                    currentState <- newState
+
+                    // Pop remaining args in reverse
+                    for i = argCount - 1 downto 0 do
+                        let arg, newState = popAndCoerceArg argZeroObjects.[i] currentState
+                        args.Add arg
+                        currentState <- newState
+
+                    args.Add thisArg
+                    args.Reverse ()
+                    args.ToImmutable (), currentState
+                | None ->
+                    // Regular instance method: args then `this`
+                    for i = argCount - 1 downto 0 do
+                        let arg, newState = popAndCoerceArg argZeroObjects.[i] currentState
+                        args.Add arg
+                        currentState <- newState
+
+                    let thisArg, newState =
+                        popAndCoerceArg
+                            (CliType.RuntimePointer (CliRuntimePointer.Managed ManagedPointerSource.Null))
+                            currentState
+
+                    args.Add thisArg
+                    currentState <- newState
+
+                    args.Reverse ()
+                    args.ToImmutable (), currentState
+
+        // Helper to create new frame with assembly loading
+        let rec createNewFrame state =
+            let returnInfo =
+                Some
+                    {
+                        JumpTo = threadState.ActiveMethodState
+                        WasInitialisingType = wasInitialising
+                        WasConstructingObj = wasConstructing
+                    }
+
+            match
+                MethodState.Empty
+                    state.ConcreteTypes
+                    baseClassTypes
+                    state._LoadedAssemblies
+                    (state.ActiveAssembly thread)
+                    methodToCall
+                    methodGenerics
+                    args
+                    returnInfo
+            with
+            | Ok frame -> state, frame
+            | Error toLoad ->
+                let state' =
+                    (state, toLoad)
+                    ||> List.fold (fun s (asmRef : WoofWare.PawPrint.AssemblyReference) ->
+                        let s, _, _ =
+                            IlMachineState.loadAssembly
+                                loggerFactory
+                                (state.LoadedAssembly methodToCall.DeclaringType.Assembly |> Option.get)
+                                (fst asmRef.Handle)
+                                s
+
+                        s
+                    )
+
+                createNewFrame state'
+
+        let state, newFrame = createNewFrame state
+
+        let oldFrame =
+            if wasClassConstructor || not advanceProgramCounterOfCaller then
+                afterPop
+            else
+                afterPop |> MethodState.advanceProgramCounter
+
+        let newThreadState =
+            { threadState with
+                MethodStates = threadState.MethodStates.Add(newFrame).SetItem (threadState.ActiveMethodState, oldFrame)
+                ActiveMethodState = threadState.MethodStates.Length
+            }
+
+        { state with
+            ThreadState = state.ThreadState |> Map.add thread newThreadState
+        }
+
+    let rec loadClass
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
+        (ty : ConcreteTypeHandle)
+        (currentThread : ThreadId)
+        (state : IlMachineState)
+        : StateLoadResult
+        =
+        let logger = loggerFactory.CreateLogger "LoadClass"
+
+        match TypeInitTable.tryGet ty state.TypeInitTable with
+        | Some TypeInitState.Initialized ->
+            // Type already initialized; nothing to do
+            StateLoadResult.NothingToDo state
+        | Some (TypeInitState.InProgress tid) when tid = currentThread ->
+            // We're already initializing this type on this thread; just proceed with the initialisation, no extra
+            // class loading required.
+            StateLoadResult.NothingToDo state
+        | Some (TypeInitState.InProgress _) ->
+            // This is usually signalled by WhatWeDid.Blocked
+            failwith
+                "TODO: cross-thread class init synchronization unimplemented - this thread has to wait for the other thread to finish initialisation"
+        | None ->
+            // We have work to do!
+
+            // Look up the concrete type from the handle
+            let concreteType =
+                match AllConcreteTypes.lookup ty state.ConcreteTypes with
+                | Some ct -> ct
+                | None -> failwith $"ConcreteTypeHandle {ty} not found in ConcreteTypes mapping"
+
+            let state, origAssyName =
+                state.WithThreadSwitchedToAssembly concreteType.Assembly currentThread
+
+            let sourceAssembly = state.LoadedAssembly concreteType.Assembly |> Option.get
+
+            let typeDef =
+                match sourceAssembly.TypeDefs.TryGetValue concreteType.Definition.Get with
+                | false, _ ->
+                    failwith
+                        $"Failed to find type definition {concreteType.Definition.Get} in {concreteType.Assembly.FullName}"
+                | true, v -> v
+
+            logger.LogDebug ("Resolving type {TypeDefNamespace}.{TypeDefName}", typeDef.Namespace, typeDef.Name)
+
+            // First mark as in-progress to detect cycles
+            let state = state.WithTypeBeginInit currentThread ty
+
+            // Check if the type has a base type that needs initialization
+            let firstDoBaseClass =
+                match typeDef.BaseType with
+                | Some baseTypeInfo ->
+                    // Determine if base type is in the same or different assembly
+                    match baseTypeInfo with
+                    | BaseTypeInfo.ForeignAssemblyType _ -> failwith "TODO"
+                    //logger.LogDebug (
+                    //    "Resolved base type of {TypeDefNamespace}.{TypeDefName} to foreign assembly {ForeignAssemblyName}",
+                    //    typeDef.Namespace,
+                    //    typeDef.Name,
+                    //    baseAssemblyName.Name
+                    //)
+
+                    //match loadClass loggerFactory baseTypeHandle baseAssemblyName currentThread state with
+                    //| FirstLoadThis state -> Error state
+                    //| NothingToDo state -> Ok state
+                    | BaseTypeInfo.TypeDef typeDefinitionHandle ->
+                        logger.LogDebug (
+                            "Resolved base type of {TypeDefNamespace}.{TypeDefName} to this assembly, typedef",
+                            typeDef.Namespace,
+                            typeDef.Name
+                        )
+
+                        let baseTypeDefn =
+                            DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies typeDef
+
+                        // Concretize the base type
+                        let state, baseTypeHandle =
+                            IlMachineState.concretizeType
+                                loggerFactory
+                                baseClassTypes
+                                state
+                                sourceAssembly.Name
+                                concreteType.Generics
+                                // TODO: surely we have generics in scope here?
+                                ImmutableArray.Empty
+                                baseTypeDefn
+
+                        // Recursively load the base class
+                        match loadClass loggerFactory baseClassTypes baseTypeHandle currentThread state with
+                        | FirstLoadThis state -> Error state
+                        | NothingToDo state -> Ok state
+                    | BaseTypeInfo.TypeRef typeReferenceHandle ->
+                        let state, assy, targetType =
+                            // TypeRef won't have any generics; it would be a TypeSpec if it did
+                            IlMachineState.resolveType
+                                loggerFactory
+                                typeReferenceHandle
+                                ImmutableArray.Empty
+                                (state.ActiveAssembly currentThread)
+                                state
+
+                        logger.LogDebug (
+                            "Resolved base type of {TypeDefNamespace}.{TypeDefName} to a typeref in assembly {ResolvedAssemblyName}, {BaseTypeNamespace}.{BaseTypeName}",
+                            typeDef.Namespace,
+                            typeDef.Name,
+                            assy.Name.Name,
+                            targetType.Namespace,
+                            targetType.Name
+                        )
+
+                        // Create a TypeDefn from the resolved TypeRef
+                        let baseTypeDefn =
+                            targetType
+                            |> DumpedAssembly.typeInfoToTypeDefn baseClassTypes state._LoadedAssemblies
+
+                        // Concretize the base type
+                        let state, baseTypeHandle =
+                            IlMachineState.concretizeType
+                                loggerFactory
+                                baseClassTypes
+                                state
+                                sourceAssembly.Name
+                                concreteType.Generics
+                                // TODO: surely we have generics in scope here?
+                                ImmutableArray.Empty
+                                baseTypeDefn
+
+                        // Recursively load the base class
+                        match loadClass loggerFactory baseClassTypes baseTypeHandle currentThread state with
+                        | FirstLoadThis state -> Error state
+                        | NothingToDo state -> Ok state
+                    | BaseTypeInfo.TypeSpec typeSpecificationHandle ->
+                        failwith "TODO: TypeSpec base type loading unimplemented"
+                | None -> Ok state // No base type (or it's System.Object)
+
+            match firstDoBaseClass with
+            | Error state -> FirstLoadThis state
+            | Ok state ->
+
+            // TODO: also need to initialise all interfaces implemented by the type
+
+            // Find the class constructor (.cctor) if it exists
+            let cctor =
+                typeDef.Methods
+                |> List.tryFind (fun method -> method.Name = ".cctor" && method.IsStatic && method.Parameters.IsEmpty)
+
+            match cctor with
+            | Some cctorMethod ->
+                // Call the class constructor! Note that we *don't* use `callMethodInActiveAssembly`, because that
+                // performs class loading, but we're already in the middle of loading this class.
+                // TODO: factor out the common bit.
+                let currentThreadState = state.ThreadState.[currentThread]
+
+                // Convert the method's type generics from TypeDefn to ConcreteTypeHandle
+                let cctorMethodWithTypeGenerics =
+                    cctorMethod
+                    |> MethodInfo.mapTypeGenerics (fun (par, _) -> concreteType.Generics.[par.SequenceNumber])
+
+                // Convert method generics (should be empty for cctor)
+                let cctorMethodWithMethodGenerics =
+                    cctorMethodWithTypeGenerics
+                    |> MethodInfo.mapMethodGenerics (fun _ -> failwith "cctor cannot be generic")
+
+                // Convert method signature from TypeDefn to ConcreteTypeHandle using concretization
+                let state, convertedSignature =
+                    cctorMethodWithMethodGenerics.Signature
+                    |> TypeMethodSignature.map
+                        state
+                        (fun state typeDefn ->
+                            IlMachineState.concretizeType
+                                loggerFactory
+                                baseClassTypes
+                                state
+                                concreteType.Assembly
+                                concreteType.Generics
+                                // no method generics for cctor
+                                ImmutableArray.Empty
+                                typeDefn
+                        )
+
+                // Convert method instructions (local variables)
+                let state, convertedInstructions =
+                    match cctorMethodWithMethodGenerics.Instructions with
+                    | None -> state, None
+                    | Some methodInstr ->
+                        let state, convertedLocalVars =
+                            match methodInstr.LocalVars with
+                            | None -> state, None
+                            | Some localVars ->
+                                // Concretize each local variable type
+                                let state, convertedVars =
+                                    ((state, []), localVars)
+                                    ||> Seq.fold (fun (state, acc) typeDefn ->
+                                        let state, handle =
+                                            IlMachineState.concretizeType
+                                                loggerFactory
+                                                baseClassTypes
+                                                state
+                                                concreteType.Assembly
+                                                concreteType.Generics
+                                                ImmutableArray.Empty // no method generics for cctor
+                                                typeDefn
+
+                                        state, handle :: acc
+                                    )
+                                    |> Tuple.rmap ImmutableArray.CreateRange
+
+                                state, Some convertedVars
+
+                        state, Some (MethodInstructions.setLocalVars convertedLocalVars methodInstr)
+
+                let fullyConvertedMethod =
+                    MethodInfo.setMethodVars convertedInstructions convertedSignature cctorMethodWithMethodGenerics
+
+                callMethod
+                    loggerFactory
+                    baseClassTypes
+                    (Some ty)
+                    None
+                    true
+                    true
+                    false
+                    // constructor is surely not generic
+                    ImmutableArray.Empty
+                    fullyConvertedMethod
+                    currentThread
+                    currentThreadState
+                    state
+                |> FirstLoadThis
+            | None ->
+                // No constructor, just continue.
+                // Mark the type as initialized.
+                let state = state.WithTypeEndInit currentThread ty
+
+                // Restore original assembly context if needed
+                state.WithThreadSwitchedToAssembly origAssyName currentThread
+                |> fst
+                |> NothingToDo
+
+    let ensureTypeInitialised
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
+        (thread : ThreadId)
+        (ty : ConcreteTypeHandle)
+        (state : IlMachineState)
+        : IlMachineState * WhatWeDid
+        =
+        match TypeInitTable.tryGet ty state.TypeInitTable with
+        | None ->
+            match loadClass loggerFactory baseClassTypes ty thread state with
+            | NothingToDo state -> state, WhatWeDid.Executed
+            | FirstLoadThis state -> state, WhatWeDid.SuspendedForClassInit
+        | Some TypeInitState.Initialized -> state, WhatWeDid.Executed
+        | Some (InProgress threadId) ->
+            if threadId = thread then
+                // II.10.5.3.2: avoid the deadlock by simply proceeding.
+                state, WhatWeDid.Executed
+            else
+                state, WhatWeDid.BlockedOnClassInit threadId
+
+    /// It may be useful to *not* advance the program counter of the caller, e.g. if you're using `callMethodInActiveAssembly`
+    /// as a convenient way to move to a different method body rather than to genuinely perform a call.
+    /// (Delegates do this, for example: we get a call to invoke the delegate, and then we implement the delegate as
+    /// another call to its function pointer.)
+    let callMethodInActiveAssembly
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
+        (thread : ThreadId)
+        (performInterfaceResolution : bool)
+        (advanceProgramCounterOfCaller : bool)
+        (methodGenerics : TypeDefn ImmutableArray option)
+        (methodToCall : WoofWare.PawPrint.MethodInfo<TypeDefn, GenericParamFromMetadata, TypeDefn>)
+        (weAreConstructingObj : ManagedHeapAddress option)
+        (typeArgsFromMetadata : TypeDefn ImmutableArray option)
+        (state : IlMachineState)
+        : IlMachineState * WhatWeDid
+        =
+        let threadState = state.ThreadState.[thread]
+
+        let state, concretizedMethod, declaringTypeHandle =
+            IlMachineState.concretizeMethodForExecution
+                loggerFactory
+                baseClassTypes
+                thread
+                methodToCall
+                methodGenerics
+                typeArgsFromMetadata
+                state
+
+        let state, typeInit =
+            ensureTypeInitialised loggerFactory baseClassTypes thread declaringTypeHandle state
+
+        match typeInit with
+        | WhatWeDid.Executed ->
+            callMethod
+                loggerFactory
+                baseClassTypes
+                None
+                weAreConstructingObj
+                performInterfaceResolution
+                false
+                advanceProgramCounterOfCaller
+                concretizedMethod.Generics
+                concretizedMethod
+                thread
+                threadState
+                state,
+            WhatWeDid.Executed
+        | _ -> state, typeInit

WoofWare.PawPrint/ImmutableArray.fs

@@ -0,0 +1,14 @@
+namespace WoofWare.PawPrint
+
+open System.Collections.Immutable
+
+[<RequireQualifiedAccess>]
+module internal ImmutableArray =
+
+    let map (f : 'a -> 'b) (arr : ImmutableArray<'a>) : ImmutableArray<'b> =
+        let b = ImmutableArray.CreateBuilder ()
+
+        for i in arr do
+            b.Add (f i)
+
+        b.ToImmutable ()

WoofWare.PawPrint/Intrinsics.fs

@@ -0,0 +1,655 @@
+namespace WoofWare.PawPrint
+
+open System
+open System.Collections.Immutable
+open Microsoft.Extensions.Logging
+
+[<RequireQualifiedAccess>]
+module Intrinsics =
+    let private safeIntrinsics =
+        [
+            // The IL implementation is fine: https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/Unsafe.cs#L677
+            "System.Private.CoreLib", "Unsafe", "AsRef"
+            // https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/libraries/System.Private.CoreLib/src/System/String.cs#L739-L750
+            "System.Private.CoreLib", "String", "get_Length"
+            // https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/libraries/System.Private.CoreLib/src/System/ArgumentNullException.cs#L54
+            "System.Private.CoreLib", "ArgumentNullException", "ThrowIfNull"
+            // https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/coreclr/System.Private.CoreLib/src/System/Type.CoreCLR.cs#L82
+            "System.Private.CoreLib", "Type", "GetTypeFromHandle"
+            // https://github.com/dotnet/runtime/blob/108fa7856efcfd39bc991c2d849eabbf7ba5989c/src/libraries/System.Private.CoreLib/src/System/ReadOnlySpan.cs#L161
+            "System.Private.CoreLib", "ReadOnlySpan`1", "get_Length"
+            // https://github.com/dotnet/runtime/blob/9e5e6aa7bc36aeb2a154709a9d1192030c30a2ef/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs#L153
+            "System.Private.CoreLib", "RuntimeHelpers", "CreateSpan"
+            // https://github.com/dotnet/runtime/blob/d258af50034c192bf7f0a18856bf83d2903d98ae/src/libraries/System.Private.CoreLib/src/System/Math.cs#L127
+            // https://github.com/dotnet/runtime/blob/d258af50034c192bf7f0a18856bf83d2903d98ae/src/libraries/System.Private.CoreLib/src/System/Math.cs#L137
+            "System.Private.CoreLib", "Math", "Abs"
+            // https://github.com/dotnet/runtime/blob/d258af50034c192bf7f0a18856bf83d2903d98ae/src/libraries/System.Private.CoreLib/src/System/Math.cs#L965C10-L1062C19
+            "System.Private.CoreLib", "Math", "Max"
+            // https://github.com/dotnet/runtime/blob/d258af50034c192bf7f0a18856bf83d2903d98ae/src/libraries/System.Private.CoreLib/src/System/Buffer.cs#L150
+            "System.Private.CoreLib", "Buffer", "Memmove"
+            // https://github.com/dotnet/runtime/blob/1c3221b63340d7f81dfd829f3bcd822e582324f6/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs#L799
+            "System.Private.CoreLib", "Thread", "get_CurrentThread"
+        ]
+        |> Set.ofList
+
+    type private RefTypeProcessingStatus =
+        | InProgress
+        | Completed of bool
+
+    let rec private containsRefType
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
+        (state : IlMachineState)
+        (seenSoFar : ImmutableDictionary<TypeInfo<TypeDefn, TypeDefn>, RefTypeProcessingStatus>)
+        (td : TypeInfo<TypeDefn, TypeDefn>)
+        : IlMachineState * ImmutableDictionary<_, RefTypeProcessingStatus> * bool
+        =
+        match seenSoFar.TryGetValue td with
+        | true, InProgress ->
+            // We've hit a cycle. Optimistically assume this path does not introduce a reference type.
+            // If another path finds a reference type, its 'true' will override this.
+            state, seenSoFar, false
+        | true, Completed v ->
+            // We've already calculated this; return the memoized result.
+            state, seenSoFar, v
+        | false, _ ->
+            // Check if this type itself is a reference type.
+            let baseType =
+                td.BaseType
+                |> DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies td.Assembly
+
+            match baseType with
+            | ResolvedBaseType.Delegate
+            | ResolvedBaseType.Object ->
+                // Short-circuit: if the type itself is a reference type, we're done.
+                let seenSoFar = seenSoFar.Add (td, Completed true)
+                state, seenSoFar, true
+            | ResolvedBaseType.Enum
+            | ResolvedBaseType.ValueType ->
+                // It's a value type, so we must check its fields.
+                // Mark as in progress before recursing.
+                let seenSoFarWithInProgress = seenSoFar.Add (td, InProgress)
+
+                let stateAfterFieldResolution, nonStaticFields =
+                    ((state, []), td.Fields)
+                    ||> List.fold (fun (currentState, acc) field ->
+                        if field.IsStatic then
+                            currentState, acc
+                        else
+                            // TODO: generics
+                            let newState, _, info =
+                                IlMachineState.resolveTypeFromDefn
+                                    loggerFactory
+                                    baseClassTypes
+                                    field.Signature
+                                    ImmutableArray.Empty
+                                    ImmutableArray.Empty
+                                    (currentState.LoadedAssembly (td.Assembly) |> Option.get)
+                                    currentState
+
+                            newState, info :: acc
+                    )
+
+                // Recurse through the fields, correctly propagating state.
+                let finalState, finalSeenSoFar, fieldsContainRefType =
+                    ((stateAfterFieldResolution, seenSoFarWithInProgress, false), nonStaticFields)
+                    ||> List.fold (fun (currentState, currentSeenSoFar, currentResult) field ->
+                        if currentResult then
+                            (currentState, currentSeenSoFar, true) // Short-circuit
+                        else
+                            let newState, newSeenSoFar, fieldResult =
+                                containsRefType loggerFactory baseClassTypes currentState currentSeenSoFar field
+
+                            (newState, newSeenSoFar, currentResult || fieldResult)
+                    )
+
+                // Mark as completed with the final result before returning.
+                let finalSeenSoFar = finalSeenSoFar.SetItem (td, Completed fieldsContainRefType)
+                finalState, finalSeenSoFar, fieldsContainRefType
+
+    let call
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<_>)
+        (methodToCall : WoofWare.PawPrint.MethodInfo<ConcreteTypeHandle, ConcreteTypeHandle, ConcreteTypeHandle>)
+        (currentThread : ThreadId)
+        (state : IlMachineState)
+        : IlMachineState option
+        =
+        let callerAssy =
+            state.ThreadState.[currentThread].MethodState.ExecutingMethod.DeclaringType.Assembly
+
+        if
+            methodToCall.DeclaringType.Assembly.Name = "System.Private.CoreLib"
+            && methodToCall.DeclaringType.Name = "Volatile"
+        then
+            // These are all safely implemented in IL, just inefficient.
+            // https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/libraries/System.Private.CoreLib/src/System/Threading/Volatile.cs#L13
+            None
+        elif
+            Set.contains
+                (methodToCall.DeclaringType.Assembly.Name, methodToCall.DeclaringType.Name, methodToCall.Name)
+                safeIntrinsics
+        then
+            None
+        else
+
+        // In general, some implementations are in:
+        // https://github.com/dotnet/runtime/blob/108fa7856efcfd39bc991c2d849eabbf7ba5989c/src/coreclr/tools/Common/TypeSystem/IL/Stubs/UnsafeIntrinsics.cs#L192
+        match methodToCall.DeclaringType.Assembly.Name, methodToCall.DeclaringType.Name, methodToCall.Name with
+        | "System.Private.CoreLib", "Type", "get_TypeHandle" ->
+            // TODO: check return type is RuntimeTypeHandle
+            match methodToCall.Signature.ParameterTypes with
+            | _ :: _ -> failwith "bad signature Type.get_TypeHandle"
+            | _ -> ()
+
+            // https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/libraries/System.Private.CoreLib/src/System/Type.cs#L470
+
+            // TODO: check return type is RuntimeTypeHandle
+            match methodToCall.Signature.ParameterTypes with
+            | _ :: _ -> failwith "bad signature Type.get_TypeHandle"
+            | _ -> ()
+
+            // no args, returns RuntimeTypeHandle, a struct with a single field (a RuntimeType class)
+            // https://github.com/dotnet/runtime/blob/1d1bf92fcf43aa6981804dc53c5174445069c9e4/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs#L18
+
+            // The thing on top of the stack will be a RuntimeType.
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let arg =
+                let rec go (arg : EvalStackValue) =
+                    match arg with
+                    | EvalStackValue.UserDefinedValueType vt ->
+                        match CliValueType.TryExactlyOneField vt with
+                        | None -> failwith "TODO"
+                        | Some field -> go (EvalStackValue.ofCliType field.Contents)
+                    | 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}"
+
+                go arg
+
+            let state =
+                let vt =
+                    // https://github.com/dotnet/runtime/blob/2b21c73fa2c32fa0195e4a411a435dda185efd08/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs#L92
+                    {
+                        Name = "m_type"
+                        Contents = CliType.ObjectRef arg
+                        Offset = None
+                        Type =
+                            AllConcreteTypes.findExistingConcreteType
+                                state.ConcreteTypes
+                                (baseClassTypes.RuntimeType.Assembly,
+                                 baseClassTypes.RuntimeType.Namespace,
+                                 baseClassTypes.RuntimeType.Name,
+                                 ImmutableArray.Empty)
+                            |> Option.get
+                    }
+                    |> List.singleton
+                    |> CliValueType.OfFields Layout.Default
+
+                IlMachineState.pushToEvalStack (CliType.ValueType vt) currentThread state
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            Some state
+        | "System.Private.CoreLib", "Type", "get_IsValueType" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [], ConcreteBool state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature Type.get_IsValueType"
+
+            let this, state = IlMachineState.popEvalStack currentThread state
+
+            let this =
+                match this with
+                | EvalStackValue.ObjectRef ptr ->
+                    IlMachineState.dereferencePointer state (ManagedPointerSource.Heap ptr)
+                | EvalStackValue.ManagedPointer ptr -> IlMachineState.dereferencePointer state ptr
+                | EvalStackValue.Float _
+                | EvalStackValue.Int32 _
+                | EvalStackValue.Int64 _ -> failwith "refusing to dereference literal"
+                | _ -> failwith "TODO"
+            // `this` should be of type Type
+            let ty =
+                match this with
+                | CliType.ValueType cvt ->
+                    match CliValueType.DereferenceField "m_handle" cvt with
+                    | CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.TypeHandlePtr cth)) -> cth
+                    | _ -> failwith ""
+                | _ -> failwith "expected a Type"
+
+            let ty = AllConcreteTypes.lookup ty state.ConcreteTypes |> Option.get
+            let ty = state.LoadedAssembly(ty.Assembly).Value.TypeDefs.[ty.Definition.Get]
+
+            let isValueType =
+                match DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies ty.Assembly ty.BaseType with
+                | ResolvedBaseType.Enum
+                | ResolvedBaseType.ValueType -> true
+                | ResolvedBaseType.Object
+                | ResolvedBaseType.Delegate -> false
+
+            IlMachineState.pushToEvalStack (CliType.ofBool isValueType) currentThread state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "Unsafe", "AsPointer" ->
+            // Method signature: 1 generic parameter, we take a Byref of that parameter, and return a TypeDefn.Pointer(Void)
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let toPush =
+                match arg with
+                | EvalStackValue.ManagedPointer ptr -> CliRuntimePointer.Managed ptr
+                | x -> failwith $"TODO: Unsafe.AsPointer(%O{x})"
+
+            IlMachineState.pushToEvalStack (CliType.RuntimePointer toPush) currentThread state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "SingleToInt32Bits" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteSingle state.ConcreteTypes ], ConcreteInt32 state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.SingleToInt32Bits"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                match arg with
+                | EvalStackValue.Float f -> BitConverter.SingleToInt32Bits (float32<float> f) |> EvalStackValue.Int32
+                | _ -> failwith "TODO"
+
+            state
+            |> IlMachineState.pushToEvalStack' result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "Int32BitsToSingle" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteInt32 state.ConcreteTypes ], ConcreteSingle state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.Int64BitsToSingle"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let arg =
+                match arg with
+                | EvalStackValue.Int32 i -> i
+                | _ -> failwith "$TODO: {arr}"
+
+            let result =
+                BitConverter.Int32BitsToSingle arg |> CliNumericType.Float32 |> CliType.Numeric
+
+            state
+            |> IlMachineState.pushToEvalStack result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "DoubleToUInt64Bits" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteDouble state.ConcreteTypes ], ConcreteUInt64 state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.DoubleToUInt64Bits"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let arg =
+                match arg with
+                | EvalStackValue.Float i -> i
+                | _ -> failwith "$TODO: {arr}"
+
+            let result =
+                BitConverter.DoubleToUInt64Bits arg
+                |> int64<uint64>
+                |> CliNumericType.Int64
+                |> CliType.Numeric
+
+            state
+            |> IlMachineState.pushToEvalStack result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "UInt64BitsToDouble" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteUInt64 state.ConcreteTypes ], ConcreteDouble state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.DoubleToUInt64Bits"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let arg =
+                match arg with
+                | EvalStackValue.Int64 i -> uint64 i
+                | _ -> failwith "$TODO: {arr}"
+
+            let result =
+                BitConverter.UInt64BitsToDouble arg |> CliNumericType.Float64 |> CliType.Numeric
+
+            state
+            |> IlMachineState.pushToEvalStack result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "Int64BitsToDouble" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteInt64 state.ConcreteTypes ], ConcreteDouble state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.Int64BitsToDouble"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let arg =
+                match arg with
+                | EvalStackValue.Int64 i -> i
+                | _ -> failwith "$TODO: {arr}"
+
+            let result =
+                BitConverter.Int64BitsToDouble arg |> CliNumericType.Float64 |> CliType.Numeric
+
+            state
+            |> IlMachineState.pushToEvalStack result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "DoubleToInt64Bits" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteDouble state.ConcreteTypes ], ConcreteInt64 state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.DoubleToInt64Bits"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                match arg with
+                | EvalStackValue.Float f -> BitConverter.DoubleToInt64Bits f |> EvalStackValue.Int64
+                | _ -> failwith "TODO"
+
+            state
+            |> IlMachineState.pushToEvalStack' result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "SingleToUInt32Bits" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteSingle state.ConcreteTypes ], ConcreteUInt32 state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.SingleToUInt32Bits"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                match arg with
+                | EvalStackValue.Float f ->
+                    BitConverter.SingleToUInt32Bits (float32<float> f)
+                    |> int<uint32>
+                    |> EvalStackValue.Int32
+                | _ -> failwith "TODO"
+
+            state
+            |> IlMachineState.pushToEvalStack' result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "BitConverter", "UInt32BitsToSingle" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteUInt32 state.ConcreteTypes ], ConcreteSingle state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature BitConverter.UInt32BitsToSingle"
+
+            let arg, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                match arg with
+                | EvalStackValue.Int32 f ->
+                    BitConverter.UInt32BitsToSingle (uint32<int> f)
+                    |> float<float32>
+                    |> EvalStackValue.Float
+                | _ -> failwith "TODO"
+
+            state
+            |> IlMachineState.pushToEvalStack' result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "String", "Equals" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteString state.ConcreteTypes ; ConcreteString state.ConcreteTypes ],
+              ConcreteBool state.ConcreteTypes ->
+                let arg1, state = IlMachineState.popEvalStack currentThread state
+
+                let arg1 =
+                    match arg1 with
+                    | EvalStackValue.ObjectRef h
+                    | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap h) -> h
+                    | EvalStackValue.Int32 _
+                    | EvalStackValue.Int64 _
+                    | EvalStackValue.Float _ -> failwith $"this isn't a string! {arg1}"
+                    | _ -> failwith $"TODO: %O{arg1}"
+
+                let arg2, state = IlMachineState.popEvalStack currentThread state
+
+                let arg2 =
+                    match arg2 with
+                    | EvalStackValue.ObjectRef h
+                    | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap h) -> h
+                    | EvalStackValue.Int32 _
+                    | EvalStackValue.Int64 _
+                    | EvalStackValue.Float _ -> failwith $"this isn't a string! {arg2}"
+                    | _ -> failwith $"TODO: %O{arg2}"
+
+                if arg1 = arg2 then
+                    state
+                    |> IlMachineState.pushToEvalStack (CliType.ofBool true) currentThread
+                    |> IlMachineState.advanceProgramCounter currentThread
+                    |> Some
+                else
+
+                let arg1 = ManagedHeap.get arg1 state.ManagedHeap
+                let arg2 = ManagedHeap.get arg2 state.ManagedHeap
+
+                if
+                    AllocatedNonArrayObject.DereferenceField "_firstChar" arg1
+                    <> AllocatedNonArrayObject.DereferenceField "_firstChar" arg2
+                then
+                    state
+                    |> IlMachineState.pushToEvalStack (CliType.ofBool false) currentThread
+                    |> IlMachineState.advanceProgramCounter currentThread
+                    |> Some
+                else
+                    failwith "TODO"
+            | _ -> None
+        | "System.Private.CoreLib", "Unsafe", "ReadUnaligned" ->
+            let ptr, state = IlMachineState.popEvalStack currentThread state
+
+            let v : CliType =
+                let rec go ptr =
+                    match ptr with
+                    | EvalStackValue.ManagedPointer src -> IlMachineState.dereferencePointer state src
+                    | EvalStackValue.NativeInt src -> failwith "TODO"
+                    | EvalStackValue.ObjectRef ptr -> failwith "TODO"
+                    | EvalStackValue.UserDefinedValueType vt ->
+                        match CliValueType.TryExactlyOneField vt with
+                        | None -> failwith "TODO"
+                        | Some field -> go (EvalStackValue.ofCliType field.Contents)
+                    | EvalStackValue.Int32 _
+                    | EvalStackValue.Int64 _
+                    | EvalStackValue.Float _ -> failwith $"this isn't a pointer! {ptr}"
+
+                go ptr
+
+            let state =
+                state
+                |> IlMachineState.pushToEvalStack v currentThread
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            Some state
+        | "System.Private.CoreLib", "String", "op_Implicit" ->
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ par ], ret ->
+                let par = state.ConcreteTypes |> AllConcreteTypes.lookup par |> Option.get
+                let ret = state.ConcreteTypes |> AllConcreteTypes.lookup ret |> Option.get
+
+                if
+                    par.Namespace = "System"
+                    && par.Name = "String"
+                    && ret.Namespace = "System"
+                    && ret.Name = "ReadOnlySpan`1"
+                then
+                    match ret.Generics |> Seq.toList with
+                    | [ gen ] ->
+                        let gen = state.ConcreteTypes |> AllConcreteTypes.lookup gen |> Option.get
+
+                        if gen.Namespace = "System" && gen.Name = "Char" then
+                            // This is just an optimisation
+                            // https://github.com/dotnet/runtime/blob/ab105b51f8b50ec5567d7cfe9001ca54dd6f64c3/src/libraries/System.Private.CoreLib/src/System/String.cs#L363-L366
+                            None
+                        else
+                            failwith "TODO: unexpected params to String.op_Implicit"
+                    | _ -> failwith "TODO: unexpected params to String.op_Implicit"
+                else
+                    failwith "TODO: unexpected params to String.op_Implicit"
+            | _ -> failwith "TODO: unexpected params to String.op_Implicit"
+        | "System.Private.CoreLib", "RuntimeHelpers", "IsReferenceOrContainsReferences" ->
+            // https://github.com/dotnet/runtime/blob/1d1bf92fcf43aa6981804dc53c5174445069c9e4/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs#L207
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [], ConcreteBool state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature for System.Private.CoreLib.RuntimeHelpers.IsReferenceOrContainsReference"
+
+            let arg = Seq.exactlyOne methodToCall.Generics
+
+            let state, result =
+                // Some types appear circular, because they're hardcoded in the runtime. We have to special-case them.
+                match arg with
+                | ConcreteChar state.ConcreteTypes -> state, false
+                | _ ->
+
+                let generic = AllConcreteTypes.lookup arg state.ConcreteTypes
+
+                let generic =
+                    match generic with
+                    | None -> failwith "somehow have not already concretised type in IsReferenceOrContainsReferences"
+                    | Some generic -> generic
+
+                let td =
+                    state.LoadedAssembly generic.Assembly
+                    |> Option.get
+                    |> fun a -> a.TypeDefs.[generic.Definition.Get]
+
+                let baseType =
+                    td.BaseType
+                    |> DumpedAssembly.resolveBaseType baseClassTypes state._LoadedAssemblies generic.Assembly
+
+                match baseType with
+                | ResolvedBaseType.Enum
+                | ResolvedBaseType.ValueType ->
+                    td
+                    |> TypeInfo.mapGeneric (fun (par, _) -> TypeDefn.GenericTypeParameter par.SequenceNumber)
+                    |> containsRefType loggerFactory baseClassTypes state ImmutableDictionary.Empty
+                    |> fun (state, _, result) -> state, result
+                | ResolvedBaseType.Object
+                | ResolvedBaseType.Delegate -> state, true
+
+            let state =
+                state
+                |> IlMachineState.pushToEvalStack (CliType.ofBool result) currentThread
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            Some state
+        | "System.Private.CoreLib", "RuntimeHelpers", "InitializeArray" ->
+            // https://github.com/dotnet/runtime/blob/9e5e6aa7bc36aeb2a154709a9d1192030c30a2ef/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs#L18
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteNonGenericArray state.ConcreteTypes ; ConcreteRuntimeFieldHandle state.ConcreteTypes ],
+              ConcreteVoid state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature for System.Private.CoreLib.RuntimeHelpers.InitializeArray"
+
+            failwith "TODO: if arg0 is null, throw NRE"
+            failwith "TODO: if arg1 contains null handle, throw ArgumentException"
+
+            failwith "TODO: array initialization"
+        | "System.Private.CoreLib", "Unsafe", "As" ->
+            // https://github.com/dotnet/runtime/blob/721fdf6dcb032da1f883d30884e222e35e3d3c99/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/Unsafe.cs#L64
+            let inputType, retType =
+                match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+                | [ input ], ret -> input, ret
+                | _ -> failwith "bad signature Unsafe.As"
+
+            let from, to_ =
+                match Seq.toList methodToCall.Generics with
+                | [ from ; to_ ] -> from, to_
+                | _ -> failwith "bad generics"
+
+            if ConcreteTypeHandle.Byref to_ <> retType then
+                failwith "bad return type"
+
+            if ConcreteTypeHandle.Byref from <> inputType then
+                failwith "bad input type"
+
+            let from =
+                match AllConcreteTypes.lookup from state.ConcreteTypes with
+                | None -> failwith "somehow have not concretised input type"
+                | Some t -> t
+
+            let to_ =
+                match AllConcreteTypes.lookup to_ state.ConcreteTypes with
+                | None -> failwith "somehow have not concretised ret type"
+                | Some t -> t
+
+            let inputAddr, state = IlMachineState.popEvalStack currentThread state
+
+            let ptr =
+                match inputAddr with
+                | EvalStackValue.Int32 _
+                | EvalStackValue.Int64 _
+                | EvalStackValue.Float _ -> failwith "expected pointer type"
+                | EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+                | EvalStackValue.ManagedPointer src ->
+                    ManagedPointerSource.InterpretedAsType (src, to_)
+                    |> EvalStackValue.ManagedPointer
+                | EvalStackValue.ObjectRef addr ->
+                    ManagedPointerSource.InterpretedAsType (ManagedPointerSource.Heap addr, to_)
+                    |> EvalStackValue.ManagedPointer
+                | EvalStackValue.UserDefinedValueType evalStackValueUserType -> failwith "todo"
+
+            let state =
+                state
+                |> IlMachineState.pushToEvalStack' ptr currentThread
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            Some state
+        | "System.Private.CoreLib", "Unsafe", "SizeOf" ->
+            // https://github.com/dotnet/runtime/blob/721fdf6dcb032da1f883d30884e222e35e3d3c99/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/Unsafe.cs#L51
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [], ConcreteInt32 state.ConcreteTypes -> ()
+            | _ -> failwith "bad signature Unsafe.SizeOf"
+
+            let ty =
+                match Seq.toList methodToCall.Generics with
+                | [ ty ] -> ty
+                | _ -> failwith "bad generics"
+
+            let zero, state = IlMachineState.cliTypeZeroOfHandle state baseClassTypes ty
+
+            let size = CliType.sizeOf zero
+
+            state
+            |> IlMachineState.pushToEvalStack (CliType.Numeric (CliNumericType.Int32 size)) currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | "System.Private.CoreLib", "RuntimeHelpers", "CreateSpan" ->
+            // https://github.com/dotnet/runtime/blob/9e5e6aa7bc36aeb2a154709a9d1192030c30a2ef/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs#L153
+            None
+        | "System.Private.CoreLib", "Type", "op_Equality" ->
+            // https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/libraries/System.Private.CoreLib/src/System/Type.cs#L703
+            None
+        | "System.Private.CoreLib", "MemoryMarshal", "GetArrayDataReference" ->
+            // https://github.com/dotnet/runtime/blob/d258af50034c192bf7f0a18856bf83d2903d98ae/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/MemoryMarshal.CoreCLR.cs#L20
+            let generic = Seq.exactlyOne methodToCall.Generics
+
+            match methodToCall.Signature.ParameterTypes, methodToCall.Signature.ReturnType with
+            | [ ConcreteGenericArray state.ConcreteTypes generic ], ConcreteByref t when t = generic -> ()
+            | _ -> failwith "bad signature MemoryMarshal.GetArrayDataReference"
+
+            let arr, state = IlMachineState.popEvalStack currentThread state
+
+            let toPush =
+                match arr with
+                | EvalStackValue.Int32 _
+                | EvalStackValue.Int64 _
+                | EvalStackValue.Float _ -> failwith "expected reference"
+                | EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+                | EvalStackValue.ObjectRef addr
+                | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr) ->
+                    if not (state.ManagedHeap.Arrays.ContainsKey addr) then
+                        failwith "array not found"
+
+                    EvalStackValue.ManagedPointer (ManagedPointerSource.ArrayIndex (addr, 0))
+                | EvalStackValue.UserDefinedValueType evalStackValueUserType -> failwith "todo"
+                | EvalStackValue.ManagedPointer ManagedPointerSource.Null -> failwith "TODO: raise NRE"
+                | EvalStackValue.ManagedPointer _ -> failwith "todo"
+
+            state
+            |> IlMachineState.pushToEvalStack' toPush currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Some
+        | a, b, c -> failwith $"TODO: implement JIT intrinsic {a}.{b}.{c}"
+        |> Option.map (fun s -> s.WithThreadSwitchedToAssembly callerAssy currentThread |> fst)

WoofWare.PawPrint/List.fs

@@ -0,0 +1,12 @@
+namespace WoofWare.PawPrint
+
+[<RequireQualifiedAccess>]
+module List =
+    let replaceWhere (f : 'a -> 'a option) (l : 'a list) : 'a list =
+        ([], l)
+        ||> List.fold (fun acc x ->
+            match f x with
+            | None -> x :: acc
+            | Some y -> y :: acc
+        )
+        |> List.rev

WoofWare.PawPrint/ManagedHeap.fs

@@ -8,11 +8,20 @@ type SyncBlock =
 
 type AllocatedNonArrayObject =
     {
-        Fields : Map<string, CliType>
-        Type : WoofWare.PawPrint.TypeInfoCrate
+        // TODO: this is a slightly odd domain; the same type for value types as class types!
+        Contents : CliValueType
+        ConcreteType : ConcreteTypeHandle
         SyncBlock : SyncBlock
     }
 
+    static member DereferenceField (name : string) (f : AllocatedNonArrayObject) : CliType =
+        CliValueType.DereferenceField name f.Contents
+
+    static member SetField (name : string) (v : CliType) (f : AllocatedNonArrayObject) : AllocatedNonArrayObject =
+        { f with
+            Contents = CliValueType.WithFieldSet name v f.Contents
+        }
+
 type AllocatedArray =
     {
         Length : int
@@ -29,7 +38,9 @@ type ManagedHeap =
         StringArrayData : ImmutableArray<char>
     }
 
-    static member Empty : ManagedHeap =
+[<RequireQualifiedAccess>]
+module ManagedHeap =
+    let empty : ManagedHeap =
         {
             NonArrayObjects = Map.empty
             FirstAvailableAddress = 1
@@ -37,12 +48,12 @@ type ManagedHeap =
             StringArrayData = ImmutableArray.Empty
         }
 
-    static member GetSyncBlock (addr : ManagedHeapAddress) (heap : ManagedHeap) : SyncBlock =
+    let getSyncBlock (addr : ManagedHeapAddress) (heap : ManagedHeap) : SyncBlock =
         match heap.NonArrayObjects.TryGetValue addr with
         | false, _ -> failwith "TODO: getting sync block of array"
         | true, v -> v.SyncBlock
 
-    static member SetSyncBlock (addr : ManagedHeapAddress) (syncValue : SyncBlock) (heap : ManagedHeap) : ManagedHeap =
+    let setSyncBlock (addr : ManagedHeapAddress) (syncValue : SyncBlock) (heap : ManagedHeap) : ManagedHeap =
         match heap.NonArrayObjects.TryGetValue addr with
         | false, _ -> failwith "TODO: locked on an array object"
         | true, v ->
@@ -55,7 +66,7 @@ type ManagedHeap =
                 NonArrayObjects = heap.NonArrayObjects |> Map.add addr newV
             }
 
-    static member AllocateArray (ty : AllocatedArray) (heap : ManagedHeap) : ManagedHeapAddress * ManagedHeap =
+    let allocateArray (ty : AllocatedArray) (heap : ManagedHeap) : ManagedHeapAddress * ManagedHeap =
         let addr = heap.FirstAvailableAddress
 
         let heap =
@@ -68,7 +79,7 @@ type ManagedHeap =
 
         ManagedHeapAddress addr, heap
 
-    static member AllocateString (len : int) (heap : ManagedHeap) : int * ManagedHeap =
+    let allocateString (len : int) (heap : ManagedHeap) : int * ManagedHeap =
         let addr = heap.StringArrayData.Length
 
         let heap =
@@ -80,7 +91,7 @@ type ManagedHeap =
 
         addr, heap
 
-    static member SetStringData (addr : int) (contents : string) (heap : ManagedHeap) : ManagedHeap =
+    let setStringData (addr : int) (contents : string) (heap : ManagedHeap) : ManagedHeap =
         let newArr =
             (heap.StringArrayData, seq { 0 .. contents.Length - 1 })
             ||> Seq.fold (fun data count -> data.SetItem (addr + count, contents.[count]))
@@ -92,11 +103,7 @@ type ManagedHeap =
 
         heap
 
-    static member AllocateNonArray
-        (ty : AllocatedNonArrayObject)
-        (heap : ManagedHeap)
-        : ManagedHeapAddress * ManagedHeap
-        =
+    let allocateNonArray (ty : AllocatedNonArrayObject) (heap : ManagedHeap) : ManagedHeapAddress * ManagedHeap =
         let addr = heap.FirstAvailableAddress
 
         let heap =
@@ -109,13 +116,27 @@ type ManagedHeap =
 
         ManagedHeapAddress addr, heap
 
-    static member SetArrayValue
-        (alloc : ManagedHeapAddress)
-        (offset : int)
-        (v : CliType)
-        (heap : ManagedHeap)
-        : ManagedHeap
-        =
+    let getArrayValue (alloc : ManagedHeapAddress) (offset : int) (heap : ManagedHeap) : CliType =
+        match heap.Arrays.TryGetValue alloc with
+        | false, _ -> failwith "TODO: array not on heap"
+        | true, arr ->
+
+        if offset < 0 || offset >= arr.Length then
+            failwith "TODO: raise IndexOutOfBoundsException"
+
+        arr.Elements.[offset]
+
+    let get (alloc : ManagedHeapAddress) (heap : ManagedHeap) : AllocatedNonArrayObject =
+        // 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
             |> Map.change
@@ -124,6 +145,9 @@ type ManagedHeap =
                     match arr with
                     | None -> failwith "tried to change element of nonexistent array"
                     | Some arr ->
+                        if offset < 0 || offset >= arr.Elements.Length then
+                            failwith "TODO: throw somehow"
+
                         { arr with
                             Elements = arr.Elements.SetItem (offset, v)
                         }

WoofWare.PawPrint/MethodState.fs

@@ -6,7 +6,7 @@ type MethodReturnState =
     {
         /// Index in the MethodStates array of a ThreadState
         JumpTo : int
-        WasInitialisingType : RuntimeConcreteType option
+        WasInitialisingType : ConcreteTypeHandle option
         /// The Newobj instruction means we need to push a reference immediately after Ret.
         WasConstructingObj : ManagedHeapAddress option
     }
@@ -19,16 +19,16 @@ and MethodState =
         _IlOpIndex : int
         EvaluationStack : EvalStack
         Arguments : CliType ImmutableArray
-        ExecutingMethod : WoofWare.PawPrint.MethodInfo<TypeDefn, TypeDefn>
+        ExecutingMethod : WoofWare.PawPrint.MethodInfo<ConcreteTypeHandle, ConcreteTypeHandle, ConcreteTypeHandle>
         /// We don't implement the local memory pool right now
         LocalMemoryPool : unit
         /// On return, we restore this state. This should be Some almost always; an exception is the entry point.
         ReturnState : MethodReturnState option
-        Generics : ImmutableArray<TypeDefn> option
+        Generics : ImmutableArray<ConcreteTypeHandle>
         /// Track which exception regions are currently active (innermost first)
         ActiveExceptionRegions : ExceptionRegion list
         /// When executing a finally/fault/filter, we need to know where to return
-        ExceptionContinuation : ExceptionContinuation option
+        ExceptionContinuation : ExceptionContinuation<ConcreteTypeHandle, ConcreteTypeHandle, ConcreteTypeHandle> option
     }
 
     member this.IlOpIndex = this._IlOpIndex
@@ -64,7 +64,7 @@ and MethodState =
             EvaluationStack = EvalStack.Empty
         }
 
-    static member setExceptionContinuation (cont : ExceptionContinuation) (state : MethodState) : MethodState =
+    static member setExceptionContinuation (cont : ExceptionContinuation<_, _, _>) (state : MethodState) : MethodState =
         { state with
             ExceptionContinuation = Some cont
         }
@@ -136,11 +136,12 @@ and MethodState =
     /// If `method` is an instance method, `args` must be of length 1+numParams.
     /// If `method` is static, `args` must be of length numParams.
     static member Empty
-        (corelib : BaseClassTypes<DumpedAssembly>)
+        (concreteTypes : AllConcreteTypes)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
         (loadedAssemblies : ImmutableDictionary<string, DumpedAssembly>)
         (containingAssembly : DumpedAssembly)
-        (method : WoofWare.PawPrint.MethodInfo<TypeDefn, TypeDefn>)
-        (methodGenerics : ImmutableArray<TypeDefn> option)
+        (method : WoofWare.PawPrint.MethodInfo<ConcreteTypeHandle, ConcreteTypeHandle, ConcreteTypeHandle>)
+        (methodGenerics : ImmutableArray<ConcreteTypeHandle>)
         (args : ImmutableArray<CliType>)
         (returnState : MethodReturnState option)
         : Result<MethodState, WoofWare.PawPrint.AssemblyReference list>
@@ -164,28 +165,18 @@ and MethodState =
         // I think valid code should remain valid if we unconditionally localsInit - it should be undefined
         // to use an uninitialised value? Not checked this; TODO.
 
-        let requiredAssemblies = ResizeArray<WoofWare.PawPrint.AssemblyReference> ()
-
-        let typeGenerics =
-            match method.DeclaringType.Generics with
-            | [] -> None
-            | x -> ImmutableArray.CreateRange x |> Some
-
         let localVars =
             let result = ImmutableArray.CreateBuilder ()
 
             for var in localVariableSig do
-                match CliType.zeroOf loadedAssemblies corelib containingAssembly typeGenerics methodGenerics var with
-                | CliTypeResolutionResult.Resolved t -> result.Add t
-                | CliTypeResolutionResult.FirstLoad (assy : WoofWare.PawPrint.AssemblyReference) ->
-                    requiredAssemblies.Add assy
+                // Note: This assumes all types have already been concretized
+                // If this fails with "ConcreteTypeHandle not found", it means
+                // we need to ensure types are concretized before creating the MethodState
+                let zero, _ = CliType.zeroOf concreteTypes loadedAssemblies baseClassTypes var
+                result.Add zero
 
             result.ToImmutable ()
 
-        if requiredAssemblies.Count > 0 then
-            Error (requiredAssemblies |> Seq.toList)
-        else
-
         let activeRegions = ExceptionHandling.getActiveRegionsAtOffset 0 method
 
         {

WoofWare.PawPrint/NullaryIlOp.fs

@@ -1,33 +1,8 @@
 namespace WoofWare.PawPrint
 
-#nowarn "42"
-
+open System
 open Microsoft.Extensions.Logging
 
-type private IArithmeticOperation =
-    abstract Int32Int32 : int32 -> int32 -> int32
-    abstract Int64Int64 : int64 -> int64 -> int64
-    abstract FloatFloat : float -> float -> float
-    abstract Name : string
-
-[<RequireQualifiedAccess>]
-module private ArithmeticOperation =
-    let add =
-        { new IArithmeticOperation with
-            member _.Int32Int32 a b = (# "add" a b : int32 #)
-            member _.Int64Int64 a b = (# "add" a b : int64 #)
-            member _.FloatFloat a b = (# "add" a b : float #)
-            member _.Name = "add"
-        }
-
-    let mul =
-        { new IArithmeticOperation with
-            member _.Int32Int32 a b = (# "mul" a b : int32 #)
-            member _.Int64Int64 a b = (# "mul" a b : int64 #)
-            member _.FloatFloat a b = (# "mul" a b : float #)
-            member _.Name = "mul"
-        }
-
 [<RequireQualifiedAccess>]
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module NullaryIlOp =
@@ -63,16 +38,6 @@ module NullaryIlOp =
         | LdindR4 -> CliType.Numeric (CliNumericType.Float32 0.0f)
         | LdindR8 -> CliType.Numeric (CliNumericType.Float64 0.0)
 
-    /// Retrieve a value from a pointer
-    let private loadFromPointerSource (state : IlMachineState) (src : ManagedPointerSource) : CliType =
-        match src with
-        | ManagedPointerSource.Null -> failwith "unexpected null pointer in Ldind operation"
-        | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) ->
-            state.ThreadState.[sourceThread].MethodStates.[methodFrame].Arguments.[int<uint16> whichVar]
-        | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
-            state.ThreadState.[sourceThread].MethodStates.[methodFrame].LocalVariables.[int<uint16> whichVar]
-        | ManagedPointerSource.Heap managedHeapAddress -> failwith "TODO: Heap pointer dereferencing not implemented"
-
     // Unified Ldind implementation
     let private executeLdind
         (targetType : LdindTargetType)
@@ -84,11 +49,11 @@ module NullaryIlOp =
 
         let loadedValue =
             match popped with
-            | EvalStackValue.ManagedPointer src -> loadFromPointerSource state src
+            | EvalStackValue.ManagedPointer src -> IlMachineState.dereferencePointer state src
             | EvalStackValue.NativeInt nativeIntSource ->
                 failwith $"TODO: Native int pointer dereferencing not implemented for {targetType}"
             | EvalStackValue.ObjectRef managedHeapAddress ->
-                failwith "TODO: Object reference dereferencing not implemented"
+                IlMachineState.dereferencePointer state (ManagedPointerSource.Heap managedHeapAddress)
             | other -> failwith $"Unexpected eval stack value for Ldind operation: {other}"
 
         let loadedValue = loadedValue |> EvalStackValue.ofCliType
@@ -103,41 +68,6 @@ module NullaryIlOp =
 
         (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
 
-    let private binaryArithmeticOperation
-        (op : IArithmeticOperation)
-        (currentThread : ThreadId)
-        (state : IlMachineState)
-        =
-        let val1, state = IlMachineState.popEvalStack currentThread state
-        let val2, state = IlMachineState.popEvalStack currentThread state
-        // see table at https://learn.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.add?view=net-9.0
-        let result =
-            match val1, val2 with
-            | EvalStackValue.Int32 val1, EvalStackValue.Int32 val2 ->
-                (# "add" val1 val2 : int32 #) |> EvalStackValue.Int32
-            | EvalStackValue.Int32 val1, EvalStackValue.NativeInt val2 -> failwith "" |> EvalStackValue.NativeInt
-            | EvalStackValue.Int32 val1, EvalStackValue.ManagedPointer val2 ->
-                failwith "" |> EvalStackValue.ManagedPointer
-            | EvalStackValue.Int32 val1, EvalStackValue.ObjectRef val2 -> failwith "" |> EvalStackValue.ObjectRef
-            | EvalStackValue.Int64 val1, EvalStackValue.Int64 val2 ->
-                (# "add" val1 val2 : int64 #) |> EvalStackValue.Int64
-            | EvalStackValue.NativeInt val1, EvalStackValue.Int32 val2 -> failwith "" |> EvalStackValue.NativeInt
-            | EvalStackValue.NativeInt val1, EvalStackValue.NativeInt val2 -> failwith "" |> EvalStackValue.NativeInt
-            | EvalStackValue.NativeInt val1, EvalStackValue.ManagedPointer val2 ->
-                failwith "" |> EvalStackValue.ManagedPointer
-            | EvalStackValue.NativeInt val1, EvalStackValue.ObjectRef val2 -> failwith "" |> EvalStackValue.ObjectRef
-            | EvalStackValue.Float val1, EvalStackValue.Float val2 ->
-                (# "add" val1 val2 : float #) |> EvalStackValue.Float
-            | EvalStackValue.ManagedPointer val1, EvalStackValue.NativeInt val2 ->
-                failwith "" |> EvalStackValue.ManagedPointer
-            | EvalStackValue.ObjectRef val1, EvalStackValue.NativeInt val2 -> failwith "" |> EvalStackValue.ObjectRef
-            | EvalStackValue.ManagedPointer val1, EvalStackValue.Int32 val2 ->
-                failwith "" |> EvalStackValue.ManagedPointer
-            | EvalStackValue.ObjectRef val1, EvalStackValue.Int32 val2 -> failwith "" |> EvalStackValue.ObjectRef
-            | val1, val2 -> failwith $"invalid %s{op.Name} operation: {val1} and {val2}"
-
-        result, state
-
     let private stind (varType : CliType) (currentThread : ThreadId) (state : IlMachineState) : IlMachineState =
         // TODO: throw NullReferenceException if unaligned target
         let valueToStore, state = IlMachineState.popEvalStack currentThread state
@@ -152,6 +82,7 @@ module NullaryIlOp =
         | EvalStackValue.ManagedPointer src ->
             match src with
             | ManagedPointerSource.Null -> failwith "TODO: throw NullReferenceException"
+            | ManagedPointerSource.InterpretedAsType (src, ty) -> failwith "TODO"
             | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) ->
                 failwith "unexpected - can we really write to an argument?"
             | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
@@ -182,8 +113,86 @@ module NullaryIlOp =
                             )
                 }
             | ManagedPointerSource.Heap managedHeapAddress -> failwith "todo"
+            | ManagedPointerSource.ArrayIndex _ -> failwith "todo"
+            | ManagedPointerSource.Field (managedPointerSource, fieldName) -> failwith "todo"
         | EvalStackValue.ObjectRef managedHeapAddress -> failwith "todo"
 
+    let internal ldElem
+        (index : EvalStackValue)
+        (arr : EvalStackValue)
+        (currentThread : ThreadId)
+        (state : IlMachineState)
+        : ExecutionResult
+        =
+        let index =
+            match index with
+            | EvalStackValue.NativeInt src ->
+                match src with
+                | NativeIntSource.FunctionPointer _
+                | NativeIntSource.FieldHandlePtr _
+                | NativeIntSource.TypeHandlePtr _
+                | NativeIntSource.ManagedPointer _ -> failwith "Refusing to treat a pointer as an array index"
+                | NativeIntSource.Verbatim i -> i |> int32
+            | EvalStackValue.Int32 i -> i
+            | _ -> failwith $"Invalid index: {index}"
+
+        let arrAddr =
+            match arr with
+            | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr)
+            | EvalStackValue.ObjectRef addr -> addr
+            | EvalStackValue.ManagedPointer ManagedPointerSource.Null -> failwith "TODO: throw NRE"
+            | _ -> failwith $"Invalid array: %O{arr}"
+
+        let value = IlMachineState.getArrayValue arrAddr index state
+
+        let state =
+            state
+            |> IlMachineState.pushToEvalStack value currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+
+        ExecutionResult.Stepped (state, WhatWeDid.Executed)
+
+    let internal stElem
+        (targetCliTypeZero : CliType)
+        (value : EvalStackValue)
+        (index : EvalStackValue)
+        (arr : EvalStackValue)
+        (currentThread : ThreadId)
+        (state : IlMachineState)
+        : ExecutionResult
+        =
+        let index =
+            match index with
+            | EvalStackValue.NativeInt src ->
+                match src with
+                | NativeIntSource.FunctionPointer _
+                | NativeIntSource.FieldHandlePtr _
+                | NativeIntSource.TypeHandlePtr _
+                | NativeIntSource.ManagedPointer _ -> failwith "Refusing to treat a pointer as an array index"
+                | NativeIntSource.Verbatim i -> i |> int32
+            | EvalStackValue.Int32 i -> i
+            | _ -> failwith $"Invalid index: {index}"
+
+        let arrAddr =
+            match arr with
+            | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr)
+            | EvalStackValue.ObjectRef addr -> addr
+            | EvalStackValue.ManagedPointer ManagedPointerSource.Null -> failwith "TODO: throw NRE"
+            | _ -> failwith $"Invalid array: %O{arr}"
+        // TODO: throw ArrayTypeMismatchException if incorrect types
+
+        let arr = state.ManagedHeap.Arrays.[arrAddr]
+
+        if index < 0 || index >= arr.Length then
+            failwith "TODO: throw IndexOutOfRangeException"
+
+        let state =
+            state
+            |> IlMachineState.setArrayValue arrAddr (EvalStackValue.toCliTypeCoerced targetCliTypeZero value) index
+            |> IlMachineState.advanceProgramCounter currentThread
+
+        ExecutionResult.Stepped (state, WhatWeDid.Executed)
+
     let internal execute
         (loggerFactory : ILoggerFactory)
         (corelib : BaseClassTypes<DumpedAssembly>)
@@ -346,92 +355,57 @@ module NullaryIlOp =
             let var2, state = state |> IlMachineState.popEvalStack currentThread
             let var1, state = state |> IlMachineState.popEvalStack currentThread
 
-            let comparisonResult =
-                // Table III.4
-                match var1, var2 with
-                | EvalStackValue.Int32 var1, EvalStackValue.Int32 var2 -> if var1 = var2 then 1 else 0
-                | EvalStackValue.Int32 var1, EvalStackValue.NativeInt var2 -> failwith "TODO: int32 CEQ nativeint"
-                | EvalStackValue.Int32 _, _ -> failwith $"bad ceq: Int32 vs {var2}"
-                | EvalStackValue.Int64 var1, EvalStackValue.Int64 var2 -> if var1 = var2 then 1 else 0
-                | EvalStackValue.Int64 _, _ -> failwith $"bad ceq: Int64 vs {var2}"
-                | EvalStackValue.Float var1, EvalStackValue.Float var2 -> failwith "TODO: float CEQ float"
-                | EvalStackValue.Float _, _ -> failwith $"bad ceq: Float vs {var2}"
-                | EvalStackValue.NativeInt var1, EvalStackValue.NativeInt var2 ->
-                    match var1, var2 with
-                    | NativeIntSource.FunctionPointer f1, NativeIntSource.FunctionPointer f2 ->
-                        if f1 = f2 then
-                            1
-                        else
-                            failwith $"TODO(CEQ): nativeint vs nativeint, {f1} vs {f2}"
-                    | NativeIntSource.TypeHandlePtr f1, NativeIntSource.TypeHandlePtr f2 -> if f1 = f2 then 1 else 0
-                    | NativeIntSource.Verbatim f1, NativeIntSource.Verbatim f2 -> if f1 = f2 then 1 else 0
-                    | NativeIntSource.ManagedPointer f1, NativeIntSource.ManagedPointer f2 -> if f1 = f2 then 1 else 0
-                    | _, _ -> failwith $"TODO (CEQ): nativeint vs nativeint, {var1} vs {var2}"
-                | EvalStackValue.NativeInt var1, EvalStackValue.Int32 var2 -> failwith $"TODO (CEQ): nativeint vs int32"
-                | EvalStackValue.NativeInt var1, EvalStackValue.ManagedPointer var2 ->
-                    failwith $"TODO (CEQ): nativeint vs managed pointer"
-                | EvalStackValue.NativeInt _, _ -> failwith $"bad ceq: NativeInt vs {var2}"
-                | EvalStackValue.ObjectRef var1, EvalStackValue.ObjectRef var2 -> if var1 = var2 then 1 else 0
-                | EvalStackValue.ObjectRef _, _ -> failwith $"bad ceq: ObjectRef vs {var2}"
-                | EvalStackValue.ManagedPointer var1, EvalStackValue.ManagedPointer var2 -> if var1 = var2 then 1 else 0
-                | EvalStackValue.ManagedPointer var1, EvalStackValue.NativeInt var2 ->
-                    failwith $"TODO (CEQ): managed pointer vs nativeint"
-                | EvalStackValue.ManagedPointer _, _ -> failwith $"bad ceq: ManagedPointer vs {var2}"
-                | EvalStackValue.UserDefinedValueType _, _ -> failwith $"bad ceq: UserDefinedValueType vs {var2}"
+            let comparisonResult = if EvalStackValueComparisons.ceq var1 var2 then 1 else 0
+
+            state
+            |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 comparisonResult) currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Tuple.withRight WhatWeDid.Executed
+            |> ExecutionResult.Stepped
+        | Cgt ->
+            let var2, state = state |> IlMachineState.popEvalStack currentThread
+            let var1, state = state |> IlMachineState.popEvalStack currentThread
+
+            let comparisonResult = if EvalStackValueComparisons.cgt var1 var2 then 1 else 0
+
+            state
+            |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 comparisonResult) currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Tuple.withRight WhatWeDid.Executed
+            |> ExecutionResult.Stepped
+        | Cgt_un ->
+            let var2, state = state |> IlMachineState.popEvalStack currentThread
+            let var1, state = state |> IlMachineState.popEvalStack currentThread
+
+            let comparisonResult = if EvalStackValueComparisons.cgtUn var1 var2 then 1 else 0
 
             state
             |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 comparisonResult) currentThread
             |> IlMachineState.advanceProgramCounter currentThread
             |> Tuple.withRight WhatWeDid.Executed
             |> ExecutionResult.Stepped
-        | Cgt -> failwith "TODO: Cgt unimplemented"
-        | Cgt_un -> failwith "TODO: Cgt_un unimplemented"
         | Clt ->
             let var2, state = state |> IlMachineState.popEvalStack currentThread
             let var1, state = state |> IlMachineState.popEvalStack currentThread
 
-            let comparisonResult =
-                match var1, var2 with
-                | EvalStackValue.Int64 var1, EvalStackValue.Int64 var2 -> if var1 < var2 then 1 else 0
-                | EvalStackValue.Float var1, EvalStackValue.Float var2 ->
-                    failwith "TODO: Clt float comparison unimplemented"
-                | EvalStackValue.ObjectRef var1, EvalStackValue.ObjectRef var2 ->
-                    failwith $"Clt instruction invalid for comparing object refs, {var1} vs {var2}"
-                | EvalStackValue.ObjectRef var1, other -> failwith $"invalid comparison, ref %O{var1} vs %O{other}"
-                | other, EvalStackValue.ObjectRef var2 -> failwith $"invalid comparison, %O{other} vs ref %O{var2}"
-                | EvalStackValue.Float i, other -> failwith $"invalid comparison, float %f{i} vs %O{other}"
-                | other, EvalStackValue.Float i -> failwith $"invalid comparison, %O{other} vs float %f{i}"
-                | EvalStackValue.Int64 i, other -> failwith $"invalid comparison, int64 %i{i} vs %O{other}"
-                | other, EvalStackValue.Int64 i -> failwith $"invalid comparison, %O{other} vs int64 %i{i}"
-                | EvalStackValue.Int32 var1, EvalStackValue.Int32 var2 -> if var1 < var2 then 1 else 0
-                | EvalStackValue.Int32 var1, EvalStackValue.NativeInt var2 ->
-                    failwith "TODO: Clt Int32 vs NativeInt comparison unimplemented"
-                | EvalStackValue.Int32 i, other -> failwith $"invalid comparison, int32 %i{i} vs %O{other}"
-                | EvalStackValue.NativeInt var1, EvalStackValue.Int32 var2 ->
-                    failwith "TODO: Clt NativeInt vs Int32 comparison unimplemented"
-                | other, EvalStackValue.Int32 var2 -> failwith $"invalid comparison, {other} vs int32 {var2}"
-                | EvalStackValue.NativeInt var1, EvalStackValue.NativeInt var2 ->
-                    if NativeIntSource.isLess var1 var2 then 1 else 0
-                | EvalStackValue.NativeInt var1, other -> failwith $"invalid comparison, nativeint {var1} vs %O{other}"
-                | EvalStackValue.ManagedPointer managedPointerSource, NativeInt int64 ->
-                    failwith "TODO: Clt ManagedPointer vs NativeInt comparison unimplemented"
-                | EvalStackValue.ManagedPointer managedPointerSource, ManagedPointer pointerSource ->
-                    failwith "TODO: Clt ManagedPointer vs ManagedPointer comparison unimplemented"
-                | EvalStackValue.ManagedPointer managedPointerSource, UserDefinedValueType _ ->
-                    failwith "TODO: Clt ManagedPointer vs UserDefinedValueType comparison unimplemented"
-                | EvalStackValue.UserDefinedValueType _, NativeInt int64 ->
-                    failwith "TODO: Clt UserDefinedValueType vs NativeInt comparison unimplemented"
-                | EvalStackValue.UserDefinedValueType _, ManagedPointer managedPointerSource ->
-                    failwith "TODO: Clt UserDefinedValueType vs ManagedPointer comparison unimplemented"
-                | EvalStackValue.UserDefinedValueType _, UserDefinedValueType _ ->
-                    failwith "TODO: Clt UserDefinedValueType vs UserDefinedValueType comparison unimplemented"
+            let comparisonResult = if EvalStackValueComparisons.clt var1 var2 then 1 else 0
+
+            state
+            |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 comparisonResult) currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Tuple.withRight WhatWeDid.Executed
+            |> ExecutionResult.Stepped
+        | Clt_un ->
+            let var2, state = state |> IlMachineState.popEvalStack currentThread
+            let var1, state = state |> IlMachineState.popEvalStack currentThread
+
+            let comparisonResult = if EvalStackValueComparisons.cltUn var1 var2 then 1 else 0
 
             state
             |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 comparisonResult) currentThread
             |> IlMachineState.advanceProgramCounter currentThread
             |> Tuple.withRight WhatWeDid.Executed
             |> ExecutionResult.Stepped
-        | Clt_un -> failwith "TODO: Clt_un unimplemented"
         | Stloc_0 ->
             state
             |> IlMachineState.popFromStackToLocalVariable currentThread 0
@@ -456,12 +430,22 @@ module NullaryIlOp =
             |> IlMachineState.advanceProgramCounter currentThread
             |> Tuple.withRight WhatWeDid.Executed
             |> ExecutionResult.Stepped
-        | Sub -> failwith "TODO: Sub unimplemented"
+        | Sub ->
+            let val2, state = IlMachineState.popEvalStack currentThread state
+            let val1, state = IlMachineState.popEvalStack currentThread state
+            let result = BinaryArithmetic.execute ArithmeticOperation.sub state val1 val2
+
+            state
+            |> IlMachineState.pushToEvalStack' result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Tuple.withRight WhatWeDid.Executed
+            |> ExecutionResult.Stepped
         | Sub_ovf -> failwith "TODO: Sub_ovf unimplemented"
         | Sub_ovf_un -> failwith "TODO: Sub_ovf_un unimplemented"
         | Add ->
-            let result, state =
-                binaryArithmeticOperation ArithmeticOperation.add currentThread state
+            let val2, state = IlMachineState.popEvalStack currentThread state
+            let val1, state = IlMachineState.popEvalStack currentThread state
+            let result = BinaryArithmetic.execute ArithmeticOperation.add state val1 val2
 
             state
             |> IlMachineState.pushToEvalStack' result currentThread
@@ -471,23 +455,168 @@ module NullaryIlOp =
         | Add_ovf -> failwith "TODO: Add_ovf unimplemented"
         | Add_ovf_un -> failwith "TODO: Add_ovf_un unimplemented"
         | Mul ->
-            let result, state =
-                binaryArithmeticOperation ArithmeticOperation.mul currentThread state
+            let val2, state = IlMachineState.popEvalStack currentThread state
+            let val1, state = IlMachineState.popEvalStack currentThread state
+            let result = BinaryArithmetic.execute ArithmeticOperation.mul state val1 val2
 
             state
             |> IlMachineState.pushToEvalStack' result currentThread
             |> IlMachineState.advanceProgramCounter currentThread
             |> Tuple.withRight WhatWeDid.Executed
             |> ExecutionResult.Stepped
-        | Mul_ovf -> failwith "TODO: Mul_ovf unimplemented"
+        | Mul_ovf ->
+            let val2, state = IlMachineState.popEvalStack currentThread state
+            let val1, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                try
+                    BinaryArithmetic.execute ArithmeticOperation.mulOvf state val1 val2 |> Ok
+                with :? OverflowException as e ->
+                    Error e
+
+            let state =
+                match result with
+                | Ok result -> state |> IlMachineState.pushToEvalStack' result currentThread
+                | Error excToThrow -> failwith "TODO: throw OverflowException"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Tuple.withRight WhatWeDid.Executed
+            |> ExecutionResult.Stepped
         | Mul_ovf_un -> failwith "TODO: Mul_ovf_un unimplemented"
-        | Div -> failwith "TODO: Div unimplemented"
+        | Div ->
+            let val2, state = IlMachineState.popEvalStack currentThread state
+            let val1, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                try
+                    BinaryArithmetic.execute ArithmeticOperation.div state val1 val2 |> Ok
+                with :? OverflowException as e ->
+                    Error e
+
+            let state =
+                match result with
+                | Ok result -> state |> IlMachineState.pushToEvalStack' result currentThread
+                | Error excToThrow -> failwith "TODO: throw OverflowException"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Tuple.withRight WhatWeDid.Executed
+            |> ExecutionResult.Stepped
         | Div_un -> failwith "TODO: Div_un unimplemented"
-        | Shr -> failwith "TODO: Shr unimplemented"
+        | Shr ->
+            let shift, state = IlMachineState.popEvalStack currentThread state
+            let number, state = IlMachineState.popEvalStack currentThread state
+
+            let shift =
+                match shift with
+                | EvalStackValue.Int32 i -> i
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim i) -> int<int64> i
+                | _ -> failwith $"Not allowed shift of {shift}"
+
+            let result =
+                // See table III.6
+                match number with
+                | EvalStackValue.Int32 i -> i >>> shift |> EvalStackValue.Int32
+                | EvalStackValue.Int64 i -> i >>> shift |> EvalStackValue.Int64
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim i) ->
+                    (i >>> shift) |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | _ -> failwith $"Not allowed to shift {number}"
+
+            let state =
+                state
+                |> IlMachineState.pushToEvalStack' result currentThread
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
         | Shr_un -> failwith "TODO: Shr_un unimplemented"
-        | Shl -> failwith "TODO: Shl unimplemented"
-        | And -> failwith "TODO: And unimplemented"
-        | Or -> failwith "TODO: Or unimplemented"
+        | Shl ->
+            let shift, state = IlMachineState.popEvalStack currentThread state
+            let number, state = IlMachineState.popEvalStack currentThread state
+
+            let shift =
+                match shift with
+                | EvalStackValue.Int32 i -> i
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim i) -> int<int64> i
+                | _ -> failwith $"Not allowed shift of {shift}"
+
+            let result =
+                // See table III.6
+                match number with
+                | EvalStackValue.Int32 i -> i <<< shift |> EvalStackValue.Int32
+                | EvalStackValue.Int64 i -> i <<< shift |> EvalStackValue.Int64
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim i) ->
+                    (i <<< shift) |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | _ -> failwith $"Not allowed to shift {number}"
+
+            let state =
+                state
+                |> IlMachineState.pushToEvalStack' result currentThread
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
+        | And ->
+            let v2, state = IlMachineState.popEvalStack currentThread state
+            let v1, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                match v1, v2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 -> v1 &&& v2 |> EvalStackValue.Int32
+                | EvalStackValue.Int32 v1, EvalStackValue.NativeInt (NativeIntSource.Verbatim v2) ->
+                    int64<int32> v1 &&& v2 |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | EvalStackValue.Int32 _, EvalStackValue.NativeInt _ ->
+                    failwith $"can't do binary operation on non-verbatim native int {v2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 -> v1 &&& v2 |> EvalStackValue.Int64
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim v1), EvalStackValue.Int32 v2 ->
+                    v1 &&& int64<int32> v2 |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | EvalStackValue.NativeInt _, EvalStackValue.Int32 _ ->
+                    failwith $"can't do binary operation on non-verbatim native int {v1}"
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim v1),
+                  EvalStackValue.NativeInt (NativeIntSource.Verbatim v2) ->
+                    v1 &&& v2 |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim _), EvalStackValue.NativeInt _ ->
+                    failwith $"can't do binary operation on non-verbatim native int {v2}"
+                | EvalStackValue.NativeInt _, EvalStackValue.NativeInt (NativeIntSource.Verbatim _) ->
+                    failwith $"can't do binary operation on non-verbatim native int {v1}"
+                | _, _ -> failwith $"refusing to do binary operation on {v1} and {v2}"
+
+            let state =
+                state
+                |> IlMachineState.pushToEvalStack' result currentThread
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
+        | Or ->
+            let v2, state = IlMachineState.popEvalStack currentThread state
+            let v1, state = IlMachineState.popEvalStack currentThread state
+
+            let result =
+                match v1, v2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 -> v1 ||| v2 |> EvalStackValue.Int32
+                | EvalStackValue.Int32 v1, EvalStackValue.NativeInt (NativeIntSource.Verbatim v2) ->
+                    int64<int32> v1 ||| v2 |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | EvalStackValue.Int32 _, EvalStackValue.NativeInt _ ->
+                    failwith $"can't do binary operation on non-verbatim native int {v2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 -> v1 ||| v2 |> EvalStackValue.Int64
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim v1), EvalStackValue.Int32 v2 ->
+                    v1 ||| int64<int32> v2 |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | EvalStackValue.NativeInt _, EvalStackValue.Int32 _ ->
+                    failwith $"can't do binary operation on non-verbatim native int {v1}"
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim v1),
+                  EvalStackValue.NativeInt (NativeIntSource.Verbatim v2) ->
+                    v1 ||| v2 |> NativeIntSource.Verbatim |> EvalStackValue.NativeInt
+                | EvalStackValue.NativeInt (NativeIntSource.Verbatim _), EvalStackValue.NativeInt _ ->
+                    failwith $"can't do binary operation on non-verbatim native int {v2}"
+                | EvalStackValue.NativeInt _, EvalStackValue.NativeInt (NativeIntSource.Verbatim _) ->
+                    failwith $"can't do binary operation on non-verbatim native int {v1}"
+                | _, _ -> failwith $"refusing to do binary operation on {v1} and {v2}"
+
+            let state =
+                state
+                |> IlMachineState.pushToEvalStack' result currentThread
+                |> IlMachineState.advanceProgramCounter currentThread
+
+            (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
         | Xor -> failwith "TODO: Xor unimplemented"
         | Conv_I ->
             let popped, state = IlMachineState.popEvalStack currentThread state
@@ -559,7 +688,20 @@ module NullaryIlOp =
             let state = state |> IlMachineState.advanceProgramCounter currentThread
 
             (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
-        | Conv_U1 -> failwith "TODO: Conv_U1 unimplemented"
+        | Conv_U1 ->
+            let popped, state = IlMachineState.popEvalStack currentThread state
+            let converted = EvalStackValue.convToUInt8 popped
+
+            let state =
+                match converted with
+                | None -> failwith "TODO: Conv_U8 conversion failure unimplemented"
+                | Some conv ->
+                    state
+                    |> IlMachineState.pushToEvalStack' (EvalStackValue.Int32 conv) currentThread
+
+            let state = state |> IlMachineState.advanceProgramCounter currentThread
+
+            (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
         | Conv_U2 -> failwith "TODO: Conv_U2 unimplemented"
         | Conv_U4 -> failwith "TODO: Conv_U4 unimplemented"
         | Conv_U8 ->
@@ -582,6 +724,7 @@ module NullaryIlOp =
             let popped =
                 match popped with
                 | EvalStackValue.ManagedPointer ManagedPointerSource.Null -> failwith "TODO: throw NRE"
+                | EvalStackValue.ObjectRef addr
                 | EvalStackValue.ManagedPointer (ManagedPointerSource.Heap addr) -> addr
                 | _ -> failwith $"can't get len of {popped}"
 
@@ -675,7 +818,7 @@ module NullaryIlOp =
             match
                 ExceptionHandling.findExceptionHandler
                     currentMethodState.IlOpIndex
-                    heapObject.Type
+                    heapObject.ConcreteType
                     currentMethodState.ExecutingMethod
                     state._LoadedAssemblies
             with
@@ -766,7 +909,16 @@ module NullaryIlOp =
         | Ldind_u8 -> failwith "TODO: Ldind_u8 unimplemented"
         | Ldind_r4 -> executeLdind LdindTargetType.LdindR4 currentThread state
         | Ldind_r8 -> executeLdind LdindTargetType.LdindR8 currentThread state
-        | Rem -> failwith "TODO: Rem unimplemented"
+        | Rem ->
+            let val2, state = IlMachineState.popEvalStack currentThread state
+            let val1, state = IlMachineState.popEvalStack currentThread state
+            let result = BinaryArithmetic.execute ArithmeticOperation.rem state val1 val2
+
+            state
+            |> IlMachineState.pushToEvalStack' result currentThread
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> Tuple.withRight WhatWeDid.Executed
+            |> ExecutionResult.Stepped
         | Rem_un -> failwith "TODO: Rem_un unimplemented"
         | Volatile -> failwith "TODO: Volatile unimplemented"
         | Tail -> failwith "TODO: Tail unimplemented"
@@ -789,25 +941,42 @@ module NullaryIlOp =
 
             let referenced =
                 match addr with
-                | EvalStackValue.ManagedPointer src ->
-                    match src with
-                    | ManagedPointerSource.Null -> failwith "TODO: throw NRE"
-                    | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) ->
-                        state.ThreadState.[sourceThread].MethodStates.[methodFrame].LocalVariables
-                            .[int<uint16> whichVar]
-                    | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) ->
-                        state.ThreadState.[sourceThread].MethodStates.[methodFrame].Arguments.[int<uint16> whichVar]
-                    | ManagedPointerSource.Heap managedHeapAddress -> failwith "todo"
+                | EvalStackValue.ManagedPointer src -> IlMachineState.dereferencePointer state src
                 | a -> failwith $"TODO: {a}"
 
             let state =
                 match referenced with
+                | CliType.RuntimePointer (CliRuntimePointer.Managed _)
                 | CliType.ObjectRef _ -> IlMachineState.pushToEvalStack referenced currentThread state
                 | _ -> failwith $"Unexpected non-reference {referenced}"
                 |> IlMachineState.advanceProgramCounter currentThread
 
             (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
-        | Stind_ref -> failwith "TODO: Stind_ref unimplemented"
+        | Stind_ref ->
+            let value, state = IlMachineState.popEvalStack currentThread state
+            let addr, state = IlMachineState.popEvalStack currentThread state
+
+            let state =
+                match addr with
+                | EvalStackValue.ManagedPointer src ->
+                    match src with
+                    | ManagedPointerSource.Null -> failwith "TODO: throw NRE"
+                    | ManagedPointerSource.LocalVariable (sourceThread, methodFrame, whichVar) -> failwith "todo"
+                    | ManagedPointerSource.Argument (sourceThread, methodFrame, whichVar) -> failwith "todo"
+                    | ManagedPointerSource.Heap managedHeapAddress -> failwith "todo"
+                    | ManagedPointerSource.ArrayIndex (arr, index) ->
+                        state
+                        |> IlMachineState.setArrayValue
+                            arr
+                            (EvalStackValue.toCliTypeCoerced (CliType.ObjectRef None) value)
+                            index
+                    | ManagedPointerSource.Field _ -> failwith "TODO"
+                    | ManagedPointerSource.InterpretedAsType (src, ty) -> failwith "TODO"
+                | addr -> failwith $"TODO: {addr}"
+
+            let state = state |> IlMachineState.advanceProgramCounter currentThread
+
+            (state, WhatWeDid.Executed) |> ExecutionResult.Stepped
         | Ldelem_i -> failwith "TODO: Ldelem_i unimplemented"
         | Ldelem_i1 -> failwith "TODO: Ldelem_i1 unimplemented"
         | Ldelem_u1 -> failwith "TODO: Ldelem_u1 unimplemented"
@@ -819,19 +988,54 @@ module NullaryIlOp =
         | Ldelem_u8 -> failwith "TODO: Ldelem_u8 unimplemented"
         | Ldelem_r4 -> failwith "TODO: Ldelem_r4 unimplemented"
         | Ldelem_r8 -> failwith "TODO: Ldelem_r8 unimplemented"
-        | Ldelem_ref -> failwith "TODO: Ldelem_ref unimplemented"
-        | Stelem_i -> failwith "TODO: Stelem_i unimplemented"
-        | Stelem_i1 -> failwith "TODO: Stelem_i1 unimplemented"
+        | Ldelem_ref ->
+            let index, state = IlMachineState.popEvalStack currentThread state
+            let arr, state = IlMachineState.popEvalStack currentThread state
+
+            ldElem index arr currentThread state
+        | Stelem_i ->
+            let value, state = IlMachineState.popEvalStack currentThread state
+            let index, state = IlMachineState.popEvalStack currentThread state
+            let arr, state = IlMachineState.popEvalStack currentThread state
+
+            stElem
+                (CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.Verbatim 0L)))
+                value
+                index
+                arr
+                currentThread
+                state
+        | Stelem_i1 ->
+            let value, state = IlMachineState.popEvalStack currentThread state
+            let index, state = IlMachineState.popEvalStack currentThread state
+            let arr, state = IlMachineState.popEvalStack currentThread state
+            stElem (CliType.Numeric (CliNumericType.Int8 0y)) value index arr currentThread state
         | Stelem_u1 -> failwith "TODO: Stelem_u1 unimplemented"
-        | Stelem_i2 -> failwith "TODO: Stelem_i2 unimplemented"
+        | Stelem_i2 ->
+            let value, state = IlMachineState.popEvalStack currentThread state
+            let index, state = IlMachineState.popEvalStack currentThread state
+            let arr, state = IlMachineState.popEvalStack currentThread state
+            stElem (CliType.Numeric (CliNumericType.Int16 0s)) value index arr currentThread state
         | Stelem_u2 -> failwith "TODO: Stelem_u2 unimplemented"
-        | Stelem_i4 -> failwith "TODO: Stelem_i4 unimplemented"
+        | Stelem_i4 ->
+            let value, state = IlMachineState.popEvalStack currentThread state
+            let index, state = IlMachineState.popEvalStack currentThread state
+            let arr, state = IlMachineState.popEvalStack currentThread state
+            stElem (CliType.Numeric (CliNumericType.Int32 0)) value index arr currentThread state
         | Stelem_u4 -> failwith "TODO: Stelem_u4 unimplemented"
-        | Stelem_i8 -> failwith "TODO: Stelem_i8 unimplemented"
+        | Stelem_i8 ->
+            let value, state = IlMachineState.popEvalStack currentThread state
+            let index, state = IlMachineState.popEvalStack currentThread state
+            let arr, state = IlMachineState.popEvalStack currentThread state
+            stElem (CliType.Numeric (CliNumericType.Int64 0L)) value index arr currentThread state
         | Stelem_u8 -> failwith "TODO: Stelem_u8 unimplemented"
         | Stelem_r4 -> failwith "TODO: Stelem_r4 unimplemented"
         | Stelem_r8 -> failwith "TODO: Stelem_r8 unimplemented"
-        | Stelem_ref -> failwith "TODO: Stelem_ref unimplemented"
+        | Stelem_ref ->
+            let value, state = IlMachineState.popEvalStack currentThread state
+            let index, state = IlMachineState.popEvalStack currentThread state
+            let arr, state = IlMachineState.popEvalStack currentThread state
+            stElem (CliType.ObjectRef None) value index arr currentThread state
         | Cpblk -> failwith "TODO: Cpblk unimplemented"
         | Initblk -> failwith "TODO: Initblk unimplemented"
         | Conv_ovf_u1 -> failwith "TODO: Conv_ovf_u1 unimplemented"

WoofWare.PawPrint/Program.fs

@@ -3,25 +3,33 @@ namespace WoofWare.PawPrint
 open System
 open System.Collections.Immutable
 open System.IO
+open System.Reflection.Metadata
 open Microsoft.Extensions.Logging
 
 [<RequireQualifiedAccess>]
 module Program =
     /// Returns the pointer to the resulting array on the heap.
     let allocateArgs
+        (loggerFactory : ILoggerFactory)
         (args : string list)
         (corelib : BaseClassTypes<DumpedAssembly>)
         (state : IlMachineState)
         : ManagedHeapAddress * IlMachineState
         =
+        let state, stringType =
+            DumpedAssembly.typeInfoToTypeDefn' corelib state._LoadedAssemblies corelib.String
+            |> IlMachineState.concretizeType
+                loggerFactory
+                corelib
+                state
+                corelib.Corelib.Name
+                ImmutableArray.Empty
+                ImmutableArray.Empty
+
         let argsAllocations, state =
             (state, args)
             ||> Seq.mapFold (fun state arg ->
-                IlMachineState.allocateManagedObject
-                    (corelib.String
-                     |> TypeInfo.mapGeneric (fun _ _ -> failwith<unit> "there are no generics here"))
-                    (failwith "TODO: assert fields and populate")
-                    state
+                IlMachineState.allocateManagedObject stringType (failwith "TODO: assert fields and populate") state
             // TODO: set the char values in memory
             )
 
@@ -32,7 +40,7 @@ module Program =
             ((state, 0), argsAllocations)
             ||> Seq.fold (fun (state, i) arg ->
                 let state =
-                    IlMachineState.setArrayValue arrayAllocation (CliType.OfManagedObject arg) i state
+                    IlMachineState.setArrayValue arrayAllocation (CliType.ofManagedObject arg) i state
 
                 state, i + 1
             )
@@ -83,70 +91,180 @@ module Program =
             | None -> failwith "No entry point in input DLL"
             | Some d -> d
 
-        let mainMethod = dumped.Methods.[entryPoint]
+        let mainMethodFromMetadata = dumped.Methods.[entryPoint]
 
-        if mainMethod.Signature.GenericParameterCount > 0 then
+        if mainMethodFromMetadata.Signature.GenericParameterCount > 0 then
             failwith "Refusing to execute generic main method"
 
-        let mainMethod =
-            mainMethod
-            |> MethodInfo.mapTypeGenerics (fun _ -> failwith "Refusing to execute generic main method")
-            |> MethodInfo.mapMethodGenerics (fun _ -> failwith "Refusing to execute generic main method")
+        let state = IlMachineState.initial loggerFactory dotnetRuntimeDirs dumped
 
-        let rec computeState (baseClassTypes : BaseClassTypes<DumpedAssembly> option) (state : IlMachineState) =
-            // The thread's state is slightly fake: we will need to put arguments onto the stack before actually
-            // executing the main method.
-            // We construct the thread here before we are entirely ready, because we need a thread from which to
-            // initialise the class containing the main method.
-            // Once we've obtained e.g. the String and Array classes, we can populate the args array.
-            match
-                MethodState.Empty
-                    (Option.toObj baseClassTypes)
-                    state._LoadedAssemblies
-                    dumped
-                    // pretend there are no instructions, so we avoid preparing anything
-                    { mainMethod with
-                        Instructions = Some MethodInstructions.OnlyRet
-                    }
-                    None
-                    (ImmutableArray.CreateRange [ CliType.ObjectRef None ])
-                    None
-            with
-            | Ok meth -> IlMachineState.addThread meth dumped.Name state, baseClassTypes
-            | Error requiresRefs ->
-                let state =
-                    (state, requiresRefs)
-                    ||> List.fold (fun state ref ->
-                        let handle, referencingAssy = ref.Handle
-                        let referencingAssy = state.LoadedAssembly referencingAssy |> Option.get
+        // Find the core library by traversing the type hierarchy of the main method's declaring type
+        // until we reach System.Object
+        let rec handleBaseTypeInfo
+            (state : IlMachineState)
+            (baseTypeInfo : BaseTypeInfo)
+            (currentAssembly : DumpedAssembly)
+            (continueWithGeneric :
+                IlMachineState
+                    -> TypeInfo<GenericParamFromMetadata, TypeDefn>
+                    -> DumpedAssembly
+                    -> IlMachineState * BaseClassTypes<DumpedAssembly> option)
+            (continueWithResolved :
+                IlMachineState
+                    -> TypeInfo<TypeDefn, TypeDefn>
+                    -> DumpedAssembly
+                    -> IlMachineState * BaseClassTypes<DumpedAssembly> option)
+            : IlMachineState * BaseClassTypes<DumpedAssembly> option
+            =
+            match baseTypeInfo with
+            | BaseTypeInfo.TypeRef typeRefHandle ->
+                // Look up the TypeRef from the handle
+                let typeRef = currentAssembly.TypeRefs.[typeRefHandle]
+
+                let rec go state =
+                    // Resolve the type reference to find which assembly it's in
+                    match
+                        Assembly.resolveTypeRef state._LoadedAssemblies currentAssembly ImmutableArray.Empty typeRef
+                    with
+                    | TypeResolutionResult.FirstLoadAssy assyRef ->
+                        // Need to load this assembly first
+                        let handle, definedIn = assyRef.Handle
 
                         let state, _, _ =
-                            IlMachineState.loadAssembly loggerFactory referencingAssy handle state
+                            IlMachineState.loadAssembly
+                                loggerFactory
+                                state._LoadedAssemblies.[definedIn.FullName]
+                                handle
+                                state
 
+                        go state
+                    | TypeResolutionResult.Resolved (resolvedAssembly, resolvedType) ->
+                        continueWithResolved state resolvedType resolvedAssembly
+
+                go state
+            | BaseTypeInfo.TypeDef typeDefHandle ->
+                // Base type is in the same assembly
+                let baseType = currentAssembly.TypeDefs.[typeDefHandle]
+                continueWithGeneric state baseType currentAssembly
+            | BaseTypeInfo.TypeSpec _ -> failwith "Type specs not yet supported in base type traversal"
+            | BaseTypeInfo.ForeignAssemblyType (assemblyName, typeDefHandle) ->
+                // Base type is in a foreign assembly
+                match state._LoadedAssemblies.TryGetValue assemblyName.FullName with
+                | true, foreignAssembly ->
+                    let baseType = foreignAssembly.TypeDefs.[typeDefHandle]
+                    continueWithGeneric state baseType foreignAssembly
+                | false, _ -> failwith $"Foreign assembly {assemblyName.FullName} not loaded"
+
+        let rec findCoreLibraryAssemblyFromGeneric
+            (state : IlMachineState)
+            (currentType : TypeInfo<GenericParamFromMetadata, TypeDefn>)
+            (currentAssembly : DumpedAssembly)
+            =
+            match currentType.BaseType with
+            | None ->
+                // We've reached the root (System.Object), so this assembly contains the core library
+                let baseTypes = Corelib.getBaseTypes currentAssembly
+                state, Some baseTypes
+            | Some baseTypeInfo ->
+                handleBaseTypeInfo
+                    state
+                    baseTypeInfo
+                    currentAssembly
+                    findCoreLibraryAssemblyFromGeneric
+                    findCoreLibraryAssemblyFromResolved
+
+        and findCoreLibraryAssemblyFromResolved
+            (state : IlMachineState)
+            (currentType : TypeInfo<TypeDefn, TypeDefn>)
+            (currentAssembly : DumpedAssembly)
+            =
+            match currentType.BaseType with
+            | None ->
+                // We've reached the root (System.Object), so this assembly contains the core library
+                let baseTypes = Corelib.getBaseTypes currentAssembly
+                state, Some baseTypes
+            | Some baseTypeInfo ->
+                handleBaseTypeInfo
+                    state
+                    baseTypeInfo
+                    currentAssembly
+                    findCoreLibraryAssemblyFromGeneric
+                    findCoreLibraryAssemblyFromResolved
+
+        let rec computeState (baseClassTypes : BaseClassTypes<DumpedAssembly> option) (state : IlMachineState) =
+            match baseClassTypes with
+            | Some baseTypes ->
+                // We already have base class types, can directly create the concretized method
+                // Use the original method from metadata, but convert FakeUnit to TypeDefn
+                let rawMainMethod =
+                    mainMethodFromMetadata
+                    |> MethodInfo.mapTypeGenerics (fun (i, _) -> TypeDefn.GenericTypeParameter i.SequenceNumber)
+
+                let state, concretizedMainMethod, _ =
+                    IlMachineState.concretizeMethodWithTypeGenerics
+                        loggerFactory
+                        baseTypes
+                        ImmutableArray.Empty // No type generics for main method's declaring type
+                        { rawMainMethod with
+                            Instructions = Some (MethodInstructions.onlyRet ())
+                        }
+                        None
+                        dumped.Name
+                        ImmutableArray.Empty
                         state
-                    )
 
-                let corelib =
-                    let coreLib =
-                        state._LoadedAssemblies.Keys
-                        |> Seq.tryFind (fun x -> x.StartsWith ("System.Private.CoreLib, ", StringComparison.Ordinal))
+                // Create the method state with the concretized method
+                match
+                    MethodState.Empty
+                        state.ConcreteTypes
+                        baseTypes
+                        state._LoadedAssemblies
+                        dumped
+                        concretizedMainMethod
+                        ImmutableArray.Empty
+                        (ImmutableArray.CreateRange [ CliType.ObjectRef None ])
+                        None
+                with
+                | Ok concretizedMeth -> IlMachineState.addThread concretizedMeth dumped.Name state, Some baseTypes
+                | Error _ -> failwith "Unexpected failure creating method state with concretized method"
+            | None ->
+                // We need to discover the core library by traversing the type hierarchy
+                let mainMethodType =
+                    dumped.TypeDefs.[mainMethodFromMetadata.DeclaringType.Definition.Get]
 
-                    coreLib
-                    |> Option.map (fun coreLib -> state._LoadedAssemblies.[coreLib] |> Corelib.getBaseTypes)
+                let state, baseTypes =
+                    findCoreLibraryAssemblyFromGeneric state mainMethodType dumped
 
-                computeState corelib state
+                computeState baseTypes state
 
-        let (state, mainThread), baseClassTypes =
-            IlMachineState.initial loggerFactory dotnetRuntimeDirs dumped
-            |> computeState None
+        let (state, mainThread), baseClassTypes = state |> computeState None
+
+        // Now that we have base class types, concretize the main method for use in the rest of the function
+        let state, concretizedMainMethod, mainTypeHandle =
+            match baseClassTypes with
+            | Some baseTypes ->
+                let rawMainMethod =
+                    mainMethodFromMetadata
+                    |> MethodInfo.mapTypeGenerics (fun (i, _) -> TypeDefn.GenericTypeParameter i.SequenceNumber)
+
+                IlMachineState.concretizeMethodWithTypeGenerics
+                    loggerFactory
+                    baseTypes
+                    ImmutableArray.Empty // No type generics for main method's declaring type
+                    rawMainMethod
+                    None
+                    dumped.Name
+                    ImmutableArray.Empty
+                    state
+            | None -> failwith "Expected base class types to be available at this point"
 
         let rec loadInitialState (state : IlMachineState) =
             match
                 state
-                |> IlMachineState.loadClass
+                |> IlMachineStateExecution.loadClass
                     loggerFactory
                     (Option.toObj baseClassTypes)
-                    mainMethod.DeclaringType
+                    mainTypeHandle
                     mainThread
             with
             | StateLoadResult.NothingToDo ilMachineState -> ilMachineState
@@ -167,12 +285,12 @@ module Program =
             | Some c -> c
 
         let arrayAllocation, state =
-            match mainMethod.Signature.ParameterTypes |> Seq.toList with
+            match mainMethodFromMetadata.Signature.ParameterTypes |> Seq.toList with
             | [ TypeDefn.OneDimensionalArrayLowerBoundZero (TypeDefn.PrimitiveType PrimitiveType.String) ] ->
-                allocateArgs argv baseClassTypes state
+                allocateArgs loggerFactory argv baseClassTypes state
             | _ -> failwith "Main method must take an array of strings; other signatures not yet implemented"
 
-        match mainMethod.Signature.ReturnType with
+        match mainMethodFromMetadata.Signature.ReturnType with
         | TypeDefn.PrimitiveType PrimitiveType.Int32 -> ()
         | _ -> failwith "Main method must return int32; other types not currently supported"
 
@@ -184,17 +302,23 @@ module Program =
 
         logger.LogInformation "Main method class now initialised"
 
+        let state =
+            { state with
+                ConcreteTypes = Corelib.concretizeAll state._LoadedAssemblies baseClassTypes state.ConcreteTypes
+            }
+
         // Now that BCL initialisation has taken place and the user-code classes are constructed,
-        // overwrite the main thread completely.
+        // overwrite the main thread completely using the already-concretized method.
         let methodState =
             match
                 MethodState.Empty
+                    state.ConcreteTypes
                     baseClassTypes
                     state._LoadedAssemblies
                     dumped
-                    mainMethod
-                    None
-                    (ImmutableArray.Create (CliType.OfManagedObject arrayAllocation))
+                    concretizedMainMethod
+                    ImmutableArray.Empty
+                    (ImmutableArray.Create (CliType.ofManagedObject arrayAllocation))
                     None
             with
             | Ok s -> s
@@ -210,11 +334,7 @@ module Program =
             { state with
                 ThreadState = state.ThreadState |> Map.add mainThread threadState
             }
-            |> IlMachineState.ensureTypeInitialised
-                loggerFactory
-                baseClassTypes
-                mainThread
-                methodState.ExecutingMethod.DeclaringType
+            |> IlMachineStateExecution.ensureTypeInitialised loggerFactory baseClassTypes mainThread mainTypeHandle
 
         match init with
         | WhatWeDid.SuspendedForClassInit -> failwith "TODO: suspended for class init"

WoofWare.PawPrint/Tuple.fs

@@ -4,3 +4,5 @@ namespace WoofWare.PawPrint
 module internal Tuple =
     let withLeft<'a, 'b> (x : 'a) (y : 'b) : 'a * 'b = x, y
     let withRight<'a, 'b> (y : 'b) (x : 'a) = x, y
+    let lmap<'a, 'b, 'c> (f : 'a -> 'c) (x : 'a, y : 'b) : 'c * 'b = f x, y
+    let rmap<'a, 'b, 'c> (f : 'b -> 'c) (x : 'a, y : 'b) : 'a * 'c = x, f y

WoofWare.PawPrint/TypeHandleRegistry.fs

@@ -1,18 +1,12 @@
 namespace WoofWare.PawPrint
 
-type CanonicalTypeIdentity =
-    {
-        AssemblyFullName : string
-        FullyQualifiedTypeName : string
-        Generics : CanonicalTypeIdentity list
-    }
+open System.Collections.Immutable
 
 type TypeHandleRegistry =
     private
         {
-            TypeHandleToType : Map<int64<typeHandle>, CanonicalTypeIdentity>
-            TypeToHandle : Map<CanonicalTypeIdentity, int64<typeHandle> * ManagedHeapAddress>
-            NextHandle : int64<typeHandle>
+            TypeHandleToType : Map<ManagedHeapAddress, ConcreteTypeHandle>
+            TypeToHandle : Map<ConcreteTypeHandle, ManagedHeapAddress>
         }
 
 [<RequireQualifiedAccess>]
@@ -21,44 +15,89 @@ module TypeHandleRegistry =
         {
             TypeHandleToType = Map.empty
             TypeToHandle = Map.empty
-            NextHandle = 1L<typeHandle>
         }
 
     /// Returns an allocated System.RuntimeType as well.
     let getOrAllocate
+        (allConcreteTypes : AllConcreteTypes)
+        (corelib : BaseClassTypes<DumpedAssembly>)
         (allocState : 'allocState)
-        (allocate : (string * CliType) list -> 'allocState -> ManagedHeapAddress * 'allocState)
-        (def : CanonicalTypeIdentity)
+        (allocate : CliValueType -> 'allocState -> ManagedHeapAddress * 'allocState)
+        (def : ConcreteTypeHandle)
         (reg : TypeHandleRegistry)
-        : (int64<typeHandle> * ManagedHeapAddress) * TypeHandleRegistry * 'allocState
+        : ManagedHeapAddress * TypeHandleRegistry * 'allocState
         =
         match Map.tryFind def reg.TypeToHandle with
         | Some v -> v, reg, allocState
         | None ->
 
-        let handle = reg.NextHandle
-
         // Here follows the class System.RuntimeType, which is an internal class type with a constructor
         // whose only purpose is to throw.
+        // https://github.com/dotnet/runtime/blob/2b21c73fa2c32fa0195e4a411a435dda185efd08/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs#L14
+        // and https://github.com/dotnet/runtime/blob/f0168ee80ba9aca18a7e7140b2bb436defda623c/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs#L44
         let fields =
             [
                 // for the GC, I think?
-                "m_keepalive", CliType.ObjectRef None
-                // TODO: this is actually a System.IntPtr https://github.com/dotnet/runtime/blob/ec11903827fc28847d775ba17e0cd1ff56cfbc2e/src/coreclr/nativeaot/Runtime.Base/src/System/Primitives.cs#L339
-                "m_cache", CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.Verbatim 0L))
-                "m_handle", CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.TypeHandlePtr handle))
+                {
+                    Name = "m_keepalive"
+                    Contents = CliType.ObjectRef None
+                    Offset = None
+                    Type =
+                        AllConcreteTypes.findExistingConcreteType
+                            allConcreteTypes
+                            (corelib.Object.Assembly,
+                             corelib.Object.Namespace,
+                             corelib.Object.Name,
+                             ImmutableArray.Empty)
+                        |> Option.get
+                }
+                {
+                    Name = "m_cache"
+                    Contents = CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.Verbatim 0L))
+                    Offset = None
+                    Type =
+                        AllConcreteTypes.findExistingConcreteType
+                            allConcreteTypes
+                            (corelib.IntPtr.Assembly,
+                             corelib.IntPtr.Namespace,
+                             corelib.IntPtr.Name,
+                             ImmutableArray.Empty)
+                        |> Option.get
+                }
+                {
+                    Name = "m_handle"
+                    Contents = CliType.Numeric (CliNumericType.NativeInt (NativeIntSource.TypeHandlePtr def))
+                    Offset = None
+                    Type =
+                        AllConcreteTypes.findExistingConcreteType
+                            allConcreteTypes
+                            (corelib.IntPtr.Assembly,
+                             corelib.IntPtr.Namespace,
+                             corelib.IntPtr.Name,
+                             ImmutableArray.Empty)
+                        |> Option.get
+                }
                 // This is the const -1, apparently?!
                 // https://github.com/dotnet/runtime/blob/f0168ee80ba9aca18a7e7140b2bb436defda623c/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs#L2496
-                "GenericParameterCountAny", CliType.Numeric (CliNumericType.Int32 -1)
+                {
+                    Name = "GenericParameterCountAny"
+                    Contents = CliType.Numeric (CliNumericType.Int32 -1)
+                    Offset = None
+                    Type =
+                        AllConcreteTypes.findExistingConcreteType
+                            allConcreteTypes
+                            (corelib.Int32.Assembly, corelib.Int32.Namespace, corelib.Int32.Name, ImmutableArray.Empty)
+                        |> Option.get
+                }
             ]
+            |> CliValueType.OfFields Layout.Default
 
         let alloc, state = allocate fields allocState
 
         let reg =
             {
-                NextHandle = handle + 1L<typeHandle>
-                TypeHandleToType = reg.TypeHandleToType |> Map.add handle def
-                TypeToHandle = reg.TypeToHandle |> Map.add def (handle, alloc)
+                TypeHandleToType = reg.TypeHandleToType |> Map.add alloc def
+                TypeToHandle = reg.TypeToHandle |> Map.add def alloc
             }
 
-        (handle, alloc), reg, state
+        alloc, reg, state

WoofWare.PawPrint/TypeInitialisation.fs

@@ -9,21 +9,21 @@ type TypeInitState =
 
 /// Tracks the initialization state of types across assemblies. The string in the key is the FullName of the AssemblyName where the type comes from.
 // TODO: need a better solution than string here! AssemblyName didn't work, we had nonequal assembly names.
-type TypeInitTable = ImmutableDictionary<RuntimeConcreteType, TypeInitState>
+type TypeInitTable = ImmutableDictionary<ConcreteTypeHandle, TypeInitState>
 
 [<RequireQualifiedAccess>]
 module TypeInitTable =
-    let tryGet (ty : RuntimeConcreteType) (t : TypeInitTable) =
+    let tryGet (ty : ConcreteTypeHandle) (t : TypeInitTable) =
         match t.TryGetValue ty with
         | true, v -> Some v
         | false, _ -> None
 
-    let beginInitialising (thread : ThreadId) (ty : RuntimeConcreteType) (t : TypeInitTable) : TypeInitTable =
+    let beginInitialising (thread : ThreadId) (ty : ConcreteTypeHandle) (t : TypeInitTable) : TypeInitTable =
         match t.TryGetValue ty with
         | false, _ -> t.Add (ty, TypeInitState.InProgress thread)
         | true, v -> failwith "Logic error: tried initialising a type which has already started initialising"
 
-    let markInitialised (thread : ThreadId) (ty : RuntimeConcreteType) (t : TypeInitTable) : TypeInitTable =
+    let markInitialised (thread : ThreadId) (ty : ConcreteTypeHandle) (t : TypeInitTable) : TypeInitTable =
         match t.TryGetValue ty with
         | false, _ -> failwith "Logic error: completing initialisation of a type which never started initialising"
         | true, TypeInitState.Initialized ->

WoofWare.PawPrint/UnaryConstIlOp.fs

@@ -87,7 +87,11 @@ module internal UnaryConstIlOp =
             |> IlMachineState.pushToEvalStack (CliType.Numeric (CliNumericType.Int8 b)) currentThread
             |> IlMachineState.advanceProgramCounter currentThread
             |> Tuple.withRight WhatWeDid.Executed
-        | Br i -> failwith "TODO: Br unimplemented"
+        | Br i ->
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> IlMachineState.jumpProgramCounter currentThread i
+            |> Tuple.withRight WhatWeDid.Executed
         | Br_s b ->
             state
             |> IlMachineState.advanceProgramCounter currentThread
@@ -103,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"
 
@@ -125,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.ObjectRef _
                 | EvalStackValue.ManagedPointer _ -> true
-                | EvalStackValue.ObjectRef _ -> failwith "TODO: Brtrue_s ObjectRef comparison unimplemented"
                 | EvalStackValue.UserDefinedValueType _ ->
                     failwith "TODO: Brtrue_s UserDefinedValueType comparison unimplemented"
 
@@ -208,7 +212,33 @@ module internal UnaryConstIlOp =
                else
                    id
             |> Tuple.withRight WhatWeDid.Executed
-        | Blt_s b -> failwith "TODO: Blt_s unimplemented"
+        | Blt_s b ->
+            let value2, state = IlMachineState.popEvalStack currentThread state
+            let value1, state = IlMachineState.popEvalStack currentThread state
+
+            let isLessThan =
+                match value1, value2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 -> v1 < v2
+                | EvalStackValue.Int32 i, EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+                | EvalStackValue.Int32 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 -> v1 < v2
+                | EvalStackValue.Int64 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.NativeInt nativeIntSource, _ -> failwith "todo"
+                | EvalStackValue.Float v1, EvalStackValue.Float v2 -> failwith "todo"
+                | EvalStackValue.Float f, _ -> failwith $"invalid comparison, {f} with {value2}"
+                | EvalStackValue.ManagedPointer v1, EvalStackValue.ManagedPointer v2 -> failwith "todo"
+                | EvalStackValue.ManagedPointer v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
+                | EvalStackValue.ObjectRef _, _ -> failwith "todo"
+                | EvalStackValue.UserDefinedValueType _, _ ->
+                    failwith "unexpectedly tried to compare user-defined value type"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> if isLessThan then
+                   IlMachineState.jumpProgramCounter currentThread (int<int8> b)
+               else
+                   id
+            |> Tuple.withRight WhatWeDid.Executed
         | Ble_s b ->
             let value2, state = IlMachineState.popEvalStack currentThread state
             let value1, state = IlMachineState.popEvalStack currentThread state
@@ -236,7 +266,33 @@ module internal UnaryConstIlOp =
                else
                    id
             |> Tuple.withRight WhatWeDid.Executed
-        | Bgt_s b -> failwith "TODO: Bgt_s unimplemented"
+        | Bgt_s b ->
+            let value2, state = IlMachineState.popEvalStack currentThread state
+            let value1, state = IlMachineState.popEvalStack currentThread state
+
+            let isGreaterThan =
+                match value1, value2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 -> v1 > v2
+                | EvalStackValue.Int32 i, EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+                | EvalStackValue.Int32 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 -> v1 > v2
+                | EvalStackValue.Int64 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.NativeInt nativeIntSource, _ -> failwith "todo"
+                | EvalStackValue.Float v1, EvalStackValue.Float v2 -> failwith "todo"
+                | EvalStackValue.Float f, _ -> failwith $"invalid comparison, {f} with {value2}"
+                | EvalStackValue.ManagedPointer v1, EvalStackValue.ManagedPointer v2 -> failwith "todo"
+                | EvalStackValue.ManagedPointer v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
+                | EvalStackValue.ObjectRef _, _ -> failwith "todo"
+                | EvalStackValue.UserDefinedValueType _, _ ->
+                    failwith "unexpectedly tried to compare user-defined value type"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> if isGreaterThan then
+                   IlMachineState.jumpProgramCounter currentThread (int<int8> b)
+               else
+                   id
+            |> Tuple.withRight WhatWeDid.Executed
         | Bge_s b ->
             let value2, state = IlMachineState.popEvalStack currentThread state
             let value1, state = IlMachineState.popEvalStack currentThread state
@@ -347,7 +403,35 @@ module internal UnaryConstIlOp =
                else
                    id
             |> Tuple.withRight WhatWeDid.Executed
-        | Bne_un_s b -> failwith "TODO: Bne_un_s unimplemented"
+        | Bne_un_s b ->
+            // Table III.4
+            let value2, state = IlMachineState.popEvalStack currentThread state
+            let value1, state = IlMachineState.popEvalStack currentThread state
+
+            let isNotEqual =
+                match value1, value2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 -> v1 <> v2
+                | EvalStackValue.Int32 v1, EvalStackValue.NativeInt v2 -> failwith "TODO"
+                | EvalStackValue.Int32 v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
+                | _, EvalStackValue.Int32 v2 -> failwith $"invalid comparison, {value1} with {v2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 -> v1 <> v2
+                | EvalStackValue.Int64 v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
+                | _, EvalStackValue.Int64 v2 -> failwith $"invalid comparison, {value1} with {v2}"
+                | EvalStackValue.Float v1, EvalStackValue.Float v2 -> v1 <> v2
+                | _, EvalStackValue.Float v2 -> failwith $"invalid comparison, {value1} with {v2}"
+                | 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 ptr1, EvalStackValue.ObjectRef ptr2 -> ptr1 <> ptr2
+                | _, _ -> failwith $"TODO {value1} {value2} (see table III.4)"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> if isNotEqual then
+                   IlMachineState.jumpProgramCounter currentThread (int b)
+               else
+                   id
+            |> Tuple.withRight WhatWeDid.Executed
         | Bge_un_s b ->
             let value2, state = IlMachineState.popEvalStack currentThread state
             let value1, state = IlMachineState.popEvalStack currentThread state
@@ -383,9 +467,111 @@ module internal UnaryConstIlOp =
                else
                    id
             |> Tuple.withRight WhatWeDid.Executed
-        | Bgt_un_s b -> failwith "TODO: Bgt_un_s unimplemented"
-        | Ble_un_s b -> failwith "TODO: Ble_un_s unimplemented"
-        | Blt_un_s b -> failwith "TODO: Blt_un_s unimplemented"
+        | Bgt_un_s b ->
+            let value2, state = IlMachineState.popEvalStack currentThread state
+            let value1, state = IlMachineState.popEvalStack currentThread state
+
+            let isGreaterThan =
+                match value1, value2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 ->
+                    if v1 < 0 || v2 < 0 then
+                        failwith "TODO"
+
+                    v1 > v2
+                | EvalStackValue.Int32 i, EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+                | EvalStackValue.Int32 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 ->
+                    if v1 < 0L || v2 < 0L then
+                        failwith "TODO"
+
+                    v1 > v2
+                | EvalStackValue.Int64 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.NativeInt nativeIntSource, _ -> failwith "todo"
+                | EvalStackValue.Float v1, EvalStackValue.Float v2 -> failwith "todo"
+                | EvalStackValue.Float f, _ -> failwith $"invalid comparison, {f} with {value2}"
+                | EvalStackValue.ManagedPointer v1, EvalStackValue.ManagedPointer v2 -> failwith "todo"
+                | EvalStackValue.ManagedPointer v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
+                | EvalStackValue.ObjectRef _, _ -> failwith "todo"
+                | EvalStackValue.UserDefinedValueType _, _ ->
+                    failwith "unexpectedly tried to compare user-defined value type"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> if isGreaterThan then
+                   IlMachineState.jumpProgramCounter currentThread (int b)
+               else
+                   id
+            |> Tuple.withRight WhatWeDid.Executed
+        | Ble_un_s b ->
+            let value2, state = IlMachineState.popEvalStack currentThread state
+            let value1, state = IlMachineState.popEvalStack currentThread state
+
+            let isLessEq =
+                match value1, value2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 ->
+                    if v1 < 0 || v2 < 0 then
+                        failwith "TODO"
+
+                    v1 <= v2
+                | EvalStackValue.Int32 i, EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+                | EvalStackValue.Int32 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 ->
+                    if v1 < 0L || v2 < 0L then
+                        failwith "TODO"
+
+                    v1 <= v2
+                | EvalStackValue.Int64 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.NativeInt nativeIntSource, _ -> failwith "todo"
+                | EvalStackValue.Float v1, EvalStackValue.Float v2 -> failwith "todo"
+                | EvalStackValue.Float f, _ -> failwith $"invalid comparison, {f} with {value2}"
+                | EvalStackValue.ManagedPointer v1, EvalStackValue.ManagedPointer v2 -> failwith "todo"
+                | EvalStackValue.ManagedPointer v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
+                | EvalStackValue.ObjectRef _, _ -> failwith "todo"
+                | EvalStackValue.UserDefinedValueType _, _ ->
+                    failwith "unexpectedly tried to compare user-defined value type"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> if isLessEq then
+                   IlMachineState.jumpProgramCounter currentThread (int b)
+               else
+                   id
+            |> Tuple.withRight WhatWeDid.Executed
+        | Blt_un_s b ->
+            let value2, state = IlMachineState.popEvalStack currentThread state
+            let value1, state = IlMachineState.popEvalStack currentThread state
+
+            let isLessThan =
+                match value1, value2 with
+                | EvalStackValue.Int32 v1, EvalStackValue.Int32 v2 ->
+                    if v1 < 0 || v2 < 0 then
+                        failwith "TODO"
+
+                    v1 < v2
+                | EvalStackValue.Int32 i, EvalStackValue.NativeInt nativeIntSource -> failwith "todo"
+                | EvalStackValue.Int32 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.Int64 v1, EvalStackValue.Int64 v2 ->
+                    if v1 < 0L || v2 < 0L then
+                        failwith "TODO"
+
+                    v1 < v2
+                | EvalStackValue.Int64 i, _ -> failwith $"invalid comparison, {i} with {value2}"
+                | EvalStackValue.NativeInt nativeIntSource, _ -> failwith "todo"
+                | EvalStackValue.Float v1, EvalStackValue.Float v2 -> failwith "todo"
+                | EvalStackValue.Float f, _ -> failwith $"invalid comparison, {f} with {value2}"
+                | EvalStackValue.ManagedPointer v1, EvalStackValue.ManagedPointer v2 -> failwith "todo"
+                | EvalStackValue.ManagedPointer v1, _ -> failwith $"invalid comparison, {v1} with {value2}"
+                | EvalStackValue.ObjectRef _, _ -> failwith "todo"
+                | EvalStackValue.UserDefinedValueType _, _ ->
+                    failwith "unexpectedly tried to compare user-defined value type"
+
+            state
+            |> IlMachineState.advanceProgramCounter currentThread
+            |> if isLessThan then
+                   IlMachineState.jumpProgramCounter currentThread (int b)
+               else
+                   id
+            |> Tuple.withRight WhatWeDid.Executed
         | Bne_un i -> failwith "TODO: Bne_un unimplemented"
         | Bge_un i -> failwith "TODO: Bge_un unimplemented"
         | Bgt_un i -> failwith "TODO: Bgt_un unimplemented"

WoofWare.PawPrint/UnaryStringTokenIlOp.fs

@@ -1,12 +1,15 @@
 namespace WoofWare.PawPrint
 
+open System.Collections.Immutable
 open System.Reflection
+open Microsoft.Extensions.Logging
 
 [<RequireQualifiedAccess>]
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module internal UnaryStringTokenIlOp =
     let execute
-        (baseClassTypes : BaseClassTypes<'a>)
+        (loggerFactory : ILoggerFactory)
+        (baseClassTypes : BaseClassTypes<DumpedAssembly>)
         (op : UnaryStringTokenIlOp)
         (sh : StringToken)
         (state : IlMachineState)
@@ -25,6 +28,8 @@ module internal UnaryStringTokenIlOp =
 
                     let state = state |> IlMachineState.setStringData dataAddr stringToAllocate
 
+                    // String type is:
+                    // https://github.com/dotnet/runtime/blob/f0168ee80ba9aca18a7e7140b2bb436defda623c/src/libraries/System.Private.CoreLib/src/System/String.cs#L26
                     let stringInstanceFields =
                         baseClassTypes.String.Fields
                         |> List.choose (fun field ->
@@ -47,16 +52,46 @@ module internal UnaryStringTokenIlOp =
 
                     let fields =
                         [
-                            "_firstChar", CliType.OfChar state.ManagedHeap.StringArrayData.[dataAddr]
-                            "_stringLength", CliType.Numeric (CliNumericType.Int32 stringToAllocate.Length)
+                            {
+                                Name = "_firstChar"
+                                Contents = CliType.ofChar state.ManagedHeap.StringArrayData.[dataAddr]
+                                Offset = None
+                                Type =
+                                    AllConcreteTypes.findExistingConcreteType
+                                        state.ConcreteTypes
+                                        (baseClassTypes.Char.Assembly,
+                                         baseClassTypes.Char.Namespace,
+                                         baseClassTypes.Char.Name,
+                                         ImmutableArray.Empty)
+                                    |> Option.get
+                            }
+                            {
+                                Name = "_stringLength"
+                                Contents = CliType.Numeric (CliNumericType.Int32 stringToAllocate.Length)
+                                Offset = None
+                                Type =
+                                    AllConcreteTypes.findExistingConcreteType
+                                        state.ConcreteTypes
+                                        (baseClassTypes.Int32.Assembly,
+                                         baseClassTypes.Int32.Namespace,
+                                         baseClassTypes.Int32.Name,
+                                         ImmutableArray.Empty)
+                                    |> Option.get
+                            }
                         ]
+                        |> CliValueType.OfFields Layout.Default
 
-                    let addr, state =
-                        IlMachineState.allocateManagedObject
-                            (baseClassTypes.String
-                             |> TypeInfo.mapGeneric (fun _ _ -> failwith<unit> "string is not generic"))
-                            fields
+                    let state, stringType =
+                        DumpedAssembly.typeInfoToTypeDefn' baseClassTypes state._LoadedAssemblies baseClassTypes.String
+                        |> IlMachineState.concretizeType
+                            loggerFactory
+                            baseClassTypes
                             state
+                            baseClassTypes.Corelib.Name
+                            ImmutableArray.Empty
+                            ImmutableArray.Empty
+
+                    let addr, state = IlMachineState.allocateManagedObject stringType fields state
 
                     addr,
                     { state with

WoofWare.PawPrint/WoofWare.PawPrint.fsproj

@@ -7,18 +7,25 @@
 
   <ItemGroup>
     <Compile Include="Tuple.fs" />
+    <Compile Include="List.fs" />
+    <Compile Include="ImmutableArray.fs" />
     <Compile Include="Result.fs" />
     <Compile Include="Corelib.fs" />
     <Compile Include="AbstractMachineDomain.fs" />
     <Compile Include="BasicCliType.fs" />
     <Compile Include="TypeHandleRegistry.fs" />
+    <Compile Include="FieldHandleRegistry.fs" />
     <Compile Include="ManagedHeap.fs" />
     <Compile Include="TypeInitialisation.fs" />
     <Compile Include="Exceptions.fs" />
     <Compile Include="EvalStack.fs" />
+    <Compile Include="EvalStackValueComparisons.fs" />
     <Compile Include="MethodState.fs" />
     <Compile Include="ThreadState.fs" />
     <Compile Include="IlMachineState.fs" />
+    <Compile Include="BinaryArithmetic.fs" />
+    <Compile Include="Intrinsics.fs" />
+    <Compile Include="IlMachineStateExecution.fs" />
     <Compile Include="NullaryIlOp.fs" />
     <Compile Include="UnaryMetadataIlOp.fs" />
     <Compile Include="UnaryStringTokenIlOp.fs" />

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1747467164,
-        "narHash": "sha256-JBXbjJ0t6T6BbVc9iPVquQI9XSXCGQJD8c8SgnUquus=",
+        "lastModified": 1756381814,
+        "narHash": "sha256-tzo7YvAsGlzo4WiIHT0ooR59VHu+aKRQdHk7sIyoia4=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "3fcbdcfc707e0aa42c541b7743e05820472bdaec",
+        "rev": "aca2499b79170038df0dbaec8bf2f689b506ad32",
         "type": "github"
       },
       "original": {

flake.nix

@@ -12,7 +12,10 @@
     ...
   }:
     flake-utils.lib.eachDefaultSystem (system: let
-      pkgs = nixpkgs.legacyPackages.${system};
+      pkgs = import nixpkgs {
+        inherit system;
+        config.allowUnfree = true;
+      };
       pname = "WoofWare.PawPrint";
       dotnet-sdk = pkgs.dotnetCorePackages.sdk_9_0;
       dotnet-runtime = pkgs.dotnetCorePackages.runtime_9_0;
@@ -67,6 +70,7 @@
           pkgs.nodePackages.markdown-link-check
           pkgs.shellcheck
           pkgs.xmlstarlet
+          pkgs.claude-code
         ];
       };
     });

nix/deps.json

@@ -21,123 +21,133 @@
   },
   {
     "pname": "FSharp.Core",
-    "version": "9.0.202",
-    "hash": "sha256-64Gub0qemmCoMa1tDus6TeTuB1+5sHfE6KD2j4o84mA="
+    "version": "9.0.303",
+    "hash": "sha256-AxR6wqodeU23KOTgkUfIgbavgbcSuzD4UBP+tiFydgA="
   },
   {
     "pname": "FsUnit",
-    "version": "7.0.1",
-    "hash": "sha256-K85CIdxMeFSHEKZk6heIXp/oFjWAn7dBILKrw49pJUY="
+    "version": "7.1.1",
+    "hash": "sha256-UMCEGKxQ4ytjmPuVpiNaAPbi3RQH9gqa61JJIUS/6hg="
   },
   {
     "pname": "Microsoft.ApplicationInsights",
-    "version": "2.22.0",
-    "hash": "sha256-mUQ63atpT00r49ca50uZu2YCiLg3yd6r3HzTryqcuEA="
+    "version": "2.23.0",
+    "hash": "sha256-5sf3bg7CZZjHseK+F3foOchEhmVeioePxMZVvS6Rjb0="
   },
   {
     "pname": "Microsoft.AspNetCore.App.Ref",
-    "version": "8.0.15",
-    "hash": "sha256-kqHuc031x46OTy7Mr2C86lLgXK83Uo6swvEjU8yZJ6c="
+    "version": "8.0.19",
+    "hash": "sha256-QySX2bih1UvwmLcn9cy1j+RuvZZwbcFKggL5Y/WcTnw="
   },
   {
     "pname": "Microsoft.AspNetCore.App.Runtime.linux-arm64",
-    "version": "8.0.15",
-    "hash": "sha256-9E6nEfEMGqAHAv3GFNOrz7JqZnqskM++6w92YMyDUT0="
+    "version": "8.0.19",
+    "hash": "sha256-69S+Ywyc5U8PDsVkkCVvZdHOgWb6ZZ3+f4UA0MLOLFI="
   },
   {
     "pname": "Microsoft.AspNetCore.App.Runtime.linux-x64",
-    "version": "8.0.15",
-    "hash": "sha256-bAUGsjDxo5VHXo/IydzmjTixAhWh4lYpCmuUFpEo8ok="
+    "version": "8.0.19",
+    "hash": "sha256-u50rdLuoADSDCthx2Fg+AnT192TalHhFrzFCfMgmTn4="
   },
   {
     "pname": "Microsoft.AspNetCore.App.Runtime.osx-arm64",
-    "version": "8.0.15",
-    "hash": "sha256-fS/n2UQViU1TJqQbLWk3waURqPQWn1zd5ad5L7i8ZGM="
+    "version": "8.0.19",
+    "hash": "sha256-QAKu2xD4UQ4+gX79ynNQ0aA07D+EW6Ke0jRiTZne8CY="
   },
   {
     "pname": "Microsoft.AspNetCore.App.Runtime.osx-x64",
-    "version": "8.0.15",
-    "hash": "sha256-IZBqDYmUVPuujfhKGwXnbsNhrMSDy/olXDjVWKGb5Y0="
+    "version": "8.0.19",
+    "hash": "sha256-v5lzESMpodrH2grgk8ojA6BLDUfyxX5r6YY5Pgq61tA="
   },
   {
     "pname": "Microsoft.CodeAnalysis.Analyzers",
-    "version": "3.3.4",
-    "hash": "sha256-qDzTfZBSCvAUu9gzq2k+LOvh6/eRvJ9++VCNck/ZpnE="
+    "version": "3.11.0",
+    "hash": "sha256-hQ2l6E6PO4m7i+ZsfFlEx+93UsLPo4IY3wDkNG11/Sw="
   },
   {
     "pname": "Microsoft.CodeAnalysis.Common",
-    "version": "4.8.0",
-    "hash": "sha256-3IEinVTZq6/aajMVA8XTRO3LTIEt0PuhGyITGJLtqz4="
+    "version": "4.14.0",
+    "hash": "sha256-ne/zxH3GqoGB4OemnE8oJElG5mai+/67ASaKqwmL2BE="
   },
   {
     "pname": "Microsoft.CodeAnalysis.CSharp",
-    "version": "4.8.0",
-    "hash": "sha256-MmOnXJvd/ezs5UPcqyGLnbZz5m+VedpRfB+kFZeeqkU="
+    "version": "4.14.0",
+    "hash": "sha256-5Mzj3XkYYLkwDWh17r1NEXSbXwwWYQPiOmkSMlgo1JY="
   },
   {
     "pname": "Microsoft.CodeCoverage",
-    "version": "17.13.0",
-    "hash": "sha256-GKrIxeyQo5Az1mztfQgea1kGtJwonnNOrXK/0ULfu8o="
+    "version": "17.14.1",
+    "hash": "sha256-f8QytG8GvRoP47rO2KEmnDLxIpyesaq26TFjDdW40Gs="
   },
   {
     "pname": "Microsoft.Extensions.DependencyInjection.Abstractions",
     "version": "9.0.2",
     "hash": "sha256-WoTLgw/OlXhgN54Szip0Zpne7i/YTXwZ1ZLCPcHV6QM="
   },
+  {
+    "pname": "Microsoft.Extensions.DependencyInjection.Abstractions",
+    "version": "9.0.6",
+    "hash": "sha256-40rY38OwSqueIWr/KMvJX9u+vipN+AaRQ6eNCZLqrog="
+  },
   {
     "pname": "Microsoft.Extensions.Logging.Abstractions",
     "version": "9.0.2",
     "hash": "sha256-mCxeuc+37XY0bmZR+z4p1hrZUdTZEg+FRcs/m6dAQDU="
   },
+  {
+    "pname": "Microsoft.Extensions.Logging.Abstractions",
+    "version": "9.0.6",
+    "hash": "sha256-lhOMYT4+hua7SlgASGFBDhOkrNOsy35WyIxU3nVsD08="
+  },
   {
     "pname": "Microsoft.NET.Test.Sdk",
-    "version": "17.13.0",
-    "hash": "sha256-sc2wvyV8cGm1FrNP2GGHEI584RCvRPu15erYCsgw5QY="
+    "version": "17.14.1",
+    "hash": "sha256-mZUzDFvFp7x1nKrcnRd0hhbNu5g8EQYt8SKnRgdhT/A="
   },
   {
     "pname": "Microsoft.NETCore.App.Host.linux-arm64",
-    "version": "8.0.15",
-    "hash": "sha256-AKPshSm9pO8nG8ksSVfWOHUAv92B/dMS/QwE33rUiCI="
+    "version": "8.0.19",
+    "hash": "sha256-R86Kqzi3FUuPZlgj3zNOObLAvXtnGrS2mxsBAxWIZrY="
   },
   {
     "pname": "Microsoft.NETCore.App.Host.linux-x64",
-    "version": "8.0.15",
-    "hash": "sha256-EmkuXpbpKVyghOw5JcVP2l3gQUebYHw+i+6romHTQyo="
+    "version": "8.0.19",
+    "hash": "sha256-a9t/bX+WIKOu9q2R52b/hPGwOpkAgpYuP42SW2QXTak="
   },
   {
     "pname": "Microsoft.NETCore.App.Host.osx-arm64",
-    "version": "8.0.15",
-    "hash": "sha256-fBucka/K+3dwVrPUU9RLTA4xKzJurWpaxI6OYH/F5WE="
+    "version": "8.0.19",
+    "hash": "sha256-VaeGPR+6ApGNtQpEaky2rdUKd4X/Pp3xFGaSgUfGNiE="
   },
   {
     "pname": "Microsoft.NETCore.App.Host.osx-x64",
-    "version": "8.0.15",
-    "hash": "sha256-uZywV0js9dMNRWipBRO5M/l+7dJpPJWQu6wa5rV2sKA="
+    "version": "8.0.19",
+    "hash": "sha256-hw7WMpTq7o544uSNvWUCIr6IRt5xZOo+eERMnwAbYyk="
   },
   {
     "pname": "Microsoft.NETCore.App.Ref",
-    "version": "8.0.15",
-    "hash": "sha256-Y5/MxR0FnKnjgJ5p+7qk/VbabjCrA8bdR4Dkm20javU="
+    "version": "8.0.19",
+    "hash": "sha256-4ymel0R1c0HrX0plAWubJPzev52y0Fsx1esyQ1R7bXc="
   },
   {
     "pname": "Microsoft.NETCore.App.Runtime.linux-arm64",
-    "version": "8.0.15",
-    "hash": "sha256-RksQhngGt+9J4d18K0oZT6L9ZpoiJ4T7D+DEEfhAXP0="
+    "version": "8.0.19",
+    "hash": "sha256-hqhpd8yT8bv05DhFTuMhfsaSISpLs3t4oM+R/ZkJH80="
   },
   {
     "pname": "Microsoft.NETCore.App.Runtime.linux-x64",
-    "version": "8.0.15",
-    "hash": "sha256-iO6pkXm4UouTsUpCeXjStckUxomy6pxrbOnM+zaR9a0="
+    "version": "8.0.19",
+    "hash": "sha256-Ou51zUFTPESAAzP/z0+sLDAAXC54+oDlESBBT12M2lM="
   },
   {
     "pname": "Microsoft.NETCore.App.Runtime.osx-arm64",
-    "version": "8.0.15",
-    "hash": "sha256-qUo70LnzZC+nVz1yvLg0R8u5gxuJawoMB8fzkcoCosw="
+    "version": "8.0.19",
+    "hash": "sha256-IC/e8AmT9twcXwzFmXAelf4ctMbg4ancKPGrPLFMNn8="
   },
   {
     "pname": "Microsoft.NETCore.App.Runtime.osx-x64",
-    "version": "8.0.15",
-    "hash": "sha256-qraVbQtSG/gVKXAy2PHi1ua7SY6iasveIN2ayYFmE9U="
+    "version": "8.0.19",
+    "hash": "sha256-Rb0z0PT/FHyk/Fgjj9W3WDpkDMKJoXR9DgHB1cJeZSA="
   },
   {
     "pname": "Microsoft.NETCore.Platforms",
@@ -161,43 +171,48 @@
   },
   {
     "pname": "Microsoft.Testing.Extensions.Telemetry",
-    "version": "1.5.3",
-    "hash": "sha256-bIXwPSa3jkr2b6xINOqMUs6/uj/r4oVFM7xq3uVIZDU="
+    "version": "1.7.3",
+    "hash": "sha256-Z6WsY2FCUbNnT5HJd7IOrfOvqknVXp6PWzTVeb0idVg="
   },
   {
     "pname": "Microsoft.Testing.Extensions.TrxReport.Abstractions",
-    "version": "1.5.3",
-    "hash": "sha256-IfMRfcyaIKEMRtx326ICKtinDBEfGw/Sv8ZHawJ96Yc="
+    "version": "1.7.3",
+    "hash": "sha256-PTee04FHyTHx/gF5NLckXuVje807G51MzkPrZ1gkgCw="
   },
   {
     "pname": "Microsoft.Testing.Extensions.VSTestBridge",
-    "version": "1.5.3",
-    "hash": "sha256-XpM/yFjhLSsuzyDV+xKubs4V1zVVYiV05E0+N4S1h0g="
+    "version": "1.7.3",
+    "hash": "sha256-8d+wZmucfSO7PsviHjVxYB4q6NcjgxvnCUpLePq35sM="
   },
   {
     "pname": "Microsoft.Testing.Platform",
-    "version": "1.5.3",
-    "hash": "sha256-y61Iih6w5D79dmrj2V675mcaeIiHoj1HSa1FRit2BLM="
+    "version": "1.7.3",
+    "hash": "sha256-cavX11P5o9rooqC3ZHw5h002OKRg2ZNR/VaRwpNTQYA="
   },
   {
     "pname": "Microsoft.Testing.Platform.MSBuild",
-    "version": "1.5.3",
-    "hash": "sha256-YspvjE5Jfi587TAfsvfDVJXNrFOkx1B3y1CKV6m7YLY="
+    "version": "1.7.3",
+    "hash": "sha256-cREl529UQ/c5atT8KimMgrgNdy6MrAd0sBGT8sXRRPM="
   },
   {
-    "pname": "Microsoft.TestPlatform.ObjectModel",
-    "version": "17.12.0",
-    "hash": "sha256-3XBHBSuCxggAIlHXmKNQNlPqMqwFlM952Av6RrLw1/w="
+    "pname": "Microsoft.TestPlatform.AdapterUtilities",
+    "version": "17.13.0",
+    "hash": "sha256-Vr+3Tad/h/nk7f/5HMExn3HvCGFCarehFAzJSfCBaOc="
   },
   {
     "pname": "Microsoft.TestPlatform.ObjectModel",
     "version": "17.13.0",
     "hash": "sha256-6S0fjfj8vA+h6dJVNwLi6oZhYDO/I/6hBZaq2VTW+Uk="
   },
+  {
+    "pname": "Microsoft.TestPlatform.ObjectModel",
+    "version": "17.14.1",
+    "hash": "sha256-QMf6O+w0IT+16Mrzo7wn+N20f3L1/mDhs/qjmEo1rYs="
+  },
   {
     "pname": "Microsoft.TestPlatform.TestHost",
-    "version": "17.13.0",
-    "hash": "sha256-L/CJzou7dhmShUgXq3aXL3CaLTJll17Q+JY2DBdUUpo="
+    "version": "17.14.1",
+    "hash": "sha256-1cxHWcvHRD7orQ3EEEPPxVGEkTpxom1/zoICC9SInJs="
   },
   {
     "pname": "Myriad.Core",
@@ -216,18 +231,18 @@
   },
   {
     "pname": "Newtonsoft.Json",
-    "version": "13.0.1",
-    "hash": "sha256-K2tSVW4n4beRPzPu3rlVaBEMdGvWSv/3Q1fxaDh4Mjo="
+    "version": "13.0.3",
+    "hash": "sha256-hy/BieY4qxBWVVsDqqOPaLy1QobiIapkbrESm6v2PHc="
   },
   {
     "pname": "NUnit",
-    "version": "4.3.2",
-    "hash": "sha256-0RWe8uFoxYp6qhPlDDEghOMcKJgyw2ybvEoAqBLebeE="
+    "version": "4.4.0",
+    "hash": "sha256-5geF5QOF+X/WkuCEgkPVKH4AdKx4U0olpU07S8+G3nU="
   },
   {
     "pname": "NUnit3TestAdapter",
-    "version": "5.0.0",
-    "hash": "sha256-7jZM4qAbIzne3AcdFfMbvbgogqpxvVe6q2S7Ls8xQy0="
+    "version": "5.1.0",
+    "hash": "sha256-5z470sFjV67wGHaw8KfmSloIAYe81Dokp0f8I6zXsDc="
   },
   {
     "pname": "runtime.any.System.Runtime",
@@ -246,8 +261,8 @@
   },
   {
     "pname": "System.Collections.Immutable",
-    "version": "7.0.0",
-    "hash": "sha256-9an2wbxue2qrtugYES9awshQg+KfJqajhnhs45kQIdk="
+    "version": "9.0.0",
+    "hash": "sha256-+6q5VMeoc5bm4WFsoV6nBXA9dV5pa/O4yW+gOdi8yac="
   },
   {
     "pname": "System.Diagnostics.DiagnosticSource",
@@ -281,19 +296,19 @@
   },
   {
     "pname": "System.Reflection.Metadata",
-    "version": "7.0.0",
-    "hash": "sha256-GwAKQhkhPBYTqmRdG9c9taqrKSKDwyUgOEhWLKxWNPI="
+    "version": "8.0.0",
+    "hash": "sha256-dQGC30JauIDWNWXMrSNOJncVa1umR1sijazYwUDdSIE="
+  },
+  {
+    "pname": "System.Reflection.Metadata",
+    "version": "9.0.0",
+    "hash": "sha256-avEWbcCh7XgpsSesnR3/SgxWi/6C5OxjR89Jf/SfRjQ="
   },
   {
     "pname": "System.Runtime",
     "version": "4.3.1",
     "hash": "sha256-R9T68AzS1PJJ7v6ARz9vo88pKL1dWqLOANg4pkQjkA0="
   },
-  {
-    "pname": "System.Runtime.CompilerServices.Unsafe",
-    "version": "6.0.0",
-    "hash": "sha256-bEG1PnDp7uKYz/OgLOWs3RWwQSVYm+AnPwVmAmcgp2I="
-  },
   {
     "pname": "TypeEquality",
     "version": "0.3.0",