wdl_analysis/

analyzer.rs

//! Implementation of the analyzer.

use std::ffi::OsStr;
use std::fmt;
use std::fmt::Display;
use std::fmt::Formatter;
use std::future::Future;
use std::mem::ManuallyDrop;
use std::ops::Range;
use std::path::Path;
use std::path::PathBuf;
use std::path::absolute;
use std::sync::Arc;
use std::thread::JoinHandle;

use anyhow::Context;
use anyhow::Error;
use anyhow::Result;
use anyhow::anyhow;
use anyhow::bail;
use ignore::WalkBuilder;
use indexmap::IndexSet;
use line_index::LineCol;
use line_index::LineIndex;
use line_index::WideEncoding;
use line_index::WideLineCol;
use lsp_types::CallHierarchyIncomingCall;
use lsp_types::CallHierarchyItem;
use lsp_types::CallHierarchyOutgoingCall;
use lsp_types::CodeLens;
use lsp_types::CompletionResponse;
use lsp_types::DocumentSymbolResponse;
use lsp_types::FoldingRange;
use lsp_types::GotoDefinitionResponse;
use lsp_types::Hover;
use lsp_types::InlayHint;
use lsp_types::Location;
use lsp_types::SemanticTokensResult;
use lsp_types::SignatureHelp;
use lsp_types::SymbolInformation;
use lsp_types::WorkspaceEdit;
use path_clean::PathClean;
use tokio::runtime::Handle;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use url::Url;

use crate::config::Config;
use crate::document::Document;
use crate::graph::DocumentGraphNode;
use crate::graph::ParseState;
use crate::queue::AddRequest;
use crate::queue::AnalysisQueue;
use crate::queue::AnalyzeRequest;
use crate::queue::CallHierarchyRequest;
use crate::queue::CodeLensRequest;
use crate::queue::CompletionRequest;
use crate::queue::DeleteRequest;
use crate::queue::DocumentSymbolRequest;
use crate::queue::FindAllReferencesRequest;
use crate::queue::FoldingRangeRequest;
use crate::queue::FormatRequest;
use crate::queue::GotoDefinitionRequest;
use crate::queue::HoverRequest;
use crate::queue::IncomingCallsRequest;
use crate::queue::InlayHintsRequest;
use crate::queue::NotifyChangeRequest;
use crate::queue::NotifyIncrementalChangeRequest;
use crate::queue::OutgoingCallsRequest;
use crate::queue::RenameRequest;
use crate::queue::Request;
use crate::queue::SemanticTokenRequest;
use crate::queue::SignatureHelpRequest;
use crate::queue::SwapValidatorRequest;
use crate::queue::UnrootDocumentsRequest;
use crate::queue::WorkspaceSymbolRequest;
use crate::rayon::RayonHandle;

/// Represents the kind of analysis progress being reported.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProgressKind {
    /// The progress is for parsing documents.
    Parsing,
    /// The progress is for analyzing documents.
    Analyzing,
}

impl fmt::Display for ProgressKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Parsing => write!(f, "parsing"),
            Self::Analyzing => write!(f, "analyzing"),
        }
    }
}

/// Converts a local file path to a file schemed URI.
pub fn path_to_uri(path: impl AsRef<Path>) -> Option<Url> {
    Url::from_file_path(absolute(path).ok()?.clean()).ok()
}

/// Represents the result of an analysis.
///
/// Analysis results are cheap to clone.
#[derive(Debug, Clone)]
pub struct AnalysisResult {
    /// The error that occurred when attempting to parse the file (e.g. the file
    /// could not be opened).
    error: Option<Arc<Error>>,
    /// The monotonic version of the document that was parsed.
    ///
    /// This value comes from incremental changes to the file.
    ///
    /// If `None`, the parsed version had no incremental changes.
    version: Option<i32>,
    /// The lines indexed for the parsed file.
    lines: Option<Arc<LineIndex>>,
    /// The analyzed document.
    document: Document,
}

impl AnalysisResult {
    /// Constructs a new analysis result for the given graph node.
    pub(crate) fn new(node: &DocumentGraphNode) -> Self {
        if let Some(error) = node.analysis_error() {
            return Self {
                error: Some(error.clone()),
                version: node.parse_state().version(),
                lines: node.parse_state().lines().cloned(),
                document: Document::default_from_uri(node.uri().clone()),
            };
        }

        let (error, version, lines) = match node.parse_state() {
            ParseState::NotParsed => unreachable!("document should have been parsed"),
            ParseState::Error(e) => (Some(e), None, None),
            ParseState::Parsed { version, lines, .. } => (None, *version, Some(lines)),
        };

        Self {
            error: error.cloned(),
            version,
            lines: lines.cloned(),
            document: node
                .document()
                .expect("analysis should have completed")
                .clone(),
        }
    }

    /// Gets the error that occurred when attempting to parse the document.
    ///
    /// An example error would be if the file could not be opened.
    ///
    /// Returns `None` if the document was parsed successfully.
    pub fn error(&self) -> Option<&Arc<Error>> {
        self.error.as_ref()
    }

    /// Gets the incremental version of the parsed document.
    ///
    /// Returns `None` if there was an error parsing the document or if the
    /// parsed document had no incremental changes.
    pub fn version(&self) -> Option<i32> {
        self.version
    }

    /// Gets the line index of the parsed document.
    ///
    /// Returns `None` if there was an error parsing the document.
    pub fn lines(&self) -> Option<&Arc<LineIndex>> {
        self.lines.as_ref()
    }

    /// Gets the analyzed document.
    pub fn document(&self) -> &Document {
        &self.document
    }
}

/// Represents a position in a document's source.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Default)]
pub struct SourcePosition {
    /// Line position in a document (zero-based).
    // NOTE: this field must come before `character` to maintain a correct sort order.
    pub line: u32,
    /// Character offset on a line in a document (zero-based). The meaning of
    /// this offset is determined by the position encoding.
    pub character: u32,
}

impl SourcePosition {
    /// Constructs a new source position from a line and character offset.
    pub fn new(line: u32, character: u32) -> Self {
        Self { line, character }
    }
}

/// Represents the encoding of a source position.
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub enum SourcePositionEncoding {
    /// The position is UTF8 encoded.
    ///
    /// A position's character is the UTF-8 offset from the start of the line.
    UTF8,
    /// The position is UTF16 encoded.
    ///
    /// A position's character is the UTF-16 offset from the start of the line.
    UTF16,
}

/// Represents an edit to a document's source after it has been applied.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AppliedEdit {
    /// The range in the old string that was replaced.
    pub range: Range<usize>,
    /// The length of the new text that replaced it.
    pub replacement_length: usize,
}

/// Represents an edit to a document's source.
#[derive(Debug, Clone)]
pub struct SourceEdit {
    /// The range of the edit.
    range: Range<SourcePosition>,
    /// The encoding of the edit positions.
    encoding: SourcePositionEncoding,
    /// The replacement text.
    text: String,
}

/// Arises when creating [`SourceEdit`]s with invalid [`SourcePosition`] ranges.
#[derive(Debug)]
pub struct RangeError(pub Range<SourcePosition>);

impl Display for RangeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "range `{:?}` has a start bound greater than its end",
            self.0
        )
    }
}

impl std::error::Error for RangeError {}

impl SourceEdit {
    /// Creates a new source edit for the given range and replacement text.
    pub fn new(
        range: Range<SourcePosition>,
        encoding: SourcePositionEncoding,
        text: impl Into<String>,
    ) -> Result<Self, RangeError> {
        if range.start > range.end {
            return Err(RangeError(range));
        }

        Ok(Self {
            range,
            encoding,
            text: text.into(),
        })
    }

    /// Gets the range of the edit.
    pub(crate) fn range(&self) -> Range<SourcePosition> {
        self.range.start..self.range.end
    }

    /// The replacement text.
    pub(crate) fn text(&self) -> &str {
        &self.text
    }

    /// Applies the edit to the given string if it's in range.
    pub(crate) fn apply(&self, source: &mut String, lines: &LineIndex) -> Result<Range<usize>> {
        let (start, end) = match self.encoding {
            SourcePositionEncoding::UTF8 => (
                LineCol {
                    line: self.range.start.line,
                    col: self.range.start.character,
                },
                LineCol {
                    line: self.range.end.line,
                    col: self.range.end.character,
                },
            ),
            SourcePositionEncoding::UTF16 => (
                lines
                    .to_utf8(
                        WideEncoding::Utf16,
                        WideLineCol {
                            line: self.range.start.line,
                            col: self.range.start.character,
                        },
                    )
                    .context("invalid edit start position")?,
                lines
                    .to_utf8(
                        WideEncoding::Utf16,
                        WideLineCol {
                            line: self.range.end.line,
                            col: self.range.end.character,
                        },
                    )
                    .context("invalid edit end position")?,
            ),
        };

        let range: Range<usize> = lines
            .offset(start)
            .context("invalid edit start position")?
            .into()
            ..lines
                .offset(end)
                .context("invalid edit end position")?
                .into();

        if !source.is_char_boundary(range.start) {
            bail!("edit start position is not at a character boundary");
        }

        if !source.is_char_boundary(range.end) {
            bail!("edit end position is not at a character boundary");
        }

        source.replace_range(range.clone(), &self.text);
        Ok(range)
    }
}

/// Represents an incremental change to a document.
#[derive(Clone, Debug)]
pub struct IncrementalChange {
    /// The monotonic version of the document.
    ///
    /// This is expected to increase for each incremental change.
    pub version: i32,
    /// The source to start from for applying edits.
    ///
    /// If this is `Some`, a full reparse will occur after applying edits to
    /// this string.
    ///
    /// If this is `None`, edits will be applied to the existing CST and an
    /// attempt will be made to incrementally parse the file.
    pub start: Option<String>,
    /// The source edits to apply.
    pub edits: Vec<SourceEdit>,
}

impl IncrementalChange {
    /// Attempts to apply the changes to the change's `start`.
    ///
    /// # Errors
    ///
    /// This will error if the `IncrementalChange` does not have a `start`
    /// source.
    pub fn apply(&self) -> Result<(String, LineIndex)> {
        let Some(mut source) = self.start.clone() else {
            bail!("no start source provided");
        };
        let mut lines = LineIndex::new(&source);
        self.apply_to(&mut source, &mut lines)?;
        Ok((source, lines))
    }

    /// Attempts to apply the changes to the given `source`.
    pub fn apply_to(&self, source: &mut String, lines: &mut LineIndex) -> Result<Vec<AppliedEdit>> {
        // We keep track of the last line we've processed so we only rebuild the
        // line index when there is a change that crosses a line
        let mut last_line = !0u32;
        let mut applied_edits = Vec::new();
        for edit in &self.edits {
            let range = edit.range();
            if last_line <= range.end.line {
                // Only rebuild the line index if the edit has changed lines
                *lines = LineIndex::new(source);
            }

            last_line = range.start.line;
            let range = edit.apply(source, lines)?;

            // We only track applied edits if they apply to existing CST.
            // Otherwise, it'll be treated as a full source
            // replacement.
            //
            // The distinction is important for incremental analysis, see
            // `AnalysisCache::intersect()`.
            if self.start.is_none() {
                applied_edits.push(AppliedEdit {
                    range,
                    replacement_length: edit.text().len(),
                });
            }
        }

        if !self.edits.is_empty() {
            // Rebuild the line index after all edits have been applied
            *lines = LineIndex::new(source);
        }

        Ok(applied_edits)
    }
}

/// Represents a Workflow Description Language (WDL) document analyzer.
///
/// By default, analysis parses documents, performs validation checks, resolves
/// imports, and performs type checking.
///
/// Each analysis operation is processed in order of request; however, the
/// individual parsing, resolution, and analysis of documents is performed
/// across a thread pool.
///
/// Note that dropping the analyzer is a blocking operation as it will wait for
/// the queue thread to join.
///
/// The type parameter is the context type passed to the progress callback.
pub struct Analyzer<Context> {
    /// The sender for sending analysis requests to the queue.
    sender: ManuallyDrop<mpsc::UnboundedSender<Request<Context>>>,
    /// The join handle for the queue task.
    handle: Option<JoinHandle<()>>,
    /// The config to use during analysis.
    config: Config,
    /// The context used to resolve symbolic module imports.
    resolution: ResolutionContext,
}

impl<Context> fmt::Debug for Analyzer<Context> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Analyzer")
            .field("config", &self.config)
            .field("resolution", &self.resolution)
            .finish_non_exhaustive()
    }
}

/// The context required to resolve symbolic module imports during analysis.
///
/// This is an either/or by construction. Resolution is either
/// [`Disabled`](ResolutionContext::Disabled), in which case symbolic imports do
/// not resolve, or [`Enabled`](ResolutionContext::Enabled), which always pairs
/// a resolver with the consumer module it resolves imports for. The pairing is
/// kept in one variant so a resolver can never exist without a module, nor a
/// module without a resolver.
#[derive(Clone, Debug, Default)]
pub enum ResolutionContext {
    /// Module resolution is disabled; symbolic imports do not resolve.
    #[default]
    Disabled,
    /// Module resolution is enabled for a consumer module.
    Enabled {
        /// The resolver used to materialize symbolic module imports.
        resolver: Arc<dyn wdl_modules::Resolver>,
        /// The consumer [`Module`](wdl_modules::module::Module) governing the
        /// analyzed sources.
        ///
        /// The caller builds this from the manifest it already parsed during
        /// discovery and hands it over here, so constructing a resolution
        /// context performs no filesystem I/O and the analysis queue never
        /// re-reads `module.json`.
        consumer_module: wdl_modules::module::Module,
    },
}

impl ResolutionContext {
    /// Creates a resolution context that resolves symbolic imports for the
    /// given consumer module through the given resolver.
    pub fn enabled(
        resolver: Arc<dyn wdl_modules::Resolver>,
        consumer_module: wdl_modules::module::Module,
    ) -> Self {
        Self::Enabled {
            resolver,
            consumer_module,
        }
    }

    /// Returns the root directory of the consumer module governing analysis, if
    /// resolution is enabled.
    pub fn module_root(&self) -> Option<&Path> {
        match self {
            Self::Disabled => None,
            Self::Enabled {
                consumer_module, ..
            } => Some(consumer_module.root.as_path()),
        }
    }

    /// Splits the context into the resolver and consumer module the analysis
    /// queue runs with.
    ///
    /// Both are `None` when resolution is disabled and both are `Some` when it
    /// is enabled, so the queue never holds a resolver without a module nor a
    /// module without a resolver.
    pub(crate) fn into_parts(
        self,
    ) -> (
        Option<Arc<dyn wdl_modules::Resolver>>,
        Option<wdl_modules::module::Module>,
    ) {
        match self {
            Self::Disabled => (None, None),
            Self::Enabled {
                resolver,
                consumer_module,
            } => (Some(resolver), Some(consumer_module)),
        }
    }
}

impl<Context> Analyzer<Context>
where
    Context: Send + Clone + 'static,
{
    /// Constructs a new analyzer with the given config.
    ///
    /// The provided progress callback will be invoked during analysis.
    ///
    /// The analyzer will use a default validator for validation.
    ///
    /// The analyzer must be constructed from the context of a Tokio runtime.
    pub fn new<Progress, Return>(config: Config, progress: Progress) -> Self
    where
        Progress: Fn(Context, ProgressKind, usize, usize) -> Return + Send + 'static,
        Return: Future<Output = ()>,
    {
        Self::new_with_resolution(config, ResolutionContext::default(), progress)
    }

    /// Constructs a new analyzer with the given config and resolution context.
    ///
    /// The provided progress callback will be invoked during analysis.
    ///
    /// The analyzer will use a default validator for validation.
    ///
    /// The analyzer must be constructed from the context of a Tokio runtime.
    pub fn new_with_resolution<Progress, Return>(
        config: Config,
        resolution: ResolutionContext,
        progress: Progress,
    ) -> Self
    where
        Progress: Fn(Context, ProgressKind, usize, usize) -> Return + Send + 'static,
        Return: Future<Output = ()>,
    {
        Self::new_with_validator_and_resolution(
            config,
            resolution,
            progress,
            crate::Validator::default,
        )
    }

    /// Constructs a new analyzer with the given config and validator function.
    ///
    /// The provided progress callback will be invoked during analysis.
    ///
    /// This validator function will be called once per worker thread to
    /// initialize a thread-local validator.
    ///
    /// The analyzer must be constructed from the context of a Tokio runtime.
    pub fn new_with_validator<Progress, Return, Validator>(
        config: Config,
        progress: Progress,
        validator: Validator,
    ) -> Self
    where
        Progress: Fn(Context, ProgressKind, usize, usize) -> Return + Send + 'static,
        Return: Future<Output = ()>,
        Validator: Fn() -> crate::Validator + Send + Sync + 'static,
    {
        Self::new_with_validator_and_resolution(
            config,
            ResolutionContext::default(),
            progress,
            validator,
        )
    }

    /// Constructs a new analyzer with the given config, resolution context, and
    /// validator function.
    ///
    /// The provided progress callback will be invoked during analysis.
    ///
    /// This validator function will be called once per worker thread to
    /// initialize a thread-local validator.
    ///
    /// The analyzer must be constructed from the context of a Tokio runtime.
    pub fn new_with_validator_and_resolution<Progress, Return, Validator>(
        config: Config,
        resolution: ResolutionContext,
        progress: Progress,
        validator: Validator,
    ) -> Self
    where
        Progress: Fn(Context, ProgressKind, usize, usize) -> Return + Send + 'static,
        Return: Future<Output = ()>,
        Validator: Fn() -> crate::Validator + Send + Sync + 'static,
    {
        let (tx, rx) = mpsc::unbounded_channel();
        let tokio = Handle::current();
        let inner_config = config.clone();
        let inner_resolution = resolution.clone();
        let handle = std::thread::spawn(move || {
            let queue = AnalysisQueue::new(
                inner_config,
                tokio,
                inner_resolution,
                progress,
                Arc::new(validator),
            );
            queue.run(rx);
        });

        Self {
            sender: ManuallyDrop::new(tx),
            handle: Some(handle),
            config,
            resolution,
        }
    }

    /// Replace the current validator function.
    ///
    /// This will mark all documents for re-analysis.
    pub async fn swap_validator<Validator>(&self, validator: Validator) -> Result<()>
    where
        Validator: Fn() -> crate::Validator + Send + Sync + 'static,
    {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::SwapValidator(SwapValidatorRequest {
                validator: Arc::new(validator),
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to receive response from analysis queue because the channel has closed")
        })?;

        Ok(())
    }

    /// Adds a document to the analyzer. Document can be a local file or a URL.
    ///
    /// Returns an error if the document could not be added.
    pub async fn add_document(&self, uri: Url) -> Result<()> {
        let mut documents = IndexSet::new();
        documents.insert(uri);

        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Add(AddRequest {
                documents,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to receive response from analysis queue because the channel has closed")
        })?;

        Ok(())
    }

    /// Adds a directory to the analyzer. It will recursively search for WDL
    /// documents in the supplied directory.
    ///
    /// Returns an error if there was a problem discovering documents for the
    /// specified path.
    pub async fn add_directory(&self, path: impl Into<PathBuf>) -> Result<()> {
        let path = path.into();
        let config = self.config.clone();
        // When the scanned directory lies inside the active module, stop the
        // walk at nested module boundaries: a subdirectory with its own
        // `module.json` is a separate (local-path dependency) module whose WDL
        // files reach the analyzer through symbolic-import materialization, not
        // directory scanning. Outside an active module there is nothing to
        // scope to, so scan everything.
        let stop_at_module_boundaries = self
            .resolution
            .module_root()
            .is_some_and(|root| path.starts_with(root));
        // Start by searching for documents
        let documents = RayonHandle::spawn(move || -> Result<IndexSet<Url>> {
            let mut documents = IndexSet::new();

            let metadata = path.metadata().with_context(|| {
                format!(
                    "failed to read metadata for `{path}`",
                    path = path.display()
                )
            })?;

            if metadata.is_file() {
                bail!("`{path}` is a file, not a directory", path = path.display());
            }

            let mut walker = WalkBuilder::new(&path);
            if let Some(ignore_filename) = config.ignore_filename() {
                walker.add_custom_ignore_filename(ignore_filename);
            }
            if stop_at_module_boundaries {
                // Stop descending into subdirectories that declare their own
                // module via a `module.json` file. Those directories belong to
                // a different module (a local-path dependency) and their WDL
                // files reach the analyzer through symbolic-import
                // materialization, not directory scanning.
                let root_for_filter = path.clone();
                walker.filter_entry(move |entry| {
                    if !entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
                        return true;
                    }
                    if entry.path() == root_for_filter {
                        return true;
                    }
                    !wdl_modules::module::is_module_root(entry.path())
                });
            }
            let walker = walker
                .standard_filters(false)
                .parents(true)
                .follow_links(true)
                .build();

            for result in walker {
                let entry = result.with_context(|| {
                    format!("failed to read directory `{path}`", path = path.display())
                })?;

                // Skip entries without a file type
                let Some(file_type) = entry.file_type() else {
                    continue;
                };
                // Skip non-files
                if !file_type.is_file() {
                    continue;
                }
                // Skip files without a `.wdl` extension
                if entry.path().extension() != Some(OsStr::new("wdl")) {
                    continue;
                }

                documents.insert(path_to_uri(entry.path()).with_context(|| {
                    format!(
                        "failed to convert path `{path}` to a URI",
                        path = entry.path().display()
                    )
                })?);
            }

            Ok(documents)
        })
        .await?;

        if documents.is_empty() {
            return Ok(());
        }

        // Send the add request to the queue
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Add(AddRequest {
                documents,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to receive response from analysis queue because the channel has closed")
        })?;

        Ok(())
    }

    /// Removes the specified documents from the analyzer.
    ///
    /// If a specified URI is a prefix (i.e. directory) of documents known to
    /// the analyzer, those documents will be removed.
    ///
    /// Documents are only removed when not referenced from importing documents.
    /// To forcefully delete the documents from the graph, use
    /// [`Self::delete_documents()`].
    pub async fn unroot_documents(&self, documents: Vec<Url>) -> Result<()> {
        // Send the unroot request to the queue
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::UnrootDocuments(UnrootDocumentsRequest {
                documents,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to receive response from analysis queue because the channel has closed")
        })?;

        Ok(())
    }

    /// Deletes the specified documents from the analyzer.
    ///
    /// This differs from [`Self::unroot_documents()`], as a deletion will occur
    /// even if the document(s) are referenced in other documents.
    pub async fn delete_documents(&self, documents: Vec<Url>) -> Result<()> {
        // Send the delete request to the queue
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Delete(DeleteRequest {
                documents,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to receive response from analysis queue because the channel has closed")
        })?;

        Ok(())
    }

    /// Notifies the analyzer that a document has an incremental change.
    ///
    /// Changes to documents that aren't known to the analyzer are ignored.
    pub fn notify_incremental_change(
        &self,
        document: Url,
        change: IncrementalChange,
    ) -> Result<()> {
        self.sender
            .send(Request::NotifyIncrementalChange(
                NotifyIncrementalChangeRequest { document, change },
            ))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })
    }

    /// Notifies the analyzer that a document has fully changed and should be
    /// fetched again.
    ///
    /// Changes to documents that aren't known to the analyzer are ignored.
    ///
    /// If `discard_pending` is true, then any pending incremental changes are
    /// discarded; otherwise, the full change is ignored if there are pending
    /// incremental changes.
    pub fn notify_change(&self, document: Url, discard_pending: bool) -> Result<()> {
        self.sender
            .send(Request::NotifyChange(NotifyChangeRequest {
                document,
                discard_pending,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })
    }

    /// Analyzes a specific document.
    ///
    /// The provided context is passed to the progress callback.
    ///
    /// If the document is up-to-date and was previously analyzed, the current
    /// analysis result is returned.
    ///
    /// Returns an analysis result for each document that was analyzed.
    pub async fn analyze_document(
        &self,
        context: Context,
        document: Url,
    ) -> Result<Vec<AnalysisResult>> {
        // Send the analyze request to the queue
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Analyze(AnalyzeRequest {
                document: Some(document),
                context,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to receive response from analysis queue because the channel has closed")
        })?
    }

    /// Performs analysis of all documents.
    ///
    /// The provided context is passed to the progress callback.
    ///
    /// If a document is up-to-date and was previously analyzed, the current
    /// analysis result is returned.
    ///
    /// Returns an analysis result for each document that was analyzed.
    pub async fn analyze(&self, context: Context) -> Result<Vec<AnalysisResult>> {
        // Send the analyze request to the queue
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Analyze(AnalyzeRequest {
                document: None, // analyze all documents
                context,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send request to analysis queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to receive response from analysis queue because the channel has closed")
        })?
    }

    /// Get the call hierarchy for the symbol at the current position.
    pub async fn call_hierarchy(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
    ) -> Result<Option<Vec<CallHierarchyItem>>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::CallHierarchy(CallHierarchyRequest {
                document,
                position,
                encoding,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send call hierarchy request to analysis queue because the channel \
                     has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive call hierarchy response from analysis queue because the \
                 channel has closed"
            )
        })
    }

    /// Formats a document.
    pub async fn format_document(&self, document: Url) -> Result<Option<(u32, u32, String)>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Format(FormatRequest {
                document,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!("failed to send format request to the queue because the channel has closed")
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to send format request to the queue because the channel has closed")
        })
    }

    /// Get all folding ranges in a document.
    pub async fn folding_range(&self, document: Url) -> Result<Option<Vec<FoldingRange>>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::FoldingRange(FoldingRangeRequest {
                document,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send folding range request to the queue because the channel has \
                     closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive folding range response from analysis queue because the channel \
                 has closed"
            )
        })
    }

    /// Performs a "goto definition" for a symbol at the current position.
    pub async fn goto_definition(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
    ) -> Result<Option<GotoDefinitionResponse>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::GotoDefinition(GotoDefinitionRequest {
                document,
                position,
                encoding,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send goto definition request to analysis queue because the channel \
                     has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive goto definition response from analysis queue because the \
                 channel has closed"
            )
        })
    }

    /// Performs a `find references` for a symbol across all the documents.
    pub async fn find_all_references(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
        include_declaration: bool,
    ) -> Result<Vec<Location>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::FindAllReferences(FindAllReferencesRequest {
                document,
                position,
                encoding,
                include_declaration,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send find all references request to analysis queue because the \
                     channel has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive find all references response from analysis queue because the \
                 client channel has closed"
            )
        })
    }

    /// Get all code lenses in a document.
    pub async fn code_lens(
        &self,
        context: Context,
        document: Url,
    ) -> Result<Option<Vec<CodeLens>>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::CodeLens(CodeLensRequest {
                document,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send codelens request to analysis queue because the channel has \
                     closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to send codelens request to analysis queue because the channel has closed"
            )
        })
    }

    /// Performs a `auto-completion` for a symbol.
    pub async fn completion(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
    ) -> Result<Option<CompletionResponse>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Completion(CompletionRequest {
                document,
                position,
                encoding,
                context,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send completion request to analysis queue because the channel has \
                     closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to send completion request to analysis queue because the channel has \
                 closed"
            )
        })
    }

    /// Performs a `hover` for a symbol at a given position in a document.
    pub async fn hover(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
    ) -> Result<Option<Hover>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Hover(HoverRequest {
                document,
                position,
                encoding,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send hover request to analysis queue because the channel has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!("failed to send hover request to analysis queue because the channel has closed")
        })
    }

    /// Renames a symbol at a given position across the workspace.
    pub async fn rename(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
        new_name: String,
    ) -> Result<Option<WorkspaceEdit>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::Rename(RenameRequest {
                document,
                position,
                encoding,
                new_name,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send rename request to analysis queue because the channel has \
                     closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive rename response from analysis queue because the channel has \
                 closed"
            )
        })
    }

    /// Gets semantic tokens for a document
    pub async fn semantic_tokens(
        &self,
        context: Context,
        document: Url,
    ) -> Result<Option<SemanticTokensResult>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::SemanticTokens(SemanticTokenRequest {
                document,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send semantic tokens request to analysis queue because the channel \
                     has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive semantic tokens response from analysis queue because the \
                 channel has closed"
            )
        })
    }

    /// Gets document symbols for a document.
    pub async fn document_symbol(&self, document: Url) -> Result<Option<DocumentSymbolResponse>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::DocumentSymbol(DocumentSymbolRequest {
                document,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send document symbol request to analysis queue because the channel \
                     has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive document symbol request to analysis queue because the channel \
                 has closed"
            )
        })
    }

    /// Gets document symbols for the workspace.
    pub async fn workspace_symbol(
        &self,
        context: Context,
        query: String,
    ) -> Result<Option<Vec<SymbolInformation>>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::WorkspaceSymbol(WorkspaceSymbolRequest {
                query,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send workspace symbol request to analysis queue because the \
                     channel has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive workspace symbol response from analysis queue because the \
                 channel has closed"
            )
        })
    }

    /// Get the incoming calls for the symbol at the current position.
    pub async fn incoming_calls(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
    ) -> Result<Option<Vec<CallHierarchyIncomingCall>>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::IncomingCalls(IncomingCallsRequest {
                document,
                position,
                encoding,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send incoming calls request to analysis queue because the channel \
                     has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive incoming calls response from analysis queue because the \
                 channel has closed"
            )
        })
    }

    /// Get the outgoing calls for the symbol at the current position.
    pub async fn outgoing_calls(
        &self,
        context: Context,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
    ) -> Result<Option<Vec<CallHierarchyOutgoingCall>>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::OutgoingCalls(OutgoingCallsRequest {
                document,
                position,
                encoding,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send outgoing calls request to analysis queue because the channel \
                     has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive outgoing calls response from analysis queue because the \
                 channel has closed"
            )
        })
    }

    /// Gets signature help for a function call at a given position.
    pub async fn signature_help(
        &self,
        document: Url,
        position: SourcePosition,
        encoding: SourcePositionEncoding,
    ) -> Result<Option<SignatureHelp>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::SignatureHelp(SignatureHelpRequest {
                document,
                position,
                encoding,
                completed: tx,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send signature help request to analysis queue because the channel \
                     has closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive signature help response from analysis queue because the \
                 channel has closed"
            )
        })
    }

    /// Requests inlay hints for a document.
    pub async fn inlay_hints(
        &self,
        context: Context,
        document: Url,
        range: lsp_types::Range,
    ) -> Result<Option<Vec<InlayHint>>> {
        let (tx, rx) = oneshot::channel();
        self.sender
            .send(Request::InlayHints(InlayHintsRequest {
                document,
                range,
                completed: tx,
                context,
            }))
            .map_err(|_| {
                anyhow!(
                    "failed to send inlay hints request to analysis queue because the channel has \
                     closed"
                )
            })?;

        rx.await.map_err(|_| {
            anyhow!(
                "failed to receive inlay hints response from analysis queue because the channel \
                 has closed"
            )
        })
    }
}

impl Default for Analyzer<()> {
    fn default() -> Self {
        Self::new(Default::default(), |_, _, _, _| async {})
    }
}

impl<C> Drop for Analyzer<C> {
    fn drop(&mut self) {
        unsafe { ManuallyDrop::drop(&mut self.sender) };
        if let Some(handle) = self.handle.take() {
            handle.join().unwrap();
        }
    }
}

/// Constant that asserts `Analyzer` is `Send + Sync`; if not, it fails to
/// compile.
const _: () = {
    /// Helper that will fail to compile if T is not `Send + Sync`.
    const fn _assert<T: Send + Sync>() {}
    _assert::<Analyzer<()>>();
};

#[cfg(test)]
mod tests {
    use std::fs;
    use std::path::PathBuf;

    use tempfile::TempDir;
    use wdl_ast::Severity;

    use super::*;

    #[tokio::test]
    #[test_log::test]
    async fn it_returns_empty_results() {
        let analyzer = Analyzer::default();
        let results = analyzer.analyze(()).await.unwrap();
        assert!(results.is_empty());
    }

    #[tokio::test]
    #[test_log::test]
    async fn it_analyzes_a_document() {
        let dir = TempDir::new().expect("failed to create temporary directory");
        let path = dir.path().join("foo.wdl");
        fs::write(
            &path,
            r#"version 1.1

task test {
    command <<<>>>
}

workflow test {
}
"#,
        )
        .expect("failed to create test file");

        // Analyze the file and check the resulting diagnostic
        let analyzer = Analyzer::default();
        analyzer
            .add_document(path_to_uri(&path).expect("should convert to URI"))
            .await
            .expect("should add document");

        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].document.diagnostics().count(), 1);
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().rule(),
            None
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().severity(),
            Severity::Error
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().message(),
            "conflicting workflow name `test`"
        );

        // Analyze again and ensure the analysis result id is unchanged
        let id = results[0].document.id().clone();
        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].document.id().as_ref(), id.as_ref());
        assert_eq!(results[0].document.diagnostics().count(), 1);
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().rule(),
            None
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().severity(),
            Severity::Error
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().message(),
            "conflicting workflow name `test`"
        );
    }

    #[tokio::test]
    #[test_log::test]
    async fn it_reanalyzes_a_document_on_change() {
        let dir = TempDir::new().expect("failed to create temporary directory");
        let path = dir.path().join("foo.wdl");
        fs::write(
            &path,
            r#"version 1.1

task test {
    command <<<>>>
}

workflow test {
}
"#,
        )
        .expect("failed to create test file");

        // Analyze the file and check the resulting diagnostic
        let analyzer = Analyzer::default();
        analyzer
            .add_document(path_to_uri(&path).expect("should convert to URI"))
            .await
            .expect("should add document");

        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].document.diagnostics().count(), 1);
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().rule(),
            None
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().severity(),
            Severity::Error
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().message(),
            "conflicting workflow name `test`"
        );

        // Rewrite the file to correct the issue
        fs::write(
            &path,
            r#"version 1.1

task test {
    command <<<>>>
}

workflow something_else {
}
"#,
        )
        .expect("failed to create test file");

        let uri = path_to_uri(&path).expect("should convert to URI");
        analyzer.notify_change(uri.clone(), false).unwrap();

        // Analyze again and ensure the analysis result id is changed and the
        // issue fixed
        let id = results[0].document.id().clone();
        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 1);
        assert_ne!(results[0].document.id().as_ref(), id.as_ref());
        assert_eq!(results[0].document.diagnostics().count(), 0);

        // Analyze again and ensure the analysis result id is unchanged
        let id = results[0].document.id().clone();
        let results = analyzer.analyze_document((), uri).await.unwrap();
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].document.id().as_ref(), id.as_ref());
        assert_eq!(results[0].document.diagnostics().count(), 0);
    }

    #[tokio::test]
    #[test_log::test]
    async fn it_reanalyzes_a_document_on_incremental_change() {
        let dir = TempDir::new().expect("failed to create temporary directory");
        let path = dir.path().join("foo.wdl");
        fs::write(
            &path,
            r#"version 1.1

task test {
    command <<<>>>
}

workflow test {
}
"#,
        )
        .expect("failed to create test file");

        // Analyze the file and check the resulting diagnostic
        let analyzer = Analyzer::default();
        analyzer
            .add_document(path_to_uri(&path).expect("should convert to URI"))
            .await
            .expect("should add document");

        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].document.diagnostics().count(), 1);
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().rule(),
            None
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().severity(),
            Severity::Error
        );
        assert_eq!(
            results[0].document.diagnostics().next().unwrap().message(),
            "conflicting workflow name `test`"
        );

        // Edit the file to correct the issue
        let uri = path_to_uri(&path).expect("should convert to URI");
        analyzer
            .notify_incremental_change(
                uri.clone(),
                IncrementalChange {
                    version: 2,
                    start: None,
                    edits: vec![SourceEdit {
                        range: SourcePosition::new(6, 9)..SourcePosition::new(6, 13),
                        encoding: SourcePositionEncoding::UTF8,
                        text: "something_else".to_string(),
                    }],
                },
            )
            .unwrap();

        // Analyze again and ensure the analysis result id is changed and the
        // issue was fixed
        let id = results[0].document.id().clone();
        let results = analyzer.analyze_document((), uri).await.unwrap();
        assert_eq!(results.len(), 1);
        assert_ne!(results[0].document.id().as_ref(), id.as_ref());
        assert_eq!(results[0].document.diagnostics().count(), 0);
    }

    #[tokio::test]
    #[test_log::test]
    async fn it_removes_documents() {
        let dir = TempDir::new().expect("failed to create temporary directory");
        let foo = dir.path().join("foo.wdl");
        fs::write(
            &foo,
            r#"version 1.1
workflow test {
}
"#,
        )
        .expect("failed to create test file");

        let bar = dir.path().join("bar.wdl");
        fs::write(
            &bar,
            r#"version 1.1
workflow test {
}
"#,
        )
        .expect("failed to create test file");

        let baz = dir.path().join("baz.wdl");
        fs::write(
            &baz,
            r#"version 1.1
workflow test {
}
"#,
        )
        .expect("failed to create test file");

        // Add all three documents to the analyzer
        let analyzer = Analyzer::default();
        analyzer
            .add_directory(dir.path())
            .await
            .expect("should add documents");

        // Analyze the documents
        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 3);
        assert!(results[0].document.diagnostics().next().is_none());
        assert!(results[1].document.diagnostics().next().is_none());
        assert!(results[2].document.diagnostics().next().is_none());

        // Analyze the documents again
        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 3);

        // Remove the documents by directory
        analyzer
            .unroot_documents(vec![
                path_to_uri(dir.path()).expect("should convert to URI"),
            ])
            .await
            .unwrap();
        let results = analyzer.analyze(()).await.unwrap();
        assert!(results.is_empty());
    }

    #[tokio::test]
    #[test_log::test]
    async fn selected_imported_task_conflicts_with_local_workflow() {
        let dir = TempDir::new().expect("failed to create temporary directory");
        fs::write(
            dir.path().join("lib.wdl"),
            r#"version 1.4
task run {
    command <<<>>>
}
"#,
        )
        .expect("failed to create library document");
        fs::write(
            dir.path().join("source.wdl"),
            r#"version 1.4
import { run } from "lib.wdl"
workflow run {
}
"#,
        )
        .expect("failed to create source document");

        let config = Config::default()
            .with_feature_flags(crate::config::FeatureFlags::default().with_wdl_1_4());
        let analyzer = Analyzer::new(config, |(), _, _, _| async {});
        analyzer
            .add_document(path_to_uri(dir.path().join("source.wdl")).expect("should convert"))
            .await
            .expect("should add document");

        let results = analyzer.analyze(()).await.expect("analysis should succeed");
        let source = results
            .iter()
            .find(|result| result.document.uri().path().contains("source.wdl"))
            .expect("should find source result");
        let errors = source
            .document
            .diagnostics()
            .filter(|diagnostic| diagnostic.severity() == Severity::Error)
            .map(|diagnostic| diagnostic.message())
            .collect::<Vec<_>>();
        assert_eq!(
            errors,
            ["import of `run` conflicts with an existing definition"]
        );
    }

    #[tokio::test]
    #[test_log::test]
    async fn symbolic_import_resolves_through_mock_resolver() {
        use wdl_modules::Manifest;
        use wdl_modules::lockfile::ResolvedSource;
        use wdl_modules::resolver::MaterializedFile;
        use wdl_modules::resolver::ResolvedTree;
        use wdl_modules::resolver::ResolverError;

        #[derive(Debug)]
        struct MockResolver {
            dep_path: PathBuf,
        }

        #[async_trait::async_trait]
        impl wdl_modules::Resolver for MockResolver {
            async fn materialize(
                &self,
                _consumer: &wdl_modules::module::Module,
                path: &wdl_modules::symbolic_path::SymbolicPath,
            ) -> Result<MaterializedFile, ResolverError> {
                let rel = match path.sub_path() {
                    Some(sub) => {
                        let mut p = sub.to_path_buf();
                        p.set_extension("wdl");
                        p
                    }
                    None => std::path::PathBuf::from("index.wdl"),
                };
                let file_path = self.dep_path.join(rel);
                let manifest_bytes = fs::read(self.dep_path.join("module.json")).unwrap();
                let manifest = Manifest::parse(&manifest_bytes).unwrap();
                Ok(MaterializedFile {
                    path: file_path,
                    module_root: self.dep_path.clone(),
                    source: ResolvedSource::Path {
                        path: self.dep_path.clone(),
                    },
                    manifest: Arc::new(manifest),
                })
            }

            async fn resolve_tree(
                &self,
                _consumer: &wdl_modules::module::Module,
            ) -> Result<ResolvedTree, ResolverError> {
                Ok(ResolvedTree::default())
            }

            async fn discover_versions(
                &self,
                _name: &wdl_modules::dependency::DependencyName,
                _source: &wdl_modules::dependency::DependencySource,
                _scope: wdl_modules::resolver::DependencyScope,
            ) -> Result<Vec<semver::Version>, ResolverError> {
                Ok(Vec::new())
            }
        }

        let dir = TempDir::new().expect("failed to create temporary directory");

        let dep_dir = dir.path().join("dep");
        fs::create_dir_all(&dep_dir).unwrap();
        fs::write(
            dep_dir.join("module.json"),
            r#"{"name":"dep","version":"1.0.0","license":"MIT"}"#,
        )
        .unwrap();
        fs::write(
            dep_dir.join("index.wdl"),
            "version 1.4\n\ntask hello {\n    command <<<>>>\n}\n",
        )
        .unwrap();

        let consumer_dir = dir.path().join("consumer");
        fs::create_dir_all(&consumer_dir).unwrap();
        let dep_path_json = dep_dir.display().to_string().replace('\\', "/");
        fs::write(
            consumer_dir.join("module.json"),
            format!(
                r#"{{"name":"consumer","version":"0.1.0","license":"MIT","dependencies":{{"dep":{{"path":"{dep_path_json}"}}}}}}"#
            ),
        )
        .unwrap();
        fs::write(
            consumer_dir.join("source.wdl"),
            "version 1.4\n\nimport dep\nimport \"lib.wdl\"\n\nworkflow main {}\n",
        )
        .unwrap();
        fs::write(
            consumer_dir.join("lib.wdl"),
            "version 1.4\n\nimport dep\n\ntask lib {\n    command <<<>>>\n}\n",
        )
        .unwrap();

        let config = Config::default()
            .with_feature_flags(crate::config::FeatureFlags::default().with_wdl_1_4());
        let resolver: Arc<dyn wdl_modules::Resolver> = Arc::new(MockResolver {
            dep_path: dep_dir.clone(),
        });
        let consumer_module = wdl_modules::module::Module::load_from_path(&consumer_dir)
            .expect("test consumer module should load");
        let resolution = ResolutionContext::enabled(resolver, consumer_module);
        let analyzer = Analyzer::new_with_resolution(config, resolution, |(), _, _, _| async {});
        analyzer
            .add_document(path_to_uri(consumer_dir.join("source.wdl")).expect("should convert"))
            .await
            .expect("should add document");

        let results = analyzer.analyze(()).await.unwrap();
        assert!(!results.is_empty(), "should have analysis results");
        let consumer_result = results
            .iter()
            .find(|r| r.document.uri().path().contains("source.wdl"))
            .expect("should find consumer result");
        let errors: Vec<_> = consumer_result
            .document
            .diagnostics()
            .filter(|d| d.severity() == Severity::Error)
            .collect();
        assert!(
            errors.is_empty(),
            "consumer should have no errors, got: {:?}",
            errors.iter().map(|d| d.message()).collect::<Vec<_>>()
        );
        let lib_result = results
            .iter()
            .find(|r| r.document.uri().path().contains("lib.wdl"))
            .expect("should find uri import result");
        let errors: Vec<_> = lib_result
            .document
            .diagnostics()
            .filter(|d| d.severity() == Severity::Error)
            .collect();
        assert!(
            errors.is_empty(),
            "uri import should have no errors, got: {:?}",
            errors.iter().map(|d| d.message()).collect::<Vec<_>>()
        );
    }

    #[tokio::test]
    #[test_log::test]
    async fn concurrent_symbolic_imports_faster_than_serial() {
        use std::sync::atomic::AtomicUsize;
        use std::sync::atomic::Ordering;
        use std::time::Duration;

        use wdl_modules::Manifest;
        use wdl_modules::lockfile::ResolvedSource;
        use wdl_modules::resolver::MaterializedFile;
        use wdl_modules::resolver::ResolvedTree;
        use wdl_modules::resolver::ResolverError;

        /// A resolver that tracks overlapping `materialize` calls.
        #[derive(Debug)]
        struct SlowMockResolver {
            dep_path: PathBuf,
            delay: Duration,
            active: AtomicUsize,
            max_active: AtomicUsize,
        }

        #[async_trait::async_trait]
        impl wdl_modules::Resolver for SlowMockResolver {
            async fn materialize(
                &self,
                _consumer: &wdl_modules::module::Module,
                path: &wdl_modules::symbolic_path::SymbolicPath,
            ) -> Result<MaterializedFile, ResolverError> {
                let active = self.active.fetch_add(1, Ordering::SeqCst) + 1;
                self.max_active.fetch_max(active, Ordering::SeqCst);
                tokio::time::sleep(self.delay).await;
                self.active.fetch_sub(1, Ordering::SeqCst);
                let rel = match path.sub_path() {
                    Some(sub) => {
                        let mut p = sub.to_path_buf();
                        p.set_extension("wdl");
                        p
                    }
                    None => std::path::PathBuf::from("index.wdl"),
                };
                let file_path = self.dep_path.join(rel);
                let manifest_bytes = fs::read(self.dep_path.join("module.json")).unwrap();
                let manifest = Manifest::parse(&manifest_bytes).unwrap();
                Ok(MaterializedFile {
                    path: file_path,
                    module_root: self.dep_path.clone(),
                    source: ResolvedSource::Path {
                        path: self.dep_path.clone(),
                    },
                    manifest: Arc::new(manifest),
                })
            }

            async fn resolve_tree(
                &self,
                _consumer: &wdl_modules::module::Module,
            ) -> Result<ResolvedTree, ResolverError> {
                Ok(ResolvedTree::default())
            }

            async fn discover_versions(
                &self,
                _name: &wdl_modules::dependency::DependencyName,
                _source: &wdl_modules::dependency::DependencySource,
                _scope: wdl_modules::resolver::DependencyScope,
            ) -> Result<Vec<semver::Version>, ResolverError> {
                Ok(Vec::new())
            }
        }

        const IMPORT_COUNT: usize = 8;
        const DELAY_MS: u64 = 200;

        let dir = TempDir::new().expect("failed to create temporary directory");

        let dep_dir = dir.path().join("slowdep");
        fs::create_dir_all(&dep_dir).unwrap();
        fs::write(
            dep_dir.join("module.json"),
            r#"{"name":"slowdep","version":"1.0.0","license":"MIT"}"#,
        )
        .unwrap();
        for i in 0..IMPORT_COUNT {
            fs::write(
                dep_dir.join(format!("sub{i}.wdl")),
                "version 1.4\n\ntask noop {\n    command <<<>>>\n}\n",
            )
            .unwrap();
        }
        fs::write(
            dep_dir.join("index.wdl"),
            "version 1.4\n\ntask noop {\n    command <<<>>>\n}\n",
        )
        .unwrap();

        let consumer_dir = dir.path().join("slowconsumer");
        fs::create_dir_all(&consumer_dir).unwrap();
        let dep_path_json = dep_dir.display().to_string().replace('\\', "/");
        fs::write(
            consumer_dir.join("module.json"),
            format!(
                r#"{{"name":"slowconsumer","version":"0.1.0","license":"MIT","dependencies":{{"slowdep":{{"path":"{dep_path_json}"}}}}}}"#
            ),
        )
        .unwrap();

        let mut source = "version 1.4\n\n".to_string();
        for i in 0..IMPORT_COUNT {
            source.push_str(&format!("import slowdep/sub{i}\n"));
        }
        source.push_str("\nworkflow main {}\n");
        fs::write(consumer_dir.join("source.wdl"), &source).unwrap();

        let config = Config::default()
            .with_feature_flags(crate::config::FeatureFlags::default().with_wdl_1_4());
        let resolver = Arc::new(SlowMockResolver {
            dep_path: dep_dir.clone(),
            delay: Duration::from_millis(DELAY_MS),
            active: AtomicUsize::new(0),
            max_active: AtomicUsize::new(0),
        });
        let resolver_trait: Arc<dyn wdl_modules::Resolver> = resolver.clone();
        let consumer_module = wdl_modules::module::Module::load_from_path(&consumer_dir)
            .expect("test consumer module should load");
        let resolution = ResolutionContext::enabled(resolver_trait, consumer_module);
        let analyzer = Analyzer::new_with_resolution(config, resolution, |(), _, _, _| async {});
        analyzer
            .add_document(path_to_uri(consumer_dir.join("source.wdl")).expect("should convert"))
            .await
            .expect("should add document");

        let results = analyzer.analyze(()).await.unwrap();

        assert!(!results.is_empty(), "should have analysis results");
        assert!(
            resolver.max_active.load(Ordering::SeqCst) > 1,
            "symbolic imports should materialize concurrently"
        );
    }

    #[tokio::test]
    #[test_log::test]
    async fn it_deletes_documents() {
        let dir = TempDir::new().expect("failed to create temporary directory");
        let foo = dir.path().join("foo.wdl");
        fs::write(
            &foo,
            r#"version 1.1
import "bar.wdl"

workflow test {
    call bar.test
}
"#,
        )
        .expect("failed to create test file");

        let bar = dir.path().join("bar.wdl");
        fs::write(
            &bar,
            r#"version 1.1
workflow test {}
"#,
        )
        .expect("failed to create test file");

        // Add both documents to the analyzer
        let analyzer = Analyzer::default();
        analyzer
            .add_directory(dir.path())
            .await
            .expect("should add documents");

        // Analyze the documents
        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 2);
        assert!(results[0].document.diagnostics().next().is_none());
        assert!(results[1].document.diagnostics().next().is_none());

        // Now delete bar.wdl, which foo.wdl depends on.
        //
        // Unlike removal, this should *force* the deletion of bar.wdl in the
        // graph (and thus cause errors in foo.wdl)
        fs::remove_file(&bar).expect("should delete file");
        analyzer
            .delete_documents(vec![path_to_uri(&bar).expect("should convert to URI")])
            .await
            .unwrap();

        // Now foo.wdl should error
        let results = analyzer.analyze(()).await.unwrap();
        assert_eq!(results.len(), 1);

        let has_import_failed_diagnostic = results[0]
            .document
            .diagnostics()
            .any(|d| d.message().contains("failed to import `bar.wdl`"));
        assert!(has_import_failed_diagnostic);
    }

    #[test]
    #[test_log::test]
    fn it_rejects_invalid_edit_ranges() {
        SourceEdit::new(
            SourcePosition::new(5, 1)..SourcePosition::new(1, 5),
            SourcePositionEncoding::UTF8,
            String::from("invalid range"),
        )
        .expect_err("should fail");
    }
}