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>

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 {