anchor.diff:  
       /// Get the options for a project
       member this.TryGetOptionsForProject(projectId: ProjectId) = 
  -        if projectTable.ContainsKey(projectId) then
  -            Some(projectTable.[projectId])
  -        else
  -            None
  +        match projectTable.TryGetValue(projectId) with
  +        | true, options -> Some options 
  +        | _ -> None
   
       /// Get the exact options for a document or project
       member this.TryGetOptionsForDocumentOrProject(document: Document) = async { 
  
positive.code:             projectContext.AddSourceFile(fileName)
              
              let project = projectContext :?> AbstractProject
              let documentId = project.GetCurrentDocumentFromPath(fileName).Id
  
              let rec onDocumentClosed = EventHandler<DocumentEventArgs> (fun _ args ->
                  if args.Document.Id = documentId then
                      projectInfoManager.RemoveSingleFileProject(projectId)
                      project.Disconnect()
                      workspace.DocumentClosed.RemoveHandler(onDocumentClosed)
              )
              workspace.DocumentClosed.AddHandler(onDocumentClosed)
  
      override this.ContentTypeName = FSharpCommonConstants.FSharpContentTypeName
      override this.LanguageName = FSharpCommonConstants.FSharpLanguageName
  
negative.code:     internal FSharpLanguageService(package : FSharpPackage) =
      inherit AbstractLanguageService<FSharpPackage, FSharpLanguageService>(package)
  
      let projectInfoManager = package.ComponentModel.DefaultExportProvider.GetExport<ProjectInfoManager>().Value
  
      let projectDisplayNameOf projectFileName = 
          if String.IsNullOrWhiteSpace projectFileName then projectFileName
          else Path.GetFileNameWithoutExtension projectFileName
  
      let singleFileProjects = ConcurrentDictionary<_, AbstractProject>()
  
      let tryRemoveSingleFileProject projectId =
          match singleFileProjects.TryRemove(projectId) with
          | true, project ->
              projectInfoManager.RemoveSingleFileProject(projectId)
              project.Disconnect()
          | _ -> ()
  
      override this.Initialize() =
          base.Initialize()
  
          this.Workspace.Options <- this.Workspace.Options.WithChangedOption(Completion.CompletionOptions.BlockForCompletionItems, FSharpCommonConstants.FSharpLanguageName, false)
          this.Workspace.Options <- this.Workspace.Options.WithChangedOption(Shared.Options.ServiceFeatureOnOffOptions.ClosedFileDiagnostic, FSharpCommonConstants.FSharpLanguageName, Nullable false)
  
          this.Workspace.DocumentClosed.Add <| fun args ->
              tryRemoveSingleFileProject args.Document.Project.Id 
              
          Events.SolutionEvents.OnAfterCloseSolution.Add <| fun _ ->
              singleFileProjects.Keys |> Seq.iter tryRemoveSingleFileProject
  
          let ctx = System.Threading.SynchronizationContext.Current
          
          let rec setupProjectsAfterSolutionOpen() =
              async {
                  use openedProjects = MailboxProcessor.Start <| fun inbox ->
                      async { 
                          // waits for AfterOpenSolution and then starts projects setup
                          do! Async.AwaitEvent Events.SolutionEvents.OnAfterOpenSolution |> Async.Ignore
                          while true do
                              let! siteProvider = inbox.Receive()
                              do! Async.SwitchToContext ctx
                              this.SetupProjectFile(siteProvider, this.Workspace) }
  
                  use _ = Events.SolutionEvents.OnAfterOpenProject |> Observable.subscribe ( fun args ->
                      match args.Hierarchy with
                      | :? IProvideProjectSite as siteProvider -> openedProjects.Post(siteProvider)
                      | _ -> () )
  
                  do! Async.AwaitEvent Events.SolutionEvents.OnAfterCloseSolution |> Async.Ignore
                  do! setupProjectsAfterSolutionOpen() 
              }
          setupProjectsAfterSolutionOpen() |> Async.StartImmediate
          
      /// Sync the information for the project 
      member this.SyncProject(project: AbstractProject, projectContext: IWorkspaceProjectContext, site: IProjectSite, forceUpdate) =
        async {
          let hashSetIgnoreCase x = new HashSet<string>(x, StringComparer.OrdinalIgnoreCase)
          let updatedFiles = site.SourceFilesOnDisk() |> hashSetIgnoreCase
          let workspaceFiles = project.GetCurrentDocuments() |> Seq.map(fun file -> file.FilePath) |> hashSetIgnoreCase
  