From 0c15deac760a654f03de3ae433e5260b5bdfb8c2 Mon Sep 17 00:00:00 2001 From: Wilco Kusee Date: Sat, 23 Mar 2019 12:07:21 +0100 Subject: Move typing to ra_ide_api --- crates/ra_ide_api/src/lib.rs | 7 +- crates/ra_ide_api/src/typing.rs | 408 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 412 insertions(+), 3 deletions(-) create mode 100644 crates/ra_ide_api/src/typing.rs (limited to 'crates/ra_ide_api') diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs index a838c30da..c2ef61ae2 100644 --- a/crates/ra_ide_api/src/lib.rs +++ b/crates/ra_ide_api/src/lib.rs @@ -37,6 +37,7 @@ mod line_index; mod folding_ranges; mod line_index_utils; mod join_lines; +mod typing; #[cfg(test)] mod marks; @@ -295,7 +296,7 @@ impl Analysis { /// up minor stuff like continuing the comment. pub fn on_enter(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); - let edit = ra_ide_api_light::on_enter(&file, position.offset)?; + let edit = typing::on_enter(&file, position.offset)?; Some(SourceChange::from_local_edit(position.file_id, edit)) } @@ -304,14 +305,14 @@ impl Analysis { // FIXME: use a snippet completion instead of this hack here. pub fn on_eq_typed(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); - let edit = ra_ide_api_light::on_eq_typed(&file, position.offset)?; + let edit = typing::on_eq_typed(&file, position.offset)?; Some(SourceChange::from_local_edit(position.file_id, edit)) } /// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately. pub fn on_dot_typed(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); - let edit = ra_ide_api_light::on_dot_typed(&file, position.offset)?; + let edit = typing::on_dot_typed(&file, position.offset)?; Some(SourceChange::from_local_edit(position.file_id, edit)) } diff --git a/crates/ra_ide_api/src/typing.rs b/crates/ra_ide_api/src/typing.rs new file mode 100644 index 000000000..b7e023d60 --- /dev/null +++ b/crates/ra_ide_api/src/typing.rs @@ -0,0 +1,408 @@ +use ra_syntax::{ + AstNode, SourceFile, SyntaxKind::*, + SyntaxNode, TextUnit, TextRange, + algo::{find_node_at_offset, find_leaf_at_offset, LeafAtOffset}, + ast::{self, AstToken}, +}; +use ra_fmt::leading_indent; +use crate::LocalEdit; +use ra_text_edit::TextEditBuilder; + +pub fn on_enter(file: &SourceFile, offset: TextUnit) -> Option { + let comment = + find_leaf_at_offset(file.syntax(), offset).left_biased().and_then(ast::Comment::cast)?; + + if let ast::CommentFlavor::Multiline = comment.flavor() { + return None; + } + + let prefix = comment.prefix(); + if offset < comment.syntax().range().start() + TextUnit::of_str(prefix) + TextUnit::from(1) { + return None; + } + + let indent = node_indent(file, comment.syntax())?; + let inserted = format!("\n{}{} ", indent, prefix); + let cursor_position = offset + TextUnit::of_str(&inserted); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, inserted); + Some(LocalEdit { + label: "on enter".to_string(), + edit: edit.finish(), + cursor_position: Some(cursor_position), + }) +} + +fn node_indent<'a>(file: &'a SourceFile, node: &SyntaxNode) -> Option<&'a str> { + let ws = match find_leaf_at_offset(file.syntax(), node.range().start()) { + LeafAtOffset::Between(l, r) => { + assert!(r == node); + l + } + LeafAtOffset::Single(n) => { + assert!(n == node); + return Some(""); + } + LeafAtOffset::None => unreachable!(), + }; + if ws.kind() != WHITESPACE { + return None; + } + let text = ws.leaf_text().unwrap(); + let pos = text.as_str().rfind('\n').map(|it| it + 1).unwrap_or(0); + Some(&text[pos..]) +} + +pub fn on_eq_typed(file: &SourceFile, eq_offset: TextUnit) -> Option { + assert_eq!(file.syntax().text().char_at(eq_offset), Some('=')); + let let_stmt: &ast::LetStmt = find_node_at_offset(file.syntax(), eq_offset)?; + if let_stmt.has_semi() { + return None; + } + if let Some(expr) = let_stmt.initializer() { + let expr_range = expr.syntax().range(); + if expr_range.contains(eq_offset) && eq_offset != expr_range.start() { + return None; + } + if file.syntax().text().slice(eq_offset..expr_range.start()).contains('\n') { + return None; + } + } else { + return None; + } + let offset = let_stmt.syntax().range().end(); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, ";".to_string()); + Some(LocalEdit { + label: "add semicolon".to_string(), + edit: edit.finish(), + cursor_position: None, + }) +} + +pub fn on_dot_typed(file: &SourceFile, dot_offset: TextUnit) -> Option { + assert_eq!(file.syntax().text().char_at(dot_offset), Some('.')); + + let whitespace = find_leaf_at_offset(file.syntax(), dot_offset) + .left_biased() + .and_then(ast::Whitespace::cast)?; + + let current_indent = { + let text = whitespace.text(); + let newline = text.rfind('\n')?; + &text[newline + 1..] + }; + let current_indent_len = TextUnit::of_str(current_indent); + + // Make sure dot is a part of call chain + let field_expr = whitespace.syntax().parent().and_then(ast::FieldExpr::cast)?; + let prev_indent = leading_indent(field_expr.syntax())?; + let target_indent = format!(" {}", prev_indent); + let target_indent_len = TextUnit::of_str(&target_indent); + if current_indent_len == target_indent_len { + return None; + } + let mut edit = TextEditBuilder::default(); + edit.replace( + TextRange::from_to(dot_offset - current_indent_len, dot_offset), + target_indent.into(), + ); + let res = LocalEdit { + label: "reindent dot".to_string(), + edit: edit.finish(), + cursor_position: Some( + dot_offset + target_indent_len - current_indent_len + TextUnit::of_char('.'), + ), + }; + Some(res) +} + +#[cfg(test)] +mod tests { + use test_utils::{add_cursor, assert_eq_text, extract_offset}; + + use super::*; + + #[test] + fn test_on_eq_typed() { + fn type_eq(before: &str, after: &str) { + let (offset, before) = extract_offset(before); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, "=".to_string()); + let before = edit.finish().apply(&before); + let file = SourceFile::parse(&before); + if let Some(result) = on_eq_typed(&file, offset) { + let actual = result.edit.apply(&before); + assert_eq_text!(after, &actual); + } else { + assert_eq_text!(&before, after) + }; + } + + // do_check(r" + // fn foo() { + // let foo =<|> + // } + // ", r" + // fn foo() { + // let foo =; + // } + // "); + type_eq( + r" +fn foo() { + let foo <|> 1 + 1 +} +", + r" +fn foo() { + let foo = 1 + 1; +} +", + ); + // do_check(r" + // fn foo() { + // let foo =<|> + // let bar = 1; + // } + // ", r" + // fn foo() { + // let foo =; + // let bar = 1; + // } + // "); + } + + fn type_dot(before: &str, after: &str) { + let (offset, before) = extract_offset(before); + let mut edit = TextEditBuilder::default(); + edit.insert(offset, ".".to_string()); + let before = edit.finish().apply(&before); + let file = SourceFile::parse(&before); + if let Some(result) = on_dot_typed(&file, offset) { + let actual = result.edit.apply(&before); + assert_eq_text!(after, &actual); + } else { + assert_eq_text!(&before, after) + }; + } + + #[test] + fn indents_new_chain_call() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + . + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + . + } + ", + ) + } + + #[test] + fn indents_new_chain_call_with_semi() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|>; + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .; + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + <|>; + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .; + } + ", + ) + } + + #[test] + fn indents_continued_chain_call() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + . + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + .first() + . + } + ", + ); + } + + #[test] + fn indents_middle_of_chain_call() { + type_dot( + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + <|> + .nth(92) + .unwrap(); + } + ", + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + . + .nth(92) + .unwrap(); + } + ", + ); + type_dot( + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + <|> + .nth(92) + .unwrap(); + } + ", + r" + fn source_impl() { + let var = enum_defvariant_list().unwrap() + . + .nth(92) + .unwrap(); + } + ", + ); + } + + #[test] + fn dont_indent_freestanding_dot() { + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + . + } + ", + ); + type_dot( + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + <|> + } + ", + r" + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + . + } + ", + ); + } + + #[test] + fn test_on_enter() { + fn apply_on_enter(before: &str) -> Option { + let (offset, before) = extract_offset(before); + let file = SourceFile::parse(&before); + let result = on_enter(&file, offset)?; + let actual = result.edit.apply(&before); + let actual = add_cursor(&actual, result.cursor_position.unwrap()); + Some(actual) + } + + fn do_check(before: &str, after: &str) { + let actual = apply_on_enter(before).unwrap(); + assert_eq_text!(after, &actual); + } + + fn do_check_noop(text: &str) { + assert!(apply_on_enter(text).is_none()) + } + + do_check( + r" +/// Some docs<|> +fn foo() { +} +", + r" +/// Some docs +/// <|> +fn foo() { +} +", + ); + do_check( + r" +impl S { + /// Some<|> docs. + fn foo() {} +} +", + r" +impl S { + /// Some + /// <|> docs. + fn foo() {} +} +", + ); + do_check_noop(r"<|>//! docz"); + } +} -- cgit v1.2.3 From a656b891fba4b89775adbc93114a20c99afe5f36 Mon Sep 17 00:00:00 2001 From: Wilco Kusee Date: Sat, 23 Mar 2019 16:55:47 +0100 Subject: Remove LocalEdit usage --- crates/ra_ide_api/src/lib.rs | 29 +++++---------- crates/ra_ide_api/src/typing.rs | 81 +++++++++++++++++++++++------------------ 2 files changed, 55 insertions(+), 55 deletions(-) (limited to 'crates/ra_ide_api') diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs index c2ef61ae2..0e7b47e3c 100644 --- a/crates/ra_ide_api/src/lib.rs +++ b/crates/ra_ide_api/src/lib.rs @@ -72,7 +72,7 @@ pub use crate::{ folding_ranges::{Fold, FoldKind}, }; pub use ra_ide_api_light::{ - HighlightedRange, Severity, StructureNode, LocalEdit, + HighlightedRange, Severity, StructureNode, }; pub use ra_db::{ Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId, @@ -295,9 +295,7 @@ impl Analysis { /// Returns an edit which should be applied when opening a new line, fixing /// up minor stuff like continuing the comment. pub fn on_enter(&self, position: FilePosition) -> Option { - let file = self.db.parse(position.file_id); - let edit = typing::on_enter(&file, position.offset)?; - Some(SourceChange::from_local_edit(position.file_id, edit)) + typing::on_enter(&self.db, position) } /// Returns an edit which should be applied after `=` was typed. Primarily, @@ -306,14 +304,17 @@ impl Analysis { pub fn on_eq_typed(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); let edit = typing::on_eq_typed(&file, position.offset)?; - Some(SourceChange::from_local_edit(position.file_id, edit)) + Some(SourceChange { + label: "add semicolon".to_string(), + source_file_edits: vec![SourceFileEdit { edit, file_id: position.file_id }], + file_system_edits: vec![], + cursor_position: None, + }) } /// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately. pub fn on_dot_typed(&self, position: FilePosition) -> Option { - let file = self.db.parse(position.file_id); - let edit = typing::on_dot_typed(&file, position.offset)?; - Some(SourceChange::from_local_edit(position.file_id, edit)) + typing::on_dot_typed(&self.db, position) } /// Returns a tree representation of symbols in the file. Useful to draw a @@ -435,18 +436,6 @@ impl Analysis { } } -impl SourceChange { - pub(crate) fn from_local_edit(file_id: FileId, edit: LocalEdit) -> SourceChange { - let file_edit = SourceFileEdit { file_id, edit: edit.edit }; - SourceChange { - label: edit.label, - source_file_edits: vec![file_edit], - file_system_edits: vec![], - cursor_position: edit.cursor_position.map(|offset| FilePosition { offset, file_id }), - } - } -} - #[test] fn analysis_is_send() { fn is_send() {} diff --git a/crates/ra_ide_api/src/typing.rs b/crates/ra_ide_api/src/typing.rs index b7e023d60..94b228466 100644 --- a/crates/ra_ide_api/src/typing.rs +++ b/crates/ra_ide_api/src/typing.rs @@ -5,31 +5,37 @@ use ra_syntax::{ ast::{self, AstToken}, }; use ra_fmt::leading_indent; -use crate::LocalEdit; -use ra_text_edit::TextEditBuilder; +use ra_text_edit::{TextEdit, TextEditBuilder}; +use ra_db::{FilePosition, SourceDatabase}; +use crate::{db::RootDatabase, SourceChange, SourceFileEdit}; -pub fn on_enter(file: &SourceFile, offset: TextUnit) -> Option { - let comment = - find_leaf_at_offset(file.syntax(), offset).left_biased().and_then(ast::Comment::cast)?; +pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option { + let file = db.parse(position.file_id); + let comment = find_leaf_at_offset(file.syntax(), position.offset) + .left_biased() + .and_then(ast::Comment::cast)?; if let ast::CommentFlavor::Multiline = comment.flavor() { return None; } let prefix = comment.prefix(); - if offset < comment.syntax().range().start() + TextUnit::of_str(prefix) + TextUnit::from(1) { + if position.offset + < comment.syntax().range().start() + TextUnit::of_str(prefix) + TextUnit::from(1) + { return None; } - let indent = node_indent(file, comment.syntax())?; + let indent = node_indent(&file, comment.syntax())?; let inserted = format!("\n{}{} ", indent, prefix); - let cursor_position = offset + TextUnit::of_str(&inserted); + let cursor_position = position.offset + TextUnit::of_str(&inserted); let mut edit = TextEditBuilder::default(); - edit.insert(offset, inserted); - Some(LocalEdit { + edit.insert(position.offset, inserted); + Some(SourceChange { label: "on enter".to_string(), - edit: edit.finish(), - cursor_position: Some(cursor_position), + source_file_edits: vec![SourceFileEdit { edit: edit.finish(), file_id: position.file_id }], + file_system_edits: vec![], + cursor_position: Some(FilePosition { offset: cursor_position, file_id: position.file_id }), }) } @@ -53,7 +59,7 @@ fn node_indent<'a>(file: &'a SourceFile, node: &SyntaxNode) -> Option<&'a str> { Some(&text[pos..]) } -pub fn on_eq_typed(file: &SourceFile, eq_offset: TextUnit) -> Option { +pub fn on_eq_typed(file: &SourceFile, eq_offset: TextUnit) -> Option { assert_eq!(file.syntax().text().char_at(eq_offset), Some('=')); let let_stmt: &ast::LetStmt = find_node_at_offset(file.syntax(), eq_offset)?; if let_stmt.has_semi() { @@ -73,17 +79,14 @@ pub fn on_eq_typed(file: &SourceFile, eq_offset: TextUnit) -> Option let offset = let_stmt.syntax().range().end(); let mut edit = TextEditBuilder::default(); edit.insert(offset, ";".to_string()); - Some(LocalEdit { - label: "add semicolon".to_string(), - edit: edit.finish(), - cursor_position: None, - }) + Some(edit.finish()) } -pub fn on_dot_typed(file: &SourceFile, dot_offset: TextUnit) -> Option { - assert_eq!(file.syntax().text().char_at(dot_offset), Some('.')); +pub(crate) fn on_dot_typed(db: &RootDatabase, position: FilePosition) -> Option { + let file = db.parse(position.file_id); + assert_eq!(file.syntax().text().char_at(position.offset), Some('.')); - let whitespace = find_leaf_at_offset(file.syntax(), dot_offset) + let whitespace = find_leaf_at_offset(file.syntax(), position.offset) .left_biased() .and_then(ast::Whitespace::cast)?; @@ -104,15 +107,18 @@ pub fn on_dot_typed(file: &SourceFile, dot_offset: TextUnit) -> Option Option Option { let (offset, before) = extract_offset(before); - let file = SourceFile::parse(&before); - let result = on_enter(&file, offset)?; - let actual = result.edit.apply(&before); - let actual = add_cursor(&actual, result.cursor_position.unwrap()); + let (analysis, file_id) = single_file(&before); + let result = analysis.on_enter(FilePosition { offset, file_id })?; + + assert_eq!(result.source_file_edits.len(), 1); + let actual = result.source_file_edits[0].edit.apply(&before); + let actual = add_cursor(&actual, result.cursor_position.unwrap().offset); Some(actual) } -- cgit v1.2.3 From a3711e08dc4e393957dff136218c47d8b77da14f Mon Sep 17 00:00:00 2001 From: Wilco Kusee Date: Sat, 23 Mar 2019 17:34:49 +0100 Subject: Move highlighting and matching_brace --- crates/ra_ide_api/src/diagnostics.rs | 7 +- crates/ra_ide_api/src/lib.rs | 9 +-- crates/ra_ide_api/src/matching_brace.rs | 45 ++++++++++++ .../src/snapshots/tests__highlighting.snap | 34 +++++++++ crates/ra_ide_api/src/syntax_highlighting.rs | 81 ++++++++++++++++++++-- 5 files changed, 165 insertions(+), 11 deletions(-) create mode 100644 crates/ra_ide_api/src/matching_brace.rs create mode 100644 crates/ra_ide_api/src/snapshots/tests__highlighting.snap (limited to 'crates/ra_ide_api') diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs index 069092528..aabb614b9 100644 --- a/crates/ra_ide_api/src/diagnostics.rs +++ b/crates/ra_ide_api/src/diagnostics.rs @@ -1,6 +1,5 @@ use itertools::Itertools; use hir::{Problem, source_binder}; -use ra_ide_api_light::Severity; use ra_db::SourceDatabase; use ra_syntax::{ Location, SourceFile, SyntaxKind, TextRange, SyntaxNode, @@ -11,6 +10,12 @@ use ra_text_edit::{TextEdit, TextEditBuilder}; use crate::{Diagnostic, FileId, FileSystemEdit, SourceChange, SourceFileEdit, db::RootDatabase}; +#[derive(Debug, Copy, Clone)] +pub enum Severity { + Error, + WeakWarning, +} + pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec { let source_file = db.parse(file_id); let mut res = Vec::new(); diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs index 0e7b47e3c..99f18b6b8 100644 --- a/crates/ra_ide_api/src/lib.rs +++ b/crates/ra_ide_api/src/lib.rs @@ -38,6 +38,7 @@ mod folding_ranges; mod line_index_utils; mod join_lines; mod typing; +mod matching_brace; #[cfg(test)] mod marks; @@ -70,10 +71,10 @@ pub use crate::{ line_index::{LineIndex, LineCol}, line_index_utils::translate_offset_with_edit, folding_ranges::{Fold, FoldKind}, + syntax_highlighting::HighlightedRange, + diagnostics::Severity, }; -pub use ra_ide_api_light::{ - HighlightedRange, Severity, StructureNode, -}; +pub use ra_ide_api_light::StructureNode; pub use ra_db::{ Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId, Edition @@ -267,7 +268,7 @@ impl Analysis { /// supported). pub fn matching_brace(&self, position: FilePosition) -> Option { let file = self.db.parse(position.file_id); - ra_ide_api_light::matching_brace(&file, position.offset) + matching_brace::matching_brace(&file, position.offset) } /// Returns a syntax tree represented as `String`, for debug purposes. diff --git a/crates/ra_ide_api/src/matching_brace.rs b/crates/ra_ide_api/src/matching_brace.rs new file mode 100644 index 000000000..d1405f14f --- /dev/null +++ b/crates/ra_ide_api/src/matching_brace.rs @@ -0,0 +1,45 @@ +use ra_syntax::{ + SourceFile, TextUnit, + algo::find_leaf_at_offset, + SyntaxKind::{self, *}, + ast::AstNode, +}; + +pub fn matching_brace(file: &SourceFile, offset: TextUnit) -> Option { + const BRACES: &[SyntaxKind] = + &[L_CURLY, R_CURLY, L_BRACK, R_BRACK, L_PAREN, R_PAREN, L_ANGLE, R_ANGLE]; + let (brace_node, brace_idx) = find_leaf_at_offset(file.syntax(), offset) + .filter_map(|node| { + let idx = BRACES.iter().position(|&brace| brace == node.kind())?; + Some((node, idx)) + }) + .next()?; + let parent = brace_node.parent()?; + let matching_kind = BRACES[brace_idx ^ 1]; + let matching_node = parent.children().find(|node| node.kind() == matching_kind)?; + Some(matching_node.range().start()) +} + +#[cfg(test)] +mod tests { + use test_utils::{add_cursor, assert_eq_text, extract_offset}; + + use super::*; + + #[test] + fn test_matching_brace() { + fn do_check(before: &str, after: &str) { + let (pos, before) = extract_offset(before); + let file = SourceFile::parse(&before); + let new_pos = match matching_brace(&file, pos) { + None => pos, + Some(pos) => pos, + }; + let actual = add_cursor(&before, new_pos); + assert_eq_text!(after, &actual); + } + + do_check("struct Foo { a: i32, }<|>", "struct Foo <|>{ a: i32, }"); + } + +} diff --git a/crates/ra_ide_api/src/snapshots/tests__highlighting.snap b/crates/ra_ide_api/src/snapshots/tests__highlighting.snap new file mode 100644 index 000000000..72029e0ed --- /dev/null +++ b/crates/ra_ide_api/src/snapshots/tests__highlighting.snap @@ -0,0 +1,34 @@ +--- +created: "2019-03-23T16:20:31.394314144Z" +creator: insta@0.7.1 +source: crates/ra_ide_api/src/syntax_highlighting.rs +expression: result +--- +Ok( + [ + HighlightedRange { + range: [1; 11), + tag: "comment" + }, + HighlightedRange { + range: [12; 14), + tag: "keyword" + }, + HighlightedRange { + range: [15; 19), + tag: "function" + }, + HighlightedRange { + range: [29; 37), + tag: "macro" + }, + HighlightedRange { + range: [38; 50), + tag: "string" + }, + HighlightedRange { + range: [52; 54), + tag: "literal" + } + ] +) diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs index fdd87bcff..a0c5e78ad 100644 --- a/crates/ra_ide_api/src/syntax_highlighting.rs +++ b/crates/ra_ide_api/src/syntax_highlighting.rs @@ -1,12 +1,81 @@ -use ra_syntax::AstNode; +use rustc_hash::FxHashSet; + +use ra_syntax::{ast, AstNode, TextRange, Direction, SyntaxKind::*}; use ra_db::SourceDatabase; -use crate::{ - FileId, HighlightedRange, - db::RootDatabase, -}; +use crate::{FileId, db::RootDatabase}; + +#[derive(Debug)] +pub struct HighlightedRange { + pub range: TextRange, + pub tag: &'static str, +} pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec { let source_file = db.parse(file_id); - ra_ide_api_light::highlight(source_file.syntax()) + + // Visited nodes to handle highlighting priorities + let mut highlighted = FxHashSet::default(); + let mut res = Vec::new(); + for node in source_file.syntax().descendants() { + if highlighted.contains(&node) { + continue; + } + let tag = match node.kind() { + COMMENT => "comment", + STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string", + ATTR => "attribute", + NAME_REF => "text", + NAME => "function", + INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal", + LIFETIME => "parameter", + k if k.is_keyword() => "keyword", + _ => { + if let Some(macro_call) = ast::MacroCall::cast(node) { + if let Some(path) = macro_call.path() { + if let Some(segment) = path.segment() { + if let Some(name_ref) = segment.name_ref() { + highlighted.insert(name_ref.syntax()); + let range_start = name_ref.syntax().range().start(); + let mut range_end = name_ref.syntax().range().end(); + for sibling in path.syntax().siblings(Direction::Next) { + match sibling.kind() { + EXCL | IDENT => range_end = sibling.range().end(), + _ => (), + } + } + res.push(HighlightedRange { + range: TextRange::from_to(range_start, range_end), + tag: "macro", + }) + } + } + } + } + continue; + } + }; + res.push(HighlightedRange { range: node.range(), tag }) + } + res +} + +#[cfg(test)] +mod tests { + use insta::assert_debug_snapshot_matches; + + use crate::mock_analysis::single_file; + + #[test] + fn test_highlighting() { + let (analysis, file_id) = single_file( + r#" +// comment +fn main() {} + println!("Hello, {}!", 92); +"#, + ); + let result = analysis.highlight(file_id); + assert_debug_snapshot_matches!("highlighting", result); + } } -- cgit v1.2.3