From e925c207ad6006c1af9a3ef5f30da126ab6bf616 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Wed, 20 Jan 2016 22:22:05 +0100
Subject: [PATCH 1/3] refactor fsihelper

---
 src/app/FAKE/Program.fs                  |   4 +-
 src/app/FakeLib/FSIHelper.fs             | 443 ++++++++++++-----------
 src/test/Test.FAKECore/FSIHelperSpecs.cs |   2 +-
 3 files changed, 230 insertions(+), 219 deletions(-)

diff --git a/src/app/FAKE/Program.fs b/src/app/FAKE/Program.fs
index 6ef5223f498..ba80947820d 100644
--- a/src/app/FAKE/Program.fs
+++ b/src/app/FAKE/Program.fs
@@ -119,7 +119,7 @@ try
                 //TODO if printDetails then printEnvironment cmdArgs args
 
                 let useCache = not (fakeArgs.Contains <@ Cli.NoCache @>)
-                if not (runBuildScriptWithFsiArgsAt printDetails fsiArgs envVars useCache true) then Environment.ExitCode <- 1
+                if not (runBuildScriptWithFsiArgsAt printDetails fsiArgs envVars useCache) then Environment.ExitCode <- 1
                 else if printDetails then log "Ready."
 
                 ()
@@ -144,7 +144,7 @@ try
                 let printDetails = containsParam "details" cmdArgs
                 if printDetails then
                     printEnvironment cmdArgs args
-                if not (runBuildScript printDetails buildScriptArg fsiArgs args true true) then Environment.ExitCode <- 1
+                if not (runBuildScript printDetails buildScriptArg fsiArgs args true) then Environment.ExitCode <- 1
                 else if printDetails then log "Ready."
             | Some handler ->
                 handler.Interact()
diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index 507a044f5b3..e47e61fb6f8 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -199,10 +199,6 @@ let executeFSIWithScriptArgsAndReturnMessages script (scriptArgs: string[]) =
 open Microsoft.FSharp.Compiler.Interactive.Shell
 open System.Reflection
 
-type private AssemblySource = 
-| GAC
-| Disk
-
 let hashRegex = Text.RegularExpressions.Regex("(?<script>.+)_(?<hash>[a-zA-Z0-9]+\.dll$)", System.Text.RegularExpressions.RegexOptions.Compiled)
 
 type private CacheInfo =
@@ -216,6 +212,8 @@ type private CacheInfo =
     IsValid : bool
   }
 
+/// gets a cache entry for the given script.
+/// We need to consider fsiOptions as they might contain --defines.
 let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
     let allScriptContents = getAllScripts scriptPath
     let scriptHash = getScriptHash allScriptContents fsiOptions
@@ -236,17 +234,13 @@ let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
             let loadedAssemblies =
                 cacheConfig.Value.Assemblies
                 |> Seq.choose (fun assemInfo ->
-                    try
-                        let assem = 
+                    try let assem =
                             if assemInfo.Location <> "" then
                                 Reflection.Assembly.LoadFrom(assemInfo.Location)
-                            else
-                                Reflection.Assembly.Load(assemInfo.FullName)
+                            else Reflection.Assembly.Load(assemInfo.FullName)
                         Some(assemInfo, assem)
-                    with
-                    | ex -> 
-                        if printDetails then tracef "Unable to find assembly %A" assemInfo
-                        None)
+                    with ex -> if printDetails then tracef "Unable to find assembly %A" assemInfo
+                               None)
                 |> Seq.toList
             let knownAssemblies =
                 loadedAssemblies
@@ -257,24 +251,24 @@ let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
                 |> Seq.filter(fun (assemInfo, assem) ->
                     assem.GetName().Version.ToString() = assemInfo.Version)
                 |> Seq.length
-            AppDomain.CurrentDomain.add_AssemblyResolve(new ResolveEventHandler(fun sender ev ->
-              let name = AssemblyName(ev.Name)
-              match knownAssemblies.TryGetValue(ev.Name) with
-              | true, a ->
-                if printDetails then tracefn "Redirect assembly load to known assembly: %s" ev.Name
-                a
-              | _ ->
-                match loadedAssemblies
-                      |> Seq.map snd
-                      |> Seq.tryFind (fun asem ->
-                          let n = asem.GetName()
-                          n.Name = name.Name &&
-                          n.GetPublicKeyToken() = name.GetPublicKeyToken()) with
-                | Some (asem) ->
-                    traceFAKE "Redirect assembly from '%s' to '%s'" ev.Name asem.FullName
-                    asem
+            AppDomain.CurrentDomain.add_AssemblyResolve(new ResolveEventHandler(fun _ ev ->
+                let name = AssemblyName(ev.Name)
+                match knownAssemblies.TryGetValue(ev.Name) with
+                | true, a ->
+                    if printDetails then tracefn "Redirect assembly load to known assembly: %s" ev.Name
+                    a
                 | _ ->
-                    null))
+                    match loadedAssemblies
+                          |> Seq.map snd
+                          |> Seq.tryFind (fun asem ->
+                              let n = asem.GetName()
+                              n.Name = name.Name &&
+                              n.GetPublicKeyToken() = name.GetPublicKeyToken()) with
+                    | Some (asem) ->
+                        traceFAKE "Redirect assembly from '%s' to '%s'" ev.Name asem.FullName
+                        asem
+                    | _ ->
+                        null))
             assemVersionValidCount = Seq.length cacheConfig.Value.Assemblies
         else
             false
@@ -286,9 +280,191 @@ let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
       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 =
+/// Run a script from the cache
+let private runScriptCached printDetails cacheInfo out err =
+    if printDetails then trace "Using cache"
+    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
+        Yaaf.FSharp.Scripting.Helper.consoleCapture out err (fun () ->
+            let ass = Reflection.Assembly.LoadFrom(cacheInfo.AssemblyPath)
+            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 ->
+                  traceError (ex.ToString())
+                  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())
+
+/// Handles a cache store operation, this should not throw as it is executed in a finally block and
+/// therefore might eat other exceptions. And a caching error is not critical.
+let private handleCaching printDetails (session:IFsiSession) fsiErrorOutput (cacheDir:DirectoryInfo) cacheInfo  =
+    try
+        let wishName = "FAKE_CACHE_" + Path.GetFileNameWithoutExtension cacheInfo.ScriptFileName + "_" + cacheInfo.ScriptHash
+        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
+
+        let destinationFile = FileInfo(cacheInfo.AssemblyPath)
+        let targetDirectory = destinationFile.Directory
+
+        if (not <| targetDirectory.Exists) then targetDirectory.Create()
+        if (destinationFile.Exists) then destinationFile.Delete()
+
+        File.WriteAllText(cacheInfo.AssemblyWarningsPath, fsiErrorOutput.ToString())
+
+        try
+            // 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 reader = new Mono.Cecil.DefaultAssemblyResolver() // see https://github.com/fsharp/FAKE/issues/1084
+            reader.AddSearchDirectory (Path.GetDirectoryName TraceHelper.fakePath)
+            reader.AddSearchDirectory (Path.GetDirectoryName typeof<string option>.Assembly.Location)
+            let readerParams = new Mono.Cecil.ReaderParameters(AssemblyResolver = reader)
+            let asem = Mono.Cecil.AssemblyDefinition.ReadAssembly(name + ".dll", readerParams)
+            asem.Name <- new Mono.Cecil.AssemblyNameDefinition(wishName, new Version(0,0,1))
+            asem.Write(wishName + ".dll")
+            File.Move(wishName + ".dll", cacheInfo.AssemblyPath)
+        with exn ->
+            // If cecil fails we might want to trigger a warning, but you know what?
+            // we can continue using the FSI-ASSEMBLY.dll
+            traceFAKE "Warning (please open an issue on FAKE and /cc @matthid): %O" exn
+            File.Move(name + ".dll", cacheInfo.AssemblyPath)
+
+        for name in [ name; wishName ] do
+            for ext in [ ".dll"; ".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
+            |> 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)
+                |> 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_"))
+
+            let cacheConfig : XDocument = Cache.create assemblies
+            cacheConfig.Save(cacheInfo.CacheConfigPath)
+            if printDetails then trace (System.Environment.NewLine + "Saved cache")
+    with ex ->
+        // Caching errors are not critical, and we shouldn't throw in a finally clause.
+        traceFAKE "CACHING ERROR - please open a issue on FAKE and /cc @matthid\n\nError: %O" ex
+        if File.Exists cacheInfo.AssemblyWarningsPath then
+            // Invalidates the cache
+            try File.Delete cacheInfo.AssemblyWarningsPath with _ -> ()
+
+/// Run a given script unchacked, saves the cache if useCache is set to true.
+/// deletes any existing caching for the given script.
+let private runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err =
+    let options = FsiOptions.ofArgs fsiOptions
+    let getScriptAndHash fileName =
+        let matched = hashRegex.Match(fileName)
+        matched.Groups.Item("script").Value, matched.Groups.Item("hash").Value
+    let cacheDir = DirectoryInfo(Path.Combine(".",".fake"))
+    if useCache then
+        // If we are here that proably means that
+        // when trying to load the cached version something went wrong...
+        if cacheDir.Exists then
+            let oldFiles =
+                cacheDir.GetFiles()
+                |> Seq.filter(fun file ->
+                    let oldScriptName, _ = getScriptAndHash(file.Name)
+                    oldScriptName = cacheInfo.ScriptFileName)
+
+            if (oldFiles |> Seq.length) > 0 then
+                if printDetails then trace "Cache is invalid, recompiling"
+                for file in oldFiles do
+                    try file.Delete()
+                    // File might be locked (for example when executing the test suite!)
+                    with :? UnauthorizedAccessException -> traceFAKE "Unable to access %s" file.FullName
+            else
+                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 = out,
+              errWriter = err)
+      with :? FsiEvaluationException as e ->
+          traceError "FsiEvaluationSession could not be created."
+          traceError e.Result.Error.Merged
+          reraise ()
+
+    try
+        try
+            session.EvalScript scriptPath
+            true
+        with :? FsiEvaluationException as eval ->
+            traceFAKE "%O" eval
+            false
+    finally
+        // Write Script Warnings & Errors at the end
+        traceFAKE "%O" fsiErrorOutput
+        // Cache in the error case as well.
+        if useCache && not cacheInfo.IsValid then
+            handleCaching printDetails session fsiErrorOutput cacheDir cacheInfo
 
+/// 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 =
     if printDetails then traceFAKE "Running Buildscript: %s" scriptPath
 
     // Add arguments to the Environment
@@ -298,13 +474,6 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
     // 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
-        |> FsiOptions.ofArgs
-
-    let handleException (ex : Exception) =
-        traceError (ex.ToString())
-
     let scriptPath =
         if Path.IsPathRooted scriptPath then
             scriptPath
@@ -312,186 +481,29 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
             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
 
-    let wishName = "FAKE_CACHE_" + Path.GetFileNameWithoutExtension cacheInfo.ScriptFileName + "_" + cacheInfo.ScriptHash
     use out = ScriptHost.CreateForwardWriter onOutMsg
     use err = ScriptHost.CreateForwardWriter onErrMsg
     if useCache && cacheInfo.IsValid then
-        if printDetails then trace "Using cache"
-        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
-            Yaaf.FSharp.Scripting.Helper.consoleCapture out err (fun () ->
-                let ass = Reflection.Assembly.LoadFrom(cacheInfo.AssemblyPath)
-                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)
-            with e -> handleException e
+//        try
+            runScriptCached printDetails cacheInfo out err
+//        with ex ->
+//            traceFAKE """CACHING WARNING
+//this might happen after Updates...
+//please open a issue on FAKE and /cc @matthid ONLY IF this happens reproducibly)
+//
+//Error: %O""" ex
+//            // Invalidates the cache
+//            runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err
     else
-        let cacheDir = DirectoryInfo(Path.Combine(".",".fake"))
-        if useCache then
-            if cacheDir.Exists then
-                let oldFiles = 
-                    cacheDir.GetFiles()
-                    |> Seq.filter(fun file -> 
-                        let oldScriptName, _ = getScriptAndHash(file.Name)
-                        oldScriptName = cacheInfo.ScriptFileName)
-
-                if (oldFiles |> Seq.length) > 0 then
-                    if cleanCache then
-                        for file in oldFiles do
-                            file.Delete()
-                    if printDetails then trace "Cache is invalid, recompiling"
-                else 
-                    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 = out,
-                  errWriter = err)
-          with :? FsiEvaluationException as e ->
-              traceError "FsiEvaluationSession could not be created."
-              traceError e.Result.Error.Merged
-              reraise ()
-
-        try
-            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
-                    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
-
-                    let destinationFile = FileInfo(cacheInfo.AssemblyPath)
-                    let targetDirectory = destinationFile.Directory
-
-                    if (not <| targetDirectory.Exists) then targetDirectory.Create()
-                    if (destinationFile.Exists) then destinationFile.Delete()
-
-                    File.WriteAllText(cacheInfo.AssemblyWarningsPath, fsiErrorOutput.ToString())
-
-                    try
-                        // 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 reader = new Mono.Cecil.DefaultAssemblyResolver() // see https://github.com/fsharp/FAKE/issues/1084
-                        reader.AddSearchDirectory (Path.GetDirectoryName TraceHelper.fakePath)
-                        reader.AddSearchDirectory (Path.GetDirectoryName typeof<string option>.Assembly.Location)
-                        let readerParams = new Mono.Cecil.ReaderParameters(AssemblyResolver = reader)
-                        let asem = Mono.Cecil.AssemblyDefinition.ReadAssembly(name + ".dll", readerParams)
-                        asem.Name <- new Mono.Cecil.AssemblyNameDefinition(wishName, new Version(0,0,1))
-                        asem.Write(wishName + ".dll")
-                        File.Move(wishName + ".dll", cacheInfo.AssemblyPath)
-                    with exn ->
-                        // If cecil fails we might want to trigger a warning, but you know what?
-                        // we can continue using the FSI-ASSEMBLY.dll
-                        traceFAKE "Warning (please open an issue on FAKE and /cc @matthid): %O" exn
-                        File.Move(name + ".dll", cacheInfo.AssemblyPath)
-
-                    for name in [ name; wishName ] do
-                        for ext in [ ".dll"; ".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
-                        |> 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)
-                            |> 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_"))
-                        
-                        let cacheConfig : XDocument = Cache.create assemblies
-                        cacheConfig.Save(cacheInfo.CacheConfigPath)
-                        if printDetails then trace (System.Environment.NewLine + "Saved cache")
-            with ex ->
-                // Caching errors are not critical, and we shouldn't throw in a finally clause.
-                traceFAKE "CACHING ERROR (please open a issue on FAKE and /cc @matthid): %O" ex
-                if File.Exists cacheInfo.AssemblyWarningsPath then
-                    // Invalidates the cache
-                    try File.Delete cacheInfo.AssemblyWarningsPath with _ -> ()
+        runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err
 
 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 executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script (scriptArgs: string[]) (fsiArgs:string[]) useCache =
     let messages = ref []
     let appendMessage isError msg =
         onMessage isError msg // For the tests to be more realistic
@@ -501,25 +513,24 @@ let executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script (scriptArgs: st
     let result =
         runFAKEScriptWithFsiArgsAndRedirectMessages
             true (FsiArgs(fsiArgs |> List.ofArray, script, scriptArgs |> List.ofArray)) []
-            (appendMessage true) (appendMessage false) useCache cleanCache
+            (appendMessage true) (appendMessage false) useCache
     (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 =
-    executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script scriptArgs [||] useCache cleanCache
+let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) useCache =
+    executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script scriptArgs [||] useCache
 
 /// 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 =
+let runBuildScriptWithFsiArgsAt printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env useCache =
     runFAKEScriptWithFsiArgsAndRedirectMessages
         printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env
         (onMessage true) (onMessage false)
         useCache
-        cleanCache
 
 /// Run the given buildscript with fsi.exe at the given working directory.
-let runBuildScriptAt printDetails script extraFsiArgs env useCache cleanCache =
-    runBuildScriptWithFsiArgsAt printDetails (FsiArgs(extraFsiArgs, script, [])) env useCache cleanCache
+let runBuildScriptAt printDetails script extraFsiArgs env useCache =
+    runBuildScriptWithFsiArgsAt printDetails (FsiArgs(extraFsiArgs, script, [])) env useCache
 
 /// Run the given buildscript with fsi.exe
-let runBuildScript printDetails script extraFsiArgs env useCache cleanCache =
-    runBuildScriptAt printDetails script extraFsiArgs env useCache cleanCache
+let runBuildScript printDetails script extraFsiArgs env useCache =
+    runBuildScriptAt printDetails script extraFsiArgs env useCache
diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index acf4f6952ea..95249d42296 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -58,7 +58,7 @@ static Tuple<Messages, string> RunExplicit(string scriptFilePath, string[] scrip
             {
 
                 result = FSIHelper.executeBuildScriptWithArgsAndFsiArgsAndReturnMessages(
-                    scriptFilePath, scriptArguments, fsiArguments, useCache, false);
+                    scriptFilePath, scriptArguments, fsiArguments, useCache);
             }
             finally
             {

From 8dd1c710649606a0078c4d3aaf83dc1352e157b8 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Wed, 20 Jan 2016 22:29:53 +0100
Subject: [PATCH 2/3] add test.

---
 src/test/Test.FAKECore/FSIHelperSpecs.cs | 31 ++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index 95249d42296..4d5413c457b 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -112,6 +112,37 @@ static FSIHelper.Script script(string path, string contents)
             return new FSIHelper.Script(contents, path.Replace("\\", "/"), null, null);
         }
 
+        It fallback_to_compiling_when_cache_is_broken =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "printf \"foobar\"");
+                    var scriptHash =
+                            FSIHelper.getScriptHash(new FSIHelper.Script[] { script(scriptFilePath, "printf \"foobar\"") }, new List<string>());
+
+                    var cacheFilePath = Path.Combine(".", ".fake", scriptFileName + "_" + scriptHash + ".dll");
+
+                    File.Exists(cacheFilePath).ShouldEqual(false);
+
+                    RunExplicit(scriptFilePath, EmptyArgs, true)
+                        .ShouldStartWith("Cache doesn't exist");
+
+                    File.Exists(cacheFilePath).ShouldEqual(true);
+                    File.WriteAllBytes(cacheFilePath, new byte[] { 8 });
+
+                    RunExplicit(scriptFilePath, EmptyArgs, true)
+                        .ShouldStartWith("Using cacheCache is invalid, recompiling");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
         It caching_and_non_caching_version_should_handle_stderr_and_stdout_equally =
             () =>
             {

From 17463458004722d18530769fc826324532b386f1 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Wed, 20 Jan 2016 22:32:42 +0100
Subject: [PATCH 3/3] enable fallback behavior.

---
 src/app/FakeLib/FSIHelper.fs             | 18 +++++++++---------
 src/test/Test.FAKECore/FSIHelperSpecs.cs |  5 +++--
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index e47e61fb6f8..c06c9caf7f4 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -485,16 +485,16 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
     use out = ScriptHost.CreateForwardWriter onOutMsg
     use err = ScriptHost.CreateForwardWriter onErrMsg
     if useCache && cacheInfo.IsValid then
-//        try
+        try
             runScriptCached printDetails cacheInfo out err
-//        with ex ->
-//            traceFAKE """CACHING WARNING
-//this might happen after Updates...
-//please open a issue on FAKE and /cc @matthid ONLY IF this happens reproducibly)
-//
-//Error: %O""" ex
-//            // Invalidates the cache
-//            runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err
+        with ex ->
+            traceFAKE """CACHING WARNING
+this might happen after Updates...
+please open a issue on FAKE and /cc @matthid ONLY IF this happens reproducibly)
+
+Error: %O""" ex
+            // Invalidates the cache
+            runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err
     else
         runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err
 
diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index 4d5413c457b..5474cce6878 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -133,8 +133,9 @@ static FSIHelper.Script script(string path, string contents)
                     File.Exists(cacheFilePath).ShouldEqual(true);
                     File.WriteAllBytes(cacheFilePath, new byte[] { 8 });
 
-                    RunExplicit(scriptFilePath, EmptyArgs, true)
-                        .ShouldStartWith("Using cacheCache is invalid, recompiling");
+                    var result = RunExplicit(scriptFilePath, EmptyArgs, true);
+                    result.ShouldContain("Using cache");
+                    result.ShouldContain("Cache is invalid, recompiling");
                 }
                 finally
                 {