mirror of
https://github.com/denoland/deno.git
synced 2024-12-13 02:52:54 -05:00
2c7174a5a2
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>
560 lines
17 KiB
Rust
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(_)));
|
|
}
|
|
}
|