From 062e030ce705280a15a40b909f13e346aed063a6 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 21 May 2018 10:35:51 +0200
Subject: [PATCH 1/4] small fix

---
 RELEASE_NOTES.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 49c43c0b259..1a71bc32fae 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -22,9 +22,9 @@
 
 * ENHANCEMENT: Add partial restore (to improve the speed when using in a release-pipeline) - https://github.com/fsharp/FAKE/issues/1926
 * FAKE5: Xake now supports FAKE 5 and is advertised as module - https://github.com/xakebuild/Xake
-- ENHANCEMENT: Parallelize targets even more - https://github.com/fsharp/FAKE/pull/1934
-- COSMETICS: Targets are always shown as "failed" - https://github.com/fsharp/FAKE/issues/1929
-- COSMETICS: Target description was printed twice - https://github.com/fsharp/FAKE/issues/1931
+* ENHANCEMENT: Parallelize targets even more - https://github.com/fsharp/FAKE/pull/1934
+* COSMETICS: Targets are always shown as "failed" - https://github.com/fsharp/FAKE/issues/1929
+* COSMETICS: Target description was printed twice - https://github.com/fsharp/FAKE/issues/1931
 
 ## 5.0.0-rc012 - 2018-05-12
 

From f221cea3894538fd3fc20c7a26af78ee11a2a6bf Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 21 May 2018 12:12:29 +0200
Subject: [PATCH 2/4] Add tests and fix
 https://github.com/fsharp/FAKE/issues/1947

---
 src/app/Fake.Runtime/CoreCache.fs            |  2 +-
 src/app/Fake.Runtime/HashGeneration.fs       | 74 +++++++++++-----
 src/test/Fake.Core.UnitTests/Fake.Runtime.fs | 92 ++++++++++++++++++++
 3 files changed, 143 insertions(+), 25 deletions(-)

diff --git a/src/app/Fake.Runtime/CoreCache.fs b/src/app/Fake.Runtime/CoreCache.fs
index e4f0d03a8c2..eef032929cc 100644
--- a/src/app/Fake.Runtime/CoreCache.fs
+++ b/src/app/Fake.Runtime/CoreCache.fs
@@ -307,7 +307,7 @@ let prepareContext (config:FakeConfig) (cache:ICachingProvider) =
     
     let getHashUncached () =
         //TODO this is only calculating the hash for the input file, not anything #load-ed
-        let allScriptContents = getAllScripts config.CompileOptions.FsiOptions.Defines config.ScriptTokens config.ScriptFilePath
+        let allScriptContents = getAllScripts config.CompileOptions.FsiOptions.Defines config.ScriptTokens.Value config.ScriptFilePath
         let getOpts (c:CompileOptions) = c.FsiOptions.AsArgs // @ c.CompileReferences
         allScriptContents, getScriptHash allScriptContents (getOpts config.CompileOptions)
     
diff --git a/src/app/Fake.Runtime/HashGeneration.fs b/src/app/Fake.Runtime/HashGeneration.fs
index 706aace504e..51e8236eb74 100644
--- a/src/app/Fake.Runtime/HashGeneration.fs
+++ b/src/app/Fake.Runtime/HashGeneration.fs
@@ -17,31 +17,32 @@ type Script = {
 let getAllScriptContents (pathsAndContents : seq<Script>) =
     pathsAndContents |> Seq.map(fun s -> s.HashContent)
 
-let getAllScripts defines (tokens:Lazy<Fake.Runtime.FSharpParser.TokenizedScript>) scriptPath : Script list =
-    let rec getAllScriptsRec (tokens:Fake.Runtime.FSharpParser.TokenizedScript) scriptPath parentIncludes : Script list =
-        let resolvePath currentIncludes currentDir relativeOrAbsolute isDir =
+let getAllScripts defines (tokens:Fake.Runtime.FSharpParser.TokenizedScript) scriptPath : Script list =
+    let rec getAllScriptsRec (tokens:Fake.Runtime.FSharpParser.TokenizedScript) workDir (scriptName:string) parentIncludes : Script list =
+        let tryResolvePath currentIncludes currentDir relativeOrAbsolute isDir =
             let possiblePaths =
               if Path.IsPathRooted relativeOrAbsolute then [ relativeOrAbsolute ]
               else
                 currentDir :: currentIncludes
                 |> List.map (fun bas -> Path.Combine(bas, relativeOrAbsolute))
-            let realPath =
-              match possiblePaths |> Seq.tryFind (if isDir then Directory.Exists else File.Exists) with
-              | Some f -> f
-              | None ->
-                failwithf "FAKE-CACHING: Could not find %s '%s' in any paths searched. Searched paths:\n%A" (if isDir then "directory" else "file") relativeOrAbsolute (currentDir :: currentIncludes)
-            realPath
+            possiblePaths
+            |> Seq.tryFind (if isDir then Directory.Exists else File.Exists)
+            |> Option.map Path.GetFullPath
+        let resolvePath currentIncludes currentDir relativeOrAbsolute isDir =
+            match tryResolvePath currentIncludes currentDir relativeOrAbsolute isDir with
+            | Some f -> f
+            | None ->
+              failwithf "FAKE-CACHING: Could not find %s '%s' in any paths searched. Searched paths:\n%A" (if isDir then "directory" else "file") relativeOrAbsolute (currentDir :: currentIncludes)
 
         let loadedContents =
-            tokens
-            |> FSharpParser.findProcessorDirectives
-            |> List.fold (fun ((currentIncludes, currentDir, childScripts) as state) preprocessorDirective ->
+            ((parentIncludes, workDir, []), FSharpParser.findProcessorDirectives tokens)
+            ||> List.fold (fun ((currentIncludes, currentDir, childScripts) as state) preprocessorDirective ->
                 let (|MatchFirstString|_|) (l:FSharpParser.StringLike list) =
                   match l with
                   | FSharpParser.StringLike.StringKeyword FSharpParser.SourceDirectory :: _ ->
-                    Some (Path.GetDirectoryName scriptPath)
+                    Some (".")
                   | FSharpParser.StringLike.StringKeyword FSharpParser.SourceFile :: _ ->
-                    Some (Path.GetFileName scriptPath)
+                    Some (scriptName)
                   | FSharpParser.StringLike.StringKeyword (FSharpParser.Unknown s) :: _ ->
                     printfn "FAKE-CACHING: Unknown special key '%s' in preprocessor directive: %A" s preprocessorDirective.Token
                     None
@@ -56,25 +57,50 @@ let getAllScripts defines (tokens:Lazy<Fake.Runtime.FSharpParser.TokenizedScript
                   if name = Runners.loadScriptName && childScriptRelPath.StartsWith ".fake"
                   then currentIncludes, currentDir, childScripts
                   else
-                      let realPath = resolvePath currentIncludes currentDir childScriptRelPath false
+                      let realPath =
+                        try resolvePath currentIncludes currentDir childScriptRelPath false
+                        with e ->
+                            let p = String.Join("\n ", currentDir :: currentIncludes)
+                            let msg =
+                                sprintf "%s(%d,%d): error FS0078: Unable to find the file '%s' in any of\n %s"
+                                    (Path.Combine(workDir, scriptPath))
+                                    preprocessorDirective.Token.LineNumber
+                                    (match preprocessorDirective.Token.TokenInfo with Some t -> t.LeftColumn + 1 | None -> 1)
+                                    childScriptRelPath
+                                    p
+                            raise <| exn(msg, e)
+                      let newWorkDir = Path.GetDirectoryName realPath
+                      let newScriptName = Path.GetFileName realPath
                       let nestedTokens =
                           File.ReadLines realPath
                           |> FSharpParser.getTokenized realPath defines
-                      currentIncludes, currentDir, getAllScriptsRec nestedTokens realPath currentIncludes @ childScripts
+                      currentIncludes, currentDir, getAllScriptsRec nestedTokens newWorkDir newScriptName currentIncludes @ childScripts
                 | { Token = { Representation = "#cd" }; Strings = MatchFirstString relOrAbsolute } ->
-                  let realPath = resolvePath currentIncludes currentDir relOrAbsolute true
+                  let realPath = 
+                    try resolvePath [] currentDir relOrAbsolute true
+                    with e ->
+                        let p = Path.Combine(currentDir, relOrAbsolute)
+                        let msg =
+                            sprintf "%s(%d,%d): error FS2302: Directory '%s' doesn't exist"
+                                (Path.Combine(workDir, scriptPath))
+                                preprocessorDirective.Token.LineNumber
+                                (match preprocessorDirective.Token.TokenInfo with Some t -> t.LeftColumn + 1 | None -> 1)
+                                p
+                        raise <| exn(msg, e)
                   currentIncludes, realPath, childScripts
                 | { Token = { Representation = "#I" }; Strings = MatchFirstString relOrAbsolute } ->
-                  let realPath = resolvePath currentIncludes currentDir relOrAbsolute true
-                  realPath :: currentIncludes, currentDir, childScripts
+                  match tryResolvePath currentIncludes currentDir relOrAbsolute true with
+                  | Some realPath ->
+                    realPath :: currentIncludes, currentDir, childScripts
+                  | None -> currentIncludes, currentDir, childScripts                
                 | _ -> state
-            ) (parentIncludes, Path.GetDirectoryName scriptPath, [])
+            ) 
             |> fun (_, _, c) -> c
-            |> List.rev
-        { Location = scriptPath
+        { Location = Path.Combine(workDir, scriptName)
           HashContent = FSharpParser.getHashableString tokens } :: loadedContents
-
-    getAllScriptsRec tokens.Value scriptPath []
+    let dir = Path.GetDirectoryName scriptPath
+    let name = Path.GetFileName scriptPath
+    getAllScriptsRec tokens dir name []
 
 let getStringHash (s:string) =
     use sha256 = System.Security.Cryptography.SHA256.Create()
diff --git a/src/test/Fake.Core.UnitTests/Fake.Runtime.fs b/src/test/Fake.Core.UnitTests/Fake.Runtime.fs
index 80fc5c8362f..fa8f52530e5 100644
--- a/src/test/Fake.Core.UnitTests/Fake.Runtime.fs
+++ b/src/test/Fake.Core.UnitTests/Fake.Runtime.fs
@@ -1,8 +1,11 @@
 module Fake.RuntimeTests
 
+open System.IO
 open Fake.Runtime
+open Fake.IO.FileSystemOperators
 open Expecto
 open Expecto.Flip
+open Fake.IO
 
 [<Tests>]
 let tests = 
@@ -51,4 +54,93 @@ nuget Fake.Core.SemVer prerelease //"
           |> Fake.Runtime.FSharpParser.findInterestingItems
       let expected = []
       Expect.equal "Expected to find reference." expected interesting 
+
+    // TODO: Add test if everything works with #ifdefed #r "paket: line"
+
+    // Tests that we handle #I and #load properly
+    testCase "Test #1947 - non-existing folders" <| fun _ ->
+      let tmpDir = Path.GetTempFileName()
+      File.Delete tmpDir
+      Directory.CreateDirectory tmpDir |> ignore
+      try
+        Directory.CreateDirectory (tmpDir </> "packages" </> "Octokit" </> "lib" </> "net45") |> ignore
+        Directory.CreateDirectory (tmpDir </> "paket-files" </> "test") |> ignore
+        let scriptText = """
+#load "paket-files/test/octokit.fsx"
+      """
+        let octokit = """
+#I __SOURCE_DIRECTORY__
+#I @"../../../../../packages/Octokit/lib/net45"
+#I @"../../packages/Octokit/lib/net45"
+#I @"../../../../../../packages/build/Octokit/lib/net45"
+#r "Octokit.dll"
+"""    
+        File.WriteAllText(tmpDir </> "paket-files" </> "test" </> "octokit.fsx", octokit)
+        let tokens =
+            Fake.Runtime.FSharpParser.getTokenized "build.fsx" ["DOTNETCORE"; "FAKE"] (scriptText.Split([|'\r';'\n'|]))
+        let scripts = HashGeneration.getAllScripts [] tokens (tmpDir </> "build.fsx")
+        let expected = [ 
+            tmpDir </> "build.fsx"
+            tmpDir </> "paket-files" </> "test" </> "octokit.fsx"
+          ]
+        let actual = scripts |> List.map (fun s -> s.Location)
+        Expect.equal "Expected to find script." expected actual
+      finally
+        Directory.Delete(tmpDir, true)
+
+    testCase "Test #1947 - test #I with ." <| fun _ ->
+      let tmpDir = Path.GetTempFileName()
+      File.Delete tmpDir
+      Directory.CreateDirectory tmpDir |> ignore
+      try
+        let testScriptPath = tmpDir </> "test.fsx"
+        let testScript = """
+#I "test"
+#I "."
+#load "file.fsx"
+"""      
+        let fileScriptPath = tmpDir </> "test" </> "file.fsx"
+        let fileScript = """
+printfn "Test"
+#load "other.fsx"
+"""      
+        let otherScriptPath = tmpDir </> "other.fsx"
+        let otherScript = """
+printfn "other.fsx"
+"""      
+        Directory.CreateDirectory (tmpDir </> "test") |> ignore
+        File.WriteAllText(fileScriptPath, fileScript)
+        File.WriteAllText(otherScriptPath, otherScript)
+        let tokens =
+            Fake.Runtime.FSharpParser.getTokenized "test.fsx" ["DOTNETCORE"; "FAKE"] (testScript.Split([|'\r';'\n'|]))
+        let scripts = HashGeneration.getAllScripts [] tokens testScriptPath
+        let expected = [ 
+            testScriptPath
+            fileScriptPath
+            otherScriptPath
+          ]
+        let actual = scripts |> List.map (fun s -> s.Location)
+        Expect.equal "Expected to find script." expected actual
+      finally
+        Directory.Delete(tmpDir, true)
+        
+    testCase "Test #1947 - good error message" <| fun _ ->
+      let tmpDir = Path.GetTempFileName()
+      File.Delete tmpDir
+      Directory.CreateDirectory tmpDir |> ignore
+      try
+        let testScriptPath = tmpDir </> "test.fsx"
+        let testScript = """
+#cd "asdas"
+"""
+        let tokens =
+            Fake.Runtime.FSharpParser.getTokenized "test.fsx" ["DOTNETCORE"; "FAKE"] (testScript.Split([|'\r';'\n'|]))
+        try
+          let scripts = HashGeneration.getAllScripts [] tokens testScriptPath
+          Expect.isTrue "Expected an exception" false
+        with e ->
+          (e.Message.Contains "test.fsx(2,1): error FS2302: Directory '" && e.Message.Contains "' doesn't exist")
+          |> Expect.isTrue (sprintf "Expected a good error message, but got: %s" e.Message)
+      finally
+        Directory.Delete(tmpDir, true)
   ]    

From 341301f01902365e17842761090e5a6b8b6d6625 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 21 May 2018 12:37:11 +0200
Subject: [PATCH 3/4] Improve error when trying to load full-framework
 assemblies.

---
 src/app/Fake.Runtime/CoreCache.fs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/app/Fake.Runtime/CoreCache.fs b/src/app/Fake.Runtime/CoreCache.fs
index eef032929cc..9454879346f 100644
--- a/src/app/Fake.Runtime/CoreCache.fs
+++ b/src/app/Fake.Runtime/CoreCache.fs
@@ -276,6 +276,8 @@ let findAndLoadInRuntimeDepsCached =
         let result = assemblyCache.GetOrAdd(name.Name, (fun _ ->
             wasCalled <- true
             findAndLoadInRuntimeDeps loadContext name logLevel runtimeDependencies))
+        if isNull result then
+            failwithf "Could not load '%A'.\nFull framework assemblies are not supported!\nYou might try to load a legacy-script with the new netcore runner.\nPlease take a look at the migration guide: https://fake.build/fake-migrate-to-fake-5.html" name
         if not wasCalled then
             let loadedName = result.GetName()
             let isPerfectMatch = loadedName.Name = name.Name && loadedName.Version = name.Version

From 56ff779c2622f6caa76a72701ab0497496e13d92 Mon Sep 17 00:00:00 2001
From: Matthias Dittrich <matthi.d@gmail.com>
Date: Mon, 21 May 2018 12:53:08 +0200
Subject: [PATCH 4/4] Use Console.WriteLine which hopefully prevents races in
 parallel mode.

---
 .../Fake.BuildServer.TeamCity/TeamCityInternal.fs    | 12 +++++++++---
 .../TeamFoundation.fs                                |  4 +++-
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/app/Fake.BuildServer.TeamCity/TeamCityInternal.fs b/src/app/Fake.BuildServer.TeamCity/TeamCityInternal.fs
index da2d439c2c2..86760082f52 100644
--- a/src/app/Fake.BuildServer.TeamCity/TeamCityInternal.fs
+++ b/src/app/Fake.BuildServer.TeamCity/TeamCityInternal.fs
@@ -72,13 +72,19 @@ module internal TeamCityWriter =
 
     /// Send message to TeamCity
     let sendToTeamCity (format:PrintfFormat<string -> unit, _, _, unit>) message =
-        printf format (scrub message)
+        sprintf format (scrub message)
+        // printf is racing with others in parallel mode
+        |> fun s -> System.Console.WriteLine("\n{0}", s)
 
     let sendToTeamCity2 (format:PrintfFormat<string -> string -> unit, _, _, unit>) param1 param2 =
-        printf format (scrub param1) (scrub param2)
+        sprintf format (scrub param1) (scrub param2)
+        // printf is racing with others in parallel mode
+        |> fun s -> System.Console.WriteLine("\n{0}", s)
 
     let sendStrToTeamCity str =
-        printf "%s" str
+        sprintf "%s" str
+        // printf is racing with others in parallel mode
+        |> fun s -> System.Console.WriteLine("\n{0}", s)
 
     /// Open Named Block
     let sendOpenBlock name description = sendToTeamCity2 "##teamcity[blockOpened name='%s' description='%s']" name description
diff --git a/src/app/Fake.BuildServer.TeamFoundation/TeamFoundation.fs b/src/app/Fake.BuildServer.TeamFoundation/TeamFoundation.fs
index 05afbeb2b17..da594bd0754 100644
--- a/src/app/Fake.BuildServer.TeamFoundation/TeamFoundation.fs
+++ b/src/app/Fake.BuildServer.TeamFoundation/TeamFoundation.fs
@@ -22,7 +22,9 @@ module TeamFoundation =
                 |> Seq.map (fun (prop, value) -> sprintf "%s=%s;" (ensureProp prop) (ensureProp value))
                 |> String.separated ""
             if String.isNullOrWhiteSpace temp then "" else " " + temp
-        printfn "##vso[%s%s]%s" action formattedProperties message
+        sprintf "##vso[%s%s]%s" action formattedProperties message
+        // printf is racing with others in parallel mode
+        |> fun s -> System.Console.WriteLine("\n{0}", s)
         
     let private toType t o =
         o |> Option.map (fun value -> t, value)