prettier 1.0.1 → 1.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (59) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +65 -1
  3. data/CONTRIBUTING.md +2 -2
  4. data/README.md +6 -1
  5. data/lib/prettier.rb +2 -2
  6. data/node_modules/prettier/index.js +54 -54
  7. data/package.json +4 -2
  8. data/src/{ruby.js → plugin.js} +2 -2
  9. data/src/{embed.js → ruby/embed.js} +2 -2
  10. data/src/{nodes.js → ruby/nodes.js} +0 -0
  11. data/src/{nodes → ruby/nodes}/alias.js +1 -1
  12. data/src/{nodes → ruby/nodes}/aref.js +8 -1
  13. data/src/{nodes → ruby/nodes}/args.js +2 -2
  14. data/src/{nodes → ruby/nodes}/arrays.js +2 -3
  15. data/src/{nodes → ruby/nodes}/assign.js +12 -4
  16. data/src/{nodes → ruby/nodes}/blocks.js +3 -3
  17. data/src/{nodes → ruby/nodes}/calls.js +54 -11
  18. data/src/ruby/nodes/case.js +65 -0
  19. data/src/{nodes → ruby/nodes}/class.js +1 -1
  20. data/src/ruby/nodes/commands.js +126 -0
  21. data/src/{nodes → ruby/nodes}/conditionals.js +3 -3
  22. data/src/{nodes → ruby/nodes}/constants.js +2 -2
  23. data/src/{nodes → ruby/nodes}/flow.js +2 -2
  24. data/src/{nodes → ruby/nodes}/hashes.js +32 -10
  25. data/src/{nodes → ruby/nodes}/heredocs.js +2 -2
  26. data/src/{nodes → ruby/nodes}/hooks.js +2 -2
  27. data/src/{nodes → ruby/nodes}/ints.js +0 -0
  28. data/src/{nodes → ruby/nodes}/lambdas.js +2 -2
  29. data/src/ruby/nodes/loops.js +104 -0
  30. data/src/{nodes → ruby/nodes}/massign.js +8 -1
  31. data/src/{nodes → ruby/nodes}/methods.js +34 -6
  32. data/src/{nodes → ruby/nodes}/operators.js +2 -2
  33. data/src/{nodes → ruby/nodes}/params.js +9 -2
  34. data/src/{nodes → ruby/nodes}/patterns.js +45 -10
  35. data/src/ruby/nodes/regexp.js +56 -0
  36. data/src/{nodes → ruby/nodes}/rescue.js +2 -2
  37. data/src/ruby/nodes/return.js +98 -0
  38. data/src/{nodes → ruby/nodes}/statements.js +1 -1
  39. data/src/{nodes → ruby/nodes}/strings.js +1 -1
  40. data/src/{nodes → ruby/nodes}/super.js +2 -2
  41. data/src/{nodes → ruby/nodes}/undef.js +1 -1
  42. data/src/{parser.js → ruby/parser.js} +2 -2
  43. data/src/{parser.rb → ruby/parser.rb} +323 -317
  44. data/src/{printer.js → ruby/printer.js} +46 -1
  45. data/src/{toProc.js → ruby/toProc.js} +0 -0
  46. data/src/utils.js +10 -93
  47. data/src/utils/containsAssignment.js +11 -0
  48. data/src/utils/getTrailingComma.js +5 -0
  49. data/src/utils/hasAncestor.js +17 -0
  50. data/src/utils/literal.js +7 -0
  51. data/src/utils/makeCall.js +11 -0
  52. data/src/utils/noIndent.js +10 -0
  53. data/src/utils/skipAssignIndent.js +10 -0
  54. metadata +48 -41
  55. data/src/nodes/case.js +0 -61
  56. data/src/nodes/commands.js +0 -91
  57. data/src/nodes/loops.js +0 -101
  58. data/src/nodes/regexp.js +0 -49
  59. data/src/nodes/return.js +0 -72
@@ -10,7 +10,7 @@ const {
10
10
  literalline,
11
11
  softline,
12
12
  trim
13
- } = require("../prettier");
13
+ } = require("../../prettier");
14
14
 
15
15
  function printBodyStmt(path, opts, print) {
16
16
  const [stmts, rescue, elseClause, ensure] = path.getValue().body;
@@ -6,7 +6,7 @@ const {
6
6
  literalline,
7
7
  softline,
8
8
  join
9
- } = require("../prettier");
9
+ } = require("../../prettier");
10
10
 
11
11
  // If there is some part of this string that matches an escape sequence or that
12
12
  // contains the interpolation pattern ("#{"), then we are locked into whichever
@@ -1,5 +1,5 @@
1
- const { align, concat, group, join, line } = require("../prettier");
2
- const { literal } = require("../utils");
1
+ const { align, concat, group, join, line } = require("../../prettier");
2
+ const { literal } = require("../../utils");
3
3
 
4
4
  function printSuper(path, opts, print) {
5
5
  const args = path.getValue().body[0];
@@ -5,7 +5,7 @@ const {
5
5
  group,
6
6
  join,
7
7
  line
8
- } = require("../prettier");
8
+ } = require("../../prettier");
9
9
 
10
10
  function printUndefSymbol(path, opts, print) {
11
11
  const node = path.getValue();
@@ -67,14 +67,14 @@ function hasPragma(text) {
67
67
  // for returning the index of the character within the source string that is the
68
68
  // beginning of the given node.
69
69
  function locStart(node) {
70
- return node.char_start;
70
+ return node.sc;
71
71
  }
72
72
 
73
73
  // This function is critical for comments and cursor support, and is responsible
74
74
  // for returning the index of the character within the source string that is the
75
75
  // ending of the given node.
76
76
  function locEnd(node) {
77
- return node.char_end;
77
+ return node.ec;
78
78
  }
79
79
 
80
80
  module.exports = {
@@ -63,14 +63,14 @@ class Prettier::Parser < Ripper
63
63
  # would happen to be the innermost keyword). Then the outer one would only be
64
64
  # able to grab the first one. In this way all of the scanner events act as
65
65
  # their own stack.
66
- def find_scanner_event(type, body = :any)
66
+ def find_scanner_event(type, body = :any, consume: true)
67
67
  index =
68
68
  scanner_events.rindex do |scanner_event|
69
69
  scanner_event[:type] == type &&
70
70
  (body == :any || (scanner_event[:body] == body))
71
71
  end
72
72
 
73
- scanner_events.delete_at(index)
73
+ consume ? scanner_events.delete_at(index) : (index && scanner_events[index])
74
74
  end
75
75
 
76
76
  # Scanner events occur when the lexer hits a new token, like a keyword or an
@@ -89,14 +89,14 @@ class Prettier::Parser < Ripper
89
89
 
90
90
  (SCANNER_EVENTS - defined).each do |event|
91
91
  define_method(:"on_#{event}") do |value|
92
- char_end = char_pos + value.size
92
+ ec = char_pos + value.size
93
93
  node = {
94
94
  type: :"@#{event}",
95
95
  body: value,
96
96
  start: lineno,
97
97
  end: lineno,
98
- char_start: char_pos,
99
- char_end: char_end
98
+ sc: char_pos,
99
+ ec: ec
100
100
  }
101
101
 
102
102
  scanner_events << node
@@ -120,8 +120,8 @@ class Prettier::Parser < Ripper
120
120
  value: value[1..-1].chomp.force_encoding('UTF-8'),
121
121
  start: lineno,
122
122
  end: lineno,
123
- char_start: char_pos,
124
- char_end: char_pos + value.length - 1
123
+ sc: char_pos,
124
+ ec: char_pos + value.length - 1
125
125
  }
126
126
  end
127
127
 
@@ -140,8 +140,8 @@ class Prettier::Parser < Ripper
140
140
  body: nil,
141
141
  start: lineno,
142
142
  end: lineno,
143
- char_start: char_pos,
144
- char_end: char_pos
143
+ sc: char_pos,
144
+ ec: char_pos
145
145
  }
146
146
  end
147
147
 
@@ -186,16 +186,13 @@ class Prettier::Parser < Ripper
186
186
  beging = find_scanner_event(:@lbrace)
187
187
  ending = find_scanner_event(:@rbrace)
188
188
 
189
- stmts.bind(
190
- find_next_statement_start(beging[:char_end]),
191
- ending[:char_start]
192
- )
189
+ stmts.bind(find_next_statement_start(beging[:ec]), ending[:sc])
193
190
 
194
191
  find_scanner_event(:@kw, 'BEGIN').merge!(
195
192
  type: :BEGIN,
196
193
  body: [beging, stmts],
197
194
  end: ending[:end],
198
- char_end: ending[:char_end]
195
+ ec: ending[:ec]
199
196
  )
200
197
  end
201
198
 
@@ -213,16 +210,13 @@ class Prettier::Parser < Ripper
213
210
  beging = find_scanner_event(:@lbrace)
214
211
  ending = find_scanner_event(:@rbrace)
215
212
 
216
- stmts.bind(
217
- find_next_statement_start(beging[:char_end]),
218
- ending[:char_start]
219
- )
213
+ stmts.bind(find_next_statement_start(beging[:ec]), ending[:sc])
220
214
 
221
215
  find_scanner_event(:@kw, 'END').merge!(
222
216
  type: :END,
223
217
  body: [beging, stmts],
224
218
  end: ending[:end],
225
- char_end: ending[:char_end]
219
+ ec: ending[:ec]
226
220
  )
227
221
  end
228
222
 
@@ -234,16 +228,16 @@ class Prettier::Parser < Ripper
234
228
  def on_alias(left, right)
235
229
  beging = find_scanner_event(:@kw, 'alias')
236
230
 
237
- paren = source[beging[:char_end]...left[:char_start]].include?('(')
231
+ paren = source[beging[:ec]...left[:sc]].include?('(')
238
232
  ending = paren ? find_scanner_event(:@rparen) : right
239
233
 
240
234
  {
241
235
  type: :alias,
242
236
  body: [left, right],
243
237
  start: beging[:start],
244
- char_start: beging[:char_start],
238
+ sc: beging[:sc],
245
239
  end: ending[:end],
246
- char_end: ending[:char_end]
240
+ ec: ending[:ec]
247
241
  }
248
242
  end
249
243
 
@@ -269,9 +263,9 @@ class Prettier::Parser < Ripper
269
263
  type: :aref,
270
264
  body: [collection, index],
271
265
  start: collection[:start],
272
- char_start: collection[:char_start],
266
+ sc: collection[:sc],
273
267
  end: ending[:end],
274
- char_end: ending[:char_end]
268
+ ec: ending[:ec]
275
269
  }
276
270
  end
277
271
 
@@ -285,9 +279,9 @@ class Prettier::Parser < Ripper
285
279
  type: :aref_field,
286
280
  body: [collection, index],
287
281
  start: collection[:start],
288
- char_start: collection[:char_start],
282
+ sc: collection[:sc],
289
283
  end: ending[:end],
290
- char_end: ending[:char_end]
284
+ ec: ending[:ec]
291
285
  }
292
286
  end
293
287
 
@@ -299,9 +293,9 @@ class Prettier::Parser < Ripper
299
293
  type: :args,
300
294
  body: [],
301
295
  start: lineno,
302
- char_start: char_pos,
296
+ sc: char_pos,
303
297
  end: lineno,
304
- char_end: char_pos
298
+ ec: char_pos
305
299
  }
306
300
  end
307
301
 
@@ -313,11 +307,7 @@ class Prettier::Parser < Ripper
313
307
  if args[:body].empty?
314
308
  arg.merge(type: :args, body: [arg])
315
309
  else
316
- args.merge!(
317
- body: args[:body] << arg,
318
- end: arg[:end],
319
- char_end: arg[:char_end]
320
- )
310
+ args.merge!(body: args[:body] << arg, end: arg[:end], ec: arg[:ec])
321
311
  end
322
312
  end
323
313
 
@@ -331,7 +321,7 @@ class Prettier::Parser < Ripper
331
321
  type: :args_add_block,
332
322
  body: [args, block],
333
323
  end: ending[:end],
334
- char_end: ending[:char_end]
324
+ ec: ending[:ec]
335
325
  )
336
326
  end
337
327
 
@@ -346,9 +336,9 @@ class Prettier::Parser < Ripper
346
336
  type: :args_add_star,
347
337
  body: [args, part],
348
338
  start: beging[:start],
349
- char_start: beging[:char_start],
339
+ sc: beging[:sc],
350
340
  end: ending[:end],
351
- char_end: ending[:char_end]
341
+ ec: ending[:ec]
352
342
  }
353
343
  end
354
344
 
@@ -373,9 +363,9 @@ class Prettier::Parser < Ripper
373
363
  type: :arg_paren,
374
364
  body: [args],
375
365
  start: beging[:start],
376
- char_start: beging[:char_start],
366
+ sc: beging[:sc],
377
367
  end: ending[:end],
378
- char_end: ending[:char_end]
368
+ ec: ending[:ec]
379
369
  }
380
370
  end
381
371
 
@@ -392,19 +382,19 @@ class Prettier::Parser < Ripper
392
382
  type: :array,
393
383
  body: [contents],
394
384
  start: beging[:start],
395
- char_start: beging[:char_start],
385
+ sc: beging[:sc],
396
386
  end: ending[:end],
397
- char_end: ending[:char_end]
387
+ ec: ending[:ec]
398
388
  }
399
389
  else
400
390
  ending = find_scanner_event(:@tstring_end)
401
- contents[:char_end] = ending[:char_end]
391
+ contents[:ec] = ending[:ec]
402
392
 
403
393
  ending.merge!(
404
394
  type: :array,
405
395
  body: [contents],
406
396
  start: contents[:start],
407
- char_start: contents[:char_start]
397
+ sc: contents[:sc]
408
398
  )
409
399
  end
410
400
  end
@@ -418,9 +408,9 @@ class Prettier::Parser < Ripper
418
408
  type: :aryptn,
419
409
  body: [const, preargs, splatarg, postargs],
420
410
  start: pieces[0][:start],
421
- char_start: pieces[0][:char_start],
411
+ sc: pieces[0][:sc],
422
412
  end: pieces[-1][:end],
423
- char_end: pieces[-1][:char_end]
413
+ ec: pieces[-1][:ec]
424
414
  }
425
415
  end
426
416
 
@@ -432,7 +422,7 @@ class Prettier::Parser < Ripper
432
422
  type: :assign,
433
423
  body: [left, right],
434
424
  end: right[:end],
435
- char_end: right[:char_end]
425
+ ec: right[:ec]
436
426
  )
437
427
  end
438
428
 
@@ -444,9 +434,9 @@ class Prettier::Parser < Ripper
444
434
  type: :assoc_new,
445
435
  body: [key, value],
446
436
  start: key[:start],
447
- char_start: key[:char_start],
437
+ sc: key[:sc],
448
438
  end: value[:end],
449
- char_end: value[:char_end]
439
+ ec: value[:ec]
450
440
  }
451
441
  end
452
442
 
@@ -457,7 +447,7 @@ class Prettier::Parser < Ripper
457
447
  type: :assoc_splat,
458
448
  body: [contents],
459
449
  end: contents[:end],
460
- char_end: contents[:char_end]
450
+ ec: contents[:ec]
461
451
  )
462
452
  end
463
453
 
@@ -470,9 +460,9 @@ class Prettier::Parser < Ripper
470
460
  type: :assoclist_from_args,
471
461
  body: assocs,
472
462
  start: assocs[0][:start],
473
- char_start: assocs[0][:char_start],
463
+ sc: assocs[0][:sc],
474
464
  end: assocs[-1][:end],
475
- char_end: assocs[-1][:char_end]
465
+ ec: assocs[-1][:ec]
476
466
  }
477
467
  end
478
468
 
@@ -485,9 +475,9 @@ class Prettier::Parser < Ripper
485
475
  type: :bare_assoc_hash,
486
476
  body: assoc_news,
487
477
  start: assoc_news[0][:start],
488
- char_start: assoc_news[0][:char_start],
478
+ sc: assoc_news[0][:sc],
489
479
  end: assoc_news[-1][:end],
490
- char_end: assoc_news[-1][:char_end]
480
+ ec: assoc_news[-1][:ec]
491
481
  }
492
482
  end
493
483
 
@@ -495,20 +485,20 @@ class Prettier::Parser < Ripper
495
485
  # It includes a bodystmt event that has all of the consequent clauses.
496
486
  def on_begin(bodystmt)
497
487
  beging = find_scanner_event(:@kw, 'begin')
498
- char_end =
488
+ ec =
499
489
  if bodystmt[:body][1..-1].any?
500
- bodystmt[:char_end]
490
+ bodystmt[:ec]
501
491
  else
502
- find_scanner_event(:@kw, 'end')[:char_end]
492
+ find_scanner_event(:@kw, 'end')[:ec]
503
493
  end
504
494
 
505
- bodystmt.bind(beging[:char_end], char_end)
495
+ bodystmt.bind(beging[:ec], ec)
506
496
 
507
497
  beging.merge!(
508
498
  type: :begin,
509
499
  body: [bodystmt],
510
500
  end: bodystmt[:end],
511
- char_end: bodystmt[:char_end]
501
+ ec: bodystmt[:ec]
512
502
  )
513
503
  end
514
504
 
@@ -519,9 +509,9 @@ class Prettier::Parser < Ripper
519
509
  type: :binary,
520
510
  body: [left, oper, right],
521
511
  start: left[:start],
522
- char_start: left[:char_start],
512
+ sc: left[:sc],
523
513
  end: right[:end],
524
- char_end: right[:char_end]
514
+ ec: right[:ec]
525
515
  }
526
516
  end
527
517
 
@@ -531,7 +521,7 @@ class Prettier::Parser < Ripper
531
521
  index =
532
522
  scanner_events.rindex do |event|
533
523
  event[:type] == :@op && %w[| ||].include?(event[:body]) &&
534
- event[:char_start] < params[:char_start]
524
+ event[:sc] < params[:sc]
535
525
  end
536
526
 
537
527
  beging = scanner_events[index]
@@ -541,9 +531,9 @@ class Prettier::Parser < Ripper
541
531
  type: :block_var,
542
532
  body: [params, locals],
543
533
  start: beging[:start],
544
- char_start: beging[:char_start],
534
+ sc: beging[:sc],
545
535
  end: ending[:end],
546
- char_end: ending[:char_end]
536
+ ec: ending[:ec]
547
537
  }
548
538
  end
549
539
 
@@ -554,7 +544,7 @@ class Prettier::Parser < Ripper
554
544
  type: :blockarg,
555
545
  body: [ident],
556
546
  end: ident[:end],
557
- char_end: ident[:char_end]
547
+ ec: ident[:ec]
558
548
  )
559
549
  end
560
550
 
@@ -562,21 +552,18 @@ class Prettier::Parser < Ripper
562
552
  # doesn't necessarily know where it started. So the parent node needs to
563
553
  # report back down into this one where it goes.
564
554
  class BodyStmt < SimpleDelegator
565
- def bind(char_start, char_end)
566
- merge!(char_start: char_start, char_end: char_end)
555
+ def bind(sc, ec)
556
+ merge!(sc: sc, ec: ec)
567
557
  parts = self[:body]
568
558
 
569
559
  # Here we're going to determine the bounds for the stmts
570
560
  consequent = parts[1..-1].compact.first
571
- self[:body][0].bind(
572
- char_start,
573
- consequent ? consequent[:char_start] : char_end
574
- )
561
+ self[:body][0].bind(sc, consequent ? consequent[:sc] : ec)
575
562
 
576
563
  # Next we're going to determine the rescue clause if there is one
577
564
  if parts[1]
578
565
  consequent = parts[2..-1].compact.first
579
- self[:body][1].bind_end(consequent ? consequent[:char_start] : char_end)
566
+ self[:body][1].bind_end(consequent ? consequent[:sc] : ec)
580
567
  end
581
568
  end
582
569
  end
@@ -588,9 +575,9 @@ class Prettier::Parser < Ripper
588
575
  type: :bodystmt,
589
576
  body: [stmts, rescued, ensured, elsed],
590
577
  start: lineno,
591
- char_start: char_pos,
578
+ sc: char_pos,
592
579
  end: lineno,
593
- char_end: char_pos
580
+ ec: char_pos
594
581
  )
595
582
  end
596
583
 
@@ -602,15 +589,15 @@ class Prettier::Parser < Ripper
602
589
  beging = find_scanner_event(:@lbrace)
603
590
  ending = find_scanner_event(:@rbrace)
604
591
 
605
- stmts.bind((block_var || beging)[:char_end], ending[:char_start])
592
+ stmts.bind((block_var || beging)[:ec], ending[:sc])
606
593
 
607
594
  {
608
595
  type: :brace_block,
609
596
  body: [block_var, stmts],
610
597
  start: beging[:start],
611
- char_start: beging[:char_start],
598
+ sc: beging[:sc],
612
599
  end: ending[:end],
613
- char_end: ending[:char_end]
600
+ ec: ending[:ec]
614
601
  }
615
602
  end
616
603
 
@@ -631,7 +618,7 @@ class Prettier::Parser < Ripper
631
618
  type: :break,
632
619
  body: [args_add_block],
633
620
  end: args_add_block[:end],
634
- char_end: args_add_block[:char_end]
621
+ ec: args_add_block[:ec]
635
622
  )
636
623
  end
637
624
 
@@ -665,9 +652,9 @@ class Prettier::Parser < Ripper
665
652
  type: :call,
666
653
  body: [receiver, oper, sending],
667
654
  start: receiver[:start],
668
- char_start: receiver[:char_start],
655
+ sc: receiver[:sc],
669
656
  end: ending[:end],
670
- char_end: ending[:char_end]
657
+ ec: ending[:ec]
671
658
  }
672
659
  end
673
660
 
@@ -675,11 +662,18 @@ class Prettier::Parser < Ripper
675
662
  # It accepts as arguments the switch of the case and the consequent
676
663
  # clause.
677
664
  def on_case(switch, consequent)
678
- find_scanner_event(:@kw, 'case').merge!(
679
- type: :case,
665
+ beging =
666
+ if event = find_scanner_event(:@kw, 'case', consume: false)
667
+ scanner_events.delete(event).merge!(type: :case)
668
+ else
669
+ keyword = find_scanner_event(:@kw, 'in', consume: false)
670
+ switch.merge(type: :rassign, keyword: keyword)
671
+ end
672
+
673
+ beging.merge!(
680
674
  body: [switch, consequent],
681
675
  end: consequent[:end],
682
- char_end: consequent[:char_end]
676
+ ec: consequent[:ec]
683
677
  )
684
678
  end
685
679
 
@@ -713,17 +707,17 @@ class Prettier::Parser < Ripper
713
707
  ending = find_scanner_event(:@kw, 'end')
714
708
 
715
709
  bodystmt.bind(
716
- find_next_statement_start((superclass || const)[:char_end]),
717
- ending[:char_start]
710
+ find_next_statement_start((superclass || const)[:ec]),
711
+ ending[:sc]
718
712
  )
719
713
 
720
714
  {
721
715
  type: :class,
722
716
  body: [const, superclass, bodystmt],
723
717
  start: beging[:start],
724
- char_start: beging[:char_start],
718
+ sc: beging[:sc],
725
719
  end: ending[:end],
726
- char_end: ending[:char_end]
720
+ ec: ending[:ec]
727
721
  }
728
722
  end
729
723
 
@@ -735,9 +729,9 @@ class Prettier::Parser < Ripper
735
729
  type: :command,
736
730
  body: [ident, args],
737
731
  start: ident[:start],
738
- char_start: ident[:char_start],
732
+ sc: ident[:sc],
739
733
  end: args[:end],
740
- char_end: args[:char_end]
734
+ ec: args[:ec]
741
735
  }
742
736
  end
743
737
 
@@ -746,15 +740,20 @@ class Prettier::Parser < Ripper
746
740
  # of the method, the operator being used to send the method, the name of
747
741
  # the method, and the arguments being passed to the method.
748
742
  def on_command_call(receiver, oper, ident, args)
743
+ # Make sure we take the operator out of the scanner events so that it
744
+ # doesn't get confused for a unary operator later.
745
+ scanner_events.delete(oper)
746
+
747
+ # Grab the ending from either the arguments or the method being sent
749
748
  ending = args || ident
750
749
 
751
750
  {
752
751
  type: :command_call,
753
752
  body: [receiver, oper, ident, args],
754
753
  start: receiver[:start],
755
- char_start: receiver[:char_start],
754
+ sc: receiver[:sc],
756
755
  end: ending[:end],
757
- char_end: ending[:char_end]
756
+ ec: ending[:ec]
758
757
  }
759
758
  end
760
759
 
@@ -769,9 +768,9 @@ class Prettier::Parser < Ripper
769
768
  type: :const_path_field,
770
769
  body: [left, const],
771
770
  start: left[:start],
772
- char_start: left[:char_start],
771
+ sc: left[:sc],
773
772
  end: const[:end],
774
- char_end: const[:char_end]
773
+ ec: const[:ec]
775
774
  }
776
775
  end
777
776
 
@@ -786,9 +785,9 @@ class Prettier::Parser < Ripper
786
785
  type: :const_path_ref,
787
786
  body: [left, const],
788
787
  start: left[:start],
789
- char_start: left[:char_start],
788
+ sc: left[:sc],
790
789
  end: const[:end],
791
- char_end: const[:char_end]
790
+ ec: const[:ec]
792
791
  }
793
792
  end
794
793
 
@@ -814,32 +813,54 @@ class Prettier::Parser < Ripper
814
813
  # │ └> params
815
814
  # └> ident
816
815
  #
816
+ # You can also have single-line methods since Ruby 3.0+, which have slightly
817
+ # different syntax but still flow through this method. Those look like:
818
+ #
819
+ # def foo = bar
820
+ # | |
821
+ # | └> stmt
822
+ # └> ident
823
+ #
817
824
  def on_def(ident, params, bodystmt)
818
825
  # Make sure to delete this scanner event in case you're defining something
819
826
  # like def class which would lead to this being a kw and causing all kinds
820
827
  # of trouble
821
828
  scanner_events.delete(ident)
822
829
 
830
+ # Find the beginning of the method definition, which works for single-line
831
+ # and normal method definitions.
832
+ beging = find_scanner_event(:@kw, 'def')
833
+
834
+ # If we don't have a bodystmt node, then we have a single-line method
835
+ if bodystmt[:type] != :bodystmt
836
+ return(
837
+ {
838
+ type: :defsl,
839
+ body: [ident, params, bodystmt],
840
+ start: beging[:start],
841
+ sc: beging[:sc],
842
+ end: bodystmt[:end],
843
+ ec: bodystmt[:ec]
844
+ }
845
+ )
846
+ end
847
+
823
848
  if params[:type] == :params && !params[:body].any?
824
- location = ident[:char_end]
825
- params.merge!(char_start: location, char_end: location)
849
+ location = ident[:ec]
850
+ params.merge!(sc: location, ec: location)
826
851
  end
827
852
 
828
- beging = find_scanner_event(:@kw, 'def')
829
853
  ending = find_scanner_event(:@kw, 'end')
830
854
 
831
- bodystmt.bind(
832
- find_next_statement_start(params[:char_end]),
833
- ending[:char_start]
834
- )
855
+ bodystmt.bind(find_next_statement_start(params[:ec]), ending[:sc])
835
856
 
836
857
  {
837
858
  type: :def,
838
859
  body: [ident, params, bodystmt],
839
860
  start: beging[:start],
840
- char_start: beging[:char_start],
861
+ sc: beging[:sc],
841
862
  end: ending[:end],
842
- char_end: ending[:char_end]
863
+ ec: ending[:ec]
843
864
  }
844
865
  end
845
866
 
@@ -864,25 +885,22 @@ class Prettier::Parser < Ripper
864
885
  scanner_events.delete(ident)
865
886
 
866
887
  if params[:type] == :params && !params[:body].any?
867
- location = ident[:char_end]
868
- params.merge!(char_start: location, char_end: location)
888
+ location = ident[:ec]
889
+ params.merge!(sc: location, ec: location)
869
890
  end
870
891
 
871
892
  beging = find_scanner_event(:@kw, 'def')
872
893
  ending = find_scanner_event(:@kw, 'end')
873
894
 
874
- bodystmt.bind(
875
- find_next_statement_start(params[:char_end]),
876
- ending[:char_start]
877
- )
895
+ bodystmt.bind(find_next_statement_start(params[:ec]), ending[:sc])
878
896
 
879
897
  {
880
898
  type: :defs,
881
899
  body: [target, oper, ident, params, bodystmt],
882
900
  start: beging[:start],
883
- char_start: beging[:char_start],
901
+ sc: beging[:sc],
884
902
  end: ending[:end],
885
- char_end: ending[:char_end]
903
+ ec: ending[:ec]
886
904
  }
887
905
  end
888
906
 
@@ -893,14 +911,14 @@ class Prettier::Parser < Ripper
893
911
  def on_defined(value)
894
912
  beging = find_scanner_event(:@kw, 'defined?')
895
913
 
896
- paren = source[beging[:char_end]...value[:char_start]].include?('(')
914
+ paren = source[beging[:ec]...value[:sc]].include?('(')
897
915
  ending = paren ? find_scanner_event(:@rparen) : value
898
916
 
899
917
  beging.merge!(
900
918
  type: :defined,
901
919
  body: [value],
902
920
  end: ending[:end],
903
- char_end: ending[:char_end]
921
+ ec: ending[:ec]
904
922
  )
905
923
  end
906
924
 
@@ -912,15 +930,15 @@ class Prettier::Parser < Ripper
912
930
  beging = find_scanner_event(:@kw, 'do')
913
931
  ending = find_scanner_event(:@kw, 'end')
914
932
 
915
- bodystmt.bind((block_var || beging)[:char_end], ending[:char_start])
933
+ bodystmt.bind((block_var || beging)[:ec], ending[:sc])
916
934
 
917
935
  {
918
936
  type: :do_block,
919
937
  body: [block_var, bodystmt],
920
938
  start: beging[:start],
921
- char_start: beging[:char_start],
939
+ sc: beging[:sc],
922
940
  end: ending[:end],
923
- char_end: ending[:char_end]
941
+ ec: ending[:ec]
924
942
  }
925
943
  end
926
944
 
@@ -937,9 +955,9 @@ class Prettier::Parser < Ripper
937
955
  type: :dot2,
938
956
  body: [left, right],
939
957
  start: beging[:start],
940
- char_start: beging[:char_start],
958
+ sc: beging[:sc],
941
959
  end: ending[:end],
942
- char_end: ending[:char_end]
960
+ ec: ending[:ec]
943
961
  }
944
962
  end
945
963
 
@@ -956,9 +974,9 @@ class Prettier::Parser < Ripper
956
974
  type: :dot3,
957
975
  body: [left, right],
958
976
  start: beging[:start],
959
- char_start: beging[:char_start],
977
+ sc: beging[:sc],
960
978
  end: ending[:end],
961
- char_end: ending[:char_end]
979
+ ec: ending[:ec]
962
980
  }
963
981
  end
964
982
 
@@ -981,7 +999,7 @@ class Prettier::Parser < Ripper
981
999
  #
982
1000
  # which would be the same symbol as above.
983
1001
  def on_dyna_symbol(string)
984
- if scanner_events.any? { |event| event[:type] == :@symbeg }
1002
+ if find_scanner_event(:@symbeg, consume: false)
985
1003
  # A normal dynamic symbol
986
1004
  beging = find_scanner_event(:@symbeg)
987
1005
  ending = find_scanner_event(:@tstring_end)
@@ -991,7 +1009,7 @@ class Prettier::Parser < Ripper
991
1009
  quote: beging[:body][1],
992
1010
  body: string[:body],
993
1011
  end: ending[:end],
994
- char_end: ending[:char_end]
1012
+ ec: ending[:ec]
995
1013
  )
996
1014
  else
997
1015
  # A dynamic symbol as a hash key
@@ -1002,9 +1020,9 @@ class Prettier::Parser < Ripper
1002
1020
  type: :dyna_symbol,
1003
1021
  quote: ending[:body][0],
1004
1022
  start: beging[:start],
1005
- char_start: beging[:char_start],
1023
+ sc: beging[:sc],
1006
1024
  end: ending[:end],
1007
- char_end: ending[:char_end]
1025
+ ec: ending[:ec]
1008
1026
  )
1009
1027
  end
1010
1028
  end
@@ -1029,15 +1047,15 @@ class Prettier::Parser < Ripper
1029
1047
  beging = find_scanner_event(:@kw, 'else')
1030
1048
  ending = find_else_ending
1031
1049
 
1032
- stmts.bind(beging[:char_end], ending[:char_start])
1050
+ stmts.bind(beging[:ec], ending[:sc])
1033
1051
 
1034
1052
  {
1035
1053
  type: :else,
1036
1054
  body: [stmts],
1037
1055
  start: beging[:start],
1038
- char_start: beging[:char_start],
1056
+ sc: beging[:sc],
1039
1057
  end: ending[:end],
1040
- char_end: ending[:char_end]
1058
+ ec: ending[:ec]
1041
1059
  }
1042
1060
  end
1043
1061
 
@@ -1049,15 +1067,15 @@ class Prettier::Parser < Ripper
1049
1067
  beging = find_scanner_event(:@kw, 'elsif')
1050
1068
  ending = consequent || find_scanner_event(:@kw, 'end')
1051
1069
 
1052
- stmts.bind(predicate[:char_end], ending[:char_start])
1070
+ stmts.bind(predicate[:ec], ending[:sc])
1053
1071
 
1054
1072
  {
1055
1073
  type: :elsif,
1056
1074
  body: [predicate, stmts, consequent],
1057
1075
  start: beging[:start],
1058
- char_start: beging[:char_start],
1076
+ sc: beging[:sc],
1059
1077
  end: ending[:end],
1060
- char_end: ending[:char_end]
1078
+ ec: ending[:ec]
1061
1079
  }
1062
1080
  end
1063
1081
 
@@ -1067,12 +1085,7 @@ class Prettier::Parser < Ripper
1067
1085
  # and add to it as we get content. It always starts with this scanner
1068
1086
  # event, so here we'll initialize the current embdoc.
1069
1087
  def on_embdoc_beg(value)
1070
- @embdoc = {
1071
- type: :@embdoc,
1072
- value: value,
1073
- start: lineno,
1074
- char_start: char_pos
1075
- }
1088
+ @embdoc = { type: :@embdoc, value: value, start: lineno, sc: char_pos }
1076
1089
  end
1077
1090
 
1078
1091
  # This is a scanner event that gets hit when we're inside an embdoc and
@@ -1092,7 +1105,7 @@ class Prettier::Parser < Ripper
1092
1105
  @embdoc.merge!(
1093
1106
  value: @embdoc[:value] << value.chomp,
1094
1107
  end: lineno,
1095
- char_end: char_pos + value.length - 1
1108
+ ec: char_pos + value.length - 1
1096
1109
  )
1097
1110
 
1098
1111
  @embdoc = nil
@@ -1111,18 +1124,15 @@ class Prettier::Parser < Ripper
1111
1124
  end
1112
1125
 
1113
1126
  ending = scanner_events[index]
1114
- stmts.bind(
1115
- find_next_statement_start(beging[:char_end]),
1116
- ending[:char_start]
1117
- )
1127
+ stmts.bind(find_next_statement_start(beging[:ec]), ending[:sc])
1118
1128
 
1119
1129
  {
1120
1130
  type: :ensure,
1121
1131
  body: [beging, stmts],
1122
1132
  start: beging[:start],
1123
- char_start: beging[:char_start],
1133
+ sc: beging[:sc],
1124
1134
  end: ending[:end],
1125
- char_end: ending[:char_end]
1135
+ ec: ending[:ec]
1126
1136
  }
1127
1137
  end
1128
1138
 
@@ -1151,9 +1161,25 @@ class Prettier::Parser < Ripper
1151
1161
  type: :field,
1152
1162
  body: [left, oper, right],
1153
1163
  start: left[:start],
1154
- char_start: left[:char_start],
1164
+ sc: left[:sc],
1155
1165
  end: right[:end],
1156
- char_end: right[:char_end]
1166
+ ec: right[:ec]
1167
+ }
1168
+ end
1169
+
1170
+ # fndptn is a parser event that represents matching against a pattern where
1171
+ # you find a pattern in an array using the Ruby 3.0+ pattern matching syntax.
1172
+ def on_fndptn(const, presplat, args, postsplat)
1173
+ beging = const || find_scanner_event(:@lbracket)
1174
+ ending = find_scanner_event(:@rbracket)
1175
+
1176
+ {
1177
+ type: :fndptn,
1178
+ body: [const, presplat, args, postsplat],
1179
+ start: beging[:start],
1180
+ sc: beging[:sc],
1181
+ end: ending[:end],
1182
+ ec: ending[:ec]
1157
1183
  }
1158
1184
  end
1159
1185
 
@@ -1165,15 +1191,15 @@ class Prettier::Parser < Ripper
1165
1191
  beging = find_scanner_event(:@kw, 'for')
1166
1192
  ending = find_scanner_event(:@kw, 'end')
1167
1193
 
1168
- stmts.bind(enumerable[:char_end], ending[:char_start])
1194
+ stmts.bind(enumerable[:ec], ending[:sc])
1169
1195
 
1170
1196
  {
1171
1197
  type: :for,
1172
1198
  body: [ident, enumerable, stmts],
1173
1199
  start: beging[:start],
1174
- char_start: beging[:char_start],
1200
+ sc: beging[:sc],
1175
1201
  end: ending[:end],
1176
- char_end: ending[:char_end]
1202
+ ec: ending[:ec]
1177
1203
  }
1178
1204
  end
1179
1205
 
@@ -1187,19 +1213,16 @@ class Prettier::Parser < Ripper
1187
1213
  if assoclist_from_args
1188
1214
  # Here we're going to expand out the location information for the assocs
1189
1215
  # node so that it can grab up any remaining comments inside the hash.
1190
- assoclist_from_args.merge!(
1191
- char_start: beging[:char_end],
1192
- char_end: ending[:char_start]
1193
- )
1216
+ assoclist_from_args.merge!(sc: beging[:ec], ec: ending[:sc])
1194
1217
  end
1195
1218
 
1196
1219
  {
1197
1220
  type: :hash,
1198
1221
  body: [assoclist_from_args],
1199
1222
  start: beging[:start],
1200
- char_start: beging[:char_start],
1223
+ sc: beging[:sc],
1201
1224
  end: ending[:end],
1202
- char_end: ending[:char_end]
1225
+ ec: ending[:ec]
1203
1226
  }
1204
1227
  end
1205
1228
 
@@ -1213,8 +1236,8 @@ class Prettier::Parser < Ripper
1213
1236
  location = {
1214
1237
  start: lineno,
1215
1238
  end: lineno,
1216
- char_start: char_pos,
1217
- char_end: char_pos + beging.length + 1
1239
+ sc: char_pos,
1240
+ ec: char_pos + beging.length + 1
1218
1241
  }
1219
1242
 
1220
1243
  # Here we're going to artificially create an extra node type so that if
@@ -1236,7 +1259,7 @@ class Prettier::Parser < Ripper
1236
1259
 
1237
1260
  # This is a scanner event that represents the end of the heredoc.
1238
1261
  def on_heredoc_end(ending)
1239
- @heredocs[-1].merge!(ending: ending.chomp, end: lineno, char_end: char_pos)
1262
+ @heredocs[-1].merge!(ending: ending.chomp, end: lineno, ec: char_pos)
1240
1263
  end
1241
1264
 
1242
1265
  # hshptn is a parser event that represents matching against a hash pattern
@@ -1248,9 +1271,9 @@ class Prettier::Parser < Ripper
1248
1271
  type: :hshptn,
1249
1272
  body: [const, kw, kwrest],
1250
1273
  start: pieces[0][:start],
1251
- char_start: pieces[0][:char_start],
1274
+ sc: pieces[0][:sc],
1252
1275
  end: pieces[-1][:end],
1253
- char_end: pieces[-1][:char_end]
1276
+ ec: pieces[-1][:ec]
1254
1277
  }
1255
1278
  end
1256
1279
 
@@ -1261,15 +1284,15 @@ class Prettier::Parser < Ripper
1261
1284
  beging = find_scanner_event(:@kw, 'if')
1262
1285
  ending = consequent || find_scanner_event(:@kw, 'end')
1263
1286
 
1264
- stmts.bind(predicate[:char_end], ending[:char_start])
1287
+ stmts.bind(predicate[:ec], ending[:sc])
1265
1288
 
1266
1289
  {
1267
1290
  type: :if,
1268
1291
  body: [predicate, stmts, consequent],
1269
1292
  start: beging[:start],
1270
- char_start: beging[:char_start],
1293
+ sc: beging[:sc],
1271
1294
  end: ending[:end],
1272
- char_end: ending[:char_end]
1295
+ ec: ending[:ec]
1273
1296
  }
1274
1297
  end
1275
1298
 
@@ -1281,7 +1304,7 @@ class Prettier::Parser < Ripper
1281
1304
  type: :ifop,
1282
1305
  body: [predicate, truthy, falsy],
1283
1306
  end: falsy[:end],
1284
- char_end: falsy[:char_end]
1307
+ ec: falsy[:ec]
1285
1308
  )
1286
1309
  end
1287
1310
 
@@ -1295,25 +1318,29 @@ class Prettier::Parser < Ripper
1295
1318
  type: :if_mod,
1296
1319
  body: [predicate, statement],
1297
1320
  start: statement[:start],
1298
- char_start: statement[:char_start],
1321
+ sc: statement[:sc],
1299
1322
  end: predicate[:end],
1300
- char_end: predicate[:char_end]
1323
+ ec: predicate[:ec]
1301
1324
  }
1302
1325
  end
1303
1326
 
1304
1327
  # in is a parser event that represents using the in keyword within the
1305
- # Ruby 2.7+ pattern matching syntax.
1328
+ # Ruby 2.7+ pattern matching syntax. Alternatively in Ruby 3+ it is also used
1329
+ # to handle rightward assignment for pattern matching.
1306
1330
  def on_in(pattern, stmts, consequent)
1331
+ # Here we have a rightward assignment
1332
+ return pattern unless stmts
1333
+
1307
1334
  beging = find_scanner_event(:@kw, 'in')
1308
1335
  ending = consequent || find_scanner_event(:@kw, 'end')
1309
1336
 
1310
- stmts.bind(beging[:char_end], ending[:char_start])
1337
+ stmts.bind(beging[:ec], ending[:sc])
1311
1338
 
1312
1339
  beging.merge!(
1313
1340
  type: :in,
1314
1341
  body: [pattern, stmts, consequent],
1315
1342
  end: ending[:end],
1316
- char_end: ending[:char_end]
1343
+ ec: ending[:ec]
1317
1344
  )
1318
1345
  end
1319
1346
 
@@ -1327,7 +1354,7 @@ class Prettier::Parser < Ripper
1327
1354
  type: :kwrest_param,
1328
1355
  body: [ident],
1329
1356
  end: ident[:end],
1330
- char_end: ident[:char_end]
1357
+ ec: ident[:ec]
1331
1358
  )
1332
1359
  end
1333
1360
 
@@ -1341,23 +1368,23 @@ class Prettier::Parser < Ripper
1341
1368
  def on_lambda(params, stmts)
1342
1369
  beging = find_scanner_event(:@tlambda)
1343
1370
 
1344
- if scanner_events.any? { |event| event[:type] == :@tlambeg }
1345
- opening = find_scanner_event(:@tlambeg)
1371
+ if event = find_scanner_event(:@tlambeg, consume: false)
1372
+ opening = scanner_events.delete(event)
1346
1373
  closing = find_scanner_event(:@rbrace)
1347
1374
  else
1348
1375
  opening = find_scanner_event(:@kw, 'do')
1349
1376
  closing = find_scanner_event(:@kw, 'end')
1350
1377
  end
1351
1378
 
1352
- stmts.bind(opening[:char_end], closing[:char_start])
1379
+ stmts.bind(opening[:ec], closing[:sc])
1353
1380
 
1354
1381
  {
1355
1382
  type: :lambda,
1356
1383
  body: [params, stmts],
1357
1384
  start: beging[:start],
1358
- char_start: beging[:char_start],
1385
+ sc: beging[:sc],
1359
1386
  end: closing[:end],
1360
- char_end: closing[:char_end]
1387
+ ec: closing[:ec]
1361
1388
  }
1362
1389
  end
1363
1390
 
@@ -1379,17 +1406,15 @@ class Prettier::Parser < Ripper
1379
1406
  # in which case we need to explicitly track the comma and add it onto the
1380
1407
  # child node.
1381
1408
  def on_massign(left, right)
1382
- if source[left[:char_end]...right[:char_start]].strip.start_with?(',')
1383
- left[:comma] = true
1384
- end
1409
+ left[:comma] = true if source[left[:ec]...right[:sc]].strip.start_with?(',')
1385
1410
 
1386
1411
  {
1387
1412
  type: :massign,
1388
1413
  body: [left, right],
1389
1414
  start: left[:start],
1390
- char_start: left[:char_start],
1415
+ sc: left[:sc],
1391
1416
  end: right[:end],
1392
- char_end: right[:char_end]
1417
+ ec: right[:ec]
1393
1418
  }
1394
1419
  end
1395
1420
 
@@ -1409,9 +1434,9 @@ class Prettier::Parser < Ripper
1409
1434
  type: :method_add_arg,
1410
1435
  body: [fcall, arg_paren],
1411
1436
  start: fcall[:start],
1412
- char_start: fcall[:char_start],
1437
+ sc: fcall[:sc],
1413
1438
  end: arg_paren[:end],
1414
- char_end: arg_paren[:char_end]
1439
+ ec: arg_paren[:ec]
1415
1440
  }
1416
1441
  end
1417
1442
 
@@ -1423,9 +1448,9 @@ class Prettier::Parser < Ripper
1423
1448
  type: :method_add_block,
1424
1449
  body: [method_add_arg, block],
1425
1450
  start: method_add_arg[:start],
1426
- char_start: method_add_arg[:char_start],
1451
+ sc: method_add_arg[:sc],
1427
1452
  end: block[:end],
1428
- char_end: block[:char_end]
1453
+ ec: block[:ec]
1429
1454
  }
1430
1455
  end
1431
1456
 
@@ -1437,9 +1462,9 @@ class Prettier::Parser < Ripper
1437
1462
  type: :mlhs,
1438
1463
  body: [],
1439
1464
  start: lineno,
1440
- char_start: char_pos,
1465
+ sc: char_pos,
1441
1466
  end: lineno,
1442
- char_end: char_pos
1467
+ ec: char_pos
1443
1468
  }
1444
1469
  end
1445
1470
 
@@ -1450,11 +1475,7 @@ class Prettier::Parser < Ripper
1450
1475
  if mlhs[:body].empty?
1451
1476
  part.merge(type: :mlhs, body: [part])
1452
1477
  else
1453
- mlhs.merge!(
1454
- body: mlhs[:body] << part,
1455
- end: part[:end],
1456
- char_end: part[:char_end]
1457
- )
1478
+ mlhs.merge!(body: mlhs[:body] << part, end: part[:end], ec: part[:ec])
1458
1479
  end
1459
1480
  end
1460
1481
 
@@ -1468,7 +1489,7 @@ class Prettier::Parser < Ripper
1468
1489
  type: :mlhs_add_post,
1469
1490
  body: [mlhs_add_star, mlhs],
1470
1491
  end: mlhs[:end],
1471
- char_end: mlhs[:char_end]
1492
+ ec: mlhs[:ec]
1472
1493
  )
1473
1494
  end
1474
1495
 
@@ -1484,9 +1505,9 @@ class Prettier::Parser < Ripper
1484
1505
  type: :mlhs_add_star,
1485
1506
  body: [mlhs, part],
1486
1507
  start: beging[:start],
1487
- char_start: beging[:char_start],
1508
+ sc: beging[:sc],
1488
1509
  end: ending[:end],
1489
- char_end: ending[:char_end]
1510
+ ec: ending[:ec]
1490
1511
  }
1491
1512
  end
1492
1513
 
@@ -1498,7 +1519,7 @@ class Prettier::Parser < Ripper
1498
1519
  beging = find_scanner_event(:@lparen)
1499
1520
  ending = find_scanner_event(:@rparen)
1500
1521
 
1501
- if source[beging[:char_end]...ending[:char_start]].strip.end_with?(',')
1522
+ if source[beging[:ec]...ending[:sc]].strip.end_with?(',')
1502
1523
  contents[:comma] = true
1503
1524
  end
1504
1525
 
@@ -1506,9 +1527,9 @@ class Prettier::Parser < Ripper
1506
1527
  type: :mlhs_paren,
1507
1528
  body: [contents],
1508
1529
  start: beging[:start],
1509
- char_start: beging[:char_start],
1530
+ sc: beging[:sc],
1510
1531
  end: ending[:end],
1511
- char_end: ending[:char_end]
1532
+ ec: ending[:ec]
1512
1533
  }
1513
1534
  end
1514
1535
 
@@ -1519,18 +1540,15 @@ class Prettier::Parser < Ripper
1519
1540
  beging = find_scanner_event(:@kw, 'module')
1520
1541
  ending = find_scanner_event(:@kw, 'end')
1521
1542
 
1522
- bodystmt.bind(
1523
- find_next_statement_start(const[:char_end]),
1524
- ending[:char_start]
1525
- )
1543
+ bodystmt.bind(find_next_statement_start(const[:ec]), ending[:sc])
1526
1544
 
1527
1545
  {
1528
1546
  type: :module,
1529
1547
  body: [const, bodystmt],
1530
1548
  start: beging[:start],
1531
- char_start: beging[:char_start],
1549
+ sc: beging[:sc],
1532
1550
  end: ending[:end],
1533
- char_end: ending[:char_end]
1551
+ ec: ending[:ec]
1534
1552
  }
1535
1553
  end
1536
1554
 
@@ -1543,9 +1561,9 @@ class Prettier::Parser < Ripper
1543
1561
  type: :mrhs,
1544
1562
  body: [],
1545
1563
  start: lineno,
1546
- char_start: char_pos,
1564
+ sc: char_pos,
1547
1565
  end: lineno,
1548
- char_end: char_pos
1566
+ ec: char_pos
1549
1567
  }
1550
1568
  end
1551
1569
 
@@ -1555,11 +1573,7 @@ class Prettier::Parser < Ripper
1555
1573
  if mrhs[:body].empty?
1556
1574
  part.merge(type: :mrhs, body: [part])
1557
1575
  else
1558
- mrhs.merge!(
1559
- body: mrhs[:body] << part,
1560
- end: part[:end],
1561
- char_end: part[:char_end]
1562
- )
1576
+ mrhs.merge!(body: mrhs[:body] << part, end: part[:end], ec: part[:ec])
1563
1577
  end
1564
1578
  end
1565
1579
 
@@ -1574,9 +1588,9 @@ class Prettier::Parser < Ripper
1574
1588
  type: :mrhs_add_star,
1575
1589
  body: [mrhs, part],
1576
1590
  start: beging[:start],
1577
- char_start: beging[:char_start],
1591
+ sc: beging[:sc],
1578
1592
  end: ending[:end],
1579
- char_end: ending[:char_end]
1593
+ ec: ending[:ec]
1580
1594
  }
1581
1595
  end
1582
1596
 
@@ -1600,7 +1614,7 @@ class Prettier::Parser < Ripper
1600
1614
  type: :next,
1601
1615
  body: [args_add_block],
1602
1616
  end: args_add_block[:end],
1603
- char_end: args_add_block[:char_end]
1617
+ ec: args_add_block[:ec]
1604
1618
  )
1605
1619
  end
1606
1620
 
@@ -1613,7 +1627,7 @@ class Prettier::Parser < Ripper
1613
1627
  type: :opassign,
1614
1628
  body: [left, oper, right],
1615
1629
  end: right[:end],
1616
- char_end: right[:char_end]
1630
+ ec: right[:ec]
1617
1631
  )
1618
1632
  end
1619
1633
 
@@ -1628,12 +1642,12 @@ class Prettier::Parser < Ripper
1628
1642
  if flattened.any?
1629
1643
  {
1630
1644
  start: flattened[0][:start],
1631
- char_start: flattened[0][:char_start],
1645
+ sc: flattened[0][:sc],
1632
1646
  end: flattened[-1][:end],
1633
- char_end: flattened[-1][:char_end]
1647
+ ec: flattened[-1][:ec]
1634
1648
  }
1635
1649
  else
1636
- { start: lineno, char_start: char_pos, end: lineno, char_end: char_pos }
1650
+ { start: lineno, sc: char_pos, end: lineno, ec: char_pos }
1637
1651
  end
1638
1652
 
1639
1653
  location.merge!(type: :params, body: types)
@@ -1649,7 +1663,7 @@ class Prettier::Parser < Ripper
1649
1663
  type: :paren,
1650
1664
  body: [contents],
1651
1665
  end: ending[:end],
1652
- char_end: ending[:char_end]
1666
+ ec: ending[:ec]
1653
1667
  )
1654
1668
  end
1655
1669
 
@@ -1658,12 +1672,7 @@ class Prettier::Parser < Ripper
1658
1672
  # source string. We'll also attach on the __END__ content if there was
1659
1673
  # some found at the end of the source string.
1660
1674
  def on_program(stmts)
1661
- range = {
1662
- start: 1,
1663
- end: lines.length,
1664
- char_start: 0,
1665
- char_end: source.length
1666
- }
1675
+ range = { start: 1, end: lines.length, sc: 0, ec: source.length }
1667
1676
 
1668
1677
  stmts[:body] << @__end__ if @__end__
1669
1678
  stmts.bind(0, source.length)
@@ -1686,7 +1695,7 @@ class Prettier::Parser < Ripper
1686
1695
  qsymbols.merge!(
1687
1696
  body: qsymbols[:body] << tstring_content,
1688
1697
  end: tstring_content[:end],
1689
- char_end: tstring_content[:char_end]
1698
+ ec: tstring_content[:ec]
1690
1699
  )
1691
1700
  end
1692
1701
 
@@ -1705,7 +1714,7 @@ class Prettier::Parser < Ripper
1705
1714
  qwords.merge!(
1706
1715
  body: qwords[:body] << tstring_content,
1707
1716
  end: tstring_content[:end],
1708
- char_end: tstring_content[:char_end]
1717
+ ec: tstring_content[:ec]
1709
1718
  )
1710
1719
  end
1711
1720
 
@@ -1719,7 +1728,8 @@ class Prettier::Parser < Ripper
1719
1728
  # expression literal, like /foo/. It can be followed by any number of
1720
1729
  # regexp_add events, which we'll append onto an array body.
1721
1730
  def on_regexp_new
1722
- find_scanner_event(:@regexp_beg).merge!(type: :regexp, body: [])
1731
+ beging = find_scanner_event(:@regexp_beg)
1732
+ beging.merge!(type: :regexp, body: [], beging: beging[:body])
1723
1733
  end
1724
1734
 
1725
1735
  # regexp_add is a parser event that represents a piece of a regular
@@ -1730,7 +1740,7 @@ class Prettier::Parser < Ripper
1730
1740
  regexp.merge!(
1731
1741
  body: regexp[:body] << piece,
1732
1742
  end: regexp[:end],
1733
- char_end: regexp[:char_end]
1743
+ ec: regexp[:ec]
1734
1744
  )
1735
1745
  end
1736
1746
 
@@ -1743,7 +1753,7 @@ class Prettier::Parser < Ripper
1743
1753
  type: :regexp_literal,
1744
1754
  ending: ending[:body],
1745
1755
  end: ending[:end],
1746
- char_end: ending[:char_end]
1756
+ ec: ending[:ec]
1747
1757
  )
1748
1758
  end
1749
1759
 
@@ -1752,17 +1762,17 @@ class Prettier::Parser < Ripper
1752
1762
  # determine its ending. Therefore it relies on its parent bodystmt node to
1753
1763
  # report its ending to it.
1754
1764
  class Rescue < SimpleDelegator
1755
- def bind_end(char_end)
1756
- merge!(char_end: char_end)
1765
+ def bind_end(ec)
1766
+ merge!(ec: ec)
1757
1767
 
1758
1768
  stmts = self[:body][2]
1759
1769
  consequent = self[:body][3]
1760
1770
 
1761
1771
  if consequent
1762
- consequent.bind_end(char_end)
1763
- stmts.bind_end(consequent[:char_start])
1772
+ consequent.bind_end(ec)
1773
+ stmts.bind_end(consequent[:sc])
1764
1774
  else
1765
- stmts.bind_end(char_end)
1775
+ stmts.bind_end(ec)
1766
1776
  end
1767
1777
  end
1768
1778
  end
@@ -1775,14 +1785,14 @@ class Prettier::Parser < Ripper
1775
1785
  last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
1776
1786
  last_node = variable || last_exception || beging
1777
1787
 
1778
- stmts.bind(find_next_statement_start(last_node[:char_end]), char_pos)
1788
+ stmts.bind(find_next_statement_start(last_node[:ec]), char_pos)
1779
1789
 
1780
1790
  Rescue.new(
1781
1791
  beging.merge!(
1782
1792
  type: :rescue,
1783
1793
  body: [exceptions, variable, stmts, consequent],
1784
1794
  end: lineno,
1785
- char_end: char_pos
1795
+ ec: char_pos
1786
1796
  )
1787
1797
  )
1788
1798
  end
@@ -1797,9 +1807,9 @@ class Prettier::Parser < Ripper
1797
1807
  type: :rescue_mod,
1798
1808
  body: [statement, rescued],
1799
1809
  start: statement[:start],
1800
- char_start: statement[:char_start],
1810
+ sc: statement[:sc],
1801
1811
  end: rescued[:end],
1802
- char_end: rescued[:char_end]
1812
+ ec: rescued[:ec]
1803
1813
  }
1804
1814
  end
1805
1815
 
@@ -1815,7 +1825,7 @@ class Prettier::Parser < Ripper
1815
1825
  type: :rest_param,
1816
1826
  body: [ident],
1817
1827
  end: ident[:end],
1818
- char_end: ident[:char_end]
1828
+ ec: ident[:ec]
1819
1829
  )
1820
1830
  end
1821
1831
 
@@ -1833,7 +1843,7 @@ class Prettier::Parser < Ripper
1833
1843
  type: :return,
1834
1844
  body: [args_add_block],
1835
1845
  end: args_add_block[:end],
1836
- char_end: args_add_block[:char_end]
1846
+ ec: args_add_block[:ec]
1837
1847
  )
1838
1848
  end
1839
1849
 
@@ -1859,18 +1869,15 @@ class Prettier::Parser < Ripper
1859
1869
  beging = find_scanner_event(:@kw, 'class')
1860
1870
  ending = find_scanner_event(:@kw, 'end')
1861
1871
 
1862
- bodystmt.bind(
1863
- find_next_statement_start(target[:char_end]),
1864
- ending[:char_start]
1865
- )
1872
+ bodystmt.bind(find_next_statement_start(target[:ec]), ending[:sc])
1866
1873
 
1867
1874
  {
1868
1875
  type: :sclass,
1869
1876
  body: [target, bodystmt],
1870
1877
  start: beging[:start],
1871
- char_start: beging[:char_start],
1878
+ sc: beging[:sc],
1872
1879
  end: ending[:end],
1873
- char_end: ending[:char_end]
1880
+ ec: ending[:ec]
1874
1881
  }
1875
1882
  end
1876
1883
 
@@ -1882,23 +1889,23 @@ class Prettier::Parser < Ripper
1882
1889
  # propagate that onto void_stmt nodes inside the stmts in order to make sure
1883
1890
  # all comments get printed appropriately.
1884
1891
  class Stmts < SimpleDelegator
1885
- def bind(char_start, char_end)
1886
- merge!(char_start: char_start, char_end: char_end)
1892
+ def bind(sc, ec)
1893
+ merge!(sc: sc, ec: ec)
1887
1894
 
1888
1895
  if self[:body][0][:type] == :void_stmt
1889
- self[:body][0].merge!(char_start: char_start, char_end: char_start)
1896
+ self[:body][0].merge!(sc: sc, ec: sc)
1890
1897
  end
1891
1898
  end
1892
1899
 
1893
- def bind_end(char_end)
1894
- merge!(char_end: char_end)
1900
+ def bind_end(ec)
1901
+ merge!(ec: ec)
1895
1902
  end
1896
1903
 
1897
1904
  def <<(statement)
1898
1905
  if self[:body].any?
1899
- merge!(statement.slice(:end, :char_end))
1906
+ merge!(statement.slice(:end, :ec))
1900
1907
  else
1901
- merge!(statement.slice(:start, :end, :char_start, :char_end))
1908
+ merge!(statement.slice(:start, :end, :sc, :ec))
1902
1909
  end
1903
1910
 
1904
1911
  self[:body] << statement
@@ -1915,8 +1922,8 @@ class Prettier::Parser < Ripper
1915
1922
  body: [],
1916
1923
  start: lineno,
1917
1924
  end: lineno,
1918
- char_start: char_pos,
1919
- char_end: char_pos
1925
+ sc: char_pos,
1926
+ ec: char_pos
1920
1927
  )
1921
1928
  end
1922
1929
 
@@ -1939,9 +1946,9 @@ class Prettier::Parser < Ripper
1939
1946
  type: :string_concat,
1940
1947
  body: [left, right],
1941
1948
  start: left[:start],
1942
- char_start: left[:char_start],
1949
+ sc: left[:sc],
1943
1950
  end: right[:end],
1944
- char_end: right[:char_end]
1951
+ ec: right[:ec]
1945
1952
  }
1946
1953
  end
1947
1954
 
@@ -1956,8 +1963,8 @@ class Prettier::Parser < Ripper
1956
1963
  body: [],
1957
1964
  start: lineno,
1958
1965
  end: lineno,
1959
- char_start: char_pos,
1960
- char_end: char_pos
1966
+ sc: char_pos,
1967
+ ec: char_pos
1961
1968
  }
1962
1969
  end
1963
1970
 
@@ -1969,7 +1976,7 @@ class Prettier::Parser < Ripper
1969
1976
  string.merge!(
1970
1977
  body: string[:body] << piece,
1971
1978
  end: piece[:end],
1972
- char_end: piece[:char_end]
1979
+ ec: piece[:ec]
1973
1980
  )
1974
1981
  end
1975
1982
 
@@ -1983,7 +1990,7 @@ class Prettier::Parser < Ripper
1983
1990
  type: :string_dvar,
1984
1991
  body: [var_ref],
1985
1992
  end: var_ref[:end],
1986
- char_end: var_ref[:char_end]
1993
+ ec: var_ref[:ec]
1987
1994
  )
1988
1995
  end
1989
1996
 
@@ -1995,15 +2002,15 @@ class Prettier::Parser < Ripper
1995
2002
  beging = find_scanner_event(:@embexpr_beg)
1996
2003
  ending = find_scanner_event(:@embexpr_end)
1997
2004
 
1998
- stmts.bind(beging[:char_end], ending[:char_start])
2005
+ stmts.bind(beging[:ec], ending[:sc])
1999
2006
 
2000
2007
  {
2001
2008
  type: :string_embexpr,
2002
2009
  body: [stmts],
2003
2010
  start: beging[:start],
2004
- char_start: beging[:char_start],
2011
+ sc: beging[:sc],
2005
2012
  end: ending[:end],
2006
- char_end: ending[:char_end]
2013
+ ec: ending[:ec]
2007
2014
  }
2008
2015
  end
2009
2016
 
@@ -2023,9 +2030,9 @@ class Prettier::Parser < Ripper
2023
2030
  body: string[:body],
2024
2031
  quote: beging[:body],
2025
2032
  start: beging[:start],
2026
- char_start: beging[:char_start],
2033
+ sc: beging[:sc],
2027
2034
  end: ending[:end],
2028
- char_end: ending[:char_end]
2035
+ ec: ending[:ec]
2029
2036
  }
2030
2037
  end
2031
2038
  end
@@ -2039,7 +2046,7 @@ class Prettier::Parser < Ripper
2039
2046
  type: :super,
2040
2047
  body: [contents],
2041
2048
  end: contents[:end],
2042
- char_end: contents[:char_end]
2049
+ ec: contents[:ec]
2043
2050
  )
2044
2051
  end
2045
2052
 
@@ -2070,7 +2077,7 @@ class Prettier::Parser < Ripper
2070
2077
  contents.merge(type: :symbol_literal, body: [contents])
2071
2078
  else
2072
2079
  beging = find_scanner_event(:@symbeg)
2073
- contents.merge!(type: :symbol_literal, char_start: beging[:char_start])
2080
+ contents.merge!(type: :symbol_literal, sc: beging[:sc])
2074
2081
  end
2075
2082
  end
2076
2083
 
@@ -2090,7 +2097,7 @@ class Prettier::Parser < Ripper
2090
2097
  symbols.merge!(
2091
2098
  body: symbols[:body] << word_add,
2092
2099
  end: word_add[:end],
2093
- char_end: word_add[:char_end]
2100
+ ec: word_add[:ec]
2094
2101
  )
2095
2102
  end
2096
2103
 
@@ -2101,8 +2108,7 @@ class Prettier::Parser < Ripper
2101
2108
  def find_colon2_before(const)
2102
2109
  index =
2103
2110
  scanner_events.rindex do |event|
2104
- event[:type] == :@op && event[:body] == '::' &&
2105
- event[:char_start] < const[:char_start]
2111
+ event[:type] == :@op && event[:body] == '::' && event[:sc] < const[:sc]
2106
2112
  end
2107
2113
 
2108
2114
  scanner_events[index]
@@ -2120,7 +2126,7 @@ class Prettier::Parser < Ripper
2120
2126
  type: :top_const_field,
2121
2127
  body: [const],
2122
2128
  start: beging[:start],
2123
- char_start: beging[:char_start]
2129
+ sc: beging[:sc]
2124
2130
  )
2125
2131
  end
2126
2132
 
@@ -2136,7 +2142,7 @@ class Prettier::Parser < Ripper
2136
2142
  type: :top_const_ref,
2137
2143
  body: [const],
2138
2144
  start: beging[:start],
2139
- char_start: beging[:char_start]
2145
+ sc: beging[:sc]
2140
2146
  )
2141
2147
  end
2142
2148
 
@@ -2148,7 +2154,7 @@ class Prettier::Parser < Ripper
2148
2154
  if oper == :not
2149
2155
  node = find_scanner_event(:@kw, 'not')
2150
2156
 
2151
- paren = source[node[:char_end]...value[:char_start]].include?('(')
2157
+ paren = source[node[:ec]...value[:sc]].include?('(')
2152
2158
  ending = paren ? find_scanner_event(:@rparen) : value
2153
2159
 
2154
2160
  node.merge!(
@@ -2156,7 +2162,7 @@ class Prettier::Parser < Ripper
2156
2162
  oper: oper,
2157
2163
  body: [value],
2158
2164
  end: ending[:end],
2159
- char_end: ending[:char_end],
2165
+ ec: ending[:ec],
2160
2166
  paren: paren
2161
2167
  )
2162
2168
  else
@@ -2176,7 +2182,7 @@ class Prettier::Parser < Ripper
2176
2182
  oper: oper[0],
2177
2183
  body: [value],
2178
2184
  end: value[:end],
2179
- char_end: value[:char_end]
2185
+ ec: value[:ec]
2180
2186
  )
2181
2187
  end
2182
2188
  end
@@ -2192,7 +2198,7 @@ class Prettier::Parser < Ripper
2192
2198
  type: :undef,
2193
2199
  body: symbol_literals,
2194
2200
  end: last[:end],
2195
- char_end: last[:char_end]
2201
+ ec: last[:ec]
2196
2202
  )
2197
2203
  end
2198
2204
 
@@ -2204,15 +2210,15 @@ class Prettier::Parser < Ripper
2204
2210
  beging = find_scanner_event(:@kw, 'unless')
2205
2211
  ending = consequent || find_scanner_event(:@kw, 'end')
2206
2212
 
2207
- stmts.bind(predicate[:char_end], ending[:char_start])
2213
+ stmts.bind(predicate[:ec], ending[:sc])
2208
2214
 
2209
2215
  {
2210
2216
  type: :unless,
2211
2217
  body: [predicate, stmts, consequent],
2212
2218
  start: beging[:start],
2213
- char_start: beging[:char_start],
2219
+ sc: beging[:sc],
2214
2220
  end: ending[:end],
2215
- char_end: ending[:char_end]
2221
+ ec: ending[:ec]
2216
2222
  }
2217
2223
  end
2218
2224
 
@@ -2226,9 +2232,9 @@ class Prettier::Parser < Ripper
2226
2232
  type: :unless_mod,
2227
2233
  body: [predicate, statement],
2228
2234
  start: statement[:start],
2229
- char_start: statement[:char_start],
2235
+ sc: statement[:sc],
2230
2236
  end: predicate[:end],
2231
- char_end: predicate[:char_end]
2237
+ ec: predicate[:ec]
2232
2238
  }
2233
2239
  end
2234
2240
 
@@ -2239,15 +2245,22 @@ class Prettier::Parser < Ripper
2239
2245
  beging = find_scanner_event(:@kw, 'until')
2240
2246
  ending = find_scanner_event(:@kw, 'end')
2241
2247
 
2242
- stmts.bind(predicate[:char_end], ending[:char_start])
2248
+ # Consume the do keyword if it exists so that it doesn't get confused for
2249
+ # some other block
2250
+ do_event = find_scanner_event(:@kw, 'do', consume: false)
2251
+ if do_event && do_event[:sc] > predicate[:ec] && do_event[:ec] < ending[:sc]
2252
+ scanner_events.delete(do_event)
2253
+ end
2254
+
2255
+ stmts.bind(predicate[:ec], ending[:sc])
2243
2256
 
2244
2257
  {
2245
2258
  type: :until,
2246
2259
  body: [predicate, stmts],
2247
2260
  start: beging[:start],
2248
- char_start: beging[:char_start],
2261
+ sc: beging[:sc],
2249
2262
  end: ending[:end],
2250
- char_end: ending[:char_end]
2263
+ ec: ending[:ec]
2251
2264
  }
2252
2265
  end
2253
2266
 
@@ -2261,9 +2274,9 @@ class Prettier::Parser < Ripper
2261
2274
  type: :until_mod,
2262
2275
  body: [predicate, statement],
2263
2276
  start: statement[:start],
2264
- char_start: statement[:char_start],
2277
+ sc: statement[:sc],
2265
2278
  end: predicate[:end],
2266
- char_end: predicate[:char_end]
2279
+ ec: predicate[:ec]
2267
2280
  }
2268
2281
  end
2269
2282
 
@@ -2274,16 +2287,16 @@ class Prettier::Parser < Ripper
2274
2287
  def on_var_alias(left, right)
2275
2288
  beging = find_scanner_event(:@kw, 'alias')
2276
2289
 
2277
- paren = source[beging[:char_end]...left[:char_start]].include?('(')
2290
+ paren = source[beging[:ec]...left[:sc]].include?('(')
2278
2291
  ending = paren ? find_scanner_event(:@rparen) : right
2279
2292
 
2280
2293
  {
2281
2294
  type: :var_alias,
2282
2295
  body: [left, right],
2283
2296
  start: beging[:start],
2284
- char_start: beging[:char_start],
2297
+ sc: beging[:sc],
2285
2298
  end: ending[:end],
2286
- char_end: ending[:char_end]
2299
+ ec: ending[:ec]
2287
2300
  }
2288
2301
  end
2289
2302
 
@@ -2305,7 +2318,7 @@ class Prettier::Parser < Ripper
2305
2318
  else
2306
2319
  # You can hit this pattern if you're assigning to a splat using pattern
2307
2320
  # matching syntax in Ruby 2.7+
2308
- { type: :var_field, body: [] }
2321
+ { type: :var_field, body: nil }
2309
2322
  end
2310
2323
  end
2311
2324
 
@@ -2335,13 +2348,7 @@ class Prettier::Parser < Ripper
2335
2348
  # block of code. It often will have comments attached to it, so it requires
2336
2349
  # some special handling.
2337
2350
  def on_void_stmt
2338
- {
2339
- type: :void_stmt,
2340
- start: lineno,
2341
- end: lineno,
2342
- char_start: char_pos,
2343
- char_end: char_pos
2344
- }
2351
+ { type: :void_stmt, start: lineno, end: lineno, sc: char_pos, ec: char_pos }
2345
2352
  end
2346
2353
 
2347
2354
  # when is a parser event that represents another clause in a case chain.
@@ -2352,15 +2359,15 @@ class Prettier::Parser < Ripper
2352
2359
  beging = find_scanner_event(:@kw, 'when')
2353
2360
  ending = consequent || find_scanner_event(:@kw, 'end')
2354
2361
 
2355
- stmts.bind(predicate[:char_end], ending[:char_start])
2362
+ stmts.bind(predicate[:ec], ending[:sc])
2356
2363
 
2357
2364
  {
2358
2365
  type: :when,
2359
2366
  body: [predicate, stmts, consequent],
2360
2367
  start: beging[:start],
2361
- char_start: beging[:char_start],
2368
+ sc: beging[:sc],
2362
2369
  end: ending[:end],
2363
- char_end: ending[:char_end]
2370
+ ec: ending[:ec]
2364
2371
  }
2365
2372
  end
2366
2373
 
@@ -2371,15 +2378,22 @@ class Prettier::Parser < Ripper
2371
2378
  beging = find_scanner_event(:@kw, 'while')
2372
2379
  ending = find_scanner_event(:@kw, 'end')
2373
2380
 
2374
- stmts.bind(predicate[:char_end], ending[:char_start])
2381
+ # Consume the do keyword if it exists so that it doesn't get confused for
2382
+ # some other block
2383
+ do_event = find_scanner_event(:@kw, 'do', consume: false)
2384
+ if do_event && do_event[:sc] > predicate[:ec] && do_event[:ec] < ending[:sc]
2385
+ scanner_events.delete(do_event)
2386
+ end
2387
+
2388
+ stmts.bind(predicate[:ec], ending[:sc])
2375
2389
 
2376
2390
  {
2377
2391
  type: :while,
2378
2392
  body: [predicate, stmts],
2379
2393
  start: beging[:start],
2380
- char_start: beging[:char_start],
2394
+ sc: beging[:sc],
2381
2395
  end: ending[:end],
2382
- char_end: ending[:char_end]
2396
+ ec: ending[:ec]
2383
2397
  }
2384
2398
  end
2385
2399
 
@@ -2393,9 +2407,9 @@ class Prettier::Parser < Ripper
2393
2407
  type: :while_mod,
2394
2408
  body: [predicate, statement],
2395
2409
  start: statement[:start],
2396
- char_start: statement[:char_start],
2410
+ sc: statement[:sc],
2397
2411
  end: predicate[:end],
2398
- char_end: predicate[:char_end]
2412
+ ec: predicate[:ec]
2399
2413
  }
2400
2414
  end
2401
2415
 
@@ -2425,11 +2439,7 @@ class Prettier::Parser < Ripper
2425
2439
  # location information from the first piece.
2426
2440
  piece.merge(type: :word, body: [piece])
2427
2441
  else
2428
- word.merge!(
2429
- body: word[:body] << piece,
2430
- end: piece[:end],
2431
- char_end: piece[:char_end]
2432
- )
2442
+ word.merge!(body: word[:body] << piece, end: piece[:end], ec: piece[:ec])
2433
2443
  end
2434
2444
  end
2435
2445
 
@@ -2449,7 +2459,7 @@ class Prettier::Parser < Ripper
2449
2459
  words.merge!(
2450
2460
  body: words[:body] << word_add,
2451
2461
  end: word_add[:end],
2452
- char_end: word_add[:char_end]
2462
+ ec: word_add[:ec]
2453
2463
  )
2454
2464
  end
2455
2465
 
@@ -2483,7 +2493,7 @@ class Prettier::Parser < Ripper
2483
2493
  xstring.merge!(
2484
2494
  body: xstring[:body] << piece,
2485
2495
  end: piece[:end],
2486
- char_end: piece[:char_end]
2496
+ ec: piece[:ec]
2487
2497
  )
2488
2498
  end
2489
2499
 
@@ -2508,11 +2518,7 @@ class Prettier::Parser < Ripper
2508
2518
  heredoc.merge!(body: xstring[:body])
2509
2519
  else
2510
2520
  ending = find_scanner_event(:@tstring_end)
2511
- xstring.merge!(
2512
- type: :xstring_literal,
2513
- end: ending[:end],
2514
- char_end: ending[:char_end]
2515
- )
2521
+ xstring.merge!(type: :xstring_literal, end: ending[:end], ec: ending[:ec])
2516
2522
  end
2517
2523
  end
2518
2524
 
@@ -2524,7 +2530,7 @@ class Prettier::Parser < Ripper
2524
2530
  type: :yield,
2525
2531
  body: [args_add_block],
2526
2532
  end: args_add_block[:end],
2527
- char_end: args_add_block[:char_end]
2533
+ ec: args_add_block[:ec]
2528
2534
  )
2529
2535
  end
2530
2536