Struct LspConfig 

pub struct LspConfig {
    pub program: OsString,
    pub args: Vec<OsString>,
    pub workspace_root: PathBuf,
    pub initialization_options: Option<Value>,
    pub workspace_only: bool,
}

Fields

program: OsString

args: Vec<OsString>

workspace_root: PathBuf

initialization_options: Option<Value>

workspace_only: bool

Implementations

impl LspConfig

pub fn new( program: impl Into<OsString>, workspace_root: impl Into<PathBuf>, ) -> Self

pub fn for_server( program: impl Into<OsString>, workspace_root: impl Into<PathBuf>, ) -> Self

Builds the command line expected by a supported language-server binary.

Most servers enter LSP mode directly. Pyrefly exposes it as the pyrefly lsp subcommand, so callers should use this constructor when the configured value is a server executable rather than a raw command.

Examples found in repository

examples/lsp_workspace_symbols.rs (line 22)

async fn main() -> Result<()> {
    let mut args = env::args_os().skip(1);
    let program = args
        .next()
        .context("usage: lsp_workspace_symbols <SERVER> <QUERY> [WORKSPACE]")?;
    let query = args
        .next()
        .context("usage: lsp_workspace_symbols <SERVER> <QUERY> [WORKSPACE]")?
        .into_string()
        .map_err(|_| anyhow!("query must be valid UTF-8"))?;
    let workspace_root = match args.next() {
        Some(path) => PathBuf::from(path),
        None => env::current_dir().context("failed to determine current directory")?,
    };

    let lsp = LspProvider::start(LspConfig::for_server(program, workspace_root)).await?;
    tokio::time::sleep(Duration::from_secs(2)).await;
    let symbols = lsp.workspace_symbols(&query).await?;

    for symbol in symbols {
        let line = symbol
            .range
            .map(|range| (range.start.line + 1).to_string())
            .unwrap_or_else(|| "?".to_owned());
        println!("{}\t{}:{line}", symbol.name, symbol.uri);
    }

    lsp.shutdown().await
}

examples/lsp_hierarchy.rs (line 59)

async fn main() -> Result<()> {
    let mut args = env::args_os().skip(1);
    let program = args.next().context(
        "usage: lsp_hierarchy <SERVER> <call|type> <incoming|outgoing> <SYMBOL> [WORKSPACE]",
    )?;
    let kind = match utf8_arg(args.next(), "hierarchy kind")?.as_str() {
        "call" => HierarchyKind::Call,
        "type" => HierarchyKind::Type,
        value => bail!("unknown hierarchy kind {value:?}; expected call or type"),
    };
    let direction = match utf8_arg(args.next(), "direction")?.as_str() {
        "incoming" => HierarchyDirection::Incoming,
        "outgoing" => HierarchyDirection::Outgoing,
        value => bail!("unknown direction {value:?}; expected incoming or outgoing"),
    };
    let symbol = utf8_arg(args.next(), "symbol")?;
    let workspace_root = match args.next() {
        Some(path) => PathBuf::from(path),
        None => env::current_dir().context("failed to determine current directory")?,
    };
    let location = match args.next() {
        Some(file) => {
            let file = PathBuf::from(file)
                .canonicalize()
                .context("failed to resolve source file")?;
            let line = utf8_arg(args.next(), "one-based line")?
                .parse::<u32>()
                .context("line must be a positive integer")?;
            let character = utf8_arg(args.next(), "one-based character")?
                .parse::<u32>()
                .context("character must be a positive integer")?;
            if line == 0 || character == 0 {
                bail!("line and character are one-based and must be positive");
            }
            let uri = Url::from_file_path(&file)
                .map_err(|()| anyhow!("source file cannot be represented as a file URI"))?;
            Some(SourceLocation {
                uri: uri.to_string(),
                line: Some(line - 1),
                character: Some(character - 1),
            })
        }
        None => None,
    };

    let lsp = LspProvider::start(LspConfig::for_server(program, workspace_root)).await?;
    tokio::time::sleep(Duration::from_secs(12)).await;
    let response = lsp
        .hierarchy_client()
        .query(HierarchyQuery {
            symbol: SymbolIdentity {
                symbol,
                kind,
                location,
            },
            direction,
        })
        .await;

    let shutdown_result = lsp.shutdown().await;
    let response = response?;
    for child in response.children {
        let location = child.location.map_or_else(
            || "unknown location".to_owned(),
            |location| {
                format!(
                    "{}:{}:{}",
                    location.uri,
                    location.line.unwrap_or(0) + 1,
                    location.character.unwrap_or(0) + 1
                )
            },
        );
        println!("{}\t{location}", child.symbol);
    }
    shutdown_result
}

pub fn arg(self, arg: impl Into<OsString>) -> Self

pub fn args<I, S>(self, args: I) -> Self

where I: IntoIterator<Item = S>, S: Into<OsString>,

pub fn initialization_options(self, options: Value) -> Self

pub fn workspace_only(self, workspace_only: bool) -> Self

Trait Implementations

impl Clone for LspConfig

fn clone(&self) -> LspConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LspConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.