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             .skip_while(|node| match node {
 267                 NodeOrToken::Node(_) => false,
 268                 NodeOrToken::Token(it) => is_single_line_ws(it),
 269             })
 270             .next()
 271             .and_then(|it| it.into_token())
 272             .filter(|node| node.kind() == delimiter_kind)
 273     }
 274
 275     let delimiter = match node.kind() {
 276         TYPE_BOUND => T![+],
 277         _ => T![,],
 278     };
 279
 280     if let Some(delimiter_node) = nearby_delimiter(delimiter, node, Direction::Next) {
 281         // Include any following whitespace when delimiter is after list item.
 282         let final_node = delimiter_node
 283             .next_sibling_or_token()
 284             .and_then(|it| it.into_token())
 285             .filter(|node| is_single_line_ws(node))
 286             .unwrap_or(delimiter_node);
 287
 288         return Some(TextRange::new(node.text_range().start(), final_node.text_range().end()));
 289     }
 290     if let Some(delimiter_node) = nearby_delimiter(delimiter, node, Direction::Prev) {
 291         return Some(TextRange::new(delimiter_node.text_range().start(), node.text_range().end()));
 292     }
 293
 294     None
 295 }
 296
 297 fn extend_comments(comment: ast::Comment) -> Option<TextRange> {
 298     let prev = adj_comments(&comment, Direction::Prev);
 299     let next = adj_comments(&comment, Direction::Next);
 300     if prev != next {
 301         Some(TextRange::new(prev.syntax().text_range().start(), next.syntax().text_range().end()))
 302     } else {
 303         None
 304     }
 305 }
 306
 307 fn adj_comments(comment: &ast::Comment, dir: Direction) -> ast::Comment {
 308     let mut res = comment.clone();
 309     for element in comment.syntax().siblings_with_tokens(dir) {
 310         let token = match element.as_token() {
 311             None => break,
 312             Some(token) => token,
 313         };
 314         if let Some(c) = ast::Comment::cast(token.clone()) {
 315             res = c
 316         } else if token.kind() != WHITESPACE || token.text().contains("\n\n") {
 317             break;
 318         }
 319     }
 320     res
 321 }
 322
 323 #[cfg(test)]
 324 mod tests {
 325     use crate::fixture;
 326
 327     use super::*;
 328
 329     fn do_check(before: &str, afters: &[&str]) {
 330         let (analysis, position) = fixture::position(&before);
 331         let before = analysis.file_text(position.file_id).unwrap();
 332         let range = TextRange::empty(position.offset);
 333         let mut frange = FileRange { file_id: position.file_id, range };
 334
 335         for &after in afters {
 336             frange.range = analysis.extend_selection(frange).unwrap();
 337             let actual = &before[frange.range];
 338             assert_eq!(after, actual);
 339         }
 340     }
 341
 342     #[test]
 343     fn test_extend_selection_arith() {
 344         do_check(r#"fn foo() { $01 + 1 }"#, &["1", "1 + 1", "{ 1 + 1 }"]);
 345     }
 346
 347     #[test]
 348     fn test_extend_selection_list() {
 349         do_check(r#"fn foo($0x: i32) {}"#, &["x", "x: i32"]);
 350         do_check(r#"fn foo($0x: i32, y: i32) {}"#, &["x", "x: i32", "x: i32, "]);
 351         do_check(r#"fn foo($0x: i32,y: i32) {}"#, &["x", "x: i32", "x: i32,", "(x: 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         do_check(r#"fn foo(x: i32,$0y: i32) {}"#, &["y", "y: i32", ",y: i32"]);
 355
 356         do_check(r#"const FOO: [usize; 2] = [ 22$0 , 33];"#, &["22", "22 , "]);
 357         do_check(r#"const FOO: [usize; 2] = [ 22 , 33$0];"#, &["33", ", 33"]);
 358         do_check(r#"const FOO: [usize; 2] = [ 22 , 33$0 ,];"#, &["33", "33 ,", "[ 22 , 33 ,]"]);
 359
 360         do_check(r#"fn main() { (1, 2$0) }"#, &["2", ", 2", "(1, 2)"]);
 361
 362         do_check(
 363             r#"
 364 const FOO: [usize; 2] = [
 365     22,
 366     $033,
 367 ]"#,
 368             &["33", "33,"],
 369         );
 370
 371         do_check(
 372             r#"
 373 const FOO: [usize; 2] = [
 374     22
 375     , 33$0,
 376 ]"#,
 377             &["33", "33,"],
 378         );
 379     }
 380
 381     #[test]
 382     fn test_extend_selection_start_of_the_line() {
 383         do_check(
 384             r#"
 385 impl S {
 386 $0    fn foo() {
 387
 388     }
 389 }"#,
 390             &["    fn foo() {\n\n    }\n"],
 391         );
 392     }
 393
 394     #[test]
 395     fn test_extend_selection_doc_comments() {
 396         do_check(
 397             r#"
 398 struct A;
 399
 400 /// bla
 401 /// bla
 402 struct B {
 403     $0
 404 }
 405             "#,
 406             &["\n    \n", "{\n    \n}", "/// bla\n/// bla\nstruct B {\n    \n}"],
 407         )
 408     }
 409
 410     #[test]
 411     fn test_extend_selection_comments() {
 412         do_check(
 413             r#"
 414 fn bar(){}
 415
 416 // fn foo() {
 417 // 1 + $01
 418 // }
 419
 420 // fn foo(){}
 421     "#,
 422             &["1", "// 1 + 1", "// fn foo() {\n// 1 + 1\n// }"],
 423         );
 424
 425         do_check(
 426             r#"
 427 // #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 428 // pub enum Direction {
 429 //  $0   Next,
 430 //     Prev
 431 // }
 432 "#,
 433             &[
 434                 "//     Next,",
 435                 "// #[derive(Debug, Clone, Copy, PartialEq, Eq)]\n// pub enum Direction {\n//     Next,\n//     Prev\n// }",
 436             ],
 437         );
 438
 439         do_check(
 440             r#"
 441 /*
 442 foo
 443 _bar1$0*/
 444 "#,
 445             &["_bar1", "/*\nfoo\n_bar1*/"],
 446         );
 447
 448         do_check(r#"//!$0foo_2 bar"#, &["foo_2", "//!foo_2 bar"]);
 449
 450         do_check(r#"/$0/foo bar"#, &["//foo bar"]);
 451     }
 452
 453     #[test]
 454     fn test_extend_selection_prefer_idents() {
 455         do_check(
 456             r#"
 457 fn main() { foo$0+bar;}
 458 "#,
 459             &["foo", "foo+bar"],
 460         );
 461         do_check(
 462             r#"
 463 fn main() { foo+$0bar;}
 464 "#,
 465             &["bar", "foo+bar"],
 466         );
 467     }
 468
 469     #[test]
 470     fn test_extend_selection_prefer_lifetimes() {
 471         do_check(r#"fn foo<$0'a>() {}"#, &["'a", "<'a>"]);
 472         do_check(r#"fn foo<'a$0>() {}"#, &["'a", "<'a>"]);
 473     }
 474
 475     #[test]
 476     fn test_extend_selection_select_first_word() {
 477         do_check(r#"// foo bar b$0az quxx"#, &["baz", "// foo bar baz quxx"]);
 478         do_check(
 479             r#"
 480 impl S {
 481 fn foo() {
 482 // hel$0lo world
 483 }
 484 }
 485 "#,
 486             &["hello", "// hello world"],
 487         );
 488     }
 489
 490     #[test]
 491     fn test_extend_selection_string() {
 492         do_check(
 493             r#"
 494 fn bar(){}
 495
 496 " fn f$0oo() {"
 497 "#,
 498             &["foo", "\" fn foo() {\""],
 499         );
 500     }
 501
 502     #[test]
 503     fn test_extend_trait_bounds_list_in_where_clause() {
 504         do_check(
 505             r#"
 506 fn foo<R>()
 507     where
 508         R: req::Request + 'static,
 509         R::Params: DeserializeOwned$0 + panic::UnwindSafe + 'static,
 510         R::Result: Serialize + 'static,
 511 "#,
 512             &[
 513                 "DeserializeOwned",
 514                 "DeserializeOwned + ",
 515                 "DeserializeOwned + panic::UnwindSafe + 'static",
 516                 "R::Params: DeserializeOwned + panic::UnwindSafe + 'static",
 517                 "R::Params: DeserializeOwned + panic::UnwindSafe + 'static,",
 518             ],
 519         );
 520         do_check(r#"fn foo<T>() where T: $0Copy"#, &["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: $0Copy+Display"#, &["Copy", "Copy+"]);
 524         do_check(r#"fn foo<T>() where T: Copy + $0Display"#, &["Display", "+ Display"]);
 525         do_check(r#"fn foo<T>() where T: Copy + $0Display + Sync"#, &["Display", "Display + "]);
 526         do_check(r#"fn foo<T>() where T: Copy +$0Display"#, &["Display", "+Display"]);
 527     }
 528
 529     #[test]
 530     fn test_extend_trait_bounds_list_inline() {
 531         do_check(r#"fn foo<T: $0Copy>() {}"#, &["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: $0Copy+Display>() {}"#, &["Copy", "Copy+"]);
 535         do_check(r#"fn foo<T: Copy + $0Display>() {}"#, &["Display", "+ Display"]);
 536         do_check(r#"fn foo<T: Copy + $0Display + Sync>() {}"#, &["Display", "Display + "]);
 537         do_check(r#"fn foo<T: Copy +$0Display>() {}"#, &["Display", "+Display"]);
 538         do_check(
 539             r#"fn foo<T: Copy$0 + Display, U: Copy>() {}"#,
 540             &[
 541                 "Copy",
 542                 "Copy + ",
 543                 "Copy + Display",
 544                 "T: Copy + Display",
 545                 "T: Copy + Display, ",
 546                 "<T: Copy + Display, U: Copy>",
 547             ],
 548         );
 549     }
 550
 551     #[test]
 552     fn test_extend_selection_on_tuple_in_type() {
 553         do_check(
 554             r#"fn main() { let _: (krate, $0_crate_def_map, module_id) = (); }"#,
 555             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
 556         );
 557         // white space variations
 558         do_check(
 559             r#"fn main() { let _: (krate,$0_crate_def_map,module_id) = (); }"#,
 560             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
 561         );
 562         do_check(
 563             r#"
 564 fn main() { let _: (
 565     krate,
 566     _crate$0_def_map,
 567     module_id
 568 ) = (); }"#,
 569             &[
 570                 "_crate_def_map",
 571                 "_crate_def_map,",
 572                 "(\n    krate,\n    _crate_def_map,\n    module_id\n)",
 573             ],
 574         );
 575     }
 576
 577     #[test]
 578     fn test_extend_selection_on_tuple_in_rvalue() {
 579         do_check(
 580             r#"fn main() { let var = (krate, _crate_def_map$0, module_id); }"#,
 581             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
 582         );
 583         // white space variations
 584         do_check(
 585             r#"fn main() { let var = (krate,_crate$0_def_map,module_id); }"#,
 586             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
 587         );
 588         do_check(
 589             r#"
 590 fn main() { let var = (
 591     krate,
 592     _crate_def_map$0,
 593     module_id
 594 ); }"#,
 595             &[
 596                 "_crate_def_map",
 597                 "_crate_def_map,",
 598                 "(\n    krate,\n    _crate_def_map,\n    module_id\n)",
 599             ],
 600         );
 601     }
 602
 603     #[test]
 604     fn test_extend_selection_on_tuple_pat() {
 605         do_check(
 606             r#"fn main() { let (krate, _crate_def_map$0, module_id) = var; }"#,
 607             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
 608         );
 609         // white space variations
 610         do_check(
 611             r#"fn main() { let (krate,_crate$0_def_map,module_id) = var; }"#,
 612             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
 613         );
 614         do_check(
 615             r#"
 616 fn main() { let (
 617     krate,
 618     _crate_def_map$0,
 619     module_id
 620 ) = var; }"#,
 621             &[
 622                 "_crate_def_map",
 623                 "_crate_def_map,",
 624                 "(\n    krate,\n    _crate_def_map,\n    module_id\n)",
 625             ],
 626         );
 627     }
 628
 629     #[test]
 630     fn extend_selection_inside_macros() {
 631         do_check(
 632             r#"macro_rules! foo { ($item:item) => {$item} }
 633                 foo!{fn hello(na$0me:usize){}}"#,
 634             &[
 635                 "name",
 636                 "name:usize",
 637                 "(name:usize)",
 638                 "fn hello(name:usize){}",
 639                 "{fn hello(name:usize){}}",
 640                 "foo!{fn hello(name:usize){}}",
 641             ],
 642         );
 643     }
 644
 645     #[test]
 646     fn extend_selection_inside_recur_macros() {
 647         do_check(
 648             r#" macro_rules! foo2 { ($item:item) => {$item} }
 649                 macro_rules! foo { ($item:item) => {foo2!($item);} }
 650                 foo!{fn hello(na$0me:usize){}}"#,
 651             &[
 652                 "name",
 653                 "name:usize",
 654                 "(name:usize)",
 655                 "fn hello(name:usize){}",
 656                 "{fn hello(name:usize){}}",
 657                 "foo!{fn hello(name:usize){}}",
 658             ],
 659         );
 660     }
 661 }