From f1e4fb3280a2bf7aa9b991242b444529ea997819 Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Thu, 12 Feb 2015 22:23:13 -0600
Subject: [PATCH 1/8] Included FunScript.Compiler in solution.

---
 src/FunScript.sln                                      | 8 +++++++-
 src/extra/FunScript.Compiler/FunScript.Compiler.fsproj | 7 +++++--
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/FunScript.sln b/src/FunScript.sln
index 94612b8..de74a11 100644
--- a/src/FunScript.sln
+++ b/src/FunScript.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
-VisualStudioVersion = 12.0.30723.0
+VisualStudioVersion = 12.0.30324.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FunScript", "main\FunScript\FunScript.fsproj", "{E0916E67-D3B0-4C3A-AD18-4146882FCEDD}"
 EndProject
@@ -13,6 +13,8 @@ Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FunScript.Interop", "main\F
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FunScript.Rx", "extra\FunScript.Rx\FunScript.Rx.fsproj", "{3D25CAB2-83A4-4D3B-9986-AC068FE29307}"
 EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FunScript.Compiler", "extra\FunScript.Compiler\FunScript.Compiler.fsproj", "{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -39,6 +41,10 @@ Global
 		{3D25CAB2-83A4-4D3B-9986-AC068FE29307}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3D25CAB2-83A4-4D3B-9986-AC068FE29307}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3D25CAB2-83A4-4D3B-9986-AC068FE29307}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj b/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
index 1c3ca3b..9f7c0fb 100644
--- a/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
+++ b/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
@@ -67,9 +67,12 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Numerics" />
-    <ProjectReference Include="..\FunScript\FunScript.fsproj">
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\main\FunScript\FunScript.fsproj">
       <Name>FunScript</Name>
-      <Project>E0916E67-D3B0-4C3A-AD18-4146882FCEDD</Project>
+      <Project>{e0916e67-d3b0-4c3a-ad18-4146882fcedd}</Project>
+      <Private>True</Private>
     </ProjectReference>
   </ItemGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

From c314218782aba3841656ce54675ac6969129f795 Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Thu, 12 Feb 2015 22:23:45 -0600
Subject: [PATCH 2/8] Refactor of argument verification to use more functional
 techniques.

---
 src/extra/FunScript.Compiler/Program.fs | 52 ++++++++++++++++++++++---
 1 file changed, 46 insertions(+), 6 deletions(-)

diff --git a/src/extra/FunScript.Compiler/Program.fs b/src/extra/FunScript.Compiler/Program.fs
index 9cd74c9..7a9c89b 100644
--- a/src/extra/FunScript.Compiler/Program.fs
+++ b/src/extra/FunScript.Compiler/Program.fs
@@ -41,22 +41,62 @@ let compile assemblyPath filename components =
 
 
 let assemPath = ref ""
+let projectPath = ref ""
 let outPath = ref ""
+let stdOut = ref false
+
 let args =
     [ ArgInfo("--assembly-path", ArgType.String(fun x -> assemPath := x), 
               "Path to the assembly you want fun script to compile")
+      ArgInfo("--project-path", ArgType.String(fun x -> projectPath := x), 
+              "Path to the project you want fun script to compile")
       ArgInfo("--out-path", ArgType.String(fun x -> outPath := x), 
-              "Path of the resulting javascript file") ]
+              "Path of the resulting javascript file")
+      ArgInfo("--std-out", ArgType.SetArg(stdOut), 
+              "Write the results to standard out instead") ]
 
 let usageText = "FunScript Compiler - usage: funsc <args>"
 
+let emptyStr = String.IsNullOrWhiteSpace
+
+let (|EmptyString|NonEmptyString|) 
+    input = if System.String.IsNullOrWhiteSpace input then EmptyString else NonEmptyString
+
+type ParseResult = {Success : bool; Message : string}
+
 [<EntryPoint>]
 let main argv = 
     ArgParser.Parse(args, usageText = usageText)
-    if String.IsNullOrWhiteSpace(!assemPath) || String.IsNullOrWhiteSpace(!outPath) then
-        printfn "error: both --assembly-path and --out-path are required"
+    
+    let sourceParseResult : ParseResult = 
+        match !assemPath, !projectPath with
+        | (EmptyString, EmptyString) -> 
+            {Success=false; Message="error: either --assembly-path or --project-path is required"}
+        | (NonEmptyString, NonEmptyString) -> 
+            {Success=false; Message="error: both --assembly-path and --project-path specified. one or the other required"}
+        | (_, _) -> 
+            {Success=true; Message=""}
+
+    let outParseResult : ParseResult = 
+        match !outPath, !stdOut with
+        | (EmptyString, false) -> 
+            {Success=false; Message="error: either --out-path or --std-out is required"}
+        | (NonEmptyString, true) -> 
+            {Success=false; Message="error: both --out-path and --std-out specified. one or the other is required"}
+        | (_, _) -> 
+            {Success=true; Message=""}
+
+    let parseResults = [sourceParseResult; outParseResult]
+    let parseFailMessages = seq { for r in parseResults do if not(r.Success) then yield r.Message}
+
+    let mutable exitCode = 0
+
+    if not(Seq.isEmpty(parseFailMessages)) then
+        for m in parseFailMessages do   
+            printf "%s\n" m
         ArgParser.Usage(args, usage = usageText)
-    else
-        // need to give more control of the components?
+        exitCode <- 1
+    else 
         compile !assemPath !outPath []//Interop.Components.all
-    0
+        
+    exitCode
\ No newline at end of file

From 308de3c2bb5eb396d2e8d8b3d69c9bf055b21196 Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Fri, 13 Feb 2015 17:31:52 -0600
Subject: [PATCH 3/8] WIP Compiler upgrade.

---
 src/extra/FunScript.Compiler/App.config       |  10 +-
 src/extra/FunScript.Compiler/Compile.fs       | 182 ++++++++++++++++++
 .../FunScript.Compiler.fsproj                 |  27 ++-
 src/extra/FunScript.Compiler/Program.fs       | 149 ++++++++------
 src/extra/FunScript.Compiler/packages.config  |   5 +
 5 files changed, 307 insertions(+), 66 deletions(-)
 create mode 100644 src/extra/FunScript.Compiler/Compile.fs
 create mode 100644 src/extra/FunScript.Compiler/packages.config

diff --git a/src/extra/FunScript.Compiler/App.config b/src/extra/FunScript.Compiler/App.config
index c9bdc98..a477f7d 100644
--- a/src/extra/FunScript.Compiler/App.config
+++ b/src/extra/FunScript.Compiler/App.config
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
     <startup> 
         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
@@ -6,10 +6,10 @@
     <runtime>
       <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <dependentAssembly>
-          <assemblyIdentity name="FSharp.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
-          <bindingRedirect oldVersion="4.0.0.0" newVersion="4.3.0.0"/>
-          <bindingRedirect oldVersion="2.3.5.0" newVersion="4.3.0.0"/>
-          <bindingRedirect oldVersion="2.0.0.0" newVersion="4.3.0.0"/>
+          <assemblyIdentity name="FSharp.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+          <bindingRedirect oldVersion="0.0.0.0-4.3.1.0" newVersion="4.3.1.0" />
+          <bindingRedirect oldVersion="2.3.5.0" newVersion="4.3.0.0" />
+          <bindingRedirect oldVersion="2.0.0.0" newVersion="4.3.0.0" />
           
         </dependentAssembly>
       </assemblyBinding>
diff --git a/src/extra/FunScript.Compiler/Compile.fs b/src/extra/FunScript.Compiler/Compile.fs
new file mode 100644
index 0000000..614a21b
--- /dev/null
+++ b/src/extra/FunScript.Compiler/Compile.fs
@@ -0,0 +1,182 @@
+module Compile
+
+    open System.Reflection
+    open System.Collections.Generic
+    open Microsoft.FSharp.Quotations
+    open Microsoft.FSharp.Compiler.SourceCodeServices
+    open Mono.Cecil
+
+    type CompileError = {Message:string}
+    type CompileResult = {
+        Success: bool
+        Errors: seq<CompileError>
+        CompiledFunScript: string
+    }
+
+    [<ReflectedDefinition>]
+    let compileMethod() = 
+        let x = true
+        x
+
+    let AssemblyToFunScript (assembly : Assembly) =
+        // Find the main method in this assembly
+        // Could offer lot more flexiblity here ...
+        let mainCompileExpr =
+            printfn "Searching for main function..."
+//            let types = Assembly.GetExecutingAssembly().GetTypes()
+//            let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
+//            let mains = 
+//                [ for typ in types do
+//                    for mi in typ.GetMethods(flags) do
+//                        if mi.Name = "compileMethod" then yield mi ]
+            let types = assembly.GetTypes()
+            let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
+            let mains = 
+                [ for typ in types do
+                    for mi in typ.GetMethods(flags) do
+                        if mi.Name = "main" then yield mi ]
+            let mainExpr = 
+                match mains with
+                | [it] -> Some(Expr.Call(it, []))
+                //| [it] -> Expr.TryGetReflectedDefinition(it)
+                | _ -> None
+            mainExpr
+
+//        let testExpr =  
+//            <@@
+//                let x = true
+//                x
+//            @@>
+
+        match mainCompileExpr with
+        | None -> 
+            {Success=false;Errors=[{Message="Could not find main function in any module."}];CompiledFunScript=""}
+        | _ ->
+            let sw = System.Diagnostics.Stopwatch.StartNew()
+            let source = FunScript.Compiler.Compiler.Compile(mainCompileExpr.Value, [])
+            printfn "Generated JavaScript in %f sec..." (float sw.ElapsedMilliseconds / 1000.0) 
+            {Success=true;Errors=Seq.empty<CompileError>;CompiledFunScript=source}
+
+    let FSharpErrorInfoPrettyMessage (error : Microsoft.FSharp.Compiler.FSharpErrorInfo) =
+        sprintf "%s %i:%i\n error: %s" error.FileName error.StartLineAlternate error.EndLineAlternate error.Message
+
+    type AssemblyRefernce = {Path:string;ReflectedAssembly:AssemblyDefinition;AssemblyName:AssemblyName}
+
+    type ExceptionOrAssembly= E of System.Exception | A of Assembly
+
+    let LoadDependencies (dependencyPaths : seq<string>) = 
+       
+        let unorderedDependencies =
+            dependencyPaths
+            |> Seq.map(fun path -> 
+                let assem = AssemblyDefinition.ReadAssembly(path)
+                {Path=path;ReflectedAssembly=assem;AssemblyName=AssemblyName(assem.FullName)}
+            )
+
+        let TopSort(roots: seq<'T>, pred: 'T -> seq<'T>, nodeIdentity: IEqualityComparer<'T>) =
+            seq {
+                let visited = HashSet(nodeIdentity)
+                let rec visit node =
+                    seq {
+                        if visited.Add(node) then
+                            for pN in pred node do
+                                yield! visit pN
+                            yield node
+                    }
+                for node in roots do
+                    yield! visit node
+            }
+
+        let comparer =
+                HashIdentity.FromFunctions<AssemblyRefernce>
+                    (fun a -> hash a.Path)
+                    (fun a b -> a.Path = b.Path)
+
+        let pred (a: AssemblyRefernce) =
+            a.ReflectedAssembly.MainModule.AssemblyReferences
+            |> Seq.choose (fun r ->
+                let n = AssemblyName(r.FullName)
+                match unorderedDependencies |> Seq.tryFind(fun x -> x.AssemblyName.FullName = n.FullName) with
+                | None -> None
+                | Some assemRef ->
+                    assemRef
+                    |> Some)
+
+        (*
+        Seperate compile domain support.
+        let handler = ResolveEventHandler(fun sender ->
+            fun eventArgs ->
+                null)
+        compileDomain.add_AssemblyResolve(handler)
+        *)
+
+        let results : seq<ExceptionOrAssembly> = 
+            TopSort(unorderedDependencies, pred, comparer)
+            |> Seq.map(fun d -> 
+                try
+                    A(Assembly.LoadFrom(d.Path))
+                with
+                | ex ->
+                    E(ex))
+        
+        results
+
+    let ProjectToFunScript (projectPath: string) =
+        let checker = FSharpChecker.Create()
+        let projectOpts = checker.GetProjectOptionsFromProjectFile(projectPath)
+
+        let dependencyPaths =
+            projectOpts.OtherOptions 
+            |> Seq.filter (fun x -> x.StartsWith("-r:"))
+            |> Seq.map (fun x -> x.Substring(3))
+
+        let dependencyResults = LoadDependencies(dependencyPaths)
+        let loadErrors =  dependencyResults |> Seq.choose(fun x ->
+            match x with
+                | A _ -> None
+                | E e -> Some e)
+        let dependencies = dependencyResults |> Seq.choose(fun x ->
+            match x with
+                | E _ -> None
+                | A a -> Some a)
+
+        match loadErrors with
+            |errors when Seq.length(errors) > 0 ->
+                let dependencyErrors = errors |> Seq.map(fun x -> {Message=x.Message})
+                {Success=false;Errors=dependencyErrors;CompiledFunScript=""}
+            |_ ->
+                let scs = Microsoft.FSharp.Compiler.SimpleSourceCodeServices.SimpleSourceCodeServices()
+                let requiredOptions = Seq.ofList [ "--validate-type-providers" ]
+
+                let baseOptions = Seq.ofArray projectOpts.OtherOptions
+
+                let options = Seq.concat [baseOptions; requiredOptions] |> Seq.distinct
+
+                let errors, exitCode, assembly = scs.CompileToDynamicAssembly(Seq.toArray options, Some(stdout, stderr))
+                let errors, exitCode = scs.Compile(Seq.toArray options)
+                
+                let handler = System.ResolveEventHandler(fun sender ->
+                    fun eventArgs ->
+                        dependencies |> Seq.find(fun x ->
+                            x.FullName = eventArgs.Name)
+                )
+
+                System.AppDomain.CurrentDomain.add_AssemblyResolve(handler)
+//                let errors = []
+//                let exitCode = 0
+                let assembly = 
+                    Assembly.LoadFrom("C:\\Projects\\FunScript.CommandLine\\FunScript.CommandLine.Example\\bin\\debug\\FunScript.CommandLine.Example.dll")
+                    |> Some
+
+                match exitCode with
+                    | i when (i < 1) ->
+                        AssemblyToFunScript(assembly.Value)
+                    | _ ->
+                        let compileErrors = 
+                            match errors with
+                                | (_) when(Seq.isEmpty errors)->
+                                    seq [{Message=sprintf "Compiler exited with code %i" exitCode}]
+                                | _ ->
+                                    seq {for err in errors 
+                                        do yield {Message=FSharpErrorInfoPrettyMessage(err)} }
+                        {Success=false;Errors=compileErrors;CompiledFunScript=""}
\ No newline at end of file
diff --git a/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj b/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
index 9f7c0fb..759c517 100644
--- a/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
+++ b/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
@@ -26,6 +26,9 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <DocumentationFile>bin\Debug\FunScript.Compiler.XML</DocumentationFile>
     <Prefer32Bit>true</Prefer32Bit>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <WarningsAsErrors />
+    <StartArguments>--project-path "C:\Projects\FunScript.CommandLine\FunScript.CommandLine.Example\FunScript.CommandLine.Example.fsproj" --std-out</StartArguments>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -56,13 +59,35 @@
   <Import Project="$(FSharpTargetsPath)" Condition="Exists('$(FSharpTargetsPath)')" />
   <ItemGroup>
     <Compile Include="PowerPack\Args.fs" />
-    <Compile Include="Program.fs" />
     <None Include="App.config" />
+    <Compile Include="Compile.fs" />
+    <Compile Include="Program.fs" />
+    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
+    <Reference Include="FSharp.Compiler.Service">
+      <HintPath>..\..\packages\FSharp.Compiler.Service.0.0.82\lib\net45\FSharp.Compiler.Service.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="FSharp.Core, Version=$(TargetFSharpCoreVersion), Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
       <Private>True</Private>
     </Reference>
+    <Reference Include="Mono.Cecil">
+      <HintPath>..\..\packages\Mono.Cecil.0.9.5.4\lib\net40\Mono.Cecil.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Mono.Cecil.Mdb">
+      <HintPath>..\..\packages\Mono.Cecil.0.9.5.4\lib\net40\Mono.Cecil.Mdb.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Mono.Cecil.Pdb">
+      <HintPath>..\..\packages\Mono.Cecil.0.9.5.4\lib\net40\Mono.Cecil.Pdb.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Mono.Cecil.Rocks">
+      <HintPath>..\..\packages\Mono.Cecil.0.9.5.4\lib\net40\Mono.Cecil.Rocks.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="mscorlib" />
     <Reference Include="System" />
     <Reference Include="System.Core" />
diff --git a/src/extra/FunScript.Compiler/Program.fs b/src/extra/FunScript.Compiler/Program.fs
index 7a9c89b..825c702 100644
--- a/src/extra/FunScript.Compiler/Program.fs
+++ b/src/extra/FunScript.Compiler/Program.fs
@@ -5,54 +5,53 @@ open FunScript
 open Microsoft.FSharp.Quotations
 open Microsoft.FSharp.Core;
 open Microsoft.FSharp.Text;
-
-let compile assemblyPath filename components =
-
-    // loading the assembly from a file maybe problematic if 
-    // the assembly as dependcies on non-BCL stuff, consider
-    // otherways of doing this
-    let asm = Assembly.LoadFile(assemblyPath)
-
-    // Find the main method in this assembly
-    // Could offer lot more flexiblity here ...
-    let mainCompileExpr =
-        printfn "Searching for main function..."
-        let types = asm.GetTypes()
-        let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
-        let mains = 
-            [ for typ in types do
-                for mi in typ.GetMethods(flags) do
-                    if mi.Name = "main" then yield mi ]
-        let main = 
-            match mains with
-            | [it] -> it
-            | _ -> failwith "Main function not found!"
-        printfn "Found entry point..."
-        Expr.Call(main, [])
-
-
-    // Compile the main function into a script
-    let sw = System.Diagnostics.Stopwatch.StartNew()
-    let source = FunScript.Compiler.Compiler.Compile(mainCompileExpr, components=components)
-    let sourceWrapped = sprintf "$(document).ready(function () {\n%s\n});" source
-    printfn "Generated JavaScript in %f sec..." (float sw.ElapsedMilliseconds / 1000.0) 
-    File.Delete filename
-    File.WriteAllText(filename, sourceWrapped)
-
-
-let assemPath = ref ""
-let projectPath = ref ""
-let outPath = ref ""
-let stdOut = ref false
+//
+//let compile assemblyPath filename components =
+//
+//    // loading the assembly from a file maybe problematic if 
+//    // the assembly as dependcies on non-BCL stuff, consider
+//    // otherways of doing this
+//    let asm = Assembly.LoadFile(assemblyPath)
+//
+//    // Find the main method in this assembly
+//    // Could offer lot more flexiblity here ...
+//    let mainCompileExpr =
+//        printfn "Searching for main function..."
+//        let types = asm.GetTypes()
+//        let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
+//        let mains = 
+//            [ for typ in types do
+//                for mi in typ.GetMethods(flags) do
+//                    if mi.Name = "main" then yield mi ]
+//        let main = 
+//            match mains with
+//            | [it] -> it
+//            | _ -> failwith "Main function not found!"
+//        printfn "Found entry point..."
+//        Expr.Call(main, [])
+//
+//    // Compile the main function into a script
+//    let sw = System.Diagnostics.Stopwatch.StartNew()
+//    let source = FunScript.Compiler.Compiler.Compile(mainCompileExpr, components=components)
+//    let sourceWrapped = sprintf "$(document).ready(function () {\n%s\n});" source
+//    printfn "Generated JavaScript in %f sec..." (float sw.ElapsedMilliseconds / 1000.0) 
+//    File.Delete filename
+//    File.WriteAllText(filename, sourceWrapped)
+
+
+let assemPathRef = ref ""
+let projectPathRef = ref ""
+let outPathRef = ref ""
+let stdOutRef = ref false
 
 let args =
-    [ ArgInfo("--assembly-path", ArgType.String(fun x -> assemPath := x), 
+    [ ArgInfo("--assembly-path", ArgType.String(fun x -> assemPathRef := x), 
               "Path to the assembly you want fun script to compile")
-      ArgInfo("--project-path", ArgType.String(fun x -> projectPath := x), 
+      ArgInfo("--project-path", ArgType.String(fun x -> projectPathRef := x), 
               "Path to the project you want fun script to compile")
-      ArgInfo("--out-path", ArgType.String(fun x -> outPath := x), 
+      ArgInfo("--out-path", ArgType.String(fun x -> outPathRef := x), 
               "Path of the resulting javascript file")
-      ArgInfo("--std-out", ArgType.SetArg(stdOut), 
+      ArgInfo("--std-out", ArgType.SetArg(stdOutRef), 
               "Write the results to standard out instead") ]
 
 let usageText = "FunScript Compiler - usage: funsc <args>"
@@ -62,41 +61,71 @@ let emptyStr = String.IsNullOrWhiteSpace
 let (|EmptyString|NonEmptyString|) 
     input = if System.String.IsNullOrWhiteSpace input then EmptyString else NonEmptyString
 
-type ParseResult = {Success : bool; Message : string}
-
 [<EntryPoint>]
 let main argv = 
     ArgParser.Parse(args, usageText = usageText)
+
+    let assemPath = !assemPathRef
+    let projectPath = !projectPathRef
+    let outPath = !outPathRef
+    let stdOut = !stdOutRef
     
-    let sourceParseResult : ParseResult = 
-        match !assemPath, !projectPath with
+    let sourceParseResult = 
+        match assemPath, projectPath with
         | (EmptyString, EmptyString) -> 
-            {Success=false; Message="error: either --assembly-path or --project-path is required"}
+            Some "error: either --assembly-path or --project-path is required"
         | (NonEmptyString, NonEmptyString) -> 
-            {Success=false; Message="error: both --assembly-path and --project-path specified. one or the other required"}
+            Some "error: both --assembly-path and --project-path specified. one or the other required"
+        | (_, _) -> 
+            None
+
+    let sourceExist = 
+        match assemPath, projectPath with
+        | (NonEmptyString, EmptyString) when (not (File.Exists assemPath)) -> 
+            Some(sprintf "error: assembly file not found at %s" assemPath)
+        | (EmptyString, NonEmptyString) when (not (File.Exists projectPath)) -> 
+            Some(sprintf "error: project file not found at %s" projectPath)
         | (_, _) -> 
-            {Success=true; Message=""}
+            None
 
-    let outParseResult : ParseResult = 
-        match !outPath, !stdOut with
+    let outParseResult = 
+        match outPath, stdOut with
         | (EmptyString, false) -> 
-            {Success=false; Message="error: either --out-path or --std-out is required"}
+            Some "error: either --out-path or --std-out is required"
         | (NonEmptyString, true) -> 
-            {Success=false; Message="error: both --out-path and --std-out specified. one or the other is required"}
+            Some "error: both --out-path and --std-out specified. one or the other is required"
         | (_, _) -> 
-            {Success=true; Message=""}
+            None
 
-    let parseResults = [sourceParseResult; outParseResult]
-    let parseFailMessages = seq { for r in parseResults do if not(r.Success) then yield r.Message}
+    let validationChecks = [sourceParseResult; outParseResult; sourceExist]
+    let failureMessages = seq { for m in validationChecks do if m.IsSome then yield m.Value}
 
     let mutable exitCode = 0
 
-    if not(Seq.isEmpty(parseFailMessages)) then
-        for m in parseFailMessages do   
+    if not(Seq.isEmpty(failureMessages)) then
+        for m in failureMessages do   
             printf "%s\n" m
         ArgParser.Usage(args, usage = usageText)
         exitCode <- 1
     else 
-        compile !assemPath !outPath []//Interop.Components.all
+        let compileResult = 
+            match assemPath, projectPath with 
+            | (NonEmptyString, EmptyString) ->
+                Compile.AssemblyToFunScript(Reflection.Assembly.LoadFile(assemPath))
+            | (EmptyString, NonEmptyString) ->
+                Compile.ProjectToFunScript(projectPath)
+            | (_, _) ->
+                failwithf "shouldnt ever get here"
         
+        if compileResult.Success then
+            if(stdOut) then
+                printf "%s" compileResult.CompiledFunScript
+            else
+                let outFile = FileInfo(outPath)
+                outFile.Directory.Create()
+                File.WriteAllText(outPath, compileResult.CompiledFunScript)
+        else
+            exitCode <- 1
+            for err in compileResult.Errors do
+                printf "%s" err.Message
     exitCode
\ No newline at end of file
diff --git a/src/extra/FunScript.Compiler/packages.config b/src/extra/FunScript.Compiler/packages.config
new file mode 100644
index 0000000..515a16d
--- /dev/null
+++ b/src/extra/FunScript.Compiler/packages.config
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="FSharp.Compiler.Service" version="0.0.82" targetFramework="net45" />
+  <package id="Mono.Cecil" version="0.9.5.4" targetFramework="net45" />
+</packages>
\ No newline at end of file

From f1102b5f51ba60f55bcbdf0b9e04d4cbf8123ed7 Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Sun, 15 Feb 2015 17:30:44 -0600
Subject: [PATCH 4/8] Added CompileAssembly to FunScript.Compiler

---
 src/compileTestData/Simple/App.config         | 14 +++
 src/compileTestData/Simple/Program.fs         |  7 ++
 src/compileTestData/Simple/Simple.fsproj      | 88 +++++++++++++++++
 src/compileTestData/WithBindings/App.config   | 14 +++
 src/compileTestData/WithBindings/Program.fs   | 15 +++
 .../WithBindings/WithBindings.fsproj          | 97 +++++++++++++++++++
 .../WithBindings/packages.config              |  5 +
 src/main/FunScript/Attributes/AssemblyMain.fs |  4 +
 src/main/FunScript/Compiler.fs                | 26 ++++-
 src/main/FunScript/FunScript.fsproj           |  1 +
 .../FunScript.Tests/AssemblyCompileTests.fs   | 24 +++++
 .../FunScript.Tests/FunScript.Tests.fsproj    | 16 +++
 12 files changed, 309 insertions(+), 2 deletions(-)
 create mode 100644 src/compileTestData/Simple/App.config
 create mode 100644 src/compileTestData/Simple/Program.fs
 create mode 100644 src/compileTestData/Simple/Simple.fsproj
 create mode 100644 src/compileTestData/WithBindings/App.config
 create mode 100644 src/compileTestData/WithBindings/Program.fs
 create mode 100644 src/compileTestData/WithBindings/WithBindings.fsproj
 create mode 100644 src/compileTestData/WithBindings/packages.config
 create mode 100644 src/main/FunScript/Attributes/AssemblyMain.fs
 create mode 100644 src/tests/FunScript.Tests/AssemblyCompileTests.fs

diff --git a/src/compileTestData/Simple/App.config b/src/compileTestData/Simple/App.config
new file mode 100644
index 0000000..a338d00
--- /dev/null
+++ b/src/compileTestData/Simple/App.config
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
+    </startup>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="FSharp.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.3.1.0" newVersion="4.3.1.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>
\ No newline at end of file
diff --git a/src/compileTestData/Simple/Program.fs b/src/compileTestData/Simple/Program.fs
new file mode 100644
index 0000000..b3dcca8
--- /dev/null
+++ b/src/compileTestData/Simple/Program.fs
@@ -0,0 +1,7 @@
+[<ReflectedDefinition>]
+module Page
+
+[<FunScript.AssemblyMain>]
+let main() = 
+    let foo = "bar"
+    foo
\ No newline at end of file
diff --git a/src/compileTestData/Simple/Simple.fsproj b/src/compileTestData/Simple/Simple.fsproj
new file mode 100644
index 0000000..627e8e8
--- /dev/null
+++ b/src/compileTestData/Simple/Simple.fsproj
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>e8eda6fd-20d3-4849-95da-ed2b0ae0a869</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <RootNamespace>Simple</RootNamespace>
+    <AssemblyName>Simple</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <TargetFSharpCoreVersion>4.3.1.0</TargetFSharpCoreVersion>
+    <Name>Simple</Name>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <Tailcalls>false</Tailcalls>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <WarningLevel>3</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DocumentationFile>bin\Debug\Simple.XML</DocumentationFile>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <Tailcalls>true</Tailcalls>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <WarningLevel>3</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DocumentationFile>bin\Release\Simple.XML</DocumentationFile>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="mscorlib" />
+    <Reference Include="FSharp.Core, Version=$(TargetFSharpCoreVersion), Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Numerics" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Program.fs" />
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\extra\FunScript.TypeScript\FunScript.TypeScript.fsproj">
+      <Name>FunScript.TypeScript</Name>
+      <Project>{164139cf-07d4-468f-b6a8-9b92504c38e4}</Project>
+      <Private>True</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\main\FunScript\FunScript.fsproj">
+      <Name>FunScript</Name>
+      <Project>{e0916e67-d3b0-4c3a-ad18-4146882fcedd}</Project>
+      <Private>True</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <PropertyGroup>
+    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '11.0'">
+      <PropertyGroup Condition="Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')">
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </When>
+    <Otherwise>
+      <PropertyGroup Condition="Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets')">
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </Otherwise>
+  </Choose>
+  <Import Project="$(FSharpTargetsPath)" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/src/compileTestData/WithBindings/App.config b/src/compileTestData/WithBindings/App.config
new file mode 100644
index 0000000..a338d00
--- /dev/null
+++ b/src/compileTestData/WithBindings/App.config
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
+    </startup>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="FSharp.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.3.1.0" newVersion="4.3.1.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>
\ No newline at end of file
diff --git a/src/compileTestData/WithBindings/Program.fs b/src/compileTestData/WithBindings/Program.fs
new file mode 100644
index 0000000..0a89e7c
--- /dev/null
+++ b/src/compileTestData/WithBindings/Program.fs
@@ -0,0 +1,15 @@
+[<ReflectedDefinition>]
+module Page
+
+open FunScript
+open FunScript.TypeScript
+
+let hello () =
+    Globals.window.alert("Hello world!")
+     
+let jq(selector : string) = Globals.Dollar.Invoke selector
+let (?) jq name = jq("#" + name)
+
+[<FunScript.AssemblyMain>]
+let main() = 
+    jq?helloWorld.click(fun _ -> hello() :> obj)
\ No newline at end of file
diff --git a/src/compileTestData/WithBindings/WithBindings.fsproj b/src/compileTestData/WithBindings/WithBindings.fsproj
new file mode 100644
index 0000000..831036d
--- /dev/null
+++ b/src/compileTestData/WithBindings/WithBindings.fsproj
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{5bb88a86-e7de-43ba-b809-a0dddad7f21c}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <RootNamespace>WithBindings</RootNamespace>
+    <AssemblyName>WithBindings</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <TargetFSharpCoreVersion>4.3.1.0</TargetFSharpCoreVersion>
+    <Name>WithBindings</Name>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <Tailcalls>false</Tailcalls>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <WarningLevel>3</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DocumentationFile>bin\Debug\WithBindings.XML</DocumentationFile>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <Tailcalls>true</Tailcalls>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <WarningLevel>3</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DocumentationFile>bin\Release\WithBindings.XML</DocumentationFile>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="FunScript.TypeScript.Binding.jquery">
+      <HintPath>..\..\packages\FunScript.TypeScript.Binding.jquery.1.1.0.37\lib\net40\FunScript.TypeScript.Binding.jquery.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="FunScript.TypeScript.Binding.lib">
+      <HintPath>..\..\packages\FunScript.TypeScript.Binding.lib.1.1.0.37\lib\net40\FunScript.TypeScript.Binding.lib.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="mscorlib" />
+    <Reference Include="FSharp.Core, Version=$(TargetFSharpCoreVersion), Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Numerics" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Program.fs" />
+    <None Include="App.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\extra\FunScript.TypeScript\FunScript.TypeScript.fsproj">
+      <Name>FunScript.TypeScript</Name>
+      <Project>{164139cf-07d4-468f-b6a8-9b92504c38e4}</Project>
+      <Private>True</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\main\FunScript\FunScript.fsproj">
+      <Name>FunScript</Name>
+      <Project>{e0916e67-d3b0-4c3a-ad18-4146882fcedd}</Project>
+      <Private>True</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <PropertyGroup>
+    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '11.0'">
+      <PropertyGroup Condition="Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')">
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </When>
+    <Otherwise>
+      <PropertyGroup Condition="Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets')">
+        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath>
+      </PropertyGroup>
+    </Otherwise>
+  </Choose>
+  <Import Project="$(FSharpTargetsPath)" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/src/compileTestData/WithBindings/packages.config b/src/compileTestData/WithBindings/packages.config
new file mode 100644
index 0000000..7b1f00d
--- /dev/null
+++ b/src/compileTestData/WithBindings/packages.config
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="FunScript.TypeScript.Binding.jquery" version="1.1.0.37" targetFramework="net45" />
+  <package id="FunScript.TypeScript.Binding.lib" version="1.1.0.37" targetFramework="net45" />
+</packages>
\ No newline at end of file
diff --git a/src/main/FunScript/Attributes/AssemblyMain.fs b/src/main/FunScript/Attributes/AssemblyMain.fs
new file mode 100644
index 0000000..f3a5c35
--- /dev/null
+++ b/src/main/FunScript/Attributes/AssemblyMain.fs
@@ -0,0 +1,4 @@
+namespace FunScript
+
+type AssemblyMain() =
+    inherit System.Attribute()
\ No newline at end of file
diff --git a/src/main/FunScript/Compiler.fs b/src/main/FunScript/Compiler.fs
index 698e1ac..b46238e 100644
--- a/src/main/FunScript/Compiler.fs
+++ b/src/main/FunScript/Compiler.fs
@@ -1,6 +1,7 @@
 module FunScript.Compiler
 
 open FunScript
+open System.Reflection
 
 //TODO: Use IoC here. MiniIoC perhaps? 
 let createComponents(isEventMappingEnabled) =
@@ -58,6 +59,27 @@ type Compiler =
    static member Compile(expression, ?components, ?noReturn, ?shouldCompress, ?isEventMappingEnabled) = 
       let components = defaultArg components []
       Compiler.CompileImpl(expression, (fun existingComponents -> existingComponents @ components), noReturn, shouldCompress, isEventMappingEnabled)
-      
+
+   static member CompileAssembly(assembly : Assembly, ?noReturn: bool, ?shouldCompress : bool, ?isEventMappingEnabled: bool) =
+      let assemblyMains =
+         let types = assembly.GetTypes()
+         let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
+         let mains = 
+            [ for typ in types do
+               for mi in typ.GetMethods(flags) do
+                  if System.Attribute.IsDefined(mi, typedefof<AssemblyMain>) then yield mi ]
+         mains
+
+      match assemblyMains with
+      | _ when assemblyMains.Length > 1 -> 
+         invalidOp "More than one method marked with [<FunScript.AssemblyMain>] found."
+      | [] -> 
+         invalidOp "No method marked with [<FunScript.AssemblyMain>] found."
+      | [main] ->
+         let mainExpr = Microsoft.FSharp.Quotations.Expr.Call(main, [])
+         Compiler.CompileImpl(mainExpr, (fun existingComponents -> existingComponents), noReturn, shouldCompress, isEventMappingEnabled)
+      | _ ->
+         failwith "never"
+            
 let compile expr = Compiler.Compile(expr)
-let compileWithoutReturn expr = Compiler.Compile(expr, noReturn=true)
+let compileWithoutReturn expr = Compiler.Compile(expr, noReturn=true)
\ No newline at end of file
diff --git a/src/main/FunScript/FunScript.fsproj b/src/main/FunScript/FunScript.fsproj
index 9caf8df..dcff42c 100644
--- a/src/main/FunScript/FunScript.fsproj
+++ b/src/main/FunScript/FunScript.fsproj
@@ -49,6 +49,7 @@
     <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Attributes\AssemblyMain.fs" />
     <Compile Include="AssemblyInfo.fs" />
     <Compile Include="AttributeHelpers.fs" />
     <Compile Include="ExprExtensions.fs" />
diff --git a/src/tests/FunScript.Tests/AssemblyCompileTests.fs b/src/tests/FunScript.Tests/AssemblyCompileTests.fs
new file mode 100644
index 0000000..c1cc284
--- /dev/null
+++ b/src/tests/FunScript.Tests/AssemblyCompileTests.fs
@@ -0,0 +1,24 @@
+#if INTERACTIVE
+#load "Interactive.fsx"
+open FunScript.Tests.Common
+#endif
+[<NUnit.Framework.TestFixture>] 
+module FunScript.Tests.CompileTests
+
+open System
+open System.Reflection
+open NUnit.Framework
+
+
+[<Test>]
+let ``Project compiles to js``() =
+    let compiled = FunScript.Compiler.Compiler.CompileAssembly(Assembly.Load("Simple"), false, false, true)
+    let expected = 
+        """var Page__main$;
+  Page__main$ = (function(unitVar0)
+  {
+    var foo = "bar";
+    return foo;
+  });
+  return Page__main$()"""
+    Assert.AreEqual(expected, compiled)
\ No newline at end of file
diff --git a/src/tests/FunScript.Tests/FunScript.Tests.fsproj b/src/tests/FunScript.Tests/FunScript.Tests.fsproj
index b336f33..62c0811 100644
--- a/src/tests/FunScript.Tests/FunScript.Tests.fsproj
+++ b/src/tests/FunScript.Tests/FunScript.Tests.fsproj
@@ -83,6 +83,7 @@
     <Compile Include="EventTests.fs" />
     <Compile Include="RxTests.fs" />
     <Compile Include="GuidTests.fs" />
+    <Compile Include="AssemblyCompileTests.fs" />
     <None Include="app.config" />
     <None Include="packages.config" />
     <None Include="edge\x86\node.dll">
@@ -136,6 +137,21 @@
       <Private>True</Private>
     </Reference>
     <Reference Include="System.Web" />
+    <ProjectReference Include="..\..\compileTestData\simple\Simple.fsproj">
+      <Name>Simple</Name>
+      <Project>{e8eda6fd-20d3-4849-95da-ed2b0ae0a869}</Project>
+      <Private>True</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\compileTestData\WithBindings\WithBindings.fsproj">
+      <Name>WithBindings</Name>
+      <Project>{5bb88a86-e7de-43ba-b809-a0dddad7f21c}</Project>
+      <Private>True</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\extra\FunScript.Compiler\FunScript.Compiler.fsproj">
+      <Name>FunScript.Compiler</Name>
+      <Project>{4aad0f56-af0f-46bd-811e-fec88ebed669}</Project>
+      <Private>True</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\extra\FunScript.Rx\FunScript.Rx.fsproj">
       <Name>FunScript.Rx</Name>
       <Project>{3d25cab2-83a4-4d3b-9986-ac068fe29307}</Project>

From 4827b0106a5c48dfee2f3771f01a3777ba952a6d Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Mon, 16 Feb 2015 13:50:22 -0600
Subject: [PATCH 5/8] Switched FunScript.Compiler to not reference FunScript
 itself. Instead uses project its compiling FunScript reference.

---
 src/FunScript.sln                             |  18 +++
 src/extra/FunScript.Compiler/Compile.fs       | 124 ++++++++++--------
 .../FunScript.Compiler.fsproj                 |   9 +-
 src/extra/FunScript.Compiler/Program.fs       |   6 +-
 4 files changed, 91 insertions(+), 66 deletions(-)

diff --git a/src/FunScript.sln b/src/FunScript.sln
index de74a11..9e5bfa2 100644
--- a/src/FunScript.sln
+++ b/src/FunScript.sln
@@ -15,6 +15,12 @@ Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FunScript.Rx", "extra\FunSc
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FunScript.Compiler", "extra\FunScript.Compiler\FunScript.Compiler.fsproj", "{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CompileTestData", "CompileTestData", "{71F5249A-EDF9-4C57-B3B8-3CEE26F8A9A6}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Simple", "compileTestData\simple\Simple.fsproj", "{E8EDA6FD-20D3-4849-95DA-ED2B0AE0A869}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WithBindings", "compileTestData\WithBindings\WithBindings.fsproj", "{5BB88A86-E7DE-43BA-B809-A0DDDAD7F21C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -45,10 +51,22 @@ Global
 		{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{4AAD0F56-AF0F-46BD-811E-FEC88EBED669}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E8EDA6FD-20D3-4849-95DA-ED2B0AE0A869}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E8EDA6FD-20D3-4849-95DA-ED2B0AE0A869}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E8EDA6FD-20D3-4849-95DA-ED2B0AE0A869}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E8EDA6FD-20D3-4849-95DA-ED2B0AE0A869}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5BB88A86-E7DE-43BA-B809-A0DDDAD7F21C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5BB88A86-E7DE-43BA-B809-A0DDDAD7F21C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5BB88A86-E7DE-43BA-B809-A0DDDAD7F21C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5BB88A86-E7DE-43BA-B809-A0DDDAD7F21C}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{E8EDA6FD-20D3-4849-95DA-ED2B0AE0A869} = {71F5249A-EDF9-4C57-B3B8-3CEE26F8A9A6}
+		{5BB88A86-E7DE-43BA-B809-A0DDDAD7F21C} = {71F5249A-EDF9-4C57-B3B8-3CEE26F8A9A6}
+	EndGlobalSection
 	GlobalSection(MonoDevelopProperties) = preSolution
 		$0.TextStylePolicy = $2
 		$1.inheritsSet = null
diff --git a/src/extra/FunScript.Compiler/Compile.fs b/src/extra/FunScript.Compiler/Compile.fs
index 614a21b..cc4d761 100644
--- a/src/extra/FunScript.Compiler/Compile.fs
+++ b/src/extra/FunScript.Compiler/Compile.fs
@@ -11,59 +11,64 @@
         Success: bool
         Errors: seq<CompileError>
         CompiledFunScript: string
-    }
+    } with
+        static member MakeSingleError message =
+            {Success=false;Errors=[{Message=message}];CompiledFunScript=""}
+        static member MakeSuccess source = 
+            {Success=true;Errors=Seq.empty<CompileError>;CompiledFunScript=source}
 
     [<ReflectedDefinition>]
     let compileMethod() = 
         let x = true
         x
 
-    let AssemblyToFunScript (assembly : Assembly) =
-        // Find the main method in this assembly
-        // Could offer lot more flexiblity here ...
-        let mainCompileExpr =
-            printfn "Searching for main function..."
-//            let types = Assembly.GetExecutingAssembly().GetTypes()
-//            let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
-//            let mains = 
-//                [ for typ in types do
-//                    for mi in typ.GetMethods(flags) do
-//                        if mi.Name = "compileMethod" then yield mi ]
-            let types = assembly.GetTypes()
-            let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
-            let mains = 
-                [ for typ in types do
-                    for mi in typ.GetMethods(flags) do
-                        if mi.Name = "main" then yield mi ]
-            let mainExpr = 
-                match mains with
-                | [it] -> Some(Expr.Call(it, []))
-                //| [it] -> Expr.TryGetReflectedDefinition(it)
-                | _ -> None
-            mainExpr
-
-//        let testExpr =  
-//            <@@
-//                let x = true
-//                x
-//            @@>
-
-        match mainCompileExpr with
-        | None -> 
-            {Success=false;Errors=[{Message="Could not find main function in any module."}];CompiledFunScript=""}
-        | _ ->
-            let sw = System.Diagnostics.Stopwatch.StartNew()
-            let source = FunScript.Compiler.Compiler.Compile(mainCompileExpr.Value, [])
-            printfn "Generated JavaScript in %f sec..." (float sw.ElapsedMilliseconds / 1000.0) 
-            {Success=true;Errors=Seq.empty<CompileError>;CompiledFunScript=source}
+    type ExceptionOrT<'t> =
+    | Exception of System.Exception
+    | T of 't
+
+    let AssemblyToFunScript (assembly : Assembly) (funScriptAssembly: Assembly) : CompileResult  =
+        //let funScriptAssembly = Assembly.Load("FunScript")
+        let compilerTypeName = "FunScript.Compiler+Compiler"
+        let compileMethodName = "CompileAssembly"//"Compile"
+
+        let getFunScriptType fullName = 
+            funScriptAssembly.GetTypes() 
+            |> Seq.tryFind(fun x -> x.FullName = fullName)
+
+        let funScriptCompiler = getFunScriptType compilerTypeName
+
+        match funScriptCompiler with
+        | None ->
+            CompileResult.MakeSingleError(sprintf "Could not find type \"%s\" in FunScript assembly" compilerTypeName)
+        | Some funScriptCompiler ->
+            let compileMethod = 
+                funScriptCompiler.GetMethods(BindingFlags.Public ||| BindingFlags.Static)
+                |> Seq.tryFind(fun x -> x.Name = compileMethodName)
+            match compileMethod with
+            | None ->
+                CompileResult.MakeSingleError(sprintf "Could not find method \"%s\" on type \"%s\" in FunScript assembly" compileMethodName compilerTypeName)
+            | Some compileMethod ->
+                let sw = System.Diagnostics.Stopwatch.StartNew()
+             
+                let invokeParams : array<obj> = [| assembly; None; None; None |]
+
+                let source : ExceptionOrT<string> = 
+                    try
+                        T(compileMethod.Invoke(null, invokeParams) :?> string)
+                    with ex ->
+                        Exception(ex)
+
+                match source with
+                | Exception ex ->
+                    CompileResult.MakeSingleError(sprintf "Exception during compile:\n%s" "" )//ex.ToString()
+                | T source ->
+                    CompileResult.MakeSuccess(source)
 
     let FSharpErrorInfoPrettyMessage (error : Microsoft.FSharp.Compiler.FSharpErrorInfo) =
         sprintf "%s %i:%i\n error: %s" error.FileName error.StartLineAlternate error.EndLineAlternate error.Message
 
     type AssemblyRefernce = {Path:string;ReflectedAssembly:AssemblyDefinition;AssemblyName:AssemblyName}
 
-    type ExceptionOrAssembly= E of System.Exception | A of Assembly
-
     let LoadDependencies (dependencyPaths : seq<string>) = 
        
         let unorderedDependencies =
@@ -110,18 +115,18 @@
         compileDomain.add_AssemblyResolve(handler)
         *)
 
-        let results : seq<ExceptionOrAssembly> = 
+        let results : seq<ExceptionOrT<Assembly>> = 
             TopSort(unorderedDependencies, pred, comparer)
             |> Seq.map(fun d -> 
                 try
-                    A(Assembly.LoadFrom(d.Path))
+                    T(Assembly.LoadFrom(d.Path))
                 with
                 | ex ->
-                    E(ex))
+                    Exception(ex))
         
         results
 
-    let ProjectToFunScript (projectPath: string) =
+    let ProjectToFunScript (projectPath: string) : CompileResult =
         let checker = FSharpChecker.Create()
         let projectOpts = checker.GetProjectOptionsFromProjectFile(projectPath)
 
@@ -133,12 +138,12 @@
         let dependencyResults = LoadDependencies(dependencyPaths)
         let loadErrors =  dependencyResults |> Seq.choose(fun x ->
             match x with
-                | A _ -> None
-                | E e -> Some e)
+                | T _ -> None
+                | Exception e -> Some e)
         let dependencies = dependencyResults |> Seq.choose(fun x ->
             match x with
-                | E _ -> None
-                | A a -> Some a)
+                | Exception _ -> None
+                | T a -> Some a)
 
         match loadErrors with
             |errors when Seq.length(errors) > 0 ->
@@ -149,10 +154,17 @@
                 let requiredOptions = Seq.ofList [ "--validate-type-providers" ]
 
                 let baseOptions = Seq.ofArray projectOpts.OtherOptions
+                
+                let outParam = "--out:"
+                let outAssemblyPath = 
+                    baseOptions 
+                    |> Seq.find(fun x -> x.StartsWith outParam)
+
+                let outAssemblyPath = outAssemblyPath.Substring(outParam.Length)
 
                 let options = Seq.concat [baseOptions; requiredOptions] |> Seq.distinct
 
-                let errors, exitCode, assembly = scs.CompileToDynamicAssembly(Seq.toArray options, Some(stdout, stderr))
+                //let errors, exitCode, assembly = scs.CompileToDynamicAssembly(Seq.toArray options, Some(stdout, stderr))
                 let errors, exitCode = scs.Compile(Seq.toArray options)
                 
                 let handler = System.ResolveEventHandler(fun sender ->
@@ -162,15 +174,17 @@
                 )
 
                 System.AppDomain.CurrentDomain.add_AssemblyResolve(handler)
-//                let errors = []
-//                let exitCode = 0
-                let assembly = 
-                    Assembly.LoadFrom("C:\\Projects\\FunScript.CommandLine\\FunScript.CommandLine.Example\\bin\\debug\\FunScript.CommandLine.Example.dll")
+                let outAssembly = 
+                    Assembly.LoadFrom(outAssemblyPath)
                     |> Some
 
                 match exitCode with
                     | i when (i < 1) ->
-                        AssemblyToFunScript(assembly.Value)
+                        match dependencies |> Seq.tryFind(fun x -> x.GetName().Name = "FunScript") with 
+                        | None -> 
+                            {Success=false;Errors=[{Message="Project must reference FunScript"}];CompiledFunScript=""}
+                        | Some funScriptAssembly ->
+                            AssemblyToFunScript outAssembly.Value funScriptAssembly
                     | _ ->
                         let compileErrors = 
                             match errors with
diff --git a/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj b/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
index 759c517..fc774c8 100644
--- a/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
+++ b/src/extra/FunScript.Compiler/FunScript.Compiler.fsproj
@@ -28,7 +28,7 @@
     <Prefer32Bit>true</Prefer32Bit>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <WarningsAsErrors />
-    <StartArguments>--project-path "C:\Projects\FunScript.CommandLine\FunScript.CommandLine.Example\FunScript.CommandLine.Example.fsproj" --std-out</StartArguments>
+    <StartArguments>--project-path "C:\Projects\FunScript\src\compileTestData\WithBindings\WithBindings.fsproj" --std-out</StartArguments>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -93,13 +93,6 @@
     <Reference Include="System.Core" />
     <Reference Include="System.Numerics" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\main\FunScript\FunScript.fsproj">
-      <Name>FunScript</Name>
-      <Project>{e0916e67-d3b0-4c3a-ad18-4146882fcedd}</Project>
-      <Private>True</Private>
-    </ProjectReference>
-  </ItemGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/src/extra/FunScript.Compiler/Program.fs b/src/extra/FunScript.Compiler/Program.fs
index 825c702..1455fff 100644
--- a/src/extra/FunScript.Compiler/Program.fs
+++ b/src/extra/FunScript.Compiler/Program.fs
@@ -1,7 +1,6 @@
 open System
 open System.IO
 open System.Reflection
-open FunScript
 open Microsoft.FSharp.Quotations
 open Microsoft.FSharp.Core;
 open Microsoft.FSharp.Text;
@@ -108,10 +107,11 @@ let main argv =
         ArgParser.Usage(args, usage = usageText)
         exitCode <- 1
     else 
-        let compileResult = 
+        let compileResult : Compile.CompileResult = 
             match assemPath, projectPath with 
             | (NonEmptyString, EmptyString) ->
-                Compile.AssemblyToFunScript(Reflection.Assembly.LoadFile(assemPath))
+//                Compile.AssemblyToFunScript Reflection.Assembly.LoadFile(assemPath) Reflection.Assembly.LoadFile(funScriptPath)
+                failwith "not implemented"
             | (EmptyString, NonEmptyString) ->
                 Compile.ProjectToFunScript(projectPath)
             | (_, _) ->

From 8b2f9830b39ab7fb25ba44e522678de987c470b9 Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Sat, 21 Feb 2015 22:30:07 -0600
Subject: [PATCH 6/8] WIP amd module implementation.

---
 src/compileTestData/Simple/Program.fs         | 15 ++-
 .../AssemblyMain.fs => Attributes.fs}         |  3 +
 src/main/FunScript/Comparison.fs              |  6 +-
 src/main/FunScript/Compiler.fs                | 24 +++--
 src/main/FunScript/FunScript.fsproj           |  2 +-
 src/main/FunScript/InternalCompiler.fs        | 92 +++++++++++++++----
 src/main/FunScript/JavaScriptNameMapper.fs    |  8 +-
 src/main/FunScript/RecordTypes.fs             |  2 +-
 src/main/FunScript/ReflectedDefinitions.fs    | 24 +++--
 src/main/FunScript/Reflection.fs              |  4 +-
 src/main/FunScript/Tuples.fs                  |  2 +-
 src/main/FunScript/UnionTypes.fs              |  2 +-
 .../FunScript.Tests/FunScript.Tests.fsproj    |  1 +
 src/tests/FunScript.Tests/ModuleTests.fs      | 31 +++++++
 14 files changed, 167 insertions(+), 49 deletions(-)
 rename src/main/FunScript/{Attributes/AssemblyMain.fs => Attributes.fs} (61%)
 create mode 100644 src/tests/FunScript.Tests/ModuleTests.fs

diff --git a/src/compileTestData/Simple/Program.fs b/src/compileTestData/Simple/Program.fs
index b3dcca8..6154fb6 100644
--- a/src/compileTestData/Simple/Program.fs
+++ b/src/compileTestData/Simple/Program.fs
@@ -1,7 +1,18 @@
 [<ReflectedDefinition>]
 module Page
 
+module x = 
+    let makeHello who = 
+        sprintf "hello %s" who
+
+module y = 
+    let yMakeHello who = 
+            x.makeHello who
+    module z =
+        let zMakeHello who = 
+            x.makeHello who
+
 [<FunScript.AssemblyMain>]
 let main() = 
-    let foo = "bar"
-    foo
\ No newline at end of file
+    let hello = y.z.zMakeHello "world"
+    hello
\ No newline at end of file
diff --git a/src/main/FunScript/Attributes/AssemblyMain.fs b/src/main/FunScript/Attributes.fs
similarity index 61%
rename from src/main/FunScript/Attributes/AssemblyMain.fs
rename to src/main/FunScript/Attributes.fs
index f3a5c35..906a15b 100644
--- a/src/main/FunScript/Attributes/AssemblyMain.fs
+++ b/src/main/FunScript/Attributes.fs
@@ -1,4 +1,7 @@
 namespace FunScript
 
 type AssemblyMain() =
+    inherit System.Attribute()
+
+type Module() =
     inherit System.Attribute()
\ No newline at end of file
diff --git a/src/main/FunScript/Comparison.fs b/src/main/FunScript/Comparison.fs
index c5a23cf..5c48aaf 100644
--- a/src/main/FunScript/Comparison.fs
+++ b/src/main/FunScript/Comparison.fs
@@ -62,7 +62,7 @@ let tryGetCompareToMethod compiler t =
     else
         let mapping = t.GetInterfaceMap typeof<IComparable>
         let compareToImplMethod = mapping.TargetMethods |> Seq.head
-        ReflectedDefinitions.tryCreateGlobalMethod "CompareTo" compiler compareToImplMethod Quote.CallType.MethodCall
+        ReflectedDefinitions.tryCreateModuleMethodExplicit "FunScript" "CompareTo" compiler compareToImplMethod Quote.CallType.MethodCall
     
 let compareInOrder valueExtractors comparandA comparandB =
     Array.foldBack (fun extractValue otherwise ->
@@ -155,7 +155,7 @@ let tryAutoGenerateCompareToLambda t =
 let getCompareToName compiler t =
    let typeArgs = Reflection.getGenericTypeArgs t
    let specialization = Reflection.getSpecializationString compiler typeArgs
-   JavaScriptNameMapper.mapType t + "_" + "GeneratedCompareTo" + specialization
+   "GeneratedCompareTo" + specialization
 
 let comparableCompareComponent compareQuote =
     let primitiveCompareMethod, _ = Quote.toMethodInfoFromLambdas <@ EmittedReplacements.compare @>
@@ -182,7 +182,7 @@ let comparableCompareComponent compareQuote =
                     | None -> None
                     | Some createCompareToLambda ->
                         let compareFuncVar = 
-                            compiler.DefineGlobal (getCompareToName compiler exprA.Type) (fun var ->
+                            compiler.DefineGlobal exprA.Type (getCompareToName compiler exprA.Type) (fun var ->
                                 compiler.Compile (ReturnStrategies.assignVar var) (createCompareToLambda())
                             )
                         let lambda = Expr.Var compareFuncVar
diff --git a/src/main/FunScript/Compiler.fs b/src/main/FunScript/Compiler.fs
index b46238e..c5be3cb 100644
--- a/src/main/FunScript/Compiler.fs
+++ b/src/main/FunScript/Compiler.fs
@@ -39,28 +39,32 @@ let createComponents(isEventMappingEnabled) =
     ]
 
 type Compiler =
-   static member private CompileImpl(expression, adjustComponents, noReturn, shouldCompress, isEventMappingEnabled) = 
+   static member private CompileImpl(expression, adjustComponents, noReturn, shouldCompress, isEventMappingEnabled, outputModules) = 
       let shouldCompress = defaultArg shouldCompress false
       let isEventMappingEnabled = defaultArg isEventMappingEnabled true
       let returnStrat = 
          if defaultArg noReturn false then ReturnStrategies.inplace
          else ReturnStrategies.returnFrom
       let components = createComponents isEventMappingEnabled
-      let compiler = InternalCompiler.Compiler(adjustComponents components)
+      let compiler = InternalCompiler.Compiler(adjustComponents components, outputModules)
       let program = compiler.Compile returnStrat expression
-      let reflectedDefs = compiler.Globals
-      let block = List.append reflectedDefs program
+      let globals = compiler.Globals
+      let block = List.append globals program
       if shouldCompress then (AST.Block block).PrintCompressed()
       else (AST.Block block).Print()
 
-   static member Compile(expression, adjustComponents, ?noReturn, ?shouldCompress, ?isEventMappingEnabled) = 
-      Compiler.CompileImpl(expression, adjustComponents, noReturn, shouldCompress, isEventMappingEnabled)
+   static member Compile(expression, adjustComponents, ?noReturn, ?shouldCompress, ?isEventMappingEnabled, ?outputModules ) = 
+      Compiler.CompileImpl(expression, adjustComponents, noReturn, shouldCompress, isEventMappingEnabled, outputModules)
 
-   static member Compile(expression, ?components, ?noReturn, ?shouldCompress, ?isEventMappingEnabled) = 
+   static member Compile(expression, ?components, ?noReturn, ?shouldCompress, ?isEventMappingEnabled, ?outputModules) = 
       let components = defaultArg components []
-      Compiler.CompileImpl(expression, (fun existingComponents -> existingComponents @ components), noReturn, shouldCompress, isEventMappingEnabled)
+      Compiler.CompileImpl(expression, (fun existingComponents -> existingComponents @ components), noReturn, shouldCompress, isEventMappingEnabled, outputModules)
 
-   static member CompileAssembly(assembly : Assembly, ?noReturn: bool, ?shouldCompress : bool, ?isEventMappingEnabled: bool) =
+//    static member CompileModules(modules, ?components, ?noReturn, ?shouldCompress, ?isEventMappingEnabled) = 
+//        let components = defaultArg components []
+//        Compiler.CompileImpl(expression, (fun existingComponents -> existingComponents @ components), noReturn, shouldCompress, isEventMappingEnabled)
+
+   static member CompileAssembly(assembly : Assembly, ?noReturn, ?shouldCompress, ?isEventMappingEnabled, ?outputModules) =
       let assemblyMains =
          let types = assembly.GetTypes()
          let flags = BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Static
@@ -77,7 +81,7 @@ type Compiler =
          invalidOp "No method marked with [<FunScript.AssemblyMain>] found."
       | [main] ->
          let mainExpr = Microsoft.FSharp.Quotations.Expr.Call(main, [])
-         Compiler.CompileImpl(mainExpr, (fun existingComponents -> existingComponents), noReturn, shouldCompress, isEventMappingEnabled)
+         Compiler.CompileImpl(mainExpr, (fun existingComponents -> existingComponents), noReturn, shouldCompress, isEventMappingEnabled, outputModules)
       | _ ->
          failwith "never"
             
diff --git a/src/main/FunScript/FunScript.fsproj b/src/main/FunScript/FunScript.fsproj
index dcff42c..ffafe7d 100644
--- a/src/main/FunScript/FunScript.fsproj
+++ b/src/main/FunScript/FunScript.fsproj
@@ -49,7 +49,6 @@
     <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Attributes\AssemblyMain.fs" />
     <Compile Include="AssemblyInfo.fs" />
     <Compile Include="AttributeHelpers.fs" />
     <Compile Include="ExprExtensions.fs" />
@@ -72,6 +71,7 @@
     <Compile Include="Core\StringWriter.fs" />
     <Compile Include="Core\Dictionaries.fs" />
     <Compile Include="Core\Web.fs" />
+    <Compile Include="Attributes.fs" />
     <Compile Include="JavaScriptNameMapper.fs" />
     <Compile Include="AST.fs" />
     <Compile Include="QuoteExtensions.fs" />
diff --git a/src/main/FunScript/InternalCompiler.fs b/src/main/FunScript/InternalCompiler.fs
index 20074f8..6b6c5a6 100644
--- a/src/main/FunScript/InternalCompiler.fs
+++ b/src/main/FunScript/InternalCompiler.fs
@@ -15,7 +15,8 @@ type ICompiler =
    abstract Compile: returnStategy:IReturnStrategy -> expr:Expr -> JSStatement list
    abstract ReplacementFor: MethodBase -> Quote.CallType -> MethodInfo option
    abstract NextTempVar: unit -> Var
-   abstract DefineGlobal: string -> (Var -> JSStatement list) -> Var
+   abstract DefineGlobal: Type -> string -> (Var -> JSStatement list) -> Var
+   abstract DefineGlobalExplicit: string -> string -> (Var -> JSStatement list) -> Var
    abstract DefineGlobalInitialization: JSStatement list -> unit
    abstract Globals: JSStatement list
 
@@ -27,12 +28,27 @@ type CallReplacer =
     TargetType: Quote.CallType
     Replacement: MethodInfo option
     TryReplace: ICompiler -> IReturnStrategy -> Expr option * Type [] * Expr list -> JSStatement list }
+      
+type JSModuleMember = 
+  { Name: string;
+    Var: Var;
+    Statements: List<JSStatement> }
+     
+module JSModule =
+   type T = 
+     { Name:string; 
+       Members: Map<string, JSModuleMember> }
+   let create (name : string ) =
+      {Name=name;Members=Map.empty}
+   let addMember (jsModuleMember: JSModuleMember) (jsModule: T) =
+      let members = jsModule.Members |> Map.add jsModuleMember.Name jsModuleMember
+      { jsModule with Members = members }
 
 type CompilerComponent =
    | CallReplacer of CallReplacer
    | CompilerComponent of ICompilerComponent
 
-type Compiler(components) as this = 
+type Compiler(components, outputModules) as this = 
    let parameterKey (mb : MethodBase) =
       mb.GetParameters() |> Array.map (fun pi ->
          pi.ParameterType.Name)
@@ -131,23 +147,59 @@ type Compiler(components) as this =
 
    let nextId = ref 0
 
-   let mutable globals = Map.empty
-
-   let define name cons =
-      match globals |> Map.tryFind name with
-      | Some (var, _) -> var
+   let mutable modules = Map.empty<string, JSModule.T>
+   let updateModule (jsModule : JSModule.T) = 
+      modules <- modules |> Map.add jsModule.Name jsModule
+      
+   let define (moduleName : string) (name : string) (cons : Var -> List<JSStatement>) =
+      let jsModule = match modules |> Map.tryFind moduleName with
+      | Some (jsModule) -> jsModule 
       | None -> 
-         // Define upfront to avoid problems with mutually recursive methods
-         let var = Var.Global(name, typeof<obj>)
-         globals <- globals |> Map.add name (var, [])
-         let assignment = cons var
-         globals <- globals |> Map.add name (var, assignment)
-         var
+         let jsModule = JSModule.create(moduleName)
+         updateModule jsModule
+         jsModule
+
+      match jsModule.Members |> Map.tryFind name with
+      | Some (moduleMember) -> moduleMember.Var
+      | None ->
+             //still have to put the full module name as the path to prevent collions when not compiling 
+             //to modules. to fix this, check whether modules are enabled.
+             let name = moduleName + "_" + name 
+             let var = Var.Global(name, typeof<obj>)
+             let moduleMember = {Name=name; Var=var; Statements=List.empty}
+             let jsModule = jsModule |> JSModule.addMember moduleMember
+             updateModule jsModule
+             let assignment = cons var
+             let jsModule = jsModule |> JSModule.addMember {moduleMember with Var = var; Statements = assignment}
+             updateModule jsModule
+             var
+//      | Some (jsModule) -> 
+//         match jsModule.Members |> Map.tryFind name with
+//         | Some (jsModuleMember) -> jsModuleMember.Var
+//         | None -> Var.Global(name, typeof<obj>) //this needs implemented
+//      | None -> 
+//         Var.Global(name, typeof<obj>)
+
+//         // Define upfront to avoid problems with mutually recursive methods
+//         let var = Var.Global(name, typeof<obj>)
+//         globals <- globals |> Map.add name (var, [])
+//         let assignment = cons var
+//         globals <- globals |> Map.add name (var, assignment)
+//         var
 
    let mutable initialization = List.empty
 
    let getGlobals() =
-      let globals = globals |> Map.toList |> List.map snd
+      //let globals = globals |> Map.toList |> List.map snd
+      let globalMethods = 
+         modules 
+         |> Map.toList 
+         |> List.map snd
+         |> List.collect(fun m -> m.Members |> Map.toList |> List.map snd)
+
+      let globals = 
+         globalMethods
+         |> List.map(fun x -> x.Var, x.Statements)
 
       let declarations = 
          match globals with
@@ -178,7 +230,7 @@ type Compiler(components) as this =
                                   && m.IsStatic = replacementMethod.IsStatic // TODO: We may need to make this comparison safer
                                   && m.GetParameters().Length = replacementMethod.GetParameters().Length) 
 
-   member __.Compile returnStategy expr  = 
+   member __.Compile returnStategy expr = 
       compile returnStategy expr
 
    member __.Globals = getGlobals()
@@ -202,9 +254,13 @@ type Compiler(components) as this =
          incr nextId
          Var(sprintf "_%i" !nextId, typeof<obj>, false) 
          
-      member __.DefineGlobal name cons =
-         define name cons
-
+      member __.DefineGlobal moduleType name cons =
+         let moduleName = JavaScriptNameMapper.mapType moduleType
+         define moduleName name cons
+      
+      member __.DefineGlobalExplicit moduleName name cons =
+         define moduleName name cons
+         
       member __.DefineGlobalInitialization stmts =
          initialization <- List.append initialization stmts
 
diff --git a/src/main/FunScript/JavaScriptNameMapper.fs b/src/main/FunScript/JavaScriptNameMapper.fs
index 40b7f37..9808c2a 100644
--- a/src/main/FunScript/JavaScriptNameMapper.fs
+++ b/src/main/FunScript/JavaScriptNameMapper.fs
@@ -116,7 +116,9 @@ let rec private getBestTypeName (t : System.Type) =
       if t.IsGenericType || t.IsGenericTypeDefinition then
          t.GetGenericArguments()
       else [||]
-   t.Name + "_" + (args |> Seq.map getBestTypeName |> String.concat "_")
+   match args with 
+   | [||] -> t.Name
+   | _ ->  t.Name + "_" + (args |> Seq.map getBestTypeName |> String.concat "_")
 
 let (*internal*) mapType (t : System.Type) =
    sanitize t.FullName (getBestTypeName t)
@@ -126,7 +128,7 @@ let getBestMethodName (mb : MethodBase) =
       if mb.IsGenericMethod || mb.IsGenericMethodDefinition then
          mb.GetGenericArguments()
       else [||]
-   (mapType mb.DeclaringType) + "_" + mb.Name + "$" + (args |> Seq.map mapType |> String.concat "_")
+   mb.Name + "$" + (args |> Seq.map mapType |> String.concat "_")
 
 let (*internal*) mapMethod mb =
    let suggestedName = getBestMethodName mb
@@ -134,5 +136,5 @@ let (*internal*) mapMethod mb =
       mb.GetParameters() |> Array.map (fun pi -> pi.ParameterType.Name)
       |> String.concat ","
    let key =
-      mb.DeclaringType.FullName + suggestedName + "[" + paramKey + "]"
+      suggestedName + "[" + paramKey + "]"
    sanitize key suggestedName
\ No newline at end of file
diff --git a/src/main/FunScript/RecordTypes.fs b/src/main/FunScript/RecordTypes.fs
index 5cc52b3..a1fbb0c 100644
--- a/src/main/FunScript/RecordTypes.fs
+++ b/src/main/FunScript/RecordTypes.fs
@@ -39,7 +39,7 @@ let private creation =
             |> List.unzip
          let name = Reflection.getRecordConstructorName compiler recType
          let cons = 
-            compiler.DefineGlobal name (fun var -> 
+            compiler.DefineGlobal recType name (fun var -> 
                [Assign(Reference var, Lambda <| createConstructor recType compiler)])
          [ yield! decls |> Seq.concat 
            yield returnStategy.Return <| New(cons, refs)
diff --git a/src/main/FunScript/ReflectedDefinitions.fs b/src/main/FunScript/ReflectedDefinitions.fs
index 4e1a26c..0796c8c 100644
--- a/src/main/FunScript/ReflectedDefinitions.fs
+++ b/src/main/FunScript/ReflectedDefinitions.fs
@@ -84,19 +84,29 @@ let private genMethod (mb:MethodBase) (replacementMi:MethodBase) (vars:Var list)
 
 let private (|CallPattern|_|) = Objects.methodCallPattern
 
-let tryCreateGlobalMethod name compiler mb callType =
+let tryCreateModuleMethodBase (compiler:FunScript.InternalCompiler.ICompiler) mb callType callDefine = 
    match Objects.replaceIfAvailable compiler mb callType with
    | CallPattern getVarsExpr as replacementMi ->
       let typeArgs = Reflection.getGenericMethodArgs replacementMi
       let specialization = Reflection.getSpecializationString compiler typeArgs
       Some(
-         compiler.DefineGlobal (name + specialization) (fun var ->
+         callDefine specialization (fun var ->
             let vars, bodyExpr = getVarsExpr()
             genMethod mb replacementMi vars bodyExpr var compiler))
    | _ -> None
 
-let createGlobalMethod name compiler mb callType =
-    match tryCreateGlobalMethod name compiler mb callType with
+let tryCreateModuleMethodExplicit moduleName methodName compiler mb callType =
+   tryCreateModuleMethodBase compiler mb callType (
+      fun (specialization) (cons) -> 
+         compiler.DefineGlobalExplicit moduleName (methodName + specialization) cons)
+
+let tryCreateModuleMethod moduleType methodName compiler mb callType =
+   tryCreateModuleMethodBase compiler mb callType (
+      fun (specialization) (cons) -> 
+         compiler.DefineGlobal moduleType (methodName + specialization) cons)
+
+let createModuleMethod moduleType methodName compiler mb callType =
+    match tryCreateModuleMethod moduleType methodName compiler mb callType with
     | None -> failwithf "No reflected definition for method: %s" mb.Name
     | Some x -> x
 
@@ -113,7 +123,7 @@ let private createConstruction
    match ci with
    | ReflectedDefinition name ->
       //TODO: Generic types will have typeArgs we need to deal with here.
-      let consRef = createGlobalMethod name compiler ci Quote.ConstructorCall
+      let consRef = createModuleMethod ci.DeclaringType name compiler ci Quote.ConstructorCall
       [ yield! decls |> List.concat
         yield returnStategy.Return <| New(consRef, refs) ]
    | _ -> []
@@ -249,7 +259,7 @@ let private createCall
    | SpecialOp((ReflectedDefinition name) as mi)
    | (ReflectedDefinition name as mi) ->
       // TODO: What about interfaces!
-      let methRef = createGlobalMethod name compiler mi Quote.MethodCall
+      let methRef = createModuleMethod mi.DeclaringType name compiler mi Quote.MethodCall
       [  yield! decls |> List.concat
          yield returnStategy.Return <| Apply(Reference methRef, refs) ]
    | _ -> []
@@ -266,7 +276,7 @@ let private getPropertyField split (compiler:InternalCompiler.ICompiler) (pi:Pro
    let name = 
       JavaScriptNameMapper.sanitizeAux
          (JavaScriptNameMapper.mapType pi.DeclaringType + "_" + pi.Name + specialization)
-   compiler.DefineGlobal name (fun var ->
+   compiler.DefineGlobal pi.DeclaringType name (fun var ->
       // TODO: wrap in function scope?
       compiler.DefineGlobalInitialization <|
          createCall split (ReturnStrategies.assignVar var) compiler [objExpr; exprs] (pi.GetGetMethod(true))
diff --git a/src/main/FunScript/Reflection.fs b/src/main/FunScript/Reflection.fs
index 4338710..fdf7dd6 100644
--- a/src/main/FunScript/Reflection.fs
+++ b/src/main/FunScript/Reflection.fs
@@ -70,7 +70,7 @@ let getRecordConstructorName compiler (recType : System.Type) =
 let getUnionCaseConstructorName compiler (uci : UnionCaseInfo) =
    let typeArgs = getGenericTypeArgs uci.DeclaringType
    let specialization = getSpecializationString compiler typeArgs
-   JavaScriptNameMapper.mapType uci.DeclaringType + "_" + uci.Name + specialization
+   uci.Name + specialization
    
 let createLambdaVars(fields : Type[]) =
    let fieldCount = fields.Length
@@ -154,7 +154,7 @@ and private netTypeExpr compiler getTypeVar (t : Type) =
 
 let rec buildRuntimeType (compiler : InternalCompiler.ICompiler) (t : System.Type) =
    let typeName = sprintf "t_%s" (JavaScriptNameMapper.mapType t)
-   compiler.DefineGlobal typeName (fun var ->
+   compiler.DefineGlobalExplicit "FunScript.RunTimeTypes" typeName (fun var ->
       let expr = netTypeExpr compiler (buildRuntimeType compiler) t
       compiler.Compile (ReturnStrategies.assignVar var) expr
    )
diff --git a/src/main/FunScript/Tuples.fs b/src/main/FunScript/Tuples.fs
index ff8f6b1..90f8560 100644
--- a/src/main/FunScript/Tuples.fs
+++ b/src/main/FunScript/Tuples.fs
@@ -33,7 +33,7 @@ let private creation =
          let specialization = Reflection.getSpecializationString compiler typeArgs
          let name = sprintf "Tuple%s" specialization
          let cons = 
-            compiler.DefineGlobal name (fun var -> 
+            compiler.DefineGlobalExplicit "Tuples" name (fun var -> 
                [Assign(Reference var, Lambda <| createConstructor n compiler)])
          [  yield! decls |> Seq.concat 
             yield returnStategy.Return <| New(cons, refs)
diff --git a/src/main/FunScript/UnionTypes.fs b/src/main/FunScript/UnionTypes.fs
index 4388abe..ad9c6a5 100644
--- a/src/main/FunScript/UnionTypes.fs
+++ b/src/main/FunScript/UnionTypes.fs
@@ -54,7 +54,7 @@ let private creation =
             |> List.unzip
          let name = Reflection.getUnionCaseConstructorName compiler uci
          let cons = 
-            compiler.DefineGlobal name (fun var -> 
+            compiler.DefineGlobal uci.DeclaringType name (fun var -> 
                [Assign(Reference var, Lambda <| createConstructor uci compiler)])
          [ yield! decls |> Seq.concat 
            yield returnStategy.Return <| New(cons, refs)
diff --git a/src/tests/FunScript.Tests/FunScript.Tests.fsproj b/src/tests/FunScript.Tests/FunScript.Tests.fsproj
index 62c0811..cd43df5 100644
--- a/src/tests/FunScript.Tests/FunScript.Tests.fsproj
+++ b/src/tests/FunScript.Tests/FunScript.Tests.fsproj
@@ -84,6 +84,7 @@
     <Compile Include="RxTests.fs" />
     <Compile Include="GuidTests.fs" />
     <Compile Include="AssemblyCompileTests.fs" />
+    <Compile Include="ModuleTests.fs" />
     <None Include="app.config" />
     <None Include="packages.config" />
     <None Include="edge\x86\node.dll">
diff --git a/src/tests/FunScript.Tests/ModuleTests.fs b/src/tests/FunScript.Tests/ModuleTests.fs
new file mode 100644
index 0000000..78e3a60
--- /dev/null
+++ b/src/tests/FunScript.Tests/ModuleTests.fs
@@ -0,0 +1,31 @@
+[<NUnit.Framework.TestFixture>] 
+module FunScript.Tests.ModuleTests
+
+open System
+open NUnit.Framework
+
+[<ReflectedDefinition>]
+module level1 = 
+    let x() = "foo"
+
+[<ReflectedDefinition>]
+module level2 = 
+    let y() = level1.x()
+
+//[<Test>]
+//let ``Compile module into amd module``() =
+//    let results = FunScript.CompileModule(gettypedef<level1>)
+//    let expected = """foo\
+//    """
+//    Assert.AreEqual(expected, results)
+//
+//[<Test>]
+//let ``Compile multiple modules into amd modules``() =
+//    test.x()
+
+[<Test>]
+let ``playing``() =
+    check
+        <@@
+        level2.y()
+        @@>

From 76f5a02bd3c1b3ee08d77cf4c596ff3e5104b6f2 Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Sun, 22 Feb 2015 21:10:34 -0600
Subject: [PATCH 7/8] Fixed moduels being overwritten.

Fixed recursive references.
---
 src/main/FunScript/InternalCompiler.fs | 41 +++++++++++---------------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/src/main/FunScript/InternalCompiler.fs b/src/main/FunScript/InternalCompiler.fs
index 6b6c5a6..c877efb 100644
--- a/src/main/FunScript/InternalCompiler.fs
+++ b/src/main/FunScript/InternalCompiler.fs
@@ -152,45 +152,38 @@ type Compiler(components, outputModules) as this =
       modules <- modules |> Map.add jsModule.Name jsModule
       
    let define (moduleName : string) (name : string) (cons : Var -> List<JSStatement>) =
-      let jsModule = match modules |> Map.tryFind moduleName with
-      | Some (jsModule) -> jsModule 
-      | None -> 
-         let jsModule = JSModule.create(moduleName)
-         updateModule jsModule
-         jsModule
+      let jsModule = 
+         match modules |> Map.tryFind moduleName with
+            | Some (jsModule) -> jsModule 
+            |None -> 
+               let jsModule = JSModule.create(moduleName)
+               updateModule jsModule
+               jsModule
+      //still have to put the full module name as the path to prevent collions when not compiling 
+      //to modules. to fix this, check whether modules are enabled.
+      let name = moduleName + "_" + name 
 
       match jsModule.Members |> Map.tryFind name with
       | Some (moduleMember) -> moduleMember.Var
       | None ->
-             //still have to put the full module name as the path to prevent collions when not compiling 
-             //to modules. to fix this, check whether modules are enabled.
-             let name = moduleName + "_" + name 
+             // Define upfront to avoid problems with mutually recursive methods
              let var = Var.Global(name, typeof<obj>)
              let moduleMember = {Name=name; Var=var; Statements=List.empty}
              let jsModule = jsModule |> JSModule.addMember moduleMember
              updateModule jsModule
              let assignment = cons var
-             let jsModule = jsModule |> JSModule.addMember {moduleMember with Var = var; Statements = assignment}
+             // more methods could have been added, need to get the latest module refernce
+             let jsModule = 
+                modules
+                |> Map.find moduleName 
+                |> JSModule.addMember {moduleMember with Var = var; Statements = assignment}
+
              updateModule jsModule
              var
-//      | Some (jsModule) -> 
-//         match jsModule.Members |> Map.tryFind name with
-//         | Some (jsModuleMember) -> jsModuleMember.Var
-//         | None -> Var.Global(name, typeof<obj>) //this needs implemented
-//      | None -> 
-//         Var.Global(name, typeof<obj>)
-
-//         // Define upfront to avoid problems with mutually recursive methods
-//         let var = Var.Global(name, typeof<obj>)
-//         globals <- globals |> Map.add name (var, [])
-//         let assignment = cons var
-//         globals <- globals |> Map.add name (var, assignment)
-//         var
 
    let mutable initialization = List.empty
 
    let getGlobals() =
-      //let globals = globals |> Map.toList |> List.map snd
       let globalMethods = 
          modules 
          |> Map.toList 

From fdfef6acccb4d7d54068ff3cea7e7e3447fafa99 Mon Sep 17 00:00:00 2001
From: Xavier Zwirtz <xavier@birddogsw.com>
Date: Thu, 26 Feb 2015 00:44:31 -0600
Subject: [PATCH 8/8] Implemented ordering of out put by dependency.

---
 src/main/FunScript/FunScript.fsproj           |   1 +
 src/main/FunScript/InternalCompiler.fs        | 121 +++++++++++++-----
 src/main/FunScript/TopSort.fs                 |  18 +++
 src/tests/FunScript.Tests/DependencyTests.fs  |  21 +++
 .../FunScript.Tests/FunScript.Tests.fsproj    |   1 +
 5 files changed, 129 insertions(+), 33 deletions(-)
 create mode 100644 src/main/FunScript/TopSort.fs
 create mode 100644 src/tests/FunScript.Tests/DependencyTests.fs

diff --git a/src/main/FunScript/FunScript.fsproj b/src/main/FunScript/FunScript.fsproj
index ffafe7d..529933c 100644
--- a/src/main/FunScript/FunScript.fsproj
+++ b/src/main/FunScript/FunScript.fsproj
@@ -52,6 +52,7 @@
     <Compile Include="AssemblyInfo.fs" />
     <Compile Include="AttributeHelpers.fs" />
     <Compile Include="ExprExtensions.fs" />
+    <Compile Include="TopSort.fs" />
     <Compile Include="Core\LanguagePrimitives.fs" />
     <Compile Include="Core\GenericConstants.fs" />
     <Compile Include="Core\Array.fs" />
diff --git a/src/main/FunScript/InternalCompiler.fs b/src/main/FunScript/InternalCompiler.fs
index c877efb..2184118 100644
--- a/src/main/FunScript/InternalCompiler.fs
+++ b/src/main/FunScript/InternalCompiler.fs
@@ -29,21 +29,31 @@ type CallReplacer =
     Replacement: MethodInfo option
     TryReplace: ICompiler -> IReturnStrategy -> Expr option * Type [] * Expr list -> JSStatement list }
       
-type JSModuleMember = 
-  { Name: string;
-    Var: Var;
-    Statements: List<JSStatement> }
-     
-module JSModule =
-   type T = 
+module JSModules =
+   type JSModule = 
      { Name:string; 
-       Members: Map<string, JSModuleMember> }
-   let create (name : string ) =
+       Members: Map<string, JSModuleMember>}
+
+   and JSModuleMember = 
+     { Container: JSModule;
+       Dependencies: seq<JSModuleMember>;
+       Name: string;
+       FullName: string;
+       Var: Var;
+       Statements: List<JSStatement> }
+
+   let createModule (name : string) =
       {Name=name;Members=Map.empty}
-   let addMember (jsModuleMember: JSModuleMember) (jsModule: T) =
+
+   let createMember (container : JSModule) name var =
+      let fullName = sprintf "%s.%s" container.Name name
+      {Name=name; FullName=fullName; Var=var; Statements=List.empty; Container=container; Dependencies=Seq.empty}
+
+   let addMember (jsModuleMember: JSModuleMember) (jsModule: JSModule) =
       let members = jsModule.Members |> Map.add jsModuleMember.Name jsModuleMember
       { jsModule with Members = members }
 
+type JSModuleMember = JSModules.JSModuleMember
 type CompilerComponent =
    | CallReplacer of CallReplacer
    | CompilerComponent of ICompilerComponent
@@ -147,39 +157,66 @@ type Compiler(components, outputModules) as this =
 
    let nextId = ref 0
 
-   let mutable modules = Map.empty<string, JSModule.T>
-   let updateModule (jsModule : JSModule.T) = 
+   let mutable modules = Map.empty<string, JSModules.JSModule>
+   let updateModule (jsModule : JSModules.JSModule) = 
       modules <- modules |> Map.add jsModule.Name jsModule
       
+   let mutable dependencyCapture = Seq.empty<seq<JSModules.JSModuleMember>>
+
    let define (moduleName : string) (name : string) (cons : Var -> List<JSStatement>) =
       let jsModule = 
          match modules |> Map.tryFind moduleName with
             | Some (jsModule) -> jsModule 
             |None -> 
-               let jsModule = JSModule.create(moduleName)
+               let jsModule = JSModules.createModule(moduleName)
                updateModule jsModule
                jsModule
+
+      dependencyCapture <- Seq.append dependencyCapture [ Seq.empty ]
       //still have to put the full module name as the path to prevent collions when not compiling 
       //to modules. to fix this, check whether modules are enabled.
       let name = moduleName + "_" + name 
 
-      match jsModule.Members |> Map.tryFind name with
-      | Some (moduleMember) -> moduleMember.Var
-      | None ->
-             // Define upfront to avoid problems with mutually recursive methods
-             let var = Var.Global(name, typeof<obj>)
-             let moduleMember = {Name=name; Var=var; Statements=List.empty}
-             let jsModule = jsModule |> JSModule.addMember moduleMember
-             updateModule jsModule
-             let assignment = cons var
-             // more methods could have been added, need to get the latest module refernce
-             let jsModule = 
-                modules
-                |> Map.find moduleName 
-                |> JSModule.addMember {moduleMember with Var = var; Statements = assignment}
-
-             updateModule jsModule
-             var
+      let moduleMember = 
+         match jsModule.Members |> Map.tryFind name with
+            | Some (moduleMember) -> moduleMember
+            | None ->
+                  // Define upfront to avoid problems with mutually recursive methods
+                  let var = Var.Global(name, typeof<obj>)
+                  let moduleMember = JSModules.createMember jsModule name var 
+                  let jsModule = jsModule |> JSModules.addMember moduleMember
+                  updateModule jsModule
+                  let assignment = cons var
+                  let dependencies = dependencyCapture |> Seq.last
+                  let fullyConstructed = {
+                     moduleMember with 
+                        Var=var; 
+                        Statements=assignment;
+                        Dependencies=dependencies}
+                  // more methods could have been added, need to get the latest module refernce
+                  let jsModule = 
+                     modules
+                     |> Map.find moduleName 
+                     |> JSModules.addMember fullyConstructed
+
+                  updateModule jsModule
+                  fullyConstructed
+
+      let depLength = dependencyCapture |> Seq.length
+      if depLength > 1 then //we are depended on
+         let dependentIndex = depLength - 2
+         let current = dependencyCapture |> Seq.nth(dependentIndex)
+         let dependent = 
+            Seq.append current [moduleMember]
+         dependencyCapture <- 
+            dependencyCapture 
+            |> Seq.mapi(fun i d -> 
+               match i with
+               | _ when i = dependentIndex -> dependent
+               | _ -> d)
+
+      dependencyCapture <- dependencyCapture |> Seq.take(depLength - 1)
+      moduleMember.Var
 
    let mutable initialization = List.empty
 
@@ -190,8 +227,24 @@ type Compiler(components, outputModules) as this =
          |> List.map snd
          |> List.collect(fun m -> m.Members |> Map.toList |> List.map snd)
 
+      
+      let comparer =
+        HashIdentity.FromFunctions<JSModules.JSModuleMember>
+            (fun m -> hash m.FullName)
+            (fun a b -> a.FullName = b.FullName)
+
+      let pred (m: JSModules.JSModuleMember) =
+         m.Dependencies
+         |> Seq.choose (fun a ->
+            match globalMethods |> Seq.tryFind(fun b -> b.FullName = a.FullName) with
+            | None -> None
+            | Some m -> Some m)
+
+      let orderedGlobals = FunScript.Sorting.TopSort(globalMethods, pred, comparer)
+
       let globals = 
-         globalMethods
+         orderedGlobals
+         |> Seq.toList
          |> List.map(fun x -> x.Var, x.Statements)
 
       let declarations = 
@@ -248,8 +301,10 @@ type Compiler(components, outputModules) as this =
          Var(sprintf "_%i" !nextId, typeof<obj>, false) 
          
       member __.DefineGlobal moduleType name cons =
-         let moduleName = JavaScriptNameMapper.mapType moduleType
-         define moduleName name cons
+         let moduleName = (JavaScriptNameMapper.mapType moduleType)
+         let result = define moduleName name cons
+         let moduleNames = modules |> Map.toList |> List.map(fun key -> fst key)
+         result
       
       member __.DefineGlobalExplicit moduleName name cons =
          define moduleName name cons
diff --git a/src/main/FunScript/TopSort.fs b/src/main/FunScript/TopSort.fs
new file mode 100644
index 0000000..ccd942f
--- /dev/null
+++ b/src/main/FunScript/TopSort.fs
@@ -0,0 +1,18 @@
+module FunScript.Sorting
+
+open System.Collections.Generic
+
+let TopSort(roots : seq<'T>, pred : 'T -> seq<'T>, nodeIdentity : IEqualityComparer<'T>) = 
+    seq { 
+        let visited = HashSet(nodeIdentity)
+        
+        let rec visit node = 
+            seq { 
+                if visited.Add(node) then 
+                    for pN in pred node do
+                        yield! visit pN
+                    yield node
+            }
+        for node in roots do
+            yield! visit node
+    }
\ No newline at end of file
diff --git a/src/tests/FunScript.Tests/DependencyTests.fs b/src/tests/FunScript.Tests/DependencyTests.fs
new file mode 100644
index 0000000..7b8c544
--- /dev/null
+++ b/src/tests/FunScript.Tests/DependencyTests.fs
@@ -0,0 +1,21 @@
+[<NUnit.Framework.TestFixture>] 
+module FunScript.Tests.DependencyTest
+
+open System
+open NUnit.Framework
+
+[<ReflectedDefinition>]
+module b = 
+    let foo() = "bar"
+
+[<ReflectedDefinition>]
+module a = 
+    let internal x = b.foo()
+    let foo() = x
+
+[<Test>]
+let ``the variables are injected in the correct order``() =
+    check
+        <@@
+        a.foo()
+        @@>
diff --git a/src/tests/FunScript.Tests/FunScript.Tests.fsproj b/src/tests/FunScript.Tests/FunScript.Tests.fsproj
index cd43df5..8b4723c 100644
--- a/src/tests/FunScript.Tests/FunScript.Tests.fsproj
+++ b/src/tests/FunScript.Tests/FunScript.Tests.fsproj
@@ -85,6 +85,7 @@
     <Compile Include="GuidTests.fs" />
     <Compile Include="AssemblyCompileTests.fs" />
     <Compile Include="ModuleTests.fs" />
+    <Compile Include="DependencyTests.fs" />
     <None Include="app.config" />
     <None Include="packages.config" />
     <None Include="edge\x86\node.dll">