anchor.diff:          let rootWarnings = rootWarnings |> List.filter isRootRange
           
           let result : LoadClosure = 
  -            { SourceFiles = List.groupByFirst !sourceFiles
  +            { SourceFiles = List.groupByFirst sourceFiles
                 References = List.groupByFirst references
                 UnresolvedReferences = unresolvedReferences
  -              Inputs = !sourceInputs
  -              NoWarns = List.groupByFirst !globalNoWarns
  +              Inputs = sourceInputs
  +              NoWarns = List.groupByFirst globalNoWarns
                 RootErrors = rootErrors
                 RootWarnings = rootWarnings}       
   
  
positive.code:             let resolvedAsFile = 
                  groupedReferences 
                  |>Array.map(fun (_filename,maxIndexOfReference,references)->
                                  let assemblyResolution = references 
                                                           |> List.map tcConfig.TryResolveLibWithDirectories
                                                           |> List.filter Option.isSome
                                                           |> List.map Option.get
                                  (maxIndexOfReference, assemblyResolution))  
                  |> Array.filter(fun (_,refs)->refs|>List.isEmpty|>not)
                  
  
negative.code:             let tcConfigB = tcConfig.CloneOfOriginalBuilder 
              TcConfig.Create(tcConfigB,validate=false),nowarns
      
      let FindClosureFiles(closureSources,tcConfig:TcConfig,codeContext,lexResourceManager:Lexhelp.LexResourceManager) =
          let tcConfig = ref tcConfig
          
          let observedSources = Observed()
          let rec loop (ClosureSource(filename,m,source,parseRequired)) = 
            [     if not (observedSources.HaveSeen(filename)) then
                      observedSources.SetSeen(filename)
                      //printfn "visiting %s" filename
                      if IsScript(filename) || parseRequired then 
                          let errors = ref []
                          let warnings = ref [] 
                          let errorLogger = 
                                  { new ErrorLogger("FindClosure") with 
                                      member x.ErrorSinkImpl(e) = errors := e :: !errors
                                      member x.WarnSinkImpl(e) = warnings := e :: !warnings
                                      member x.ErrorCount = (!errors).Length }                        
  
                          use _unwindEL = PushErrorLoggerPhaseUntilUnwind (fun _ -> errorLogger)
                          let pathOfMetaCommandSource = Path.GetDirectoryName(filename)
                          match ParseScriptText(filename,source,!tcConfig,codeContext,lexResourceManager,errorLogger) with 
                          | Some parsedScriptAst ->                    
                              let preSources = (!tcConfig).GetAvailableLoadedSources()
  
                              let tcConfigResult, noWarns = ApplyMetaCommandsFromInputToTcConfigAndGatherNoWarn !tcConfig (parsedScriptAst,pathOfMetaCommandSource)
                              tcConfig := tcConfigResult // We accumulate the tcConfig in order to collect assembly references
                          
                              let postSources = (!tcConfig).GetAvailableLoadedSources()
                              let sources = if preSources.Length < postSources.Length then postSources.[preSources.Length..] else []
  
                              //for (_,subFile) in sources do
                              //   printfn "visiting %s - has subsource of %s " filename subFile
  
                              for (m,subFile) in sources do
                                  if IsScript(subFile) then 
                                      for subSource in ClosureSourceOfFilename(subFile,m,tcConfigResult.inputCodePage,false) do
                                          yield! loop subSource
                                  else
                                      yield ClosureFile(subFile, m, None, [], [], []) 
  
                              //printfn "yielding source %s" filename
                              yield ClosureFile(filename, m, Some parsedScriptAst, !errors, !warnings, !noWarns)
  
                          | None -> 
                              //printfn "yielding source %s (failed parse)" filename
                              yield ClosureFile(filename, m, None, !errors, !warnings, [])
                      else 
                          // Don't traverse into .fs leafs.
                          //printfn "yielding non-script source %s" filename
                          yield ClosureFile(filename, m, None, [], [], []) ]
  
          closureSources |> List.map loop |> List.concat, !tcConfig
          
      /// Reduce the full directive closure into LoadClosure
      let GetLoadClosure(rootFilename,closureFiles,tcConfig:TcConfig,codeContext) = 
      
          // Mark the last file as isLastCompiland. 
          let closureFiles =
              match List.frontAndBack closureFiles with
              | rest, ClosureFile(filename,m,Some(ParsedInput.ImplFile(ParsedImplFileInput(name,isScript,qualNameOfFile,scopedPragmas,hashDirectives,implFileFlags,_))),errs,warns,nowarns) -> 
                  rest @ [ClosureFile(filename,m,Some(ParsedInput.ImplFile(ParsedImplFileInput(name,isScript,qualNameOfFile,scopedPragmas,hashDirectives,implFileFlags,(true, tcConfig.target.IsExe)))),errs,warns,nowarns)]
              | _ -> closureFiles
  
          // Get all source files.
          let sourceFiles = [  for (ClosureFile(filename,m,_,_,_,_)) in closureFiles -> (filename,m) ]
          let sourceInputs = [  for (ClosureFile(filename,_,input,_,_,_)) in closureFiles -> (filename,input) ]
          let globalNoWarns = closureFiles |> List.collect (fun (ClosureFile(_,_,_,_,_,noWarns)) -> noWarns)
  
          // Resolve all references.
          let references, unresolvedReferences, resolutionWarnings, resolutionErrors = 
              let resolutionErrors = ref []
              let resolutionWarnings = ref [] 
              let errorLogger = 
                  { new ErrorLogger("GetLoadClosure") with 
                     member x.ErrorSinkImpl(e) = resolutionErrors := e :: !resolutionErrors
                     member x.WarnSinkImpl(e) = resolutionWarnings := e :: !resolutionWarnings
                     member x.ErrorCount = (!resolutionErrors).Length }      
          
              use unwindEL = PushErrorLoggerPhaseUntilUnwind (fun _ -> errorLogger) 
              let references,unresolvedReferences = GetAssemblyResolutionInformation(tcConfig)
              let references =  references |> List.map (fun ar -> ar.resolvedPath,ar)
              references, unresolvedReferences, resolutionWarnings, resolutionErrors
  
          // Root errors and warnings - look at the last item in the closureFiles list
          let rootErrors, rootWarnings = 
              match List.rev closureFiles with
              | ClosureFile(_,_,_,errors,warnings,_) :: _ -> errors @ !resolutionErrors, warnings @ !resolutionWarnings
              | _ -> [],[] // When no file existed.
          
          let isRootRange exn =
  