anchor.diff:      member tcConfig.ResolveSourceFile(m, nm, pathLoadedFrom) = 
           data.ResolveSourceFile(m, nm, pathLoadedFrom)
   
  +    member tcConfig.MsBuildResolve (references, mode, errorAndWarningRange, showMessages) =
  +        let logMessage showMessages = 
  +            if showMessages && tcConfig.showReferenceResolutions then (fun (message: string)->dprintf "%s\n" message)
  +            else ignore
  +
  +        let logDiagnostic showMessages = 
  +            (fun isError code message->
  +                if showMessages && mode = ResolveAssemblyReferenceMode.ReportErrors then 
  +                  if isError then
  +                    errorR(MSBuildReferenceResolutionError(code, message, errorAndWarningRange))
  +                  else
  +                    match code with 
  +                    // These are warnings that mean 'not resolved' for some assembly.
  +                    // Note that we don't get to know the name of the assembly that couldn't be resolved.
  +                    // Ignore these and rely on the logic below to emit an error for each unresolved reference.
  +                    | "MSB3246" // Resolved file has a bad image, no metadata, or is otherwise inaccessible.
  +                    | "MSB3106"  
  +                        -> ()
  +                    | _ -> 
  +                        if code = "MSB3245" then 
  +                            errorR(MSBuildReferenceResolutionWarning(code, message, errorAndWarningRange))
  +                        else
  +                            warning(MSBuildReferenceResolutionWarning(code, message, errorAndWarningRange)))
  +
  +        let targetProcessorArchitecture = 
  +            match tcConfig.platform with
  +            | None -> "MSIL"
  +            | Some X86 -> "x86"
  +            | Some AMD64 -> "amd64"
  +            | Some IA64 -> "ia64"
  + 
  +        try 
  +            tcConfig.legacyReferenceResolver.Resolve
  +               (tcConfig.resolutionEnvironment, 
  +                references, 
  +                tcConfig.targetFrameworkVersion, 
  +                tcConfig.GetTargetFrameworkDirectories(), 
  +                targetProcessorArchitecture, 
  +                tcConfig.fsharpBinariesDir, // FSharp binaries directory
  +                tcConfig.includes, // Explicit include directories
  +                tcConfig.implicitIncludeDir, // Implicit include directory (likely the project directory)
  +                logMessage showMessages, logDiagnostic showMessages)
  +        with 
  +            ReferenceResolver.ResolutionFailure -> error(Error(FSComp.SR.buildAssemblyResolutionFailed(), errorAndWarningRange))
  +
  +
       // NOTE!! if mode=Speculative then this method must not report ANY warnings or errors through 'warning' or 'error'. Instead
       // it must return warnings and errors as data
       //
  
positive.code:                     // When building desktop then we need these additional dependencies
                      yield AssemblyReference(rangeStartup, "System.Numerics.dll", None)
                      yield AssemblyReference(rangeStartup, "System.dll", None)
                      yield AssemblyReference(rangeStartup, "netstandard.dll", None)
  
              if tcConfig.framework then
                  for s in defaultReferencesForScriptsAndOutOfProjectSources tcConfig.useFsiAuxLib assumeDotNetFramework tcConfig.useSdkRefs do
  
negative.code:                 else 
                      // MSBuild resolution may have unified the result of two duplicate references. Try to re-resolve now.
                      // If re-resolution worked then this was a removed duplicate.
                      tcConfig.MsBuildResolve([|originalName, ""|], mode, errorAndWarningRange, (*showMessages*)false).Length<>0 
                      
              let unresolvedReferences =                     
                      groupedReferences 
  