use std::ops::Range; use crate::{    motion::right, normal::normal_object, state::Mode, utils::coerce_punctuation,    visual::visual_object, Vim,};use editor::{    display_map::{DisplaySnapshot, ToDisplayPoint},    movement::{self, FindRange},    Bias, DisplayPoint,};use gpui::{actions, impl_actions, ViewContext, WindowContext};use language::{char_kind, BufferSnapshot, CharKind, Point, Selection};use serde::Deserialize;use workspace::Workspace; #[derive(Copy, Clone, Debug, PartialEq)]pub enum Object {    Word { ignore_punctuation: bool },    Sentence,    Paragraph,    Quotes,    BackQuotes,    DoubleQuotes,    VerticalBars,    Parentheses,    SquareBrackets,    CurlyBrackets,    AngleBrackets,    Argument,    Tag,} #[derive(Clone, Deserialize, PartialEq)]#[serde(rename_all = "camelCase")]struct Word {    #[serde(default)]    ignore_punctuation: bool,} impl_actions!(vim, [Word]); actions!(    vim,    [        Sentence,        Paragraph,        Quotes,        BackQuotes,        DoubleQuotes,        VerticalBars,        Parentheses,        SquareBrackets,        CurlyBrackets,        AngleBrackets,        Argument,        Tag    ]); pub fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {    workspace.register_action(        |_: &mut Workspace, &Word { ignore_punctuation }: &Word, cx: _| {            object(Object::Word { ignore_punctuation }, cx)        },    );    workspace.register_action(|_: &mut Workspace, _: &Tag, cx: _| object(Object::Tag, cx));    workspace        .register_action(|_: &mut Workspace, _: &Sentence, cx: _| object(Object::Sentence, cx));    workspace        .register_action(|_: &mut Workspace, _: &Paragraph, cx: _| object(Object::Paragraph, cx));    workspace.register_action(|_: &mut Workspace, _: &Quotes, cx: _| object(Object::Quotes, cx));    workspace        .register_action(|_: &mut Workspace, _: &BackQuotes, cx: _| object(Object::BackQuotes, cx));    workspace.register_action(|_: &mut Workspace, _: &DoubleQuotes, cx: _| {        object(Object::DoubleQuotes, cx)    });    workspace.register_action(|_: &mut Workspace, _: &Parentheses, cx: _| {        object(Object::Parentheses, cx)    });    workspace.register_action(|_: &mut Workspace, _: &SquareBrackets, cx: _| {        object(Object::SquareBrackets, cx)    });    workspace.register_action(|_: &mut Workspace, _: &CurlyBrackets, cx: _| {        object(Object::CurlyBrackets, cx)    });    workspace.register_action(|_: &mut Workspace, _: &AngleBrackets, cx: _| {        object(Object::AngleBrackets, cx)    });    workspace.register_action(|_: &mut Workspace, _: &VerticalBars, cx: _| {        object(Object::VerticalBars, cx)    });    workspace        .register_action(|_: &mut Workspace, _: &Argument, cx: _| object(Object::Argument, cx));} fn object(object: Object, cx: &mut WindowContext) {    match Vim::read(cx).state().mode {        Mode::Normal => normal_object(object, cx),        Mode::Visual | Mode::VisualLine | Mode::VisualBlock => visual_object(object, cx),        Mode::Insert | Mode::Replace => {            // Shouldn't execute a text object in insert mode. Ignoring        }    }} impl Object {    pub fn is_multiline(self) -> bool {        match self {            Object::Word { .. }            | Object::Quotes            | Object::BackQuotes            | Object::VerticalBars            | Object::DoubleQuotes => false,            Object::Sentence            | Object::Paragraph            | Object::Parentheses            | Object::Tag            | Object::AngleBrackets            | Object::CurlyBrackets            | Object::SquareBrackets            | Object::Argument => true,        }    }     pub fn always_expands_both_ways(self) -> bool {        match self {            Object::Word { .. } | Object::Sentence | Object::Paragraph | Object::Argument => false,            Object::Quotes            | Object::BackQuotes            | Object::DoubleQuotes            | Object::VerticalBars            | Object::Parentheses            | Object::SquareBrackets            | Object::Tag            | Object::CurlyBrackets            | Object::AngleBrackets => true,        }    }     pub fn target_visual_mode(self, current_mode: Mode) -> Mode {        match self {            Object::Word { .. }            | Object::Sentence            | Object::Quotes            | Object::BackQuotes            | Object::DoubleQuotes => {                if current_mode == Mode::VisualBlock {                    Mode::VisualBlock                } else {                    Mode::Visual                }            }            Object::Parentheses            | Object::SquareBrackets            | Object::CurlyBrackets            | Object::AngleBrackets            | Object::VerticalBars            | Object::Tag            | Object::Argument => Mode::Visual,            Object::Paragraph => Mode::VisualLine,        }    }     pub fn range(        self,        map: &DisplaySnapshot,        relative_to: DisplayPoint,        around: bool,    ) -> Option<Range<DisplayPoint>> {        match self {            Object::Word { ignore_punctuation } => {                if around {                    around_word(map, relative_to, ignore_punctuation)                } else {                    in_word(map, relative_to, ignore_punctuation)                }            }            Object::Sentence => sentence(map, relative_to, around),            Object::Paragraph => paragraph(map, relative_to, around),            Object::Quotes => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '\'', '\'')            }            Object::BackQuotes => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '`', '`')            }            Object::DoubleQuotes => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '"', '"')            }            Object::VerticalBars => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '|', '|')            }            Object::Parentheses => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '(', ')')            }            Object::Tag => surrounding_html_tag(map, relative_to, around),            Object::SquareBrackets => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '[', ']')            }            Object::CurlyBrackets => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '{', '}')            }            Object::AngleBrackets => {                surrounding_markers(map, relative_to, around, self.is_multiline(), '<', '>')            }            Object::Argument => argument(map, relative_to, around),        }    }     pub fn expand_selection(        self,        map: &DisplaySnapshot,        selection: &mut Selection<DisplayPoint>,        around: bool,    ) -> bool {        if let Some(range) = self.range(map, selection.head(), around) {            selection.start = range.start;            selection.end = range.end;            true        } else {            false        }    }} /// Returns a range that surrounds the word `relative_to` is in.////// If `relative_to` is at the start of a word, return the word./// If `relative_to` is between words, return the space between.fn in_word(    map: &DisplaySnapshot,    relative_to: DisplayPoint,    ignore_punctuation: bool,) -> Option<Range<DisplayPoint>> {    // Use motion::right so that we consider the character under the cursor when looking for the start    let scope = map        .buffer_snapshot        .language_scope_at(relative_to.to_point(map));    let start = movement::find_preceding_boundary_display_point(        map,        right(map, relative_to, 1),        movement::FindRange::SingleLine,        |left, right| {            coerce_punctuation(char_kind(&scope, left), ignore_punctuation)                != coerce_punctuation(char_kind(&scope, right), ignore_punctuation)        },    );     let end = movement::find_boundary(map, relative_to, FindRange::SingleLine, |left, right| {        coerce_punctuation(char_kind(&scope, left), ignore_punctuation)            != coerce_punctuation(char_kind(&scope, right), ignore_punctuation)    });     Some(start..end)} fn surrounding_html_tag(    map: &DisplaySnapshot,    relative_to: DisplayPoint,    surround: bool,) -> Option<Range<DisplayPoint>> {    fn read_tag(chars: impl Iterator<Item = char>) -> String {        chars            .take_while(|c| c.is_alphanumeric() || *c == ':' || *c == '-' || *c == '_' || *c == '.')            .collect()    }    fn open_tag(mut chars: impl Iterator<Item = char>) -> Option<String> {        if Some('<') != chars.next() {            return None;        }        Some(read_tag(chars))    }    fn close_tag(mut chars: impl Iterator<Item = char>) -> Option<String> {        if (Some('<'), Some('/')) != (chars.next(), chars.next()) {            return None;        }        Some(read_tag(chars))    }     let snapshot = &map.buffer_snapshot;    let offset = relative_to.to_offset(map, Bias::Left);    let excerpt = snapshot.excerpt_containing(offset..offset)?;    let buffer = excerpt.buffer();    let offset = excerpt.map_offset_to_buffer(offset);     // Find the most closest to current offset    let mut cursor = buffer.syntax_layer_at(offset)?.node().walk();    let mut last_child_node = cursor.node();    while cursor.goto_first_child_for_byte(offset).is_some() {        last_child_node = cursor.node();    }     let mut last_child_node = Some(last_child_node);    while let Some(cur_node) = last_child_node {        if cur_node.child_count() >= 2 {            let first_child = cur_node.child(0);            let last_child = cur_node.child(cur_node.child_count() - 1);            if let (Some(first_child), Some(last_child)) = (first_child, last_child) {                let open_tag = open_tag(buffer.chars_for_range(first_child.byte_range()));                let close_tag = close_tag(buffer.chars_for_range(last_child.byte_range()));                if open_tag.is_some()                    && open_tag == close_tag                    && (first_child.end_byte() + 1..last_child.start_byte()).contains(&offset)                {                    let range = if surround {                        first_child.byte_range().start..last_child.byte_range().end                    } else {                        first_child.byte_range().end..last_child.byte_range().start                    };                    if excerpt.contains_buffer_range(range.clone()) {                        let result = excerpt.map_range_from_buffer(range);                        return Some(                            result.start.to_display_point(map)..result.end.to_display_point(map),                        );                    }                }            }        }        last_child_node = cur_node.parent();    }    None}/// Returns a range that surrounds the word and following whitespace/// relative_to is in.////// If `relative_to` is at the start of a word, return the word and following whitespace./// If `relative_to` is between words, return the whitespace back and the following word.////// if in word///   delete that word///   if there is whitespace following the word, delete that as well///   otherwise, delete any preceding whitespace/// otherwise///   delete whitespace around cursor///   delete word following the cursorfn around_word(    map: &DisplaySnapshot,    relative_to: DisplayPoint,    ignore_punctuation: bool,) -> Option<Range<DisplayPoint>> {    let scope = map        .buffer_snapshot        .language_scope_at(relative_to.to_point(map));    let in_word = map        .chars_at(relative_to)        .next()        .map(|(c, _)| char_kind(&scope, c) != CharKind::Whitespace)        .unwrap_or(false);     if in_word {        around_containing_word(map, relative_to, ignore_punctuation)    } else {        around_next_word(map, relative_to, ignore_punctuation)    }} fn around_containing_word(    map: &DisplaySnapshot,    relative_to: DisplayPoint,    ignore_punctuation: bool,) -> Option<Range<DisplayPoint>> {    in_word(map, relative_to, ignore_punctuation)        .map(|range| expand_to_include_whitespace(map, range, true))} fn around_next_word(    map: &DisplaySnapshot,    relative_to: DisplayPoint,    ignore_punctuation: bool,) -> Option<Range<DisplayPoint>> {    let scope = map        .buffer_snapshot        .language_scope_at(relative_to.to_point(map));    // Get the start of the word    let start = movement::find_preceding_boundary_display_point(        map,        right(map, relative_to, 1),        FindRange::SingleLine,        |left, right| {            coerce_punctuation(char_kind(&scope, left), ignore_punctuation)                != coerce_punctuation(char_kind(&scope, right), ignore_punctuation)        },    );     let mut word_found = false;    let end = movement::find_boundary(map, relative_to, FindRange::MultiLine, |left, right| {        let left_kind = coerce_punctuation(char_kind(&scope, left), ignore_punctuation);        let right_kind = coerce_punctuation(char_kind(&scope, right), ignore_punctuation);         let found = (word_found && left_kind != right_kind) || right == '\n' && left == '\n';         if right_kind != CharKind::Whitespace {            word_found = true;        }         found    });     Some(start..end)} fn argument(    map: &DisplaySnapshot,    relative_to: DisplayPoint,    around: bool,) -> Option<Range<DisplayPoint>> {    let snapshot = &map.buffer_snapshot;    let offset = relative_to.to_offset(map, Bias::Left);     // The `argument` vim text object uses the syntax tree, so we operate at the buffer level and map back to the display level    let excerpt = snapshot.excerpt_containing(offset..offset)?;    let buffer = excerpt.buffer();     fn comma_delimited_range_at(        buffer: &BufferSnapshot,        mut offset: usize,        include_comma: bool,    ) -> Option<Range<usize>> {        // Seek to the first non-whitespace character        offset += buffer            .chars_at(offset)            .take_while(|c| c.is_whitespace())            .map(char::len_utf8)            .sum::<usize>();         let bracket_filter = |open: Range<usize>, close: Range<usize>| {            // Filter out empty ranges            if open.end == close.start {                return false;            }             // If the cursor is outside the brackets, ignore them            if open.start == offset || close.end == offset {                return false;            }             // TODO: Is there any better way to filter out string brackets?            // Used to filter out string brackets            return matches!(                buffer.chars_at(open.start).next(),                Some('(' | '[' | '{' | '<' | '|')            );        };         // Find the brackets containing the cursor        let (open_bracket, close_bracket) =            buffer.innermost_enclosing_bracket_ranges(offset..offset, Some(&bracket_filter))?;         let inner_bracket_range = open_bracket.end..close_bracket.start;         let layer = buffer.syntax_layer_at(offset)?;        let node = layer.node();        let mut cursor = node.walk();         // Loop until we find the smallest node whose parent covers the bracket range. This node is the argument in the parent argument list        let mut parent_covers_bracket_range = false;        loop {            let node = cursor.node();            let range = node.byte_range();            let covers_bracket_range =                range.start == open_bracket.start && range.end == close_bracket.end;            if parent_covers_bracket_range && !covers_bracket_range {                break;            }            parent_covers_bracket_range = covers_bracket_range;             // Unable to find a child node with a parent that covers the bracket range, so no argument to select            if cursor.goto_first_child_for_byte(offset).is_none() {                return None;            }        }         let mut argument_node = cursor.node();         // If the child node is the open bracket, move to the next sibling.        if argument_node.byte_range() == open_bracket {            if !cursor.goto_next_sibling() {                return Some(inner_bracket_range);            }            argument_node = cursor.node();        }        // While the child node is the close bracket or a comma, move to the previous sibling        while argument_node.byte_range() == close_bracket || argument_node.kind() == "," {            if !cursor.goto_previous_sibling() {                return Some(inner_bracket_range);            }            argument_node = cursor.node();            if argument_node.byte_range() == open_bracket {                return Some(inner_bracket_range);            }        }         // The start and end of the argument range, defaulting to the start and end of the argument node        let mut start = argument_node.start_byte();        let mut end = argument_node.end_byte();         let mut needs_surrounding_comma = include_comma;         // Seek backwards to find the start of the argument - either the previous comma or the opening bracket.        // We do this because multiple nodes can represent a single argument, such as with rust `vec![a.b.c, d.e.f]`

Lines 1–500 of 1605. Load more