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

@@ -2703,6 +2703,7 @@ dependencies = [
  "rayon",
  "reedline",
  "rstest",
+ "serde_json",
  "serial_test",
  "signal-hook",
  "simplelog",

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

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())
         {

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;
 

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),

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(),
     }
 }

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(_) => {
+        Expr::Var(var_id) => {
-            vec![(expr.span, FlatShape::Variable)]
+            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(_) => {
+        Pattern::Variable(var_id) => {
-            output.push((match_pattern.span, FlatShape::Variable));
+            output.push((match_pattern.span, FlatShape::VarDecl(*var_id)));
         }
-        Pattern::Rest(_) => {
+        Pattern::Rest(var_id) => {
-            output.push((match_pattern.span, FlatShape::Variable));
+            output.push((match_pattern.span, FlatShape::VarDecl(*var_id)));
         }
         Pattern::Or(patterns) => {
             for pattern in patterns {

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

src/command.rs

@@ -36,7 +36,8 @@ pub(crate) fn gather_commandline_args() -> (Vec<String>, String, Vec<String>) {
             | "--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<Value> =
+                call.get_flag(engine_state, &mut stack, "ide-goto-def")?;
+            let ide_hover: Option<Value> = call.get_flag(engine_state, &mut stack, "ide-hover")?;
+            let ide_complete: Option<Value> =
+                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<Expression> = 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<Spanned<String>>,
     pub(crate) execute: Option<Spanned<String>>,
     pub(crate) table_mode: Option<Value>,
+    pub(crate) ide_goto_def: Option<Value>,
+    pub(crate) ide_hover: Option<Value>,
+    pub(crate) ide_complete: Option<Value>,
+    pub(crate) ide_check: Option<Spanned<String>>,
 }
 
 #[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")]

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<u8>, 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<EngineState>, 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!("]}}");
+    }
+}

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