crates/ide/src/extend_selection.rs

   1 use std::iter::successors;
   2
   3 use hir::Semantics;
   4 use ide_db::RootDatabase;
   5 use syntax::{
   6     algo::{self, skip_trivia_token},
   7     ast::{self, AstNode, AstToken},
   8     Direction, NodeOrToken,
   9     SyntaxKind::{self, *},
  10     SyntaxNode, SyntaxToken, TextRange, TextSize, TokenAtOffset, T,
  11 };
  12
  13 use crate::FileRange;
  14
  15 // Feature: Expand and Shrink Selection
  16 //
  17 // Extends or shrinks the current selection to the encompassing syntactic construct
  18 // (expression, statement, item, module, etc). It works with multiple cursors.
  19 //
  20 // This is a standard LSP feature and not a protocol extension.
  21 //
  22 // |===
  23 // | Editor  | Shortcut
  24 //
  25 // | VS Code | kbd:[Alt+Shift+→], kbd:[Alt+Shift+←]
  26 // |===
  27 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
  28     let sema = Semantics::new(db);
  29     let src = sema.parse(frange.file_id);
  30     try_extend_selection(&sema, src.syntax(), frange).unwrap_or(frange.range)
  31 }
  32
  33 fn try_extend_selection(
  34     sema: &Semantics<RootDatabase>,
  35     root: &SyntaxNode,
  36     frange: FileRange,
  37 ) -> Option<TextRange> {
  38     let range = frange.range;
  39
  40     let string_kinds = [COMMENT, STRING, BYTE_STRING];
  41     let list_kinds = [
  42         RECORD_PAT_FIELD_LIST,
  43         MATCH_ARM_LIST,
  44         RECORD_FIELD_LIST,
  45         TUPLE_FIELD_LIST,
  46         RECORD_EXPR_FIELD_LIST,
  47         VARIANT_LIST,
  48         USE_TREE_LIST,
  49         GENERIC_PARAM_LIST,
  50         GENERIC_ARG_LIST,
  51         TYPE_BOUND_LIST,
  52         PARAM_LIST,
  53         ARG_LIST,
  54         ARRAY_EXPR,
  55         TUPLE_EXPR,
  56         TUPLE_TYPE,
  57         TUPLE_PAT,
  58         WHERE_CLAUSE,
  59     ];
  60
  61     if range.is_empty() {
  62         let offset = range.start();
  63         let mut leaves = root.token_at_offset(offset);
  64         if leaves.clone().all(|it| it.kind() == WHITESPACE) {
  65             return Some(extend_ws(root, leaves.next()?, offset));
  66         }
  67         let leaf_range = match leaves {
  68             TokenAtOffset::None => return None,
  69             TokenAtOffset::Single(l) => {
  70                 if string_kinds.contains(&l.kind()) {
  71                     extend_single_word_in_comment_or_string(&l, offset)
  72                         .unwrap_or_else(|| l.text_range())
  73                 } else {
  74                     l.text_range()
  75                 }
  76             }
  77             TokenAtOffset::Between(l, r) => pick_best(l, r).text_range(),
  78         };
  79         return Some(leaf_range);
  80     };
  81     let node = match root.covering_element(range) {
  82         NodeOrToken::Token(token) => {
  83             if token.text_range() != range {
  84                 return Some(token.text_range());
  85             }
  86             if let Some(comment) = ast::Comment::cast(token.clone()) {
  87                 if let Some(range) = extend_comments(comment) {
  88                     return Some(range);
  89                 }
  90             }
  91             token.parent()?
  92         }
  93         NodeOrToken::Node(node) => node,
  94     };
  95
  96     // if we are in single token_tree, we maybe live in macro or attr
  97     if node.kind() == TOKEN_TREE {
  98         if let Some(macro_call) = node.ancestors().find_map(ast::MacroCall::cast) {
  99             if let Some(range) = extend_tokens_from_range(sema, macro_call, range) {
 100                 return Some(range);
 101             }
 102         }
 103     }
 104
 105     if node.text_range() != range {
 106         return Some(node.text_range());
 107     }
 108
 109     let node = shallowest_node(&node);
 110
 111     if node.parent().map(|n| list_kinds.contains(&n.kind())) == Some(true) {
 112         if let Some(range) = extend_list_item(&node) {
 113             return Some(range);
 114         }
 115     }
 116
 117     node.parent().map(|it| it.text_range())
 118 }
 119
 120 fn extend_tokens_from_range(
 121     sema: &Semantics<RootDatabase>,
 122     macro_call: ast::MacroCall,
 123     original_range: TextRange,
 124 ) -> Option<TextRange> {
 125     let src = macro_call.syntax().covering_element(original_range);
 126     let (first_token, last_token) = match src {
 127         NodeOrToken::Node(it) => (it.first_token()?, it.last_token()?),
 128         NodeOrToken::Token(it) => (it.clone(), it),
 129     };
 130
 131     let mut first_token = skip_trivia_token(first_token, Direction::Next)?;
 132     let mut last_token = skip_trivia_token(last_token, Direction::Prev)?;
 133
 134     while !original_range.contains_range(first_token.text_range()) {
 135         first_token = skip_trivia_token(first_token.next_token()?, Direction::Next)?;
 136     }
 137     while !original_range.contains_range(last_token.text_range()) {
 138         last_token = skip_trivia_token(last_token.prev_token()?, Direction::Prev)?;
 139     }
 140
 141     // compute original mapped token range
 142     let extended = {
 143         let fst_expanded = sema.descend_into_macros(first_token.clone());
 144         let lst_expanded = sema.descend_into_macros(last_token.clone());
 145         let mut lca =
 146             algo::least_common_ancestor(&fst_expanded.parent()?, &lst_expanded.parent()?)?;
 147         lca = shallowest_node(&lca);
 148         if lca.first_token() == Some(fst_expanded) && lca.last_token() == Some(lst_expanded) {
 149             lca = lca.parent()?;
 150         }
 151         lca
 152     };
 153
 154     // Compute parent node range
 155     let validate = |token: &SyntaxToken| -> bool {
 156         let expanded = sema.descend_into_macros(token.clone());
 157         let parent = match expanded.parent() {
 158             Some(it) => it,
 159             None => return false,
 160         };
 161         algo::least_common_ancestor(&extended, &parent).as_ref() == Some(&extended)
 162     };
 163
 164     // Find the first and last text range under expanded parent
 165     let first = successors(Some(first_token), |token| {
 166         let token = token.prev_token()?;
 167         skip_trivia_token(token, Direction::Prev)
 168     })
 169     .take_while(validate)
 170     .last()?;
 171
 172     let last = successors(Some(last_token), |token| {
 173         let token = token.next_token()?;
 174         skip_trivia_token(token, Direction::Next)
 175     })
 176     .take_while(validate)
 177     .last()?;
 178
 179     let range = first.text_range().cover(last.text_range());
 180     if range.contains_range(original_range) && original_range != range {
 181         Some(range)
 182     } else {
 183         None
 184     }
 185 }
 186
 187 /// Find the shallowest node with same range, which allows us to traverse siblings.
 188 fn shallowest_node(node: &SyntaxNode) -> SyntaxNode {
 189     node.ancestors().take_while(|n| n.text_range() == node.text_range()).last().unwrap()
 190 }
 191
 192 fn extend_single_word_in_comment_or_string(
 193     leaf: &SyntaxToken,
 194     offset: TextSize,
 195 ) -> Option<TextRange> {
 196     let text: &str = leaf.text();
 197     let cursor_position: u32 = (offset - leaf.text_range().start()).into();
 198
 199     let (before, after) = text.split_at(cursor_position as usize);
 200
 201     fn non_word_char(c: char) -> bool {
 202         !(c.is_alphanumeric() || c == '_')
 203     }
 204
 205     let start_idx = before.rfind(non_word_char)? as u32;
 206     let end_idx = after.find(non_word_char).unwrap_or_else(|| after.len()) as u32;
 207
 208     let from: TextSize = (start_idx + 1).into();
 209     let to: TextSize = (cursor_position + end_idx).into();
 210
 211     let range = TextRange::new(from, to);
 212     if range.is_empty() {
 213         None
 214     } else {
 215         Some(range + leaf.text_range().start())
 216     }
 217 }
 218
 219 fn extend_ws(root: &SyntaxNode, ws: SyntaxToken, offset: TextSize) -> TextRange {
 220     let ws_text = ws.text();
 221     let suffix = TextRange::new(offset, ws.text_range().end()) - ws.text_range().start();
 222     let prefix = TextRange::new(ws.text_range().start(), offset) - ws.text_range().start();
 223     let ws_suffix = &ws_text[suffix];
 224     let ws_prefix = &ws_text[prefix];
 225     if ws_text.contains('\n') && !ws_suffix.contains('\n') {
 226         if let Some(node) = ws.next_sibling_or_token() {
 227             let start = match ws_prefix.rfind('\n') {
 228                 Some(idx) => ws.text_range().start() + TextSize::from((idx + 1) as u32),
 229                 None => node.text_range().start(),
 230             };
 231             let end = if root.text().char_at(node.text_range().end()) == Some('\n') {
 232                 node.text_range().end() + TextSize::of('\n')
 233             } else {
 234                 node.text_range().end()
 235             };
 236             return TextRange::new(start, end);
 237         }
 238     }
 239     ws.text_range()
 240 }
 241
 242 fn pick_best(l: SyntaxToken, r: SyntaxToken) -> SyntaxToken {
 243     return if priority(&r) > priority(&l) { r } else { l };
 244     fn priority(n: &SyntaxToken) -> usize {
 245         match n.kind() {
 246             WHITESPACE => 0,
 247             IDENT | T![self] | T![super] | T![crate] | LIFETIME_IDENT => 2,
 248             _ => 1,
 249         }
 250     }
 251 }
 252
 253 /// Extend list item selection to include nearby delimiter and whitespace.
 254 fn extend_list_item(node: &SyntaxNode) -> Option<TextRange> {
 255     fn is_single_line_ws(node: &SyntaxToken) -> bool {
 256         node.kind() == WHITESPACE && !node.text().contains('\n')
 257     }
 258
 259     fn nearby_delimiter(
 260         delimiter_kind: SyntaxKind,
 261         node: &SyntaxNode,
 262         dir: Direction,
 263     ) -> Option<SyntaxToken> {
 264         node.siblings_with_tokens(dir)
 265             .skip(1)
 266             .find(|node| match node {
 267                 NodeOrToken::Node(_) => true,
 268                 NodeOrToken::Token(it) => !is_single_line_ws(it),
 269             })
 270             .and_then(|it| it.into_token())
 271             .filter(|node| node.kind() == delimiter_kind)
 272     }
 273
 274     let delimiter = match node.kind() {
 275         TYPE_BOUND => T![+],
 276         _ => T![,],
 277     };
 278
 279     if let Some(delimiter_node) = nearby_delimiter(delimiter, node, Direction::Next) {
 280         // Include any following whitespace when delimiter is after list item.
 281         let final_node = delimiter_node
 282             .next_sibling_or_token()
 283             .and_then(|it| it.into_token())
 284             .filter(|node| is_single_line_ws(node))
 285             .unwrap_or(delimiter_node);
 286
 287         return Some(TextRange::new(node.text_range().start(), final_node.text_range().end()));
 288     }
 289     if let Some(delimiter_node) = nearby_delimiter(delimiter, node, Direction::Prev) {
 290         return Some(TextRange::new(delimiter_node.text_range().start(), node.text_range().end()));
 291     }
 292
 293     None
 294 }
 295
 296 fn extend_comments(comment: ast::Comment) -> Option<TextRange> {
 297     let prev = adj_comments(&comment, Direction::Prev);
 298     let next = adj_comments(&comment, Direction::Next);
 299     if prev != next {
 300         Some(TextRange::new(prev.syntax().text_range().start(), next.syntax().text_range().end()))
 301     } else {
 302         None
 303     }
 304 }
 305
 306 fn adj_comments(comment: &ast::Comment, dir: Direction) -> ast::Comment {
 307     let mut res = comment.clone();
 308     for element in comment.syntax().siblings_with_tokens(dir) {
 309         let token = match element.as_token() {
 310             None => break,
 311             Some(token) => token,
 312         };
 313         if let Some(c) = ast::Comment::cast(token.clone()) {
 314             res = c
 315         } else if token.kind() != WHITESPACE || token.text().contains("\n\n") {
 316             break;
 317         }
 318     }
 319     res
 320 }
 321
 322 #[cfg(test)]
 323 mod tests {
 324     use crate::fixture;
 325
 326     use super::*;
 327
 328     fn do_check(before: &str, afters: &[&str]) {
 329         let (analysis, position) = fixture::position(&before);
 330         let before = analysis.file_text(position.file_id).unwrap();
 331         let range = TextRange::empty(position.offset);
 332         let mut frange = FileRange { file_id: position.file_id, range };
 333
 334         for &after in afters {
 335             frange.range = analysis.extend_selection(frange).unwrap();
 336             let actual = &before[frange.range];
 337             assert_eq!(after, actual);
 338         }
 339     }
 340
 341     #[test]
 342     fn test_extend_selection_arith() {
 343         do_check(r#"fn foo() { $01 + 1 }"#, &["1", "1 + 1", "{ 1 + 1 }"]);
 344     }
 345
 346     #[test]
 347     fn test_extend_selection_list() {
 348         do_check(r#"fn foo($0x: i32) {}"#, &["x", "x: i32"]);
 349         do_check(r#"fn foo($0x: i32, y: i32) {}"#, &["x", "x: i32", "x: i32, "]);
 350         do_check(r#"fn foo($0x: i32,y: i32) {}"#, &["x", "x: i32", "x: i32,", "(x: i32,y: i32)"]);
 351         do_check(r#"fn foo(x: i32, $0y: i32) {}"#, &["y", "y: i32", ", y: i32"]);
 352         do_check(r#"fn foo(x: i32, $0y: i32, ) {}"#, &["y", "y: i32", "y: i32, "]);
 353         do_check(r#"fn foo(x: i32,$0y: i32) {}"#, &["y", "y: i32", ",y: i32"]);
 354
 355         do_check(r#"const FOO: [usize; 2] = [ 22$0 , 33];"#, &["22", "22 , "]);
 356         do_check(r#"const FOO: [usize; 2] = [ 22 , 33$0];"#, &["33", ", 33"]);
 357         do_check(r#"const FOO: [usize; 2] = [ 22 , 33$0 ,];"#, &["33", "33 ,", "[ 22 , 33 ,]"]);
 358
 359         do_check(r#"fn main() { (1, 2$0) }"#, &["2", ", 2", "(1, 2)"]);
 360
 361         do_check(
 362             r#"
 363 const FOO: [usize; 2] = [
 364     22,
 365     $033,
 366 ]"#,
 367             &["33", "33,"],
 368         );
 369
 370         do_check(
 371             r#"
 372 const FOO: [usize; 2] = [
 373     22
 374     , 33$0,
 375 ]"#,
 376             &["33", "33,"],
 377         );
 378     }
 379
 380     #[test]
 381     fn test_extend_selection_start_of_the_line() {
 382         do_check(
 383             r#"
 384 impl S {
 385 $0    fn foo() {
 386
 387     }
 388 }"#,
 389             &["    fn foo() {\n\n    }\n"],
 390         );
 391     }
 392
 393     #[test]
 394     fn test_extend_selection_doc_comments() {
 395         do_check(
 396             r#"
 397 struct A;
 398
 399 /// bla
 400 /// bla
 401 struct B {
 402     $0
 403 }
 404             "#,
 405             &["\n    \n", "{\n    \n}", "/// bla\n/// bla\nstruct B {\n    \n}"],
 406         )
 407     }
 408
 409     #[test]
 410     fn test_extend_selection_comments() {
 411         do_check(
 412             r#"
 413 fn bar(){}
 414
 415 // fn foo() {
 416 // 1 + $01
 417 // }
 418
 419 // fn foo(){}
 420     "#,
 421             &["1", "// 1 + 1", "// fn foo() {\n// 1 + 1\n// }"],
 422         );
 423
 424         do_check(
 425             r#"
 426 // #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 427 // pub enum Direction {
 428 //  $0   Next,
 429 //     Prev
 430 // }
 431 "#,
 432             &[
 433                 "//     Next,",
 434                 "// #[derive(Debug, Clone, Copy, PartialEq, Eq)]\n// pub enum Direction {\n//     Next,\n//     Prev\n// }",
 435             ],
 436         );
 437
 438         do_check(
 439             r#"
 440 /*
 441 foo
 442 _bar1$0*/
 443 "#,
 444             &["_bar1", "/*\nfoo\n_bar1*/"],
 445         );
 446
 447         do_check(r#"//!$0foo_2 bar"#, &["foo_2", "//!foo_2 bar"]);
 448
 449         do_check(r#"/$0/foo bar"#, &["//foo bar"]);
 450     }
 451
 452     #[test]
 453     fn test_extend_selection_prefer_idents() {
 454         do_check(
 455             r#"
 456 fn main() { foo$0+bar;}
 457 "#,
 458             &["foo", "foo+bar"],
 459         );
 460         do_check(
 461             r#"
 462 fn main() { foo+$0bar;}
 463 "#,
 464             &["bar", "foo+bar"],
 465         );
 466     }
 467
 468     #[test]
 469     fn test_extend_selection_prefer_lifetimes() {
 470         do_check(r#"fn foo<$0'a>() {}"#, &["'a", "<'a>"]);
 471         do_check(r#"fn foo<'a$0>() {}"#, &["'a", "<'a>"]);
 472     }
 473
 474     #[test]
 475     fn test_extend_selection_select_first_word() {
 476         do_check(r#"// foo bar b$0az quxx"#, &["baz", "// foo bar baz quxx"]);
 477         do_check(
 478             r#"
 479 impl S {
 480 fn foo() {
 481 // hel$0lo world
 482 }
 483 }
 484 "#,
 485             &["hello", "// hello world"],
 486         );
 487     }
 488
 489     #[test]
 490     fn test_extend_selection_string() {
 491         do_check(
 492             r#"
 493 fn bar(){}
 494
 495 " fn f$0oo() {"
 496 "#,
 497             &["foo", "\" fn foo() {\""],
 498         );
 499     }
 500
 501     #[test]
 502     fn test_extend_trait_bounds_list_in_where_clause() {
 503         do_check(
 504             r#"
 505 fn foo<R>()
 506     where
 507         R: req::Request + 'static,
 508         R::Params: DeserializeOwned$0 + panic::UnwindSafe + 'static,
 509         R::Result: Serialize + 'static,
 510 "#,
 511             &[
 512                 "DeserializeOwned",
 513                 "DeserializeOwned + ",
 514                 "DeserializeOwned + panic::UnwindSafe + 'static",
 515                 "R::Params: DeserializeOwned + panic::UnwindSafe + 'static",
 516                 "R::Params: DeserializeOwned + panic::UnwindSafe + 'static,",
 517             ],
 518         );
 519         do_check(r#"fn foo<T>() where T: $0Copy"#, &["Copy"]);
 520         do_check(r#"fn foo<T>() where T: $0Copy + Display"#, &["Copy", "Copy + "]);
 521         do_check(r#"fn foo<T>() where T: $0Copy +Display"#, &["Copy", "Copy +"]);
 522         do_check(r#"fn foo<T>() where T: $0Copy+Display"#, &["Copy", "Copy+"]);
 523         do_check(r#"fn foo<T>() where T: Copy + $0Display"#, &["Display", "+ Display"]);
 524         do_check(r#"fn foo<T>() where T: Copy + $0Display + Sync"#, &["Display", "Display + "]);
 525         do_check(r#"fn foo<T>() where T: Copy +$0Display"#, &["Display", "+Display"]);
 526     }
 527
 528     #[test]
 529     fn test_extend_trait_bounds_list_inline() {
 530         do_check(r#"fn foo<T: $0Copy>() {}"#, &["Copy"]);
 531         do_check(r#"fn foo<T: $0Copy + Display>() {}"#, &["Copy", "Copy + "]);
 532         do_check(r#"fn foo<T: $0Copy +Display>() {}"#, &["Copy", "Copy +"]);
 533         do_check(r#"fn foo<T: $0Copy+Display>() {}"#, &["Copy", "Copy+"]);
 534         do_check(r#"fn foo<T: Copy + $0Display>() {}"#, &["Display", "+ Display"]);
 535         do_check(r#"fn foo<T: Copy + $0Display + Sync>() {}"#, &["Display", "Display + "]);
 536         do_check(r#"fn foo<T: Copy +$0Display>() {}"#, &["Display", "+Display"]);
 537         do_check(
 538             r#"fn foo<T: Copy$0 + Display, U: Copy>() {}"#,
 539             &[
 540                 "Copy",
 541                 "Copy + ",
 542                 "Copy + Display",
 543                 "T: Copy + Display",
 544                 "T: Copy + Display, ",
 545                 "<T: Copy + Display, U: Copy>",
 546             ],
 547         );
 548     }
 549
 550     #[test]
 551     fn test_extend_selection_on_tuple_in_type() {
 552         do_check(
 553             r#"fn main() { let _: (krate, $0_crate_def_map, module_id) = (); }"#,
 554             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
 555         );
 556         // white space variations
 557         do_check(
 558             r#"fn main() { let _: (krate,$0_crate_def_map,module_id) = (); }"#,
 559             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
 560         );
 561         do_check(
 562             r#"
 563 fn main() { let _: (
 564     krate,
 565     _crate$0_def_map,
 566     module_id
 567 ) = (); }"#,
 568             &[
 569                 "_crate_def_map",
 570                 "_crate_def_map,",
 571                 "(\n    krate,\n    _crate_def_map,\n    module_id\n)",
 572             ],
 573         );
 574     }
 575
 576     #[test]
 577     fn test_extend_selection_on_tuple_in_rvalue() {
 578         do_check(
 579             r#"fn main() { let var = (krate, _crate_def_map$0, module_id); }"#,
 580             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
 581         );
 582         // white space variations
 583         do_check(
 584             r#"fn main() { let var = (krate,_crate$0_def_map,module_id); }"#,
 585             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
 586         );
 587         do_check(
 588             r#"
 589 fn main() { let var = (
 590     krate,
 591     _crate_def_map$0,
 592     module_id
 593 ); }"#,
 594             &[
 595                 "_crate_def_map",
 596                 "_crate_def_map,",
 597                 "(\n    krate,\n    _crate_def_map,\n    module_id\n)",
 598             ],
 599         );
 600     }
 601
 602     #[test]
 603     fn test_extend_selection_on_tuple_pat() {
 604         do_check(
 605             r#"fn main() { let (krate, _crate_def_map$0, module_id) = var; }"#,
 606             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
 607         );
 608         // white space variations
 609         do_check(
 610             r#"fn main() { let (krate,_crate$0_def_map,module_id) = var; }"#,
 611             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
 612         );
 613         do_check(
 614             r#"
 615 fn main() { let (
 616     krate,
 617     _crate_def_map$0,
 618     module_id
 619 ) = var; }"#,
 620             &[
 621                 "_crate_def_map",
 622                 "_crate_def_map,",
 623                 "(\n    krate,\n    _crate_def_map,\n    module_id\n)",
 624             ],
 625         );
 626     }
 627
 628     #[test]
 629     fn extend_selection_inside_macros() {
 630         do_check(
 631             r#"macro_rules! foo { ($item:item) => {$item} }
 632                 foo!{fn hello(na$0me:usize){}}"#,
 633             &[
 634                 "name",
 635                 "name:usize",
 636                 "(name:usize)",
 637                 "fn hello(name:usize){}",
 638                 "{fn hello(name:usize){}}",
 639                 "foo!{fn hello(name:usize){}}",
 640             ],
 641         );
 642     }
 643
 644     #[test]
 645     fn extend_selection_inside_recur_macros() {
 646         do_check(
 647             r#" macro_rules! foo2 { ($item:item) => {$item} }
 648                 macro_rules! foo { ($item:item) => {foo2!($item);} }
 649                 foo!{fn hello(na$0me:usize){}}"#,
 650             &[
 651                 "name",
 652                 "name:usize",
 653                 "(name:usize)",
 654                 "fn hello(name:usize){}",
 655                 "{fn hello(name:usize){}}",
 656                 "foo!{fn hello(name:usize){}}",
 657             ],
 658         );
 659     }
 660 }