anchor.diff:          |> Promise.bind (function Some x -> Promise.lift x | None -> getWorkspaceForModeIonideSearch ())
           |> Promise.bind (initWorkspaceHelper parseVisibleTextEditors)
   
  -
       let activate (context : ExtensionContext) parseVisibleTextEditors =
  +        CurrentWorkspaceConfiguration.setContext context
           commands.registerCommand("fsharp.clearCache", clearCache |> unbox<Func<obj,obj>> )
           |> context.subscriptions.Add
   
  
positive.code:     module private CurrentWorkspaceConfiguration =
          let private key = "FSharp.workspacePath"
  
          let private parseConfiguredWorkspace (value: string) =
            let fullPath = path.join(workspace.rootPath, value)
            if value.ToLowerInvariant().EndsWith(".sln") then
                ConfiguredWorkspace.Solution fullPath
            else
  
negative.code:                 with
                  | _ -> false
  
          let private parseAndValidate (config: string option) =
              match config with
              | None
              | Some "" -> None
              | Some ws ->
                  let configured = parse ws
                  if pathExists configured then
                      Some configured
                  else
                      logger.Warn("Ignoring configured workspace '%s' as the file or directory can't be resolved (From '%s')", ws, sprintf "%A" configured)
                      None
  
          let private getStringFromWorkspaceConfig () =
              workspace.getConfiguration().get<string option>(key)
  
          let private getStringFromExtensionState () =
              extensionWorkspaceState.Value.get<string>(key)
  
          let get () =
              match parseAndValidate (getStringFromWorkspaceConfig()) with
              | Some c -> Some c
              | None -> parseAndValidate (getStringFromExtensionState())
  
          let private getWorkspacePath (value: ConfiguredWorkspace) =
              match value with
              | ConfiguredWorkspace.Solution path -> path
              | ConfiguredWorkspace.Directory path -> path
  
          let private isConfiguredInWorkspace () =
              match getStringFromWorkspaceConfig () with
              | None
              | Some "" -> false
              | Some _ -> true
  
          let set (value: ConfiguredWorkspace) =
              let configuredPath = getWorkspacePath value
              if isConfiguredInWorkspace () then
                  let relativePath =
                      let raw = path.relative(workspace.rootPath, configuredPath)
                      if not (path.isAbsolute raw) && not (raw.StartsWith "..") then
                          "./" + raw
                      else
                          raw
  
                  let config = workspace.getConfiguration()
                  config.update(key, relativePath, false)
              else
                  extensionWorkspaceState.Value.update(key, configuredPath)
  
          let setFromPeek (value: WorkspacePeekFound) =
              match value with
  