extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2024-12-22 15:13:01 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add IDE support (#8745)

Browse Source 
# 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>
This commit is contained in:
JT 2023-04-06 07:34:47 +12:00 committed by GitHub
parent 91282d4404
commit 56efbd7de9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 564 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

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

1
Cargo.toml
View File

@ -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

4
crates/nu-cli/src/completions/command_completions.rs
View File

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

2
crates/nu-cli/src/completions/completer.rs
View File

@ -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;

7
crates/nu-cli/src/syntax_highlight.rs
View File

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

2
crates/nu-color-config/src/shape_color.rs
View File

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

33
crates/nu-parser/src/flatten.rs
View File

@ -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 {

2
crates/nu-utils/src/sample_config/default_config.nu
View File

@ -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

40
src/command.rs
View File

@ -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")]

471
src/ide.rs Normal file
View File

@ -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!("]}}");
}
}

20
src/main.rs
View File

@ -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