Merge branch 'main' into more-ldind

WoofWare.PawPrint.Domain/TypeDefn.fs

@@ -46,6 +46,13 @@ type TypeMethodSignature<'Types> =
 
 [<RequireQualifiedAccess>]
 module TypeMethodSignature =
+    let sigsEqual<'T> (equal : 'T -> 'T -> bool) (s1 : TypeMethodSignature<'T>) (s2 : TypeMethodSignature<'T>) : bool =
+        s1.GenericParameterCount = s2.GenericParameterCount
+        && s1.ParameterTypes.Length = s2.ParameterTypes.Length
+        && equal s1.ReturnType s2.ReturnType
+        && List.zip s1.ParameterTypes s2.ParameterTypes
+           |> List.forall (fun (x, y) -> equal x y)
+
     let make<'T> (p : MethodSignature<'T>) : TypeMethodSignature<'T> =
         {
             Header = ComparableSignatureHeader.Make p.Header
@@ -170,6 +177,30 @@ type TypeDefn =
 
 [<RequireQualifiedAccess>]
 module TypeDefn =
+    let rec equals
+        (t1TypeGenerics : TypeDefn ImmutableArray)
+        (t1MethodGenerics : TypeDefn ImmutableArray)
+        (t2TypeGenerics : TypeDefn ImmutableArray)
+        (t2MethodGenerics : TypeDefn ImmutableArray)
+        (t1 : TypeDefn)
+        (t2 : TypeDefn)
+        : bool
+        =
+        match t1, t2 with
+        | TypeDefn.GenericTypeParameter i, j ->
+            equals t1TypeGenerics t1MethodGenerics t2TypeGenerics t2MethodGenerics t1TypeGenerics.[i] j
+        | TypeDefn.GenericMethodParameter i, j ->
+            equals t1TypeGenerics t1MethodGenerics t2TypeGenerics t2MethodGenerics t1MethodGenerics.[i] j
+        | i, TypeDefn.GenericTypeParameter j ->
+            equals t1TypeGenerics t1MethodGenerics t2TypeGenerics t2MethodGenerics i t2TypeGenerics.[j]
+        | i, TypeDefn.GenericMethodParameter j ->
+            equals t1TypeGenerics t1MethodGenerics t2TypeGenerics t2MethodGenerics i t2MethodGenerics.[j]
+        | TypeDefn.PrimitiveType x, TypeDefn.PrimitiveType y -> x = y
+        | TypeDefn.Array (x, shapeX), TypeDefn.Array (y, shapeY) ->
+            shapeX = shapeY
+            && equals t1TypeGenerics t1MethodGenerics t2TypeGenerics t2TypeGenerics x y
+        | t1, t2 -> failwith $"TODO: {t1} = {t2}"
+
     let isManaged (typeDefn : TypeDefn) : bool =
         match typeDefn with
         | TypeDefn.PrimitiveType primitiveType -> failwith "todo"

WoofWare.PawPrint/IlMachineState.fs

@@ -1211,6 +1211,10 @@ module IlMachineState =
                 resolveTypeFromSpec loggerFactory corelib parent assy typeGenerics methodGenerics state
             | parent -> failwith $"Unexpected: {parent}"
 
+        let executingMethod = state.ThreadState.[currentThread].MethodState.ExecutingMethod
+        let methodGenerics = executingMethod.Generics
+        let typeGenerics = executingMethod.DeclaringType.Generics
+
         match mem.Signature with
         | MemberSignature.Field fieldSig ->
             let availableFields =
@@ -1234,8 +1238,12 @@ module IlMachineState =
             let availableMethods =
                 targetType.Methods
                 |> List.filter (fun mi -> mi.Name = memberName)
-                // TODO: this needs to resolve the TypeMethodSignature to e.g. remove references to generic parameters
+                |> List.filter (fun mi ->
-                |> List.filter (fun mi -> mi.Signature = memberSig)
+                    let pars = mi.Signature.ParameterTypes = memberSig.ParameterTypes
+                    let ret = mi.Signature.ReturnType = memberSig.ReturnType
+                    pars && ret
+                // TypeMethodSignature.sigsEqual (TypeDefn.equals ) mi.Signature memberSig
+                )
 
             let method =
                 match availableMethods with

WoofWare.PawPrint/UnaryMetadataIlOp.fs

@@ -141,7 +141,54 @@ module internal UnaryMetadataIlOp =
             |> fst
             |> IlMachineState.callMethodInActiveAssembly loggerFactory baseClassTypes thread true generics method None
 
-        | Castclass -> failwith "TODO: Castclass unimplemented"
+        | Castclass ->
+            let logger = loggerFactory.CreateLogger "Castclass"
+
+            let actualObj, state = IlMachineState.popEvalStack thread state
+
+            let actualObj =
+                match actualObj with
+                | EvalStackValue.ManagedPointer p ->
+                    match p with
+                    | ManagedPointerSource.Heap a -> a
+                    | ManagedPointerSource.Null -> failwith "TODO: push null and succeed"
+                    | _ -> failwith $"TODO: {p}"
+                | s -> failwith $"TODO: {s}"
+
+            let targetType : TypeDefn =
+                match metadataToken with
+                | MetadataToken.TypeDefinition td ->
+                    let activeAssy = state.ActiveAssembly thread
+                    let ty = activeAssy.TypeDefs.[td]
+
+                    let baseTy =
+                        DumpedAssembly.resolveBaseType
+                            baseClassTypes
+                            state._LoadedAssemblies
+                            activeAssy.Name
+                            ty.BaseType
+
+                    let sigType =
+                        match baseTy with
+                        | ResolvedBaseType.Enum
+                        | ResolvedBaseType.ValueType -> SignatureTypeKind.ValueType
+                        | ResolvedBaseType.Object -> SignatureTypeKind.Class
+                        | ResolvedBaseType.Delegate -> failwith "todo"
+
+                    TypeDefn.FromDefinition (ComparableTypeDefinitionHandle.Make td, activeAssy.Name.FullName, sigType)
+                | MetadataToken.TypeSpecification handle -> state.ActiveAssembly(thread).TypeSpecs.[handle].Signature
+                | m -> failwith $"unexpected metadata token {m} in Castclass"
+
+            let sourceType = state.ManagedHeap.NonArrayObjects.[actualObj].Type
+
+            logger.LogDebug (
+                "Casting object of type {SourceTypeAssembly}.{SourceTypeNamespace}.{SourceTypeName}",
+                sourceType.Assembly.Name,
+                sourceType.Namespace,
+                sourceType.Name
+            )
+
+            failwith "TODO: Castclass unimplemented"
         | Newobj ->
             let logger = loggerFactory.CreateLogger "Newobj"
 
@@ -342,6 +389,8 @@ module internal UnaryMetadataIlOp =
         | Box -> failwith "TODO: Box unimplemented"
         | Ldelema -> failwith "TODO: Ldelema unimplemented"
         | Isinst ->
+            let logger = loggerFactory.CreateLogger "Isinst"
+
             let actualObj, state = IlMachineState.popEvalStack thread state
 
             let targetType : TypeDefn =