Assembler: callee method signatures.

Author: ForNeVeR

Naggum.Assembler/Assembler.fs

@@ -1,6 +1,7 @@
 module Naggum.Assembler.Assembler
 
 open System
+open System.Reflection
 open System.Reflection.Emit
 
 open Naggum.Assembler.Representation
@@ -11,9 +12,40 @@ let processMetadataItem = function
     | Atom (Symbol ".entrypoint") -> EntryPoint
     | other -> failwithf "Unrecognized metadata item definition: %A" other
 
+let resolveAssembly _ =
+    Assembly.GetAssembly(typeof<Int32>) // TODO: Assembly resolver
+
+let resolveType name =
+    let result = Type.GetType name // TODO: Resolve types from the assembler context
+    if isNull result then
+        failwithf "Type %s could not be found" name
+
+    result
+
+let resolveTypes =
+    List.map (function 
+              | Atom (Symbol name) -> resolveType name
+              | other -> failwithf "Unrecognized type: %A" other)
+
+let processMethodSignature = function
+    | [Atom (Symbol assembly)
+       Atom (Symbol typeName)
+       Atom (Symbol methodName)
+       List argumentTypes
+       Atom (Symbol returnType)] ->
+        { Assembly = Some (resolveAssembly assembly) // TODO: Resolve types from current assembly
+          ContainingType = Some (resolveType typeName) // TODO: Resolve methods without a type (e.g. assembly methods)
+          Name = methodName
+          ArgumentTypes = resolveTypes argumentTypes
+          ReturnType = resolveType typeName }
+    | other -> failwithf "Unrecognized method signature: %A" other
+
 let processInstruction = function
-    | List ([Atom (Symbol "ldstr"); Atom (Symbol string)]) -> Ldstr string
-    | List ([Atom (Symbol "call"); Atom (Symbol methodName)]) -> failwithf "Method calls are not supported now"
+    | List ([Atom (Symbol "ldstr"); Atom (Object (:? string as s))]) ->
+        Ldstr s
+    | List ([Atom (Symbol "call"); List (calleeSignature)]) ->
+        let signature = processMethodSignature calleeSignature
+        Call signature
     | List ([Atom (Symbol "ret")]) -> Ret
     | other -> failwithf "Unrecognized instruction: %A" other
 
@@ -32,12 +64,18 @@ let addBody body method' =
               body
 
 let processAssemblyUnit = function
-    | List (Atom (Symbol ".method") :: Atom (Symbol name) :: List arguments :: List metadata :: body) ->
+    | List (Atom (Symbol ".method")
+            :: Atom (Symbol name)
+            :: List argumentTypes
+            :: Atom (Symbol returnType)
+            :: List metadata
+            :: body) ->
         let definition =
             { Metadata = Set.empty
               Visibility = Public // TODO: Determine method visibility
               Name = name
-              ReturnType = typeof<Void> // TODO: Determine method return type
+              ArgumentTypes = resolveTypes argumentTypes
+              ReturnType = resolveType returnType
               Body = List.empty }
         definition
         |> addMetadata metadata

Naggum.Assembler/Representation.fs

@@ -8,16 +8,26 @@ type MetadataItem =
 type Visibility =
     | Public
 
+type Type = System.Type
+
+type MethodSignature =
+    { Assembly : Assembly option
+      ContainingType : Type option
+      Name : string
+      ArgumentTypes : Type list
+      ReturnType : Type }
+
 type Instruction =
     | Ldstr of string
-    | Call of MethodInfo
+    | Call of MethodSignature
     | Ret
 
 type MethodDefinition =
     { Metadata : Set<MetadataItem>
       Visibility : Visibility
       Name : string
-      ReturnType : System.Type
+      ArgumentTypes : Type list
+      ReturnType : Type
       Body : Instruction list }
 
 type AssemblyUnit =

Naggum.Test/AssemblerTests.fs

@@ -2,17 +2,35 @@
 
 open System
 open System.IO
+open System.Reflection
 open System.Text
 
 open Xunit
 
 open Naggum.Assembler
 open Naggum.Assembler.Representation
 
+let mscorlib = Assembly.GetAssembly(typeof<Int32>)
+
+let mainMethodDefinition =
+    { Metadata = Set.singleton EntryPoint
+      Visibility = Public
+      Name = "Main"
+      ArgumentTypes = List.empty
+      ReturnType = typeof<Void> 
+      Body = List.empty }
+
+let consoleWriteLine =
+    { Assembly = Some mscorlib
+      ContainingType = Some typeof<Console>
+      Name = "WriteLine"
+      ArgumentTypes = [typeof<string>]
+      ReturnType = typeof<Void> }
+
 let checkPreparationResult (source : string) (expected : Assembly list) =
     use stream = new MemoryStream(Encoding.UTF8.GetBytes source)
     let actual = Assembler.prepare "file.ngi" stream |> Seq.toList
-    
+
     Assert.Equal<Assembly list> (expected, actual)
 
 [<Fact>]
@@ -24,33 +42,31 @@ let ``Empty assembly should be processed`` () =
 [<Fact>]
 let ``Simplest method should be processed`` () =
     let source = "(.assembly Stub
-  (.method Main () (.entrypoint)
+  (.method Main () System.Void (.entrypoint)
     (ret)))
 "
     let result =
         { Name = "Stub"
-          Units = [Method { Metadata = Set.singleton EntryPoint
-                            Visibility = Public
-                            Name = "Main"
-                            ReturnType = typeof<Void> 
-                            Body = [ Ret ] } ] }
+          Units = [Method { mainMethodDefinition with 
+                                Body = [ Ret ] } ] }
     checkPreparationResult source [result]
 
 [<Fact>]
 let ``Hello world assembly should be processed`` () =
     let source = "(.assembly Hello
-  (.method Main () (.entrypoint)
+  (.method Main () System.Void (.entrypoint)
     (ldstr \"Hello, world!\")
-    (call `void System.Console::WriteLine(string)`)
+    (call (mscorlib System.Console WriteLine (System.String) System.Void))
     (ret)))
 "
     let result =
-        { Name = "Empty"
+        { Name = "Hello"
           Units = [Method { Metadata = Set.singleton EntryPoint
                             Visibility = Public
                             Name = "Main"
+                            ArgumentTypes = List.empty
                             ReturnType = typeof<Void> 
                             Body = [ Ldstr "Hello, world!"
-                                     Call (typeof<Console>.GetMethod("WriteLine", [| typeof<String> |]))
+                                     Call consoleWriteLine
                                      Ret ] } ] }
     checkPreparationResult source [result]