0
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-10-29 08:58:01 -04:00
denoland-deno/cli/tools/repl/editor.rs
Roy Li 2c7174a5a2
fix(repl): Hide indexable properties in tab completion (#18141)
Closes #17831. This change hides the indices of any indexed collection
when triggering tab completion for object properties in the REPL.

An example is shown in the issue, but for verbosity here is another.

Before the change:
```
> const arr = new Uint8ClampedArray([1, 2, 3])
undefined
> arr.
0                     map
1                     reverse
2                     reduce
...
```
After the change:
```
> const arr = new Uint8ClampedArray([1, 2, 3])
undefined
> arr.
constructor               reduce
BYTES_PER_ELEMENT         reduceRight
buffer                    set
...
```

Co-authored-by: David Sherret <dsherret@users.noreply.github.com>
2023-03-16 19:46:50 +00:00

560 lines
17 KiB
Rust

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use crate::colors;
use deno_ast::swc::parser::error::SyntaxError;
use deno_ast::swc::parser::token::BinOpToken;
use deno_ast::swc::parser::token::Token;
use deno_ast::swc::parser::token::Word;
use deno_ast::view::AssignOp;
use deno_core::anyhow::Context as _;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
use deno_core::serde_json;
use rustyline::completion::Completer;
use rustyline::error::ReadlineError;
use rustyline::highlight::Highlighter;
use rustyline::validate::ValidationContext;
use rustyline::validate::ValidationResult;
use rustyline::validate::Validator;
use rustyline::Cmd;
use rustyline::CompletionType;
use rustyline::ConditionalEventHandler;
use rustyline::Config;
use rustyline::Context;
use rustyline::Editor;
use rustyline::Event;
use rustyline::EventContext;
use rustyline::EventHandler;
use rustyline::KeyCode;
use rustyline::KeyEvent;
use rustyline::Modifiers;
use rustyline::RepeatCount;
use rustyline_derive::Helper;
use rustyline_derive::Hinter;
use std::borrow::Cow;
use std::path::PathBuf;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::Relaxed;
use std::sync::Arc;
use super::cdp;
use super::channel::RustylineSyncMessageSender;
use super::session::REPL_INTERNALS_NAME;
// Provides helpers to the editor like validation for multi-line edits, completion candidates for
// tab completion.
#[derive(Helper, Hinter)]
pub struct EditorHelper {
pub context_id: u64,
pub sync_sender: RustylineSyncMessageSender,
}
impl EditorHelper {
pub fn get_global_lexical_scope_names(&self) -> Vec<String> {
let evaluate_response = self
.sync_sender
.post_message(
"Runtime.globalLexicalScopeNames",
Some(cdp::GlobalLexicalScopeNamesArgs {
execution_context_id: Some(self.context_id),
}),
)
.unwrap();
let evaluate_response: cdp::GlobalLexicalScopeNamesResponse =
serde_json::from_value(evaluate_response).unwrap();
evaluate_response.names
}
pub fn get_expression_property_names(&self, expr: &str) -> Vec<String> {
// try to get the properties from the expression
if let Some(properties) = self.get_object_expr_properties(expr) {
return properties;
}
// otherwise fall back to the prototype
let expr_type = self.get_expression_type(expr);
let object_expr = match expr_type.as_deref() {
// possibilities: https://chromedevtools.github.io/devtools-protocol/v8/Runtime/#type-RemoteObject
Some("object") => "Object.prototype",
Some("function") => "Function.prototype",
Some("string") => "String.prototype",
Some("boolean") => "Boolean.prototype",
Some("bigint") => "BigInt.prototype",
Some("number") => "Number.prototype",
_ => return Vec::new(), // undefined, symbol, and unhandled
};
self
.get_object_expr_properties(object_expr)
.unwrap_or_default()
}
fn get_expression_type(&self, expr: &str) -> Option<String> {
self.evaluate_expression(expr).map(|res| res.result.kind)
}
fn get_object_expr_properties(
&self,
object_expr: &str,
) -> Option<Vec<String>> {
let evaluate_result = self.evaluate_expression(object_expr)?;
let object_id = evaluate_result.result.object_id?;
let get_properties_response = self
.sync_sender
.post_message(
"Runtime.getProperties",
Some(cdp::GetPropertiesArgs {
object_id,
own_properties: None,
accessor_properties_only: None,
generate_preview: None,
non_indexed_properties_only: Some(true),
}),
)
.ok()?;
let get_properties_response: cdp::GetPropertiesResponse =
serde_json::from_value(get_properties_response).ok()?;
Some(
get_properties_response
.result
.into_iter()
.map(|prop| prop.name)
.collect(),
)
}
fn evaluate_expression(&self, expr: &str) -> Option<cdp::EvaluateResponse> {
let evaluate_response = self
.sync_sender
.post_message(
"Runtime.evaluate",
Some(cdp::EvaluateArgs {
expression: expr.to_string(),
object_group: None,
include_command_line_api: None,
silent: None,
context_id: Some(self.context_id),
return_by_value: None,
generate_preview: None,
user_gesture: None,
await_promise: None,
throw_on_side_effect: Some(true),
timeout: Some(200),
disable_breaks: None,
repl_mode: None,
allow_unsafe_eval_blocked_by_csp: None,
unique_context_id: None,
}),
)
.ok()?;
let evaluate_response: cdp::EvaluateResponse =
serde_json::from_value(evaluate_response).ok()?;
if evaluate_response.exception_details.is_some() {
None
} else {
Some(evaluate_response)
}
}
}
fn is_word_boundary(c: char) -> bool {
if matches!(c, '.' | '_' | '$') {
false
} else {
char::is_ascii_whitespace(&c) || char::is_ascii_punctuation(&c)
}
}
fn get_expr_from_line_at_pos(line: &str, cursor_pos: usize) -> &str {
let start = line[..cursor_pos].rfind(is_word_boundary).unwrap_or(0);
let end = line[cursor_pos..]
.rfind(is_word_boundary)
.map(|i| cursor_pos + i)
.unwrap_or(cursor_pos);
let word = &line[start..end];
let word = word.strip_prefix(is_word_boundary).unwrap_or(word);
let word = word.strip_suffix(is_word_boundary).unwrap_or(word);
word
}
impl Completer for EditorHelper {
type Candidate = String;
fn complete(
&self,
line: &str,
pos: usize,
_ctx: &Context<'_>,
) -> Result<(usize, Vec<String>), ReadlineError> {
let lsp_completions = self.sync_sender.lsp_completions(line, pos);
if !lsp_completions.is_empty() {
// assumes all lsp completions have the same start position
return Ok((
lsp_completions[0].range.start,
lsp_completions.into_iter().map(|c| c.new_text).collect(),
));
}
let expr = get_expr_from_line_at_pos(line, pos);
// check if the expression is in the form `obj.prop`
if let Some(index) = expr.rfind('.') {
let sub_expr = &expr[..index];
let prop_name = &expr[index + 1..];
let candidates = self
.get_expression_property_names(sub_expr)
.into_iter()
.filter(|n| {
!n.starts_with("Symbol(")
&& n.starts_with(prop_name)
&& n != &*REPL_INTERNALS_NAME
})
.collect();
Ok((pos - prop_name.len(), candidates))
} else {
// combine results of declarations and globalThis properties
let mut candidates = self
.get_expression_property_names("globalThis")
.into_iter()
.chain(self.get_global_lexical_scope_names())
.filter(|n| n.starts_with(expr) && n != &*REPL_INTERNALS_NAME)
.collect::<Vec<_>>();
// sort and remove duplicates
candidates.sort();
candidates.dedup(); // make sure to sort first
Ok((pos - expr.len(), candidates))
}
}
}
impl Validator for EditorHelper {
fn validate(
&self,
ctx: &mut ValidationContext,
) -> Result<ValidationResult, ReadlineError> {
Ok(validate(ctx.input()))
}
}
fn validate(input: &str) -> ValidationResult {
let line_info = text_lines::TextLines::new(input);
let mut stack: Vec<Token> = Vec::new();
let mut in_template = false;
let mut div_token_count_on_current_line = 0;
let mut last_line_index = 0;
for item in deno_ast::lex(input, deno_ast::MediaType::TypeScript) {
let current_line_index = line_info.line_index(item.range.start);
if current_line_index != last_line_index {
div_token_count_on_current_line = 0;
last_line_index = current_line_index;
}
if let deno_ast::TokenOrComment::Token(token) = item.inner {
match token {
Token::BinOp(BinOpToken::Div)
| Token::AssignOp(AssignOp::DivAssign) => {
// it's too complicated to write code to detect regular expression literals
// which are no longer tokenized, so if a `/` or `/=` happens twice on the same
// line, then we bail
div_token_count_on_current_line += 1;
if div_token_count_on_current_line >= 2 {
return ValidationResult::Valid(None);
}
}
Token::BackQuote => in_template = !in_template,
Token::LParen
| Token::LBracket
| Token::LBrace
| Token::DollarLBrace => stack.push(token),
Token::RParen | Token::RBracket | Token::RBrace => {
match (stack.pop(), token) {
(Some(Token::LParen), Token::RParen)
| (Some(Token::LBracket), Token::RBracket)
| (Some(Token::LBrace), Token::RBrace)
| (Some(Token::DollarLBrace), Token::RBrace) => {}
(Some(left), _) => {
return ValidationResult::Invalid(Some(format!(
"Mismatched pairs: {left:?} is not properly closed"
)))
}
(None, _) => {
// While technically invalid when unpaired, it should be V8's task to output error instead.
// Thus marked as valid with no info.
return ValidationResult::Valid(None);
}
}
}
Token::Error(error) => {
match error.kind() {
// If there is unterminated template, it continues to read input.
SyntaxError::UnterminatedTpl => {}
_ => {
// If it failed parsing, it should be V8's task to output error instead.
// Thus marked as valid with no info.
return ValidationResult::Valid(None);
}
}
}
_ => {}
}
}
}
if !stack.is_empty() || in_template {
return ValidationResult::Incomplete;
}
ValidationResult::Valid(None)
}
impl Highlighter for EditorHelper {
fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
hint.into()
}
fn highlight_candidate<'c>(
&self,
candidate: &'c str,
completion: rustyline::CompletionType,
) -> Cow<'c, str> {
if completion == CompletionType::List {
candidate.into()
} else {
self.highlight(candidate, 0)
}
}
fn highlight_char(&self, line: &str, _: usize) -> bool {
!line.is_empty()
}
fn highlight<'l>(&self, line: &'l str, _: usize) -> Cow<'l, str> {
let mut out_line = String::from(line);
let mut lexed_items = deno_ast::lex(line, deno_ast::MediaType::TypeScript)
.into_iter()
.peekable();
while let Some(item) = lexed_items.next() {
// Adding color adds more bytes to the string,
// so an offset is needed to stop spans falling out of sync.
let offset = out_line.len() - line.len();
let range = item.range;
out_line.replace_range(
range.start + offset..range.end + offset,
&match item.inner {
deno_ast::TokenOrComment::Token(token) => match token {
Token::Str { .. } | Token::Template { .. } | Token::BackQuote => {
colors::green(&line[range]).to_string()
}
Token::Regex(_, _) => colors::red(&line[range]).to_string(),
Token::Num { .. } | Token::BigInt { .. } => {
colors::yellow(&line[range]).to_string()
}
Token::Word(word) => match word {
Word::True | Word::False | Word::Null => {
colors::yellow(&line[range]).to_string()
}
Word::Keyword(_) => colors::cyan(&line[range]).to_string(),
Word::Ident(ident) => {
if ident == *"undefined" {
colors::gray(&line[range]).to_string()
} else if ident == *"Infinity" || ident == *"NaN" {
colors::yellow(&line[range]).to_string()
} else if ident == *"async" || ident == *"of" {
colors::cyan(&line[range]).to_string()
} else {
let next = lexed_items.peek().map(|item| &item.inner);
if matches!(
next,
Some(deno_ast::TokenOrComment::Token(Token::LParen))
) {
// We're looking for something that looks like a function
// We use a simple heuristic: 'ident' followed by 'LParen'
colors::intense_blue(&line[range]).to_string()
} else {
line[range].to_string()
}
}
}
},
_ => line[range].to_string(),
},
deno_ast::TokenOrComment::Comment { .. } => {
colors::gray(&line[range]).to_string()
}
},
);
}
out_line.into()
}
}
#[derive(Clone)]
pub struct ReplEditor {
inner: Arc<Mutex<Editor<EditorHelper>>>,
history_file_path: Option<PathBuf>,
errored_on_history_save: Arc<AtomicBool>,
should_exit_on_interrupt: Arc<AtomicBool>,
}
impl ReplEditor {
pub fn new(
helper: EditorHelper,
history_file_path: Option<PathBuf>,
) -> Result<Self, AnyError> {
let editor_config = Config::builder()
.completion_type(CompletionType::List)
.build();
let mut editor =
Editor::with_config(editor_config).expect("Failed to create editor.");
editor.set_helper(Some(helper));
if let Some(history_file_path) = &history_file_path {
editor.load_history(history_file_path).unwrap_or(());
}
editor.bind_sequence(
KeyEvent(KeyCode::Char('s'), Modifiers::CTRL),
EventHandler::Simple(Cmd::Newline),
);
editor.bind_sequence(
KeyEvent(KeyCode::Tab, Modifiers::NONE),
EventHandler::Conditional(Box::new(TabEventHandler)),
);
let should_exit_on_interrupt = Arc::new(AtomicBool::new(false));
editor.bind_sequence(
KeyEvent(KeyCode::Char('r'), Modifiers::CTRL),
EventHandler::Conditional(Box::new(ReverseSearchHistoryEventHandler {
should_exit_on_interrupt: should_exit_on_interrupt.clone(),
})),
);
if let Some(history_file_path) = &history_file_path {
let history_file_dir = history_file_path.parent().unwrap();
std::fs::create_dir_all(history_file_dir).with_context(|| {
format!(
"Unable to create directory for the history file: {}",
history_file_dir.display()
)
})?;
}
Ok(ReplEditor {
inner: Arc::new(Mutex::new(editor)),
history_file_path,
errored_on_history_save: Arc::new(AtomicBool::new(false)),
should_exit_on_interrupt,
})
}
pub fn readline(&self) -> Result<String, ReadlineError> {
self.inner.lock().readline("> ")
}
pub fn update_history(&self, entry: String) {
self.inner.lock().add_history_entry(entry);
if let Some(history_file_path) = &self.history_file_path {
if let Err(e) = self.inner.lock().append_history(history_file_path) {
if self.errored_on_history_save.load(Relaxed) {
return;
}
self.errored_on_history_save.store(true, Relaxed);
eprintln!("Unable to save history file: {e}");
}
}
}
pub fn should_exit_on_interrupt(&self) -> bool {
self.should_exit_on_interrupt.load(Relaxed)
}
pub fn set_should_exit_on_interrupt(&self, yes: bool) {
self.should_exit_on_interrupt.store(yes, Relaxed);
}
}
/// Command to reverse search history , same as rustyline default C-R but that resets repl should_exit flag to false
struct ReverseSearchHistoryEventHandler {
should_exit_on_interrupt: Arc<AtomicBool>,
}
impl ConditionalEventHandler for ReverseSearchHistoryEventHandler {
fn handle(
&self,
_: &Event,
_: RepeatCount,
_: bool,
_: &EventContext,
) -> Option<Cmd> {
self.should_exit_on_interrupt.store(false, Relaxed);
Some(Cmd::ReverseSearchHistory)
}
}
/// A custom tab key event handler
/// It uses a heuristic to determine if the user is requesting completion or if they want to insert an actual tab
/// The heuristic goes like this:
/// - If the last character before the cursor is whitespace, the the user wants to insert a tab
/// - Else the user is requesting completion
struct TabEventHandler;
impl ConditionalEventHandler for TabEventHandler {
fn handle(
&self,
evt: &Event,
n: RepeatCount,
_: bool,
ctx: &EventContext,
) -> Option<Cmd> {
debug_assert_eq!(
*evt,
Event::from(KeyEvent(KeyCode::Tab, Modifiers::NONE))
);
if ctx.line().is_empty()
|| ctx.line()[..ctx.pos()]
.chars()
.rev()
.next()
.filter(|c| c.is_whitespace())
.is_some()
{
if cfg!(target_os = "windows") {
// Inserting a tab is broken in windows with rustyline
// use 4 spaces as a workaround for now
Some(Cmd::Insert(n, " ".into()))
} else {
Some(Cmd::Insert(n, "\t".into()))
}
} else {
None // default complete
}
}
}
#[cfg(test)]
mod test {
use rustyline::validate::ValidationResult;
use super::validate;
#[test]
fn validate_only_one_forward_slash_per_line() {
let code = r#"function test(arr){
if( arr.length <= 1) return arr.map(a => a / 2)
let left = test( arr.slice( 0 , arr.length/2 ) )"#;
assert!(matches!(validate(code), ValidationResult::Incomplete));
}
#[test]
fn validate_regex_looking_code() {
let code = r#"/testing/;"#;
assert!(matches!(validate(code), ValidationResult::Valid(_)));
}
}