From 8432a6cbfb7d581128662329bd01cf4c8f6b6a3c Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Sun, 17 Jan 2016 11:40:00 +0100
Subject: [PATCH 01/13] add bootstrap step to FAKE in order to check the newly
 produced FAKE.exe

---
 build.fsx | 51 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 50 insertions(+), 1 deletion(-)

diff --git a/build.fsx b/build.fsx
index bf35c08ce0b..9c15b27ce0f 100644
--- a/build.fsx
+++ b/build.fsx
@@ -149,6 +149,43 @@ Target "Test" (fun _ ->
     |>  xUnit id
 )
 
+Target "Bootstrap" (fun _ ->
+    let buildScript = "build.fsx"
+    let testScript = "testbuild.fsx"
+    // Check if we can build ourself with the new binaries.
+    let test clearCache script =
+        let clear () =
+            // Will make sure the test call actually compiles the script.
+            // Note: We cannot just clean .fake here as it might be locked by the currently executing code :)
+            if Directory.Exists ".fake" then
+                Directory.EnumerateFiles(".fake")
+                  |> Seq.filter (fun s -> (Path.GetFileName s).StartsWith script)
+                  |> Seq.iter File.Delete
+        let executeTarget target =
+            if clearCache then clear ()
+            ExecProcess (fun info ->
+                info.FileName <- "build/FAKE.exe"
+                info.WorkingDirectory <- "."
+                info.Arguments <- sprintf "%s %s -pd" script target) (System.TimeSpan.FromMinutes 3.0)
+
+        let result = executeTarget "PrintColors"
+        if result <> 0 then failwith "Bootstrapping failed"
+
+        let result = executeTarget "FailFast"
+        if result = 0 then failwith "Bootstrapping failed"
+
+    File.ReadAllText buildScript
+    |> fun s -> s.Replace("#I @\"packages/build/FAKE/tools/\"", "#I @\"build/\"")
+    |> fun text -> File.WriteAllText(testScript, text)
+
+    try
+      // Will compile the script.
+      test true testScript
+      // Will use the compiled/cached version.
+      test false testScript
+    finally File.Delete(testScript)
+)
+
 Target "SourceLink" (fun _ ->
     !! "src/app/**/*.fsproj" 
     |> Seq.iter (fun f ->
@@ -287,7 +324,18 @@ Target "Release" (fun _ ->
     Branches.tag "" release.NugetVersion
     Branches.pushTag "" "origin" release.NugetVersion
 )
-
+open System
+Target "PrintColors" (fun s ->
+  let color (color: ConsoleColor) (code : unit -> _) =
+      let before = Console.ForegroundColor
+      try
+        Console.ForegroundColor <- color
+        code ()
+      finally
+        Console.ForegroundColor <- before
+  color ConsoleColor.Magenta (fun _ -> printfn "TestMagenta")
+)
+Target "FailFast" (fun _ -> failwith "fail fast")
 Target "Default" DoNothing
 
 // Dependencies
@@ -296,6 +344,7 @@ Target "Default" DoNothing
     ==> "BuildSolution"
     //==> "ILRepack"
     ==> "Test"
+    ==> "Bootstrap"
     ==> "Default"
     ==> "CopyLicense"
     =?> ("GenerateDocs", isLocalBuild && not isLinux)

From 1497dd7e62c55ce84c0db12a0d71abcbf47d9ea0 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Sun, 17 Jan 2016 11:42:29 +0100
Subject: [PATCH 02/13] add yaaf.fsharp.scripting to fakelib (infrastructure
 only).

---
 .gitignore                       | 1 +
 paket.dependencies               | 2 ++
 paket.lock                       | 5 ++++-
 src/app/FakeLib/FakeLib.fsproj   | 8 ++++++--
 src/app/FakeLib/paket.references | 1 +
 5 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 5faae9b128d..e8b537fc9ca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -59,6 +59,7 @@ release.cmd
 Samples/typescript/out/
 help/RELEASE_NOTES.md
 paket.exe
+paket-files/
 
 # Ignore the Vagrant local directories
 .vagrant/*
diff --git a/paket.dependencies b/paket.dependencies
index c4220e83584..497d4b52e1d 100644
--- a/paket.dependencies
+++ b/paket.dependencies
@@ -38,6 +38,8 @@ nuget FluentMigrator.Runner
 nuget HashLib
 nuget FSharp.Compiler.Service
 
+github matthid/Yaaf.FSharp.Scripting src/source/Yaaf.FSharp.Scripting/YaafFSharpScripting.fs
+
 group Build
 content: none
 source http://nuget.org/api/v2
diff --git a/paket.lock b/paket.lock
index 430dbf72bcb..92013a0b832 100644
--- a/paket.lock
+++ b/paket.lock
@@ -81,7 +81,10 @@ NUGET
     xunit.extensions (1.9.2)
       xunit (1.9.2)
     xunit.runners (1.9.2)
-
+GITHUB
+  remote: matthid/Yaaf.FSharp.Scripting
+  specs:
+    src/source/Yaaf.FSharp.Scripting/YaafFSharpScripting.fs (8295ec5cacc78c7b1eb369d7cd72fcd81f9c8ff7)
 GROUP Build
 CONTENT: NONE
 NUGET
diff --git a/src/app/FakeLib/FakeLib.fsproj b/src/app/FakeLib/FakeLib.fsproj
index 19e5c8f7c02..2d2f93b9197 100644
--- a/src/app/FakeLib/FakeLib.fsproj
+++ b/src/app/FakeLib/FakeLib.fsproj
@@ -16,7 +16,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug</OutputPath>
-    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;NET40</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>3</WarningLevel>
     <DocumentationFile>
@@ -30,12 +30,16 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>..\..\..\build\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants>TRACE;NET40</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>3</WarningLevel>
     <DocumentationFile>..\..\..\build\FakeLib.XML</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="..\..\..\paket-files\matthid\Yaaf.FSharp.Scripting\src\source\Yaaf.FSharp.Scripting\YaafFSharpScripting.fs">
+      <Paket>True</Paket>
+      <Link>paket-files/YaafFSharpScripting.fs</Link>
+    </Compile>
     <Compile Include="AssemblyInfo.fs" />
     <Compile Include="UserInputHelper.fs" />
     <Compile Include="CSharpHelper.fs" />
diff --git a/src/app/FakeLib/paket.references b/src/app/FakeLib/paket.references
index 5bb6c8e93a7..d34763987b0 100644
--- a/src/app/FakeLib/paket.references
+++ b/src/app/FakeLib/paket.references
@@ -1,3 +1,4 @@
+File: YaafFSharpScripting.fs
 FSharp.Core
 FSharp.Compiler.Service
 Mono.Web.Xdt

From e419f24c414bae52e38657e5cf75c8ed4ccb4f22 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Sun, 17 Jan 2016 11:44:50 +0100
Subject: [PATCH 03/13] add traceUnknown to log a message without modifying the
 console color.

---
 src/app/FakeLib/TraceHelper.fs     |  3 +++
 src/app/FakeLib/TraceListener.fs   | 23 +++++++++++++++--------
 src/app/FakeLib/UserInputHelper.fs |  9 +++++----
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/src/app/FakeLib/TraceHelper.fs b/src/app/FakeLib/TraceHelper.fs
index 03cca56d547..be252d7c689 100644
--- a/src/app/FakeLib/TraceHelper.fs
+++ b/src/app/FakeLib/TraceHelper.fs
@@ -32,6 +32,9 @@ let logVerbosefn fmt =
 /// Writes a trace to the command line (in green)
 let trace message = postMessage (TraceMessage(message, true))
 
+/// Writes a trace to the command line (in the current console color)
+let traceUnknown message = postMessage (UnknownMessage(message, false))
+
 /// Writes a message to the command line (in green)
 let tracefn fmt = Printf.ksprintf trace fmt
 
diff --git a/src/app/FakeLib/TraceListener.fs b/src/app/FakeLib/TraceListener.fs
index a0385c3492c..edeab26143c 100644
--- a/src/app/FakeLib/TraceListener.fs
+++ b/src/app/FakeLib/TraceListener.fs
@@ -11,6 +11,7 @@ type TraceData =
     | ErrorMessage of string
     | LogMessage of string * bool
     | TraceMessage of string * bool
+    | UnknownMessage of string * bool
     | FinishedMessage
     | OpenTag of string * string
     | CloseTag of string
@@ -26,6 +27,7 @@ let colorMap traceData =
     | ErrorMessage _ -> ConsoleColor.Red
     | LogMessage _ -> ConsoleColor.Gray
     | TraceMessage _ -> ConsoleColor.Green
+    | UnknownMessage _ -> Console.ForegroundColor
     | FinishedMessage -> ConsoleColor.White
     | _ -> ConsoleColor.Gray
 
@@ -37,13 +39,17 @@ type ConsoleTraceListener(importantMessagesToStdErr, colorMap) =
     
     let writeText toStdErr color newLine text = 
         let curColor = Console.ForegroundColor
-        if curColor <> color then Console.ForegroundColor <- color
-        if toStdErr then 
-            if newLine then eprintfn "%s" text
-            else eprintf "%s" text
-        else if newLine then printfn "%s" text
-        else printf "%s" text
-        if curColor <> color then Console.ForegroundColor <- curColor
+        try
+          if curColor <> color then Console.ForegroundColor <- color
+          let printer =
+            match toStdErr, newLine with
+            | true, true -> eprintfn
+            | true, false -> eprintf
+            | false, true -> printfn
+            | false, false -> printf
+          printer "%s" text
+        finally
+          if curColor <> color then Console.ForegroundColor <- curColor
     
     interface ITraceListener with
         /// Writes the given message to the Console.
@@ -54,7 +60,8 @@ type ConsoleTraceListener(importantMessagesToStdErr, colorMap) =
             | OpenTag _ -> ()
             | CloseTag _ -> ()
             | ImportantMessage text | ErrorMessage text -> writeText importantMessagesToStdErr color true text
-            | LogMessage(text, newLine) | TraceMessage(text, newLine) -> writeText false color newLine text
+            | UnknownMessage(text, newLine) | LogMessage(text, newLine) | TraceMessage(text, newLine) ->
+                writeText false color newLine text
             | FinishedMessage -> ()
 
 /// The default TraceListener for Console.
diff --git a/src/app/FakeLib/UserInputHelper.fs b/src/app/FakeLib/UserInputHelper.fs
index 235c4388dc5..64034699e0f 100644
--- a/src/app/FakeLib/UserInputHelper.fs
+++ b/src/app/FakeLib/UserInputHelper.fs
@@ -38,10 +38,11 @@ let internal readString (echo: bool) : string =
 
 let internal color (color: ConsoleColor) (code : unit -> _) =
     let before = Console.ForegroundColor
-    Console.ForegroundColor <- color
-    let result = code ()
-    Console.ForegroundColor <- before
-    result
+    try
+      Console.ForegroundColor <- color
+      code ()
+    finally
+      Console.ForegroundColor <- before
     
 /// Return a string entered by the user followed by enter. The input is echoed to the screen.
 let getUserInput prompt =

From 986d66cbccae7d98e820ad2fac987ffd32601c35 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Sun, 17 Jan 2016 11:48:34 +0100
Subject: [PATCH 04/13] use Yaaf.FSharp.Scripting to display code-warnings in
 the build script (at the end).

---
 src/app/FakeLib/FSIHelper.fs | 299 ++++++++++++++++++++---------------
 1 file changed, 168 insertions(+), 131 deletions(-)

diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index 9886f532f3a..2f7f7ae00ad 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -9,6 +9,7 @@ open System.Diagnostics
 open System.Threading
 open System.Text.RegularExpressions
 open System.Xml.Linq
+open Yaaf.FSharp.Scripting
 
 let private FSIPath = @".\tools\FSharp\;.\lib\FSharp\;[ProgramFilesX86]\Microsoft SDKs\F#\4.0\Framework\v4.0;[ProgramFilesX86]\Microsoft SDKs\F#\3.1\Framework\v4.0;[ProgramFilesX86]\Microsoft SDKs\F#\3.0\Framework\v4.0;[ProgramFiles]\Microsoft F#\v4.0\;[ProgramFilesX86]\Microsoft F#\v4.0\;[ProgramFiles]\FSharp-2.0.0.0\bin\;[ProgramFilesX86]\FSharp-2.0.0.0\bin\;[ProgramFiles]\FSharp-1.9.9.9\bin\;[ProgramFilesX86]\FSharp-1.9.9.9\bin\"
 
@@ -203,59 +204,33 @@ type private AssemblySource =
 | Disk
 
 let hashRegex = Text.RegularExpressions.Regex("(?<script>.+)_(?<hash>[a-zA-Z0-9]+\.dll$)", System.Text.RegularExpressions.RegexOptions.Compiled)
-/// Run the given FAKE script with fsi.exe at the given working directory. Provides full access to Fsi options and args. Redirect output and error messages.
-let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(fsiOptions, scriptPath, scriptArgs)) env onErrMsg onOutMsg useCache cleanCache =
-
-    if printDetails then traceFAKE "Running Buildscript: %s" scriptPath
-
-    // Add arguments to the Environment
-    for (k,v) in env do
-      Environment.SetEnvironmentVariable(k, v, EnvironmentVariableTarget.Process)
-
-    // Create an env var that only contains the build script args part from the --fsiargs (or "").
-    Environment.SetEnvironmentVariable("fsiargs-buildscriptargs", String.Join(" ", scriptArgs))
-
-    let fsiConfig = FsiEvaluationSession.GetDefaultConfiguration()
-
-    let options =
-        [ "fsi.exe"; "--noninteractive" ] @ fsiOptions
-        |> List.toArray
-
-    let sbOut = Text.StringBuilder()
-    let sbErr = Text.StringBuilder()
-    let handleMessages() =
-        let handleMessagesFrom (sb:Text.StringBuilder) onMsg =
-            let s = sb.ToString()
-            if not <| String.IsNullOrEmpty s
-                then onMsg s
-        handleMessagesFrom sbOut onOutMsg
-        handleMessagesFrom sbErr onErrMsg
-    let handleException (ex : Exception) = 
-        onErrMsg (ex.ToString())
 
-    use outStream = new StringWriter(sbOut)
-    use errStream = new StringWriter(sbErr)
-    use stdin = new StreamReader(Stream.Null)
-
-    let scriptPath =
-        if Path.IsPathRooted scriptPath then
-            scriptPath
-        else
-            Path.Combine(Directory.GetCurrentDirectory(), scriptPath)
-        
+type private CacheInfo =
+  {
+    ScriptFileName : string
+    AssemblyPath : string
+    AssemblyWarningsPath : string
+    CacheConfigPath : string
+    CacheConfig : Lazy<Cache.CacheConfig>
+    IsValid : bool
+  }
+
+let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
     let allScriptContents = getAllScripts scriptPath
     let scriptHash = lazy (getScriptHash allScriptContents fsiOptions)
     //TODO this is only calculating the hash for the input file, not anything #load-ed
     
-    let scriptFileName = lazy(Path.GetFileName(scriptPath))
-    let hashPath = lazy("./.fake/" + scriptFileName.Value + "_" + scriptHash.Value)
-    let assemblyPath = lazy(hashPath.Value + ".dll")
-    let cacheConfigPath = lazy(hashPath.Value + "_config.xml")
-    let cacheConfig = lazy(Cache.read cacheConfigPath.Value)
-    let cacheValid = lazy (
+    let scriptFileName = Path.GetFileName(scriptPath)
+    let hashPath = "./.fake/" + scriptFileName + "_" + scriptHash.Value
+    let assemblyPath = hashPath + ".dll"
+    let assemblyWarningsPath = hashPath + "_warnings.txt"
+    let cacheConfigPath = hashPath + "_config.xml"
+    let cacheConfig = lazy Cache.read cacheConfigPath
+    let cacheValid =
         let cacheFilesExist = 
-            System.IO.File.Exists(assemblyPath.Value) &&
-            System.IO.File.Exists(cacheConfigPath.Value) 
+            File.Exists(assemblyPath) &&
+            File.Exists(cacheConfigPath) &&
+            File.Exists(assemblyWarningsPath)
         if cacheFilesExist then
             let loadedAssemblies =
                 cacheConfig.Value.Assemblies
@@ -302,37 +277,86 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
             assemVersionValidCount = Seq.length cacheConfig.Value.Assemblies
         else
             false
-    )
+    { ScriptFileName = scriptFileName
+      AssemblyPath = assemblyPath
+      AssemblyWarningsPath = assemblyWarningsPath
+      CacheConfigPath = cacheConfigPath
+      CacheConfig = cacheConfig
+      IsValid = cacheValid }
+
+/// Run the given FAKE script with fsi.exe at the given working directory. Provides full access to Fsi options and args. Redirect output and error messages.
+let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(fsiOptions, scriptPath, scriptArgs)) env onErrMsg onOutMsg useCache cleanCache =
+
+    if printDetails then traceFAKE "Running Buildscript: %s" scriptPath
+
+    // Add arguments to the Environment
+    for (k,v) in env do
+      Environment.SetEnvironmentVariable(k, v, EnvironmentVariableTarget.Process)
+
+    // Create an env var that only contains the build script args part from the --fsiargs (or "").
+    Environment.SetEnvironmentVariable("fsiargs-buildscriptargs", String.Join(" ", scriptArgs))
+
+    let options =
+        (FsiOptions.Default.AsArgs |> Array.toList) @ fsiOptions
+        |> FsiOptions.ofArgs
+
+    let handleException (ex : Exception) =
+        onErrMsg (ex.ToString())
+
+    let scriptPath =
+        if Path.IsPathRooted scriptPath then
+            scriptPath
+        else
+            Path.Combine(Directory.GetCurrentDirectory(), scriptPath)
 
+    let cacheInfo = getCacheInfoFromScript printDetails fsiOptions scriptPath
     let getScriptAndHash fileName =
         let matched = hashRegex.Match(fileName)
         matched.Groups.Item("script").Value, matched.Groups.Item("hash").Value
 
-    if useCache && cacheValid.Value then
+    if useCache && cacheInfo.IsValid then
         
         if printDetails then trace "Using cache"
-        let noExtension = Path.GetFileNameWithoutExtension(scriptFileName.Value)
-        let fullName = 
-            sprintf "<StartupCode$FSI_0001>.$FSI_0001_%s%s$%s" 
-                (noExtension.Substring(0, 1).ToUpper())
-                (noExtension.Substring(1))
-                (Path.GetExtension(scriptFileName.Value).Substring(1))
-
-        let assembly = Reflection.Assembly.LoadFrom(assemblyPath.Value)
-
-        let mainModule = assembly.GetType(fullName)
-        
+        let noExtension = Path.GetFileNameWithoutExtension(cacheInfo.ScriptFileName)
+
+        let startString = "<StartupCode$FSI_"
+        let endString =
+          sprintf "_%s%s$%s"
+            (noExtension.Substring(0, 1).ToUpper())
+            (noExtension.Substring(1))
+            (Path.GetExtension(cacheInfo.ScriptFileName).Substring(1))
+        let fullName i = sprintf "%s%s>.$FSI_%s%s" startString i i endString
+        let exampleName = fullName "0001"
+        let parseName (n:string) =
+            if n.Length >= exampleName.Length &&
+               n.Substring(0, startString.Length) = startString &&
+               n.Substring(n.Length - endString.Length) = endString then
+                let num = n.Substring(startString.Length, 4)
+                assert (fullName num = n)
+                Some (num)
+            else None
         try
-            let _result = 
-                mainModule.InvokeMember(
-                    "main@",
-                    BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.Static, 
-                    null, null, [||])
-            true
-        with
-        | ex ->
-            handleException ex
-            false
+            match Reflection.Assembly.LoadFrom(cacheInfo.AssemblyPath)
+                  .GetTypes()
+                  |> Seq.filter (fun t -> parseName t.FullName |> Option.isSome)
+                  |> Seq.tryHead with
+            | Some mainModule ->
+              try
+                  mainModule.InvokeMember(
+                      "main@",
+                      BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.Static,
+                      null, null, [||])
+                  |> ignore
+                  true
+              with
+              | ex ->
+                  handleException ex
+                  false
+            | None -> failwithf "We could not find a type similar to '%s' in the cached assembly!" exampleName
+        finally
+            try
+                traceFAKE "%s" (File.ReadAllText cacheInfo.AssemblyWarningsPath)
+            with e -> traceError (e.ToString())
     else
         let cacheDir = DirectoryInfo(Path.Combine(".",".fake"))
         if useCache then
@@ -341,7 +365,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                     cacheDir.GetFiles()
                     |> Seq.filter(fun file -> 
                         let oldScriptName, _ = getScriptAndHash(file.Name)
-                        oldScriptName = scriptFileName.Value)
+                        oldScriptName = cacheInfo.ScriptFileName)
 
                 if (oldFiles |> Seq.length) > 0 then
                     if cleanCache then
@@ -352,79 +376,92 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                     if printDetails then trace "Cache doesn't exist"
             else
                 if printDetails then trace "Cache doesn't exist"
+
+        // Contains warnings and errors about the build script.
+        let fsiErrorOutput = new System.Text.StringBuilder()
+        let session =
+          try ScriptHost.Create
+                (options, preventStdOut = true,
+                  fsiErrWriter = ScriptHost.CreateForwardWriter
+                    ((fun s ->
+                        if String.IsNullOrWhiteSpace s |> not then
+                            fsiErrorOutput.AppendLine s |> ignore),
+                      removeNewLines = true),
+                  outWriter = ScriptHost.CreateForwardWriter onOutMsg,
+                  errWriter = ScriptHost.CreateForwardWriter onErrMsg)
+          with :? FsiEvaluationException as e ->
+              traceError "FsiEvaluationSession could not be created."
+              traceError e.Result.Error.Merged
+              reraise ()
+
         try
-            let session = FsiEvaluationSession.Create(fsiConfig, options, stdin, outStream, errStream)
             try
                 session.EvalScript scriptPath
+                true
+            with :? FsiEvaluationException as eval ->
+                // Write Script Warnings & Errors at the end
+                handleException eval
+                false
+        finally
+            // Write Script Warnings & Errors at the end
+            traceFAKE "%O" fsiErrorOutput
+            // Cache in the error case as well.
+            try
+                if useCache && not cacheInfo.IsValid then
+                    session.DynamicAssemblyBuilder.Save("FSI-ASSEMBLY.dll")
+                    if not <| Directory.Exists cacheDir.FullName then
+                        let di = Directory.CreateDirectory cacheDir.FullName
+                        di.Attributes <- FileAttributes.Directory ||| FileAttributes.Hidden
 
-                try
-                    if useCache && not cacheValid.Value then
-                        let assemBuilder = session.DynamicAssembly :?> System.Reflection.Emit.AssemblyBuilder
-                        assemBuilder.Save("FSI-ASSEMBLY.dll")
-                        if not <| Directory.Exists cacheDir.FullName then
-                            let di = Directory.CreateDirectory cacheDir.FullName 
-                            di.Attributes <- FileAttributes.Directory ||| FileAttributes.Hidden
-
-                        let destinationFile = FileInfo(assemblyPath.Value)
-                        let targetDirectory = destinationFile.Directory
+                    let destinationFile = FileInfo(cacheInfo.AssemblyPath)
+                    let targetDirectory = destinationFile.Directory
 
-                        if (not <| targetDirectory.Exists) then targetDirectory.Create()
-                        if (destinationFile.Exists) then destinationFile.Delete()
+                    if (not <| targetDirectory.Exists) then targetDirectory.Create()
+                    if (destinationFile.Exists) then destinationFile.Delete()
 
-                        File.Move("FSI-ASSEMBLY.dll", assemblyPath.Value)
+                    File.WriteAllText(cacheInfo.AssemblyWarningsPath, fsiErrorOutput.ToString())
+                    File.Move("FSI-ASSEMBLY.dll", cacheInfo.AssemblyPath)
                     
-                        if File.Exists("FSI-ASSEMBLY.pdb") then
-                            File.Delete("FSI-ASSEMBLY.pdb")
-                        if File.Exists("FSI-ASSEMBLY.dll.mdb") then
-                            File.Delete("FSI-ASSEMBLY.dll.mdb")
-
-                        let dynamicAssemblies = 
+                    if File.Exists("FSI-ASSEMBLY.pdb") then
+                        File.Delete("FSI-ASSEMBLY.pdb")
+                    if File.Exists("FSI-ASSEMBLY.dll.mdb") then
+                        File.Delete("FSI-ASSEMBLY.dll.mdb")
+
+                    let dynamicAssemblies =
+                        System.AppDomain.CurrentDomain.GetAssemblies()
+                        |> Seq.filter(fun assem -> assem.IsDynamic)
+                        |> Seq.map(fun assem -> assem.GetName().Name)
+                        |> Seq.filter(fun assem -> assem <> "FSI-ASSEMBLY")
+                        // General Reflection.Emit helper (most likely harmless to ignore)
+                        |> Seq.filter(fun assem -> assem <> "Anonymously Hosted DynamicMethods Assembly")
+                        // RazorEngine generated
+                        |> Seq.filter(fun assem -> assem <> "RazorEngine.Compilation.ImpromptuInterfaceDynamicAssembly")
+                        |> Seq.cache
+                    if dynamicAssemblies |> Seq.length > 0 then
+                        let msg =
+                            sprintf "Dynamic assemblies were generated during evaluation of script (%s).\nCan not save cache."
+                                (System.String.Join(", ", dynamicAssemblies))
+                        trace msg
+
+                    else
+                        let assemblies =
                             System.AppDomain.CurrentDomain.GetAssemblies()
-                            |> Seq.filter(fun assem -> assem.IsDynamic)
-                            |> Seq.map(fun assem -> assem.GetName().Name)
-                            |> Seq.filter(fun assem -> assem <> "FSI-ASSEMBLY")
-                            // General Reflection.Emit helper (most likely harmless to ignore)
-                            |> Seq.filter(fun assem -> assem <> "Anonymously Hosted DynamicMethods Assembly")
-                            // RazorEngine generated
-                            |> Seq.filter(fun assem -> assem <> "RazorEngine.Compilation.ImpromptuInterfaceDynamicAssembly")
-                            |> Seq.cache
-                        if dynamicAssemblies |> Seq.length > 0 then
-                            let msg =
-                                sprintf "Dynamic assemblies were generated during evaluation of script (%s).\nCan not save cache." 
-                                    (System.String.Join(", ", dynamicAssemblies))
-                            trace msg
-
-                        else
-                            let assemblies = 
-                                System.AppDomain.CurrentDomain.GetAssemblies()
-                                |> Seq.filter(fun assem -> not assem.IsDynamic)
-                                // They are not dynamic, but can't be re-used either.
-                                |> Seq.filter(fun assem -> not <| assem.GetName().Name.StartsWith("CompiledRazorTemplates.Dynamic.RazorEngine_"))
+                            |> Seq.filter(fun assem -> not assem.IsDynamic)
+                            // They are not dynamic, but can't be re-used either.
+                            |> Seq.filter(fun assem -> not <| assem.GetName().Name.StartsWith("CompiledRazorTemplates.Dynamic.RazorEngine_"))
                         
-                            let cacheConfig : XDocument = Cache.create assemblies
-                            cacheConfig.Save(cacheConfigPath.Value) 
-                            if printDetails then trace (System.Environment.NewLine + "Saved cache")
-                with 
-                | ex ->
-                    handleException ex
-                    reraise()
-                // TODO: Reactivate when FCS don't show output any more 
-                // handleMessages()
-                true
-            with
-            | _ex ->
-                handleMessages()
-                false
-        with
-        | exn ->
-            traceError "FsiEvaluationSession could not be created."
-            traceError <| sbErr.ToString()
-            raise exn
+                        let cacheConfig : XDocument = Cache.create assemblies
+                        cacheConfig.Save(cacheInfo.CacheConfigPath)
+                        if printDetails then trace (System.Environment.NewLine + "Saved cache")
+            with ex ->
+                handleException ex
+                reraise()
 
 /// Run the given buildscript with fsi.exe and allows for extra arguments to the script. Returns output.
 let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) useCache cleanCache =
     let messages = ref []
     let appendMessage isError msg =
+        traceUnknown msg // Some test code expects that the executed script writes to stdout
         messages := { IsError = isError
                       Message = msg
                       Timestamp = DateTimeOffset.UtcNow } :: !messages
@@ -438,7 +475,7 @@ let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) us
 let runBuildScriptWithFsiArgsAt printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env useCache cleanCache =
     runFAKEScriptWithFsiArgsAndRedirectMessages
         printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env
-        traceError (fun s-> traceFAKE "%s" s)
+        traceError traceUnknown
         useCache
         cleanCache
 

From 07966457b8bb5ffa0a0a484e946027bd3ca45654 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Sun, 17 Jan 2016 11:58:23 +0100
Subject: [PATCH 05/13] Call Debugger.Launch.

---
 src/app/FAKE/Program.fs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/app/FAKE/Program.fs b/src/app/FAKE/Program.fs
index e93d1262128..e8935caae3b 100644
--- a/src/app/FAKE/Program.fs
+++ b/src/app/FAKE/Program.fs
@@ -55,7 +55,9 @@ try
         | Choice1Of2(fakeArgs) ->
             
             //Break to allow a debugger to be attached here
-            if fakeArgs.Contains <@ Cli.Break @> then Diagnostics.Debugger.Break()
+            if fakeArgs.Contains <@ Cli.Break @> then
+                Diagnostics.Debugger.Launch() |> ignore
+                Diagnostics.Debugger.Break() |> ignore
 
             //Boot and version force us to ignore other args, so check for them and handle.
             let isBoot, bootArgs = fakeArgs.Contains <@ Cli.Boot @>, fakeArgs.GetResults <@ Cli.Boot @>

From 77c47708afc9813a42abc2305ef04404fb1677a4 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Sun, 17 Jan 2016 11:58:41 +0100
Subject: [PATCH 06/13] don't call Environment.Exit too ealy.

---
 src/app/FAKE/Program.fs         | 2 ++
 src/app/FakeLib/TargetHelper.fs | 5 +++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/app/FAKE/Program.fs b/src/app/FAKE/Program.fs
index e8935caae3b..1c5550d16f3 100644
--- a/src/app/FAKE/Program.fs
+++ b/src/app/FAKE/Program.fs
@@ -164,3 +164,5 @@ try
 
 finally
     traceEndBuild()
+    if !TargetHelper.ExitCode.exitCode <> 0 then exit !TargetHelper.ExitCode.exitCode
+    if Environment.ExitCode <> 0 then exit Environment.ExitCode
\ No newline at end of file
diff --git a/src/app/FakeLib/TargetHelper.fs b/src/app/FakeLib/TargetHelper.fs
index 8bcf63396b6..8c4fb7d2e8f 100644
--- a/src/app/FakeLib/TargetHelper.fs
+++ b/src/app/FakeLib/TargetHelper.fs
@@ -278,7 +278,6 @@ let targetError targetName (exn:System.Exception) =
         | _ -> exn.ToString()
 
     let msg = sprintf "%s%s" (error exn) (if exn.InnerException <> null then "\n" + (exn.InnerException |> error) else "")
-            
     traceError <| sprintf "Running build failed.\nError:\n%s" msg
 
     let isFailedTestsException = exn :? UnitTestCommon.FailedTestsException
@@ -427,7 +426,9 @@ let WriteTaskTimeSummary total =
 
     traceLine()
 
-let private changeExitCodeIfErrorOccured() = if errors <> [] then exit 42 
+module ExitCode =
+    let exitCode = ref 0
+let private changeExitCodeIfErrorOccured() = if errors <> [] then Environment.ExitCode <- 42; ExitCode.exitCode := 42
    
 /// [omit]
 let isListMode = hasBuildParam "list"

From 68db0fb580049c39589561a454f67ea5be2ac99c Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 18 Jan 2016 18:50:11 +0100
Subject: [PATCH 07/13] add tests for using framework assemblies without #r
 references in the build script.

---
 src/app/FakeLib/FSIHelper.fs             |  8 +-
 src/test/Test.FAKECore/FSIHelperSpecs.cs | 93 +++++++++++++++++++++---
 2 files changed, 88 insertions(+), 13 deletions(-)

diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index 2f7f7ae00ad..27d13876497 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -458,7 +458,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                 reraise()
 
 /// Run the given buildscript with fsi.exe and allows for extra arguments to the script. Returns output.
-let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) useCache cleanCache =
+let executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script (scriptArgs: string[]) (fsiArgs:string[]) useCache cleanCache =
     let messages = ref []
     let appendMessage isError msg =
         traceUnknown msg // Some test code expects that the executed script writes to stdout
@@ -467,10 +467,14 @@ let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) us
                       Timestamp = DateTimeOffset.UtcNow } :: !messages
     let result =
         runFAKEScriptWithFsiArgsAndRedirectMessages
-            true (FsiArgs([], script, scriptArgs |> List.ofArray)) []
+            true (FsiArgs(fsiArgs |> List.ofArray, script, scriptArgs |> List.ofArray)) []
             (appendMessage true) (appendMessage false) useCache cleanCache
     (result, !messages)
 
+/// Run the given buildscript with fsi.exe and allows for extra arguments to the script. Returns output.
+let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) useCache cleanCache =
+    executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script scriptArgs [||] useCache cleanCache
+
 /// Run the given buildscript with fsi.exe at the given working directory.  Provides full access to Fsi options and args.
 let runBuildScriptWithFsiArgsAt printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env useCache cleanCache =
     runFAKEScriptWithFsiArgsAndRedirectMessages
diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index 581e3743d54..e898638b687 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -10,8 +10,8 @@ namespace Test.FAKECore
 {
     public class when_running_script
     {
-
-        static string RunExplicit(string scriptFilePath, string arguments, bool useCache)
+        static string[] EmptyArgs = new string[0];
+        static string RunExplicit(string scriptFilePath, string[] scriptArguments, string[] fsiArguments, bool useCache)
         {
             var stdOut = Console.Out;
 
@@ -23,7 +23,8 @@ static string RunExplicit(string scriptFilePath, string arguments, bool useCache
             try
             {
                 
-                result = FSIHelper.executeBuildScriptWithArgsAndReturnMessages(scriptFilePath, new string[] { }, useCache, false);
+                result = FSIHelper.executeBuildScriptWithArgsAndFsiArgsAndReturnMessages(
+                    scriptFilePath, scriptArguments, fsiArguments, useCache, false);
             }
             finally
             {
@@ -48,14 +49,19 @@ static string RunExplicit(string scriptFilePath, string arguments, bool useCache
                 .Replace("\n", "").Replace("\r", "");
         }
 
-        static string Run(string script, string arguments, bool useCache)
+        static string RunExplicit(string scriptFilePath, string[] scriptArguments, bool useCache)
+        {
+            return RunExplicit(scriptFilePath, scriptArguments, EmptyArgs, useCache);
+        }
+
+        static string Run(string script, string[] scriptArguments, bool useCache)
         {
             var scriptFilePath = Path.GetTempFileName() + ".fsx";
             string result;
             try
             {
                 File.WriteAllText(scriptFilePath, script);
-                result = RunExplicit(scriptFilePath, arguments, useCache);
+                result = RunExplicit(scriptFilePath, scriptArguments, useCache);
             }
             finally
             {
@@ -72,10 +78,75 @@ static FSIHelper.Script script(string path, string contents)
             return new FSIHelper.Script(contents, path.Replace("\\", "/"), null, null);
         }
 
+        It should_be_able_to_use_system_xml =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "open System.Xml");
+                    RunExplicit(scriptFilePath, EmptyArgs, false)
+                        .ShouldEqual("");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
+        It should_be_able_to_use_system_web =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "open System.Web");
+                    RunExplicit(scriptFilePath, EmptyArgs, false)
+                        .ShouldEqual("");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
+        /// <summary>
+        /// See https://github.com/fsharp/FAKE/pull/1080
+        /// </summary>
+        It should_work_with_debug_flag =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "printfn \"test\"");
+                    RunExplicit(
+                        scriptFilePath,
+                        EmptyArgs,
+                        new[] {
+                            "--debug+",
+                            "--optimize-",
+                            "--platform", "AnyCpu",
+                            "--configuration", "Release",
+                            "--csversion", "2007" },
+                        false)
+                        .ShouldEqual("test");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
         It should_use_then_invalidate_cache =
             () =>
             {
-                var arguments = "";
                 var scriptFilePath = Path.GetTempFileName() + ".fsx";
                 var scriptFileName = Path.GetFileName(scriptFilePath);
                 try
@@ -88,17 +159,17 @@ static FSIHelper.Script script(string path, string contents)
 
                     File.Exists(cacheFilePath).ShouldEqual(false);
 
-                    RunExplicit(scriptFilePath, arguments, false)
+                    RunExplicit(scriptFilePath, EmptyArgs, false)
                        .ShouldEqual("foobar");
 
                     File.Exists(cacheFilePath).ShouldEqual(false);
 
-                    RunExplicit(scriptFilePath, arguments, true)
+                    RunExplicit(scriptFilePath, EmptyArgs, true)
                         .ShouldStartWith("Cache doesn't exist");
 
                     File.Exists(cacheFilePath).ShouldEqual(true);
 
-                    RunExplicit(scriptFilePath, arguments, true)
+                    RunExplicit(scriptFilePath, EmptyArgs, true)
                         .ShouldEqual(
                             ("Using cache" + nl + "foobar")
                             .Replace("\n", "").Replace("\r", ""));
@@ -106,7 +177,7 @@ static FSIHelper.Script script(string path, string contents)
                     File.WriteAllText(scriptFilePath, "printf \"foobarbaz\"");
 
                     var changedScriptHash = FSIHelper.getScriptHash(new FSIHelper.Script[] { script(scriptFilePath, "printf \"foobarbaz\"") }, new List<string>());
-                    RunExplicit(scriptFilePath, arguments, true)
+                    RunExplicit(scriptFilePath, EmptyArgs, true)
                         .ShouldStartWith("Cache is invalid, recompiling");
 
                     File.Exists("./.fake/" + scriptFileName + "_" + changedScriptHash + ".dll").ShouldEqual(true);
@@ -132,7 +203,7 @@ static FSIHelper.Script script(string path, string contents)
                     File.WriteAllText(mainPath, mainScript.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\r", nl));
                     File.WriteAllText(loadedPath, loadedScript.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\r", nl));
 
-                    RunExplicit(mainPath, "", false)
+                    RunExplicit(mainPath, EmptyArgs, false)
                         .ShouldEqual("loaded;main");
                 }
                 finally

From cbc2d913316e2493b94d3557c255252861c4f729 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 18 Jan 2016 18:50:50 +0100
Subject: [PATCH 08/13] don't use --noframwork

---
 src/app/FakeLib/FSIHelper.fs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index 27d13876497..d9eafbe3523 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -297,7 +297,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
     Environment.SetEnvironmentVariable("fsiargs-buildscriptargs", String.Join(" ", scriptArgs))
 
     let options =
-        (FsiOptions.Default.AsArgs |> Array.toList) @ fsiOptions
+        fsiOptions
         |> FsiOptions.ofArgs
 
     let handleException (ex : Exception) =

From ce07db1e55dfd7ccf4cc98812198f4a4a201752c Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 18 Jan 2016 18:59:19 +0100
Subject: [PATCH 09/13] update Scripting to support debug flags.

---
 paket.lock | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paket.lock b/paket.lock
index 92013a0b832..34c0289a47f 100644
--- a/paket.lock
+++ b/paket.lock
@@ -84,7 +84,7 @@ NUGET
 GITHUB
   remote: matthid/Yaaf.FSharp.Scripting
   specs:
-    src/source/Yaaf.FSharp.Scripting/YaafFSharpScripting.fs (8295ec5cacc78c7b1eb369d7cd72fcd81f9c8ff7)
+    src/source/Yaaf.FSharp.Scripting/YaafFSharpScripting.fs (48789eeb63382a6934966472e270e87880cb49ed)
 GROUP Build
 CONTENT: NONE
 NUGET

From 23a06f68f1cc8a5cb79e5c29a84c585d3c660195 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 18 Jan 2016 22:35:57 +0100
Subject: [PATCH 10/13] capture output when running the cached version && use
 mono-cecil to rename the saved assembly in order to be able to execute a
 test-suite with multiple cached build scripts.

---
 src/app/FakeLib/FSIHelper.fs             | 77 +++++++++++++---------
 src/test/Test.FAKECore/FSIHelperSpecs.cs | 84 +++++++++++++++++++-----
 2 files changed, 113 insertions(+), 48 deletions(-)

diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index d9eafbe3523..a58e4f6096d 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -208,6 +208,7 @@ let hashRegex = Text.RegularExpressions.Regex("(?<script>.+)_(?<hash>[a-zA-Z0-9]
 type private CacheInfo =
   {
     ScriptFileName : string
+    ScriptHash : string
     AssemblyPath : string
     AssemblyWarningsPath : string
     CacheConfigPath : string
@@ -217,11 +218,11 @@ type private CacheInfo =
 
 let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
     let allScriptContents = getAllScripts scriptPath
-    let scriptHash = lazy (getScriptHash allScriptContents fsiOptions)
+    let scriptHash = getScriptHash allScriptContents fsiOptions
     //TODO this is only calculating the hash for the input file, not anything #load-ed
     
     let scriptFileName = Path.GetFileName(scriptPath)
-    let hashPath = "./.fake/" + scriptFileName + "_" + scriptHash.Value
+    let hashPath = "./.fake/" + scriptFileName + "_" + scriptHash
     let assemblyPath = hashPath + ".dll"
     let assemblyWarningsPath = hashPath + "_warnings.txt"
     let cacheConfigPath = hashPath + "_config.xml"
@@ -278,6 +279,7 @@ let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
         else
             false
     { ScriptFileName = scriptFileName
+      ScriptHash = scriptHash
       AssemblyPath = assemblyPath
       AssemblyWarningsPath = assemblyWarningsPath
       CacheConfigPath = cacheConfigPath
@@ -314,6 +316,9 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
         let matched = hashRegex.Match(fileName)
         matched.Groups.Item("script").Value, matched.Groups.Item("hash").Value
 
+    let wishName = "FAKE_CACHE_" + Path.GetFileNameWithoutExtension cacheInfo.ScriptFileName + "_" + cacheInfo.ScriptHash
+    use out = ScriptHost.CreateForwardWriter onOutMsg
+    use err = ScriptHost.CreateForwardWriter(onErrMsg, removeNewLines = true)
     if useCache && cacheInfo.IsValid then
         
         if printDetails then trace "Using cache"
@@ -336,23 +341,24 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                 Some (num)
             else None
         try
-            match Reflection.Assembly.LoadFrom(cacheInfo.AssemblyPath)
-                  .GetTypes()
-                  |> Seq.filter (fun t -> parseName t.FullName |> Option.isSome)
-                  |> Seq.tryHead with
-            | Some mainModule ->
-              try
-                  mainModule.InvokeMember(
-                      "main@",
-                      BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.Static,
-                      null, null, [||])
-                  |> ignore
-                  true
-              with
-              | ex ->
-                  handleException ex
-                  false
-            | None -> failwithf "We could not find a type similar to '%s' in the cached assembly!" exampleName
+            Yaaf.FSharp.Scripting.Helper.consoleCapture out err (fun () ->
+                let ass = Reflection.Assembly.LoadFrom(cacheInfo.AssemblyPath)
+                assert (ass.GetName().Name = wishName)
+                match ass.GetTypes()
+                      |> Seq.filter (fun t -> parseName t.FullName |> Option.isSome)
+                      |> Seq.tryHead with
+                | Some mainModule ->
+                  try mainModule.InvokeMember(
+                          "main@",
+                          BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.Static,
+                          null, null, [||])
+                      |> ignore
+                      true
+                  with
+                  | ex ->
+                      handleException ex
+                      false
+                | None -> failwithf "We could not find a type similar to '%s' in the cached assembly!" exampleName)
         finally
             try
                 traceFAKE "%s" (File.ReadAllText cacheInfo.AssemblyWarningsPath)
@@ -387,8 +393,8 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                         if String.IsNullOrWhiteSpace s |> not then
                             fsiErrorOutput.AppendLine s |> ignore),
                       removeNewLines = true),
-                  outWriter = ScriptHost.CreateForwardWriter onOutMsg,
-                  errWriter = ScriptHost.CreateForwardWriter onErrMsg)
+                  outWriter = out,
+                  errWriter = err)
           with :? FsiEvaluationException as e ->
               traceError "FsiEvaluationSession could not be created."
               traceError e.Result.Error.Merged
@@ -408,7 +414,9 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
             // Cache in the error case as well.
             try
                 if useCache && not cacheInfo.IsValid then
-                    session.DynamicAssemblyBuilder.Save("FSI-ASSEMBLY.dll")
+                    let d = session.DynamicAssemblyBuilder
+                    let name = "FSI-ASSEMBLY"
+                    d.Save(name + ".dll")
                     if not <| Directory.Exists cacheDir.FullName then
                         let di = Directory.CreateDirectory cacheDir.FullName
                         di.Attributes <- FileAttributes.Directory ||| FileAttributes.Hidden
@@ -420,18 +428,27 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                     if (destinationFile.Exists) then destinationFile.Delete()
 
                     File.WriteAllText(cacheInfo.AssemblyWarningsPath, fsiErrorOutput.ToString())
-                    File.Move("FSI-ASSEMBLY.dll", cacheInfo.AssemblyPath)
-                    
-                    if File.Exists("FSI-ASSEMBLY.pdb") then
-                        File.Delete("FSI-ASSEMBLY.pdb")
-                    if File.Exists("FSI-ASSEMBLY.dll.mdb") then
-                        File.Delete("FSI-ASSEMBLY.dll.mdb")
+
+                    // Now we change the AssemblyName of the written Assembly via Mono.Cecil.
+                    // Strictly speaking this is not needed, however this helps with executing
+                    // the test suite, as the runtime will only load a single
+                    // FSI-ASSEMBLY with version 0.0.0.0 by using LoadFrom...
+                    let asem = Mono.Cecil.AssemblyDefinition.ReadAssembly(name + ".dll")
+                    asem.Name <- new Mono.Cecil.AssemblyNameDefinition(wishName, new Version(0,0,1))
+                    asem.Write(wishName + ".dll")
+                    File.Move(wishName + ".dll", cacheInfo.AssemblyPath)
+                    File.Delete(name + ".dll")
+                    for name in [ name; wishName ] do
+                        for ext in [ ".pdb"; ".dll.mdb" ] do
+                            if File.Exists(name + ext) then
+                                File.Delete(name + ext)
 
                     let dynamicAssemblies =
                         System.AppDomain.CurrentDomain.GetAssemblies()
                         |> Seq.filter(fun assem -> assem.IsDynamic)
                         |> Seq.map(fun assem -> assem.GetName().Name)
                         |> Seq.filter(fun assem -> assem <> "FSI-ASSEMBLY")
+                        |> Seq.filter(fun assem -> assem.StartsWith "FAKE_CACHE_")
                         // General Reflection.Emit helper (most likely harmless to ignore)
                         |> Seq.filter(fun assem -> assem <> "Anonymously Hosted DynamicMethods Assembly")
                         // RazorEngine generated
@@ -447,6 +464,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                         let assemblies =
                             System.AppDomain.CurrentDomain.GetAssemblies()
                             |> Seq.filter(fun assem -> not assem.IsDynamic)
+                            |> Seq.filter(fun assem -> assem.GetName().Name.StartsWith "FAKE_CACHE_")
                             // They are not dynamic, but can't be re-used either.
                             |> Seq.filter(fun assem -> not <| assem.GetName().Name.StartsWith("CompiledRazorTemplates.Dynamic.RazorEngine_"))
                         
@@ -461,7 +479,6 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
 let executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script (scriptArgs: string[]) (fsiArgs:string[]) useCache cleanCache =
     let messages = ref []
     let appendMessage isError msg =
-        traceUnknown msg // Some test code expects that the executed script writes to stdout
         messages := { IsError = isError
                       Message = msg
                       Timestamp = DateTimeOffset.UtcNow } :: !messages
@@ -469,7 +486,7 @@ let executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script (scriptArgs: st
         runFAKEScriptWithFsiArgsAndRedirectMessages
             true (FsiArgs(fsiArgs |> List.ofArray, script, scriptArgs |> List.ofArray)) []
             (appendMessage true) (appendMessage false) useCache cleanCache
-    (result, !messages)
+    (result, !messages |> List.rev)
 
 /// Run the given buildscript with fsi.exe and allows for extra arguments to the script. Returns output.
 let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) useCache cleanCache =
diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index e898638b687..6da5b1d6510 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -5,24 +5,34 @@
 using System.IO;
 using Fake;
 using Machine.Specifications;
+using Messages = Microsoft.FSharp.Collections.FSharpList<Fake.ProcessHelper.ConsoleMessage>;
 
 namespace Test.FAKECore
 {
     public class when_running_script
     {
         static string[] EmptyArgs = new string[0];
-        static string RunExplicit(string scriptFilePath, string[] scriptArguments, string[] fsiArguments, bool useCache)
+
+        static Messages IgnoreDateTimeOffset(Messages msgs)
+        {
+            // We don't care about the datetimeoffset.
+            var mapFunc = FSharpFuncUtil.ToFSharpFunc<Fake.ProcessHelper.ConsoleMessage, Fake.ProcessHelper.ConsoleMessage>(cm =>
+                new ProcessHelper.ConsoleMessage(cm.IsError, cm.Message, new DateTimeOffset()));
+            return Microsoft.FSharp.Collections.ListModule.Map(mapFunc, msgs);
+        }
+
+        static Tuple<Messages, string> RunExplicit(string scriptFilePath, string[] scriptArguments, string[] fsiArguments, bool useCache)
         {
             var stdOut = Console.Out;
 
             var sbOut = new System.Text.StringBuilder();
             var outStream = new StringWriter(sbOut);
             Console.SetOut(outStream);
-            Tuple<bool, Microsoft.FSharp.Collections.FSharpList<ProcessHelper.ConsoleMessage>> result;
-            
+            Tuple<bool, Messages> result;
+
             try
             {
-                
+
                 result = FSIHelper.executeBuildScriptWithArgsAndFsiArgsAndReturnMessages(
                     scriptFilePath, scriptArguments, fsiArguments, useCache, false);
             }
@@ -42,16 +52,16 @@ static string RunExplicit(string scriptFilePath, string[] scriptArguments, strin
             {
                 Console.WriteLine(x.Message);
             }
-            var messages = result.Item2.Where(x => !x.IsError).Select(x => x.Message);
-            return 
+
+            return Tuple.Create(result.Item2,
                 sbOut.ToString()
                 .Replace("Running Buildscript: " + scriptFilePath, "")
-                .Replace("\n", "").Replace("\r", "");
+                .Replace("\n", "").Replace("\r", ""));
         }
 
         static string RunExplicit(string scriptFilePath, string[] scriptArguments, bool useCache)
         {
-            return RunExplicit(scriptFilePath, scriptArguments, EmptyArgs, useCache);
+            return RunExplicit(scriptFilePath, scriptArguments, EmptyArgs, useCache).Item2;
         }
 
         static string Run(string script, string[] scriptArguments, bool useCache)
@@ -78,6 +88,34 @@ static FSIHelper.Script script(string path, string contents)
             return new FSIHelper.Script(contents, path.Replace("\\", "/"), null, null);
         }
 
+        It caching_and_non_caching_version_should_handle_stderr_and_stdout_equally =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "printf \"stdout\"; eprintf \"stderr\"");
+                    // without cache
+                    var res1 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res1.Item2.ShouldStartWith("Cache doesn't exist");
+
+                    // with cache
+                    var res2 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res2.Item2.ShouldEqual(
+                            ("Using cache" + nl + "")
+                            .Replace("\n", "").Replace("\r", ""));
+
+                    Microsoft.FSharp.Core.Operators.op_Equality(IgnoreDateTimeOffset(res1.Item1), IgnoreDateTimeOffset(res2.Item1))
+                        .ShouldBeTrue();
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
         It should_be_able_to_use_system_xml =
             () =>
             {
@@ -135,7 +173,7 @@ static FSIHelper.Script script(string path, string contents)
                             "--configuration", "Release",
                             "--csversion", "2007" },
                         false)
-                        .ShouldEqual("test");
+                        .Item1.Head.Message.ShouldEqual("test");
                 }
                 finally
                 {
@@ -159,8 +197,8 @@ static FSIHelper.Script script(string path, string contents)
 
                     File.Exists(cacheFilePath).ShouldEqual(false);
 
-                    RunExplicit(scriptFilePath, EmptyArgs, false)
-                       .ShouldEqual("foobar");
+                    RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, false)
+                       .Item1.Head.Message.ShouldEqual("foobar");
 
                     File.Exists(cacheFilePath).ShouldEqual(false);
 
@@ -169,16 +207,24 @@ static FSIHelper.Script script(string path, string contents)
 
                     File.Exists(cacheFilePath).ShouldEqual(true);
 
-                    RunExplicit(scriptFilePath, EmptyArgs, true)
-                        .ShouldEqual(
-                            ("Using cache" + nl + "foobar")
+                    var res1 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res1.Item2.ShouldEqual(
+                            ("Using cache" + nl + "")
                             .Replace("\n", "").Replace("\r", ""));
+                    res1.Item1.Head.Message.ShouldEqual("foobar");
 
                     File.WriteAllText(scriptFilePath, "printf \"foobarbaz\"");
 
                     var changedScriptHash = FSIHelper.getScriptHash(new FSIHelper.Script[] { script(scriptFilePath, "printf \"foobarbaz\"") }, new List<string>());
-                    RunExplicit(scriptFilePath, EmptyArgs, true)
-                        .ShouldStartWith("Cache is invalid, recompiling");
+                    var res2 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res2.Item2.ShouldStartWith("Cache is invalid, recompiling");
+                    res2.Item1.Head.Message.ShouldEqual("foobarbaz");
+
+                    // This last test is not strictly needed, but it is a good test to check if we can execute
+                    // multiple caching tests in the same session (see comment in FSIHelper.fs where we use Mono.Cecil to rename the assembly)
+                    var res3 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res3.Item2.ShouldStartWith("Using cache");
+                    res3.Item1.Head.Message.ShouldEqual("foobarbaz");
 
                     File.Exists("./.fake/" + scriptFileName + "_" + changedScriptHash + ".dll").ShouldEqual(true);
                 }
@@ -203,8 +249,10 @@ static FSIHelper.Script script(string path, string contents)
                     File.WriteAllText(mainPath, mainScript.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\r", nl));
                     File.WriteAllText(loadedPath, loadedScript.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\r", nl));
 
-                    RunExplicit(mainPath, EmptyArgs, false)
-                        .ShouldEqual("loaded;main");
+                    var res = RunExplicit(mainPath, EmptyArgs, EmptyArgs, false);
+                    res.Item2.ShouldEqual(""); // output is redirected
+                    res.Item1.Head.Message.ShouldEqual("loaded;");
+                    res.Item1.Tail.Head.Message.ShouldEqual("main"); // list is never reverted
                 }
                 finally
                 {

From d8bccd135b8f1e716357e84ca6c741878630e525 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 18 Jan 2016 23:56:29 +0100
Subject: [PATCH 11/13] don't use traceError it's too difficult to understand
 and to implement correctly.

---
 src/app/FakeLib/FSIHelper.fs             |  9 +++-
 src/app/FakeLib/TraceHelper.fs           |  3 --
 src/app/FakeLib/TraceListener.fs         | 33 +++++++++---
 src/test/Test.FAKECore/FSIHelperSpecs.cs | 66 +++++++++++++++++++++---
 4 files changed, 92 insertions(+), 19 deletions(-)

diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index a58e4f6096d..c78966ca64c 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -318,7 +318,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
 
     let wishName = "FAKE_CACHE_" + Path.GetFileNameWithoutExtension cacheInfo.ScriptFileName + "_" + cacheInfo.ScriptHash
     use out = ScriptHost.CreateForwardWriter onOutMsg
-    use err = ScriptHost.CreateForwardWriter(onErrMsg, removeNewLines = true)
+    use err = ScriptHost.CreateForwardWriter onErrMsg
     if useCache && cacheInfo.IsValid then
         
         if printDetails then trace "Using cache"
@@ -475,10 +475,15 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                 handleException ex
                 reraise()
 
+let internal onMessage isError =
+    let printer = if isError && TraceListener.importantMessagesToStdErr then eprintf else printf
+    printer "%s"
+
 /// Run the given buildscript with fsi.exe and allows for extra arguments to the script. Returns output.
 let executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script (scriptArgs: string[]) (fsiArgs:string[]) useCache cleanCache =
     let messages = ref []
     let appendMessage isError msg =
+        onMessage isError msg // For the tests to be more realistic
         messages := { IsError = isError
                       Message = msg
                       Timestamp = DateTimeOffset.UtcNow } :: !messages
@@ -496,7 +501,7 @@ let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) us
 let runBuildScriptWithFsiArgsAt printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env useCache cleanCache =
     runFAKEScriptWithFsiArgsAndRedirectMessages
         printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env
-        traceError traceUnknown
+        (onMessage true) (onMessage false)
         useCache
         cleanCache
 
diff --git a/src/app/FakeLib/TraceHelper.fs b/src/app/FakeLib/TraceHelper.fs
index be252d7c689..03cca56d547 100644
--- a/src/app/FakeLib/TraceHelper.fs
+++ b/src/app/FakeLib/TraceHelper.fs
@@ -32,9 +32,6 @@ let logVerbosefn fmt =
 /// Writes a trace to the command line (in green)
 let trace message = postMessage (TraceMessage(message, true))
 
-/// Writes a trace to the command line (in the current console color)
-let traceUnknown message = postMessage (UnknownMessage(message, false))
-
 /// Writes a message to the command line (in green)
 let tracefn fmt = Printf.ksprintf trace fmt
 
diff --git a/src/app/FakeLib/TraceListener.fs b/src/app/FakeLib/TraceListener.fs
index edeab26143c..404dde81f58 100644
--- a/src/app/FakeLib/TraceListener.fs
+++ b/src/app/FakeLib/TraceListener.fs
@@ -11,10 +11,29 @@ type TraceData =
     | ErrorMessage of string
     | LogMessage of string * bool
     | TraceMessage of string * bool
-    | UnknownMessage of string * bool
     | FinishedMessage
     | OpenTag of string * string
     | CloseTag of string
+    member x.NewLine =
+        match x with
+        | ImportantMessage _
+        | ErrorMessage _ -> Some true
+        | LogMessage (_, newLine)
+        | TraceMessage (_, newLine) -> Some newLine
+        | StartMessage
+        | FinishedMessage
+        | OpenTag _
+        | CloseTag _ -> None
+    member x.Message =
+        match x with
+        | ImportantMessage text
+        | ErrorMessage text
+        | LogMessage (text, _)
+        | TraceMessage (text, _) -> Some text
+        | StartMessage
+        | FinishedMessage
+        | OpenTag _
+        | CloseTag _ -> None
 
 /// Defines a TraceListener interface
 type ITraceListener = 
@@ -27,7 +46,6 @@ let colorMap traceData =
     | ErrorMessage _ -> ConsoleColor.Red
     | LogMessage _ -> ConsoleColor.Gray
     | TraceMessage _ -> ConsoleColor.Green
-    | UnknownMessage _ -> Console.ForegroundColor
     | FinishedMessage -> ConsoleColor.White
     | _ -> ConsoleColor.Gray
 
@@ -59,15 +77,18 @@ type ConsoleTraceListener(importantMessagesToStdErr, colorMap) =
             | StartMessage -> ()
             | OpenTag _ -> ()
             | CloseTag _ -> ()
-            | ImportantMessage text | ErrorMessage text -> writeText importantMessagesToStdErr color true text
-            | UnknownMessage(text, newLine) | LogMessage(text, newLine) | TraceMessage(text, newLine) ->
+            | ImportantMessage text | ErrorMessage text ->
+                writeText importantMessagesToStdErr color true text
+            | LogMessage(text, newLine) | TraceMessage(text, newLine) ->
                 writeText false color newLine text
             | FinishedMessage -> ()
 
+// If we write the stderr on those build servers the build will fail.
+let importantMessagesToStdErr = buildServer <> CCNet && buildServer <> AppVeyor
+
 /// The default TraceListener for Console.
 let defaultConsoleTraceListener =
-  // If we write the stderr on those build servers the build will fail.
-  ConsoleTraceListener(buildServer <> CCNet && buildServer <> AppVeyor, colorMap)
+  ConsoleTraceListener(importantMessagesToStdErr, colorMap)
 
 /// Specifies if the XmlWriter should close tags automatically
 let mutable AutoCloseXmlWriter = false
diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index 6da5b1d6510..7b25d315836 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -11,6 +11,30 @@ namespace Test.FAKECore
 {
     public class when_running_script
     {
+        class MyTracer : Fake.TraceListener.ITraceListener
+        {
+            StringBuilder builder;
+            public MyTracer(StringBuilder builder)
+            {
+                this.builder = builder;
+            }
+
+            public void Write(TraceListener.TraceData value)
+            {
+                if (value.Message != null)
+                {
+                    builder.Append(value.Message.Value);
+                }
+
+                if (value.NewLine != null)
+                {
+                    builder.AppendLine();
+                }
+            }
+
+            public override string ToString() { return builder.ToString(); }
+        }
+
         static string[] EmptyArgs = new string[0];
 
         static Messages IgnoreDateTimeOffset(Messages msgs)
@@ -102,9 +126,7 @@ static FSIHelper.Script script(string path, string contents)
 
                     // with cache
                     var res2 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
-                    res2.Item2.ShouldEqual(
-                            ("Using cache" + nl + "")
-                            .Replace("\n", "").Replace("\r", ""));
+                    res2.Item2.ShouldStartWith("Using cache");
 
                     Microsoft.FSharp.Core.Operators.op_Equality(IgnoreDateTimeOffset(res1.Item1), IgnoreDateTimeOffset(res2.Item1))
                         .ShouldBeTrue();
@@ -116,6 +138,36 @@ static FSIHelper.Script script(string path, string contents)
                 }
             };
 
+        It tracing_functions_should_work =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                var t = new MyTracer(new StringBuilder());
+                TraceListener.listeners.Add(t);
+                try
+                {
+                    var fakeLib = typeof(Fake.TraceListener).Assembly.Location;
+                    File.WriteAllText(scriptFilePath, @"
+#r """ + fakeLib.Replace(@"\", @"\\") + @"""
+open Fake
+traceFAKE ""TEST_FAKE_OUTPUT""");
+                    RunExplicit(scriptFilePath, EmptyArgs, false)
+                        .ShouldEqual("");
+                    var result = t.ToString();
+                    var idx = result.IndexOf("TEST_FAKE_OUTPUT");
+                    idx.ShouldBeGreaterThan(-1);
+                    // We should not have it twice
+                    result.Substring(idx + "TEST_FAKE_OUTPUT".Length).ShouldNotContain("TEST_FAKE_OUTPUT");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                    TraceListener.listeners.Remove(t);
+                }
+            };
+
         It should_be_able_to_use_system_xml =
             () =>
             {
@@ -208,9 +260,7 @@ static FSIHelper.Script script(string path, string contents)
                     File.Exists(cacheFilePath).ShouldEqual(true);
 
                     var res1 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
-                    res1.Item2.ShouldEqual(
-                            ("Using cache" + nl + "")
-                            .Replace("\n", "").Replace("\r", ""));
+                    res1.Item2.ShouldStartWith("Using cache");
                     res1.Item1.Head.Message.ShouldEqual("foobar");
 
                     File.WriteAllText(scriptFilePath, "printf \"foobarbaz\"");
@@ -250,9 +300,9 @@ static FSIHelper.Script script(string path, string contents)
                     File.WriteAllText(loadedPath, loadedScript.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\r", nl));
 
                     var res = RunExplicit(mainPath, EmptyArgs, EmptyArgs, false);
-                    res.Item2.ShouldEqual(""); // output is redirected
+                    res.Item2.ShouldEqual("loaded;main");
                     res.Item1.Head.Message.ShouldEqual("loaded;");
-                    res.Item1.Tail.Head.Message.ShouldEqual("main"); // list is never reverted
+                    res.Item1.Tail.Head.Message.ShouldEqual("main");
                 }
                 finally
                 {

From d636f089902d5d27a1e2ddcdcbb91e00fb0c51d3 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Tue, 19 Jan 2016 00:16:01 +0100
Subject: [PATCH 12/13] fix appveyor

---
 src/test/Test.FAKECore/FSIHelperSpecs.cs | 36 +++++++++++++++++-------
 1 file changed, 26 insertions(+), 10 deletions(-)

diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index 7b25d315836..acf4f6952ea 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -144,21 +144,37 @@ static FSIHelper.Script script(string path, string contents)
                 var scriptFilePath = Path.GetTempFileName() + ".fsx";
                 var scriptFileName = Path.GetFileName(scriptFilePath);
                 var t = new MyTracer(new StringBuilder());
-                TraceListener.listeners.Add(t);
                 try
                 {
-                    var fakeLib = typeof(Fake.TraceListener).Assembly.Location;
-                    File.WriteAllText(scriptFilePath, @"
+                    var fakeLib = typeof(TraceListener).Assembly.Location;
+                    TraceListener.listeners.Add(t);
+                    {
+                        File.WriteAllText(scriptFilePath, @"
 #r """ + fakeLib.Replace(@"\", @"\\") + @"""
 open Fake
 traceFAKE ""TEST_FAKE_OUTPUT""");
-                    RunExplicit(scriptFilePath, EmptyArgs, false)
-                        .ShouldEqual("");
-                    var result = t.ToString();
-                    var idx = result.IndexOf("TEST_FAKE_OUTPUT");
-                    idx.ShouldBeGreaterThan(-1);
-                    // We should not have it twice
-                    result.Substring(idx + "TEST_FAKE_OUTPUT".Length).ShouldNotContain("TEST_FAKE_OUTPUT");
+                        RunExplicit(scriptFilePath, EmptyArgs, false);
+                        var result = t.ToString();
+                        var idx = result.IndexOf("TEST_FAKE_OUTPUT");
+                        idx.ShouldBeGreaterThan(-1);
+                        // We should not have it twice
+                        result.Substring(idx + "TEST_FAKE_OUTPUT".Length).ShouldNotContain("TEST_FAKE_OUTPUT");
+                    }
+                    TraceListener.listeners.Remove(t);
+                    t = new MyTracer(new StringBuilder());
+                    TraceListener.listeners.Add(t);
+                    {
+                        File.WriteAllText(scriptFilePath, @"
+#r """ + fakeLib.Replace(@"\", @"\\") + @"""
+open Fake
+trace ""TEST_FAKE_OUTPUT""");
+                        RunExplicit(scriptFilePath, EmptyArgs, false);
+                        var result = t.ToString();
+                        var idx = result.IndexOf("TEST_FAKE_OUTPUT");
+                        idx.ShouldBeGreaterThan(-1);
+                        // We should not have it twice
+                        result.Substring(idx + "TEST_FAKE_OUTPUT".Length).ShouldNotContain("TEST_FAKE_OUTPUT");
+                    }
                 }
                 finally
                 {

From c488c270e58545eced7154358cd6870402a2ebab Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Tue, 19 Jan 2016 00:22:52 +0100
Subject: [PATCH 13/13] use traceError instead of onErrMsg, to properly log the
 exceptions.

---
 src/app/FakeLib/FSIHelper.fs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index c78966ca64c..c6759bcb129 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -303,7 +303,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
         |> FsiOptions.ofArgs
 
     let handleException (ex : Exception) =
-        onErrMsg (ex.ToString())
+        traceError (ex.ToString())
 
     let scriptPath =
         if Path.IsPathRooted scriptPath then
@@ -362,7 +362,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
         finally
             try
                 traceFAKE "%s" (File.ReadAllText cacheInfo.AssemblyWarningsPath)
-            with e -> traceError (e.ToString())
+            with e -> handleException e
     else
         let cacheDir = DirectoryInfo(Path.Combine(".",".fake"))
         if useCache then