anchor.diff:                  (param "doc" doc) :: compilerArgs
   
           // F# cares about order so assume that the files were listed in order
  -        let compilerArgs = (project.SourceFiles |> List.ofSeq |> List.rev) @ compilerArgs
  -        project.SourceFiles
  -        |> Seq.iter (fun f -> watcher.WatchFile f |> ignore)
  +        let compilerArgs = (sources |> List.ofSeq |> List.rev) @ compilerArgs
   
           // These are the metadata references being used by your project.
           // Everything in your project.json is resolved and normailzed here:
  
positive.code:         // - Package references are turned into the appropriate assemblies
          // - Assembly neutral references
          // Each IMetadaReference maps to an assembly
          let compilerArgs, tempFiles =
              let refs, tempFiles =
                  incomingReferences
                  |> List.ofSeq
                  |> List.map convertRef
                  |> List.unzip
  
              let refs = refs |> List.choose id
              let tempFiles = tempFiles |> List.choose id
  
              let refs =
                  refs
                  |> List.map (fun r -> "-r:" + r)
  
              refs @ compilerArgs, tempFiles
          
          let compilerArgsArr = ("fsc.exe" :: (compilerArgs |> List.rev)) |> Array.ofList
  
          let scs = SimpleSourceCodeServices()
          let errors, exitCode = scs.Compile compilerArgsArr
          tempFiles |> Seq.iter (fun f -> File.Delete f |> ignore)
          Directory.Delete tempBasePath
          let warnings =
              errors
              |> Array.choose (fun e ->
  
negative.code: 
  open System.IO
  open System.Runtime.Versioning
  open Microsoft.Framework.Runtime
  open Microsoft.FSharp.Compiler
  open Microsoft.FSharp.Compiler.SourceCodeServices
  open Microsoft.FSharp.Compiler.SimpleSourceCodeServices
  open Microsoft.FSharp.Compiler.AbstractIL.Internal.Library
  
  module Helpers =
      let inline ni () = raise (new System.NotImplementedException ())
  
  type internal MetadataReference =
  | FileMetadataReference of string
  | ImageMetadataReference of string * byte array
  | ProjectMetadataReference of string * (Stream -> unit)
  with
      member r.VirtPath 
          with get () =
              match r with
              | FileMetadataReference f -> f
              | ImageMetadataReference (p, a) -> p
              | ProjectMetadataReference (p, a) -> p
  
  [<CompilationRepresentationAttribute(CompilationRepresentationFlags.ModuleSuffix)>]
  module internal MetadataReference =
      let virtPath (p: MetadataReference) = p.VirtPath
  
  open Helpers
  module internal Compiler =
      let lock fn =
          let l = new obj ()
          lock l fn
  
      let tprintf fmt = ignore // Printf.ksprintf System.Diagnostics.Trace.Write fmt
      let tprintfn fmt = ignore //Printf.ksprintf System.Diagnostics.Trace.WriteLine fmt
  
      let getReferences (project: Project) targetFramework incomingReferences =
          let name = project.Name
  
          let makePath p = "C:\\" + p + ".dll"
  
          let (|>|) a b =
              a, (b a)
  
          incomingReferences
          |> List.ofSeq
          |> List.choose (fun (r: IMetadataReference) ->
              match r with
              // Skip this project
              | _ when r.Name = (typeof<MetadataReference>.Assembly.GetName ()).Name -> None
                  
              // NuGet references
              | :? IMetadataFileReference as r -> Some (FileMetadataReference r.Path)
  
              // Assembly neutral references
              | :? IMetadataEmbeddedReference as r -> Some (ImageMetadataReference ((makePath r.Name), r.Contents))
  
              // Project references
              | :? IMetadataProjectReference as r -> Some (ProjectMetadataReference ((makePath r.Name), r.EmitReferenceAssembly))
  
              // Other
              | _ -> failwith "Invalid reference type")
          |>| (List.map (fun r -> r.VirtPath, r) >> Map.ofList)
  
      let makeStream = function
          | FileMetadataReference f -> File.OpenRead f :> Stream
          | ImageMetadataReference (p, a) -> new MemoryStream (a) :> Stream
          | ProjectMetadataReference (p, a) -> let ms = new MemoryStream () in a ms; ms :> Stream
  
      let makeByteArray = function
          | FileMetadataReference f -> File.ReadAllBytes f
          | ImageMetadataReference (p, a) -> a
          | ProjectMetadataReference (p, a) -> use ms = new MemoryStream () in a ms; ms.ToArray ()
  
      let makeFs refs =
          let defaultFileSystem = Shim.FileSystem
          { new IFileSystem with
              // Implement the service to open files for reading and writing
              member fs.FileStreamReadShim name =
                  tprintfn "FileStreamReadShim: %s" name
                  match Map.tryFind name refs with
                  | Some s -> makeStream s
                  | _ -> defaultFileSystem.FileStreamReadShim name
  
              member fs.FileStreamCreateShim name =
                  tprintfn "FileStreamCreateShim: %s" name
                  defaultFileSystem.FileStreamCreateShim name
  
              member fs.FileStreamWriteExistingShim name =
                  tprintfn "FileStreamWriteExistingShim: %s" name
                  defaultFileSystem.FileStreamWriteExistingShim name
  
              member fs.ReadAllBytesShim name =
                  tprintfn "ReadAllBytesShim: %s" name
                  match Map.tryFind name refs with
                  | Some s -> makeByteArray s
                  | _ -> defaultFileSystem.ReadAllBytesShim name
  
              // Implement the service related to temporary paths and file time stamps
              member fs.GetTempPathShim () = 
                  tprintfn "GetTempPathShim: ()"
                  defaultFileSystem.GetTempPathShim ()
  
              member fs.GetLastWriteTimeShim name = 
                  tprintfn "GetLastWriteTimeShim: %s" name
                  defaultFileSystem.GetLastWriteTimeShim name
  
              member fs.GetFullPathShim name = 
                  tprintfn "GetFullPathShim: %s" name
                  defaultFileSystem.GetFullPathShim name
  
              member fs.IsInvalidPathShim name = 
                  tprintfn "IsInvalidPathShim: %s" name
                  defaultFileSystem.IsInvalidPathShim name
  
              member fs.IsPathRootedShim name = 
                  tprintfn "IsPathRootedShim: %s" name
                  defaultFileSystem.IsPathRootedShim name
  
              // Implement the service related to file existence and deletion
              member fs.SafeExists name =
                  tprintfn "SafeExists: %s" name
                  Map.containsKey name refs || defaultFileSystem.SafeExists name
  
              member fs.FileDelete name =
                  tprintfn "FileDelete: %s" name
                  defaultFileSystem.FileDelete name
  
              // Implement the service related to assembly loading, used to load type providers
              // and for F# interactive.
              member fs.AssemblyLoadFrom name =
                  tprintfn "AssemblyLoadFrom: %s" name
                  defaultFileSystem.AssemblyLoadFrom name
  
              member fs.AssemblyLoad name =
                  tprintfn "AssemblyLoad: %s" name.FullName
                  defaultFileSystem.AssemblyLoad name
          }
  
      let param name value = sprintf "--%s:%s" name value
  
      let emit name sources refs outputPath emitPdb emitDocFile emitExe inMemory =
          let outExt ext = Path.Combine [|outputPath; name + ext|]
          let outputDll = outExt (if emitExe then ".exe" else ".dll")
  
          let compilerArgs = [(param "out" outputDll); "--target:" + (if emitExe then "exe" else "library"); "--noframework"]
  
          let compilerArgs = 
              match emitPdb with
  