use crate::{ syntax::Syntax, tree_sitter::{Node, Tree}, Rope, RopeSlice, State, }; /// To determine indentation of a newly inserted line, figure out the indentation at the last col /// of the previous line. pub const TAB_WIDTH: usize = 4; fn indent_level_for_line(line: RopeSlice) -> usize { let mut len = 0; for ch in line.chars() { match ch { '\t' => len += TAB_WIDTH, ' ' => len += 1, _ => break, } } len / TAB_WIDTH } /// Find the highest syntax node at position. /// This is to identify the column where this node (e.g., an HTML closing tag) ends. fn get_highest_syntax_node_at_bytepos(syntax: &Syntax, pos: usize) -> Option { let tree = syntax.root_layer.tree.as_ref().unwrap(); // named_descendant let mut node = match tree.root_node().descendant_for_byte_range(pos, pos) { Some(node) => node, None => return None, }; while let Some(parent) = node.parent() { if parent.start_byte() == node.start_byte() { node = parent } else { break; } } Some(node) } fn walk(node: Option, newline: bool) -> usize { let mut increment = 0; // Hardcoded for rust for now let indent_scopes = &[ // indent except first or block? "while_expression", "for_expression", "loop_expression", "if_expression", "if_let_expression", "match_expression", "match_arm", ]; // this is for multiline things, such as: // self.method() // .chain() // .chain() // where the first line isn't indented let indent_except_first_scopes = &[ "block", "arguments", "declaration_list", "field_declaration_list", "enum_variant_list", // "function_item", // "call_expression", // "closure_expression", "binary_expression", "field_expression", // "where_predicate", // where_clause instead? ]; let outdent = &["}", "]", ")"]; let mut node = match node { Some(node) => node, None => return 0, }; // if we're calculating indentation for a brand new line then the current node will become the // parent node. We need to take it's indentation level into account too. let node_kind = node.kind(); if newline && (indent_scopes.contains(&node_kind) || indent_except_first_scopes.contains(&node_kind)) { increment += 1; } while let Some(parent) = node.parent() { let not_first_sibling = node.prev_sibling().is_some(); let not_last_sibling = node.next_sibling().is_some(); let not_first_or_last_sibling = not_first_sibling && not_last_sibling; let parent_kind = parent.kind(); // println!( // "name: {}\tparent: {}\trange:\t{} {}\tfirst={:?}\tlast={:?}", // node.kind(), // parent.kind(), // node.range().start_point, // node.range().end_point, // node.prev_sibling().is_none(), // node.next_sibling().is_none(), // ); if outdent.contains(&node.kind()) { // we outdent by skipping the rules for the current level and jumping up node = parent; continue; } let is_scope = indent_scopes.contains(&parent_kind); // && not_first_or_last_sibling if is_scope && not_first_or_last_sibling { // println!("is_scope {}", parent_kind); increment += 1 } let is_scope = indent_except_first_scopes.contains(&parent_kind); // && not_first_sibling if is_scope && not_first_sibling { // println!("is_scope_except_first {}", parent_kind); increment += 1 } // if last_scope && increment > 0 && ...{ ignore } node = parent; } increment } fn find_first_non_whitespace_char(state: &State, line_num: usize) -> Option { let line = state.doc.line(line_num); let mut start = state.doc.line_to_char(line_num); // find first non-whitespace char for ch in line.chars() { // TODO: could use memchr with chunks? if ch != ' ' && ch != '\t' && ch != '\n' { return Some(start); } start += 1; } None } fn suggested_indent_for_line(syntax: Option<&Syntax>, state: &State, line_num: usize) -> usize { let line = state.doc.line(line_num); let current = indent_level_for_line(line); if let Some(start) = find_first_non_whitespace_char(state, line_num) { return suggested_indent_for_pos(syntax, state, start, false); }; // if the line is blank, indent should be zero 0 } // TODO: two usecases: if we are triggering this for a new, blank line: // - it should return 0 when mass indenting stuff // - it should look up the wrapper node and count it too when we press o/O pub fn suggested_indent_for_pos( syntax: Option<&Syntax>, state: &State, pos: usize, new_line: bool, ) -> usize { if let Some(syntax) = syntax { let byte_start = state.doc.char_to_byte(pos); let node = get_highest_syntax_node_at_bytepos(syntax, byte_start); let indentation = walk(node, new_line); // special case for comments // println!("------------"); // if preserve_leading_whitespace indentation } else { // TODO: heuristics for non-tree sitter grammars 0 } } #[cfg(test)] mod test { use super::*; #[test] fn test_indent_level() { let line = Rope::from(" fn new"); // 8 spaces assert_eq!(indent_level_for_line(line.slice(..)), 2); let line = Rope::from("\t\t\tfn new"); // 3 tabs assert_eq!(indent_level_for_line(line.slice(..)), 3); // mixed indentation let line = Rope::from("\t \tfn new"); // 1 tab, 4 spaces, tab assert_eq!(indent_level_for_line(line.slice(..)), 3); } #[test] fn test_suggested_indent_for_line() { let doc = Rope::from( " mod test { fn hello_world() { 1 + 1; let does_indentation_work = 1; let test_function = function_with_param(this_param, that_param ); let test_function = function_with_param( this_param, that_param ); let test_function = function_with_proper_indent(param1, param2, ); let selection = Selection::new( changes .clone() .map(|(start, end, text): (usize, usize, Option)| { let len = text.map(|text| text.len()).unwrap() - 1; // minus newline let pos = start + len; Range::new(pos, pos) }) .collect(), 0, ); return; } } impl MyTrait for YourType where A: TraitB + TraitC, D: TraitE + TraitF, { } #[test] // ", ); let state = State::new(doc); // TODO: set_language let language_config = crate::syntax::LOADER .language_config_for_scope("source.rust") .unwrap(); let highlight_config = language_config.highlight_config(&[]).unwrap().unwrap(); let syntax = Syntax::new(&state.doc, highlight_config.clone()); // { // { // 1 + 1 // } // } // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 1), 0); // { // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 2), 1); // { // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 3), 2); // // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 4), 1); // } // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 5), 0); // } assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 1), 0); // mod assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 2), 1); // fn assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 3), 2); // 1 + 1 assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 4), 0); // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 5), 2); // does_indentation_work assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 7), 2); // let test_function assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 8), 3); // that_param assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 9), 2); // ); assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 10), 0); // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 11), 2); // let test_function assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 12), 3); // this_param assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 13), 3); // that_param assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 14), 2); // ); assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 15), 0); // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 16), 2); // let test_function assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 17), 3); // param2 assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 18), 2); // ); assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 20), 2); // let selection assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 21), 3); // changes assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 22), 4); // clone() assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 23), 4); // map() assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 24), 5); // let len assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 25), 5); // let pos assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 26), 5); // Range assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 27), 4); // }) assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 28), 4); // .collect(), assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 29), 3); // 0, assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 30), 2); // }) assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 31), 0); // assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 32), 2); // return; assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 33), 1); // } assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 34), 0); // } } }