diff --git a/.fantomasignore b/.fantomasignore
index f974955bb889e4dfb9e8b6d2efdcf0d4c4cc7c45..cc41976ea8d28567b1a107da0a6e8b38747f0c18 100644
--- a/.fantomasignore
+++ b/.fantomasignore
@@ -16,7 +16,6 @@ src/FSharp.Core/**/*.fs
 src/Compiler/**/*.fs
 src/fsc/**/*.fs
 src/fscAnyCpu/**/*.fs
-src/FSharp.Build/**/*.fs
 src/FSharp.Compiler.Server.Shared/**/*.fs
 src/FSharp.DependencyManager.Nuget/**/*.fs
 src/fsi/**/*.fs
diff --git a/src/FSharp.Build/CreateFSharpManifestResourceName.fs b/src/FSharp.Build/CreateFSharpManifestResourceName.fs
index b377442c62baf2eed25a95cc2eed0ab1c3f376c2..175a76d203007e511451de199717b34c43728b5b 100644
--- a/src/FSharp.Build/CreateFSharpManifestResourceName.fs
+++ b/src/FSharp.Build/CreateFSharpManifestResourceName.fs
@@ -4,9 +4,7 @@ namespace FSharp.Build
 
 open System
 open System.IO
-open System.Text
 open Microsoft.Build.Tasks
-open Microsoft.Build.Utilities
 
 type CreateFSharpManifestResourceName public () =
     inherit CreateCSharpManifestResourceName()
@@ -14,12 +12,14 @@ type CreateFSharpManifestResourceName public () =
     // When set to true, generate resource names in the same way as C# with root namespace and folder names
     member val UseStandardResourceNames = false with get, set
 
-    override this.CreateManifestName 
-                ((fileName:string), 
-                    (linkFileName:string),
-                    (rootNamespace:string), (* may be null *)  
-                    (dependentUponFileName:string), (* may be null *) 
-                    (binaryStream:System.IO.Stream) (* may be null *)) : string = 
+    override this.CreateManifestName
+        (
+            fileName: string,
+            linkFileName: string,
+            rootNamespace: string,  // may be null
+            dependentUponFileName: string,  // may be null
+            binaryStream: Stream // may be null
+        ) : string =
 
         // The Visual CSharp and XBuild CSharp toolchains transform resource names like this:
         //     SubDir\abc.resx --> SubDir.abc.resources
@@ -30,37 +30,56 @@ type CreateFSharpManifestResourceName public () =
 
         let fileName, linkFileName, rootNamespace =
             match this.UseStandardResourceNames with
-            | true ->
-                fileName, linkFileName, rootNamespace
+            | true -> fileName, linkFileName, rootNamespace
             | false ->
-                let runningOnMono = 
+                let runningOnMono =
                     try
                         System.Type.GetType("Mono.Runtime") <> null
-                    with e -> 
-                        false  
-                let fileName = if not runningOnMono || fileName.EndsWith(".resources", StringComparison.OrdinalIgnoreCase) then fileName else Path.GetFileName(fileName)
-                let linkFileName = if not runningOnMono || linkFileName.EndsWith(".resources", StringComparison.OrdinalIgnoreCase) then linkFileName else Path.GetFileName(linkFileName)
-                fileName, linkFileName, "" 
+                    with
+                    | e -> false
 
-        let embeddedFileName = 
+                let fileName =
+                    if
+                        not runningOnMono
+                        || fileName.EndsWith(".resources", StringComparison.OrdinalIgnoreCase)
+                    then
+                        fileName
+                    else
+                        Path.GetFileName(fileName)
+
+                let linkFileName =
+                    if
+                        not runningOnMono
+                        || linkFileName.EndsWith(".resources", StringComparison.OrdinalIgnoreCase)
+                    then
+                        linkFileName
+                    else
+                        Path.GetFileName(linkFileName)
+
+                fileName, linkFileName, ""
+
+        let embeddedFileName =
             match linkFileName with
-            |   null -> fileName
-            |   _ -> linkFileName
+            | null -> fileName
+            | _ -> linkFileName
 
-        // since we do not support resources dependent on a form, we always pass null for a binary stream 
-        let cSharpResult = 
+        // since we do not support resources dependent on a form, we always pass null for a binary stream
+        let cSharpResult =
             base.CreateManifestName(fileName, linkFileName, rootNamespace, dependentUponFileName, null)
         // Workaround that makes us keep .resources extension on both 3.5 and 3.5SP1
         // 3.5 stripped ".resources", 3.5 SP1 does not. We should do 3.5SP1  thing
         let extensionToWorkaround = ".resources"
-        if embeddedFileName.EndsWith(extensionToWorkaround, StringComparison.OrdinalIgnoreCase) 
-                && not (cSharpResult.EndsWith(extensionToWorkaround, StringComparison.OrdinalIgnoreCase)) then
+
+        if
+            embeddedFileName.EndsWith(extensionToWorkaround, StringComparison.OrdinalIgnoreCase)
+            && not (cSharpResult.EndsWith(extensionToWorkaround, StringComparison.OrdinalIgnoreCase))
+        then
             cSharpResult + extensionToWorkaround
         else
             cSharpResult
-            
-        
-    override _.IsSourceFile (fileName: string) = 
+
+    override _.IsSourceFile(fileName: string) =
         let extension = Path.GetExtension(fileName)
-        (String.Equals(extension, ".fs", StringComparison.OrdinalIgnoreCase) ||
-            String.Equals(extension, ".ml", StringComparison.OrdinalIgnoreCase))
\ No newline at end of file
+
+        (String.Equals(extension, ".fs", StringComparison.OrdinalIgnoreCase)
+         || String.Equals(extension, ".ml", StringComparison.OrdinalIgnoreCase))
diff --git a/src/FSharp.Build/FSharpCommandLineBuilder.fs b/src/FSharp.Build/FSharpCommandLineBuilder.fs
index 2fd7dfa1d06409e70c670e85859454561f58c486..bf86d185edc2e4aa22a1dc172bd219c85b48201d 100644
--- a/src/FSharp.Build/FSharpCommandLineBuilder.fs
+++ b/src/FSharp.Build/FSharpCommandLineBuilder.fs
@@ -10,20 +10,23 @@ open Internal.Utilities
 
 [<assembly: System.Runtime.InteropServices.ComVisible(false)>]
 [<assembly: System.CLSCompliant(true)>]
-do()
+do ()
 
 // Shim to match nullness checking library support in preview
 [<AutoOpen>]
-module Utils = 
+module Utils =
 
     /// Match on the nullness of an argument.
-    let inline (|Null|NonNull|) (x: 'T) : Choice<unit,'T> = match x with null -> Null | v -> NonNull v
+    let inline (|Null|NonNull|) (x: 'T) : Choice<unit, 'T> =
+        match x with
+        | null -> Null
+        | v -> NonNull v
 
     /// Indicates that a type may be null. 'MaybeNull<string>' used internally in the F# compiler as unchecked
     /// replacement for 'string?' for example for future FS-1060.
-    type 'T MaybeNull when 'T : null and 'T: not struct = 'T
+    type 'T MaybeNull when 'T: null and 'T: not struct = 'T
 
-type FSharpCommandLineBuilder () =
+type FSharpCommandLineBuilder() =
 
     // In addition to generating a command-line that will be handed to cmd.exe, we also generate
     // an array of individual arguments.  The former needs to be quoted (and cmd.exe will strip the
@@ -31,8 +34,8 @@ type FSharpCommandLineBuilder () =
     // class gets us out of the business of unparsing-then-reparsing arguments.
 
     let builder = new CommandLineBuilder()
-    let mutable args = []  // in reverse order
-    let mutable srcs = []  // in reverse order
+    let mutable args = [] // in reverse order
+    let mutable srcs = [] // in reverse order
 
     /// Return a list of the arguments (with no quoting for the cmd.exe shell)
     member _.CapturedArguments() = List.rev args
@@ -48,8 +51,9 @@ type FSharpCommandLineBuilder () =
         // do not update "args", not used
         for item in filenames do
             let tmp = new CommandLineBuilder()
-            tmp.AppendSwitchUnquotedIfNotNull("", item.ItemSpec)  // we don't want to quote the file name, this is a way to get that
+            tmp.AppendSwitchUnquotedIfNotNull("", item.ItemSpec) // we don't want to quote the file name, this is a way to get that
             let s = tmp.ToString()
+
             if s <> String.Empty then
                 srcs <- tmp.ToString() :: srcs
 
@@ -58,6 +62,7 @@ type FSharpCommandLineBuilder () =
         let tmp = new CommandLineBuilder()
         tmp.AppendSwitchUnquotedIfNotNull(switch, values, sep)
         let s = tmp.ToString()
+
         if s <> String.Empty then
             args <- s :: args
 
@@ -66,43 +71,57 @@ type FSharpCommandLineBuilder () =
         builder.AppendSwitchIfNotNull(switch, value)
         let tmp = new CommandLineBuilder()
         tmp.AppendSwitchUnquotedIfNotNull(switch, value)
+
         let providedMetaData =
-            metadataNames
-            |> Array.filter (String.IsNullOrWhiteSpace >> not)
+            metadataNames |> Array.filter (String.IsNullOrWhiteSpace >> not)
+
         if providedMetaData.Length > 0 then
             tmp.AppendTextUnquoted ","
-            tmp.AppendTextUnquoted (providedMetaData|> String.concat ",")
+            tmp.AppendTextUnquoted(providedMetaData |> String.concat ",")
+
         let s = tmp.ToString()
+
         if s <> String.Empty then
             args <- s :: args
 
     member _.AppendSwitchUnquotedIfNotNull(switch: string, value: string MaybeNull) =
-        assert(switch = "")  // we only call this method for "OtherFlags"
+        assert (switch = "") // we only call this method for "OtherFlags"
         // Unfortunately we still need to mimic what cmd.exe does, but only for "OtherFlags".
-        let ParseCommandLineArgs(commandLine: string) = // returns list in reverse order
+        let ParseCommandLineArgs (commandLine: string) = // returns list in reverse order
             let mutable args = []
             let mutable i = 0 // index into commandLine
             let len = commandLine.Length
+
             while i < len do
                 // skip whitespace
                 while i < len && System.Char.IsWhiteSpace(commandLine, i) do
                     i <- i + 1
+
                 if i < len then
                     // parse an argument
                     let sb = new StringBuilder()
                     let mutable finished = false
                     let mutable insideQuote = false
+
                     while i < len && not finished do
                         match commandLine.[i] with
-                        | '"' -> insideQuote <- not insideQuote; i <- i + 1
+                        | '"' ->
+                            insideQuote <- not insideQuote
+                            i <- i + 1
                         | c when not insideQuote && System.Char.IsWhiteSpace(c) -> finished <- true
-                        | c -> sb.Append(c) |> ignore; i <- i + 1
+                        | c ->
+                            sb.Append(c) |> ignore
+                            i <- i + 1
+
                     args <- sb.ToString() :: args
+
             args
+
         builder.AppendSwitchUnquotedIfNotNull(switch, value)
         let tmp = new CommandLineBuilder()
         tmp.AppendSwitchUnquotedIfNotNull(switch, value)
         let s = tmp.ToString()
+
         if s <> String.Empty then
             args <- ParseCommandLineArgs(s) @ args
 
@@ -110,8 +129,5 @@ type FSharpCommandLineBuilder () =
         builder.AppendSwitch(switch)
         args <- switch :: args
 
-    member internal x.GetCapturedArguments() = 
-        [|
-            yield! x.CapturedArguments()
-            yield! x.CapturedFilenames()
-        |]
+    member internal x.GetCapturedArguments() =
+        [| yield! x.CapturedArguments(); yield! x.CapturedFilenames() |]
diff --git a/src/FSharp.Build/FSharpEmbedResXSource.fs b/src/FSharp.Build/FSharpEmbedResXSource.fs
index fc8b9167d38f5442b75a683addf531d1f8b671c2..24665c44f5881d684fa9217355aab94ebb6aa98c 100644
--- a/src/FSharp.Build/FSharpEmbedResXSource.fs
+++ b/src/FSharp.Build/FSharpEmbedResXSource.fs
@@ -3,8 +3,6 @@
 namespace FSharp.Build
 
 open System
-open System.Collections
-open System.Globalization
 open System.IO
 open System.Linq
 open System.Text
@@ -20,7 +18,8 @@ type FSharpEmbedResXSource() =
     let mutable _outputPath: string = ""
     let mutable _targetFramework: string = ""
 
-    let boilerplate = @"// <auto-generated>
+    let boilerplate =
+        @"// <auto-generated>
 
 namespace {0}
 
@@ -32,95 +31,128 @@ module internal {1} =
     let ResourceManager = new System.Resources.ResourceManager(""{2}"", C(0).GetType().GetTypeInfo().Assembly)
     let GetString(name:System.String) : System.String = ResourceManager.GetString(name, Culture)"
 
-    let boilerplateGetObject = "    let GetObject(name:System.String) : System.Object = ResourceManager.GetObject(name, Culture)"
+    let boilerplateGetObject =
+        "    let GetObject(name:System.String) : System.Object = ResourceManager.GetObject(name, Culture)"
 
-    let generateSource (resx:string) (fullModuleName:string) (generateLegacy:bool) (generateLiteral:bool) =
+    let generateSource (resx: string) (fullModuleName: string) (generateLegacy: bool) (generateLiteral: bool) =
         try
             let printMessage = printfn "FSharpEmbedResXSource: %s"
             let justFileName = Path.GetFileNameWithoutExtension(resx)
             let sourcePath = Path.Combine(_outputPath, justFileName + ".fs")
 
             // simple up-to-date check
-            if File.Exists(resx) && File.Exists(sourcePath) &&
-                File.GetLastWriteTimeUtc(resx) <= File.GetLastWriteTimeUtc(sourcePath) then
+            if File.Exists(resx)
+               && File.Exists(sourcePath)
+               && File.GetLastWriteTimeUtc(resx) <= File.GetLastWriteTimeUtc(sourcePath) then
                 printMessage (sprintf "Skipping generation: '%s' since it is up-to-date." sourcePath)
                 Some(sourcePath)
             else
                 let namespaceName, moduleName =
                     let parts = fullModuleName.Split('.')
-                    if parts.Length = 1 then ("global", parts.[0])
-                    else (String.Join(".", parts, 0, parts.Length - 1), parts.[parts.Length - 1])
-                let generateGetObject = not (_targetFramework.StartsWith("netstandard1.") || _targetFramework.StartsWith("netcoreapp1."))
+
+                    if parts.Length = 1 then
+                        ("global", parts.[0])
+                    else
+                        (String.Join(".", parts, 0, parts.Length - 1), parts.[parts.Length - 1])
+
+                let generateGetObject =
+                    not (
+                        _targetFramework.StartsWith("netstandard1.")
+                        || _targetFramework.StartsWith("netcoreapp1.")
+                    )
+
                 printMessage (sprintf "Generating code for target framework %s" _targetFramework)
-                let sb = StringBuilder().AppendLine(String.Format(boilerplate, namespaceName, moduleName, justFileName))
-                if generateGetObject then sb.AppendLine(boilerplateGetObject) |> ignore
+
+                let sb =
+                    StringBuilder()
+                        .AppendLine(String.Format(boilerplate, namespaceName, moduleName, justFileName))
+
+                if generateGetObject then
+                    sb.AppendLine(boilerplateGetObject) |> ignore
+
                 printMessage <| sprintf "Generating: %s" sourcePath
+
                 let body =
                     let xname = XName.op_Implicit
+
                     XDocument.Load(resx).Descendants(xname "data")
-                    |> Seq.fold (fun (sb:StringBuilder) (node:XElement) ->
-                        let name =
-                            match node.Attribute(xname "name") with
-                            | null -> failwith (sprintf "Missing resource name on element '%s'" (node.ToString()))
-                            | attr -> attr.Value
-                        let docComment =
-                            match node.Elements(xname "value").FirstOrDefault() with
-                            | null -> failwith <| sprintf "Missing resource value for '%s'" name
-                            | element -> element.Value.Trim()
-                        let identifier = if Char.IsLetter(name.[0]) || name.[0] = '_' then name else "_" + name
-                        let commentBody =
-                            XElement(xname "summary", docComment).ToString().Split([|"\r\n"; "\r"; "\n"|], StringSplitOptions.None)
-                            |> Array.fold (fun (sb:StringBuilder) line -> sb.AppendLine("    /// " + line)) (StringBuilder())
-                        // add the resource
-                        let accessorBody =
-                            match (generateLegacy, generateLiteral) with
-                            | (true, true) -> sprintf "    [<Literal>]\n    let %s = \"%s\"" identifier name
-                            | (true, false) -> sprintf "    let %s = \"%s\"" identifier name // the [<Literal>] attribute can't be used for FSharp.Core
-                            | (false, _) ->
-                                let isStringResource = node.Attribute(xname "type") |> isNull
-                                match (isStringResource, generateGetObject) with
-                                | (true, _) -> sprintf "    let %s() = GetString(\"%s\")" identifier name
-                                | (false, true) -> sprintf "    let %s() = GetObject(\"%s\")" identifier name
-                                | (false, false) -> "" // the target runtime doesn't support non-string resources
-                                // TODO: When calling the `GetObject` version, parse the `type` attribute to discover the proper return type
-                        sb.AppendLine().Append(commentBody).AppendLine(accessorBody)
-                    ) sb
+                    |> Seq.fold
+                        (fun (sb: StringBuilder) (node: XElement) ->
+                            let name =
+                                match node.Attribute(xname "name") with
+                                | null -> failwith (sprintf "Missing resource name on element '%s'" (node.ToString()))
+                                | attr -> attr.Value
+
+                            let docComment =
+                                match node.Elements(xname "value").FirstOrDefault() with
+                                | null -> failwith <| sprintf "Missing resource value for '%s'" name
+                                | element -> element.Value.Trim()
+
+                            let identifier =
+                                if Char.IsLetter(name.[0]) || name.[0] = '_' then
+                                    name
+                                else
+                                    "_" + name
+
+                            let commentBody =
+                                XElement(xname "summary", docComment)
+                                    .ToString()
+                                    .Split([| "\r\n"; "\r"; "\n" |], StringSplitOptions.None)
+                                |> Array.fold
+                                    (fun (sb: StringBuilder) line -> sb.AppendLine("    /// " + line))
+                                    (StringBuilder())
+                            // add the resource
+                            let accessorBody =
+                                match (generateLegacy, generateLiteral) with
+                                | (true, true) -> sprintf "    [<Literal>]\n    let %s = \"%s\"" identifier name
+                                | (true, false) -> sprintf "    let %s = \"%s\"" identifier name // the [<Literal>] attribute can't be used for FSharp.Core
+                                | (false, _) ->
+                                    let isStringResource = node.Attribute(xname "type") |> isNull
+
+                                    match (isStringResource, generateGetObject) with
+                                    | (true, _) -> sprintf "    let %s() = GetString(\"%s\")" identifier name
+                                    | (false, true) -> sprintf "    let %s() = GetObject(\"%s\")" identifier name
+                                    | (false, false) -> "" // the target runtime doesn't support non-string resources
+                            // TODO: When calling the `GetObject` version, parse the `type` attribute to discover the proper return type
+                            sb.AppendLine().Append(commentBody).AppendLine(accessorBody))
+                        sb
+
                 File.WriteAllText(sourcePath, body.ToString())
                 printMessage <| sprintf "Done: %s" sourcePath
                 Some(sourcePath)
-        with e ->
+        with
+        | e ->
             printf "An exception occurred when processing '%s'\n%s" resx (e.ToString())
             None
 
     [<Required>]
     member _.EmbeddedResource
-        with get() = _embeddedText
-         and set(value) = _embeddedText <- value
+        with get () = _embeddedText
+        and set (value) = _embeddedText <- value
 
     [<Required>]
     member _.IntermediateOutputPath
-        with get() = _outputPath
-         and set(value) = _outputPath <- value
+        with get () = _outputPath
+        and set (value) = _outputPath <- value
 
     member _.TargetFramework
-        with get() = _targetFramework
-         and set(value) = _targetFramework <- value
+        with get () = _targetFramework
+        and set (value) = _targetFramework <- value
 
     [<Output>]
-    member _.GeneratedSource
-        with get() = _generatedSource
+    member _.GeneratedSource = _generatedSource
 
     interface ITask with
         member _.BuildEngine
-            with get() = _buildEngine
-             and set(value) = _buildEngine <- value
+            with get () = _buildEngine
+            and set (value) = _buildEngine <- value
 
         member _.HostObject
-            with get() = _hostObject
-             and set(value) = _hostObject <- value
+            with get () = _hostObject
+            and set (value) = _hostObject <- value
 
         member this.Execute() =
-            let getBooleanMetadata (metadataName:string) (defaultValue:bool) (item:ITaskItem) =
+            let getBooleanMetadata (metadataName: string) (defaultValue: bool) (item: ITaskItem) =
                 match item.GetMetadata(metadataName) with
                 | value when String.IsNullOrWhiteSpace(value) -> defaultValue
                 | value ->
@@ -128,19 +160,26 @@ module internal {1} =
                     | "true" -> true
                     | "false" -> false
                     | _ -> failwith (sprintf "Expected boolean value for '%s' found '%s'" metadataName value)
+
             let mutable success = true
+
             let generatedSource =
-                [| for item in this.EmbeddedResource do
-                    if getBooleanMetadata "GenerateSource" false item then
-                        let moduleName =
-                            match item.GetMetadata("GeneratedModuleName") with
-                            | null | "" -> Path.GetFileNameWithoutExtension(item.ItemSpec)
-                            | value -> value
-                        let generateLegacy = getBooleanMetadata "GenerateLegacyCode" false item
-                        let generateLiteral = getBooleanMetadata "GenerateLiterals" true item
-                        match generateSource item.ItemSpec moduleName generateLegacy generateLiteral with
-                        | Some (source) -> yield TaskItem(source) :> ITaskItem
-                        | None -> success <- false
+                [|
+                    for item in this.EmbeddedResource do
+                        if getBooleanMetadata "GenerateSource" false item then
+                            let moduleName =
+                                match item.GetMetadata("GeneratedModuleName") with
+                                | null
+                                | "" -> Path.GetFileNameWithoutExtension(item.ItemSpec)
+                                | value -> value
+
+                            let generateLegacy = getBooleanMetadata "GenerateLegacyCode" false item
+                            let generateLiteral = getBooleanMetadata "GenerateLiterals" true item
+
+                            match generateSource item.ItemSpec moduleName generateLegacy generateLiteral with
+                            | Some (source) -> yield TaskItem(source) :> ITaskItem
+                            | None -> success <- false
                 |]
+
             _generatedSource <- generatedSource
             success
diff --git a/src/FSharp.Build/FSharpEmbedResourceText.fs b/src/FSharp.Build/FSharpEmbedResourceText.fs
index f43fef77a43c335e331ab1299ddf9881d7879a0d..eb1907187a872a5352ebbe9c821d551d80e42304 100644
--- a/src/FSharp.Build/FSharpEmbedResourceText.fs
+++ b/src/FSharp.Build/FSharpEmbedResourceText.fs
@@ -14,10 +14,10 @@ type FSharpEmbedResourceText() =
     let mutable _generatedResx: ITaskItem[] = [||]
     let mutable _outputPath: string = ""
 
-    let PrintErr(fileName, line, msg) =
+    let PrintErr (fileName, line, msg) =
         printfn "%s(%d): error : %s" fileName line msg
 
-    let Err(fileName, line, msg) =
+    let Err (fileName, line, msg) =
         PrintErr(fileName, line, msg)
         printfn "Note that the syntax of each line is one of these three alternatives:"
         printfn "# comment"
@@ -25,7 +25,8 @@ type FSharpEmbedResourceText() =
         printfn "errNum,ident,\"string\""
         failwith (sprintf "there were errors in the file '%s'" fileName)
 
-    let xmlBoilerPlateString = @"<?xml version=""1.0"" encoding=""utf-8""?>
+    let xmlBoilerPlateString =
+        @"<?xml version=""1.0"" encoding=""utf-8""?>
 <root>
     <!--
     Microsoft ResX Schema
@@ -147,87 +148,123 @@ type FSharpEmbedResourceText() =
 </root>"
 
     // The kinds of 'holes' we can do
-    let ComputeHoles fileName lineNum (txt:string) : ResizeArray<string> * string =
+    let ComputeHoles fileName lineNum (txt: string) : ResizeArray<string> * string =
         // takes in a %d%s kind of string, returns array of string and {0}{1} kind of string
         let mutable i = 0
         let mutable holeNumber = 0
-        let mutable holes = ResizeArray()  //  order
+        let mutable holes = ResizeArray() //  order
         let sb = new System.Text.StringBuilder()
+
         let AddHole holeType =
             match holeType with
             | "System.UInt32" -> sb.Append(sprintf "{%d:x}" holeNumber) |> ignore
             | _ -> sb.Append(sprintf "{%d}" holeNumber) |> ignore
+
             holeNumber <- holeNumber + 1
             holes.Add(holeType)
+
         while i < txt.Length do
             if txt.[i] = '%' then
-                if i+1 = txt.Length then
+                if i + 1 = txt.Length then
                     Err(fileName, lineNum, "(at end of string) % must be followed by d, x, f, s, or %")
                 else
-                    match txt.[i+1] with
+                    match txt.[i + 1] with
                     | 'd' -> AddHole "System.Int32"
                     | 'x' -> AddHole "System.UInt32"
                     | 'X' -> AddHole "System.UInt32"
                     | 'f' -> AddHole "System.Double"
                     | 's' -> AddHole "System.String"
                     | '%' -> sb.Append('%') |> ignore
-                    | c -> Err(fileName, lineNum, sprintf "'%%%c' is not a valid sequence, only %%d %%x %%X %%f %%s or %%%%" c)
+                    | c ->
+                        Err(
+                            fileName,
+                            lineNum,
+                            sprintf "'%%%c' is not a valid sequence, only %%d %%x %%X %%f %%s or %%%%" c
+                        )
+
                 i <- i + 2
             else
                 match txt.[i] with
                 | '{' -> sb.Append "{{" |> ignore
                 | '}' -> sb.Append "}}" |> ignore
                 | c -> sb.Append c |> ignore
+
                 i <- i + 1
         //printfn "holes.Length = %d, lineNum = %d" holes.Length //lineNum txt
         (holes, sb.ToString())
 
     let Unquote (s: string) =
-        if s.StartsWith "\"" && s.EndsWith "\"" then s.Substring(1, s.Length - 2)
-        else failwith "error message string should be quoted"
+        if s.StartsWith "\"" && s.EndsWith "\"" then
+            s.Substring(1, s.Length - 2)
+        else
+            failwith "error message string should be quoted"
 
-    let ParseLine fileName lineNum (txt:string) =
+    let ParseLine fileName lineNum (txt: string) =
         let mutable errNum = None
         let identB = new System.Text.StringBuilder()
         let mutable i = 0
         // parse optional error number
         if i < txt.Length && System.Char.IsDigit txt.[i] then
             let numB = new System.Text.StringBuilder()
+
             while i < txt.Length && System.Char.IsDigit txt.[i] do
                 numB.Append txt.[i] |> ignore
                 i <- i + 1
+
             errNum <- Some(int (numB.ToString()))
+
             if i = txt.Length || txt.[i] <> ',' then
                 Err(fileName, lineNum, sprintf "After the error number '%d' there should be a comma" errNum.Value)
             // Skip the comma
             i <- i + 1
         // parse short identifier
-        if i < txt.Length && not(System.Char.IsLetter(txt.[i])) then
-            Err(fileName, lineNum, sprintf "The first character in the short identifier should be a letter, but found '%c'" txt.[i])
+        if i < txt.Length && not (System.Char.IsLetter(txt.[i])) then
+            Err(
+                fileName,
+                lineNum,
+                sprintf "The first character in the short identifier should be a letter, but found '%c'" txt.[i]
+            )
+
         while i < txt.Length && System.Char.IsLetterOrDigit txt.[i] do
             identB.Append txt.[i] |> ignore
             i <- i + 1
+
         let ident = identB.ToString()
+
         if ident.Length = 0 then
             Err(fileName, lineNum, "Did not find the short identifier")
+        else if i = txt.Length || txt.[i] <> ',' then
+            Err(fileName, lineNum, sprintf "After the identifier '%s' there should be a comma" ident)
         else
-            if i = txt.Length || txt.[i] <> ',' then
-                Err(fileName, lineNum, sprintf "After the identifier '%s' there should be a comma" ident)
+            // Skip the comma
+            i <- i + 1
+
+            if i = txt.Length then
+                Err(
+                    fileName,
+                    lineNum,
+                    sprintf "After the identifier '%s' and comma, there should be the quoted string resource" ident
+                )
             else
-                // Skip the comma
-                i <- i + 1
-                if i = txt.Length then
-                    Err(fileName, lineNum, sprintf "After the identifier '%s' and comma, there should be the quoted string resource" ident)
-                else
-                    let str =
-                        try
-                            System.String.Format(Unquote(txt.Substring i))  // Format turns e.g '\n' into that char, but also requires that we 'escape' curlies in the original .txt file, e.g. "{{"
-                        with
-                            e -> Err(fileName, lineNum, sprintf "Error calling System.String.Format (note that curly braces must be escaped, and there cannot be trailing space on the line): >>>%s<<< -- %s" (txt.Substring i) e.Message)
-                    let holes, netFormatString = ComputeHoles fileName lineNum str
-                    (lineNum, (errNum,ident), str, holes.ToArray(), netFormatString)
-
-    let stringBoilerPlatePrefix = @"
+                let str =
+                    try
+                        System.String.Format(Unquote(txt.Substring i)) // Format turns e.g '\n' into that char, but also requires that we 'escape' curlies in the original .txt file, e.g. "{{"
+                    with
+                    | e ->
+                        Err(
+                            fileName,
+                            lineNum,
+                            sprintf
+                                "Error calling System.String.Format (note that curly braces must be escaped, and there cannot be trailing space on the line): >>>%s<<< -- %s"
+                                (txt.Substring i)
+                                e.Message
+                        )
+
+                let holes, netFormatString = ComputeHoles fileName lineNum str
+                (lineNum, (errNum, ident), str, holes.ToArray(), netFormatString)
+
+    let stringBoilerPlatePrefix =
+        @"
 open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators
 open Microsoft.FSharp.Reflection
 open System.Reflection
@@ -238,14 +275,18 @@ open Microsoft.FSharp.Text
 open Microsoft.FSharp.Collections
 open Printf
 "
-    let StringBoilerPlate fileName = @"
+
+    let StringBoilerPlate fileName =
+        @"
     // BEGIN BOILERPLATE
 
     static let getCurrentAssembly () = System.Reflection.Assembly.GetExecutingAssembly()
 
     static let getTypeInfo (t: System.Type) = t
 
-    static let resources = lazy (new System.Resources.ResourceManager(""" + fileName + @""", getCurrentAssembly()))
+    static let resources = lazy (new System.Resources.ResourceManager("""
+        + fileName
+        + @""", getCurrentAssembly()))
 
     static let GetString(name:string) =
         let s = resources.Value.GetString(name, System.Globalization.CultureInfo.CurrentUICulture)
@@ -332,150 +373,235 @@ open Printf
     // END BOILERPLATE
 "
 
-    let generateResxAndSource (fileName:string) =
+    let generateResxAndSource (fileName: string) =
         try
-          let printMessage message = printfn "FSharpEmbedResourceText: %s" message
-          let justFileName = Path.GetFileNameWithoutExtension(fileName) // .txt
-          if justFileName |> Seq.exists (System.Char.IsLetterOrDigit >> not) then
-              Err(fileName, 0, sprintf "The file name '%s' is not allowed; only letters and digits can be used, as the file name also becomes the namespace for the SR class" justFileName)
-          let outFileName = Path.Combine(_outputPath, justFileName + ".fs")
-          let outXmlFileName = Path.Combine(_outputPath, justFileName + ".resx")
-
-          let condition1 = File.Exists(outFileName)
-          let condition2 = condition1 && File.Exists(outXmlFileName)
-          let condition3 = condition2 && File.Exists(fileName)
-          let condition4 = condition3 && (File.GetLastWriteTimeUtc(fileName) <= File.GetLastWriteTimeUtc(outFileName))
-          let condition5 = condition4 && (File.GetLastWriteTimeUtc(fileName) <= File.GetLastWriteTimeUtc(outXmlFileName) )
-          if condition5 then
-            printMessage (sprintf "Skipping generation of %s and %s from %s since up-to-date" outFileName outXmlFileName fileName)
-            Some (fileName, outFileName, outXmlFileName)
-          else
-            printMessage (sprintf "Generating %s and %s from %s, because condition %d is false, see FSharpEmbedResourceText.fs in the F# source"  outFileName outXmlFileName fileName (if not condition1 then 1 elif not condition2 then 2 elif not condition3 then 3 elif not condition4 then 4 else 5) )
-
-            printMessage (sprintf "Reading %s" fileName)
-            let lines = File.ReadAllLines(fileName)
-                        |> Array.mapi (fun i s -> i,s) // keep line numbers
-                        |> Array.filter (fun (i,s) -> not(s.StartsWith "#"))  // filter out comments
-
-            printMessage (sprintf "Parsing %s" fileName)
-            let stringInfos = lines |> Array.map (fun (i,s) -> ParseLine fileName i s)
-            // now we have array of (lineNum, ident, str, holes, netFormatString)  // str has %d, netFormatString has {0}
-
-            printMessage (sprintf "Validating %s" fileName)
-            // validate that all the idents are unique
-            let allIdents = new System.Collections.Generic.Dictionary<string,int>()
-            for (line,(_,ident),_,_,_) in stringInfos do
-                if allIdents.ContainsKey(ident) then
-                    Err(fileName,line,sprintf "Identifier '%s' is already used previously on line %d - each identifier must be unique" ident allIdents.[ident])
-                allIdents.Add(ident,line)
-
-            printMessage (sprintf "Validating uniqueness of %s" fileName)
-            // validate that all the strings themselves are unique
-            let allStrs = new System.Collections.Generic.Dictionary<string,(int*string)>()
-            for (line,(_,ident),str,_,_) in stringInfos do
-                if allStrs.ContainsKey(str) then
-                    let prevLine,prevIdent = allStrs.[str]
-                    Err(fileName,line,sprintf "String '%s' already appears on line %d with identifier '%s' - each string must be unique" str prevLine prevIdent)
-                allStrs.Add(str,(line,ident))
-
-            printMessage (sprintf "Generating %s" outFileName)
-            use outStream = File.Create outFileName
-            use out = new StreamWriter(outStream)
-            fprintfn out "// This is a generated file; the original input is '%s'" fileName
-            fprintfn out "namespace %s" justFileName
-            fprintfn out "%s" stringBoilerPlatePrefix
-            fprintfn out "type internal SR private() ="
-            let theResourceName = justFileName
-            fprintfn out "%s" (StringBoilerPlate theResourceName)
-
-            printMessage (sprintf "Generating resource methods for %s" outFileName)
-            // gen each resource method
-            stringInfos |> Seq.iter (fun (lineNum, (optErrNum,ident), str, holes, netFormatString) ->
-                let formalArgs = new System.Text.StringBuilder()
-                let actualArgs = new System.Text.StringBuilder()
-                let mutable firstTime = true
-                let mutable n = 0
-                formalArgs.Append "(" |> ignore
-                for hole in holes do
-                    if firstTime then
-                        firstTime <- false
-                    else
-                        formalArgs.Append ", " |> ignore
-                        actualArgs.Append " " |> ignore
-                    formalArgs.Append(sprintf "a%d : %s" n hole) |> ignore
-                    actualArgs.Append(sprintf "a%d" n) |> ignore
-                    n <- n + 1
-                formalArgs.Append ")" |> ignore
-                fprintfn out "    /// %s" str
-                fprintfn out "    /// (Originally from %s:%d)" fileName (lineNum+1)
-                let justPercentsFromFormatString =
-                    (holes |> Array.fold (fun acc holeType ->
-                        acc + match holeType with
-                                | "System.Int32" -> ",,,%d"
-                                | "System.UInt32" -> ",,,%x"
-                                | "System.Double" -> ",,,%f"
-                                | "System.String" -> ",,,%s"
-                                | _ -> failwith "unreachable") "") + ",,,"
-                let errPrefix = match optErrNum with
-                                | None -> ""
-                                | Some n -> sprintf "%d, " n
-                fprintfn out "    static member %s%s = (%sGetStringFunc(\"%s\",\"%s\") %s)" ident (formalArgs.ToString()) errPrefix ident justPercentsFromFormatString (actualArgs.ToString())
+            let printMessage message =
+                printfn "FSharpEmbedResourceText: %s" message
+
+            let justFileName = Path.GetFileNameWithoutExtension(fileName) // .txt
+
+            if justFileName |> Seq.exists (System.Char.IsLetterOrDigit >> not) then
+                Err(
+                    fileName,
+                    0,
+                    sprintf
+                        "The file name '%s' is not allowed; only letters and digits can be used, as the file name also becomes the namespace for the SR class"
+                        justFileName
                 )
 
-            printMessage (sprintf "Generating .resx for %s" outFileName)
-            fprintfn out ""
-            // gen validation method
-            fprintfn out "    /// Call this method once to validate that all known resources are valid; throws if not"
-            fprintfn out "    static member RunStartupValidation() ="
-            stringInfos |> Seq.iter (fun (lineNum, (optErrNum,ident), str, holes, netFormatString) ->
-                fprintfn out "        ignore(GetString(\"%s\"))" ident
-            )
-            fprintfn out "        ()"  // in case there are 0 strings, we need the generated code to parse
-            // gen to resx
-            let xd = new System.Xml.XmlDocument()
-            xd.LoadXml(xmlBoilerPlateString)
-            stringInfos |> Seq.iter (fun (lineNum, (optErrNum,ident), str, holes, netFormatString) ->
-                let xn = xd.CreateElement("data")
-                xn.SetAttribute("name",ident) |> ignore
-                xn.SetAttribute("xml:space","preserve") |> ignore
-                let xnc = xd.CreateElement "value"
-                xn.AppendChild xnc |> ignore
-                xnc.AppendChild(xd.CreateTextNode netFormatString) |> ignore
-                xd.LastChild.AppendChild xn |> ignore
-            )
-            use outXmlStream = File.Create outXmlFileName
-            xd.Save outXmlStream
-            printMessage (sprintf "Done %s" outFileName)
-            Some (fileName, outFileName, outXmlFileName)
-        with e ->
+            let outFileName = Path.Combine(_outputPath, justFileName + ".fs")
+            let outXmlFileName = Path.Combine(_outputPath, justFileName + ".resx")
+
+            let condition1 = File.Exists(outFileName)
+            let condition2 = condition1 && File.Exists(outXmlFileName)
+            let condition3 = condition2 && File.Exists(fileName)
+
+            let condition4 =
+                condition3
+                && (File.GetLastWriteTimeUtc(fileName) <= File.GetLastWriteTimeUtc(outFileName))
+
+            let condition5 =
+                condition4
+                && (File.GetLastWriteTimeUtc(fileName) <= File.GetLastWriteTimeUtc(outXmlFileName))
+
+            if condition5 then
+                printMessage (
+                    sprintf
+                        "Skipping generation of %s and %s from %s since up-to-date"
+                        outFileName
+                        outXmlFileName
+                        fileName
+                )
+
+                Some(fileName, outFileName, outXmlFileName)
+            else
+                printMessage (
+                    sprintf
+                        "Generating %s and %s from %s, because condition %d is false, see FSharpEmbedResourceText.fs in the F# source"
+                        outFileName
+                        outXmlFileName
+                        fileName
+                        (if not condition1 then 1
+                         elif not condition2 then 2
+                         elif not condition3 then 3
+                         elif not condition4 then 4
+                         else 5)
+                )
+
+                printMessage (sprintf "Reading %s" fileName)
+
+                let lines =
+                    File.ReadAllLines(fileName)
+                    |> Array.mapi (fun i s -> i, s) // keep line numbers
+                    |> Array.filter (fun (i, s) -> not (s.StartsWith "#")) // filter out comments
+
+                printMessage (sprintf "Parsing %s" fileName)
+                let stringInfos = lines |> Array.map (fun (i, s) -> ParseLine fileName i s)
+                // now we have array of (lineNum, ident, str, holes, netFormatString)  // str has %d, netFormatString has {0}
+
+                printMessage (sprintf "Validating %s" fileName)
+                // validate that all the idents are unique
+                let allIdents = new System.Collections.Generic.Dictionary<string, int>()
+
+                for (line, (_, ident), _, _, _) in stringInfos do
+                    if allIdents.ContainsKey(ident) then
+                        Err(
+                            fileName,
+                            line,
+                            sprintf
+                                "Identifier '%s' is already used previously on line %d - each identifier must be unique"
+                                ident
+                                allIdents.[ident]
+                        )
+
+                    allIdents.Add(ident, line)
+
+                printMessage (sprintf "Validating uniqueness of %s" fileName)
+                // validate that all the strings themselves are unique
+                let allStrs = new System.Collections.Generic.Dictionary<string, (int * string)>()
+
+                for (line, (_, ident), str, _, _) in stringInfos do
+                    if allStrs.ContainsKey(str) then
+                        let prevLine, prevIdent = allStrs.[str]
+
+                        Err(
+                            fileName,
+                            line,
+                            sprintf
+                                "String '%s' already appears on line %d with identifier '%s' - each string must be unique"
+                                str
+                                prevLine
+                                prevIdent
+                        )
+
+                    allStrs.Add(str, (line, ident))
+
+                printMessage (sprintf "Generating %s" outFileName)
+                use outStream = File.Create outFileName
+                use out = new StreamWriter(outStream)
+                fprintfn out "// This is a generated file; the original input is '%s'" fileName
+                fprintfn out "namespace %s" justFileName
+                fprintfn out "%s" stringBoilerPlatePrefix
+                fprintfn out "type internal SR private() ="
+                let theResourceName = justFileName
+                fprintfn out "%s" (StringBoilerPlate theResourceName)
+
+                printMessage (sprintf "Generating resource methods for %s" outFileName)
+                // gen each resource method
+                stringInfos
+                |> Seq.iter (fun (lineNum, (optErrNum, ident), str, holes, netFormatString) ->
+                    let formalArgs = new System.Text.StringBuilder()
+                    let actualArgs = new System.Text.StringBuilder()
+                    let mutable firstTime = true
+                    let mutable n = 0
+                    formalArgs.Append "(" |> ignore
+
+                    for hole in holes do
+                        if firstTime then
+                            firstTime <- false
+                        else
+                            formalArgs.Append ", " |> ignore
+                            actualArgs.Append " " |> ignore
+
+                        formalArgs.Append(sprintf "a%d : %s" n hole) |> ignore
+                        actualArgs.Append(sprintf "a%d" n) |> ignore
+                        n <- n + 1
+
+                    formalArgs.Append ")" |> ignore
+                    fprintfn out "    /// %s" str
+                    fprintfn out "    /// (Originally from %s:%d)" fileName (lineNum + 1)
+
+                    let justPercentsFromFormatString =
+                        (holes
+                         |> Array.fold
+                             (fun acc holeType ->
+                                 acc
+                                 + match holeType with
+                                   | "System.Int32" -> ",,,%d"
+                                   | "System.UInt32" -> ",,,%x"
+                                   | "System.Double" -> ",,,%f"
+                                   | "System.String" -> ",,,%s"
+                                   | _ -> failwith "unreachable")
+                             "")
+                        + ",,,"
+
+                    let errPrefix =
+                        match optErrNum with
+                        | None -> ""
+                        | Some n -> sprintf "%d, " n
+
+                    fprintfn
+                        out
+                        "    static member %s%s = (%sGetStringFunc(\"%s\",\"%s\") %s)"
+                        ident
+                        (formalArgs.ToString())
+                        errPrefix
+                        ident
+                        justPercentsFromFormatString
+                        (actualArgs.ToString()))
+
+                printMessage (sprintf "Generating .resx for %s" outFileName)
+                fprintfn out ""
+                // gen validation method
+                fprintfn
+                    out
+                    "    /// Call this method once to validate that all known resources are valid; throws if not"
+
+                fprintfn out "    static member RunStartupValidation() ="
+
+                stringInfos
+                |> Seq.iter (fun (lineNum, (optErrNum, ident), str, holes, netFormatString) ->
+                    fprintfn out "        ignore(GetString(\"%s\"))" ident)
+
+                fprintfn out "        ()" // in case there are 0 strings, we need the generated code to parse
+                // gen to resx
+                let xd = new System.Xml.XmlDocument()
+                xd.LoadXml(xmlBoilerPlateString)
+
+                stringInfos
+                |> Seq.iter (fun (lineNum, (optErrNum, ident), str, holes, netFormatString) ->
+                    let xn = xd.CreateElement("data")
+                    xn.SetAttribute("name", ident) |> ignore
+                    xn.SetAttribute("xml:space", "preserve") |> ignore
+                    let xnc = xd.CreateElement "value"
+                    xn.AppendChild xnc |> ignore
+                    xnc.AppendChild(xd.CreateTextNode netFormatString) |> ignore
+                    xd.LastChild.AppendChild xn |> ignore)
+
+                use outXmlStream = File.Create outXmlFileName
+                xd.Save outXmlStream
+                printMessage (sprintf "Done %s" outFileName)
+                Some(fileName, outFileName, outXmlFileName)
+        with
+        | e ->
             PrintErr(fileName, 0, sprintf "An exception occurred when processing '%s'\n%s" fileName (e.ToString()))
             None
 
     [<Required>]
     member _.EmbeddedText
-        with get() = _embeddedText
-         and set(value) = _embeddedText <- value
+        with get () = _embeddedText
+        and set (value) = _embeddedText <- value
 
     [<Required>]
     member _.IntermediateOutputPath
-        with get() = _outputPath
-         and set(value) = _outputPath <- value
+        with get () = _outputPath
+        and set (value) = _outputPath <- value
 
     [<Output>]
-    member _.GeneratedSource
-        with get() = _generatedSource
+    member _.GeneratedSource = _generatedSource
 
     [<Output>]
-    member _.GeneratedResx
-        with get() = _generatedResx
+    member _.GeneratedResx = _generatedResx
 
     interface ITask with
         member _.BuildEngine
-            with get() = _buildEngine
-             and set(value) = _buildEngine <- value
+            with get () = _buildEngine
+            and set (value) = _buildEngine <- value
+
         member _.HostObject
-            with get() = _hostObject
-             and set(value) = _hostObject <- value
+            with get () = _hostObject
+            and set (value) = _hostObject <- value
+
         member this.Execute() =
 
             let generatedFiles =
@@ -483,20 +609,24 @@ open Printf
                 |> Array.choose (fun item -> generateResxAndSource item.ItemSpec)
 
             let generatedSource, generatedResx =
-                [| for (textFile, source, resx) in generatedFiles do
-                    let sourceItem =
-                        let item = TaskItem(source)
-                        item.SetMetadata("AutoGen", "true")
-                        item.SetMetadata("DesignTime", "true")
-                        item.SetMetadata("DependentUpon", resx)
-                        item :> ITaskItem
-                    let resxItem =
-                        let item = TaskItem(resx)
-                        item.SetMetadata("ManifestResourceName", Path.GetFileNameWithoutExtension(resx))
-                        item.SetMetadata("SourceDocumentPath", textFile)
-                        item :> ITaskItem
-                    yield (sourceItem, resxItem) |]
-                 |> Array.unzip
+                [|
+                    for (textFile, source, resx) in generatedFiles do
+                        let sourceItem =
+                            let item = TaskItem(source)
+                            item.SetMetadata("AutoGen", "true")
+                            item.SetMetadata("DesignTime", "true")
+                            item.SetMetadata("DependentUpon", resx)
+                            item :> ITaskItem
+
+                        let resxItem =
+                            let item = TaskItem(resx)
+                            item.SetMetadata("ManifestResourceName", Path.GetFileNameWithoutExtension(resx))
+                            item.SetMetadata("SourceDocumentPath", textFile)
+                            item :> ITaskItem
+
+                        yield (sourceItem, resxItem)
+                |]
+                |> Array.unzip
 
             let generatedResult = (generatedFiles.Length = this.EmbeddedText.Length)
 
diff --git a/src/FSharp.Build/Fsc.fs b/src/FSharp.Build/Fsc.fs
index 3e5e6a8937d0266545048fb022a925ec39307234..76447c2f9614916ad063fb530b734c6496640c65 100644
--- a/src/FSharp.Build/Fsc.fs
+++ b/src/FSharp.Build/Fsc.fs
@@ -16,17 +16,17 @@ open Internal.Utilities
 //The goal is to have the most common/important flags available via the Fsc class, and the
 //rest can be "backdoored" through the .OtherFlags property.
 
-type public Fsc () as this = 
+type public Fsc() as this =
 
-    inherit ToolTask ()
+    inherit ToolTask()
 
     let mutable baseAddress: string MaybeNull = null
-    let mutable capturedArguments: string list = []  // list of individual args, to pass to HostObject Compile()
-    let mutable capturedFilenames: string list = []  // list of individual source filenames, to pass to HostObject Compile()
+    let mutable capturedArguments: string list = [] // list of individual args, to pass to HostObject Compile()
+    let mutable capturedFilenames: string list = [] // list of individual source filenames, to pass to HostObject Compile()
     let mutable checksumAlgorithm: string MaybeNull = null
     let mutable codePage: string MaybeNull = null
     let mutable commandLineArgs: ITaskItem list = []
-    let mutable compilerTools: ITaskItem [] = [||]
+    let mutable compilerTools: ITaskItem[] = [||]
     let mutable debugSymbols = false
     let mutable debugType: string MaybeNull = null
     let mutable defineConstants: ITaskItem[] = [||]
@@ -42,7 +42,7 @@ type public Fsc () as this =
     let mutable keyFile: string MaybeNull = null
     let mutable langVersion: string MaybeNull = null
     let mutable noFramework = false
-    let mutable optimize : bool = true
+    let mutable optimize: bool = true
     let mutable otherFlags: string MaybeNull = null
     let mutable outputAssembly: string MaybeNull = null
     let mutable pathMap: string MaybeNull = null
@@ -55,7 +55,7 @@ type public Fsc () as this =
     let mutable references: ITaskItem[] = [||]
     let mutable referencePath: string MaybeNull = null
     let mutable resources: ITaskItem[] = [||]
-    let mutable skipCompilerExecution: bool  = false
+    let mutable skipCompilerExecution: bool = false
     let mutable sources: ITaskItem[] = [||]
     let mutable sourceLink: string MaybeNull = null
     let mutable subsystemVersion: string MaybeNull = null
@@ -63,13 +63,18 @@ type public Fsc () as this =
     let mutable targetProfile: string MaybeNull = null
     let mutable targetType: string MaybeNull = null
     let mutable toolExe: string = "fsc.exe"
+
     let defaultToolPath =
         let locationOfThisDll =
-            try Some(Path.GetDirectoryName(typeof<Fsc>.Assembly.Location))
-            with _ -> None
+            try
+                Some(Path.GetDirectoryName(typeof<Fsc>.Assembly.Location))
+            with
+            | _ -> None
+
         match FSharpEnvironment.BinFolderOfDefaultFSharpCompiler(locationOfThisDll) with
         | Some s -> s
         | None -> ""
+
     let mutable treatWarningsAsErrors: bool = false
     let mutable useStandardResourceNames: bool = false
     let mutable warningsAsErrors: string MaybeNull = null
@@ -86,12 +91,17 @@ type public Fsc () as this =
 
     /// Trim whitespace ... spaces, tabs, newlines,returns, Double quotes and single quotes
     let wsCharsToTrim = [| ' '; '\t'; '\"'; '\'' |]
+
     let splitAndWsTrim (s: string MaybeNull) =
         match s with
         | Null -> [||]
         | NonNull s ->
-            let array = s.Split([| ';'; ','; '\r'; '\n' |], StringSplitOptions.RemoveEmptyEntries)
-            array |> Array.map(fun item -> item.Trim(wsCharsToTrim)) |> Array.filter(fun s -> not (String.IsNullOrEmpty s))
+            let array =
+                s.Split([| ';'; ','; '\r'; '\n' |], StringSplitOptions.RemoveEmptyEntries)
+
+            array
+            |> Array.map (fun item -> item.Trim(wsCharsToTrim))
+            |> Array.filter (fun s -> not (String.IsNullOrEmpty s))
 
     // See bug 6483; this makes parallel build faster, and is fine to set unconditionally
     do this.YieldDuringToolExecution <- true
@@ -110,17 +120,19 @@ type public Fsc () as this =
             builder.AppendSwitch("-g")
 
         // DebugType
-        builder.AppendSwitchIfNotNull("--debug:",
-            match debugType with 
+        builder.AppendSwitchIfNotNull(
+            "--debug:",
+            match debugType with
             | Null -> null
-            | NonNull debugType -> 
+            | NonNull debugType ->
                 match debugType.ToUpperInvariant() with
-                | "NONE"     -> null
+                | "NONE" -> null
                 | "PORTABLE" -> "portable"
-                | "PDBONLY"  -> "pdbonly"
+                | "PDBONLY" -> "pdbonly"
                 | "EMBEDDED" -> "embedded"
-                | "FULL"     -> "full"
-                | _          -> null)
+                | "FULL" -> "full"
+                | _ -> null
+        )
 
         if embedAllSources then
             builder.AppendSwitch("--embed+")
@@ -151,8 +163,12 @@ type public Fsc () as this =
 
         // KeyFile
         builder.AppendSwitchIfNotNull("--keyfile:", keyFile)
-        if delaySign then builder.AppendSwitch("--delaysign+")
-        if publicSign then builder.AppendSwitch("--publicsign+")
+
+        if delaySign then
+            builder.AppendSwitch("--delaysign+")
+
+        if publicSign then
+            builder.AppendSwitch("--publicsign+")
 
         // Optimize
         if optimize then
@@ -166,32 +182,48 @@ type public Fsc () as this =
 
         // PdbFile
         builder.AppendSwitchIfNotNull("--pdb:", pdbFile)
-// Platform
-        builder.AppendSwitchIfNotNull("--platform:",
+        // Platform
+        builder.AppendSwitchIfNotNull(
+            "--platform:",
 
             let ToUpperInvariant (s: string MaybeNull) =
-                match s with Null -> null | NonNull s -> s.ToUpperInvariant()
+                match s with
+                | Null -> null
+                | NonNull s -> s.ToUpperInvariant()
 
             match ToUpperInvariant(platform), prefer32bit, ToUpperInvariant(targetType) with
-                | "ANYCPU", true, "EXE"
-                | "ANYCPU", true, "WINEXE" -> "anycpu32bitpreferred"
-                | "ANYCPU",  _, _  -> "anycpu"
-                | "X86",  _, _  -> "x86"
-                | "X64",  _, _  -> "x64"
-                | _ -> null)
+            | "ANYCPU", true, "EXE"
+            | "ANYCPU", true, "WINEXE" -> "anycpu32bitpreferred"
+            | "ANYCPU", _, _ -> "anycpu"
+            | "X86", _, _ -> "x86"
+            | "X64", _, _ -> "x64"
+            | _ -> null
+        )
 
         // checksumAlgorithm
-        builder.AppendSwitchIfNotNull("--checksumalgorithm:",
-            let ToUpperInvariant (s:string) = if s = null then null else s.ToUpperInvariant()
+        builder.AppendSwitchIfNotNull(
+            "--checksumalgorithm:",
+            let ToUpperInvariant (s: string) =
+                if s = null then
+                    null
+                else
+                    s.ToUpperInvariant()
+
             match ToUpperInvariant(checksumAlgorithm) with
-                | "SHA1" -> "Sha1"
-                | "SHA256" -> "Sha256"
-                | _ -> null)
+            | "SHA1" -> "Sha1"
+            | "SHA256" -> "Sha256"
+            | _ -> null
+        )
 
         // Resources
         for item in resources do
             match useStandardResourceNames with
-            | true -> builder.AppendSwitchIfNotNull("--resource:", item.ItemSpec, [|item.GetMetadata("LogicalName"); item.GetMetadata("Access")|])
+            | true ->
+                builder.AppendSwitchIfNotNull(
+                    "--resource:",
+                    item.ItemSpec,
+                    [| item.GetMetadata("LogicalName"); item.GetMetadata("Access") |]
+                )
             | false -> builder.AppendSwitchIfNotNull("--resource:", item.ItemSpec)
 
         // VersionFile
@@ -208,20 +240,22 @@ type public Fsc () as this =
         builder.AppendSwitchesIfNotNull("--lib:", referencePath |> splitAndWsTrim, ",")
 
         // TargetType
-        builder.AppendSwitchIfNotNull("--target:", 
-            match targetType with 
+        builder.AppendSwitchIfNotNull(
+            "--target:",
+            match targetType with
             | Null -> null
-            | NonNull targetType -> 
+            | NonNull targetType ->
                 match targetType.ToUpperInvariant() with
                 | "LIBRARY" -> "library"
                 | "EXE" -> "exe"
-                | "WINEXE" -> "winexe" 
+                | "WINEXE" -> "winexe"
                 | "MODULE" -> "module"
-                | _ -> null)
+                | _ -> null
+        )
 
         // NoWarn
         builder.AppendSwitchesIfNotNull("--nowarn:", disabledWarnings |> splitAndWsTrim, ",")
-        
+
         // WarningLevel
         builder.AppendSwitchIfNotNull("--warn:", warningLevel)
 
@@ -265,6 +299,7 @@ type public Fsc () as this =
         builder.AppendSwitch("--flaterrors")
 
         builder.AppendSwitchIfNotNull("--subsystemversion:", subsystemVersion)
+
         if highEntropyVA then
             builder.AppendSwitch("--highentropyva+")
         else
@@ -273,8 +308,8 @@ type public Fsc () as this =
         builder.AppendSwitchIfNotNull("--targetprofile:", targetProfile)
 
         builder.AppendSwitch("--nocopyfsharpcore")
-        
-        builder.AppendSwitchesIfNotNull("--pathmap:", pathMap |> splitAndWsTrim, ",")   
+
+        builder.AppendSwitchesIfNotNull("--pathmap:", pathMap |> splitAndWsTrim, ",")
 
         if deterministic then
             builder.AppendSwitch("--deterministic+")
@@ -291,134 +326,134 @@ type public Fsc () as this =
 
     // --baseaddress
     member _.BaseAddress
-        with get() = baseAddress 
-        and set(s) = baseAddress <- s
+        with get () = baseAddress
+        and set (s) = baseAddress <- s
 
     // --checksumalgorithm
     member _.ChecksumAlgorithm
-        with get() = checksumAlgorithm 
-        and set(s) = checksumAlgorithm <- s
+        with get () = checksumAlgorithm
+        and set (s) = checksumAlgorithm <- s
 
     // --codepage <int>: Specify the codepage to use when opening source files
     member _.CodePage
-        with get() = codePage
-        and set(s) = codePage <- s
+        with get () = codePage
+        and set (s) = codePage <- s
 
     // -r <string>: Reference an F# or .NET assembly.
     member _.CompilerTools
-        with get() = compilerTools
-        and set(a) = compilerTools <- a
+        with get () = compilerTools
+        and set (a) = compilerTools <- a
 
     // -g: Produce debug file. Disables optimizations if a -O flag is not given.
     member _.DebugSymbols
-        with get() = debugSymbols
-        and set(b) = debugSymbols <- b
+        with get () = debugSymbols
+        and set (b) = debugSymbols <- b
 
     // --debug <none/portable/embedded/pdbonly/full>: Emit debugging information
     member _.DebugType
-        with get() = debugType
-        and set(s) = debugType <- s
+        with get () = debugType
+        and set (s) = debugType <- s
 
-    member _.Deterministic 
-        with get() = deterministic
-        and set(p) = deterministic <- p
+    member _.Deterministic
+        with get () = deterministic
+        and set (p) = deterministic <- p
 
     member _.DelaySign
-        with get() = delaySign
-        and set(s) = delaySign <- s
+        with get () = delaySign
+        and set (s) = delaySign <- s
 
     // --nowarn <string>: Do not report the given specific warning.
     member _.DisabledWarnings
-        with get() = disabledWarnings
-        and set(a) = disabledWarnings <- a
+        with get () = disabledWarnings
+        and set (a) = disabledWarnings <- a
 
     // --define <string>: Define the given conditional compilation symbol.
     member _.DefineConstants
-        with get() = defineConstants
-        and set(a) = defineConstants <- a
+        with get () = defineConstants
+        and set (a) = defineConstants <- a
 
     // --doc <string>: Write the xmldoc of the assembly to the given file.
     member _.DocumentationFile
-        with get() = documentationFile
-        and set(s) = documentationFile <- s
+        with get () = documentationFile
+        and set (s) = documentationFile <- s
 
-    member _.DotnetFscCompilerPath  
-        with get() = dotnetFscCompilerPath
-        and set(p) = dotnetFscCompilerPath <- p
+    member _.DotnetFscCompilerPath
+        with get () = dotnetFscCompilerPath
+        and set (p) = dotnetFscCompilerPath <- p
 
     member _.EmbedAllSources
-        with get() = embedAllSources
-        and  set(s) = embedAllSources <- s
+        with get () = embedAllSources
+        and set (s) = embedAllSources <- s
 
     member _.Embed
-        with get() = embeddedFiles
-        and set(e) = embeddedFiles <- e
+        with get () = embeddedFiles
+        and set (e) = embeddedFiles <- e
 
     member _.EmbeddedFiles
-        with get() = embeddedFiles
-        and set(e) = embeddedFiles <- e
+        with get () = embeddedFiles
+        and set (e) = embeddedFiles <- e
 
-    // --generate-interface-file <string>: 
+    // --generate-interface-file <string>:
     //     Print the inferred interface of the
     //     assembly to a file.
 
     member _.GenerateInterfaceFile
-        with get() = generateInterfaceFile
-        and set(s) = generateInterfaceFile <- s
+        with get () = generateInterfaceFile
+        and set (s) = generateInterfaceFile <- s
 
-    // --keyfile <string>: 
+    // --keyfile <string>:
     //     Sign the assembly the given keypair file, as produced
     //     by the .NET Framework SDK 'sn.exe' tool. This produces
     //     an assembly with a strong name. This is only relevant if producing
     //     an assembly to be shared amongst programs from different
     //     directories, e.g. to be installed in the Global Assembly Cache.
     member _.KeyFile
-        with get() = keyFile
-        and set(s) = keyFile <- s
+        with get () = keyFile
+        and set (s) = keyFile <- s
 
     member _.LangVersion
-        with get() = langVersion
-        and set(s) = langVersion <- s
+        with get () = langVersion
+        and set (s) = langVersion <- s
 
     member _.LCID
-        with get() = vslcid
-        and set(p) = vslcid <- p
+        with get () = vslcid
+        and set (p) = vslcid <- p
 
     // --noframework
     member _.NoFramework
-        with get() = noFramework 
-        and set(b) = noFramework <- b
+        with get () = noFramework
+        and set (b) = noFramework <- b
 
     // --optimize
     member _.Optimize
-        with get() = optimize
-        and set(p) = optimize <- p
+        with get () = optimize
+        and set (p) = optimize <- p
 
     // --tailcalls
     member _.Tailcalls
-        with get() = tailcalls
-        and set(p) = tailcalls <- p
+        with get () = tailcalls
+        and set (p) = tailcalls <- p
 
     // REVIEW: decide whether to keep this, for now is handy way to deal with as-yet-unimplemented features
     member _.OtherFlags
-        with get() = otherFlags
-        and set(s) = otherFlags <- s
+        with get () = otherFlags
+        and set (s) = otherFlags <- s
 
     // -o <string>: Name the output file
     member _.OutputAssembly
-        with get() = outputAssembly
-        and set(s) = outputAssembly <- s
+        with get () = outputAssembly
+        and set (s) = outputAssembly <- s
 
     // --pathmap <string>: Paths to rewrite when producing deterministic builds
     member _.PathMap
-        with get() = pathMap
-        and set(s) = pathMap <- s
+        with get () = pathMap
+        and set (s) = pathMap <- s
 
-    // --pdb <string>: 
+    // --pdb <string>:
     //     Name the debug output file
     member _.PdbFile
-        with get() = pdbFile
-        and set(s) = pdbFile <- s
+        with get () = pdbFile
+        and set (s) = pdbFile <- s
 
     // --platform <string>: Limit which platforms this code can run on:
     //            x86
@@ -426,59 +461,59 @@ type public Fsc () as this =
     //            anycpu
     //            anycpu32bitpreferred
     member _.Platform
-        with get() = platform 
-        and set(s) = platform <- s
+        with get () = platform
+        and set (s) = platform <- s
 
     // indicator whether anycpu32bitpreferred is applicable or not
     member _.Prefer32Bit
-        with get() = prefer32bit 
-        and set(s) = prefer32bit <- s
+        with get () = prefer32bit
+        and set (s) = prefer32bit <- s
 
     member _.PreferredUILang
-        with get() = preferredUILang 
-        and set(s) = preferredUILang <- s
+        with get () = preferredUILang
+        and set (s) = preferredUILang <- s
 
     member _.ProvideCommandLineArgs
-        with get() = provideCommandLineArgs
-        and set(p) = provideCommandLineArgs <- p
+        with get () = provideCommandLineArgs
+        and set (p) = provideCommandLineArgs <- p
 
     member _.PublicSign
-        with get() = publicSign 
-        and set(s) = publicSign <- s
+        with get () = publicSign
+        and set (s) = publicSign <- s
 
     // -r <string>: Reference an F# or .NET assembly.
     member _.References
-        with get() = references
-        and set(a) = references <- a
+        with get () = references
+        and set (a) = references <- a
 
     // --lib
     member _.ReferencePath
-        with get() = referencePath
-        and set(s) = referencePath <- s
+        with get () = referencePath
+        and set (s) = referencePath <- s
 
     // --resource <string>: Embed the specified managed resources (.resource).
     //   Produce .resource files from .resx files using resgen.exe or resxc.exe.
     member _.Resources
-        with get() = resources
-        and set(a) = resources <- a
+        with get () = resources
+        and set (a) = resources <- a
 
     member _.SkipCompilerExecution
-        with get() = skipCompilerExecution
-        and set(p) = skipCompilerExecution <- p
+        with get () = skipCompilerExecution
+        and set (p) = skipCompilerExecution <- p
 
     // SourceLink
-    member _.SourceLink  
-        with get() = sourceLink 
-        and set(s) = sourceLink <- s
+    member _.SourceLink
+        with get () = sourceLink
+        and set (s) = sourceLink <- s
 
-    // source files 
+    // source files
     member _.Sources
-        with get() = sources
-        and set(a) = sources <- a
+        with get () = sources
+        and set (a) = sources <- a
 
     member _.TargetProfile
-        with get() = targetProfile
-        and set(p) = targetProfile <- p
+        with get () = targetProfile
+        and set (p) = targetProfile <- p
 
     // --target exe: Produce an executable with a console
     // --target winexe: Produce an executable which does not have a
@@ -486,94 +521,103 @@ type public Fsc () as this =
     // --target library: Produce a DLL
     // --target module: Produce a module that can be added to another assembly
     member _.TargetType
-        with get() = targetType
-        and set(s) = targetType <- s
+        with get () = targetType
+        and set (s) = targetType <- s
 
     member _.TreatWarningsAsErrors
-        with get() = treatWarningsAsErrors
-        and set(p) = treatWarningsAsErrors <- p
+        with get () = treatWarningsAsErrors
+        and set (p) = treatWarningsAsErrors <- p
 
     // When set to true, generate resource names in the same way as C# with root namespace and folder names
     member _.UseStandardResourceNames
-        with get() = useStandardResourceNames
-        and set(s) = useStandardResourceNames <- s
+        with get () = useStandardResourceNames
+        and set (s) = useStandardResourceNames <- s
 
-    // --version-file <string>: 
+    // --version-file <string>:
     member _.VersionFile
-        with get() = versionFile
-        and set(s) = versionFile <- s
+        with get () = versionFile
+        and set (s) = versionFile <- s
 
     // For specifying a win32 icon file (.ico)
     member _.Win32IconFile
-        with get() = win32icon
-        and set(s) = win32icon <- s
+        with get () = win32icon
+        and set (s) = win32icon <- s
 
     // For specifying a win32 native resource file (.res)
     member _.Win32ResourceFile
-        with get() = win32res
-        and set(s) = win32res <- s
+        with get () = win32res
+        and set (s) = win32res <- s
 
     // For specifying a win32 manifest file
     member _.Win32ManifestFile
-        with get() = win32manifest
-        and set(m) = win32manifest <- m
+        with get () = win32manifest
+        and set (m) = win32manifest <- m
 
     // For specifying the warning level (0-4)
     member _.WarningLevel
-        with get() = warningLevel
-        and set(s) = warningLevel <- s
+        with get () = warningLevel
+        and set (s) = warningLevel <- s
 
-    member _.WarningsAsErrors 
-        with get() = warningsAsErrors
-        and set(s) = warningsAsErrors <- s
+    member _.WarningsAsErrors
+        with get () = warningsAsErrors
+        and set (s) = warningsAsErrors <- s
 
     member _.WarningsNotAsErrors
-        with get() = warningsNotAsErrors
-        and set(s) = warningsNotAsErrors <- s
+        with get () = warningsNotAsErrors
+        and set (s) = warningsNotAsErrors <- s
 
-    member _.WarnOn 
-        with get() = warnOn
-        and set(s) = warnOn <- s
+    member _.WarnOn
+        with get () = warnOn
+        and set (s) = warnOn <- s
 
     member _.VisualStudioStyleErrors
-        with get() = vserrors
-        and set(p) = vserrors <- p
+        with get () = vserrors
+        and set (p) = vserrors <- p
 
     member _.Utf8Output
-        with get() = utf8output
-        and set(p) = utf8output <- p
+        with get () = utf8output
+        and set (p) = utf8output <- p
 
     member _.SubsystemVersion
-        with get() = subsystemVersion
-        and set(p) = subsystemVersion <- p
+        with get () = subsystemVersion
+        and set (p) = subsystemVersion <- p
 
     member _.HighEntropyVA
-        with get() = highEntropyVA
-        and set(p) = highEntropyVA <- p
+        with get () = highEntropyVA
+        and set (p) = highEntropyVA <- p
 
     [<Output>]
     member _.CommandLineArgs
-        with get() = List.toArray commandLineArgs
-        and set(p) = commandLineArgs <- (List.ofArray p)
+        with get () = List.toArray commandLineArgs
+        and set (p) = commandLineArgs <- (List.ofArray p)
 
     // ToolTask methods
-    override _.ToolName = "fsc.exe" 
+    override _.ToolName = "fsc.exe"
 
-    override _.StandardErrorEncoding = if utf8output then System.Text.Encoding.UTF8 else base.StandardErrorEncoding
+    override _.StandardErrorEncoding =
+        if utf8output then
+            System.Text.Encoding.UTF8
+        else
+            base.StandardErrorEncoding
 
-    override _.StandardOutputEncoding = if utf8output then System.Text.Encoding.UTF8 else base.StandardOutputEncoding
+    override _.StandardOutputEncoding =
+        if utf8output then
+            System.Text.Encoding.UTF8
+        else
+            base.StandardOutputEncoding
 
     override fsc.GenerateFullPathToTool() =
         if defaultToolPath = "" then
-            raise (new System.InvalidOperationException(FSBuild.SR.toolpathUnknown()))
+            raise (new System.InvalidOperationException(FSBuild.SR.toolpathUnknown ()))
+
         System.IO.Path.Combine(defaultToolPath, fsc.ToolExe)
 
-    override fsc.LogToolCommand (message:string) =
-        fsc.Log.LogMessageFromText(message, MessageImportance.Normal) |>ignore
+    override fsc.LogToolCommand(message: string) =
+        fsc.Log.LogMessageFromText(message, MessageImportance.Normal) |> ignore
 
-    member internal fsc.InternalGenerateFullPathToTool() = fsc.GenerateFullPathToTool()             // expose for unit testing
+    member internal fsc.InternalGenerateFullPathToTool() = fsc.GenerateFullPathToTool() // expose for unit testing
 
-    member internal _.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) =    // F# does not allow protected members to be captured by lambdas, this is the standard workaround
+    member internal _.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) = // F# does not allow protected members to be captured by lambdas, this is the standard workaround
         base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
 
     /// Intercept the call to ExecuteTool to handle the host compile case.
@@ -588,39 +632,66 @@ type public Fsc () as this =
             0
         else
             let host = box fsc.HostObject
+
             match host with
             | null -> base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
             | _ ->
-                let sources = sources|>Array.map(fun i->i.ItemSpec)
+                let sources = sources |> Array.map (fun i -> i.ItemSpec)
+
                 let invokeCompiler baseCallDelegate =
                     try
                         let ret =
-                            (host.GetType()).InvokeMember("Compile", BindingFlags.Public ||| BindingFlags.NonPublic ||| BindingFlags.InvokeMethod ||| BindingFlags.Instance, null, host,
-                                                        [| baseCallDelegate; box (capturedArguments |> List.toArray); box (capturedFilenames |> List.toArray) |],
-                                                        CultureInfo.InvariantCulture)
+                            (host.GetType())
+                                .InvokeMember(
+                                    "Compile",
+                                    BindingFlags.Public
+                                    ||| BindingFlags.NonPublic
+                                    ||| BindingFlags.InvokeMethod
+                                    ||| BindingFlags.Instance,
+                                    null,
+                                    host,
+                                    [|
+                                        baseCallDelegate
+                                        box (capturedArguments |> List.toArray)
+                                        box (capturedFilenames |> List.toArray)
+                                    |],
+                                    CultureInfo.InvariantCulture
+                                )
+
                         unbox ret
                     with
                     // ok, this is what happens when VS IDE cancels the build, no need to assert, just log the build-canceled error and return -1 to denote task failed
                     // Do a string compare on the type name to do eliminate a compile time dependency on Microsoft.Build.dll
-                    | :? TargetInvocationException as tie when not (isNull tie.InnerException) && (tie.InnerException).GetType().FullName = "Microsoft.Build.Exceptions.BuildAbortedException" ->
-                        fsc.Log.LogError(tie.InnerException.Message, [| |])
+                    | :? TargetInvocationException as tie when
+                        not (isNull tie.InnerException)
+                        && (tie.InnerException).GetType().FullName = "Microsoft.Build.Exceptions.BuildAbortedException"
+                        ->
+                        fsc.Log.LogError(tie.InnerException.Message, [||])
                         -1
-                    | e -> reraise()
+                    | e -> reraise ()
+
+                let baseCallDelegate =
+                    Func<int>(fun () -> fsc.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands))
 
-                let baseCallDelegate = Func<int>(fun () -> fsc.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) )
                 try
                     invokeCompiler baseCallDelegate
                 with
                 | e ->
-                    Debug.Fail("HostObject received by Fsc task did not have a Compile method or the compile method threw an exception. " + (e.ToString()))
-                    reraise()
+                    Debug.Fail(
+                        "HostObject received by Fsc task did not have a Compile method or the compile method threw an exception. "
+                        + (e.ToString())
+                    )
+
+                    reraise ()
 
     override _.GenerateCommandLineCommands() =
         let builder = new FSharpCommandLineBuilder()
+
         match dotnetFscCompilerPath with
-        | Null | "" -> ()
-        | NonNull dotnetFscCompilerPath ->
-            builder.AppendSwitch(dotnetFscCompilerPath)
+        | Null
+        | "" -> ()
+        | NonNull dotnetFscCompilerPath -> builder.AppendSwitch(dotnetFscCompilerPath)
+
         builder.ToString()
 
     override _.GenerateResponseFileCommands() =
@@ -628,17 +699,13 @@ type public Fsc () as this =
         builder.GetCapturedArguments() |> String.concat Environment.NewLine
 
     // expose this to internal components (for nunit testing)
-    member internal fsc.InternalGenerateCommandLineCommands() =
-        fsc.GenerateCommandLineCommands()
+    member internal fsc.InternalGenerateCommandLineCommands() = fsc.GenerateCommandLineCommands()
 
     // expose this to internal components (for nunit testing)
-    member internal fsc.InternalGenerateResponseFileCommands() =
-        fsc.GenerateResponseFileCommands()
+    member internal fsc.InternalGenerateResponseFileCommands() = fsc.GenerateResponseFileCommands()
 
     member internal fsc.InternalExecuteTool(pathToTool, responseFileCommands, commandLineCommands) =
         fsc.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
 
-    member internal fsc.GetCapturedArguments() = [|
-            yield! capturedArguments
-            yield! capturedFilenames
-        |]
+    member internal fsc.GetCapturedArguments() =
+        [| yield! capturedArguments; yield! capturedFilenames |]
diff --git a/src/FSharp.Build/Fsi.fs b/src/FSharp.Build/Fsi.fs
index 8f83a6d0bdc6aad55afa130c0284155cd93a9684..634f92023bd36a04a90206b2d99850d2a4dcfe32 100644
--- a/src/FSharp.Build/Fsi.fs
+++ b/src/FSharp.Build/Fsi.fs
@@ -7,6 +7,7 @@ open System.Diagnostics
 open System.Globalization
 open System.IO
 open System.Reflection
+open System.Text
 open Microsoft.Build.Framework
 open Microsoft.Build.Utilities
 open Internal.Utilities
@@ -16,12 +17,12 @@ open Internal.Utilities
 //The goal is to have the most common/important flags available via the Fsi class, and the
 //rest can be "backdoored" through the .OtherFlags property.
 
-type public Fsi () as this = 
+type public Fsi() as this =
 
-    inherit ToolTask ()
+    inherit ToolTask()
 
-    let mutable capturedArguments: string list = []  // list of individual args, to pass to HostObject Compile()
-    let mutable capturedFilenames: string list = []  // list of individual source filenames, to pass to HostObject Compile()
+    let mutable capturedArguments: string list = [] // list of individual args, to pass to HostObject Compile()
+    let mutable capturedFilenames: string list = [] // list of individual source filenames, to pass to HostObject Compile()
     let mutable codePage: string MaybeNull = null
     let mutable commandLineArgs: ITaskItem list = []
     let mutable defineConstants: ITaskItem[] = [||]
@@ -45,13 +46,18 @@ type public Fsi () as this =
     let mutable targetProfile: string MaybeNull = null
     let mutable targetType: string MaybeNull = null
     let mutable toolExe: string = "fsi.exe"
+
     let mutable toolPath: string =
         let locationOfThisDll =
-            try Some(Path.GetDirectoryName(typeof<Fsi>.Assembly.Location))
-            with _ -> None
+            try
+                Some(Path.GetDirectoryName(typeof<Fsi>.Assembly.Location))
+            with
+            | _ -> None
+
         match FSharpEnvironment.BinFolderOfDefaultFSharpCompiler(locationOfThisDll) with
         | Some s -> s
         | None -> ""
+
     let mutable treatWarningsAsErrors: bool = false
     let mutable warningsAsErrors: string MaybeNull = null
     let mutable warningsNotAsErrors: string MaybeNull = null
@@ -68,13 +74,17 @@ type public Fsi () as this =
         builder.AppendSwitchIfNotNull("--codepage:", codePage)
 
         builder.AppendSwitchIfNotNull("--langversion:", langVersion)
-        if noFramework then builder.AppendSwitch("--noframework")
+
+        if noFramework then
+            builder.AppendSwitch("--noframework")
 
         for item in defineConstants do
             builder.AppendSwitchIfNotNull("--define:", item.ItemSpec)
 
-        if optimize then builder.AppendSwitch("--optimize+")
-        else builder.AppendSwitch("--optimize-")
+        if optimize then
+            builder.AppendSwitch("--optimize+")
+        else
+            builder.AppendSwitch("--optimize-")
 
         if not tailcalls then
             builder.AppendSwitch("--tailcalls-")
@@ -85,29 +95,43 @@ type public Fsi () as this =
         // NoWarn
         match disabledWarnings with
         | Null -> ()
-        | NonNull disabledWarnings -> builder.AppendSwitchesIfNotNull("--nowarn:", disabledWarnings.Split([|' '; ';'; ','; '\r'; '\n'|], StringSplitOptions.RemoveEmptyEntries), ",")
+        | NonNull disabledWarnings ->
+            builder.AppendSwitchesIfNotNull(
+                "--nowarn:",
+                disabledWarnings.Split([| ' '; ';'; ','; '\r'; '\n' |], StringSplitOptions.RemoveEmptyEntries),
+                ","
+            )
 
         builder.AppendSwitchIfNotNull("--warn:", warningLevel)
 
-        if treatWarningsAsErrors then builder.AppendSwitch("--warnaserror")
+        if treatWarningsAsErrors then
+            builder.AppendSwitch("--warnaserror")
 
         // Change warning 76, HashReferenceNotAllowedInNonScript/HashDirectiveNotAllowedInNonScript/HashIncludeNotAllowedInNonScript, into an error
         let warningsAsErrorsArray =
             match warningsAsErrors with
             | Null -> [| "76" |]
-            | NonNull warningsAsErrors -> (warningsAsErrors + " 76 ").Split([|' '; ';'; ','|], StringSplitOptions.RemoveEmptyEntries)
+            | NonNull warningsAsErrors ->
+                (warningsAsErrors + " 76 ")
+                    .Split([| ' '; ';'; ',' |], StringSplitOptions.RemoveEmptyEntries)
 
         builder.AppendSwitchesIfNotNull("--warnaserror:", warningsAsErrorsArray, ",")
 
         match warningsNotAsErrors with
         | Null -> ()
-        | NonNull warningsNotAsErrors -> builder.AppendSwitchesIfNotNull("--warnaserror-:", warningsNotAsErrors.Split([|' '; ';'; ','|], StringSplitOptions.RemoveEmptyEntries), ",")
+        | NonNull warningsNotAsErrors ->
+            builder.AppendSwitchesIfNotNull(
+                "--warnaserror-:",
+                warningsNotAsErrors.Split([| ' '; ';'; ',' |], StringSplitOptions.RemoveEmptyEntries),
+                ","
+            )
 
         builder.AppendSwitchIfNotNull("--LCID:", vslcid)
 
         builder.AppendSwitchIfNotNull("--preferreduilang:", preferredUILang)
 
-        if utf8output then builder.AppendSwitch("--utf8output")
+        if utf8output then
+            builder.AppendSwitch("--utf8output")
 
         builder.AppendSwitch("--fullpaths")
         builder.AppendSwitch("--flaterrors")
@@ -124,7 +148,8 @@ type public Fsi () as this =
         builder.AppendSwitchUnquotedIfNotNull("", otherFlags)
         capturedArguments <- builder.CapturedArguments()
 
-        if fsiExec then builder.AppendSwitch("--exec")
+        if fsiExec then
+            builder.AppendSwitch("--exec")
 
         // Sources - these have to go last
         builder.AppendFileNamesIfNotNull(sources, " ")
@@ -134,143 +159,153 @@ type public Fsi () as this =
 
     // --codepage <int>: Specify the codepage to use when opening source files
     member _.CodePage
-        with get() = codePage
-        and set(s) = codePage <- s
+        with get () = codePage
+        and set value = codePage <- value
 
     // --nowarn <string>: Do not report the given specific warning.
     member _.DisabledWarnings
-        with get() = disabledWarnings
-        and set(a) = disabledWarnings <- a
+        with get () = disabledWarnings
+        and set value = disabledWarnings <- value
 
     // --define <string>: Define the given conditional compilation symbol.
     member _.DefineConstants
-        with get() = defineConstants
-        and set(a) = defineConstants <- a
+        with get () = defineConstants
+        and set value = defineConstants <- value
 
-    member _.DotnetFsiCompilerPath  
-        with get() = dotnetFsiCompilerPath
-        and set(p) = dotnetFsiCompilerPath <- p
+    member _.DotnetFsiCompilerPath
+        with get () = dotnetFsiCompilerPath
+        and set value = dotnetFsiCompilerPath <- value
 
     member _.FsiExec
-        with get() = fsiExec
-        and set(p) = fsiExec <- p
+        with get () = fsiExec
+        and set value = fsiExec <- value
 
     member _.LCID
-        with get() = vslcid
-        and set(p) = vslcid <- p
+        with get () = vslcid
+        and set value = vslcid <- value
 
     member _.LangVersion
-        with get() = langVersion
-        and set(s) = langVersion <- s
+        with get () = langVersion
+        and set value = langVersion <- value
 
     // --noframework
     member _.NoFramework
-        with get() = noFramework 
-        and set(b) = noFramework <- b
+        with get () = noFramework
+        and set (b) = noFramework <- b
 
     // --optimize
     member _.Optimize
-        with get() = optimize
-        and set(p) = optimize <- p
+        with get () = optimize
+        and set value = optimize <- value
 
     // --tailcalls
     member _.Tailcalls
-        with get() = tailcalls
-        and set(p) = tailcalls <- p
+        with get () = tailcalls
+        and set value = tailcalls <- value
 
     member _.OtherFlags
-        with get() = otherFlags
-        and set(s) = otherFlags <- s
+        with get () = otherFlags
+        and set value = otherFlags <- value
 
     member _.PreferredUILang
-        with get() = preferredUILang 
-        and set(s) = preferredUILang <- s
+        with get () = preferredUILang
+        and set value = preferredUILang <- value
 
     member _.ProvideCommandLineArgs
-        with get() = provideCommandLineArgs
-        and set(p) = provideCommandLineArgs <- p
+        with get () = provideCommandLineArgs
+        and set value = provideCommandLineArgs <- value
 
     // -r <string>: Reference an F# or .NET assembly.
     member _.References
-        with get() = references
-        and set(a) = references <- a
+        with get () = references
+        and set value = references <- value
 
     // --lib
     member _.ReferencePath
-        with get() = referencePath
-        and set(s) = referencePath <- s
+        with get () = referencePath
+        and set value = referencePath <- value
 
     // -load:<string>: load an F# source file
     member _.LoadSources
-        with get() = loadSources
-        and set(a) = loadSources <- a
+        with get () = loadSources
+        and set value = loadSources <- value
 
     member _.SkipCompilerExecution
-        with get() = skipCompilerExecution
-        and set(p) = skipCompilerExecution <- p
+        with get () = skipCompilerExecution
+        and set value = skipCompilerExecution <- value
 
-    // source files 
+    // source files
     member _.Sources
-        with get() = sources
-        and set(a) = sources <- a
+        with get () = sources
+        and set value = sources <- value
 
     member _.TargetProfile
-        with get() = targetProfile
-        and set(p) = targetProfile <- p
+        with get () = targetProfile
+        and set value = targetProfile <- value
 
     member _.TreatWarningsAsErrors
-        with get() = treatWarningsAsErrors
-        and set(p) = treatWarningsAsErrors <- p
-        
+        with get () = treatWarningsAsErrors
+        and set value = treatWarningsAsErrors <- value
+
     // For targeting other folders for "fsi.exe" (or ToolExe if different)
     member _.ToolPath
-        with get() = toolPath
-        and set(s) = toolPath <- s
+        with get () = toolPath
+        and set value = toolPath <- value
 
     // --use:<string>: execute an F# source file on startup
     member _.UseSources
-        with get() = useSources
-        and set(a) = useSources <- a
+        with get () = useSources
+        and set value = useSources <- value
 
     // For specifying the warning level (0-4)
     member _.WarningLevel
-        with get() = warningLevel
-        and set(s) = warningLevel <- s
+        with get () = warningLevel
+        and set value = warningLevel <- value
 
-    member _.WarningsAsErrors 
-        with get() = warningsAsErrors
-        and set(s) = warningsAsErrors <- s
+    member _.WarningsAsErrors
+        with get () = warningsAsErrors
+        and set value = warningsAsErrors <- value
 
     member _.WarningsNotAsErrors
-        with get() = warningsNotAsErrors
-        and set(s) = warningsNotAsErrors <- s
+        with get () = warningsNotAsErrors
+        and set value = warningsNotAsErrors <- value
 
     member _.Utf8Output
-        with get() = utf8output
-        and set(p) = utf8output <- p
+        with get () = utf8output
+        and set value = utf8output <- value
 
     [<Output>]
     member _.CommandLineArgs
-        with get() = List.toArray commandLineArgs
-        and set(p) = commandLineArgs <- (List.ofArray p)
+        with get () = List.toArray commandLineArgs
+        and set value = commandLineArgs <- List.ofArray value
 
     // ToolTask methods
-    override _.ToolName = "fsi.exe" 
+    override _.ToolName = "fsi.exe"
 
-    override _.StandardErrorEncoding = if utf8output then System.Text.Encoding.UTF8 else base.StandardErrorEncoding
+    override _.StandardErrorEncoding =
+        if utf8output then
+            Encoding.UTF8
+        else
+            base.StandardErrorEncoding
 
-    override _.StandardOutputEncoding = if utf8output then System.Text.Encoding.UTF8 else base.StandardOutputEncoding
+    override _.StandardOutputEncoding =
+        if utf8output then
+            Encoding.UTF8
+        else
+            base.StandardOutputEncoding
+
+    override fsi.GenerateFullPathToTool() =
+        if toolPath = "" then
+            raise (new System.InvalidOperationException(FSBuild.SR.toolpathUnknown ()))
 
-    override fsi.GenerateFullPathToTool() = 
-        if toolPath = "" then raise (new System.InvalidOperationException(FSBuild.SR.toolpathUnknown()))
         System.IO.Path.Combine(toolPath, fsi.ToolExe)
 
-    override fsi.LogToolCommand (message:string) =
-        fsi.Log.LogMessageFromText(message, MessageImportance.Normal) |>ignore
+    override fsi.LogToolCommand(message: string) =
+        fsi.Log.LogMessageFromText(message, MessageImportance.Normal) |> ignore
 
-    member internal fsi.InternalGenerateFullPathToTool() = fsi.GenerateFullPathToTool()             // expose for unit testing
+    member internal fsi.InternalGenerateFullPathToTool() = fsi.GenerateFullPathToTool() // expose for unit testing
 
-    member internal _.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) =    // F# does not allow protected members to be captured by lambdas, this is the standard workaround
+    member internal _.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) = // F# does not allow protected members to be captured by lambdas, this is the standard workaround
         base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
 
     /// Intercept the call to ExecuteTool to handle the host compile case.
@@ -285,37 +320,65 @@ type public Fsi () as this =
             0
         else
             let host = box fsi.HostObject
+
             match host with
             | null -> base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
             | _ ->
                 let invokeCompiler baseCallDelegate =
                     try
                         let ret =
-                            (host.GetType()).InvokeMember("Compile", BindingFlags.Public ||| BindingFlags.NonPublic ||| BindingFlags.InvokeMethod ||| BindingFlags.Instance, null, host,
-                                                        [| baseCallDelegate; box (capturedArguments |> List.toArray); box (capturedFilenames |> List.toArray) |],
-                                                        CultureInfo.InvariantCulture)
+                            (host.GetType())
+                                .InvokeMember(
+                                    "Compile",
+                                    BindingFlags.Public
+                                    ||| BindingFlags.NonPublic
+                                    ||| BindingFlags.InvokeMethod
+                                    ||| BindingFlags.Instance,
+                                    null,
+                                    host,
+                                    [|
+                                        baseCallDelegate
+                                        box (capturedArguments |> List.toArray)
+                                        box (capturedFilenames |> List.toArray)
+                                    |],
+                                    CultureInfo.InvariantCulture
+                                )
+
                         unbox ret
                     with
                     // ok, this is what happens when VS IDE cancels the build, no need to assert, just log the build-canceled error and return -1 to denote task failed
                     // Do a string compare on the type name to do eliminate a compile time dependency on Microsoft.Build.dll
-                    | :? TargetInvocationException as tie when not (isNull tie.InnerException) && (tie.InnerException).GetType().FullName = "Microsoft.Build.Exceptions.BuildAbortedException" ->
-                        fsi.Log.LogError(tie.InnerException.Message, [| |])
+                    | :? TargetInvocationException as tie when
+                        not (isNull tie.InnerException)
+                        && (tie.InnerException).GetType().FullName = "Microsoft.Build.Exceptions.BuildAbortedException"
+                        ->
+                        fsi.Log.LogError(tie.InnerException.Message, [||])
                         -1
-                    | _ -> reraise()
+                    | _ -> reraise ()
+
+                let baseCallDelegate =
+                    Func<int>(fun () -> fsi.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands))
 
-                let baseCallDelegate = Func<int>(fun () -> fsi.BaseExecuteTool(pathToTool, responseFileCommands, commandLineCommands) )
                 try
                     invokeCompiler baseCallDelegate
-                with e ->
-                    Debug.Assert(false, "HostObject received by Fsi task did not have a Compile method or the compile method threw an exception. "+(e.ToString()))
-                    reraise()
+                with
+                | e ->
+                    Debug.Assert(
+                        false,
+                        "HostObject received by Fsi task did not have a Compile method or the compile method threw an exception. "
+                        + (e.ToString())
+                    )
+
+                    reraise ()
 
     override _.GenerateCommandLineCommands() =
         let builder = new FSharpCommandLineBuilder()
+
         match dotnetFsiCompilerPath with
-        | Null | "" -> ()
-        | NonNull dotnetFsiCompilerPath ->
-            builder.AppendSwitch(dotnetFsiCompilerPath)
+        | Null
+        | "" -> ()
+        | NonNull dotnetFsiCompilerPath -> builder.AppendSwitch(dotnetFsiCompilerPath)
+
         builder.ToString()
 
     override _.GenerateResponseFileCommands() =
@@ -323,17 +386,13 @@ type public Fsi () as this =
         builder.GetCapturedArguments() |> String.concat Environment.NewLine
 
     // expose this to internal components (for nunit testing)
-    member internal fsi.InternalGenerateCommandLineCommands() =
-        fsi.GenerateCommandLineCommands()
+    member internal fsi.InternalGenerateCommandLineCommands() = fsi.GenerateCommandLineCommands()
 
     // expose this to internal components (for nunit testing)
-    member internal fsi.InternalGenerateResponseFileCommands() =
-        fsi.GenerateResponseFileCommands()
+    member internal fsi.InternalGenerateResponseFileCommands() = fsi.GenerateResponseFileCommands()
 
     member internal fsi.InternalExecuteTool(pathToTool, responseFileCommands, commandLineCommands) =
         fsi.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands)
 
-    member internal fsi.GetCapturedArguments() = [|
-            yield! capturedArguments
-            yield! capturedFilenames
-        |]
+    member internal _.GetCapturedArguments() =
+        [| yield! capturedArguments; yield! capturedFilenames |]
diff --git a/src/FSharp.Build/InternalsVisibleTo.fs b/src/FSharp.Build/InternalsVisibleTo.fs
index bb1fe45b30a1ba4974dd338bca45df59d4db03fa..4fac6c0ca80d7112a6618018f74da3786a6a1620 100644
--- a/src/FSharp.Build/InternalsVisibleTo.fs
+++ b/src/FSharp.Build/InternalsVisibleTo.fs
@@ -2,5 +2,5 @@
 
 namespace Microsoft.FSharp
 
-[<assembly:System.Runtime.CompilerServices.InternalsVisibleTo("VisualFSharp.UnitTests, PublicKey=002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293")>]
-do()
+[<assembly: System.Runtime.CompilerServices.InternalsVisibleTo("VisualFSharp.UnitTests, PublicKey=002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293")>]
+do ()
diff --git a/src/FSharp.Build/MapSourceRoots.fs b/src/FSharp.Build/MapSourceRoots.fs
index 5707935d70602c5236bec8def8a5199184516fbd..eb13aecad0bf2ad9f0b4177d900edf1acc184114 100644
--- a/src/FSharp.Build/MapSourceRoots.fs
+++ b/src/FSharp.Build/MapSourceRoots.fs
@@ -22,9 +22,10 @@ module Utilities =
     /// Copied from msbuild. ItemSpecs are normalized using this method.
     /// </summary>
     let FixFilePath (path: string) =
-        if String.IsNullOrEmpty(path) || Path.DirectorySeparatorChar = '\\'
-        then path
-        else path.Replace('\\', '/');
+        if String.IsNullOrEmpty(path) || Path.DirectorySeparatorChar = '\\' then
+            path
+        else
+            path.Replace('\\', '/')
 
 /// <summary>
 /// Given a list of SourceRoot items produces a list of the same items with added <c>MappedPath</c> metadata that
@@ -36,8 +37,8 @@ module Utilities =
 /// The <c>MappedPath</c> is either the path (ItemSpec) itself, when <see cref="Deterministic"/> is false,
 /// or a calculated deterministic source path (starting with prefix '/_/', '/_1/', etc.), otherwise.
 /// </remarks>
-type MapSourceRoots () =
-    inherit Task ()
+type MapSourceRoots() =
+    inherit Task()
 
     static let MappedPath = "MappedPath"
     static let SourceControl = "SourceControl"
@@ -45,6 +46,7 @@ type MapSourceRoots () =
     static let ContainingRoot = "ContainingRoot"
     static let RevisionId = "RevisionId"
     static let SourceLinkUrl = "SourceLinkUrl"
+
     static let knownMetadataNames =
         [
             SourceControl
@@ -55,36 +57,44 @@ type MapSourceRoots () =
             SourceLinkUrl
         ]
 
-    static let (|NullOrEmpty|HasValue|) (s: string) = if String.IsNullOrEmpty s then NullOrEmpty else HasValue s
+    static let (|NullOrEmpty|HasValue|) (s: string) =
+        if String.IsNullOrEmpty s then
+            NullOrEmpty
+        else
+            HasValue s
+
     static let ensureEndsWithSlash (path: string) =
-        if path.EndsWith "/" then path
-        else path + "/"
+        if path.EndsWith "/" then
+            path
+        else
+            path + "/"
 
     static let endsWithDirectorySeparator (path: string) =
-        if path.Length = 0 then false
+        if path.Length = 0 then
+            false
         else
             let endChar = path.[path.Length - 1]
-            endChar = Path.DirectorySeparatorChar || endChar = Path.AltDirectorySeparatorChar
+
+            endChar = Path.DirectorySeparatorChar
+            || endChar = Path.AltDirectorySeparatorChar
 
     static let reportConflictingWellKnownMetadata (log: TaskLoggingHelper) (l: ITaskItem) (r: ITaskItem) =
         for name in knownMetadataNames do
             match l.GetMetadata name, r.GetMetadata name with
             | HasValue lValue, HasValue rValue when lValue <> rValue ->
-                log.LogWarning(FSBuild.SR.mapSourceRootsContainsDuplicate(r.ItemSpec, name, lValue, rValue))
+                log.LogWarning(FSBuild.SR.mapSourceRootsContainsDuplicate (r.ItemSpec, name, lValue, rValue))
             | _, _ -> ()
 
-
-    static member PerformMapping (log: TaskLoggingHelper) (sourceRoots: ITaskItem []) deterministic =
+    static member PerformMapping (log: TaskLoggingHelper) (sourceRoots: ITaskItem[]) deterministic =
         let mappedSourceRoots = ResizeArray<_>()
-        let rootByItemSpec = Dictionary<string, ITaskItem>();
+        let rootByItemSpec = Dictionary<string, ITaskItem>()
 
         for sourceRoot in sourceRoots do
             // The SourceRoot is required to have a trailing directory separator.
             // We do not append one implicitly as we do not know which separator to append on Windows.
             // The usage of SourceRoot might be sensitive to what kind of separator is used (e.g. in SourceLink where it needs
             // to match the corresponding separators used in paths given to the compiler).
-            if not (endsWithDirectorySeparator sourceRoot.ItemSpec)
-            then
+            if not (endsWithDirectorySeparator sourceRoot.ItemSpec) then
                 log.LogError(FSBuild.SR.mapSourceRootsPathMustEndWithSlashOrBackslash sourceRoot.ItemSpec)
 
             match rootByItemSpec.TryGetValue sourceRoot.ItemSpec with
@@ -95,24 +105,24 @@ type MapSourceRoots () =
                 rootByItemSpec.[sourceRoot.ItemSpec] <- sourceRoot
                 mappedSourceRoots.Add sourceRoot
 
-        if log.HasLoggedErrors
-        then None
+        if log.HasLoggedErrors then
+            None
         else
-            if deterministic
-            then
-                let topLevelMappedPaths = Dictionary<_,_>()
+            if deterministic then
+                let topLevelMappedPaths = Dictionary<_, _>()
+
                 let setTopLevelMappedPaths isSourceControlled =
 
                     let mapNestedRootIfEmpty (root: ITaskItem) =
                         let localPath = root.ItemSpec
+
                         match root.GetMetadata NestedRoot with
                         | NullOrEmpty ->
                             // root isn't nested
-                            if topLevelMappedPaths.ContainsKey(localPath)
-                            then
-                                log.LogError(FSBuild.SR.mapSourceRootsContainsDuplicate(localPath, NestedRoot, "", ""));
+                            if topLevelMappedPaths.ContainsKey(localPath) then
+                                log.LogError(FSBuild.SR.mapSourceRootsContainsDuplicate (localPath, NestedRoot, "", ""))
                             else
-                                let index = topLevelMappedPaths.Count;
+                                let index = topLevelMappedPaths.Count
                                 let mappedPath = "/_" + (if index = 0 then "" else string index) + "/"
                                 topLevelMappedPaths.[localPath] <- mappedPath
                                 root.SetMetadata(MappedPath, mappedPath)
@@ -130,8 +140,7 @@ type MapSourceRoots () =
                 // then assign mapped paths to other source-controlled top-level roots:
                 setTopLevelMappedPaths false
 
-                if topLevelMappedPaths.Count = 0
-                then
+                if topLevelMappedPaths.Count = 0 then
                     log.LogError(FSBuild.SR.mapSourceRootsNoTopLevelSourceRoot ())
                 else
                     // finally, calculate mapped paths of nested roots:
@@ -144,18 +153,22 @@ type MapSourceRoots () =
                                 // Since the paths in ItemSpec have backslashes replaced with slashes on non-Windows platforms we need to do the same for ContainingRoot.
                                 match topLevelMappedPaths.TryGetValue(Utilities.FixFilePath(containingRoot)) with
                                 | true, mappedTopLevelPath ->
-                                    root.SetMetadata(MappedPath, mappedTopLevelPath + ensureEndsWithSlash(nestedRoot.Replace('\\', '/')));
+                                    root.SetMetadata(
+                                        MappedPath,
+                                        mappedTopLevelPath + ensureEndsWithSlash (nestedRoot.Replace('\\', '/'))
+                                    )
                                 | false, _ ->
                                     log.LogError(FSBuild.SR.mapSourceRootsNoSuchTopLevelSourceRoot containingRoot)
-                            | NullOrEmpty ->
-                                log.LogError(FSBuild.SR.mapSourceRootsNoSuchTopLevelSourceRoot "")
+                            | NullOrEmpty -> log.LogError(FSBuild.SR.mapSourceRootsNoSuchTopLevelSourceRoot "")
                         | NullOrEmpty -> ()
             else
                 for root in mappedSourceRoots do
                     root.SetMetadata(MappedPath, root.ItemSpec)
 
-            if log.HasLoggedErrors then None else Some (mappedSourceRoots.ToArray())
-
+            if log.HasLoggedErrors then
+                None
+            else
+                Some(mappedSourceRoots.ToArray())
 
     /// <summary>
     /// SourceRoot items with the following optional well-known metadata:
@@ -166,7 +179,7 @@ type MapSourceRoots () =
     /// </list>
     /// </summary>
     [<Required>]
-    member val SourceRoots: ITaskItem[] = [| |] with get, set
+    member val SourceRoots: ITaskItem[] = [||] with get, set
 
     /// <summary>
     /// True if the mapped paths should be deterministic.
@@ -178,12 +191,11 @@ type MapSourceRoots () =
     /// Items listed in <see cref="SourceRoots"/> that have the same ItemSpec will be merged into a single item in this list.
     /// </summary>
     [<Output>]
-    member val MappedSourceRoots: ITaskItem[] = [| |] with get, set
+    member val MappedSourceRoots: ITaskItem[] = [||] with get, set
 
     override this.Execute() =
         match MapSourceRoots.PerformMapping this.Log this.SourceRoots this.Deterministic with
-        | None ->
-            false
+        | None -> false
         | Some mappings ->
             this.MappedSourceRoots <- mappings
-            true
\ No newline at end of file
+            true
diff --git a/src/FSharp.Build/SubstituteText.fs b/src/FSharp.Build/SubstituteText.fs
index 07152f19571a86f8da6795fafc0de3b4e2319c68..c4be2300c0f521adde2399431d4404419b478b5b 100644
--- a/src/FSharp.Build/SubstituteText.fs
+++ b/src/FSharp.Build/SubstituteText.fs
@@ -3,12 +3,10 @@
 namespace FSharp.Build
 
 open System
-open System.Collections
 open System.IO
 open Microsoft.Build.Framework
-open Microsoft.Build.Utilities
 
-type SubstituteText () =
+type SubstituteText() =
 
     let mutable _buildEngine: IBuildEngine MaybeNull = null
     let mutable _hostObject: ITaskHost MaybeNull = null
@@ -18,25 +16,25 @@ type SubstituteText () =
 
     [<Required>]
     member _.EmbeddedResources
-        with get() = embeddedResources
-         and set(value) = embeddedResources <- value
+        with get () = embeddedResources
+        and set (value) = embeddedResources <- value
 
     [<Output>]
-    member _.CopiedFiles
-        with get() = copiedFiles.ToArray()
+    member _.CopiedFiles = copiedFiles.ToArray()
 
     interface ITask with
         member _.BuildEngine
-            with get() = _buildEngine
-             and set(value) = _buildEngine <- value
+            with get () = _buildEngine
+            and set (value) = _buildEngine <- value
 
         member _.HostObject
-            with get() = _hostObject
-             and set(value) = _hostObject <- value
+            with get () = _hostObject
+            and set (value) = _hostObject <- value
 
         member _.Execute() =
             copiedFiles.Clear()
-            if not(isNull embeddedResources) then
+
+            if not (isNull embeddedResources) then
                 for item in embeddedResources do
                     // Update ITaskItem metadata to point to new location
                     let sourcePath = item.GetMetadata("FullPath")
@@ -46,7 +44,7 @@ type SubstituteText () =
 
                     // Is there any replacement to do?
                     if not (String.IsNullOrWhiteSpace(pattern1) && String.IsNullOrWhiteSpace(pattern2)) then
-                        if not(String.IsNullOrWhiteSpace(sourcePath)) then
+                        if not (String.IsNullOrWhiteSpace(sourcePath)) then
                             try
                                 let getTargetPathFrom key =
                                     let md = item.GetMetadata(key)
@@ -56,12 +54,13 @@ type SubstituteText () =
                                     target
 
                                 // Copy from the location specified in Identity
-                                let sourcePath=item.GetMetadata("Identity")
+                                let sourcePath = item.GetMetadata("Identity")
 
                                 // Copy to the location specified in TargetPath unless no TargetPath is provided, then use Identity
-                                let targetPath=
+                                let targetPath =
                                     let identityPath = getTargetPathFrom "Identity"
                                     let intermediateTargetPath = item.GetMetadata("IntermediateTargetPath")
+
                                     if not (String.IsNullOrWhiteSpace(intermediateTargetPath)) then
                                         let fileName = Path.GetFileName(identityPath)
                                         let target = Path.Combine(intermediateTargetPath, fileName)
@@ -73,20 +72,24 @@ type SubstituteText () =
 
                                 // Transform file
                                 let mutable contents = File.ReadAllText(sourcePath)
+
                                 if not (String.IsNullOrWhiteSpace(pattern1)) then
                                     let replacement = item.GetMetadata("Replacement1")
                                     contents <- contents.Replace(pattern1, replacement)
+
                                 if not (String.IsNullOrWhiteSpace(pattern2)) then
                                     let replacement = item.GetMetadata("Replacement2")
                                     contents <- contents.Replace(pattern2, replacement)
 
                                 let directory = Path.GetDirectoryName(targetPath)
-                                if not(Directory.Exists(directory)) then
-                                    Directory.CreateDirectory(directory) |>ignore
+
+                                if not (Directory.Exists(directory)) then
+                                    Directory.CreateDirectory(directory) |> ignore
 
                                 File.WriteAllText(targetPath, contents)
                             with
                             | _ -> ()
 
                     copiedFiles.Add(item)
+
             true
diff --git a/src/FSharp.Build/WriteCodeFragment.fs b/src/FSharp.Build/WriteCodeFragment.fs
index d1a943b8c98278845af9f812318ef5c6da2a7134..7cc80eeafc44f135247fdcd311d0ae4666f48095 100644
--- a/src/FSharp.Build/WriteCodeFragment.fs
+++ b/src/FSharp.Build/WriteCodeFragment.fs
@@ -17,59 +17,81 @@ type WriteCodeFragment() =
     let mutable _language: string = ""
     let mutable _assemblyAttributes: ITaskItem[] = [||]
 
-    static let escapeString (str:string) =
-        let sb = str.ToCharArray() |> Seq.fold (fun (sb:StringBuilder) (c:char) ->
-            match c with
-            | '\n' | '\u2028' | '\u2028' -> sb.Append("\\n")
-            | '\r' -> sb.Append("\\r")
-            | '\t' -> sb.Append("\\t")
-            | '\'' -> sb.Append("\\'")
-            | '\\' -> sb.Append("\\\\")
-            | '"' -> sb.Append("\\\"")
-            | '\u0000' -> sb.Append("\\0")
-            | _ -> sb.Append(c)) (StringBuilder().Append("\""))
+    static let escapeString (str: string) =
+        let sb =
+            str.ToCharArray()
+            |> Seq.fold
+                (fun (sb: StringBuilder) (c: char) ->
+                    match c with
+                    | '\n'
+                    | '\u2028'
+                    | '\u2028' -> sb.Append("\\n")
+                    | '\r' -> sb.Append("\\r")
+                    | '\t' -> sb.Append("\\t")
+                    | '\'' -> sb.Append("\\'")
+                    | '\\' -> sb.Append("\\\\")
+                    | '"' -> sb.Append("\\\"")
+                    | '\u0000' -> sb.Append("\\0")
+                    | _ -> sb.Append(c))
+                (StringBuilder().Append("\""))
+
         sb.Append("\"").ToString()
 
-    static member GenerateAttribute (item:ITaskItem, language:string) =
+    static member GenerateAttribute(item: ITaskItem, language: string) =
         let attributeName = item.ItemSpec
+
         let args =
             // mimicking the behavior from https://github.com/Microsoft/msbuild/blob/70ce7e9ccb891b63f0859f1f7f0b955693ed3742/src/Tasks/WriteCodeFragment.cs#L355-L415
             // Split parameters into unnamed positional (e.g., key is "_Parameter1", etc.) and proper named parameters.
             let customMetadata = item.CloneCustomMetadata()
+
             let parameterPairs =
                 // normalize everything to strings
                 seq { for entry in customMetadata -> entry :?> DictionaryEntry }
                 |> Seq.toList
                 |> List.map (fun entry ->
                     let key = entry.Key :?> string
-                    let value = match entry.Value with
-                                | null -> "null"
-                                | :? string as value -> escapeString value
-                                | value -> value.ToString()
+
+                    let value =
+                        match entry.Value with
+                        | null -> "null"
+                        | :? string as value -> escapeString value
+                        | value -> value.ToString()
+
                     (key, value))
-            let orderedParameters, namedParameters = parameterPairs |> List.partition (fun (key, _) -> key.StartsWith("_Parameter"))
+
+            let orderedParameters, namedParameters =
+                parameterPairs |> List.partition (fun (key, _) -> key.StartsWith("_Parameter"))
+
             let orderedParametersWithIndex =
                 orderedParameters
                 |> List.map (fun (key, value) ->
                     let indexString = key.Substring("_Parameter".Length)
+
                     match Int32.TryParse indexString with
                     | (true, index) -> (index, value)
                     | (false, _) -> failwith (sprintf "Unable to parse '%s' as an index" indexString))
                 |> List.sortBy fst
             // assign ordered parameters to array
             let orderedParametersArray =
-                if List.isEmpty orderedParametersWithIndex then [||]
-                else Array.create (List.last orderedParametersWithIndex |> fst) "null"
+                if List.isEmpty orderedParametersWithIndex then
+                    [||]
+                else
+                    Array.create (List.last orderedParametersWithIndex |> fst) "null"
+
             List.iter (fun (index, value) -> orderedParametersArray.[index - 1] <- value) orderedParametersWithIndex
             // construct ordered parameter lists
             let combinedOrderedParameters = String.Join(", ", orderedParametersArray)
-            let combinedNamedParameters = String.Join(", ", List.map (fun (key, value) -> sprintf "%s = %s" key value) namedParameters)
+
+            let combinedNamedParameters =
+                String.Join(", ", List.map (fun (key, value) -> sprintf "%s = %s" key value) namedParameters)
             // construct the final argument string; positional arguments followed by named
             match (combinedOrderedParameters.Length, combinedNamedParameters.Length) with
             | (0, 0) -> "" // no arguments
             | (0, _) -> combinedNamedParameters // only named arguments
             | (_, 0) -> combinedOrderedParameters // only positional arguments
             | (_, _) -> combinedOrderedParameters + ", " + combinedNamedParameters // both positional and named arguments
+
         match language.ToLowerInvariant() with
         | "f#" -> sprintf "[<assembly: %s(%s)>]" attributeName args
         | "c#" -> sprintf "[assembly: %s(%s)]" attributeName args
@@ -78,64 +100,73 @@ type WriteCodeFragment() =
 
     // adding this property to maintain API equivalence with the MSBuild task
     member _.Language
-        with get() = _language
-         and set(value) = _language <- value
+        with get () = _language
+        and set (value) = _language <- value
 
     member _.AssemblyAttributes
-        with get() = _assemblyAttributes
-         and set(value) = _assemblyAttributes <- value
+        with get () = _assemblyAttributes
+        and set (value) = _assemblyAttributes <- value
 
     member _.OutputDirectory
-        with get() = _outputDirectory
-         and set(value) = _outputDirectory <- value
+        with get () = _outputDirectory
+        and set (value) = _outputDirectory <- value
 
     [<Output>]
     member _.OutputFile
-        with get() = _outputFile
-         and set(value) = _outputFile <- value
-
+        with get () = _outputFile
+        and set (value) = _outputFile <- value
 
     interface ITask with
         member _.BuildEngine
-            with get() = _buildEngine
-             and set(value) = _buildEngine <- value
+            with get () = _buildEngine
+            and set (value) = _buildEngine <- value
 
         member _.HostObject
-            with get() = _hostObject
-             and set(value) = _hostObject <- value
+            with get () = _hostObject
+            and set (value) = _hostObject <- value
 
         member _.Execute() =
             try
-                match _outputFile with 
+                match _outputFile with
                 | Null -> failwith "Output location must be specified"
-                | NonNull outputFile -> 
-                let boilerplate =
-                    match _language.ToLowerInvariant() with
-                    | "f#" -> "// <auto-generated>\n//     Generated by the FSharp WriteCodeFragment class.\n// </auto-generated>\nnamespace FSharp\n\nopen System\nopen System.Reflection\n"
-                    | "c#" -> "// <auto-generated>\n//     Generated by the FSharp WriteCodeFragment class.\n// </auto-generated>\n\nusing System;\nusing System.Reflection;"
-                    | "vb" -> "'------------------------------------------------------------------------------\n' <auto-generated>\n'     Generated by the FSharp WriteCodeFragment class.\n' </auto-generated>\n'------------------------------------------------------------------------------\n\nOption Strict Off\nOption Explicit On\n\nImports System\nImports System.Reflection"
-                    | _ -> failwith "Language name must be one of F#, C# or VB"
-
-                let sb = StringBuilder().AppendLine(boilerplate).AppendLine()
-                let code = Array.fold (fun (sb:StringBuilder) (item:ITaskItem) -> sb.AppendLine(WriteCodeFragment.GenerateAttribute (item, _language.ToLowerInvariant()))) sb _assemblyAttributes
-
-                if _language.ToLowerInvariant() = "f#" then code.AppendLine("do()") |> ignore
-                let fileName = outputFile.ItemSpec
-
-                let outputFileItem =
-                    match _outputDirectory with 
-                    | Null -> outputFile
-                    | NonNull outputDirectory -> 
-                        if Path.IsPathRooted(fileName) then 
-                            outputFile
-                        else
-                            TaskItem(Path.Combine(outputDirectory.ItemSpec, fileName)) :> ITaskItem
-
-                let codeText = code.ToString()
-                File.WriteAllText(fileName, codeText)
-                _outputFile <- outputFileItem
-                true
-
-            with e ->
+                | NonNull outputFile ->
+                    let boilerplate =
+                        match _language.ToLowerInvariant() with
+                        | "f#" ->
+                            "// <auto-generated>\n//     Generated by the FSharp WriteCodeFragment class.\n// </auto-generated>\nnamespace FSharp\n\nopen System\nopen System.Reflection\n"
+                        | "c#" ->
+                            "// <auto-generated>\n//     Generated by the FSharp WriteCodeFragment class.\n// </auto-generated>\n\nusing System;\nusing System.Reflection;"
+                        | "vb" ->
+                            "'------------------------------------------------------------------------------\n' <auto-generated>\n'     Generated by the FSharp WriteCodeFragment class.\n' </auto-generated>\n'------------------------------------------------------------------------------\n\nOption Strict Off\nOption Explicit On\n\nImports System\nImports System.Reflection"
+                        | _ -> failwith "Language name must be one of F#, C# or VB"
+
+                    let sb = StringBuilder().AppendLine(boilerplate).AppendLine()
+
+                    let code =
+                        (sb, _assemblyAttributes)
+                        ||> Array.fold (fun (sb: StringBuilder) (item: ITaskItem) ->
+                            sb.AppendLine(WriteCodeFragment.GenerateAttribute(item, _language.ToLowerInvariant())))
+
+                    if _language.ToLowerInvariant() = "f#" then
+                        code.AppendLine("do()") |> ignore
+
+                    let fileName = outputFile.ItemSpec
+
+                    let outputFileItem =
+                        match _outputDirectory with
+                        | Null -> outputFile
+                        | NonNull outputDirectory ->
+                            if Path.IsPathRooted(fileName) then
+                                outputFile
+                            else
+                                TaskItem(Path.Combine(outputDirectory.ItemSpec, fileName)) :> ITaskItem
+
+                    let codeText = code.ToString()
+                    File.WriteAllText(fileName, codeText)
+                    _outputFile <- outputFileItem
+                    true
+
+            with
+            | e ->
                 printf "Error writing code fragment: %s" (e.ToString())
                 false