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:                 with
                  | _ -> false
  
          let get () =
              let config = workspace.getConfiguration().get<string option>(key)
              match config with
              | None
              | Some "" -> None
              | Some ws ->
                  let configured = parseConfiguredWorkspace ws
                  if pathExists configured then
                      Some configured
                  else
                      logger.Warn("Ignoring configured workspace '%s' as the file or directory can't be resolved", ws)
                      None
  
          let private getWorkspacePath (value: ConfiguredWorkspace) =
              match value with
              | ConfiguredWorkspace.Solution path -> path
              | ConfiguredWorkspace.Directory path -> path
  
          let set (value: ConfiguredWorkspace) =
              let configuredPath = getWorkspacePath value
              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)
  
          let setFromPeek (value: WorkspacePeekFound) =
              match value with
  
negative.code:     module private CurrentWorkspaceConfiguration =
          let private key = "FSharp.workspacePath"
  
          let mutable extensionWorkspaceState: Memento option = None
  
          let setContext (context : ExtensionContext) =
              extensionWorkspaceState <- Some context.workspaceState
  
          let private parse (value: string) =
            let fullPath = path.resolve(workspace.rootPath, value)
            if value.ToLowerInvariant().EndsWith(".sln") then
                ConfiguredWorkspace.Solution fullPath
            else
  