From 56efbd7de935a154c7b01965b4a81da7941c1ef5 Mon Sep 17 00:00:00 2001 From: JT <547158+jntrnr@users.noreply.github.com> Date: Thu, 6 Apr 2023 07:34:47 +1200 Subject: [PATCH] Add IDE support (#8745) # Description This adds a set of new flags on the `nu` binary intended for use in IDEs. Here is the set of supported functionality so far: * goto-def - go to the definition of a variable or custom command * type hints - see the inferred type of variables * check - see the errors in the document (currently only one error is supported) * hover - get information about the variable or custom command * complete - get a completion list at the current position # User-Facing Changes No changes to the REPL experience. This only impacts the IDE scenario. # Tests + Formatting Don't forget to add tests that cover your changes. Make sure you've run and fixed any issues with these commands: - `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes) - `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass - `cargo run -- crates/nu-utils/standard_library/tests.nu` to run the tests for the standard library > **Note** > from `nushell` you can also use the `toolkit` as follows > ```bash > use toolkit.nu # or use an `env_change` hook to activate it automatically > toolkit check pr > ``` # After Submitting If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date. --------- Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> --- Cargo.lock | 1 + Cargo.toml | 1 + .../src/completions/command_completions.rs | 4 +- crates/nu-cli/src/completions/completer.rs | 2 +- crates/nu-cli/src/syntax_highlight.rs | 7 +- crates/nu-color-config/src/shape_color.rs | 2 + crates/nu-parser/src/flatten.rs | 33 +- .../src/sample_config/default_config.nu | 2 + src/command.rs | 40 +- src/ide.rs | 471 ++++++++++++++++++ src/main.rs | 20 + 11 files changed, 564 insertions(+), 19 deletions(-) create mode 100644 src/ide.rs diff --git a/Cargo.lock b/Cargo.lock index a94dbdfbff..6c925dc416 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2703,6 +2703,7 @@ dependencies = [ "rayon", "reedline", "rstest", + "serde_json", "serial_test", "signal-hook", "simplelog", diff --git a/Cargo.toml b/Cargo.toml index 5d9df03f61..7531a44d44 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -69,6 +69,7 @@ rayon = "1.7.0" is_executable = "1.0.1" simplelog = "0.12.0" time = "0.3.12" +serde_json = "1.0" [target.'cfg(not(target_os = "windows"))'.dependencies] # Our dependencies don't use OpenSSL on Windows diff --git a/crates/nu-cli/src/completions/command_completions.rs b/crates/nu-cli/src/completions/command_completions.rs index b9427e8e80..4fcfeae8e2 100644 --- a/crates/nu-cli/src/completions/command_completions.rs +++ b/crates/nu-cli/src/completions/command_completions.rs @@ -169,7 +169,7 @@ impl Completer for CommandCompletion { .take_while(|x| { matches!( x.1, - FlatShape::InternalCall + FlatShape::InternalCall(_) | FlatShape::External | FlatShape::ExternalArg | FlatShape::Literal @@ -197,7 +197,7 @@ impl Completer for CommandCompletion { let config = working_set.get_config(); let commands = if matches!(self.flat_shape, nu_parser::FlatShape::External) - || matches!(self.flat_shape, nu_parser::FlatShape::InternalCall) + || matches!(self.flat_shape, nu_parser::FlatShape::InternalCall(_)) || ((span.end - span.start) == 0) || is_passthrough_command(working_set.delta.get_file_contents()) { diff --git a/crates/nu-cli/src/completions/completer.rs b/crates/nu-cli/src/completions/completer.rs index d1cc7fd7fb..1cbab139c3 100644 --- a/crates/nu-cli/src/completions/completer.rs +++ b/crates/nu-cli/src/completions/completer.rs @@ -490,7 +490,7 @@ fn most_left_variable( let result = working_set.get_span_contents(item.0).to_vec(); match item.1 { - FlatShape::Variable => { + FlatShape::Variable(_) => { variables_found.push(result); found_var = true; diff --git a/crates/nu-cli/src/syntax_highlight.rs b/crates/nu-cli/src/syntax_highlight.rs index 77764599fd..51ca55376b 100644 --- a/crates/nu-cli/src/syntax_highlight.rs +++ b/crates/nu-cli/src/syntax_highlight.rs @@ -91,9 +91,10 @@ impl Highlighter for NuHighlighter { FlatShape::Int => add_colored_token(&shape.1, next_token), FlatShape::Float => add_colored_token(&shape.1, next_token), FlatShape::Range => add_colored_token(&shape.1, next_token), - FlatShape::InternalCall => add_colored_token(&shape.1, next_token), + FlatShape::InternalCall(_) => add_colored_token(&shape.1, next_token), FlatShape::External => add_colored_token(&shape.1, next_token), FlatShape::ExternalArg => add_colored_token(&shape.1, next_token), + FlatShape::Keyword => add_colored_token(&shape.1, next_token), FlatShape::Literal => add_colored_token(&shape.1, next_token), FlatShape::Operator => add_colored_token(&shape.1, next_token), FlatShape::Signature => add_colored_token(&shape.1, next_token), @@ -117,7 +118,9 @@ impl Highlighter for NuHighlighter { FlatShape::Filepath => add_colored_token(&shape.1, next_token), FlatShape::Directory => add_colored_token(&shape.1, next_token), FlatShape::GlobPattern => add_colored_token(&shape.1, next_token), - FlatShape::Variable => add_colored_token(&shape.1, next_token), + FlatShape::Variable(_) | FlatShape::VarDecl(_) => { + add_colored_token(&shape.1, next_token) + } FlatShape::Flag => add_colored_token(&shape.1, next_token), FlatShape::Pipe => add_colored_token(&shape.1, next_token), FlatShape::And => add_colored_token(&shape.1, next_token), diff --git a/crates/nu-color-config/src/shape_color.rs b/crates/nu-color-config/src/shape_color.rs index 8fa83c4c6d..fab25b47e3 100644 --- a/crates/nu-color-config/src/shape_color.rs +++ b/crates/nu-color-config/src/shape_color.rs @@ -21,6 +21,7 @@ pub fn default_shape_color(shape: String) -> Style { "shape_globpattern" => Style::new().fg(Color::Cyan).bold(), "shape_int" => Style::new().fg(Color::Purple).bold(), "shape_internalcall" => Style::new().fg(Color::Cyan).bold(), + "shape_keyword" => Style::new().fg(Color::Cyan).bold(), "shape_list" => Style::new().fg(Color::Cyan).bold(), "shape_literal" => Style::new().fg(Color::Blue), "shape_match_pattern" => Style::new().fg(Color::Green), @@ -36,6 +37,7 @@ pub fn default_shape_color(shape: String) -> Style { "shape_string_interpolation" => Style::new().fg(Color::Cyan).bold(), "shape_table" => Style::new().fg(Color::Blue).bold(), "shape_variable" => Style::new().fg(Color::Purple), + "shape_vardecl" => Style::new().fg(Color::Purple), _ => Style::default(), } } diff --git a/crates/nu-parser/src/flatten.rs b/crates/nu-parser/src/flatten.rs index 82b2306aa0..9182609e49 100644 --- a/crates/nu-parser/src/flatten.rs +++ b/crates/nu-parser/src/flatten.rs @@ -2,8 +2,8 @@ use nu_protocol::ast::{ Block, Expr, Expression, ImportPatternMember, MatchPattern, PathMember, Pattern, Pipeline, PipelineElement, }; -use nu_protocol::DeclId; use nu_protocol::{engine::StateWorkingSet, Span}; +use nu_protocol::{DeclId, VarId}; use std::fmt::{Display, Formatter, Result}; #[derive(Debug, Eq, PartialEq, Ord, Clone, PartialOrd)] @@ -23,7 +23,8 @@ pub enum FlatShape { Garbage, GlobPattern, Int, - InternalCall, + InternalCall(DeclId), + Keyword, List, Literal, MatchPattern, @@ -38,7 +39,8 @@ pub enum FlatShape { String, StringInterpolation, Table, - Variable, + Variable(VarId), + VarDecl(VarId), } impl Display for FlatShape { @@ -59,7 +61,8 @@ impl Display for FlatShape { FlatShape::Garbage => write!(f, "shape_garbage"), FlatShape::GlobPattern => write!(f, "shape_globpattern"), FlatShape::Int => write!(f, "shape_int"), - FlatShape::InternalCall => write!(f, "shape_internalcall"), + FlatShape::InternalCall(_) => write!(f, "shape_internalcall"), + FlatShape::Keyword => write!(f, "shape_keyword"), FlatShape::List => write!(f, "shape_list"), FlatShape::Literal => write!(f, "shape_literal"), FlatShape::MatchPattern => write!(f, "shape_match_pattern"), @@ -74,7 +77,8 @@ impl Display for FlatShape { FlatShape::String => write!(f, "shape_string"), FlatShape::StringInterpolation => write!(f, "shape_string_interpolation"), FlatShape::Table => write!(f, "shape_table"), - FlatShape::Variable => write!(f, "shape_variable"), + FlatShape::Variable(_) => write!(f, "shape_variable"), + FlatShape::VarDecl(_) => write!(f, "shape_vardecl"), } } } @@ -145,7 +149,7 @@ pub fn flatten_expression( output } Expr::Call(call) => { - let mut output = vec![(call.head, FlatShape::InternalCall)]; + let mut output = vec![(call.head, FlatShape::InternalCall(call.decl_id))]; let mut args = vec![]; for positional in call.positional_iter() { @@ -392,7 +396,7 @@ pub fn flatten_expression( output } Expr::Keyword(_, span, expr) => { - let mut output = vec![(*span, FlatShape::InternalCall)]; + let mut output = vec![(*span, FlatShape::Keyword)]; output.extend(flatten_expression(working_set, expr)); output } @@ -447,8 +451,11 @@ pub fn flatten_expression( output } - Expr::Var(_) | Expr::VarDecl(_) => { - vec![(expr.span, FlatShape::Variable)] + Expr::Var(var_id) => { + vec![(expr.span, FlatShape::Variable(*var_id))] + } + Expr::VarDecl(var_id) => { + vec![(expr.span, FlatShape::VarDecl(*var_id))] } } } @@ -559,11 +566,11 @@ pub fn flatten_pattern(match_pattern: &MatchPattern) -> Vec<(Span, FlatShape)> { Pattern::Value(_) => { output.push((match_pattern.span, FlatShape::MatchPattern)); } - Pattern::Variable(_) => { - output.push((match_pattern.span, FlatShape::Variable)); + Pattern::Variable(var_id) => { + output.push((match_pattern.span, FlatShape::VarDecl(*var_id))); } - Pattern::Rest(_) => { - output.push((match_pattern.span, FlatShape::Variable)); + Pattern::Rest(var_id) => { + output.push((match_pattern.span, FlatShape::VarDecl(*var_id))); } Pattern::Or(patterns) => { for pattern in patterns { diff --git a/crates/nu-utils/src/sample_config/default_config.nu b/crates/nu-utils/src/sample_config/default_config.nu index a6db657b38..25f818e451 100644 --- a/crates/nu-utils/src/sample_config/default_config.nu +++ b/crates/nu-utils/src/sample_config/default_config.nu @@ -86,6 +86,7 @@ let dark_theme = { shape_string_interpolation: cyan_bold shape_table: blue_bold shape_variable: purple + shape_vardecl: purple } let light_theme = { @@ -168,6 +169,7 @@ let light_theme = { shape_string_interpolation: cyan_bold shape_table: blue_bold shape_variable: purple + shape_vardecl: purple } # External completer example diff --git a/src/command.rs b/src/command.rs index bb36296801..5772f3d4c6 100644 --- a/src/command.rs +++ b/src/command.rs @@ -36,7 +36,8 @@ pub(crate) fn gather_commandline_args() -> (Vec, String, Vec) { | "--env-config" => args.next().map(|a| escape_quote_string(&a)), #[cfg(feature = "plugin")] "--plugin-config" => args.next().map(|a| escape_quote_string(&a)), - "--log-level" | "--log-target" | "--testbin" | "--threads" | "-t" => args.next(), + "--log-level" | "--log-target" | "--testbin" | "--threads" | "-t" + | "--ide-goto-def" | "--ide-hover" | "--ide-complete" => args.next(), _ => None, }; @@ -95,6 +96,12 @@ pub(crate) fn parse_commandline_args( )) = pipeline.elements.get(0) { let redirect_stdin = call.get_named_arg("stdin"); + let ide_goto_def: Option = + call.get_flag(engine_state, &mut stack, "ide-goto-def")?; + let ide_hover: Option = call.get_flag(engine_state, &mut stack, "ide-hover")?; + let ide_complete: Option = + call.get_flag(engine_state, &mut stack, "ide-complete")?; + let ide_check = call.get_named_arg("ide-check"); let login_shell = call.get_named_arg("login"); let interactive_shell = call.get_named_arg("interactive"); let commands: Option = call.get_flag_expr("commands"); @@ -180,6 +187,10 @@ pub(crate) fn parse_commandline_args( log_level, log_target, execute, + ide_goto_def, + ide_hover, + ide_complete, + ide_check, table_mode, }); } @@ -212,6 +223,10 @@ pub(crate) struct NushellCliArgs { pub(crate) log_target: Option>, pub(crate) execute: Option>, pub(crate) table_mode: Option, + pub(crate) ide_goto_def: Option, + pub(crate) ide_hover: Option, + pub(crate) ide_complete: Option, + pub(crate) ide_check: Option>, } #[derive(Clone)] @@ -268,6 +283,29 @@ impl Command for Nu { SyntaxShape::String, "start with an alternate environment config file", None, + ) + .named( + "ide-goto-def", + SyntaxShape::Int, + "go to the definition of the item at the given position", + None, + ) + .named( + "ide-hover", + SyntaxShape::Int, + "give information about the item at the given position", + None, + ) + .named( + "ide-complete", + SyntaxShape::Int, + "list completions for the item at the given position", + None, + ) + .switch( + "ide-check", + "run a diagnostic check on the given source", + None, ); #[cfg(feature = "plugin")] diff --git a/src/ide.rs b/src/ide.rs new file mode 100644 index 0000000000..8c50934322 --- /dev/null +++ b/src/ide.rs @@ -0,0 +1,471 @@ +use miette::IntoDiagnostic; +use nu_cli::{report_error, NuCompleter}; +use nu_parser::{flatten_block, parse, FlatShape}; +use nu_protocol::{ + engine::{EngineState, Stack, StateWorkingSet}, + DeclId, ShellError, Span, Value, VarId, +}; +use reedline::Completer; +use serde_json::json; +use std::sync::Arc; + +enum Id { + Variable(VarId), + Declaration(DeclId), + Value(FlatShape), +} + +fn find_id( + working_set: &mut StateWorkingSet, + file_path: &str, + file: &[u8], + location: &Value, +) -> Option<(Id, usize, Span)> { + let offset = working_set.next_span_start(); + let (block, _) = parse(working_set, Some(file_path), file, false, &[]); + + let flattened = flatten_block(working_set, &block); + + if let Ok(location) = location.as_i64() { + let location = location as usize + offset; + for item in flattened { + if location >= item.0.start && location < item.0.end { + match &item.1 { + FlatShape::Variable(var_id) | FlatShape::VarDecl(var_id) => { + return Some((Id::Variable(*var_id), offset, item.0)); + } + FlatShape::InternalCall(decl_id) => { + return Some((Id::Declaration(*decl_id), offset, item.0)); + } + _ => return Some((Id::Value(item.1), offset, item.0)), + } + } + } + None + } else { + None + } +} + +fn read_in_file<'a>( + engine_state: &'a mut EngineState, + file_path: &String, +) -> (Vec, StateWorkingSet<'a>) { + let file = std::fs::read(file_path) + .into_diagnostic() + .unwrap_or_else(|e| { + let working_set = StateWorkingSet::new(engine_state); + report_error( + &working_set, + &ShellError::FileNotFoundCustom( + format!("Could not read file '{}': {:?}", file_path, e.to_string()), + Span::unknown(), + ), + ); + std::process::exit(1); + }); + + engine_state.start_in_file(Some(file_path)); + + let working_set = StateWorkingSet::new(engine_state); + + (file, working_set) +} + +pub fn check(engine_state: &mut EngineState, file_path: &String) { + let mut working_set = StateWorkingSet::new(engine_state); + let file = std::fs::read(file_path); + + if let Ok(contents) = file { + let offset = working_set.next_span_start(); + let (block, err) = parse(&mut working_set, Some(file_path), &contents, false, &[]); + + if let Some(err) = err { + let mut span = err.span(); + span.start -= offset; + span.end -= offset; + + let msg = err.to_string(); + + println!( + "{}", + json!({ + "type": "diagnostic", + "severity": "Error", + "message": msg, + "span": { + "start": span.start, + "end": span.end + } + }) + ); + } + + let flattened = flatten_block(&working_set, &block); + + for flat in flattened { + if let FlatShape::VarDecl(var_id) = flat.1 { + let var = working_set.get_variable(var_id); + println!( + "{}", + json!({ + "type": "hint", + "typename": var.ty, + "position": { + "start": flat.0.start - offset, + "end": flat.0.end - offset + } + }) + ); + } + } + } +} + +pub fn goto_def(engine_state: &mut EngineState, file_path: &String, location: &Value) { + let (file, mut working_set) = read_in_file(engine_state, file_path); + + match find_id(&mut working_set, file_path, &file, location) { + Some((Id::Declaration(decl_id), offset, _)) => { + let result = working_set.get_decl(decl_id); + if let Some(block_id) = result.get_block_id() { + let block = working_set.get_block(block_id); + if let Some(span) = &block.span { + for file in working_set.files() { + if span.start >= file.1 && span.start < file.2 { + println!( + "{}", + json!( + { + "file": file.0, + "start": span.start - offset, + "end": span.end - offset + } + ) + ); + return; + } + } + } + } + } + Some((Id::Variable(var_id), offset, _)) => { + let var = working_set.get_variable(var_id); + for file in working_set.files() { + if var.declaration_span.start >= file.1 && var.declaration_span.start < file.2 { + println!( + "{}", + json!( + { + "file": file.0, + "start": var.declaration_span.start - offset, + "end": var.declaration_span.end - offset + } + ) + ); + return; + } + } + } + _ => {} + } + + println!("{{}}"); +} + +pub fn hover(engine_state: &mut EngineState, file_path: &String, location: &Value) { + let (file, mut working_set) = read_in_file(engine_state, file_path); + + match find_id(&mut working_set, file_path, &file, location) { + Some((Id::Declaration(decl_id), offset, span)) => { + let decl = working_set.get_decl(decl_id); + + let mut description = format!("```\n### Signature\n```\n{}\n\n", decl.signature()); + + description.push_str(&format!("```\n### Usage\n {}\n```\n", decl.usage())); + + if !decl.extra_usage().is_empty() { + description.push_str(&format!( + "\n```\n### Extra usage:\n {}\n```\n", + decl.extra_usage() + )); + } + + if !decl.examples().is_empty() { + description.push_str("\n```\n### Example(s)\n```\n"); + + for example in decl.examples() { + description.push_str(&format!( + "```\n {}\n```\n {}\n\n", + example.description, example.example + )); + } + } + + println!( + "{}", + json!({ + "hover": description, + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ); + } + Some((Id::Variable(var_id), offset, span)) => { + let var = working_set.get_variable(var_id); + + println!( + "{}", + json!({ + "hover": format!("{}{}", if var.mutable { "mutable " } else { "" }, var.ty), + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ); + } + Some((Id::Value(shape), offset, span)) => match shape { + FlatShape::Binary => println!( + "{}", + json!({ + "hover": "binary", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Bool => println!( + "{}", + json!({ + "hover": "bool", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::DateTime => println!( + "{}", + json!({ + "hover": "datetime", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::External => println!( + "{}", + json!({ + "hover": "external", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::ExternalArg => println!( + "{}", + json!({ + "hover": "external arg", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Flag => println!( + "{}", + json!({ + "hover": "flag", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Block => println!( + "{}", + json!({ + "hover": "block", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Directory => println!( + "{}", + json!({ + "hover": "directory", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Filepath => println!( + "{}", + json!({ + "hover": "file path", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Float => println!( + "{}", + json!({ + "hover": "float", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::GlobPattern => println!( + "{}", + json!({ + "hover": "glob pattern", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Int => println!( + "{}", + json!({ + "hover": "int", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Keyword => println!( + "{}", + json!({ + "hover": "keyword", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::List => println!( + "{}", + json!({ + "hover": "list", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::MatchPattern => println!( + "{}", + json!({ + "hover": "match pattern", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Nothing => println!( + "{}", + json!({ + "hover": "nothing", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Range => println!( + "{}", + json!({ + "hover": "range", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Record => println!( + "{}", + json!({ + "hover": "record", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::String => println!( + "{}", + json!({ + "hover": "string", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::StringInterpolation => println!( + "{}", + json!({ + "hover": "string interpolation", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + FlatShape::Table => println!( + "{}", + json!({ + "hover": "table", + "span": { + "start": span.start - offset, + "end": span.end - offset + } + }) + ), + _ => {} + }, + _ => {} + } +} + +pub fn complete(engine_reference: Arc, file_path: &String, location: &Value) { + let stack = Stack::new(); + let mut completer = NuCompleter::new(engine_reference, stack); + + let file = std::fs::read(file_path) + .into_diagnostic() + .unwrap_or_else(|_| { + std::process::exit(1); + }); + + if let Ok(location) = location.as_i64() { + let results = completer.complete(&String::from_utf8_lossy(&file), location as usize); + print!("{{\"completions\": ["); + let mut first = true; + for result in results { + if !first { + print!(", ") + } else { + first = false; + } + print!("\"{}\"", result.value,) + } + println!("]}}"); + } +} diff --git a/src/main.rs b/src/main.rs index 240fdcca7e..87a3f809bb 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,5 +1,6 @@ mod command; mod config_files; +mod ide; mod logger; mod run; mod signals; @@ -136,6 +137,25 @@ fn main() -> Result<()> { use_color, ); + // IDE commands + if let Some(ide_goto_def) = parsed_nu_cli_args.ide_goto_def { + ide::goto_def(&mut engine_state, &script_name, &ide_goto_def); + + return Ok(()); + } else if let Some(ide_hover) = parsed_nu_cli_args.ide_hover { + ide::hover(&mut engine_state, &script_name, &ide_hover); + + return Ok(()); + } else if let Some(ide_complete) = parsed_nu_cli_args.ide_complete { + ide::complete(Arc::new(engine_state), &script_name, &ide_complete); + + return Ok(()); + } else if parsed_nu_cli_args.ide_check.is_some() { + ide::check(&mut engine_state, &script_name); + + return Ok(()); + } + start_time = std::time::Instant::now(); if let Some(testbin) = &parsed_nu_cli_args.testbin { // Call out to the correct testbin