+use itertools::Itertools;

+ Direction, NodeOrToken, SourceFile, SyntaxElement,

+ SyntaxKind::*,

+ ast::{self, AstNode, AstToken, HasArgList, edit::AstNodeEdit},

+ syntax_editor::Element,

+#[derive(Debug, PartialEq, Eq, Clone, Copy)]

+ TraitAliases,

+ Stmt,

+ TailExpr,

+ pub collapsed_text: Option<String>,

+}

+

+impl Fold {

+ pub fn new(range: TextRange, kind: FoldKind) -> Self {

+ Self { range, kind, collapsed_text: None }

+ }

+

+ pub fn with_text(mut self, text: String) -> Self {

+ self.collapsed_text = Some(text);

+ self

+ }

+pub(crate) fn folding_ranges(file: &SourceFile, collapsed_text: bool) -> Vec<Fold> {

+ if let Some(kind) = fold_kind(element.clone()) {

+

+ if let NodeOrToken::Node(node) = &element

+ && let Some(fn_) = ast::Fn::cast(node.clone())

+ if !fn_

+ .unwrap_or_default()

+ if let Some(body) = fn_.body() {

+ let fn_start = fn_

+ res.push(build_fold(&element, kind, collapsed_text));

+

+ res.push(build_fold(&element, kind, collapsed_text));

+ res.push(Fold::new(

+ TextRange::new(region, comment.syntax().text_range().end()),

+ FoldKind::Region,

+ ));

+ res.push(Fold::new(range, FoldKind::Comment));

+ res.push(Fold::new(range, FoldKind::Modules));

+ res.push(Fold::new(range, FoldKind::Imports));

+ res.push(Fold::new(range, FoldKind::Consts));

+ res.push(Fold::new(range, FoldKind::Statics));

+ res.push(Fold::new(range, FoldKind::TypeAliases));

+ }

+ },

+ ast::TraitAlias(alias) => {

+ if let Some(range) = contiguous_range_for_item_group(alias, &mut visited_nodes) {

+ res.push(Fold::new(range, FoldKind::TraitAliases));

+ res.push(Fold::new(range, FoldKind::ExternCrates));

+ res.push(Fold::new(range, FoldKind::MatchArm));

+/// Builds a fold for the given syntax element.

+///

+/// This function creates a `Fold` object that represents a collapsible region in the code.

+/// If `collapsed_text` is enabled, it generates a preview text for certain fold kinds that

+/// shows a summarized version of the folded content.

+fn build_fold(element: &SyntaxElement, kind: FoldKind, collapsed_text: bool) -> Fold {

+ if !collapsed_text {

+ return Fold::new(element.text_range(), kind);

+ }

+

+ let fold_with_collapsed_text = match kind {

+ FoldKind::TailExpr => {

+ let expr = ast::Expr::cast(element.as_node().unwrap().clone()).unwrap();

+

+ let indent_level = expr.indent_level().0;

+ let indents = " ".repeat(indent_level as usize);

+

+ let mut fold = Fold::new(element.text_range(), kind);

+ if let Some(collapsed_expr) = collapsed_text_from_expr(expr) {

+ fold = fold.with_text(format!("{indents}{collapsed_expr}"));

+ }

+ Some(fold)

+ }

+ FoldKind::Stmt => 'blk: {

+ let node = element.as_node().unwrap();

+

+ match_ast! {

+ match node {

+ ast::ExprStmt(expr) => {

+ let Some(expr) = expr.expr() else {

+ break 'blk None;

+ };

+

+ let indent_level = expr.indent_level().0;

+ let indents = " ".repeat(indent_level as usize);

+

+ let mut fold = Fold::new(element.text_range(), kind);

+ if let Some(collapsed_expr) = collapsed_text_from_expr(expr) {

+ fold = fold.with_text(format!("{indents}{collapsed_expr};"));

+ }

+ Some(fold)

+ },

+ ast::LetStmt(let_stmt) => {

+ if let_stmt.let_else().is_some() {

+ break 'blk None;

+ }

+

+ let Some(expr) = let_stmt.initializer() else {

+ break 'blk None;

+ };

+

+ let expr_offset =

+ expr.syntax().text_range().start() - let_stmt.syntax().text_range().start();

+ let text_before_expr = let_stmt.syntax().text().slice(..expr_offset);

+ if text_before_expr.contains_char('\n') {

+ break 'blk None;

+ }

+

+ let indent_level = let_stmt.indent_level().0;

+ let indents = " ".repeat(indent_level as usize);

+

+ let mut fold = Fold::new(element.text_range(), kind);

+ if let Some(collapsed_expr) = collapsed_text_from_expr(expr) {

+ fold = fold.with_text(format!("{indents}{text_before_expr}{collapsed_expr};"));

+ }

+ Some(fold)

+ },

+ _ => None,

+ }

+ }

+ }

+ _ => None,

+ };

+

+ fold_with_collapsed_text.unwrap_or_else(|| Fold::new(element.text_range(), kind))

+}

+

+fn fold_kind(element: SyntaxElement) -> Option<FoldKind> {

+ // handle tail_expr

+ if let Some(node) = element.as_node()

+ && let Some(block) = node.parent().and_then(|it| it.parent()).and_then(ast::BlockExpr::cast) // tail_expr -> stmt_list -> block

+ && block.tail_expr().is_some_and(|tail| tail.syntax() == node)

+ {

+ return Some(FoldKind::TailExpr);

+ }

+

+ match element.kind() {

+ EXPR_STMT | LET_STMT => Some(FoldKind::Stmt),

+/// Generates a collapsed text representation of a chained expression.

+///

+/// This function analyzes an expression and creates a concise string representation

+/// that shows the structure of method chains, field accesses, and function calls.

+/// It's particularly useful for folding long chained expressions like:

+/// `obj.method1()?.field.method2(args)` -> `obj.method1()?.field.method2(…)`

+///

+/// The function traverses the expression tree from the outermost expression inward,

+/// collecting method names, field names, and call signatures. It accumulates try

+/// operators (`?`) and applies them to the appropriate parts of the chain.

+///

+/// # Parameters

+/// - `expr`: The expression to generate collapsed text for

+///

+/// # Returns

+/// - `Some(String)`: A dot-separated chain representation if the expression is chainable

+/// - `None`: If the expression is not suitable for collapsing (e.g., simple literals)

+///

+/// # Examples

+/// - `foo.bar().baz?` -> `"foo.bar().baz?"`

+/// - `obj.method(arg1, arg2)` -> `"obj.method(…)"`

+/// - `value?.field` -> `"value?.field"`

+fn collapsed_text_from_expr(mut expr: ast::Expr) -> Option<String> {

+ let mut names = Vec::new();

+ let mut try_marks = String::with_capacity(1);

+

+ let fold_general_expr = |expr: ast::Expr, try_marks: &mut String| {

+ let text = expr.syntax().text();

+ let name = if text.contains_char('\n') {

+ format!("<expr>{try_marks}")

+ } else {

+ format!("{text}{try_marks}")

+ };

+ try_marks.clear();

+ name

+ };

+

+ loop {

+ let receiver = match expr {

+ ast::Expr::MethodCallExpr(call) => {

+ let name = call

+ .name_ref()

+ .map(|name| name.text().to_owned())

+ .unwrap_or_else(|| "�".into());

+ if call.arg_list().and_then(|arg_list| arg_list.args().next()).is_some() {

+ names.push(format!("{name}(…){try_marks}"));

+ } else {

+ names.push(format!("{name}(){try_marks}"));

+ }

+ try_marks.clear();

+ call.receiver()

+ }

+ ast::Expr::FieldExpr(field) => {

+ let name = match field.field_access() {

+ Some(ast::FieldKind::Name(name)) => format!("{name}{try_marks}"),

+ Some(ast::FieldKind::Index(index)) => format!("{index}{try_marks}"),

+ None => format!("�{try_marks}"),

+ };

+ names.push(name);

+ try_marks.clear();

+ field.expr()

+ }

+ ast::Expr::TryExpr(try_expr) => {

+ try_marks.push('?');

+ try_expr.expr()

+ }

+ ast::Expr::CallExpr(call) => {

+ let name = fold_general_expr(call.expr().unwrap(), &mut try_marks);

+ if call.arg_list().and_then(|arg_list| arg_list.args().next()).is_some() {

+ names.push(format!("{name}(…){try_marks}"));

+ } else {

+ names.push(format!("{name}(){try_marks}"));

+ }

+ try_marks.clear();

+ None

+ }

+ e => {

+ if names.is_empty() {

+ return None;

+ }

+ names.push(fold_general_expr(e, &mut try_marks));

+ None

+ }

+ };

+ if let Some(receiver) = receiver {

+ expr = receiver;

+ } else {

+ break;

+ }

+ }

+

+ Some(names.iter().rev().join("."))

+}

+

+ if fold_kind(match_arm.expr()?.syntax().syntax_element()).is_some() {

+ check_inner(ra_fixture, true);

+ }

+

+ fn check_without_collapsed_text(#[rust_analyzer::rust_fixture] ra_fixture: &str) {

+ check_inner(ra_fixture, false);

+ }

+

+ fn check_inner(ra_fixture: &str, enable_collapsed_text: bool) {

+ let ranges = ranges

+ .into_iter()

+ .map(|(range, text)| {

+ let (attr, collapsed_text) = match text {

+ Some(text) => match text.split_once(':') {

+ Some((attr, collapsed_text)) => {

+ (Some(attr.to_owned()), Some(collapsed_text.to_owned()))

+ }

+ None => (Some(text), None),

+ },

+ None => (None, None),

+ };

+ (range, attr, collapsed_text)

+ })

+ .collect_vec();

+ let mut folds = folding_ranges(&parse.tree(), enable_collapsed_text);

+ for (fold, (range, attr, collapsed_text)) in folds.iter().zip(ranges.into_iter()) {

+ FoldKind::Stmt => "stmt",

+ FoldKind::TailExpr => "tailexpr",

+ if enable_collapsed_text {

+ assert_eq!(fold.collapsed_text, collapsed_text);

+ } else {

+ assert_eq!(fold.collapsed_text, None);

+ }

+ <fold tailexpr>match 0 <fold block>{

+ }</fold></fold>

+ <fold tailexpr>match foo <fold block>{

+ }</fold></fold>

+ <fold tailexpr: frobnicate(…)>frobnicate<fold arglist>(

+ )</fold></fold>

+ fn test_fold_tail_expr() {

+ check(

+ r#"

+fn f() <fold block>{

+ let x = 1;

+

+ <fold tailexpr: some_function().chain().method()>some_function()

+ .chain()

+ .method()</fold>

+}</fold>

+"#,

+ )

+ }

+

+ #[test]

+ fn test_fold_let_stmt_with_chained_methods() {

+ check(

+ r#"

+fn main() <fold block>{

+ <fold stmt: let result = some_value.method1().method2()?.method3();>let result = some_value

+ .method1()

+ .method2()?

+ .method3();</fold>

+

+ println!("{}", result);

+}</fold>

+"#,

+ )

+ }

+

+ #[test]

+ fn test_fold_let_stmt_with_chained_methods_without_collapsed_text() {

+ check_without_collapsed_text(

+ r#"

+fn main() <fold block>{

+ <fold stmt>let result = some_value

+ .method1()

+ .method2()?

+ .method3();</fold>

+

+ println!("{}", result);

+}</fold>

+"#,

+ )

+ }