ruby_parser 3.13.0 → 3.13.1

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 (33) hide show
  1. checksums.yaml +4 -4
  2. checksums.yaml.gz.sig +0 -0
  3. data.tar.gz.sig +0 -0
  4. data/History.rdoc +32 -0
  5. data/Rakefile +2 -3
  6. data/bin/ruby_parse_extract_error +10 -32
  7. data/lib/rp_extensions.rb +1 -1
  8. data/lib/ruby20_parser.rb +2427 -2432
  9. data/lib/ruby20_parser.y +32 -29
  10. data/lib/ruby21_parser.rb +2101 -2109
  11. data/lib/ruby21_parser.y +32 -29
  12. data/lib/ruby22_parser.rb +2080 -2095
  13. data/lib/ruby22_parser.y +32 -29
  14. data/lib/ruby23_parser.rb +2337 -2332
  15. data/lib/ruby23_parser.y +32 -29
  16. data/lib/ruby24_parser.rb +2347 -2335
  17. data/lib/ruby24_parser.y +32 -23
  18. data/lib/ruby25_parser.rb +2347 -2334
  19. data/lib/ruby25_parser.y +32 -23
  20. data/lib/ruby26_parser.rb +2351 -2338
  21. data/lib/ruby26_parser.y +32 -23
  22. data/lib/ruby_lexer.rb +253 -161
  23. data/lib/ruby_lexer.rex +25 -25
  24. data/lib/ruby_lexer.rex.rb +68 -26
  25. data/lib/ruby_parser.rb +3 -1
  26. data/lib/ruby_parser.yy +34 -23
  27. data/lib/ruby_parser_extras.rb +64 -43
  28. data/test/test_ruby_lexer.rb +1013 -952
  29. data/test/test_ruby_parser.rb +161 -24
  30. data/tools/munge.rb +2 -1
  31. data/tools/ripper.rb +6 -1
  32. metadata +2 -2
  33. metadata.gz.sig +0 -0
data/lib/ruby_parser_extras.rb CHANGED
@@ -7,7 +7,7 @@ require "rp_extensions"
7
7
  require "rp_stringscanner"
8
8
 
9
9
  module RubyParserStuff
10
- VERSION = "3.13.0"
10
+ VERSION = "3.13.1"
11
11
 
12
12
  attr_accessor :lexer, :in_def, :in_single, :file
13
13
  attr_accessor :in_kwarg
@@ -698,6 +698,22 @@ module RubyParserStuff
698
698
  result
699
699
  end
700
700
 
701
+ def new_const_op_asgn val
702
+ lhs, asgn_op, rhs = val[0], val[1].to_sym, val[2]
703
+
704
+ result = case asgn_op
705
+ when :"||" then
706
+ s(:op_asgn_or, lhs, rhs)
707
+ when :"&&" then
708
+ s(:op_asgn_and, lhs, rhs)
709
+ else
710
+ s(:op_asgn, lhs, asgn_op, rhs)
711
+ end
712
+
713
+ result.line = lhs.line
714
+ result
715
+ end
716
+
701
717
  def new_op_asgn2 val
702
718
  recv, call_op, meth, op, arg = val
703
719
  meth = :"#{meth}="
@@ -804,6 +820,7 @@ module RubyParserStuff
804
820
 
805
821
  def new_string val
806
822
  str = val[0]
823
+ str.force_encoding("UTF-8")
807
824
  str.force_encoding("ASCII-8BIT") unless str.valid_encoding?
808
825
  result = s(:str, str)
809
826
  self.lexer.fixup_lineno str.count("\n")
@@ -1168,6 +1185,8 @@ module RubyParserStuff
1168
1185
  end
1169
1186
 
1170
1187
  class Keyword
1188
+ include RubyLexer::State::Values
1189
+
1171
1190
  class KWtable
1172
1191
  attr_accessor :name, :state, :id0, :id1
1173
1192
  def initialize(name, id=[], state=nil)
@@ -1196,48 +1215,50 @@ module RubyParserStuff
1196
1215
  # :expr_value = :expr_beg -- work to remove. Need multi-state support.
1197
1216
 
1198
1217
  wordlist = [
1199
- ["alias", [:kALIAS, :kALIAS ], :expr_fname ],
1200
- ["and", [:kAND, :kAND ], :expr_beg ],
1201
- ["begin", [:kBEGIN, :kBEGIN ], :expr_beg ],
1202
- ["break", [:kBREAK, :kBREAK ], :expr_mid ],
1203
- ["case", [:kCASE, :kCASE ], :expr_beg ],
1204
- ["class", [:kCLASS, :kCLASS ], :expr_class ],
1205
- ["def", [:kDEF, :kDEF ], :expr_fname ],
1206
- ["defined?", [:kDEFINED, :kDEFINED ], :expr_arg ],
1207
- ["do", [:kDO, :kDO ], :expr_beg ],
1208
- ["else", [:kELSE, :kELSE ], :expr_beg ],
1209
- ["elsif", [:kELSIF, :kELSIF ], :expr_beg ],
1210
- ["end", [:kEND, :kEND ], :expr_end ],
1211
- ["ensure", [:kENSURE, :kENSURE ], :expr_beg ],
1212
- ["false", [:kFALSE, :kFALSE ], :expr_end ],
1213
- ["for", [:kFOR, :kFOR ], :expr_beg ],
1214
- ["if", [:kIF, :kIF_MOD ], :expr_beg ],
1215
- ["in", [:kIN, :kIN ], :expr_beg ],
1216
- ["module", [:kMODULE, :kMODULE ], :expr_beg ],
1217
- ["next", [:kNEXT, :kNEXT ], :expr_mid ],
1218
- ["nil", [:kNIL, :kNIL ], :expr_end ],
1219
- ["not", [:kNOT, :kNOT ], :expr_arg ],
1220
- ["or", [:kOR, :kOR ], :expr_beg ],
1221
- ["redo", [:kREDO, :kREDO ], :expr_end ],
1222
- ["rescue", [:kRESCUE, :kRESCUE_MOD ], :expr_mid ],
1223
- ["retry", [:kRETRY, :kRETRY ], :expr_end ],
1224
- ["return", [:kRETURN, :kRETURN ], :expr_mid ],
1225
- ["self", [:kSELF, :kSELF ], :expr_end ],
1226
- ["super", [:kSUPER, :kSUPER ], :expr_arg ],
1227
- ["then", [:kTHEN, :kTHEN ], :expr_beg ],
1228
- ["true", [:kTRUE, :kTRUE ], :expr_end ],
1229
- ["undef", [:kUNDEF, :kUNDEF ], :expr_fname ],
1230
- ["unless", [:kUNLESS, :kUNLESS_MOD ], :expr_beg ],
1231
- ["until", [:kUNTIL, :kUNTIL_MOD ], :expr_beg ],
1232
- ["when", [:kWHEN, :kWHEN ], :expr_beg ],
1233
- ["while", [:kWHILE, :kWHILE_MOD ], :expr_beg ],
1234
- ["yield", [:kYIELD, :kYIELD ], :expr_arg ],
1235
- ["BEGIN", [:klBEGIN, :klBEGIN ], :expr_end ],
1236
- ["END", [:klEND, :klEND ], :expr_end ],
1237
- ["__FILE__", [:k__FILE__, :k__FILE__ ], :expr_end ],
1238
- ["__LINE__", [:k__LINE__, :k__LINE__ ], :expr_end ],
1239
- ["__ENCODING__", [:k__ENCODING__, :k__ENCODING__], :expr_end],
1240
- ].map { |args| KWtable.new(*args) }
1218
+ ["alias", [:kALIAS, :kALIAS ], EXPR_FNAME|EXPR_FITEM],
1219
+ ["and", [:kAND, :kAND ], EXPR_BEG ],
1220
+ ["begin", [:kBEGIN, :kBEGIN ], EXPR_BEG ],
1221
+ ["break", [:kBREAK, :kBREAK ], EXPR_MID ],
1222
+ ["case", [:kCASE, :kCASE ], EXPR_BEG ],
1223
+ ["class", [:kCLASS, :kCLASS ], EXPR_CLASS ],
1224
+ ["def", [:kDEF, :kDEF ], EXPR_FNAME ],
1225
+ ["defined?", [:kDEFINED, :kDEFINED ], EXPR_ARG ],
1226
+ ["do", [:kDO, :kDO ], EXPR_BEG ],
1227
+ ["else", [:kELSE, :kELSE ], EXPR_BEG ],
1228
+ ["elsif", [:kELSIF, :kELSIF ], EXPR_BEG ],
1229
+ ["end", [:kEND, :kEND ], EXPR_END ],
1230
+ ["ensure", [:kENSURE, :kENSURE ], EXPR_BEG ],
1231
+ ["false", [:kFALSE, :kFALSE ], EXPR_END ],
1232
+ ["for", [:kFOR, :kFOR ], EXPR_BEG ],
1233
+ ["if", [:kIF, :kIF_MOD ], EXPR_BEG ],
1234
+ ["in", [:kIN, :kIN ], EXPR_BEG ],
1235
+ ["module", [:kMODULE, :kMODULE ], EXPR_BEG ],
1236
+ ["next", [:kNEXT, :kNEXT ], EXPR_MID ],
1237
+ ["nil", [:kNIL, :kNIL ], EXPR_END ],
1238
+ ["not", [:kNOT, :kNOT ], EXPR_ARG ],
1239
+ ["or", [:kOR, :kOR ], EXPR_BEG ],
1240
+ ["redo", [:kREDO, :kREDO ], EXPR_END ],
1241
+ ["rescue", [:kRESCUE, :kRESCUE_MOD ], EXPR_MID ],
1242
+ ["retry", [:kRETRY, :kRETRY ], EXPR_END ],
1243
+ ["return", [:kRETURN, :kRETURN ], EXPR_MID ],
1244
+ ["self", [:kSELF, :kSELF ], EXPR_END ],
1245
+ ["super", [:kSUPER, :kSUPER ], EXPR_ARG ],
1246
+ ["then", [:kTHEN, :kTHEN ], EXPR_BEG ],
1247
+ ["true", [:kTRUE, :kTRUE ], EXPR_END ],
1248
+ ["undef", [:kUNDEF, :kUNDEF ], EXPR_FNAME|EXPR_FITEM],
1249
+ ["unless", [:kUNLESS, :kUNLESS_MOD ], EXPR_BEG ],
1250
+ ["until", [:kUNTIL, :kUNTIL_MOD ], EXPR_BEG ],
1251
+ ["when", [:kWHEN, :kWHEN ], EXPR_BEG ],
1252
+ ["while", [:kWHILE, :kWHILE_MOD ], EXPR_BEG ],
1253
+ ["yield", [:kYIELD, :kYIELD ], EXPR_ARG ],
1254
+ ["BEGIN", [:klBEGIN, :klBEGIN ], EXPR_END ],
1255
+ ["END", [:klEND, :klEND ], EXPR_END ],
1256
+ ["__FILE__", [:k__FILE__, :k__FILE__ ], EXPR_END ],
1257
+ ["__LINE__", [:k__LINE__, :k__LINE__ ], EXPR_END ],
1258
+ ["__ENCODING__", [:k__ENCODING__, :k__ENCODING__], EXPR_END],
1259
+ ].map { |args|
1260
+ KWtable.new(*args)
1261
+ }
1241
1262
 
1242
1263
  # :startdoc:
1243
1264
 
data/test/test_ruby_lexer.rb CHANGED
@@ -1,17 +1,20 @@
1
1
  # encoding: US-ASCII
2
+ # TODO: work this out
2
3
 
3
4
  require "minitest/autorun"
4
5
  require "ruby_lexer"
5
6
  require "ruby_parser"
6
7
 
7
8
  class TestRubyLexer < Minitest::Test
9
+ include RubyLexer::State::Values
10
+
8
11
  attr_accessor :processor, :lex, :parser_class, :lex_state
9
12
 
10
13
  alias :lexer :lex # lets me copy/paste code from parser
11
14
  alias :lexer= :lex=
12
15
 
13
16
  def setup
14
- self.lex_state = :expr_beg
17
+ self.lex_state = EXPR_BEG
15
18
  setup_lexer_class RubyParser.latest.class
16
19
  end
17
20
 
@@ -59,11 +62,11 @@ class TestRubyLexer < Minitest::Test
59
62
  end
60
63
  end
61
64
 
62
- def assert_lex_fname name, type, end_state = :expr_arg # TODO: swap name/type
65
+ def assert_lex_fname name, type, end_state = EXPR_ARG # TODO: swap name/type
63
66
  assert_lex3("def #{name} ",
64
67
  nil,
65
68
 
66
- :kDEF, "def", :expr_fname,
69
+ :kDEF, "def", EXPR_FNAME,
67
70
  type, name, end_state)
68
71
  end
69
72
 
@@ -102,8 +105,8 @@ class TestRubyLexer < Minitest::Test
102
105
  end
103
106
 
104
107
  def assert_read_escape expected, input
105
- @lex.ss.string = input
106
- assert_equal expected, @lex.read_escape, input
108
+ @lex.ss.string = input.dup
109
+ assert_equal expected, @lex.read_escape.b, input
107
110
  end
108
111
 
109
112
  def assert_read_escape_bad input # TODO: rename refute_read_escape
@@ -132,15 +135,15 @@ class TestRubyLexer < Minitest::Test
132
135
  lexer.cmdarg.push false
133
136
 
134
137
  lexer.lex_strterm = nil
135
- lexer.lex_state = :expr_beg
138
+ lexer.lex_state = EXPR_BEG
136
139
 
137
140
  yield
138
141
 
139
- lexer.lex_state = :expr_endarg
140
- assert_next_lexeme :tSTRING_DEND, "}", :expr_endarg, 0
142
+ lexer.lex_state = EXPR_ENDARG
143
+ assert_next_lexeme :tSTRING_DEND, "}", EXPR_ENDARG, 0
141
144
 
142
145
  lexer.lex_strterm = lex_strterm
143
- lexer.lex_state = :expr_beg
146
+ lexer.lex_state = EXPR_BEG
144
147
  lexer.string_nest = string_nest
145
148
  lexer.brace_nest = brace_nest
146
149
 
@@ -158,7 +161,7 @@ class TestRubyLexer < Minitest::Test
158
161
 
159
162
  def test_unicode_ident
160
163
  s = "@\u1088\u1077\u1093\u1072"
161
- assert_lex3(s.dup, nil, :tIVAR, s.dup, :expr_end)
164
+ assert_lex3(s.dup, nil, :tIVAR, s.dup, EXPR_END)
162
165
  end
163
166
 
164
167
  def test_read_escape
@@ -217,9 +220,9 @@ class TestRubyLexer < Minitest::Test
217
220
  def test_yylex_ambiguous_uminus
218
221
  assert_lex3("m -3",
219
222
  nil,
220
- :tIDENTIFIER, "m", :expr_cmdarg,
221
- :tUMINUS_NUM, "-", :expr_beg,
222
- :tINTEGER, 3, :expr_end)
223
+ :tIDENTIFIER, "m", EXPR_CMDARG,
224
+ :tUMINUS_NUM, "-", EXPR_BEG,
225
+ :tINTEGER, 3, EXPR_NUM)
223
226
 
224
227
  # TODO: verify warning
225
228
  end
@@ -227,36 +230,36 @@ class TestRubyLexer < Minitest::Test
227
230
  def test_yylex_ambiguous_uplus
228
231
  assert_lex3("m +3",
229
232
  nil,
230
- :tIDENTIFIER, "m", :expr_cmdarg,
231
- :tINTEGER, 3, :expr_end)
233
+ :tIDENTIFIER, "m", EXPR_CMDARG,
234
+ :tINTEGER, 3, EXPR_NUM)
232
235
 
233
236
  # TODO: verify warning
234
237
  end
235
238
 
236
239
  def test_yylex_and
237
- assert_lex3("&", nil, :tAMPER, "&", :expr_beg)
240
+ assert_lex3("&", nil, :tAMPER, "&", EXPR_BEG)
238
241
  end
239
242
 
240
243
  def test_yylex_and2
241
- assert_lex3("&&", nil, :tANDOP, "&&", :expr_beg)
244
+ assert_lex3("&&", nil, :tANDOP, "&&", EXPR_BEG)
242
245
  end
243
246
 
244
247
  def test_yylex_and2_equals
245
- assert_lex3("&&=", nil, :tOP_ASGN, "&&", :expr_beg)
248
+ assert_lex3("&&=", nil, :tOP_ASGN, "&&", EXPR_BEG)
246
249
  end
247
250
 
248
251
  def test_yylex_and_dot
249
252
  setup_lexer_class RubyParser::V23
250
253
 
251
- assert_lex3("&.", nil, :tLONELY, "&.", :expr_dot)
254
+ assert_lex3("&.", nil, :tLONELY, "&.", EXPR_DOT)
252
255
  end
253
256
 
254
257
  def test_yylex_and_dot_call
255
258
  setup_lexer_class RubyParser::V23
256
259
 
257
260
  assert_lex3("x&.y", nil,
258
- :tIDENTIFIER, "x", :expr_cmdarg,
259
- :tLONELY, "&.", :expr_dot,
261
+ :tIDENTIFIER, "x", EXPR_CMDARG,
262
+ :tLONELY, "&.", EXPR_DOT,
260
263
  :tIDENTIFIER, "y")
261
264
  end
262
265
 
@@ -264,32 +267,32 @@ class TestRubyLexer < Minitest::Test
264
267
  setup_lexer_class Ruby23Parser
265
268
 
266
269
  assert_lex3("x\n&.y", nil,
267
- :tIDENTIFIER, "x", :expr_cmdarg,
268
- :tLONELY, "&.", :expr_dot,
270
+ :tIDENTIFIER, "x", EXPR_CMDARG,
271
+ :tLONELY, "&.", EXPR_DOT,
269
272
  :tIDENTIFIER, "y")
270
273
  end
271
274
 
272
275
  def test_yylex_and_arg
273
- self.lex_state = :expr_arg
276
+ self.lex_state = EXPR_ARG
274
277
 
275
278
  assert_lex3(" &y",
276
279
  nil,
277
- :tAMPER, "&", :expr_beg,
278
- :tIDENTIFIER, "y", :expr_arg)
280
+ :tAMPER, "&", EXPR_BEG,
281
+ :tIDENTIFIER, "y", EXPR_ARG)
279
282
  end
280
283
 
281
284
  def test_yylex_and_equals
282
- assert_lex3("&=", nil, :tOP_ASGN, "&", :expr_beg)
285
+ assert_lex3("&=", nil, :tOP_ASGN, "&", EXPR_BEG)
283
286
  end
284
287
 
285
288
  def test_yylex_and_expr
286
- self.lex_state = :expr_arg
289
+ self.lex_state = EXPR_ARG
287
290
 
288
291
  assert_lex3("x & y",
289
292
  nil,
290
- :tIDENTIFIER, "x", :expr_cmdarg,
291
- :tAMPER2, "&", :expr_beg,
292
- :tIDENTIFIER, "y", :expr_arg)
293
+ :tIDENTIFIER, "x", EXPR_CMDARG,
294
+ :tAMPER2, "&", EXPR_BEG,
295
+ :tIDENTIFIER, "y", EXPR_ARG)
293
296
  end
294
297
 
295
298
  def test_yylex_and_meth
@@ -297,7 +300,7 @@ class TestRubyLexer < Minitest::Test
297
300
  end
298
301
 
299
302
  def test_yylex_assoc
300
- assert_lex3("=>", nil, :tASSOC, "=>", :expr_beg)
303
+ assert_lex3 "=>", nil, :tASSOC, "=>", EXPR_BEG
301
304
  end
302
305
 
303
306
  def test_yylex_label__20
@@ -305,8 +308,8 @@ class TestRubyLexer < Minitest::Test
305
308
 
306
309
  assert_lex3("{a:",
307
310
  nil,
308
- :tLBRACE, "{", :expr_beg,
309
- :tLABEL, "a", :expr_labeled)
311
+ :tLBRACE, "{", EXPR_PAR,
312
+ :tLABEL, "a", EXPR_LAB)
310
313
  end
311
314
 
312
315
  def test_yylex_label_in_params__20
@@ -314,9 +317,9 @@ class TestRubyLexer < Minitest::Test
314
317
 
315
318
  assert_lex3("foo(a:",
316
319
  nil,
317
- :tIDENTIFIER, "foo", :expr_cmdarg,
318
- :tLPAREN2, "(", :expr_beg,
319
- :tLABEL, "a", :expr_labeled)
320
+ :tIDENTIFIER, "foo", EXPR_CMDARG,
321
+ :tLPAREN2, "(", EXPR_PAR,
322
+ :tLABEL, "a", EXPR_LAB)
320
323
  end
321
324
 
322
325
  def test_yylex_paren_string_parens_interpolated
@@ -327,22 +330,22 @@ class TestRubyLexer < Minitest::Test
327
330
  s(:evstr, s(:call, nil, :d)),
328
331
  s(:str, ")")))
329
332
 
330
- assert_next_lexeme :tSTRING_BEG, "%)", :expr_beg, 0, 0
331
- assert_next_lexeme :tSTRING_CONTENT, "(", :expr_beg, 0, 0
332
- assert_next_lexeme :tSTRING_DBEG, nil, :expr_beg, 0, 0
333
+ assert_next_lexeme :tSTRING_BEG, "%)", EXPR_BEG, 0, 0
334
+ assert_next_lexeme :tSTRING_CONTENT, "(", EXPR_BEG, 0, 0
335
+ assert_next_lexeme :tSTRING_DBEG, nil, EXPR_BEG, 0, 0
333
336
 
334
337
  emulate_string_interpolation do
335
- assert_next_lexeme :tIDENTIFIER, "b", :expr_cmdarg, 0, 0
338
+ assert_next_lexeme :tIDENTIFIER, "b", EXPR_CMDARG, 0, 0
336
339
  end
337
340
 
338
- assert_next_lexeme :tSTRING_DBEG, nil, :expr_beg, 0, 0
341
+ assert_next_lexeme :tSTRING_DBEG, nil, EXPR_BEG, 0, 0
339
342
 
340
343
  emulate_string_interpolation do
341
- assert_next_lexeme :tIDENTIFIER, "d", :expr_cmdarg, 0, 0
344
+ assert_next_lexeme :tIDENTIFIER, "d", EXPR_CMDARG, 0, 0
342
345
  end
343
346
 
344
- assert_next_lexeme :tSTRING_CONTENT, ")", :expr_beg, 0, 0
345
- assert_next_lexeme :tSTRING_END, ")", :expr_end, 0, 0
347
+ assert_next_lexeme :tSTRING_CONTENT, ")", EXPR_BEG, 0, 0
348
+ assert_next_lexeme :tSTRING_END, ")", EXPR_END, 0, 0
346
349
 
347
350
  refute_lexeme
348
351
  end
@@ -351,20 +354,20 @@ class TestRubyLexer < Minitest::Test
351
354
  setup_lexer('%( #{(/abcd/)} )',
352
355
  s(:dstr, " ", s(:evstr, s(:lit, /abcd/)), s(:str, " ")))
353
356
 
354
- assert_next_lexeme :tSTRING_BEG, "%)", :expr_beg, 0, 0
355
- assert_next_lexeme :tSTRING_CONTENT, " ", :expr_beg, 0, 0
356
- assert_next_lexeme :tSTRING_DBEG, nil, :expr_beg, 0, 0
357
+ assert_next_lexeme :tSTRING_BEG, "%)", EXPR_BEG, 0, 0
358
+ assert_next_lexeme :tSTRING_CONTENT, " ", EXPR_BEG, 0, 0
359
+ assert_next_lexeme :tSTRING_DBEG, nil, EXPR_BEG, 0, 0
357
360
 
358
361
  emulate_string_interpolation do
359
- assert_next_lexeme :tLPAREN, "(", :expr_beg, 1, 0
360
- assert_next_lexeme :tREGEXP_BEG, "/", :expr_beg, 1, 0
361
- assert_next_lexeme :tSTRING_CONTENT, "abcd", :expr_beg, 1, 0
362
- assert_next_lexeme :tREGEXP_END, "", :expr_end, 1, 0
363
- assert_next_lexeme :tRPAREN, ")", :expr_endfn, 0, 0
362
+ assert_next_lexeme :tLPAREN, "(", EXPR_PAR, 1, 0
363
+ assert_next_lexeme :tREGEXP_BEG, "/", EXPR_PAR, 1, 0
364
+ assert_next_lexeme :tSTRING_CONTENT, "abcd", EXPR_PAR, 1, 0
365
+ assert_next_lexeme :tREGEXP_END, "", EXPR_END, 1, 0
366
+ assert_next_lexeme :tRPAREN, ")", EXPR_ENDFN, 0, 0
364
367
  end
365
368
 
366
- assert_next_lexeme :tSTRING_CONTENT, " ", :expr_beg, 0, 0
367
- assert_next_lexeme :tSTRING_END, ")", :expr_end, 0, 0
369
+ assert_next_lexeme :tSTRING_CONTENT, " ", EXPR_BEG, 0, 0
370
+ assert_next_lexeme :tSTRING_END, ")", EXPR_END, 0, 0
368
371
 
369
372
  refute_lexeme
370
373
  end
@@ -375,26 +378,26 @@ class TestRubyLexer < Minitest::Test
375
378
  assert_lex("def +@; end",
376
379
  s(:defn, :+@, s(:args), s(:nil)),
377
380
 
378
- :kDEF, "def", :expr_fname, 0, 0,
379
- :tUPLUS, "+@", :expr_arg, 0, 0,
380
- :tSEMI, ";", :expr_beg, 0, 0,
381
- :kEND, "end", :expr_end, 0, 0)
381
+ :kDEF, "def", EXPR_FNAME, 0, 0,
382
+ :tUPLUS, "+@", EXPR_ARG, 0, 0,
383
+ :tSEMI, ";", EXPR_BEG, 0, 0,
384
+ :kEND, "end", EXPR_END, 0, 0)
382
385
 
383
386
  assert_lex("def !@; end",
384
387
  s(:defn, :"!@", s(:args), s(:nil)),
385
388
 
386
- :kDEF, "def", :expr_fname, 0, 0,
387
- :tUBANG, "!@", :expr_arg, 0, 0,
388
- :tSEMI, ";", :expr_beg, 0, 0,
389
- :kEND, "end", :expr_end, 0, 0)
389
+ :kDEF, "def", EXPR_FNAME, 0, 0,
390
+ :tUBANG, "!@", EXPR_ARG, 0, 0,
391
+ :tSEMI, ";", EXPR_BEG, 0, 0,
392
+ :kEND, "end", EXPR_END, 0, 0)
390
393
  end
391
394
 
392
395
  def test_yylex_not_at_ivar
393
396
  assert_lex("!@ivar",
394
397
  s(:call, s(:ivar, :@ivar), :"!"),
395
398
 
396
- :tBANG, "!", :expr_beg, 0, 0,
397
- :tIVAR, "@ivar", :expr_end, 0, 0)
399
+ :tBANG, "!", EXPR_BEG, 0, 0,
400
+ :tIVAR, "@ivar", EXPR_END, 0, 0)
398
401
  end
399
402
 
400
403
  def test_yylex_number_times_ident_times_return_number
@@ -403,43 +406,43 @@ class TestRubyLexer < Minitest::Test
403
406
  s(:call, s(:lit, 1), :*, s(:call, nil, :b)),
404
407
  :*, s(:lit, 3)),
405
408
 
406
- :tINTEGER, 1, :expr_end, 0, 0,
407
- :tSTAR2, "*", :expr_beg, 0, 0,
408
- :tIDENTIFIER, "b", :expr_arg, 0, 0,
409
- :tSTAR2, "*", :expr_beg, 0, 0,
410
- :tINTEGER, 3, :expr_end, 0, 0)
409
+ :tINTEGER, 1, EXPR_NUM, 0, 0,
410
+ :tSTAR2, "*", EXPR_BEG, 0, 0,
411
+ :tIDENTIFIER, "b", EXPR_ARG, 0, 0,
412
+ :tSTAR2, "*", EXPR_BEG, 0, 0,
413
+ :tINTEGER, 3, EXPR_NUM, 0, 0)
411
414
 
412
415
  assert_lex("1 * b *\n 3",
413
416
  s(:call,
414
417
  s(:call, s(:lit, 1), :*, s(:call, nil, :b)),
415
418
  :*, s(:lit, 3)),
416
419
 
417
- :tINTEGER, 1, :expr_end, 0, 0,
418
- :tSTAR2, "*", :expr_beg, 0, 0,
419
- :tIDENTIFIER, "b", :expr_arg, 0, 0,
420
- :tSTAR2, "*", :expr_beg, 0, 0,
421
- :tINTEGER, 3, :expr_end, 0, 0)
420
+ :tINTEGER, 1, EXPR_NUM, 0, 0,
421
+ :tSTAR2, "*", EXPR_BEG, 0, 0,
422
+ :tIDENTIFIER, "b", EXPR_ARG, 0, 0,
423
+ :tSTAR2, "*", EXPR_BEG, 0, 0,
424
+ :tINTEGER, 3, EXPR_NUM, 0, 0)
422
425
  end
423
426
 
424
427
  def test_yylex_paren_string_parens_interpolated_regexp
425
428
  setup_lexer('%((#{(/abcd/)}))',
426
429
  s(:dstr, "(", s(:evstr, s(:lit, /abcd/)), s(:str, ")")))
427
430
 
428
- assert_next_lexeme :tSTRING_BEG, "%)", :expr_beg, 0, 0
429
- assert_next_lexeme :tSTRING_CONTENT, "(", :expr_beg, 0, 0
431
+ assert_next_lexeme :tSTRING_BEG, "%)", EXPR_BEG, 0, 0
432
+ assert_next_lexeme :tSTRING_CONTENT, "(", EXPR_BEG, 0, 0
430
433
 
431
- assert_next_lexeme :tSTRING_DBEG, nil, :expr_beg, 0, 0
434
+ assert_next_lexeme :tSTRING_DBEG, nil, EXPR_BEG, 0, 0
432
435
 
433
436
  emulate_string_interpolation do
434
- assert_next_lexeme :tLPAREN, "(", :expr_beg, 1, 0
435
- assert_next_lexeme :tREGEXP_BEG, "/", :expr_beg, 1, 0
436
- assert_next_lexeme :tSTRING_CONTENT, "abcd", :expr_beg, 1, 0
437
- assert_next_lexeme :tREGEXP_END, "", :expr_end, 1, 0
438
- assert_next_lexeme :tRPAREN, ")", :expr_endfn, 0, 0
437
+ assert_next_lexeme :tLPAREN, "(", EXPR_PAR, 1, 0
438
+ assert_next_lexeme :tREGEXP_BEG, "/", EXPR_PAR, 1, 0
439
+ assert_next_lexeme :tSTRING_CONTENT, "abcd", EXPR_PAR, 1, 0
440
+ assert_next_lexeme :tREGEXP_END, "", EXPR_END, 1, 0
441
+ assert_next_lexeme :tRPAREN, ")", EXPR_ENDFN, 0, 0
439
442
  end
440
443
 
441
- assert_next_lexeme :tSTRING_CONTENT, ")", :expr_beg, 0, 0
442
- assert_next_lexeme :tSTRING_END, ")", :expr_end, 0, 0
444
+ assert_next_lexeme :tSTRING_CONTENT, ")", EXPR_BEG, 0, 0
445
+ assert_next_lexeme :tSTRING_END, ")", EXPR_END, 0, 0
443
446
 
444
447
  refute_lexeme
445
448
  end
@@ -447,11 +450,11 @@ class TestRubyLexer < Minitest::Test
447
450
  def test_yylex_method_parens_chevron
448
451
  assert_lex("a()<<1",
449
452
  s(:call, s(:call, nil, :a), :<<, s(:lit, 1)),
450
- :tIDENTIFIER, "a", :expr_cmdarg, 0, 0,
451
- :tLPAREN2, "(", :expr_beg, 1, 0,
452
- :tRPAREN, ")", :expr_endfn, 0, 0,
453
- :tLSHFT, "<<" , :expr_beg, 0, 0,
454
- :tINTEGER, 1, :expr_end, 0, 0)
453
+ :tIDENTIFIER, "a", EXPR_CMDARG, 0, 0,
454
+ :tLPAREN2, "(", EXPR_PAR, 1, 0,
455
+ :tRPAREN, ")", EXPR_ENDFN, 0, 0,
456
+ :tLSHFT, "<<" , EXPR_BEG, 0, 0,
457
+ :tINTEGER, 1, EXPR_NUM, 0, 0)
455
458
  end
456
459
 
457
460
  def test_yylex_lambda_args__20
@@ -461,12 +464,12 @@ class TestRubyLexer < Minitest::Test
461
464
  s(:iter, s(:call, nil, :lambda),
462
465
  s(:args, :a)),
463
466
 
464
- :tLAMBDA, nil, :expr_endfn, 0, 0,
465
- :tLPAREN2, "(", :expr_beg, 1, 0,
466
- :tIDENTIFIER, "a", :expr_arg, 1, 0,
467
- :tRPAREN, ")", :expr_endfn, 0, 0,
468
- :tLCURLY, "{", :expr_beg, 0, 1,
469
- :tRCURLY, "}", :expr_endarg, 0, 0)
467
+ :tLAMBDA, nil, EXPR_ENDFN, 0, 0,
468
+ :tLPAREN2, "(", EXPR_PAR, 1, 0,
469
+ :tIDENTIFIER, "a", EXPR_ARG, 1, 0,
470
+ :tRPAREN, ")", EXPR_ENDFN, 0, 0,
471
+ :tLCURLY, "{", EXPR_PAR, 0, 1,
472
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
470
473
  end
471
474
 
472
475
  def test_yylex_lambda_as_args_with_block__20
@@ -474,12 +477,12 @@ class TestRubyLexer < Minitest::Test
474
477
 
475
478
  assert_lex3("a -> do end do end",
476
479
  nil,
477
- :tIDENTIFIER, "a", :expr_cmdarg,
478
- :tLAMBDA, nil, :expr_endfn,
479
- :kDO, "do", :expr_beg,
480
- :kEND, "end", :expr_end,
481
- :kDO, "do", :expr_beg,
482
- :kEND, "end", :expr_end)
480
+ :tIDENTIFIER, "a", EXPR_CMDARG,
481
+ :tLAMBDA, nil, EXPR_ENDFN,
482
+ :kDO, "do", EXPR_BEG,
483
+ :kEND, "end", EXPR_END,
484
+ :kDO, "do", EXPR_BEG,
485
+ :kEND, "end", EXPR_END)
483
486
  end
484
487
 
485
488
  def test_yylex_lambda_args_opt__20
@@ -489,14 +492,14 @@ class TestRubyLexer < Minitest::Test
489
492
  s(:iter, s(:call, nil, :lambda),
490
493
  s(:args, s(:lasgn, :a, s(:nil)))),
491
494
 
492
- :tLAMBDA, nil, :expr_endfn, 0, 0,
493
- :tLPAREN2, "(", :expr_beg, 1, 0,
494
- :tIDENTIFIER, "a", :expr_arg, 1, 0,
495
- :tEQL, "=", :expr_beg, 1, 0,
496
- :kNIL, "nil", :expr_end, 1, 0,
497
- :tRPAREN, ")", :expr_endfn, 0, 0,
498
- :tLCURLY, "{", :expr_beg, 0, 1,
499
- :tRCURLY, "}", :expr_endarg, 0, 0)
495
+ :tLAMBDA, nil, EXPR_ENDFN, 0, 0,
496
+ :tLPAREN2, "(", EXPR_PAR, 1, 0,
497
+ :tIDENTIFIER, "a", EXPR_ARG, 1, 0,
498
+ :tEQL, "=", EXPR_BEG, 1, 0,
499
+ :kNIL, "nil", EXPR_END, 1, 0,
500
+ :tRPAREN, ")", EXPR_ENDFN, 0, 0,
501
+ :tLCURLY, "{", EXPR_PAR, 0, 1,
502
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
500
503
  end
501
504
 
502
505
  def test_yylex_lambda_hash__20
@@ -506,15 +509,15 @@ class TestRubyLexer < Minitest::Test
506
509
  s(:iter, s(:call, nil, :lambda),
507
510
  s(:args, s(:lasgn, :a, s(:hash)))),
508
511
 
509
- :tLAMBDA, nil, :expr_endfn, 0, 0,
510
- :tLPAREN2, "(", :expr_beg, 1, 0,
511
- :tIDENTIFIER, "a", :expr_arg, 1, 0,
512
- :tEQL, "=", :expr_beg, 1, 0,
513
- :tLBRACE, "{", :expr_beg, 1, 1,
514
- :tRCURLY, "}", :expr_endarg, 1, 0,
515
- :tRPAREN, ")", :expr_endfn, 0, 0,
516
- :tLCURLY, "{", :expr_beg, 0, 1,
517
- :tRCURLY, "}", :expr_endarg, 0, 0)
512
+ :tLAMBDA, nil, EXPR_ENDFN, 0, 0,
513
+ :tLPAREN2, "(", EXPR_PAR, 1, 0,
514
+ :tIDENTIFIER, "a", EXPR_ARG, 1, 0,
515
+ :tEQL, "=", EXPR_BEG, 1, 0,
516
+ :tLBRACE, "{", EXPR_PAR, 1, 1,
517
+ :tRCURLY, "}", EXPR_ENDARG, 1, 0,
518
+ :tRPAREN, ")", EXPR_ENDFN, 0, 0,
519
+ :tLCURLY, "{", EXPR_PAR, 0, 1,
520
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
518
521
  end
519
522
 
520
523
  def test_yylex_iter_array_curly
@@ -523,19 +526,19 @@ class TestRubyLexer < Minitest::Test
523
526
  s(:call, nil, :f, s(:lit, :a), s(:array, s(:lit, :b))),
524
527
  s(:args, :c, :d)),
525
528
 
526
- :tIDENTIFIER, "f", :expr_cmdarg, 0, 0,
527
- :tSYMBOL, "a", :expr_end, 0, 0,
528
- :tCOMMA, ",", :expr_beg, 0, 0,
529
- :tLBRACK, "[", :expr_beg, 1, 0,
530
- :tSYMBOL, "b", :expr_end, 1, 0,
531
- :tRBRACK, "]", :expr_endarg, 0, 0,
532
- :tLBRACE_ARG, "{", :expr_beg, 0, 1,
533
- :tPIPE, "|", :expr_beg, 0, 1,
534
- :tIDENTIFIER, "c", :expr_arg, 0, 1,
535
- :tCOMMA, ",", :expr_beg, 0, 1,
536
- :tIDENTIFIER, "d", :expr_arg, 0, 1,
537
- :tPIPE, "|", :expr_beg, 0, 1,
538
- :tRCURLY, "}", :expr_endarg, 0, 0)
529
+ :tIDENTIFIER, "f", EXPR_CMDARG, 0, 0,
530
+ :tSYMBOL, "a", EXPR_END, 0, 0,
531
+ :tCOMMA, ",", EXPR_PAR, 0, 0,
532
+ :tLBRACK, "[", EXPR_PAR, 1, 0,
533
+ :tSYMBOL, "b", EXPR_END, 1, 0,
534
+ :tRBRACK, "]", EXPR_ENDARG, 0, 0,
535
+ :tLBRACE_ARG, "{", EXPR_BEG, 0, 1,
536
+ :tPIPE, "|", EXPR_PAR, 0, 1,
537
+ :tIDENTIFIER, "c", EXPR_ARG, 0, 1,
538
+ :tCOMMA, ",", EXPR_PAR, 0, 1,
539
+ :tIDENTIFIER, "d", EXPR_ARG, 0, 1,
540
+ :tPIPE, "|", EXPR_PAR, 0, 1,
541
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
539
542
  end
540
543
 
541
544
  def test_yylex_const_call_same_name
@@ -547,18 +550,18 @@ class TestRubyLexer < Minitest::Test
547
550
  0,
548
551
  s(:call, nil, :f, s(:lit, :c)))),
549
552
 
550
- :tCONSTANT, "X", :expr_cmdarg, 0, 0,
551
- :tEQL, "=", :expr_beg, 0, 0,
552
- :tIDENTIFIER, "a", :expr_arg, 0, 0,
553
- :tLCURLY, "{", :expr_beg, 0, 1,
554
- :tRCURLY, "}", :expr_endarg, 0, 0,
555
- :tSEMI, ";", :expr_beg, 0, 0,
553
+ :tCONSTANT, "X", EXPR_CMDARG, 0, 0,
554
+ :tEQL, "=", EXPR_BEG, 0, 0,
555
+ :tIDENTIFIER, "a", EXPR_ARG, 0, 0,
556
+ :tLCURLY, "{", EXPR_PAR, 0, 1,
557
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0,
558
+ :tSEMI, ";", EXPR_BEG, 0, 0,
556
559
 
557
- :tIDENTIFIER, "b", :expr_cmdarg, 0, 0,
558
- :tLCURLY, "{", :expr_beg, 0, 1,
559
- :tIDENTIFIER, "f", :expr_cmdarg, 0, 1, # different
560
- :tSYMBOL, "c", :expr_end, 0, 1,
561
- :tRCURLY, "}", :expr_endarg, 0, 0)
560
+ :tIDENTIFIER, "b", EXPR_CMDARG, 0, 0,
561
+ :tLCURLY, "{", EXPR_PAR, 0, 1,
562
+ :tIDENTIFIER, "f", EXPR_CMDARG, 0, 1, # different
563
+ :tSYMBOL, "c", EXPR_END, 0, 1,
564
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
562
565
 
563
566
  assert_lex("X = a { }; b { X :c }",
564
567
  s(:block,
@@ -568,18 +571,18 @@ class TestRubyLexer < Minitest::Test
568
571
  0,
569
572
  s(:call, nil, :X, s(:lit, :c)))),
570
573
 
571
- :tCONSTANT, "X", :expr_cmdarg, 0, 0,
572
- :tEQL, "=", :expr_beg, 0, 0,
573
- :tIDENTIFIER, "a", :expr_arg, 0, 0,
574
- :tLCURLY, "{", :expr_beg, 0, 1,
575
- :tRCURLY, "}", :expr_endarg, 0, 0,
576
- :tSEMI, ";", :expr_beg, 0, 0,
574
+ :tCONSTANT, "X", EXPR_CMDARG, 0, 0,
575
+ :tEQL, "=", EXPR_BEG, 0, 0,
576
+ :tIDENTIFIER, "a", EXPR_ARG, 0, 0,
577
+ :tLCURLY, "{", EXPR_PAR, 0, 1,
578
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0,
579
+ :tSEMI, ";", EXPR_BEG, 0, 0,
577
580
 
578
- :tIDENTIFIER, "b", :expr_cmdarg, 0, 0,
579
- :tLCURLY, "{", :expr_beg, 0, 1,
580
- :tCONSTANT, "X", :expr_cmdarg, 0, 1, # same
581
- :tSYMBOL, "c", :expr_end, 0, 1,
582
- :tRCURLY, "}", :expr_endarg, 0, 0)
581
+ :tIDENTIFIER, "b", EXPR_CMDARG, 0, 0,
582
+ :tLCURLY, "{", EXPR_PAR, 0, 1,
583
+ :tCONSTANT, "X", EXPR_CMDARG, 0, 1, # same
584
+ :tSYMBOL, "c", EXPR_END, 0, 1,
585
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
583
586
  end
584
587
 
585
588
  def test_yylex_lasgn_call_same_name
@@ -588,47 +591,47 @@ class TestRubyLexer < Minitest::Test
588
591
  s(:call, s(:call, nil, :b), :c,
589
592
  s(:hash, s(:lit, :d), s(:lit, 1)))),
590
593
 
591
- :tIDENTIFIER, "a", :expr_cmdarg, 0, 0,
592
- :tEQL, "=", :expr_beg, 0, 0,
593
- :tIDENTIFIER, "b", :expr_arg, 0, 0,
594
- :tDOT, ".", :expr_dot, 0, 0,
595
- :tIDENTIFIER, "c", :expr_arg, 0, 0, # different
596
- :tSYMBOL, "d", :expr_end, 0, 0,
597
- :tASSOC, "=>", :expr_beg, 0, 0,
598
- :tINTEGER, 1, :expr_end, 0, 0)
594
+ :tIDENTIFIER, "a", EXPR_CMDARG, 0, 0,
595
+ :tEQL, "=", EXPR_BEG, 0, 0,
596
+ :tIDENTIFIER, "b", EXPR_ARG, 0, 0,
597
+ :tDOT, ".", EXPR_DOT, 0, 0,
598
+ :tIDENTIFIER, "c", EXPR_ARG, 0, 0, # different
599
+ :tSYMBOL, "d", EXPR_END, 0, 0,
600
+ :tASSOC, "=>", EXPR_BEG, 0, 0,
601
+ :tINTEGER, 1, EXPR_NUM, 0, 0)
599
602
 
600
603
  assert_lex("a = b.a :d => 1",
601
604
  s(:lasgn, :a,
602
605
  s(:call, s(:call, nil, :b), :a,
603
606
  s(:hash, s(:lit, :d), s(:lit, 1)))),
604
607
 
605
- :tIDENTIFIER, "a", :expr_cmdarg, 0, 0,
606
- :tEQL, "=", :expr_beg, 0, 0,
607
- :tIDENTIFIER, "b", :expr_arg, 0, 0,
608
- :tDOT, ".", :expr_dot, 0, 0,
609
- :tIDENTIFIER, "a", :expr_arg, 0, 0, # same as lvar
610
- :tSYMBOL, "d", :expr_end, 0, 0,
611
- :tASSOC, "=>", :expr_beg, 0, 0,
612
- :tINTEGER, 1, :expr_end, 0, 0)
608
+ :tIDENTIFIER, "a", EXPR_CMDARG, 0, 0,
609
+ :tEQL, "=", EXPR_BEG, 0, 0,
610
+ :tIDENTIFIER, "b", EXPR_ARG, 0, 0,
611
+ :tDOT, ".", EXPR_DOT, 0, 0,
612
+ :tIDENTIFIER, "a", EXPR_ARG, 0, 0, # same as lvar
613
+ :tSYMBOL, "d", EXPR_END, 0, 0,
614
+ :tASSOC, "=>", EXPR_BEG, 0, 0,
615
+ :tINTEGER, 1, EXPR_NUM, 0, 0)
613
616
  end
614
617
 
615
618
  def test_yylex_back_ref
616
619
  assert_lex3("[$&, $`, $', $+]",
617
620
  nil,
618
- :tLBRACK, "[", :expr_beg,
619
- :tBACK_REF, :&, :expr_end, :tCOMMA, ",", :expr_beg,
620
- :tBACK_REF, :"`", :expr_end, :tCOMMA, ",", :expr_beg,
621
- :tBACK_REF, :"'", :expr_end, :tCOMMA, ",", :expr_beg,
622
- :tBACK_REF, :+, :expr_end,
623
- :tRBRACK, "]", :expr_endarg)
621
+ :tLBRACK, "[", EXPR_PAR,
622
+ :tBACK_REF, :&, EXPR_END, :tCOMMA, ",", EXPR_PAR,
623
+ :tBACK_REF, :"`", EXPR_END, :tCOMMA, ",", EXPR_PAR,
624
+ :tBACK_REF, :"'", EXPR_END, :tCOMMA, ",", EXPR_PAR,
625
+ :tBACK_REF, :+, EXPR_END,
626
+ :tRBRACK, "]", EXPR_ENDARG)
624
627
  end
625
628
 
626
629
  def test_yylex_backslash
627
630
  assert_lex3("1 \\\n+ 2",
628
631
  nil,
629
- :tINTEGER, 1, :expr_end,
630
- :tPLUS, "+", :expr_beg,
631
- :tINTEGER, 2, :expr_end)
632
+ :tINTEGER, 1, EXPR_NUM,
633
+ :tPLUS, "+", EXPR_BEG,
634
+ :tINTEGER, 2, EXPR_NUM)
632
635
  end
633
636
 
634
637
  def test_yylex_backslash_bad
@@ -638,37 +641,37 @@ class TestRubyLexer < Minitest::Test
638
641
  def test_yylex_backtick
639
642
  assert_lex3("`ls`",
640
643
  nil,
641
- :tXSTRING_BEG, "`", :expr_beg,
642
- :tSTRING_CONTENT, "ls", :expr_beg,
643
- :tSTRING_END, "`", :expr_end)
644
+ :tXSTRING_BEG, "`", EXPR_BEG,
645
+ :tSTRING_CONTENT, "ls", EXPR_BEG,
646
+ :tSTRING_END, "`", EXPR_END)
644
647
  end
645
648
 
646
649
  def test_yylex_backtick_cmdarg
647
- self.lex_state = :expr_dot
650
+ self.lex_state = EXPR_DOT
648
651
 
649
652
  # \n ensures expr_cmd (TODO: why?)
650
- assert_lex3("\n`", nil, :tBACK_REF2, "`", :expr_cmdarg)
653
+ assert_lex3("\n`", nil, :tBACK_REF2, "`", EXPR_CMDARG)
651
654
  end
652
655
 
653
656
  def test_yylex_backtick_dot
654
- self.lex_state = :expr_dot
657
+ self.lex_state = EXPR_DOT
655
658
 
656
659
  assert_lex3("a.`(3)",
657
660
  nil,
658
- :tIDENTIFIER, "a", :expr_cmdarg,
659
- :tDOT, ".", :expr_dot,
660
- :tBACK_REF2, "`", :expr_arg,
661
- :tLPAREN2, "(", :expr_beg,
662
- :tINTEGER, 3, :expr_end,
663
- :tRPAREN, ")", :expr_endfn)
661
+ :tIDENTIFIER, "a", EXPR_CMDARG,
662
+ :tDOT, ".", EXPR_DOT,
663
+ :tBACK_REF2, "`", EXPR_ARG,
664
+ :tLPAREN2, "(", EXPR_PAR,
665
+ :tINTEGER, 3, EXPR_NUM,
666
+ :tRPAREN, ")", EXPR_ENDFN)
664
667
  end
665
668
 
666
669
  def test_yylex_backtick_method
667
- self.lex_state = :expr_fname
670
+ self.lex_state = EXPR_FNAME
668
671
 
669
672
  assert_lex3("`",
670
673
  nil,
671
- :tBACK_REF2, "`", :expr_end)
674
+ :tBACK_REF2, "`", EXPR_END)
672
675
  end
673
676
 
674
677
  def test_yylex_bad_char
@@ -676,24 +679,24 @@ class TestRubyLexer < Minitest::Test
676
679
  end
677
680
 
678
681
  def test_yylex_bang
679
- assert_lex3("!", nil, :tBANG, "!", :expr_beg)
682
+ assert_lex3("!", nil, :tBANG, "!", EXPR_BEG)
680
683
  end
681
684
 
682
685
  def test_yylex_bang_equals
683
- assert_lex3("!=", nil, :tNEQ, "!=", :expr_beg)
686
+ assert_lex3("!=", nil, :tNEQ, "!=", EXPR_BEG)
684
687
  end
685
688
 
686
689
  def test_yylex_bang_tilde
687
- assert_lex3("!~", nil, :tNMATCH, "!~", :expr_beg)
690
+ assert_lex3("!~", nil, :tNMATCH, "!~", EXPR_BEG)
688
691
  end
689
692
 
690
693
  def test_yylex_block_bug_1
691
694
  assert_lex3("a do end",
692
695
  s(:iter, s(:call, nil, :a), 0),
693
696
 
694
- :tIDENTIFIER, "a", :expr_cmdarg,
695
- :kDO, "do", :expr_beg,
696
- :kEND, "end", :expr_end)
697
+ :tIDENTIFIER, "a", EXPR_CMDARG,
698
+ :kDO, "do", EXPR_BEG,
699
+ :kEND, "end", EXPR_END)
697
700
  end
698
701
 
699
702
  def test_yylex_block_bug_2
@@ -702,70 +705,70 @@ class TestRubyLexer < Minitest::Test
702
705
  s(:lasgn, :a, s(:lit, 1)),
703
706
  s(:iter, s(:call, nil, :a), 0)),
704
707
 
705
- :tIDENTIFIER, "a", :expr_cmdarg,
706
- :tEQL, "=", :expr_beg,
707
- :tINTEGER, 1, :expr_end,
708
- :tNL, nil, :expr_beg,
709
- :tIDENTIFIER, "a", :expr_cmdarg,
710
- :kDO, "do", :expr_beg,
711
- :kEND, "end", :expr_end)
708
+ :tIDENTIFIER, "a", EXPR_CMDARG,
709
+ :tEQL, "=", EXPR_BEG,
710
+ :tINTEGER, 1, EXPR_NUM,
711
+ :tNL, nil, EXPR_BEG,
712
+ :tIDENTIFIER, "a", EXPR_CMDARG,
713
+ :kDO, "do", EXPR_BEG,
714
+ :kEND, "end", EXPR_END)
712
715
  end
713
716
 
714
717
  def test_yylex_block_bug_3
715
718
  assert_lex3("a { }",
716
719
  s(:iter, s(:call, nil, :a), 0),
717
720
 
718
- :tIDENTIFIER, "a", :expr_cmdarg, # verified
719
- :tLCURLY, "{", :expr_beg, # TODO: expr_beg|expr_label
720
- :tRCURLY, "}", :expr_endarg)
721
+ :tIDENTIFIER, "a", EXPR_CMDARG, # verified
722
+ :tLCURLY, "{", EXPR_PAR,
723
+ :tRCURLY, "}", EXPR_ENDARG)
721
724
  end
722
725
 
723
726
  def test_yylex_carat
724
- assert_lex3("^", nil, :tCARET, "^", :expr_beg)
727
+ assert_lex3("^", nil, :tCARET, "^", EXPR_BEG)
725
728
  end
726
729
 
727
730
  def test_yylex_carat_equals
728
- assert_lex3("^=", nil, :tOP_ASGN, "^", :expr_beg)
731
+ assert_lex3("^=", nil, :tOP_ASGN, "^", EXPR_BEG)
729
732
  end
730
733
 
731
734
  def test_yylex_colon2
732
735
  assert_lex3("A::B",
733
736
  nil,
734
- :tCONSTANT, "A", :expr_cmdarg,
735
- :tCOLON2, "::", :expr_dot,
736
- :tCONSTANT, "B", :expr_arg)
737
+ :tCONSTANT, "A", EXPR_CMDARG,
738
+ :tCOLON2, "::", EXPR_DOT,
739
+ :tCONSTANT, "B", EXPR_ARG)
737
740
  end
738
741
 
739
742
  def test_yylex_colon2_argh
740
743
  assert_lex3("module X::Y\n c\nend",
741
744
  nil,
742
- :kMODULE, "module", :expr_beg,
743
- :tCONSTANT, "X", :expr_cmdarg,
744
- :tCOLON2, "::", :expr_dot,
745
- :tCONSTANT, "Y", :expr_arg,
746
- :tNL, nil, :expr_beg,
747
- :tIDENTIFIER, "c", :expr_cmdarg,
748
- :tNL, nil, :expr_beg,
749
- :kEND, "end", :expr_end)
745
+ :kMODULE, "module", EXPR_BEG,
746
+ :tCONSTANT, "X", EXPR_CMDARG,
747
+ :tCOLON2, "::", EXPR_DOT,
748
+ :tCONSTANT, "Y", EXPR_ARG,
749
+ :tNL, nil, EXPR_BEG,
750
+ :tIDENTIFIER, "c", EXPR_CMDARG,
751
+ :tNL, nil, EXPR_BEG,
752
+ :kEND, "end", EXPR_END)
750
753
  end
751
754
 
752
755
  def test_yylex_colon3
753
756
  assert_lex3("::Array",
754
757
  nil,
755
- :tCOLON3, "::", :expr_beg,
756
- :tCONSTANT, "Array", :expr_arg)
758
+ :tCOLON3, "::", EXPR_BEG,
759
+ :tCONSTANT, "Array", EXPR_ARG)
757
760
  end
758
761
 
759
762
  def test_yylex_comma
760
- assert_lex3(",", nil, :tCOMMA, ",", :expr_beg)
763
+ assert_lex3(",", nil, :tCOMMA, ",", EXPR_PAR)
761
764
  end
762
765
 
763
766
  def test_yylex_comment
764
767
  assert_lex3("1 # one\n# two\n2",
765
768
  nil,
766
- :tINTEGER, 1, :expr_end,
767
- :tNL, nil, :expr_beg,
768
- :tINTEGER, 2, :expr_end)
769
+ :tINTEGER, 1, EXPR_NUM,
770
+ :tNL, nil, EXPR_BEG,
771
+ :tINTEGER, 2, EXPR_NUM)
769
772
 
770
773
  assert_equal "# one\n# two\n", @lex.comments
771
774
  end
@@ -773,7 +776,7 @@ class TestRubyLexer < Minitest::Test
773
776
  def test_yylex_comment_begin
774
777
  assert_lex3("=begin\nblah\nblah\n=end\n42",
775
778
  nil,
776
- :tINTEGER, 42, :expr_end)
779
+ :tINTEGER, 42, EXPR_NUM)
777
780
 
778
781
  assert_equal "=begin\nblah\nblah\n=end\n", @lex.comments
779
782
  end
@@ -787,14 +790,14 @@ class TestRubyLexer < Minitest::Test
787
790
  def test_yylex_comment_begin_not_comment
788
791
  assert_lex3("beginfoo = 5\np x \\\n=beginfoo",
789
792
  nil,
790
- :tIDENTIFIER, "beginfoo", :expr_cmdarg,
791
- :tEQL, "=", :expr_beg,
792
- :tINTEGER, 5, :expr_end,
793
- :tNL, nil, :expr_beg,
794
- :tIDENTIFIER, "p", :expr_cmdarg,
795
- :tIDENTIFIER, "x", :expr_arg,
796
- :tEQL, "=", :expr_beg,
797
- :tIDENTIFIER, "beginfoo", :expr_arg)
793
+ :tIDENTIFIER, "beginfoo", EXPR_CMDARG,
794
+ :tEQL, "=", EXPR_BEG,
795
+ :tINTEGER, 5, EXPR_NUM,
796
+ :tNL, nil, EXPR_BEG,
797
+ :tIDENTIFIER, "p", EXPR_CMDARG,
798
+ :tIDENTIFIER, "x", EXPR_ARG,
799
+ :tEQL, "=", EXPR_BEG,
800
+ :tIDENTIFIER, "beginfoo", EXPR_ARG)
798
801
  end
799
802
 
800
803
  def test_yylex_comment_begin_space
@@ -814,18 +817,18 @@ class TestRubyLexer < Minitest::Test
814
817
  end
815
818
 
816
819
  def test_yylex_constant
817
- assert_lex3("ArgumentError", nil, :tCONSTANT, "ArgumentError", :expr_cmdarg)
820
+ assert_lex3("ArgumentError", nil, :tCONSTANT, "ArgumentError", EXPR_CMDARG)
818
821
  end
819
822
 
820
823
  def test_yylex_constant_semi
821
824
  assert_lex3("ArgumentError;",
822
825
  nil,
823
- :tCONSTANT, "ArgumentError", :expr_cmdarg,
824
- :tSEMI, ";", :expr_beg)
826
+ :tCONSTANT, "ArgumentError", EXPR_CMDARG,
827
+ :tSEMI, ";", EXPR_BEG)
825
828
  end
826
829
 
827
830
  def test_yylex_cvar
828
- assert_lex3("@@blah", nil, :tCVAR, "@@blah", :expr_end)
831
+ assert_lex3("@@blah", nil, :tCVAR, "@@blah", EXPR_END)
829
832
  end
830
833
 
831
834
  def test_yylex_cvar_bad
@@ -835,75 +838,75 @@ class TestRubyLexer < Minitest::Test
835
838
  end
836
839
 
837
840
  def test_yylex_def_bad_name
838
- self.lex_state = :expr_fname
841
+ self.lex_state = EXPR_FNAME
839
842
  refute_lex("def [ ", :kDEF, "def")
840
843
  end
841
844
 
842
845
  def test_yylex_div
843
846
  assert_lex3("a / 2",
844
847
  nil,
845
- :tIDENTIFIER, "a", :expr_cmdarg,
846
- :tDIVIDE, "/", :expr_beg,
847
- :tINTEGER, 2, :expr_end)
848
+ :tIDENTIFIER, "a", EXPR_CMDARG,
849
+ :tDIVIDE, "/", EXPR_BEG,
850
+ :tINTEGER, 2, EXPR_NUM)
848
851
  end
849
852
 
850
853
  def test_yylex_div_equals
851
854
  assert_lex3("a /= 2",
852
855
  nil,
853
- :tIDENTIFIER, "a", :expr_cmdarg,
854
- :tOP_ASGN, "/", :expr_beg,
855
- :tINTEGER, 2, :expr_end)
856
+ :tIDENTIFIER, "a", EXPR_CMDARG,
857
+ :tOP_ASGN, "/", EXPR_BEG,
858
+ :tINTEGER, 2, EXPR_NUM)
856
859
  end
857
860
 
858
861
  def test_yylex_do
859
862
  assert_lex3("x do 42 end",
860
863
  nil,
861
- :tIDENTIFIER, "x", :expr_cmdarg,
862
- :kDO, "do", :expr_beg,
863
- :tINTEGER, 42, :expr_end,
864
- :kEND, "end", :expr_end)
864
+ :tIDENTIFIER, "x", EXPR_CMDARG,
865
+ :kDO, "do", EXPR_BEG,
866
+ :tINTEGER, 42, EXPR_NUM,
867
+ :kEND, "end", EXPR_END)
865
868
  end
866
869
 
867
870
  def test_yylex_do_block
868
- self.lex_state = :expr_endarg
871
+ self.lex_state = EXPR_ENDARG
869
872
 
870
873
  assert_lex3("x.y do 42 end",
871
874
  nil,
872
- :tIDENTIFIER, "x", :expr_end,
873
- :tDOT, ".", :expr_dot,
874
- :tIDENTIFIER, "y", :expr_arg,
875
- :kDO_BLOCK, "do", :expr_beg,
876
- :tINTEGER, 42, :expr_end,
877
- :kEND, "end", :expr_end) do
875
+ :tIDENTIFIER, "x", EXPR_END,
876
+ :tDOT, ".", EXPR_DOT,
877
+ :tIDENTIFIER, "y", EXPR_ARG,
878
+ :kDO_BLOCK, "do", EXPR_BEG,
879
+ :tINTEGER, 42, EXPR_NUM,
880
+ :kEND, "end", EXPR_END) do
878
881
  @lex.cmdarg.push true
879
882
  end
880
883
  end
881
884
 
882
885
  def test_yylex_do_block2
883
- self.lex_state = :expr_endarg
886
+ self.lex_state = EXPR_ENDARG
884
887
 
885
888
  assert_lex3("do 42 end",
886
889
  nil,
887
- :kDO_BLOCK, "do", :expr_beg,
888
- :tINTEGER, 42, :expr_end,
889
- :kEND, "end", :expr_end)
890
+ :kDO_BLOCK, "do", EXPR_BEG,
891
+ :tINTEGER, 42, EXPR_NUM,
892
+ :kEND, "end", EXPR_END)
890
893
  end
891
894
 
892
895
  def test_yylex_is_your_spacebar_broken?
893
896
  assert_lex3(":a!=:b",
894
897
  nil,
895
- :tSYMBOL, "a", :expr_end,
896
- :tNEQ, "!=", :expr_beg,
897
- :tSYMBOL, "b", :expr_end)
898
+ :tSYMBOL, "a", EXPR_END,
899
+ :tNEQ, "!=", EXPR_BEG,
900
+ :tSYMBOL, "b", EXPR_END)
898
901
  end
899
902
 
900
903
  def test_yylex_do_cond
901
904
  assert_lex3("x do 42 end",
902
905
  nil,
903
- :tIDENTIFIER, "x", :expr_cmdarg,
904
- :kDO_COND, "do", :expr_beg,
905
- :tINTEGER, 42, :expr_end,
906
- :kEND, "end", :expr_end) do
906
+ :tIDENTIFIER, "x", EXPR_CMDARG,
907
+ :kDO_COND, "do", EXPR_BEG,
908
+ :tINTEGER, 42, EXPR_NUM,
909
+ :kEND, "end", EXPR_END) do
907
910
  @lex.cond.push true
908
911
  end
909
912
  end
@@ -914,40 +917,40 @@ class TestRubyLexer < Minitest::Test
914
917
  end
915
918
 
916
919
  def test_yylex_dollar_eos
917
- assert_lex3("$", nil, "$", "$", :expr_end) # FIX: wtf is this?!?
920
+ assert_lex3("$", nil, "$", "$", EXPR_END) # FIX: wtf is this?!?
918
921
  end
919
922
 
920
923
  def test_yylex_dot # HINT message sends
921
- assert_lex3(".", nil, :tDOT, ".", :expr_dot)
924
+ assert_lex3(".", nil, :tDOT, ".", EXPR_DOT)
922
925
  end
923
926
 
924
927
  def test_yylex_dot2
925
- assert_lex3("..", nil, :tDOT2, "..", :expr_beg)
928
+ assert_lex3("..", nil, :tDOT2, "..", EXPR_BEG)
926
929
  end
927
930
 
928
931
  def test_yylex_dot3
929
- assert_lex3("...", nil, :tDOT3, "...", :expr_beg)
932
+ assert_lex3("...", nil, :tDOT3, "...", EXPR_BEG)
930
933
  end
931
934
 
932
935
  def test_yylex_equals
933
936
  # FIX: this sucks
934
- assert_lex3("=", nil, :tEQL, "=", :expr_beg)
937
+ assert_lex3("=", nil, :tEQL, "=", EXPR_BEG)
935
938
  end
936
939
 
937
940
  def test_yylex_equals2
938
- assert_lex3("==", nil, :tEQ, "==", :expr_beg)
941
+ assert_lex3("==", nil, :tEQ, "==", EXPR_BEG)
939
942
  end
940
943
 
941
944
  def test_yylex_equals3
942
- assert_lex3("===", nil, :tEQQ, "===", :expr_beg)
945
+ assert_lex3("===", nil, :tEQQ, "===", EXPR_BEG)
943
946
  end
944
947
 
945
948
  def test_yylex_equals_tilde
946
- assert_lex3("=~", nil, :tMATCH, "=~", :expr_beg)
949
+ assert_lex3("=~", nil, :tMATCH, "=~", EXPR_BEG)
947
950
  end
948
951
 
949
952
  def test_yylex_float
950
- assert_lex3("1.0", nil, :tFLOAT, 1.0, :expr_end)
953
+ assert_lex3("1.0", nil, :tFLOAT, 1.0, EXPR_NUM)
951
954
  end
952
955
 
953
956
  def test_yylex_float_bad_no_underscores
@@ -965,55 +968,55 @@ class TestRubyLexer < Minitest::Test
965
968
  def test_yylex_float_call
966
969
  assert_lex3("1.0.to_s",
967
970
  nil,
968
- :tFLOAT, 1.0, :expr_end,
969
- :tDOT, ".", :expr_dot,
970
- :tIDENTIFIER, "to_s", :expr_arg)
971
+ :tFLOAT, 1.0, EXPR_NUM,
972
+ :tDOT, ".", EXPR_DOT,
973
+ :tIDENTIFIER, "to_s", EXPR_ARG)
971
974
  end
972
975
 
973
976
  def test_yylex_float_dot_E
974
977
  assert_lex3("1.0E10",
975
978
  nil,
976
- :tFLOAT, 10000000000.0, :expr_end)
979
+ :tFLOAT, 10000000000.0, EXPR_NUM)
977
980
  end
978
981
 
979
982
  def test_yylex_float_dot_E_neg
980
983
  assert_lex3("-1.0E10",
981
984
  nil,
982
- :tUMINUS_NUM, "-", :expr_beg,
983
- :tFLOAT, 10000000000.0, :expr_end)
985
+ :tUMINUS_NUM, "-", EXPR_BEG,
986
+ :tFLOAT, 10000000000.0, EXPR_NUM)
984
987
  end
985
988
 
986
989
  def test_yylex_float_dot_e
987
990
  assert_lex3("1.0e10",
988
991
  nil,
989
- :tFLOAT, 10000000000.0, :expr_end)
992
+ :tFLOAT, 10000000000.0, EXPR_NUM)
990
993
  end
991
994
 
992
995
  def test_yylex_float_dot_e_neg
993
996
  assert_lex3("-1.0e10",
994
997
  nil,
995
- :tUMINUS_NUM, "-", :expr_beg,
996
- :tFLOAT, 10000000000.0, :expr_end)
998
+ :tUMINUS_NUM, "-", EXPR_BEG,
999
+ :tFLOAT, 10000000000.0, EXPR_NUM)
997
1000
  end
998
1001
 
999
1002
  def test_yylex_float_e
1000
1003
  assert_lex3("1e10",
1001
1004
  nil,
1002
- :tFLOAT, 10000000000.0, :expr_end)
1005
+ :tFLOAT, 10000000000.0, EXPR_NUM)
1003
1006
  end
1004
1007
 
1005
1008
  def test_yylex_float_e_bad_double_e
1006
1009
  assert_lex3("1e2e3",
1007
1010
  nil,
1008
- :tFLOAT, 100, :expr_end,
1009
- :tIDENTIFIER, "e3", :expr_end)
1011
+ :tFLOAT, 100, EXPR_NUM,
1012
+ :tIDENTIFIER, "e3", EXPR_END)
1010
1013
  end
1011
1014
 
1012
1015
  def test_yylex_float_if_modifier
1013
1016
  assert_lex3("1e2if",
1014
1017
  nil,
1015
- :tFLOAT, 100, :expr_end,
1016
- :kIF_MOD, "if", :expr_beg)
1018
+ :tFLOAT, 100, EXPR_NUM,
1019
+ :kIF_MOD, "if", EXPR_PAR)
1017
1020
  end
1018
1021
 
1019
1022
  def test_yylex_float_e_bad_trailing_underscore
@@ -1021,157 +1024,157 @@ class TestRubyLexer < Minitest::Test
1021
1024
  end
1022
1025
 
1023
1026
  def test_yylex_float_e_minus
1024
- assert_lex3("1e-10", nil, :tFLOAT, 1.0e-10, :expr_end)
1027
+ assert_lex3("1e-10", nil, :tFLOAT, 1.0e-10, EXPR_NUM)
1025
1028
  end
1026
1029
 
1027
1030
  def test_yylex_float_e_neg
1028
1031
  assert_lex3("-1e10",
1029
1032
  nil,
1030
- :tUMINUS_NUM, "-", :expr_beg,
1031
- :tFLOAT, 10000000000.0, :expr_end)
1033
+ :tUMINUS_NUM, "-", EXPR_BEG,
1034
+ :tFLOAT, 10000000000.0, EXPR_NUM)
1032
1035
  end
1033
1036
 
1034
1037
  def test_yylex_float_e_neg_minus
1035
1038
  assert_lex3("-1e-10",
1036
1039
  nil,
1037
- :tUMINUS_NUM, "-", :expr_beg,
1038
- :tFLOAT, 1.0e-10, :expr_end)
1040
+ :tUMINUS_NUM, "-", EXPR_BEG,
1041
+ :tFLOAT, 1.0e-10, EXPR_NUM)
1039
1042
  end
1040
1043
 
1041
1044
  def test_yylex_float_e_neg_plus
1042
1045
  assert_lex3("-1e+10",
1043
1046
  nil,
1044
- :tUMINUS_NUM, "-", :expr_beg,
1045
- :tFLOAT, 10000000000.0, :expr_end)
1047
+ :tUMINUS_NUM, "-", EXPR_BEG,
1048
+ :tFLOAT, 10000000000.0, EXPR_NUM)
1046
1049
  end
1047
1050
 
1048
1051
  def test_yylex_float_e_plus
1049
- assert_lex3("1e+10", nil, :tFLOAT, 10000000000.0, :expr_end)
1052
+ assert_lex3("1e+10", nil, :tFLOAT, 10000000000.0, EXPR_NUM)
1050
1053
  end
1051
1054
 
1052
1055
  def test_yylex_float_e_zero
1053
- assert_lex3("0e0", nil, :tFLOAT, 0.0, :expr_end)
1056
+ assert_lex3("0e0", nil, :tFLOAT, 0.0, EXPR_NUM)
1054
1057
  end
1055
1058
 
1056
1059
  def test_yylex_float_neg
1057
1060
  assert_lex3("-1.0",
1058
1061
  nil,
1059
- :tUMINUS_NUM, "-", :expr_beg,
1060
- :tFLOAT, 1.0, :expr_end)
1062
+ :tUMINUS_NUM, "-", EXPR_BEG,
1063
+ :tFLOAT, 1.0, EXPR_NUM)
1061
1064
  end
1062
1065
 
1063
1066
  def test_yylex_ge
1064
1067
  assert_lex3("a >= 2",
1065
1068
  nil,
1066
- :tIDENTIFIER, "a", :expr_cmdarg,
1067
- :tGEQ, ">=", :expr_beg,
1068
- :tINTEGER, 2, :expr_end)
1069
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1070
+ :tGEQ, ">=", EXPR_BEG,
1071
+ :tINTEGER, 2, EXPR_NUM)
1069
1072
  end
1070
1073
 
1071
1074
  def test_yylex_global
1072
- assert_lex3("$blah", nil, :tGVAR, "$blah", :expr_end)
1075
+ assert_lex3("$blah", nil, :tGVAR, "$blah", EXPR_END)
1073
1076
  end
1074
1077
 
1075
1078
  def test_yylex_global_backref
1076
- self.lex_state = :expr_fname
1079
+ self.lex_state = EXPR_FNAME
1077
1080
 
1078
- assert_lex3("$`", nil, :tGVAR, "$`", :expr_end)
1081
+ assert_lex3("$`", nil, :tGVAR, "$`", EXPR_END)
1079
1082
  end
1080
1083
 
1081
1084
  def test_yylex_global_dash_nothing
1082
- assert_lex3("$- ", nil, :tGVAR, "$-", :expr_end)
1085
+ assert_lex3("$- ", nil, :tGVAR, "$-", EXPR_END)
1083
1086
  end
1084
1087
 
1085
1088
  def test_yylex_global_dash_something
1086
- assert_lex3("$-x", nil, :tGVAR, "$-x", :expr_end)
1089
+ assert_lex3("$-x", nil, :tGVAR, "$-x", EXPR_END)
1087
1090
  end
1088
1091
 
1089
1092
  def test_yylex_global_number
1090
- self.lex_state = :expr_fname
1093
+ self.lex_state = EXPR_FNAME
1091
1094
 
1092
- assert_lex3("$1", nil, :tGVAR, "$1", :expr_end)
1095
+ assert_lex3("$1", nil, :tGVAR, "$1", EXPR_END)
1093
1096
  end
1094
1097
 
1095
1098
  def test_yylex_global_number_big
1096
- self.lex_state = :expr_fname
1099
+ self.lex_state = EXPR_FNAME
1097
1100
 
1098
- assert_lex3("$1234", nil, :tGVAR, "$1234", :expr_end)
1101
+ assert_lex3("$1234", nil, :tGVAR, "$1234", EXPR_END)
1099
1102
  end
1100
1103
 
1101
1104
  def test_yylex_global_other
1102
1105
  assert_lex3("[$~, $*, $$, $?, $!, $@, $/, $\\, $;, $,, $., $=, $:, $<, $>, $\"]",
1103
1106
  nil,
1104
- :tLBRACK, "[", :expr_beg,
1105
- :tGVAR, "$~", :expr_end, :tCOMMA, ",", :expr_beg,
1106
- :tGVAR, "$*", :expr_end, :tCOMMA, ",", :expr_beg,
1107
- :tGVAR, "$$", :expr_end, :tCOMMA, ",", :expr_beg,
1108
- :tGVAR, "$?", :expr_end, :tCOMMA, ",", :expr_beg,
1109
- :tGVAR, "$!", :expr_end, :tCOMMA, ",", :expr_beg,
1110
- :tGVAR, "$@", :expr_end, :tCOMMA, ",", :expr_beg,
1111
- :tGVAR, "$/", :expr_end, :tCOMMA, ",", :expr_beg,
1112
- :tGVAR, "$\\", :expr_end, :tCOMMA, ",", :expr_beg,
1113
- :tGVAR, "$;", :expr_end, :tCOMMA, ",", :expr_beg,
1114
- :tGVAR, "$,", :expr_end, :tCOMMA, ",", :expr_beg,
1115
- :tGVAR, "$.", :expr_end, :tCOMMA, ",", :expr_beg,
1116
- :tGVAR, "$=", :expr_end, :tCOMMA, ",", :expr_beg,
1117
- :tGVAR, "$:", :expr_end, :tCOMMA, ",", :expr_beg,
1118
- :tGVAR, "$<", :expr_end, :tCOMMA, ",", :expr_beg,
1119
- :tGVAR, "$>", :expr_end, :tCOMMA, ",", :expr_beg,
1120
- :tGVAR, "$\"", :expr_end,
1121
- :tRBRACK, "]", :expr_endarg)
1107
+ :tLBRACK, "[", EXPR_PAR,
1108
+ :tGVAR, "$~", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1109
+ :tGVAR, "$*", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1110
+ :tGVAR, "$$", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1111
+ :tGVAR, "$?", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1112
+ :tGVAR, "$!", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1113
+ :tGVAR, "$@", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1114
+ :tGVAR, "$/", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1115
+ :tGVAR, "$\\", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1116
+ :tGVAR, "$;", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1117
+ :tGVAR, "$,", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1118
+ :tGVAR, "$.", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1119
+ :tGVAR, "$=", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1120
+ :tGVAR, "$:", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1121
+ :tGVAR, "$<", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1122
+ :tGVAR, "$>", EXPR_END, :tCOMMA, ",", EXPR_PAR,
1123
+ :tGVAR, "$\"", EXPR_END,
1124
+ :tRBRACK, "]", EXPR_ENDARG)
1122
1125
  end
1123
1126
 
1124
1127
  def test_yylex_global_underscore
1125
- assert_lex3("$_", nil, :tGVAR, "$_", :expr_end)
1128
+ assert_lex3("$_", nil, :tGVAR, "$_", EXPR_END)
1126
1129
  end
1127
1130
 
1128
1131
  def test_yylex_global_wierd
1129
- assert_lex3("$__blah", nil, :tGVAR, "$__blah", :expr_end)
1132
+ assert_lex3("$__blah", nil, :tGVAR, "$__blah", EXPR_END)
1130
1133
  end
1131
1134
 
1132
1135
  def test_yylex_global_zero
1133
- assert_lex3("$0", nil, :tGVAR, "$0", :expr_end)
1136
+ assert_lex3("$0", nil, :tGVAR, "$0", EXPR_END)
1134
1137
  end
1135
1138
 
1136
1139
  def test_yylex_gt
1137
1140
  assert_lex3("a > 2",
1138
1141
  nil,
1139
- :tIDENTIFIER, "a", :expr_cmdarg,
1140
- :tGT, ">", :expr_beg,
1141
- :tINTEGER, 2, :expr_end)
1142
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1143
+ :tGT, ">", EXPR_BEG,
1144
+ :tINTEGER, 2, EXPR_NUM)
1142
1145
  end
1143
1146
 
1144
1147
  def test_yylex_heredoc_backtick
1145
1148
  assert_lex3("a = <<`EOF`\n blah blah\nEOF\n\n",
1146
1149
  nil,
1147
- :tIDENTIFIER, "a", :expr_cmdarg,
1148
- :tEQL, "=", :expr_beg,
1149
- :tXSTRING_BEG, "`", :expr_beg,
1150
- :tSTRING_CONTENT, " blah blah\n", :expr_beg,
1151
- :tSTRING_END, "EOF", :expr_end,
1152
- :tNL, nil, :expr_beg)
1150
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1151
+ :tEQL, "=", EXPR_BEG,
1152
+ :tXSTRING_BEG, "`", EXPR_BEG,
1153
+ :tSTRING_CONTENT, " blah blah\n", EXPR_BEG,
1154
+ :tSTRING_END, "EOF", EXPR_END,
1155
+ :tNL, nil, EXPR_BEG)
1153
1156
  end
1154
1157
 
1155
1158
  def test_yylex_heredoc_double
1156
1159
  assert_lex3("a = <<\"EOF\"\n blah blah\nEOF\n\n",
1157
1160
  nil,
1158
- :tIDENTIFIER, "a", :expr_cmdarg,
1159
- :tEQL, "=", :expr_beg,
1160
- :tSTRING_BEG, "\"", :expr_beg,
1161
- :tSTRING_CONTENT, " blah blah\n", :expr_beg,
1162
- :tSTRING_END, "EOF", :expr_end,
1163
- :tNL, nil, :expr_beg)
1161
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1162
+ :tEQL, "=", EXPR_BEG,
1163
+ :tSTRING_BEG, "\"", EXPR_BEG,
1164
+ :tSTRING_CONTENT, " blah blah\n", EXPR_BEG,
1165
+ :tSTRING_END, "EOF", EXPR_END,
1166
+ :tNL, nil, EXPR_BEG)
1164
1167
  end
1165
1168
 
1166
1169
  def test_yylex_heredoc_double_dash
1167
1170
  assert_lex3("a = <<-\"EOF\"\n blah blah\n EOF\n\n",
1168
1171
  nil,
1169
- :tIDENTIFIER, "a", :expr_cmdarg,
1170
- :tEQL, "=", :expr_beg,
1171
- :tSTRING_BEG, "\"", :expr_beg,
1172
- :tSTRING_CONTENT, " blah blah\n", :expr_beg,
1173
- :tSTRING_END, "EOF", :expr_end,
1174
- :tNL, nil, :expr_beg)
1172
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1173
+ :tEQL, "=", EXPR_BEG,
1174
+ :tSTRING_BEG, "\"", EXPR_BEG,
1175
+ :tSTRING_CONTENT, " blah blah\n", EXPR_BEG,
1176
+ :tSTRING_END, "EOF", EXPR_END,
1177
+ :tNL, nil, EXPR_BEG)
1175
1178
  end
1176
1179
 
1177
1180
  def test_yylex_heredoc_double_squiggly
@@ -1179,12 +1182,12 @@ class TestRubyLexer < Minitest::Test
1179
1182
 
1180
1183
  assert_lex3("a = <<~\"EOF\"\n blah blah\n EOF\n\n",
1181
1184
  nil,
1182
- :tIDENTIFIER, "a", :expr_cmdarg,
1183
- :tEQL, "=", :expr_beg,
1184
- :tSTRING_BEG, "\"", :expr_beg,
1185
- :tSTRING_CONTENT, "blah blah\n", :expr_beg,
1186
- :tSTRING_END, "EOF", :expr_end,
1187
- :tNL, nil, :expr_beg)
1185
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1186
+ :tEQL, "=", EXPR_BEG,
1187
+ :tSTRING_BEG, "\"", EXPR_BEG,
1188
+ :tSTRING_CONTENT, "blah blah\n", EXPR_BEG,
1189
+ :tSTRING_END, "EOF", EXPR_END,
1190
+ :tNL, nil, EXPR_BEG)
1188
1191
  end
1189
1192
 
1190
1193
  # mri handles tabs in a pretty specific way:
@@ -1194,12 +1197,12 @@ class TestRubyLexer < Minitest::Test
1194
1197
 
1195
1198
  assert_lex3("a = <<~\"EOF\"\n blah blah\n \tblah blah\n EOF\n\n",
1196
1199
  nil,
1197
- :tIDENTIFIER, "a", :expr_cmdarg,
1198
- :tEQL, "=", :expr_beg,
1199
- :tSTRING_BEG, "\"", :expr_beg,
1200
- :tSTRING_CONTENT, "blah blah\n\tblah blah\n", :expr_beg,
1201
- :tSTRING_END, "EOF", :expr_end,
1202
- :tNL, nil, :expr_beg)
1200
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1201
+ :tEQL, "=", EXPR_BEG,
1202
+ :tSTRING_BEG, "\"", EXPR_BEG,
1203
+ :tSTRING_CONTENT, "blah blah\n\tblah blah\n", EXPR_BEG,
1204
+ :tSTRING_END, "EOF", EXPR_END,
1205
+ :tNL, nil, EXPR_BEG)
1203
1206
  end
1204
1207
 
1205
1208
  def test_yylex_heredoc_double_squiggly_with_tab_indentation_removed
@@ -1207,12 +1210,12 @@ class TestRubyLexer < Minitest::Test
1207
1210
 
1208
1211
  assert_lex3("a = <<~\"EOF\"\n blah blah\n\t blah blah\n EOF\n\n",
1209
1212
  nil,
1210
- :tIDENTIFIER, "a", :expr_cmdarg,
1211
- :tEQL, "=", :expr_beg,
1212
- :tSTRING_BEG, "\"", :expr_beg,
1213
- :tSTRING_CONTENT, "blah blah\n blah blah\n", :expr_beg,
1214
- :tSTRING_END, "EOF", :expr_end,
1215
- :tNL, nil, :expr_beg)
1213
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1214
+ :tEQL, "=", EXPR_BEG,
1215
+ :tSTRING_BEG, "\"", EXPR_BEG,
1216
+ :tSTRING_CONTENT, "blah blah\n blah blah\n", EXPR_BEG,
1217
+ :tSTRING_END, "EOF", EXPR_END,
1218
+ :tNL, nil, EXPR_BEG)
1216
1219
  end
1217
1220
 
1218
1221
  def test_yylex_heredoc_double_eos
@@ -1230,41 +1233,43 @@ class TestRubyLexer < Minitest::Test
1230
1233
  end
1231
1234
 
1232
1235
  def test_yylex_heredoc_double_interp
1233
- assert_lex3("a = <<\"EOF\"\n#x a \#@a b \#$b c \#{3} \nEOF\n\n",
1234
- nil,
1235
- :tIDENTIFIER, "a", :expr_cmdarg,
1236
- :tEQL, "=", :expr_beg,
1237
- :tSTRING_BEG, "\"", :expr_beg,
1238
- :tSTRING_CONTENT, "#x a ", :expr_beg,
1239
- :tSTRING_DVAR, "\#@", :expr_beg,
1240
- :tSTRING_CONTENT, "@a b ", :expr_beg, # HUH?
1241
- :tSTRING_DVAR, "\#$", :expr_beg,
1242
- :tSTRING_CONTENT, "$b c ", :expr_beg, # HUH?
1243
- :tSTRING_DBEG, "\#{", :expr_beg,
1244
- :tSTRING_CONTENT, "3} \n", :expr_beg, # HUH?
1245
- :tSTRING_END, "EOF", :expr_end,
1246
- :tNL, nil, :expr_beg)
1236
+ assert_lex3("a = <<\"EOF\"\n#x a \#@a b \#$b c \#@@d \#{3} \nEOF\n\n",
1237
+ nil,
1238
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1239
+ :tEQL, "=", EXPR_BEG,
1240
+ :tSTRING_BEG, "\"", EXPR_BEG,
1241
+ :tSTRING_CONTENT, "#x a ", EXPR_BEG,
1242
+ :tSTRING_DVAR, "\#@", EXPR_BEG,
1243
+ :tSTRING_CONTENT, "@a b ", EXPR_BEG, # HUH?
1244
+ :tSTRING_DVAR, "\#$", EXPR_BEG,
1245
+ :tSTRING_CONTENT, "$b c ", EXPR_BEG, # HUH?
1246
+ :tSTRING_DVAR, "\#@", EXPR_BEG,
1247
+ :tSTRING_CONTENT, "@@d ", EXPR_BEG, # HUH?
1248
+ :tSTRING_DBEG, "\#{", EXPR_BEG,
1249
+ :tSTRING_CONTENT, "3} \n", EXPR_BEG,
1250
+ :tSTRING_END, "EOF", EXPR_END,
1251
+ :tNL, nil, EXPR_BEG)
1247
1252
  end
1248
1253
 
1249
1254
  def test_yylex_heredoc_empty
1250
1255
  assert_lex3("<<\"\"\n\#{x}\nblah2\n\n\n",
1251
1256
  nil,
1252
- :tSTRING_BEG, "\"", :expr_beg,
1253
- :tSTRING_DBEG, "\#{", :expr_beg,
1254
- :tSTRING_CONTENT, "x}\nblah2\n", :expr_beg,
1255
- :tSTRING_END, "", :expr_end,
1256
- :tNL, nil, :expr_beg)
1257
+ :tSTRING_BEG, "\"", EXPR_BEG,
1258
+ :tSTRING_DBEG, "\#{", EXPR_BEG,
1259
+ :tSTRING_CONTENT, "x}\nblah2\n", EXPR_BEG,
1260
+ :tSTRING_END, "", EXPR_END,
1261
+ :tNL, nil, EXPR_BEG)
1257
1262
  end
1258
1263
 
1259
1264
  def test_yylex_heredoc_none
1260
1265
  assert_lex3("a = <<EOF\nblah\nblah\nEOF\n",
1261
1266
  nil,
1262
- :tIDENTIFIER, "a", :expr_cmdarg,
1263
- :tEQL, "=", :expr_beg,
1264
- :tSTRING_BEG, "\"", :expr_beg,
1265
- :tSTRING_CONTENT, "blah\nblah\n", :expr_beg,
1266
- :tSTRING_END, "EOF", :expr_end,
1267
- :tNL, nil, :expr_beg)
1267
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1268
+ :tEQL, "=", EXPR_BEG,
1269
+ :tSTRING_BEG, "\"", EXPR_BEG,
1270
+ :tSTRING_CONTENT, "blah\nblah\n", EXPR_BEG,
1271
+ :tSTRING_END, "EOF", EXPR_END,
1272
+ :tNL, nil, EXPR_BEG)
1268
1273
  end
1269
1274
 
1270
1275
  def test_yylex_heredoc_none_bad_eos
@@ -1277,12 +1282,12 @@ class TestRubyLexer < Minitest::Test
1277
1282
  def test_yylex_heredoc_none_dash
1278
1283
  assert_lex3("a = <<-EOF\nblah\nblah\n EOF\n",
1279
1284
  nil,
1280
- :tIDENTIFIER, "a", :expr_cmdarg,
1281
- :tEQL, "=", :expr_beg,
1282
- :tSTRING_BEG, "\"", :expr_beg,
1283
- :tSTRING_CONTENT, "blah\nblah\n", :expr_beg,
1284
- :tSTRING_END, "EOF", :expr_end,
1285
- :tNL, nil, :expr_beg)
1285
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1286
+ :tEQL, "=", EXPR_BEG,
1287
+ :tSTRING_BEG, "\"", EXPR_BEG,
1288
+ :tSTRING_CONTENT, "blah\nblah\n", EXPR_BEG,
1289
+ :tSTRING_END, "EOF", EXPR_END,
1290
+ :tNL, nil, EXPR_BEG)
1286
1291
  end
1287
1292
 
1288
1293
  def test_yylex_heredoc_none_squiggly
@@ -1290,23 +1295,23 @@ class TestRubyLexer < Minitest::Test
1290
1295
 
1291
1296
  assert_lex3("a = <<~EOF\n blah\n blah\n EOF\n",
1292
1297
  nil,
1293
- :tIDENTIFIER, "a", :expr_cmdarg,
1294
- :tEQL, "=", :expr_beg,
1295
- :tSTRING_BEG, "\"", :expr_beg,
1296
- :tSTRING_CONTENT, "blah\nblah\n", :expr_beg,
1297
- :tSTRING_END, "EOF", :expr_end,
1298
- :tNL, nil, :expr_beg)
1298
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1299
+ :tEQL, "=", EXPR_BEG,
1300
+ :tSTRING_BEG, "\"", EXPR_BEG,
1301
+ :tSTRING_CONTENT, "blah\nblah\n", EXPR_BEG,
1302
+ :tSTRING_END, "EOF", EXPR_END,
1303
+ :tNL, nil, EXPR_BEG)
1299
1304
  end
1300
1305
 
1301
1306
  def test_yylex_heredoc_single
1302
1307
  assert_lex3("a = <<'EOF'\n blah blah\nEOF\n\n",
1303
1308
  nil,
1304
- :tIDENTIFIER, "a", :expr_cmdarg,
1305
- :tEQL, "=", :expr_beg,
1306
- :tSTRING_BEG, "\"", :expr_beg,
1307
- :tSTRING_CONTENT, " blah blah\n", :expr_beg,
1308
- :tSTRING_END, "EOF", :expr_end,
1309
- :tNL, nil, :expr_beg)
1309
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1310
+ :tEQL, "=", EXPR_BEG,
1311
+ :tSTRING_BEG, "\"", EXPR_BEG,
1312
+ :tSTRING_CONTENT, " blah blah\n", EXPR_BEG,
1313
+ :tSTRING_END, "EOF", EXPR_END,
1314
+ :tNL, nil, EXPR_BEG)
1310
1315
  end
1311
1316
 
1312
1317
  def test_yylex_heredoc_single_bad_eos_body
@@ -1340,12 +1345,12 @@ class TestRubyLexer < Minitest::Test
1340
1345
  def test_yylex_heredoc_single_dash
1341
1346
  assert_lex3("a = <<-'EOF'\n blah blah\n EOF\n\n",
1342
1347
  nil,
1343
- :tIDENTIFIER, "a", :expr_cmdarg,
1344
- :tEQL, "=", :expr_beg,
1345
- :tSTRING_BEG, "\"", :expr_beg,
1346
- :tSTRING_CONTENT, " blah blah\n", :expr_beg,
1347
- :tSTRING_END, "EOF", :expr_end,
1348
- :tNL, nil, :expr_beg)
1348
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1349
+ :tEQL, "=", EXPR_BEG,
1350
+ :tSTRING_BEG, "\"", EXPR_BEG,
1351
+ :tSTRING_CONTENT, " blah blah\n", EXPR_BEG,
1352
+ :tSTRING_END, "EOF", EXPR_END,
1353
+ :tNL, nil, EXPR_BEG)
1349
1354
  end
1350
1355
 
1351
1356
  def test_yylex_heredoc_single_squiggly
@@ -1353,24 +1358,24 @@ class TestRubyLexer < Minitest::Test
1353
1358
 
1354
1359
  assert_lex3("a = <<~'EOF'\n blah blah\n EOF\n\n",
1355
1360
  nil,
1356
- :tIDENTIFIER, "a", :expr_cmdarg,
1357
- :tEQL, "=", :expr_beg,
1358
- :tSTRING_BEG, "\"", :expr_beg,
1359
- :tSTRING_CONTENT, "blah blah\n", :expr_beg,
1360
- :tSTRING_END, "EOF", :expr_end,
1361
- :tNL, nil, :expr_beg)
1361
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1362
+ :tEQL, "=", EXPR_BEG,
1363
+ :tSTRING_BEG, "\"", EXPR_BEG,
1364
+ :tSTRING_CONTENT, "blah blah\n", EXPR_BEG,
1365
+ :tSTRING_END, "EOF", EXPR_END,
1366
+ :tNL, nil, EXPR_BEG)
1362
1367
  end
1363
1368
 
1364
1369
  def test_yylex_identifier
1365
1370
  assert_lex3("identifier",
1366
1371
  nil,
1367
- :tIDENTIFIER, "identifier", :expr_cmdarg)
1372
+ :tIDENTIFIER, "identifier", EXPR_CMDARG)
1368
1373
  end
1369
1374
 
1370
1375
  def test_yylex_identifier_bang
1371
1376
  assert_lex3("identifier!",
1372
1377
  nil,
1373
- :tFID, "identifier!", :expr_cmdarg)
1378
+ :tFID, "identifier!", EXPR_CMDARG)
1374
1379
  end
1375
1380
 
1376
1381
  def test_yylex_identifier_cmp
@@ -1380,34 +1385,34 @@ class TestRubyLexer < Minitest::Test
1380
1385
  def test_yylex_identifier_def__20
1381
1386
  setup_lexer_class RubyParser::V20
1382
1387
 
1383
- assert_lex_fname "identifier", :tIDENTIFIER, :expr_endfn
1388
+ assert_lex_fname "identifier", :tIDENTIFIER, EXPR_ENDFN
1384
1389
  end
1385
1390
 
1386
1391
  def test_yylex_identifier_eh
1387
- assert_lex3("identifier?", nil, :tFID, "identifier?", :expr_cmdarg)
1392
+ assert_lex3("identifier?", nil, :tFID, "identifier?", EXPR_CMDARG)
1388
1393
  end
1389
1394
 
1390
1395
  def test_yylex_identifier_equals_arrow
1391
1396
  assert_lex3(":blah==>",
1392
1397
  nil,
1393
- :tSYMBOL, "blah=", :expr_end,
1394
- :tASSOC, "=>", :expr_beg)
1398
+ :tSYMBOL, "blah=", EXPR_END,
1399
+ :tASSOC, "=>", EXPR_BEG)
1395
1400
  end
1396
1401
 
1397
1402
  def test_yylex_identifier_equals3
1398
1403
  assert_lex3(":a===b",
1399
1404
  nil,
1400
- :tSYMBOL, "a", :expr_end,
1401
- :tEQQ, "===", :expr_beg,
1402
- :tIDENTIFIER, "b", :expr_arg)
1405
+ :tSYMBOL, "a", EXPR_END,
1406
+ :tEQQ, "===", EXPR_BEG,
1407
+ :tIDENTIFIER, "b", EXPR_ARG)
1403
1408
  end
1404
1409
 
1405
1410
  def test_yylex_identifier_equals_equals_arrow
1406
1411
  assert_lex3(":a==>b",
1407
1412
  nil,
1408
- :tSYMBOL, "a=", :expr_end,
1409
- :tASSOC, "=>", :expr_beg,
1410
- :tIDENTIFIER, "b", :expr_arg)
1413
+ :tSYMBOL, "a=", EXPR_END,
1414
+ :tASSOC, "=>", EXPR_BEG,
1415
+ :tIDENTIFIER, "b", EXPR_ARG)
1411
1416
  end
1412
1417
 
1413
1418
  def test_yylex_identifier_equals_caret
@@ -1417,7 +1422,7 @@ class TestRubyLexer < Minitest::Test
1417
1422
  def test_yylex_identifier_equals_def__20
1418
1423
  setup_lexer_class RubyParser::V20
1419
1424
 
1420
- assert_lex_fname "identifier=", :tIDENTIFIER, :expr_endfn
1425
+ assert_lex_fname "identifier=", :tIDENTIFIER, EXPR_ENDFN
1421
1426
  end
1422
1427
 
1423
1428
  def test_yylex_identifier_equals_def2
@@ -1425,12 +1430,12 @@ class TestRubyLexer < Minitest::Test
1425
1430
  end
1426
1431
 
1427
1432
  def test_yylex_identifier_equals_expr
1428
- self.lex_state = :expr_dot
1433
+ self.lex_state = EXPR_DOT
1429
1434
  assert_lex3("y = arg",
1430
1435
  nil,
1431
- :tIDENTIFIER, "y", :expr_cmdarg,
1432
- :tEQL, "=", :expr_beg,
1433
- :tIDENTIFIER, "arg", :expr_arg)
1436
+ :tIDENTIFIER, "y", EXPR_CMDARG,
1437
+ :tEQL, "=", EXPR_BEG,
1438
+ :tIDENTIFIER, "arg", EXPR_ARG)
1434
1439
  end
1435
1440
 
1436
1441
  def test_yylex_identifier_equals_or
@@ -1442,12 +1447,12 @@ class TestRubyLexer < Minitest::Test
1442
1447
  end
1443
1448
 
1444
1449
  def test_yylex_identifier_equals_tilde
1445
- self.lex_state = :expr_fname # can only set via parser's defs
1450
+ self.lex_state = EXPR_FNAME # can only set via parser's defs
1446
1451
 
1447
1452
  assert_lex3("identifier=~",
1448
1453
  nil,
1449
- :tIDENTIFIER, "identifier", :expr_endfn,
1450
- :tMATCH, "=~", :expr_beg)
1454
+ :tIDENTIFIER, "identifier", EXPR_ENDFN,
1455
+ :tMATCH, "=~", EXPR_BEG)
1451
1456
  end
1452
1457
 
1453
1458
  def test_yylex_identifier_gt
@@ -1475,11 +1480,11 @@ class TestRubyLexer < Minitest::Test
1475
1480
  end
1476
1481
 
1477
1482
  def test_yylex_integer
1478
- assert_lex3("42", nil, :tINTEGER, 42, :expr_end)
1483
+ assert_lex3("42", nil, :tINTEGER, 42, EXPR_NUM)
1479
1484
  end
1480
1485
 
1481
1486
  def test_yylex_integer_bin
1482
- assert_lex3("0b101010", nil, :tINTEGER, 42, :expr_end)
1487
+ assert_lex3("0b101010", nil, :tINTEGER, 42, EXPR_NUM)
1483
1488
  end
1484
1489
 
1485
1490
  def test_yylex_integer_bin_bad_none
@@ -1491,7 +1496,7 @@ class TestRubyLexer < Minitest::Test
1491
1496
  end
1492
1497
 
1493
1498
  def test_yylex_integer_dec
1494
- assert_lex3("42", nil, :tINTEGER, 42, :expr_end)
1499
+ assert_lex3("42", nil, :tINTEGER, 42, EXPR_NUM)
1495
1500
  end
1496
1501
 
1497
1502
  def test_yylex_integer_dec_bad_underscores
@@ -1499,7 +1504,7 @@ class TestRubyLexer < Minitest::Test
1499
1504
  end
1500
1505
 
1501
1506
  def test_yylex_integer_dec_d
1502
- assert_lex3("0d42", nil, :tINTEGER, 42, :expr_end)
1507
+ assert_lex3("0d42", nil, :tINTEGER, 42, EXPR_NUM)
1503
1508
  end
1504
1509
 
1505
1510
  def test_yylex_integer_dec_d_bad_none
@@ -1513,24 +1518,24 @@ class TestRubyLexer < Minitest::Test
1513
1518
  def test_yylex_integer_if_modifier
1514
1519
  assert_lex3("123if",
1515
1520
  nil,
1516
- :tINTEGER, 123, :expr_end,
1517
- :kIF_MOD, "if", :expr_beg)
1521
+ :tINTEGER, 123, EXPR_NUM,
1522
+ :kIF_MOD, "if", EXPR_PAR)
1518
1523
  end
1519
1524
 
1520
1525
  def test_yylex_question_eh_a__20
1521
1526
  setup_lexer_class RubyParser::V20
1522
1527
 
1523
- assert_lex3("?a", nil, :tSTRING, "a", :expr_end)
1528
+ assert_lex3("?a", nil, :tSTRING, "a", EXPR_END)
1524
1529
  end
1525
1530
 
1526
1531
  def test_yylex_question_eh_escape_M_escape_C__20
1527
1532
  setup_lexer_class RubyParser::V20
1528
1533
 
1529
- assert_lex3("?\\M-\\C-a", nil, :tSTRING, "\M-\C-a", :expr_end)
1534
+ assert_lex3("?\\M-\\C-a", nil, :tSTRING, "\M-\C-a", EXPR_END)
1530
1535
  end
1531
1536
 
1532
1537
  def test_yylex_integer_hex
1533
- assert_lex3 "0x2a", nil, :tINTEGER, 42, :expr_end
1538
+ assert_lex3 "0x2a", nil, :tINTEGER, 42, EXPR_NUM
1534
1539
  end
1535
1540
 
1536
1541
  def test_yylex_integer_hex_bad_none
@@ -1542,7 +1547,7 @@ class TestRubyLexer < Minitest::Test
1542
1547
  end
1543
1548
 
1544
1549
  def test_yylex_integer_oct
1545
- assert_lex3("052", nil, :tINTEGER, 42, :expr_end)
1550
+ assert_lex3("052", nil, :tINTEGER, 42, EXPR_NUM)
1546
1551
  end
1547
1552
 
1548
1553
  def test_yylex_integer_oct_bad_range
@@ -1558,7 +1563,7 @@ class TestRubyLexer < Minitest::Test
1558
1563
  end
1559
1564
 
1560
1565
  def test_yylex_integer_oct_O
1561
- assert_lex3 "0O52", nil, :tINTEGER, 42, :expr_end
1566
+ assert_lex3 "0O52", nil, :tINTEGER, 42, EXPR_NUM
1562
1567
  end
1563
1568
 
1564
1569
  def test_yylex_integer_oct_O_bad_range
@@ -1570,11 +1575,11 @@ class TestRubyLexer < Minitest::Test
1570
1575
  end
1571
1576
 
1572
1577
  def test_yylex_integer_oct_O_not_bad_none
1573
- assert_lex3 "0O ", nil, :tINTEGER, 0, :expr_end
1578
+ assert_lex3 "0O ", nil, :tINTEGER, 0, EXPR_NUM
1574
1579
  end
1575
1580
 
1576
1581
  def test_yylex_integer_oct_o
1577
- assert_lex3 "0o52", nil, :tINTEGER, 42, :expr_end
1582
+ assert_lex3 "0o52", nil, :tINTEGER, 42, EXPR_NUM
1578
1583
  end
1579
1584
 
1580
1585
  def test_yylex_integer_oct_o_bad_range
@@ -1586,19 +1591,19 @@ class TestRubyLexer < Minitest::Test
1586
1591
  end
1587
1592
 
1588
1593
  def test_yylex_integer_oct_o_not_bad_none
1589
- assert_lex3 "0o ", nil, :tINTEGER, 0, :expr_end
1594
+ assert_lex3 "0o ", nil, :tINTEGER, 0, EXPR_NUM
1590
1595
  end
1591
1596
 
1592
1597
  def test_yylex_integer_trailing
1593
1598
  assert_lex3("1.to_s",
1594
1599
  nil,
1595
- :tINTEGER, 1, :expr_end,
1596
- :tDOT, ".", :expr_dot,
1597
- :tIDENTIFIER, "to_s", :expr_arg)
1600
+ :tINTEGER, 1, EXPR_NUM,
1601
+ :tDOT, ".", EXPR_DOT,
1602
+ :tIDENTIFIER, "to_s", EXPR_ARG)
1598
1603
  end
1599
1604
 
1600
1605
  def test_yylex_integer_underscore
1601
- assert_lex3("4_2", nil, :tINTEGER, 42, :expr_end)
1606
+ assert_lex3("4_2", nil, :tINTEGER, 42, EXPR_NUM)
1602
1607
  end
1603
1608
 
1604
1609
  def test_yylex_integer_underscore_bad
@@ -1606,11 +1611,11 @@ class TestRubyLexer < Minitest::Test
1606
1611
  end
1607
1612
 
1608
1613
  def test_yylex_integer_zero
1609
- assert_lex3 "0", nil, :tINTEGER, 0, :expr_end
1614
+ assert_lex3 "0", nil, :tINTEGER, 0, EXPR_NUM
1610
1615
  end
1611
1616
 
1612
1617
  def test_yylex_ivar
1613
- assert_lex3("@blah", nil, :tIVAR, "@blah", :expr_end)
1618
+ assert_lex3("@blah", nil, :tIVAR, "@blah", EXPR_END)
1614
1619
  end
1615
1620
 
1616
1621
  def test_yylex_ivar_bad
@@ -1618,237 +1623,237 @@ class TestRubyLexer < Minitest::Test
1618
1623
  end
1619
1624
 
1620
1625
  def test_yylex_ivar_bad_0_length
1621
- refute_lex "1+@\n", :tINTEGER, 1, :tPLUS, "+", :expr_end
1626
+ refute_lex "1+@\n", :tINTEGER, 1, :tPLUS, "+", EXPR_NUM
1622
1627
  end
1623
1628
 
1624
1629
  def test_yylex_keyword_expr
1625
- self.lex_state = :expr_endarg
1630
+ self.lex_state = EXPR_ENDARG
1626
1631
 
1627
- assert_lex3("if", nil, :kIF_MOD, "if", :expr_beg)
1632
+ assert_lex3("if", nil, :kIF_MOD, "if", EXPR_PAR)
1628
1633
  end
1629
1634
 
1630
1635
  def test_yylex_lt
1631
- assert_lex3("<", nil, :tLT, "<", :expr_beg)
1636
+ assert_lex3("<", nil, :tLT, "<", EXPR_BEG)
1632
1637
  end
1633
1638
 
1634
1639
  def test_yylex_lt2
1635
1640
  assert_lex3("a << b",
1636
1641
  nil,
1637
- :tIDENTIFIER, "a", :expr_cmdarg,
1638
- :tLSHFT, "<<", :expr_beg,
1639
- :tIDENTIFIER, "b", :expr_arg)
1642
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1643
+ :tLSHFT, "<<", EXPR_BEG,
1644
+ :tIDENTIFIER, "b", EXPR_ARG)
1640
1645
  end
1641
1646
 
1642
1647
  def test_yylex_lt2_equals
1643
1648
  assert_lex3("a <<= b",
1644
1649
  nil,
1645
- :tIDENTIFIER, "a", :expr_cmdarg,
1646
- :tOP_ASGN, "<<", :expr_beg,
1647
- :tIDENTIFIER, "b", :expr_arg)
1650
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1651
+ :tOP_ASGN, "<<", EXPR_BEG,
1652
+ :tIDENTIFIER, "b", EXPR_ARG)
1648
1653
  end
1649
1654
 
1650
1655
  def test_yylex_lt_equals
1651
- assert_lex3("<=", nil, :tLEQ, "<=", :expr_beg)
1656
+ assert_lex3("<=", nil, :tLEQ, "<=", EXPR_BEG)
1652
1657
  end
1653
1658
 
1654
1659
  def test_yylex_minus
1655
1660
  assert_lex3("1 - 2",
1656
1661
  nil,
1657
- :tINTEGER, 1, :expr_end,
1658
- :tMINUS, "-", :expr_beg,
1659
- :tINTEGER, 2, :expr_end)
1662
+ :tINTEGER, 1, EXPR_NUM,
1663
+ :tMINUS, "-", EXPR_BEG,
1664
+ :tINTEGER, 2, EXPR_NUM)
1660
1665
  end
1661
1666
 
1662
1667
  def test_yylex_minus_equals
1663
- assert_lex3("-=", nil, :tOP_ASGN, "-", :expr_beg)
1668
+ assert_lex3("-=", nil, :tOP_ASGN, "-", EXPR_BEG)
1664
1669
  end
1665
1670
 
1666
1671
  def test_yylex_minus_method
1667
- self.lex_state = :expr_fname
1672
+ self.lex_state = EXPR_FNAME
1668
1673
 
1669
- assert_lex3("-", nil, :tMINUS, "-", :expr_arg)
1674
+ assert_lex3("-", nil, :tMINUS, "-", EXPR_ARG)
1670
1675
  end
1671
1676
 
1672
1677
  def test_yylex_minus_unary_method
1673
- self.lex_state = :expr_fname
1678
+ self.lex_state = EXPR_FNAME
1674
1679
 
1675
- assert_lex3("-@", nil, :tUMINUS, "-@", :expr_arg)
1680
+ assert_lex3("-@", nil, :tUMINUS, "-@", EXPR_ARG)
1676
1681
  end
1677
1682
 
1678
1683
  def test_yylex_minus_unary_number
1679
1684
  assert_lex3("-42",
1680
1685
  nil,
1681
- :tUMINUS_NUM, "-", :expr_beg,
1682
- :tINTEGER, 42, :expr_end)
1686
+ :tUMINUS_NUM, "-", EXPR_BEG,
1687
+ :tINTEGER, 42, EXPR_NUM)
1683
1688
  end
1684
1689
 
1685
1690
  def test_yylex_nth_ref
1686
1691
  assert_lex3("[$1, $2, $3, $4, $5, $6, $7, $8, $9]",
1687
1692
  nil,
1688
- :tLBRACK, "[", :expr_beg,
1689
- :tNTH_REF, 1, :expr_end, :tCOMMA, ",", :expr_beg,
1690
- :tNTH_REF, 2, :expr_end, :tCOMMA, ",", :expr_beg,
1691
- :tNTH_REF, 3, :expr_end, :tCOMMA, ",", :expr_beg,
1692
- :tNTH_REF, 4, :expr_end, :tCOMMA, ",", :expr_beg,
1693
- :tNTH_REF, 5, :expr_end, :tCOMMA, ",", :expr_beg,
1694
- :tNTH_REF, 6, :expr_end, :tCOMMA, ",", :expr_beg,
1695
- :tNTH_REF, 7, :expr_end, :tCOMMA, ",", :expr_beg,
1696
- :tNTH_REF, 8, :expr_end, :tCOMMA, ",", :expr_beg,
1697
- :tNTH_REF, 9, :expr_end,
1698
- :tRBRACK, "]", :expr_endarg)
1693
+ :tLBRACK, "[", EXPR_PAR,
1694
+ :tNTH_REF, 1, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1695
+ :tNTH_REF, 2, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1696
+ :tNTH_REF, 3, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1697
+ :tNTH_REF, 4, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1698
+ :tNTH_REF, 5, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1699
+ :tNTH_REF, 6, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1700
+ :tNTH_REF, 7, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1701
+ :tNTH_REF, 8, EXPR_END, :tCOMMA, ",", EXPR_PAR,
1702
+ :tNTH_REF, 9, EXPR_END,
1703
+ :tRBRACK, "]", EXPR_ENDARG)
1699
1704
  end
1700
1705
 
1701
1706
  def test_yylex_open_bracket
1702
- assert_lex3("(", nil, :tLPAREN, "(", :expr_beg)
1707
+ assert_lex3("(", nil, :tLPAREN, "(", EXPR_PAR)
1703
1708
  end
1704
1709
 
1705
1710
  def test_yylex_open_bracket_cmdarg
1706
- self.lex_state = :expr_cmdarg
1711
+ self.lex_state = EXPR_CMDARG
1707
1712
 
1708
- assert_lex3(" (", nil, :tLPAREN_ARG, "(", :expr_beg)
1713
+ assert_lex3(" (", nil, :tLPAREN_ARG, "(", EXPR_PAR)
1709
1714
  end
1710
1715
 
1711
1716
  def test_yylex_open_bracket_exprarg__20
1712
1717
  setup_lexer_class RubyParser::V20
1713
- self.lex_state = :expr_arg
1718
+ self.lex_state = EXPR_ARG
1714
1719
 
1715
- assert_lex3(" (", nil, :tLPAREN_ARG, "(", :expr_beg)
1720
+ assert_lex3(" (", nil, :tLPAREN_ARG, "(", EXPR_PAR)
1716
1721
  end
1717
1722
 
1718
1723
  def test_yylex_open_curly_bracket
1719
- assert_lex3("{", nil, :tLBRACE, "{", :expr_beg)
1724
+ assert_lex3("{", nil, :tLBRACE, "{", EXPR_PAR)
1720
1725
  end
1721
1726
 
1722
1727
  def test_yylex_open_curly_bracket_arg
1723
- self.lex_state = :expr_arg
1728
+ self.lex_state = EXPR_ARG
1724
1729
 
1725
1730
  assert_lex3("m { 3 }",
1726
1731
  nil,
1727
- :tIDENTIFIER, "m", :expr_cmdarg,
1728
- :tLCURLY, "{", :expr_beg,
1729
- :tINTEGER, 3, :expr_end,
1730
- :tRCURLY, "}", :expr_endarg)
1732
+ :tIDENTIFIER, "m", EXPR_CMDARG,
1733
+ :tLCURLY, "{", EXPR_PAR,
1734
+ :tINTEGER, 3, EXPR_NUM,
1735
+ :tRCURLY, "}", EXPR_ENDARG)
1731
1736
  end
1732
1737
 
1733
1738
  def test_yylex_open_curly_bracket_block
1734
- self.lex_state = :expr_endarg # seen m(3)
1739
+ self.lex_state = EXPR_ENDARG # seen m(3)
1735
1740
 
1736
1741
  assert_lex3("{ 4 }",
1737
1742
  nil,
1738
- :tLBRACE_ARG, "{", :expr_beg,
1739
- :tINTEGER, 4, :expr_end,
1740
- :tRCURLY, "}", :expr_endarg)
1743
+ :tLBRACE_ARG, "{", EXPR_BEG,
1744
+ :tINTEGER, 4, EXPR_NUM,
1745
+ :tRCURLY, "}", EXPR_ENDARG)
1741
1746
  end
1742
1747
 
1743
1748
  def test_yylex_open_square_bracket_arg
1744
- self.lex_state = :expr_arg
1749
+ self.lex_state = EXPR_ARG
1745
1750
 
1746
1751
  assert_lex3("m [ 3 ]",
1747
1752
  nil,
1748
- :tIDENTIFIER, "m", :expr_cmdarg,
1749
- :tLBRACK, "[", :expr_beg,
1750
- :tINTEGER, 3, :expr_end,
1751
- :tRBRACK, "]", :expr_endarg)
1753
+ :tIDENTIFIER, "m", EXPR_CMDARG,
1754
+ :tLBRACK, "[", EXPR_PAR,
1755
+ :tINTEGER, 3, EXPR_NUM,
1756
+ :tRBRACK, "]", EXPR_ENDARG)
1752
1757
  end
1753
1758
 
1754
1759
  def test_yylex_open_square_bracket_ary
1755
1760
  assert_lex3("[1, 2, 3]",
1756
1761
  nil,
1757
- :tLBRACK, "[", :expr_beg,
1758
- :tINTEGER, 1, :expr_end, :tCOMMA, ",", :expr_beg,
1759
- :tINTEGER, 2, :expr_end, :tCOMMA, ",", :expr_beg,
1760
- :tINTEGER, 3, :expr_end,
1761
- :tRBRACK, "]", :expr_endarg)
1762
+ :tLBRACK, "[", EXPR_PAR,
1763
+ :tINTEGER, 1, EXPR_NUM, :tCOMMA, ",", EXPR_PAR,
1764
+ :tINTEGER, 2, EXPR_NUM, :tCOMMA, ",", EXPR_PAR,
1765
+ :tINTEGER, 3, EXPR_NUM,
1766
+ :tRBRACK, "]", EXPR_ENDARG)
1762
1767
  end
1763
1768
 
1764
1769
  def test_yylex_open_square_bracket_meth
1765
1770
  assert_lex3("m[3]",
1766
1771
  nil,
1767
- :tIDENTIFIER, "m", :expr_cmdarg,
1768
- :tLBRACK2, "[", :expr_beg,
1769
- :tINTEGER, 3, :expr_end,
1770
- :tRBRACK, "]", :expr_endarg)
1772
+ :tIDENTIFIER, "m", EXPR_CMDARG,
1773
+ :tLBRACK2, "[", EXPR_PAR,
1774
+ :tINTEGER, 3, EXPR_NUM,
1775
+ :tRBRACK, "]", EXPR_ENDARG)
1771
1776
  end
1772
1777
 
1773
1778
  def test_yylex_or
1774
- assert_lex3("|", nil, :tPIPE, "|", :expr_beg)
1779
+ assert_lex3("|", nil, :tPIPE, "|", EXPR_PAR)
1775
1780
  end
1776
1781
 
1777
1782
  def test_yylex_or2
1778
- assert_lex3("||", nil, :tOROP, "||", :expr_beg)
1783
+ assert_lex3("||", nil, :tOROP, "||", EXPR_BEG)
1779
1784
  end
1780
1785
 
1781
1786
  def test_yylex_or2_equals
1782
- assert_lex3("||=", nil, :tOP_ASGN, "||", :expr_beg)
1787
+ assert_lex3("||=", nil, :tOP_ASGN, "||", EXPR_BEG)
1783
1788
  end
1784
1789
 
1785
1790
  def test_yylex_or_equals
1786
- assert_lex3("|=", nil, :tOP_ASGN, "|", :expr_beg)
1791
+ assert_lex3("|=", nil, :tOP_ASGN, "|", EXPR_BEG)
1787
1792
  end
1788
1793
 
1789
1794
  def test_yylex_percent
1790
1795
  assert_lex3("a % 2",
1791
1796
  nil,
1792
- :tIDENTIFIER, "a", :expr_cmdarg,
1793
- :tPERCENT, "%", :expr_beg,
1794
- :tINTEGER, 2, :expr_end)
1797
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1798
+ :tPERCENT, "%", EXPR_BEG,
1799
+ :tINTEGER, 2, EXPR_NUM)
1795
1800
  end
1796
1801
 
1797
1802
  def test_yylex_percent_equals
1798
1803
  assert_lex3("a %= 2",
1799
1804
  nil,
1800
- :tIDENTIFIER, "a", :expr_cmdarg,
1801
- :tOP_ASGN, "%", :expr_beg,
1802
- :tINTEGER, 2, :expr_end)
1805
+ :tIDENTIFIER, "a", EXPR_CMDARG,
1806
+ :tOP_ASGN, "%", EXPR_BEG,
1807
+ :tINTEGER, 2, EXPR_NUM)
1803
1808
  end
1804
1809
 
1805
1810
  def test_yylex_plus
1806
1811
  assert_lex3("1 + 1", # TODO lex_state?
1807
1812
  nil,
1808
- :tINTEGER, 1, :expr_end,
1809
- :tPLUS, "+", :expr_beg,
1810
- :tINTEGER, 1, :expr_end)
1813
+ :tINTEGER, 1, EXPR_NUM,
1814
+ :tPLUS, "+", EXPR_BEG,
1815
+ :tINTEGER, 1, EXPR_NUM)
1811
1816
  end
1812
1817
 
1813
1818
  def test_yylex_plus_equals
1814
- assert_lex3("+=", nil, :tOP_ASGN, "+", :expr_beg)
1819
+ assert_lex3("+=", nil, :tOP_ASGN, "+", EXPR_BEG)
1815
1820
  end
1816
1821
 
1817
1822
  def test_yylex_plus_method
1818
- self.lex_state = :expr_fname
1823
+ self.lex_state = EXPR_FNAME
1819
1824
 
1820
- assert_lex3("+", nil, :tPLUS, "+", :expr_arg)
1825
+ assert_lex3("+", nil, :tPLUS, "+", EXPR_ARG)
1821
1826
  end
1822
1827
 
1823
1828
  def test_yylex_plus_unary_method
1824
- self.lex_state = :expr_fname
1829
+ self.lex_state = EXPR_FNAME
1825
1830
 
1826
- assert_lex3("+@", nil, :tUPLUS, "+@", :expr_arg)
1831
+ assert_lex3("+@", nil, :tUPLUS, "+@", EXPR_ARG)
1827
1832
  end
1828
1833
 
1829
1834
  def test_yylex_not_unary_method
1830
- self.lex_state = :expr_fname
1835
+ self.lex_state = EXPR_FNAME
1831
1836
 
1832
- assert_lex3("!@", nil, :tUBANG, "!@", :expr_arg)
1837
+ assert_lex3("!@", nil, :tUBANG, "!@", EXPR_ARG)
1833
1838
  end
1834
1839
 
1835
1840
  def test_yylex_numbers
1836
- assert_lex3("0b10", nil, :tINTEGER, 2, :expr_end)
1837
- assert_lex3("0B10", nil, :tINTEGER, 2, :expr_end)
1841
+ assert_lex3("0b10", nil, :tINTEGER, 2, EXPR_NUM)
1842
+ assert_lex3("0B10", nil, :tINTEGER, 2, EXPR_NUM)
1838
1843
 
1839
- assert_lex3("0d10", nil, :tINTEGER, 10, :expr_end)
1840
- assert_lex3("0D10", nil, :tINTEGER, 10, :expr_end)
1844
+ assert_lex3("0d10", nil, :tINTEGER, 10, EXPR_NUM)
1845
+ assert_lex3("0D10", nil, :tINTEGER, 10, EXPR_NUM)
1841
1846
 
1842
- assert_lex3("0x10", nil, :tINTEGER, 16, :expr_end)
1843
- assert_lex3("0X10", nil, :tINTEGER, 16, :expr_end)
1847
+ assert_lex3("0x10", nil, :tINTEGER, 16, EXPR_NUM)
1848
+ assert_lex3("0X10", nil, :tINTEGER, 16, EXPR_NUM)
1844
1849
 
1845
- assert_lex3("0o10", nil, :tINTEGER, 8, :expr_end)
1846
- assert_lex3("0O10", nil, :tINTEGER, 8, :expr_end)
1850
+ assert_lex3("0o10", nil, :tINTEGER, 8, EXPR_NUM)
1851
+ assert_lex3("0O10", nil, :tINTEGER, 8, EXPR_NUM)
1847
1852
 
1848
- assert_lex3("0o", nil, :tINTEGER, 0, :expr_end)
1849
- assert_lex3("0O", nil, :tINTEGER, 0, :expr_end)
1853
+ assert_lex3("0o", nil, :tINTEGER, 0, EXPR_NUM)
1854
+ assert_lex3("0O", nil, :tINTEGER, 0, EXPR_NUM)
1850
1855
 
1851
- assert_lex3("0", nil, :tINTEGER, 0, :expr_end)
1856
+ assert_lex3("0", nil, :tINTEGER, 0, EXPR_NUM)
1852
1857
 
1853
1858
  refute_lex "0x"
1854
1859
  refute_lex "0X"
@@ -1870,7 +1875,7 @@ class TestRubyLexer < Minitest::Test
1870
1875
  end
1871
1876
 
1872
1877
  def test_yylex_plus_unary_number
1873
- assert_lex3("+42", nil, :tINTEGER, 42, :expr_end)
1878
+ assert_lex3("+42", nil, :tINTEGER, 42, EXPR_NUM)
1874
1879
  end
1875
1880
 
1876
1881
  def test_yylex_question_bad_eos
@@ -1878,31 +1883,31 @@ class TestRubyLexer < Minitest::Test
1878
1883
  end
1879
1884
 
1880
1885
  def test_yylex_question_ws
1881
- assert_lex3("? ", nil, :tEH, "?", :expr_value)
1882
- assert_lex3("?\n", nil, :tEH, "?", :expr_value)
1883
- assert_lex3("?\t", nil, :tEH, "?", :expr_value)
1884
- assert_lex3("?\v", nil, :tEH, "?", :expr_value)
1885
- assert_lex3("?\r", nil, :tEH, "?", :expr_value)
1886
- assert_lex3("?\f", nil, :tEH, "?", :expr_value)
1886
+ assert_lex3("? ", nil, :tEH, "?", EXPR_BEG)
1887
+ assert_lex3("?\n", nil, :tEH, "?", EXPR_BEG)
1888
+ assert_lex3("?\t", nil, :tEH, "?", EXPR_BEG)
1889
+ assert_lex3("?\v", nil, :tEH, "?", EXPR_BEG)
1890
+ assert_lex3("?\r", nil, :tEH, "?", EXPR_BEG)
1891
+ assert_lex3("?\f", nil, :tEH, "?", EXPR_BEG)
1887
1892
  end
1888
1893
 
1889
1894
  def test_yylex_question_ws_backslashed__20
1890
1895
  setup_lexer_class RubyParser::V20
1891
1896
 
1892
- assert_lex3("?\\ ", nil, :tSTRING, " ", :expr_end)
1893
- assert_lex3("?\\n", nil, :tSTRING, "\n", :expr_end)
1894
- assert_lex3("?\\t", nil, :tSTRING, "\t", :expr_end)
1895
- assert_lex3("?\\v", nil, :tSTRING, "\v", :expr_end)
1896
- assert_lex3("?\\r", nil, :tSTRING, "\r", :expr_end)
1897
- assert_lex3("?\\f", nil, :tSTRING, "\f", :expr_end)
1897
+ assert_lex3("?\\ ", nil, :tSTRING, " ", EXPR_END)
1898
+ assert_lex3("?\\n", nil, :tSTRING, "\n", EXPR_END)
1899
+ assert_lex3("?\\t", nil, :tSTRING, "\t", EXPR_END)
1900
+ assert_lex3("?\\v", nil, :tSTRING, "\v", EXPR_END)
1901
+ assert_lex3("?\\r", nil, :tSTRING, "\r", EXPR_END)
1902
+ assert_lex3("?\\f", nil, :tSTRING, "\f", EXPR_END)
1898
1903
  end
1899
1904
 
1900
1905
  def test_yylex_rbracket
1901
- assert_lex3("]", nil, :tRBRACK, "]", :expr_endarg)
1906
+ assert_lex3("]", nil, :tRBRACK, "]", EXPR_ENDARG)
1902
1907
  end
1903
1908
 
1904
1909
  def test_yylex_rcurly
1905
- assert_lex("}", nil, :tRCURLY, "}", :expr_endarg, 0, 1) do
1910
+ assert_lex("}", nil, :tRCURLY, "}", EXPR_ENDARG, 0, 1) do
1906
1911
  lexer.brace_nest += 2
1907
1912
  end
1908
1913
  end
@@ -1910,18 +1915,18 @@ class TestRubyLexer < Minitest::Test
1910
1915
  def test_yylex_regexp
1911
1916
  assert_lex3("/regexp/",
1912
1917
  nil,
1913
- :tREGEXP_BEG, "/", :expr_beg,
1914
- :tSTRING_CONTENT, "regexp", :expr_beg,
1915
- :tREGEXP_END, "", :expr_end)
1918
+ :tREGEXP_BEG, "/", EXPR_BEG,
1919
+ :tSTRING_CONTENT, "regexp", EXPR_BEG,
1920
+ :tREGEXP_END, "", EXPR_END)
1916
1921
  end
1917
1922
 
1918
1923
  def test_yylex_regexp_ambiguous
1919
1924
  assert_lex3("method /regexp/",
1920
1925
  nil,
1921
- :tIDENTIFIER, "method", :expr_cmdarg,
1922
- :tREGEXP_BEG, "/", :expr_cmdarg,
1923
- :tSTRING_CONTENT, "regexp", :expr_cmdarg,
1924
- :tREGEXP_END, "", :expr_end)
1926
+ :tIDENTIFIER, "method", EXPR_CMDARG,
1927
+ :tREGEXP_BEG, "/", EXPR_CMDARG,
1928
+ :tSTRING_CONTENT, "regexp", EXPR_CMDARG,
1929
+ :tREGEXP_END, "", EXPR_END)
1925
1930
  end
1926
1931
 
1927
1932
  def test_yylex_regexp_bad
@@ -1933,25 +1938,25 @@ class TestRubyLexer < Minitest::Test
1933
1938
  def test_yylex_regexp_escape_C
1934
1939
  assert_lex3("/regex\\C-x/",
1935
1940
  nil,
1936
- :tREGEXP_BEG, "/", :expr_beg,
1937
- :tSTRING_CONTENT, "regex\\C-x", :expr_beg,
1938
- :tREGEXP_END, "", :expr_end)
1941
+ :tREGEXP_BEG, "/", EXPR_BEG,
1942
+ :tSTRING_CONTENT, "regex\\C-x", EXPR_BEG,
1943
+ :tREGEXP_END, "", EXPR_END)
1939
1944
  end
1940
1945
 
1941
1946
  def test_yylex_regexp_escape_C_M
1942
1947
  assert_lex3("/regex\\C-\\M-x/",
1943
1948
  nil,
1944
- :tREGEXP_BEG, "/", :expr_beg,
1945
- :tSTRING_CONTENT, "regex\\C-\\M-x", :expr_beg,
1946
- :tREGEXP_END, "", :expr_end)
1949
+ :tREGEXP_BEG, "/", EXPR_BEG,
1950
+ :tSTRING_CONTENT, "regex\\C-\\M-x", EXPR_BEG,
1951
+ :tREGEXP_END, "", EXPR_END)
1947
1952
  end
1948
1953
 
1949
1954
  def test_yylex_regexp_escape_C_M_craaaazy
1950
1955
  assert_lex3("/regex\\C-\\\n\\M-x/",
1951
1956
  nil,
1952
- :tREGEXP_BEG, "/", :expr_beg,
1953
- :tSTRING_CONTENT, "regex\\C-\\M-x", :expr_beg,
1954
- :tREGEXP_END, "", :expr_end)
1957
+ :tREGEXP_BEG, "/", EXPR_BEG,
1958
+ :tSTRING_CONTENT, "regex\\C-\\M-x", EXPR_BEG,
1959
+ :tREGEXP_END, "", EXPR_END)
1955
1960
  end
1956
1961
 
1957
1962
  def test_yylex_regexp_escape_C_bad_dash
@@ -1977,17 +1982,17 @@ class TestRubyLexer < Minitest::Test
1977
1982
  def test_yylex_regexp_escape_M
1978
1983
  assert_lex3("/regex\\M-x/",
1979
1984
  nil,
1980
- :tREGEXP_BEG, "/", :expr_beg,
1981
- :tSTRING_CONTENT, "regex\\M-x", :expr_beg,
1982
- :tREGEXP_END, "", :expr_end)
1985
+ :tREGEXP_BEG, "/", EXPR_BEG,
1986
+ :tSTRING_CONTENT, "regex\\M-x", EXPR_BEG,
1987
+ :tREGEXP_END, "", EXPR_END)
1983
1988
  end
1984
1989
 
1985
1990
  def test_yylex_regexp_escape_M_C
1986
1991
  assert_lex3("/regex\\M-\\C-x/",
1987
1992
  nil,
1988
- :tREGEXP_BEG, "/", :expr_beg,
1989
- :tSTRING_CONTENT, "regex\\M-\\C-x", :expr_beg,
1990
- :tREGEXP_END, "", :expr_end)
1993
+ :tREGEXP_BEG, "/", EXPR_BEG,
1994
+ :tSTRING_CONTENT, "regex\\M-\\C-x", EXPR_BEG,
1995
+ :tREGEXP_END, "", EXPR_END)
1991
1996
  end
1992
1997
 
1993
1998
  def test_yylex_regexp_escape_M_bad_dash
@@ -2009,49 +2014,49 @@ class TestRubyLexer < Minitest::Test
2009
2014
  def test_yylex_regexp_escape_backslash_slash
2010
2015
  assert_lex3("/\\//",
2011
2016
  nil,
2012
- :tREGEXP_BEG, "/", :expr_beg,
2013
- :tSTRING_CONTENT, "\\/", :expr_beg,
2014
- :tREGEXP_END, "", :expr_end)
2017
+ :tREGEXP_BEG, "/", EXPR_BEG,
2018
+ :tSTRING_CONTENT, "\\/", EXPR_BEG,
2019
+ :tREGEXP_END, "", EXPR_END)
2015
2020
  end
2016
2021
 
2017
2022
  def test_yylex_regexp_escape_backslash_terminator
2018
2023
  assert_lex3("%r%blah\\%blah%",
2019
2024
  nil,
2020
- :tREGEXP_BEG, "%r\000", :expr_beg,
2021
- :tSTRING_CONTENT, "blah\\%blah", :expr_beg,
2022
- :tREGEXP_END, "", :expr_end)
2025
+ :tREGEXP_BEG, "%r\000", EXPR_BEG,
2026
+ :tSTRING_CONTENT, "blah\\%blah", EXPR_BEG,
2027
+ :tREGEXP_END, "", EXPR_END)
2023
2028
  end
2024
2029
 
2025
2030
  def test_yylex_regexp_escaped_delim
2026
2031
  assert_lex3("%r!blah(?\\!blah)!",
2027
2032
  nil,
2028
- :tREGEXP_BEG, "%r\000", :expr_beg,
2029
- :tSTRING_CONTENT, "blah(?!blah)", :expr_beg,
2030
- :tREGEXP_END, "", :expr_end)
2033
+ :tREGEXP_BEG, "%r\000", EXPR_BEG,
2034
+ :tSTRING_CONTENT, "blah(?!blah)", EXPR_BEG,
2035
+ :tREGEXP_END, "", EXPR_END)
2031
2036
  end
2032
2037
 
2033
2038
  def test_yylex_regexp_escape_backslash_terminator_meta1
2034
2039
  assert_lex3("%r{blah\\}blah}",
2035
2040
  nil,
2036
- :tREGEXP_BEG, "%r{", :expr_beg, # FIX ?!?
2037
- :tSTRING_CONTENT, "blah\\}blah", :expr_beg,
2038
- :tREGEXP_END, "", :expr_end)
2041
+ :tREGEXP_BEG, "%r{", EXPR_BEG, # FIX ?!?
2042
+ :tSTRING_CONTENT, "blah\\}blah", EXPR_BEG,
2043
+ :tREGEXP_END, "", EXPR_END)
2039
2044
  end
2040
2045
 
2041
2046
  def test_yylex_regexp_escape_backslash_terminator_meta2
2042
2047
  assert_lex3("%r/blah\\/blah/",
2043
2048
  nil,
2044
- :tREGEXP_BEG, "%r\000", :expr_beg,
2045
- :tSTRING_CONTENT, "blah\\/blah", :expr_beg,
2046
- :tREGEXP_END, "", :expr_end)
2049
+ :tREGEXP_BEG, "%r\000", EXPR_BEG,
2050
+ :tSTRING_CONTENT, "blah\\/blah", EXPR_BEG,
2051
+ :tREGEXP_END, "", EXPR_END)
2047
2052
  end
2048
2053
 
2049
2054
  def test_yylex_regexp_escape_backslash_terminator_meta3
2050
2055
  assert_lex3("%r/blah\\%blah/",
2051
2056
  nil,
2052
- :tREGEXP_BEG, "%r\000", :expr_beg,
2053
- :tSTRING_CONTENT, "blah\\%blah", :expr_beg,
2054
- :tREGEXP_END, "", :expr_end)
2057
+ :tREGEXP_BEG, "%r\000", EXPR_BEG,
2058
+ :tSTRING_CONTENT, "blah\\%blah", EXPR_BEG,
2059
+ :tREGEXP_END, "", EXPR_END)
2055
2060
  end
2056
2061
 
2057
2062
  def test_yylex_regexp_escape_bad_eos
@@ -2061,50 +2066,50 @@ class TestRubyLexer < Minitest::Test
2061
2066
  def test_yylex_regexp_escape_bs
2062
2067
  assert_lex3("/regex\\\\regex/",
2063
2068
  nil,
2064
- :tREGEXP_BEG, "/", :expr_beg,
2065
- :tSTRING_CONTENT, "regex\\\\regex", :expr_beg,
2066
- :tREGEXP_END, "", :expr_end)
2069
+ :tREGEXP_BEG, "/", EXPR_BEG,
2070
+ :tSTRING_CONTENT, "regex\\\\regex", EXPR_BEG,
2071
+ :tREGEXP_END, "", EXPR_END)
2067
2072
  end
2068
2073
 
2069
2074
  def test_yylex_regexp_escape_c
2070
2075
  assert_lex3("/regex\\cxxx/",
2071
2076
  nil,
2072
- :tREGEXP_BEG, "/", :expr_beg,
2073
- :tSTRING_CONTENT, "regex\\cxxx", :expr_beg,
2074
- :tREGEXP_END, "", :expr_end)
2077
+ :tREGEXP_BEG, "/", EXPR_BEG,
2078
+ :tSTRING_CONTENT, "regex\\cxxx", EXPR_BEG,
2079
+ :tREGEXP_END, "", EXPR_END)
2075
2080
  end
2076
2081
 
2077
2082
  def test_yylex_regexp_escape_c_backslash
2078
2083
  assert_lex3("/regex\\c\\n/",
2079
2084
  nil,
2080
- :tREGEXP_BEG, "/", :expr_beg,
2081
- :tSTRING_CONTENT, "regex\\c\\n", :expr_beg,
2082
- :tREGEXP_END, "", :expr_end)
2085
+ :tREGEXP_BEG, "/", EXPR_BEG,
2086
+ :tSTRING_CONTENT, "regex\\c\\n", EXPR_BEG,
2087
+ :tREGEXP_END, "", EXPR_END)
2083
2088
  end
2084
2089
 
2085
2090
  def test_yylex_regexp_escape_chars
2086
2091
  assert_lex3("/re\\tge\\nxp/",
2087
2092
  nil,
2088
- :tREGEXP_BEG, "/", :expr_beg,
2089
- :tSTRING_CONTENT, "re\\tge\\nxp", :expr_beg,
2090
- :tREGEXP_END, "", :expr_end)
2093
+ :tREGEXP_BEG, "/", EXPR_BEG,
2094
+ :tSTRING_CONTENT, "re\\tge\\nxp", EXPR_BEG,
2095
+ :tREGEXP_END, "", EXPR_END)
2091
2096
  end
2092
2097
 
2093
2098
  def test_yylex_regexp_escape_double_backslash
2094
2099
  regexp = '/[\\/\\\\]$/'
2095
2100
  assert_lex3(regexp.dup,
2096
2101
  nil,
2097
- :tREGEXP_BEG, "/", :expr_beg,
2098
- :tSTRING_CONTENT, "[\\/\\\\]$", :expr_beg,
2099
- :tREGEXP_END, "", :expr_end)
2102
+ :tREGEXP_BEG, "/", EXPR_BEG,
2103
+ :tSTRING_CONTENT, "[\\/\\\\]$", EXPR_BEG,
2104
+ :tREGEXP_END, "", EXPR_END)
2100
2105
  end
2101
2106
 
2102
2107
  def test_yylex_regexp_escape_hex
2103
2108
  assert_lex3("/regex\\x61xp/",
2104
2109
  nil,
2105
- :tREGEXP_BEG, "/", :expr_beg,
2106
- :tSTRING_CONTENT, "regex\\x61xp", :expr_beg,
2107
- :tREGEXP_END, "", :expr_end)
2110
+ :tREGEXP_BEG, "/", EXPR_BEG,
2111
+ :tSTRING_CONTENT, "regex\\x61xp", EXPR_BEG,
2112
+ :tREGEXP_END, "", EXPR_END)
2108
2113
  end
2109
2114
 
2110
2115
  def test_yylex_regexp_escape_hex_bad
@@ -2114,133 +2119,133 @@ class TestRubyLexer < Minitest::Test
2114
2119
  def test_yylex_regexp_escape_hex_one
2115
2120
  assert_lex3("/^[\\xd\\xa]{2}/on",
2116
2121
  nil,
2117
- :tREGEXP_BEG, "/", :expr_beg,
2118
- :tSTRING_CONTENT, "^[\\xd\\xa]{2}", :expr_beg,
2119
- :tREGEXP_END, "on", :expr_end)
2122
+ :tREGEXP_BEG, "/", EXPR_BEG,
2123
+ :tSTRING_CONTENT, "^[\\xd\\xa]{2}", EXPR_BEG,
2124
+ :tREGEXP_END, "on", EXPR_END)
2120
2125
  end
2121
2126
 
2122
2127
  def test_yylex_regexp_escape_oct1
2123
2128
  assert_lex3("/regex\\0xp/",
2124
2129
  nil,
2125
- :tREGEXP_BEG, "/", :expr_beg,
2126
- :tSTRING_CONTENT, "regex\\0xp", :expr_beg,
2127
- :tREGEXP_END, "", :expr_end)
2130
+ :tREGEXP_BEG, "/", EXPR_BEG,
2131
+ :tSTRING_CONTENT, "regex\\0xp", EXPR_BEG,
2132
+ :tREGEXP_END, "", EXPR_END)
2128
2133
  end
2129
2134
 
2130
2135
  def test_yylex_regexp_escape_oct2
2131
2136
  assert_lex3("/regex\\07xp/",
2132
2137
  nil,
2133
- :tREGEXP_BEG, "/", :expr_beg,
2134
- :tSTRING_CONTENT, "regex\\07xp", :expr_beg,
2135
- :tREGEXP_END, "", :expr_end)
2138
+ :tREGEXP_BEG, "/", EXPR_BEG,
2139
+ :tSTRING_CONTENT, "regex\\07xp", EXPR_BEG,
2140
+ :tREGEXP_END, "", EXPR_END)
2136
2141
  end
2137
2142
 
2138
2143
  def test_yylex_regexp_escape_oct3
2139
2144
  assert_lex3("/regex\\10142/",
2140
2145
  nil,
2141
- :tREGEXP_BEG, "/", :expr_beg,
2142
- :tSTRING_CONTENT, "regex\\10142", :expr_beg,
2143
- :tREGEXP_END, "", :expr_end)
2146
+ :tREGEXP_BEG, "/", EXPR_BEG,
2147
+ :tSTRING_CONTENT, "regex\\10142", EXPR_BEG,
2148
+ :tREGEXP_END, "", EXPR_END)
2144
2149
  end
2145
2150
 
2146
2151
  def test_yylex_regexp_escape_return
2147
2152
  assert_lex3("/regex\\\nregex/",
2148
2153
  nil,
2149
- :tREGEXP_BEG, "/", :expr_beg,
2150
- :tSTRING_CONTENT, "regexregex", :expr_beg,
2151
- :tREGEXP_END, "", :expr_end)
2154
+ :tREGEXP_BEG, "/", EXPR_BEG,
2155
+ :tSTRING_CONTENT, "regexregex", EXPR_BEG,
2156
+ :tREGEXP_END, "", EXPR_END)
2152
2157
  end
2153
2158
 
2154
2159
  def test_yylex_regexp_nm
2155
2160
  assert_lex3("/.*/nm",
2156
2161
  nil,
2157
- :tREGEXP_BEG, "/", :expr_beg,
2158
- :tSTRING_CONTENT, ".*", :expr_beg,
2159
- :tREGEXP_END, "nm", :expr_end)
2162
+ :tREGEXP_BEG, "/", EXPR_BEG,
2163
+ :tSTRING_CONTENT, ".*", EXPR_BEG,
2164
+ :tREGEXP_END, "nm", EXPR_END)
2160
2165
  end
2161
2166
 
2162
2167
  def test_yylex_rparen
2163
- assert_lex3(")", nil, :tRPAREN, ")", :expr_endfn)
2168
+ assert_lex3(")", nil, :tRPAREN, ")", EXPR_ENDFN)
2164
2169
  end
2165
2170
 
2166
2171
  def test_yylex_rshft
2167
2172
  assert_lex3("a >> 2",
2168
2173
  nil,
2169
- :tIDENTIFIER, "a", :expr_cmdarg,
2170
- :tRSHFT, ">>", :expr_beg,
2171
- :tINTEGER, 2, :expr_end)
2174
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2175
+ :tRSHFT, ">>", EXPR_BEG,
2176
+ :tINTEGER, 2, EXPR_NUM)
2172
2177
  end
2173
2178
 
2174
2179
  def test_yylex_rshft_equals
2175
2180
  assert_lex3("a >>= 2",
2176
2181
  nil,
2177
- :tIDENTIFIER, "a", :expr_cmdarg,
2178
- :tOP_ASGN, ">>", :expr_beg,
2179
- :tINTEGER, 2, :expr_end)
2182
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2183
+ :tOP_ASGN, ">>", EXPR_BEG,
2184
+ :tINTEGER, 2, EXPR_NUM)
2180
2185
  end
2181
2186
 
2182
2187
  def test_yylex_star
2183
2188
  assert_lex3("a * ",
2184
2189
  nil,
2185
- :tIDENTIFIER, "a", :expr_cmdarg,
2186
- :tSTAR2, "*", :expr_beg)
2190
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2191
+ :tSTAR2, "*", EXPR_BEG)
2187
2192
  end
2188
2193
 
2189
2194
  def test_yylex_star2
2190
2195
  assert_lex3("a ** ",
2191
2196
  nil,
2192
- :tIDENTIFIER, "a", :expr_cmdarg,
2193
- :tPOW, "**", :expr_beg)
2197
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2198
+ :tPOW, "**", EXPR_BEG)
2194
2199
  end
2195
2200
 
2196
2201
  def test_yylex_star2_equals
2197
2202
  assert_lex3("a **= ",
2198
2203
  nil,
2199
- :tIDENTIFIER, "a", :expr_cmdarg,
2200
- :tOP_ASGN, "**", :expr_beg)
2204
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2205
+ :tOP_ASGN, "**", EXPR_BEG)
2201
2206
  end
2202
2207
 
2203
2208
  def test_yylex_star_arg
2204
- self.lex_state = :expr_arg
2209
+ self.lex_state = EXPR_ARG
2205
2210
 
2206
2211
  assert_lex3(" *a",
2207
2212
  nil,
2208
- :tSTAR, "*", :expr_beg,
2209
- :tIDENTIFIER, "a", :expr_arg)
2213
+ :tSTAR, "*", EXPR_BEG,
2214
+ :tIDENTIFIER, "a", EXPR_ARG)
2210
2215
  end
2211
2216
 
2212
2217
  def test_yylex_star_arg_beg
2213
- self.lex_state = :expr_beg
2218
+ self.lex_state = EXPR_BEG
2214
2219
 
2215
2220
  assert_lex3("*a",
2216
2221
  nil,
2217
- :tSTAR, "*", :expr_beg,
2218
- :tIDENTIFIER, "a", :expr_arg)
2222
+ :tSTAR, "*", EXPR_BEG,
2223
+ :tIDENTIFIER, "a", EXPR_ARG)
2219
2224
  end
2220
2225
 
2221
2226
  def test_yylex_star_arg_beg_fname
2222
- self.lex_state = :expr_fname
2227
+ self.lex_state = EXPR_FNAME
2223
2228
 
2224
2229
  assert_lex3("*a",
2225
2230
  nil,
2226
- :tSTAR2, "*", :expr_arg,
2227
- :tIDENTIFIER, "a", :expr_arg)
2231
+ :tSTAR2, "*", EXPR_ARG,
2232
+ :tIDENTIFIER, "a", EXPR_ARG)
2228
2233
  end
2229
2234
 
2230
2235
  def test_yylex_star_arg_beg_fname2
2231
- self.lex_state = :expr_fname
2236
+ self.lex_state = EXPR_FNAME
2232
2237
 
2233
2238
  assert_lex3("*a",
2234
2239
  nil,
2235
- :tSTAR2, "*", :expr_arg,
2236
- :tIDENTIFIER, "a", :expr_arg)
2240
+ :tSTAR2, "*", EXPR_ARG,
2241
+ :tIDENTIFIER, "a", EXPR_ARG)
2237
2242
  end
2238
2243
 
2239
2244
  def test_yylex_star_equals
2240
2245
  assert_lex3("a *= ",
2241
2246
  nil,
2242
- :tIDENTIFIER, "a", :expr_cmdarg,
2243
- :tOP_ASGN, "*", :expr_beg)
2247
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2248
+ :tOP_ASGN, "*", EXPR_BEG)
2244
2249
  end
2245
2250
 
2246
2251
  def test_yylex_string_bad_eos
@@ -2252,31 +2257,31 @@ class TestRubyLexer < Minitest::Test
2252
2257
  end
2253
2258
 
2254
2259
  def test_yylex_string_double
2255
- assert_lex3("\"string\"", nil, :tSTRING, "string", :expr_end)
2260
+ assert_lex3("\"string\"", nil, :tSTRING, "string", EXPR_END)
2256
2261
  end
2257
2262
 
2258
2263
  def test_yylex_string_double_escape_C
2259
- assert_lex3("\"\\C-a\"", nil, :tSTRING, "\001", :expr_end)
2264
+ assert_lex3("\"\\C-a\"", nil, :tSTRING, "\001", EXPR_END)
2260
2265
  end
2261
2266
 
2262
2267
  def test_yylex_string_double_escape_C_backslash
2263
2268
  assert_lex3("\"\\C-\\\\\"",
2264
2269
  nil,
2265
- :tSTRING_BEG, "\"", :expr_beg,
2266
- :tSTRING_CONTENT, "\034", :expr_beg,
2267
- :tSTRING_END, "\"", :expr_end)
2270
+ :tSTRING_BEG, "\"", EXPR_BEG,
2271
+ :tSTRING_CONTENT, "\034", EXPR_BEG,
2272
+ :tSTRING_END, "\"", EXPR_END)
2268
2273
  end
2269
2274
 
2270
2275
  def test_yylex_string_double_escape_C_escape
2271
2276
  assert_lex3("\"\\C-\\M-a\"",
2272
2277
  nil,
2273
- :tSTRING_BEG, "\"", :expr_beg,
2274
- :tSTRING_CONTENT, "\201", :expr_beg,
2275
- :tSTRING_END, "\"", :expr_end)
2278
+ :tSTRING_BEG, "\"", EXPR_BEG,
2279
+ :tSTRING_CONTENT, "\201", EXPR_BEG,
2280
+ :tSTRING_END, "\"", EXPR_END)
2276
2281
  end
2277
2282
 
2278
2283
  def test_yylex_string_double_escape_C_question
2279
- assert_lex3("\"\\C-?\"", nil, :tSTRING, "\177", :expr_end)
2284
+ assert_lex3("\"\\C-?\"", nil, :tSTRING, "\177", EXPR_END)
2280
2285
  end
2281
2286
 
2282
2287
  def test_yylex_string_utf8_simple
@@ -2284,7 +2289,22 @@ class TestRubyLexer < Minitest::Test
2284
2289
 
2285
2290
  assert_lex3('"\u{3024}"',
2286
2291
  s(:str, chr),
2287
- :tSTRING, chr, :expr_end)
2292
+ :tSTRING, chr, EXPR_END)
2293
+ end
2294
+
2295
+ def test_yylex_string_utf8_trailing_hex
2296
+ chr = [0x3024].pack("U")
2297
+ str = "#{chr}abz"
2298
+
2299
+ assert_lex3('"\u3024abz"',
2300
+ s(:str, str),
2301
+ :tSTRING, str, EXPR_END)
2302
+ end
2303
+
2304
+ def test_yylex_string_utf8_missing_hex
2305
+ refute_lex('"\u3zzz"')
2306
+ refute_lex('"\u30zzz"')
2307
+ refute_lex('"\u302zzz"')
2288
2308
  end
2289
2309
 
2290
2310
  def test_yylex_string_utf8_complex
@@ -2292,234 +2312,282 @@ class TestRubyLexer < Minitest::Test
2292
2312
 
2293
2313
  assert_lex3('"#@a\u{3024}"',
2294
2314
  s(:dstr, "", s(:evstr, s(:ivar, :@a)), s(:str, chr)),
2295
- :tSTRING_BEG, '"', :expr_beg,
2296
- :tSTRING_DVAR, nil, :expr_beg,
2297
- :tSTRING_CONTENT, "@a"+chr, :expr_beg,
2298
- :tSTRING_END, '"', :expr_end)
2315
+ :tSTRING_BEG, '"', EXPR_BEG,
2316
+ :tSTRING_DVAR, nil, EXPR_BEG,
2317
+ :tSTRING_CONTENT, "@a"+chr, EXPR_BEG,
2318
+ :tSTRING_END, '"', EXPR_END)
2319
+ end
2320
+
2321
+ def test_yylex_string_utf8_complex_trailing_hex
2322
+ chr = [0x3024].pack("U")
2323
+ str = "#{chr}abz"
2324
+
2325
+ assert_lex3('"#@a\u3024abz"',
2326
+ s(:dstr, "", s(:evstr, s(:ivar, :@a)), s(:str, str)),
2327
+ :tSTRING_BEG, '"', EXPR_BEG,
2328
+ :tSTRING_DVAR, nil, EXPR_BEG,
2329
+ :tSTRING_CONTENT, "@a"+str, EXPR_BEG,
2330
+ :tSTRING_END, '"', EXPR_END)
2331
+ end
2332
+
2333
+ def test_yylex_string_utf8_complex_missing_hex
2334
+ chr = [0x302].pack("U")
2335
+ str = "#{chr}zzz"
2336
+
2337
+ refute_lex('"#@a\u302zzz"',
2338
+ :tSTRING_BEG, '"',
2339
+ :tSTRING_DVAR, nil,
2340
+ :tSTRING_CONTENT, "@a"+str,
2341
+ :tSTRING_END, '"')
2342
+
2343
+ chr = [0x30].pack("U")
2344
+ str = "#{chr}zzz"
2345
+
2346
+ refute_lex('"#@a\u30zzz"',
2347
+ :tSTRING_BEG, '"',
2348
+ :tSTRING_DVAR, nil,
2349
+ :tSTRING_CONTENT, "@a"+str,
2350
+ :tSTRING_END, '"')
2351
+
2352
+ chr = [0x3].pack("U")
2353
+ str = "#{chr}zzz"
2354
+
2355
+ refute_lex('"#@a\u3zzz"',
2356
+ :tSTRING_BEG, '"',
2357
+ :tSTRING_DVAR, nil,
2358
+ :tSTRING_CONTENT, "@a"+str,
2359
+ :tSTRING_END, '"')
2299
2360
  end
2300
2361
 
2301
2362
  def test_yylex_string_double_escape_M
2302
2363
  chr = "\341"
2303
- chr.force_encoding("UTF-8") if RubyLexer::HAS_ENC
2304
2364
 
2305
- assert_lex3("\"\\M-a\"", nil, :tSTRING, chr, :expr_end)
2365
+ assert_lex3("\"\\M-a\"", nil, :tSTRING, chr, EXPR_END)
2306
2366
  end
2307
2367
 
2308
2368
  def test_why_does_ruby_hate_me?
2309
2369
  assert_lex3("\"Nl%\\000\\000A\\000\\999\"", # you should be ashamed
2310
2370
  nil,
2311
- :tSTRING, ["Nl%","\x00","\x00","A","\x00","999"].join, :expr_end)
2371
+ :tSTRING, ["Nl%","\x00","\x00","A","\x00","999"].join, EXPR_END)
2312
2372
  end
2313
2373
 
2314
2374
  def test_yylex_string_double_escape_M_backslash
2315
2375
  assert_lex3("\"\\M-\\\\\"",
2316
2376
  nil,
2317
- :tSTRING_BEG, "\"", :expr_beg,
2318
- :tSTRING_CONTENT, "\334", :expr_beg,
2319
- :tSTRING_END, "\"", :expr_end)
2377
+ :tSTRING_BEG, "\"", EXPR_BEG,
2378
+ :tSTRING_CONTENT, "\334", EXPR_BEG,
2379
+ :tSTRING_END, "\"", EXPR_END)
2320
2380
  end
2321
2381
 
2322
2382
  def test_yylex_string_double_escape_M_escape
2323
2383
  assert_lex3("\"\\M-\\C-a\"",
2324
2384
  nil,
2325
- :tSTRING_BEG, "\"", :expr_beg,
2326
- :tSTRING_CONTENT, "\201", :expr_beg,
2327
- :tSTRING_END, "\"", :expr_end)
2385
+ :tSTRING_BEG, "\"", EXPR_BEG,
2386
+ :tSTRING_CONTENT, "\201", EXPR_BEG,
2387
+ :tSTRING_END, "\"", EXPR_END)
2328
2388
  end
2329
2389
 
2330
2390
  def test_yylex_string_double_escape_bs1
2331
- assert_lex3("\"a\\a\\a\"", nil, :tSTRING, "a\a\a", :expr_end)
2391
+ assert_lex3("\"a\\a\\a\"", nil, :tSTRING, "a\a\a", EXPR_END)
2332
2392
  end
2333
2393
 
2334
2394
  def test_yylex_string_double_escape_bs2
2335
- assert_lex3("\"a\\\\a\"", nil, :tSTRING, "a\\a", :expr_end)
2395
+ assert_lex3("\"a\\\\a\"", nil, :tSTRING, "a\\a", EXPR_END)
2336
2396
  end
2337
2397
 
2338
2398
  def test_yylex_string_double_escape_c
2339
- assert_lex3("\"\\ca\"", nil, :tSTRING, "\001", :expr_end)
2399
+ assert_lex3("\"\\ca\"", nil, :tSTRING, "\001", EXPR_END)
2340
2400
  end
2341
2401
 
2342
2402
  def test_yylex_string_double_escape_c_backslash
2343
2403
  assert_lex3("\"\\c\\\"",
2344
2404
  nil,
2345
- :tSTRING_BEG, "\"", :expr_beg,
2346
- :tSTRING_CONTENT, "\034", :expr_beg,
2347
- :tSTRING_END, "\"", :expr_end)
2405
+ :tSTRING_BEG, "\"", EXPR_BEG,
2406
+ :tSTRING_CONTENT, "\034", EXPR_BEG,
2407
+ :tSTRING_END, "\"", EXPR_END)
2348
2408
  end
2349
2409
 
2350
2410
  def test_yylex_string_double_escape_c_escape
2351
2411
  assert_lex3("\"\\c\\M-a\"",
2352
2412
  nil,
2353
- :tSTRING_BEG, "\"", :expr_beg,
2354
- :tSTRING_CONTENT, "\201", :expr_beg,
2355
- :tSTRING_END, "\"", :expr_end)
2413
+ :tSTRING_BEG, "\"", EXPR_BEG,
2414
+ :tSTRING_CONTENT, "\201", EXPR_BEG,
2415
+ :tSTRING_END, "\"", EXPR_END)
2356
2416
  end
2357
2417
 
2358
2418
  def test_yylex_string_double_escape_c_question
2359
- assert_lex3("\"\\c?\"", nil, :tSTRING, "\177", :expr_end)
2419
+ assert_lex3("\"\\c?\"", nil, :tSTRING, "\177", EXPR_END)
2360
2420
  end
2361
2421
 
2362
2422
  def test_yylex_string_double_escape_chars
2363
- assert_lex3("\"s\\tri\\ng\"", nil, :tSTRING, "s\tri\ng", :expr_end)
2423
+ assert_lex3("\"s\\tri\\ng\"", nil, :tSTRING, "s\tri\ng", EXPR_END)
2364
2424
  end
2365
2425
 
2366
2426
  def test_yylex_string_double_escape_hex
2367
- assert_lex3("\"n = \\x61\\x62\\x63\"", nil, :tSTRING, "n = abc", :expr_end)
2427
+ assert_lex3("\"n = \\x61\\x62\\x63\"", nil, :tSTRING, "n = abc", EXPR_END)
2368
2428
  end
2369
2429
 
2370
2430
  def test_yylex_string_double_escape_octal
2371
- assert_lex3("\"n = \\101\\102\\103\"", nil, :tSTRING, "n = ABC", :expr_end)
2431
+ assert_lex3("\"n = \\101\\102\\103\"", nil, :tSTRING, "n = ABC", EXPR_END)
2372
2432
  end
2373
2433
 
2374
2434
  def test_yylex_string_double_escape_octal_fucked
2375
- assert_lex3("\"n = \\444\"", nil, :tSTRING, "n = $", :expr_end)
2435
+ assert_lex3("\"n = \\444\"", nil, :tSTRING, "n = $", EXPR_END)
2376
2436
  end
2377
2437
 
2378
2438
  def test_yylex_string_double_interp
2379
2439
  assert_lex3("\"blah #x a \#@a b \#$b c \#{3} # \"",
2380
2440
  nil,
2381
- :tSTRING_BEG, "\"", :expr_beg,
2382
- :tSTRING_CONTENT, "blah #x a ", :expr_beg,
2383
- :tSTRING_DVAR, nil, :expr_beg,
2384
- :tSTRING_CONTENT, "@a b ", :expr_beg,
2385
- :tSTRING_DVAR, nil, :expr_beg,
2386
- :tSTRING_CONTENT, "$b c ", :expr_beg,
2387
- :tSTRING_DBEG, nil, :expr_beg,
2388
- :tSTRING_CONTENT, "3} # ", :expr_beg,
2389
- :tSTRING_END, "\"", :expr_end)
2441
+ :tSTRING_BEG, "\"", EXPR_BEG,
2442
+ :tSTRING_CONTENT, "blah #x a ", EXPR_BEG,
2443
+ :tSTRING_DVAR, nil, EXPR_BEG,
2444
+ :tSTRING_CONTENT, "@a b ", EXPR_BEG,
2445
+ :tSTRING_DVAR, nil, EXPR_BEG,
2446
+ :tSTRING_CONTENT, "$b c ", EXPR_BEG,
2447
+ :tSTRING_DBEG, nil, EXPR_BEG,
2448
+ :tSTRING_CONTENT, "3} # ", EXPR_BEG,
2449
+ :tSTRING_END, "\"", EXPR_END)
2390
2450
  end
2391
2451
 
2392
2452
  def test_yylex_string_double_pound_dollar_bad
2393
2453
  assert_lex3('"#$%"', nil,
2394
2454
 
2395
- :tSTRING_BEG, "\"", :expr_beg,
2396
- :tSTRING_CONTENT, '#$%', :expr_beg,
2397
- :tSTRING_END, "\"", :expr_end)
2455
+ :tSTRING_BEG, "\"", EXPR_BEG,
2456
+ :tSTRING_CONTENT, '#$%', EXPR_BEG,
2457
+ :tSTRING_END, "\"", EXPR_END)
2398
2458
  end
2399
2459
 
2400
2460
  def test_yylex_string_double_nested_curlies
2401
2461
  assert_lex3("%{nest{one{two}one}nest}",
2402
2462
  nil,
2403
- :tSTRING_BEG, "%}", :expr_beg,
2404
- :tSTRING_CONTENT, "nest{one{two}one}nest", :expr_beg,
2405
- :tSTRING_END, "}", :expr_end)
2463
+ :tSTRING_BEG, "%}", EXPR_BEG,
2464
+ :tSTRING_CONTENT, "nest{one{two}one}nest", EXPR_BEG,
2465
+ :tSTRING_END, "}", EXPR_END)
2406
2466
  end
2407
2467
 
2408
2468
  def test_yylex_string_double_no_interp
2409
- assert_lex3("\"# blah\"", nil, :tSTRING, "# blah", :expr_end)
2410
- assert_lex3("\"blah # blah\"", nil, :tSTRING, "blah # blah", :expr_end)
2469
+ assert_lex3("\"# blah\"", nil, :tSTRING, "# blah", EXPR_END)
2470
+ assert_lex3("\"blah # blah\"", nil, :tSTRING, "blah # blah", EXPR_END)
2411
2471
  end
2412
2472
 
2413
2473
  def test_yylex_string_escape_x_single
2414
- assert_lex3("\"\\x0\"", nil, :tSTRING, "\000", :expr_end)
2474
+ assert_lex3("\"\\x0\"", nil, :tSTRING, "\000", EXPR_END)
2415
2475
  end
2416
2476
 
2417
2477
  def test_yylex_string_pct_i
2418
2478
  assert_lex3("%i[s1 s2\ns3]",
2419
2479
  nil,
2420
- :tQSYMBOLS_BEG, "%i[", :expr_beg,
2421
- :tSTRING_CONTENT, "s1", :expr_beg,
2422
- :tSPACE, nil, :expr_beg,
2423
- :tSTRING_CONTENT, "s2", :expr_beg,
2424
- :tSPACE, nil, :expr_beg,
2425
- :tSTRING_CONTENT, "s3", :expr_beg,
2426
- :tSPACE, nil, :expr_beg,
2427
- :tSTRING_END, nil, :expr_end)
2480
+ :tQSYMBOLS_BEG, "%i[", EXPR_BEG,
2481
+ :tSTRING_CONTENT, "s1", EXPR_BEG,
2482
+ :tSPACE, nil, EXPR_BEG,
2483
+ :tSTRING_CONTENT, "s2", EXPR_BEG,
2484
+ :tSPACE, nil, EXPR_BEG,
2485
+ :tSTRING_CONTENT, "s3", EXPR_BEG,
2486
+ :tSPACE, nil, EXPR_BEG,
2487
+ :tSTRING_END, nil, EXPR_END)
2428
2488
  end
2429
2489
 
2430
2490
  def test_yylex_string_pct_I
2431
2491
  assert_lex3("%I[s1 s2\ns3]",
2432
2492
  nil,
2433
- :tSYMBOLS_BEG, "%I[", :expr_beg,
2434
- :tSTRING_CONTENT, "s1", :expr_beg,
2435
- :tSPACE, nil, :expr_beg,
2436
- :tSTRING_CONTENT, "s2", :expr_beg,
2437
- :tSPACE, nil, :expr_beg,
2438
- :tSTRING_CONTENT, "s3", :expr_beg,
2439
- :tSPACE, nil, :expr_beg,
2440
- :tSTRING_END, nil, :expr_end)
2493
+ :tSYMBOLS_BEG, "%I[", EXPR_BEG,
2494
+ :tSTRING_CONTENT, "s1", EXPR_BEG,
2495
+ :tSPACE, nil, EXPR_BEG,
2496
+ :tSTRING_CONTENT, "s2", EXPR_BEG,
2497
+ :tSPACE, nil, EXPR_BEG,
2498
+ :tSTRING_CONTENT, "s3", EXPR_BEG,
2499
+ :tSPACE, nil, EXPR_BEG,
2500
+ :tSTRING_END, nil, EXPR_END)
2441
2501
  end
2442
2502
 
2443
2503
  def test_yylex_string_pct_i_extra_space
2444
2504
  assert_lex3("%i[ s1 s2\ns3 ]",
2445
2505
  nil,
2446
- :tQSYMBOLS_BEG, "%i[", :expr_beg,
2447
- :tSTRING_CONTENT, "s1", :expr_beg,
2448
- :tSPACE, nil, :expr_beg,
2449
- :tSTRING_CONTENT, "s2", :expr_beg,
2450
- :tSPACE, nil, :expr_beg,
2451
- :tSTRING_CONTENT, "s3", :expr_beg,
2452
- :tSPACE, nil, :expr_beg,
2453
- :tSTRING_END, nil, :expr_end)
2506
+ :tQSYMBOLS_BEG, "%i[", EXPR_BEG,
2507
+ :tSTRING_CONTENT, "s1", EXPR_BEG,
2508
+ :tSPACE, nil, EXPR_BEG,
2509
+ :tSTRING_CONTENT, "s2", EXPR_BEG,
2510
+ :tSPACE, nil, EXPR_BEG,
2511
+ :tSTRING_CONTENT, "s3", EXPR_BEG,
2512
+ :tSPACE, nil, EXPR_BEG,
2513
+ :tSTRING_END, nil, EXPR_END)
2454
2514
  end
2455
2515
 
2456
2516
  def test_yylex_string_pct_I_extra_space
2457
2517
  assert_lex3("%I[ s1 s2\ns3 ]",
2458
2518
  nil,
2459
- :tSYMBOLS_BEG, "%I[", :expr_beg,
2460
- :tSTRING_CONTENT, "s1", :expr_beg,
2461
- :tSPACE, nil, :expr_beg,
2462
- :tSTRING_CONTENT, "s2", :expr_beg,
2463
- :tSPACE, nil, :expr_beg,
2464
- :tSTRING_CONTENT, "s3", :expr_beg,
2465
- :tSPACE, nil, :expr_beg,
2466
- :tSTRING_END, nil, :expr_end)
2519
+ :tSYMBOLS_BEG, "%I[", EXPR_BEG,
2520
+ :tSTRING_CONTENT, "s1", EXPR_BEG,
2521
+ :tSPACE, nil, EXPR_BEG,
2522
+ :tSTRING_CONTENT, "s2", EXPR_BEG,
2523
+ :tSPACE, nil, EXPR_BEG,
2524
+ :tSTRING_CONTENT, "s3", EXPR_BEG,
2525
+ :tSPACE, nil, EXPR_BEG,
2526
+ :tSTRING_END, nil, EXPR_END)
2467
2527
  end
2468
2528
 
2469
2529
  def test_yylex_string_pct_q
2470
2530
  assert_lex3("%q[s1 s2]",
2471
2531
  nil,
2472
- :tSTRING_BEG, "%q[", :expr_beg,
2473
- :tSTRING_CONTENT, "s1 s2", :expr_beg,
2474
- :tSTRING_END, "]", :expr_end)
2532
+ :tSTRING_BEG, "%q[", EXPR_BEG,
2533
+ :tSTRING_CONTENT, "s1 s2", EXPR_BEG,
2534
+ :tSTRING_END, "]", EXPR_END)
2475
2535
  end
2476
2536
 
2477
2537
  def test_yylex_string_pct_Q
2478
2538
  assert_lex3("%Q[s1 s2]",
2479
2539
  nil,
2480
- :tSTRING_BEG, "%Q[", :expr_beg,
2481
- :tSTRING_CONTENT, "s1 s2", :expr_beg,
2482
- :tSTRING_END, "]", :expr_end)
2540
+ :tSTRING_BEG, "%Q[", EXPR_BEG,
2541
+ :tSTRING_CONTENT, "s1 s2", EXPR_BEG,
2542
+ :tSTRING_END, "]", EXPR_END)
2543
+ end
2544
+
2545
+ def test_yylex_string_pct_s
2546
+ assert_lex3("%s[s1 s2]",
2547
+ nil,
2548
+ :tSYMBEG, "%s[", EXPR_FNAME, # TODO: :tSYM_BEG ?
2549
+ :tSTRING_CONTENT, "s1 s2", EXPR_FNAME, # man... I don't like this
2550
+ :tSTRING_END, "]", EXPR_END)
2483
2551
  end
2484
2552
 
2485
2553
  def test_yylex_string_pct_W
2486
2554
  assert_lex3("%W[s1 s2\ns3]", # TODO: add interpolation to these
2487
2555
  nil,
2488
- :tWORDS_BEG, "%W[", :expr_beg,
2489
- :tSTRING_CONTENT, "s1", :expr_beg,
2490
- :tSPACE, nil, :expr_beg,
2491
- :tSTRING_CONTENT, "s2", :expr_beg,
2492
- :tSPACE, nil, :expr_beg,
2493
- :tSTRING_CONTENT, "s3", :expr_beg,
2494
- :tSPACE, nil, :expr_beg,
2495
- :tSTRING_END, nil, :expr_end)
2556
+ :tWORDS_BEG, "%W[", EXPR_BEG,
2557
+ :tSTRING_CONTENT, "s1", EXPR_BEG,
2558
+ :tSPACE, nil, EXPR_BEG,
2559
+ :tSTRING_CONTENT, "s2", EXPR_BEG,
2560
+ :tSPACE, nil, EXPR_BEG,
2561
+ :tSTRING_CONTENT, "s3", EXPR_BEG,
2562
+ :tSPACE, nil, EXPR_BEG,
2563
+ :tSTRING_END, nil, EXPR_END)
2496
2564
  end
2497
2565
 
2498
2566
  def test_yylex_string_pct_W_bs_nl
2499
2567
  assert_lex3("%W[s1 \\\ns2]", # TODO: add interpolation to these
2500
2568
  nil,
2501
- :tWORDS_BEG, "%W[", :expr_beg,
2502
- :tSTRING_CONTENT, "s1", :expr_beg,
2503
- :tSPACE, nil, :expr_beg,
2504
- :tSTRING_CONTENT, "\ns2", :expr_beg,
2505
- :tSPACE, nil, :expr_beg,
2506
- :tSTRING_END, nil, :expr_end)
2569
+ :tWORDS_BEG, "%W[", EXPR_BEG,
2570
+ :tSTRING_CONTENT, "s1", EXPR_BEG,
2571
+ :tSPACE, nil, EXPR_BEG,
2572
+ :tSTRING_CONTENT, "\ns2", EXPR_BEG,
2573
+ :tSPACE, nil, EXPR_BEG,
2574
+ :tSTRING_END, nil, EXPR_END)
2507
2575
  end
2508
2576
 
2509
2577
  def test_yylex_string_pct_angle
2510
2578
  assert_lex3("%<blah>",
2511
2579
  nil,
2512
- :tSTRING_BEG, "%>", :expr_beg,
2513
- :tSTRING_CONTENT, "blah", :expr_beg,
2514
- :tSTRING_END, ">", :expr_end)
2580
+ :tSTRING_BEG, "%>", EXPR_BEG,
2581
+ :tSTRING_CONTENT, "blah", EXPR_BEG,
2582
+ :tSTRING_END, ">", EXPR_END)
2515
2583
  end
2516
2584
 
2517
2585
  def test_yylex_string_pct_other
2518
2586
  assert_lex3("%%blah%",
2519
2587
  nil,
2520
- :tSTRING_BEG, "%%", :expr_beg,
2521
- :tSTRING_CONTENT, "blah", :expr_beg,
2522
- :tSTRING_END, "%", :expr_end)
2588
+ :tSTRING_BEG, "%%", EXPR_BEG,
2589
+ :tSTRING_CONTENT, "blah", EXPR_BEG,
2590
+ :tSTRING_END, "%", EXPR_END)
2523
2591
  end
2524
2592
 
2525
2593
  def test_yylex_string_pct_w
@@ -2534,130 +2602,130 @@ class TestRubyLexer < Minitest::Test
2534
2602
  def test_yylex_string_pct_w_bs_nl
2535
2603
  assert_lex3("%w[s1 \\\ns2]",
2536
2604
  nil,
2537
- :tQWORDS_BEG, "%w[", :expr_beg,
2538
- :tSTRING_CONTENT, "s1", :expr_beg,
2539
- :tSPACE, nil, :expr_beg,
2540
- :tSTRING_CONTENT, "\ns2", :expr_beg,
2541
- :tSPACE, nil, :expr_beg,
2542
- :tSTRING_END, nil, :expr_end)
2605
+ :tQWORDS_BEG, "%w[", EXPR_BEG,
2606
+ :tSTRING_CONTENT, "s1", EXPR_BEG,
2607
+ :tSPACE, nil, EXPR_BEG,
2608
+ :tSTRING_CONTENT, "\ns2", EXPR_BEG,
2609
+ :tSPACE, nil, EXPR_BEG,
2610
+ :tSTRING_END, nil, EXPR_END)
2543
2611
  end
2544
2612
 
2545
2613
  def test_yylex_string_pct_w_bs_sp
2546
2614
  assert_lex3("%w[s\\ 1 s\\ 2]",
2547
2615
  nil,
2548
- :tQWORDS_BEG, "%w[", :expr_beg,
2549
- :tSTRING_CONTENT, "s 1", :expr_beg,
2550
- :tSPACE, nil, :expr_beg,
2551
- :tSTRING_CONTENT, "s 2", :expr_beg,
2552
- :tSPACE, nil, :expr_beg,
2553
- :tSTRING_END, nil, :expr_end)
2616
+ :tQWORDS_BEG, "%w[", EXPR_BEG,
2617
+ :tSTRING_CONTENT, "s 1", EXPR_BEG,
2618
+ :tSPACE, nil, EXPR_BEG,
2619
+ :tSTRING_CONTENT, "s 2", EXPR_BEG,
2620
+ :tSPACE, nil, EXPR_BEG,
2621
+ :tSTRING_END, nil, EXPR_END)
2554
2622
  end
2555
2623
 
2556
2624
  def test_yylex_string_single
2557
- assert_lex3("'string'", nil, :tSTRING, "string", :expr_end)
2625
+ assert_lex3("'string'", nil, :tSTRING, "string", EXPR_END)
2558
2626
  end
2559
2627
 
2560
2628
  def test_yylex_string_single_escape_chars
2561
- assert_lex3("'s\\tri\\ng'", nil, :tSTRING, "s\\tri\\ng", :expr_end)
2629
+ assert_lex3("'s\\tri\\ng'", nil, :tSTRING, "s\\tri\\ng", EXPR_END)
2562
2630
  end
2563
2631
 
2564
2632
  def test_yylex_string_single_nl
2565
- assert_lex3("'blah\\\nblah'", nil, :tSTRING, "blah\\\nblah", :expr_end)
2633
+ assert_lex3("'blah\\\nblah'", nil, :tSTRING, "blah\\\nblah", EXPR_END)
2566
2634
  end
2567
2635
 
2568
2636
  def test_yylex_string_single_escaped_quote
2569
- assert_lex3("'foo\\'bar'", nil, :tSTRING, "foo'bar", :expr_end)
2637
+ assert_lex3("'foo\\'bar'", nil, :tSTRING, "foo'bar", EXPR_END)
2570
2638
  end
2571
2639
 
2572
2640
  def test_yylex_symbol
2573
- assert_lex3(":symbol", nil, :tSYMBOL, "symbol", :expr_end)
2641
+ assert_lex3(":symbol", nil, :tSYMBOL, "symbol", EXPR_END)
2574
2642
  end
2575
2643
 
2576
2644
  def test_yylex_symbol_zero_byte
2577
2645
  assert_lex(":\"symbol\0\"", nil,
2578
- :tSYMBOL, "symbol\0", :expr_end)
2646
+ :tSYMBOL, "symbol\0", EXPR_END)
2579
2647
  end
2580
2648
 
2581
2649
  def test_yylex_symbol_double
2582
2650
  assert_lex3(":\"symbol\"",
2583
2651
  nil,
2584
- :tSYMBOL, "symbol", :expr_end)
2652
+ :tSYMBOL, "symbol", EXPR_END)
2585
2653
  end
2586
2654
 
2587
2655
  def test_yylex_symbol_double_interp
2588
2656
  assert_lex3(':"symbol#{1+1}"',
2589
2657
  nil,
2590
- :tSYMBEG, ":", :expr_fname,
2591
- :tSTRING_CONTENT, "symbol", :expr_fname,
2592
- :tSTRING_DBEG, nil, :expr_fname,
2593
- :tSTRING_CONTENT, "1+1}", :expr_fname, # HUH? this is BS
2594
- :tSTRING_END, "\"", :expr_end)
2658
+ :tSYMBEG, ":", EXPR_FNAME,
2659
+ :tSTRING_CONTENT, "symbol", EXPR_FNAME,
2660
+ :tSTRING_DBEG, nil, EXPR_FNAME,
2661
+ :tSTRING_CONTENT, "1+1}", EXPR_FNAME, # HUH? this is BS
2662
+ :tSTRING_END, "\"", EXPR_END)
2595
2663
  end
2596
2664
 
2597
2665
  def test_yylex_symbol_single
2598
2666
  assert_lex3(":'symbol'",
2599
2667
  nil,
2600
- :tSYMBOL, "symbol", :expr_end)
2668
+ :tSYMBOL, "symbol", EXPR_END)
2601
2669
  end
2602
2670
 
2603
2671
  def test_yylex_symbol_single_noninterp
2604
2672
  assert_lex3(':\'symbol#{1+1}\'',
2605
2673
  nil,
2606
- :tSYMBOL, 'symbol#{1+1}', :expr_end)
2674
+ :tSYMBOL, 'symbol#{1+1}', EXPR_END)
2607
2675
  end
2608
2676
 
2609
2677
  def test_yylex_symbol_single_escape_chars
2610
2678
  assert_lex3(":'s\\tri\\ng'",
2611
2679
  nil,
2612
- :tSYMBOL, "s\\tri\\ng", :expr_end)
2680
+ :tSYMBOL, "s\\tri\\ng", EXPR_END)
2613
2681
  end
2614
2682
 
2615
2683
  def test_yylex_string_single_escape_quote_and_backslash
2616
- assert_lex3(":'foo\\'bar\\\\baz'", nil, :tSYMBOL, "foo'bar\\baz", :expr_end)
2684
+ assert_lex3(":'foo\\'bar\\\\baz'", nil, :tSYMBOL, "foo'bar\\baz", EXPR_END)
2617
2685
  end
2618
2686
 
2619
2687
  def test_yylex_ternary1
2620
2688
  assert_lex3("a ? b : c",
2621
2689
  nil,
2622
- :tIDENTIFIER, "a", :expr_cmdarg,
2623
- :tEH, "?", :expr_value,
2624
- :tIDENTIFIER, "b", :expr_arg,
2625
- :tCOLON, ":", :expr_beg,
2626
- :tIDENTIFIER, "c", :expr_arg)
2690
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2691
+ :tEH, "?", EXPR_BEG,
2692
+ :tIDENTIFIER, "b", EXPR_ARG,
2693
+ :tCOLON, ":", EXPR_BEG,
2694
+ :tIDENTIFIER, "c", EXPR_ARG)
2627
2695
 
2628
2696
  assert_lex3("a ?bb : c", # GAH! MATZ!!!
2629
2697
  nil,
2630
- :tIDENTIFIER, "a", :expr_cmdarg,
2631
- :tEH, "?", :expr_beg,
2632
- :tIDENTIFIER, "bb", :expr_arg,
2633
- :tCOLON, ":", :expr_beg,
2634
- :tIDENTIFIER, "c", :expr_arg)
2698
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2699
+ :tEH, "?", EXPR_BEG,
2700
+ :tIDENTIFIER, "bb", EXPR_ARG,
2701
+ :tCOLON, ":", EXPR_BEG,
2702
+ :tIDENTIFIER, "c", EXPR_ARG)
2635
2703
 
2636
2704
  assert_lex3("42 ?",
2637
2705
  nil,
2638
- :tINTEGER, 42, :expr_end,
2639
- :tEH, "?", :expr_value)
2706
+ :tINTEGER, 42, EXPR_NUM,
2707
+ :tEH, "?", EXPR_BEG)
2640
2708
  end
2641
2709
 
2642
2710
  def test_yylex_tilde
2643
- assert_lex3("~", nil, :tTILDE, "~", :expr_beg)
2711
+ assert_lex3("~", nil, :tTILDE, "~", EXPR_BEG)
2644
2712
  end
2645
2713
 
2646
2714
  def test_yylex_tilde_unary
2647
- self.lex_state = :expr_fname
2715
+ self.lex_state = EXPR_FNAME
2648
2716
 
2649
- assert_lex3("~@", nil, :tTILDE, "~", :expr_arg)
2717
+ assert_lex3("~@", nil, :tTILDE, "~", EXPR_ARG)
2650
2718
  end
2651
2719
 
2652
2720
  def test_yylex_uminus
2653
2721
  assert_lex3("-blah",
2654
2722
  nil,
2655
- :tUMINUS, "-", :expr_beg,
2656
- :tIDENTIFIER, "blah", :expr_arg)
2723
+ :tUMINUS, "-", EXPR_BEG,
2724
+ :tIDENTIFIER, "blah", EXPR_ARG)
2657
2725
  end
2658
2726
 
2659
2727
  def test_yylex_underscore
2660
- assert_lex3("_var", nil, :tIDENTIFIER, "_var", :expr_cmdarg)
2728
+ assert_lex3("_var", nil, :tIDENTIFIER, "_var", EXPR_CMDARG)
2661
2729
  end
2662
2730
 
2663
2731
  def test_yylex_underscore_end
@@ -2669,46 +2737,46 @@ class TestRubyLexer < Minitest::Test
2669
2737
  def test_yylex_uplus
2670
2738
  assert_lex3("+blah",
2671
2739
  nil,
2672
- :tUPLUS, "+", :expr_beg,
2673
- :tIDENTIFIER, "blah", :expr_arg)
2740
+ :tUPLUS, "+", EXPR_BEG,
2741
+ :tIDENTIFIER, "blah", EXPR_ARG)
2674
2742
  end
2675
2743
 
2676
2744
  def test_zbug_float_in_decl
2677
2745
  assert_lex3("def initialize(u = 0.0, s = 0.0",
2678
2746
  nil,
2679
- :kDEF, "def", :expr_fname,
2680
- :tIDENTIFIER, "initialize", :expr_endfn,
2681
- :tLPAREN2, "(", :expr_beg,
2682
- :tIDENTIFIER, "u", :expr_arg,
2683
- :tEQL, "=", :expr_beg,
2684
- :tFLOAT, 0.0, :expr_end,
2685
- :tCOMMA, ",", :expr_beg,
2686
- :tIDENTIFIER, "s", :expr_arg,
2687
- :tEQL, "=", :expr_beg,
2688
- :tFLOAT, 0.0, :expr_end)
2747
+ :kDEF, "def", EXPR_FNAME,
2748
+ :tIDENTIFIER, "initialize", EXPR_ENDFN,
2749
+ :tLPAREN2, "(", EXPR_PAR,
2750
+ :tIDENTIFIER, "u", EXPR_ARG,
2751
+ :tEQL, "=", EXPR_BEG,
2752
+ :tFLOAT, 0.0, EXPR_NUM,
2753
+ :tCOMMA, ",", EXPR_PAR,
2754
+ :tIDENTIFIER, "s", EXPR_ARG,
2755
+ :tEQL, "=", EXPR_BEG,
2756
+ :tFLOAT, 0.0, EXPR_NUM)
2689
2757
  end
2690
2758
 
2691
2759
  def test_zbug_id_equals
2692
2760
  assert_lex3("a = 0.0",
2693
2761
  nil,
2694
- :tIDENTIFIER, "a", :expr_cmdarg,
2695
- :tEQL, "=", :expr_beg,
2696
- :tFLOAT, 0.0, :expr_end)
2762
+ :tIDENTIFIER, "a", EXPR_CMDARG,
2763
+ :tEQL, "=", EXPR_BEG,
2764
+ :tFLOAT, 0.0, EXPR_NUM)
2697
2765
  end
2698
2766
 
2699
2767
  def test_zbug_no_spaces_in_decl
2700
2768
  assert_lex3("def initialize(u=0.0,s=0.0",
2701
2769
  nil,
2702
- :kDEF, "def", :expr_fname,
2703
- :tIDENTIFIER, "initialize", :expr_endfn,
2704
- :tLPAREN2, "(", :expr_beg,
2705
- :tIDENTIFIER, "u", :expr_arg,
2706
- :tEQL, "=", :expr_beg,
2707
- :tFLOAT, 0.0, :expr_end,
2708
- :tCOMMA, ",", :expr_beg,
2709
- :tIDENTIFIER, "s", :expr_arg,
2710
- :tEQL, "=", :expr_beg,
2711
- :tFLOAT, 0.0, :expr_end)
2770
+ :kDEF, "def", EXPR_FNAME,
2771
+ :tIDENTIFIER, "initialize", EXPR_ENDFN,
2772
+ :tLPAREN2, "(", EXPR_PAR,
2773
+ :tIDENTIFIER, "u", EXPR_ARG,
2774
+ :tEQL, "=", EXPR_BEG,
2775
+ :tFLOAT, 0.0, EXPR_NUM,
2776
+ :tCOMMA, ",", EXPR_PAR,
2777
+ :tIDENTIFIER, "s", EXPR_ARG,
2778
+ :tEQL, "=", EXPR_BEG,
2779
+ :tFLOAT, 0.0, EXPR_NUM)
2712
2780
  end
2713
2781
 
2714
2782
  def test_pct_w_backslashes
@@ -2718,12 +2786,12 @@ class TestRubyLexer < Minitest::Test
2718
2786
  assert_lex("%w[foo#{char}bar]",
2719
2787
  s(:array, s(:str, "foo"), s(:str, "bar")),
2720
2788
 
2721
- :tQWORDS_BEG, "%w[", :expr_beg, 0, 0,
2722
- :tSTRING_CONTENT, "foo", :expr_beg, 0, 0,
2723
- :tSPACE, nil, :expr_beg, 0, 0,
2724
- :tSTRING_CONTENT, "bar", :expr_beg, 0, 0,
2725
- :tSPACE, nil, :expr_beg, 0, 0,
2726
- :tSTRING_END, nil, :expr_end, 0, 0)
2789
+ :tQWORDS_BEG, "%w[", EXPR_BEG, 0, 0,
2790
+ :tSTRING_CONTENT, "foo", EXPR_BEG, 0, 0,
2791
+ :tSPACE, nil, EXPR_BEG, 0, 0,
2792
+ :tSTRING_CONTENT, "bar", EXPR_BEG, 0, 0,
2793
+ :tSPACE, nil, EXPR_BEG, 0, 0,
2794
+ :tSTRING_END, nil, EXPR_END, 0, 0)
2727
2795
  end
2728
2796
  end
2729
2797
 
@@ -2731,17 +2799,17 @@ class TestRubyLexer < Minitest::Test
2731
2799
  assert_lex(":'a'",
2732
2800
  s(:lit, :a),
2733
2801
 
2734
- :tSYMBOL, "a", :expr_end, 0, 0)
2802
+ :tSYMBOL, "a", EXPR_END, 0, 0)
2735
2803
  end
2736
2804
 
2737
2805
  def test_yylex_hash_colon
2738
2806
  assert_lex("{a:1}",
2739
2807
  s(:hash, s(:lit, :a), s(:lit, 1)),
2740
2808
 
2741
- :tLBRACE, "{", :expr_beg, 0, 1,
2742
- :tLABEL, "a", :expr_labeled, 0, 1,
2743
- :tINTEGER, 1, :expr_end, 0, 1,
2744
- :tRCURLY, "}", :expr_endarg, 0, 0)
2809
+ :tLBRACE, "{", EXPR_PAR, 0, 1,
2810
+ :tLABEL, "a", EXPR_LAB, 0, 1,
2811
+ :tINTEGER, 1, EXPR_NUM, 0, 1,
2812
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
2745
2813
  end
2746
2814
 
2747
2815
  def test_yylex_hash_colon_quoted_22
@@ -2750,10 +2818,10 @@ class TestRubyLexer < Minitest::Test
2750
2818
  assert_lex("{'a':1}",
2751
2819
  s(:hash, s(:lit, :a), s(:lit, 1)),
2752
2820
 
2753
- :tLBRACE, "{", :expr_beg, 0, 1,
2754
- :tLABEL, "a", :expr_labeled, 0, 1,
2755
- :tINTEGER, 1, :expr_end, 0, 1,
2756
- :tRCURLY, "}", :expr_endarg, 0, 0)
2821
+ :tLBRACE, "{", EXPR_PAR, 0, 1,
2822
+ :tLABEL, "a", EXPR_LAB, 0, 1,
2823
+ :tINTEGER, 1, EXPR_NUM, 0, 1,
2824
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
2757
2825
  end
2758
2826
 
2759
2827
  def test_yylex_hash_colon_quoted_symbol_22
@@ -2762,10 +2830,10 @@ class TestRubyLexer < Minitest::Test
2762
2830
  assert_lex("{'abc': :b}",
2763
2831
  s(:hash, s(:lit, :abc), s(:lit, :b)),
2764
2832
 
2765
- :tLBRACE, "{", :expr_beg, 0, 1,
2766
- :tLABEL, "abc", :expr_labeled, 0, 1,
2767
- :tSYMBOL, "b", :expr_end, 0, 1,
2768
- :tRCURLY, "}", :expr_endarg, 0, 0)
2833
+ :tLBRACE, "{", EXPR_PAR, 0, 1,
2834
+ :tLABEL, "abc", EXPR_LAB, 0, 1,
2835
+ :tSYMBOL, "b", EXPR_END, 0, 1,
2836
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
2769
2837
  end
2770
2838
 
2771
2839
  def test_yylex_hash_colon_double_quoted_symbol_22
@@ -2774,10 +2842,10 @@ class TestRubyLexer < Minitest::Test
2774
2842
  assert_lex('{"abc": :b}',
2775
2843
  s(:hash, s(:lit, :abc), s(:lit, :b)),
2776
2844
 
2777
- :tLBRACE, "{", :expr_beg, 0, 1,
2778
- :tLABEL, "abc", :expr_labeled, 0, 1,
2779
- :tSYMBOL, "b", :expr_end, 0, 1,
2780
- :tRCURLY, "}", :expr_endarg, 0, 0)
2845
+ :tLBRACE, "{", EXPR_PAR, 0, 1,
2846
+ :tLABEL, "abc", EXPR_LAB, 0, 1,
2847
+ :tSYMBOL, "b", EXPR_END, 0, 1,
2848
+ :tRCURLY, "}", EXPR_ENDARG, 0, 0)
2781
2849
  end
2782
2850
 
2783
2851
  def test_yylex_required_kwarg_no_value_22
@@ -2785,12 +2853,12 @@ class TestRubyLexer < Minitest::Test
2785
2853
 
2786
2854
  assert_lex3("def foo a:, b:\nend",
2787
2855
  nil,
2788
- :kDEF, "def", :expr_fname,
2789
- :tIDENTIFIER, "foo", :expr_endfn,
2790
- :tLABEL, "a", :expr_labeled,
2791
- :tCOMMA, ",", :expr_beg,
2792
- :tLABEL, "b", :expr_labeled,
2793
- :kEND, "end", :expr_end)
2856
+ :kDEF, "def", EXPR_FNAME,
2857
+ :tIDENTIFIER, "foo", EXPR_ENDFN,
2858
+ :tLABEL, "a", EXPR_LAB,
2859
+ :tCOMMA, ",", EXPR_PAR,
2860
+ :tLABEL, "b", EXPR_LAB,
2861
+ :kEND, "end", EXPR_END)
2794
2862
  end
2795
2863
 
2796
2864
  def test_yylex_hash_colon_double_quoted_with_escapes
@@ -2799,10 +2867,10 @@ class TestRubyLexer < Minitest::Test
2799
2867
  assert_lex3("{\"s\\tr\\i\\ng\\\\foo\\'bar\":1}",
2800
2868
  nil,
2801
2869
 
2802
- :tLBRACE, "{", :expr_beg,
2803
- :tLABEL, "s\tr\i\ng\\foo'bar", :expr_labeled,
2804
- :tINTEGER, 1, :expr_end,
2805
- :tRCURLY, "}", :expr_endarg)
2870
+ :tLBRACE, "{", EXPR_PAR,
2871
+ :tLABEL, "s\tr\i\ng\\foo'bar", EXPR_LAB,
2872
+ :tINTEGER, 1, EXPR_NUM,
2873
+ :tRCURLY, "}", EXPR_ENDARG)
2806
2874
  end
2807
2875
 
2808
2876
  def test_yylex_hash_colon_quoted_with_escapes
@@ -2811,87 +2879,80 @@ class TestRubyLexer < Minitest::Test
2811
2879
  assert_lex3("{'s\\tr\\i\\ng\\\\foo\\'bar':1}",
2812
2880
  nil,
2813
2881
 
2814
- :tLBRACE, "{", :expr_beg,
2815
- :tLABEL, "s\\tr\\i\\ng\\foo'bar", :expr_labeled,
2816
- :tINTEGER, 1, :expr_end,
2817
- :tRCURLY, "}", :expr_endarg)
2882
+ :tLBRACE, "{", EXPR_PAR,
2883
+ :tLABEL, "s\\tr\\i\\ng\\foo'bar", EXPR_LAB,
2884
+ :tINTEGER, 1, EXPR_NUM,
2885
+ :tRCURLY, "}", EXPR_ENDARG)
2818
2886
  end
2819
2887
 
2820
2888
  def test_ruby21_rational_literal
2821
2889
  setup_lexer_class RubyParser::V21
2822
2890
 
2823
- assert_lex3("10r", nil, :tRATIONAL, Rational(10), :expr_end)
2824
- assert_lex3("0x10r", nil, :tRATIONAL, Rational(16), :expr_end)
2825
- assert_lex3("0o10r", nil, :tRATIONAL, Rational(8), :expr_end)
2826
- assert_lex3("0or", nil, :tRATIONAL, Rational(0), :expr_end)
2827
- assert_lex3("0b10r", nil, :tRATIONAL, Rational(2), :expr_end)
2828
- assert_lex3("1.5r", nil, :tRATIONAL, Rational(15, 10), :expr_end)
2829
- assert_lex3("15e3r", nil, :tRATIONAL, Rational(15000), :expr_end)
2830
- assert_lex3("15e-3r", nil, :tRATIONAL, Rational(15, 1000), :expr_end)
2831
- assert_lex3("1.5e3r", nil, :tRATIONAL, Rational(1500), :expr_end)
2832
- assert_lex3("1.5e-3r", nil, :tRATIONAL, Rational(15, 10000), :expr_end)
2891
+ assert_lex3("10r", nil, :tRATIONAL, Rational(10), EXPR_NUM)
2892
+ assert_lex3("0x10r", nil, :tRATIONAL, Rational(16), EXPR_NUM)
2893
+ assert_lex3("0o10r", nil, :tRATIONAL, Rational(8), EXPR_NUM)
2894
+ assert_lex3("0or", nil, :tRATIONAL, Rational(0), EXPR_NUM)
2895
+ assert_lex3("0b10r", nil, :tRATIONAL, Rational(2), EXPR_NUM)
2896
+ assert_lex3("1.5r", nil, :tRATIONAL, Rational(15, 10), EXPR_NUM)
2897
+ assert_lex3("15e3r", nil, :tRATIONAL, Rational(15000), EXPR_NUM)
2898
+ assert_lex3("15e-3r", nil, :tRATIONAL, Rational(15, 1000), EXPR_NUM)
2899
+ assert_lex3("1.5e3r", nil, :tRATIONAL, Rational(1500), EXPR_NUM)
2900
+ assert_lex3("1.5e-3r", nil, :tRATIONAL, Rational(15, 10000), EXPR_NUM)
2833
2901
 
2834
2902
  assert_lex3("-10r", nil,
2835
- :tUMINUS_NUM, "-", :expr_beg,
2836
- :tRATIONAL, Rational(10), :expr_end)
2903
+ :tUMINUS_NUM, "-", EXPR_BEG,
2904
+ :tRATIONAL, Rational(10), EXPR_NUM)
2837
2905
  end
2838
2906
 
2839
2907
  def test_ruby21_imaginary_literal
2840
2908
  setup_lexer_class RubyParser::V21
2841
2909
 
2842
- assert_lex3("1i", nil, :tIMAGINARY, Complex(0, 1), :expr_end)
2843
- assert_lex3("0x10i", nil, :tIMAGINARY, Complex(0, 16), :expr_end)
2844
- assert_lex3("0o10i", nil, :tIMAGINARY, Complex(0, 8), :expr_end)
2845
- assert_lex3("0oi", nil, :tIMAGINARY, Complex(0, 0), :expr_end)
2846
- assert_lex3("0b10i", nil, :tIMAGINARY, Complex(0, 2), :expr_end)
2847
- assert_lex3("1.5i", nil, :tIMAGINARY, Complex(0, 1.5), :expr_end)
2848
- assert_lex3("15e3i", nil, :tIMAGINARY, Complex(0, 15000), :expr_end)
2849
- assert_lex3("15e-3i", nil, :tIMAGINARY, Complex(0, 0.015), :expr_end)
2850
- assert_lex3("1.5e3i", nil, :tIMAGINARY, Complex(0, 1500), :expr_end)
2851
- assert_lex3("1.5e-3i", nil, :tIMAGINARY, Complex(0, 0.0015), :expr_end)
2910
+ assert_lex3("1i", nil, :tIMAGINARY, Complex(0, 1), EXPR_NUM)
2911
+ assert_lex3("0x10i", nil, :tIMAGINARY, Complex(0, 16), EXPR_NUM)
2912
+ assert_lex3("0o10i", nil, :tIMAGINARY, Complex(0, 8), EXPR_NUM)
2913
+ assert_lex3("0oi", nil, :tIMAGINARY, Complex(0, 0), EXPR_NUM)
2914
+ assert_lex3("0b10i", nil, :tIMAGINARY, Complex(0, 2), EXPR_NUM)
2915
+ assert_lex3("1.5i", nil, :tIMAGINARY, Complex(0, 1.5), EXPR_NUM)
2916
+ assert_lex3("15e3i", nil, :tIMAGINARY, Complex(0, 15000), EXPR_NUM)
2917
+ assert_lex3("15e-3i", nil, :tIMAGINARY, Complex(0, 0.015), EXPR_NUM)
2918
+ assert_lex3("1.5e3i", nil, :tIMAGINARY, Complex(0, 1500), EXPR_NUM)
2919
+ assert_lex3("1.5e-3i", nil, :tIMAGINARY, Complex(0, 0.0015), EXPR_NUM)
2852
2920
 
2853
2921
  assert_lex3("-10i", nil,
2854
- :tUMINUS_NUM, "-", :expr_beg,
2855
- :tIMAGINARY, Complex(0, 10), :expr_end)
2922
+ :tUMINUS_NUM, "-", EXPR_BEG,
2923
+ :tIMAGINARY, Complex(0, 10), EXPR_NUM)
2856
2924
  end
2857
2925
 
2858
2926
  def test_ruby21_rational_imaginary_literal
2859
2927
  setup_lexer_class RubyParser::V21
2860
2928
 
2861
- assert_lex3("1ri", nil, :tIMAGINARY, Complex(0, Rational(1)), :expr_end)
2862
- assert_lex3("0x10ri", nil, :tIMAGINARY, Complex(0, Rational(16)), :expr_end)
2863
- assert_lex3("0o10ri", nil, :tIMAGINARY, Complex(0, Rational(8)), :expr_end)
2864
- assert_lex3("0ori", nil, :tIMAGINARY, Complex(0, Rational(0)), :expr_end)
2865
- assert_lex3("0b10ri", nil, :tIMAGINARY, Complex(0, Rational(2)), :expr_end)
2866
- assert_lex3("1.5ri", nil, :tIMAGINARY, Complex(0, Rational("1.5")), :expr_end)
2867
- assert_lex3("15e3ri", nil, :tIMAGINARY, Complex(0, Rational("15e3")), :expr_end)
2868
- assert_lex3("15e-3ri", nil, :tIMAGINARY, Complex(0, Rational("15e-3")), :expr_end)
2869
- assert_lex3("1.5e3ri", nil, :tIMAGINARY, Complex(0, Rational("1.5e3")), :expr_end)
2870
- assert_lex3("1.5e-3ri", nil, :tIMAGINARY, Complex(0, Rational("1.5e-3")), :expr_end)
2929
+ assert_lex3 "1ri", nil, :tIMAGINARY, Complex(0, Rational(1)), EXPR_NUM
2930
+ assert_lex3 "0x10ri", nil, :tIMAGINARY, Complex(0, Rational(16)), EXPR_NUM
2931
+ assert_lex3 "0o10ri", nil, :tIMAGINARY, Complex(0, Rational(8)), EXPR_NUM
2932
+ assert_lex3 "0ori", nil, :tIMAGINARY, Complex(0, Rational(0)), EXPR_NUM
2933
+ assert_lex3 "0b10ri", nil, :tIMAGINARY, Complex(0, Rational(2)), EXPR_NUM
2934
+ assert_lex3 "1.5ri", nil, :tIMAGINARY, Complex(0, Rational("1.5")), EXPR_NUM
2935
+ assert_lex3 "15e3ri", nil, :tIMAGINARY, Complex(0, Rational("15e3")), EXPR_NUM
2936
+ assert_lex3 "15e-3ri", nil, :tIMAGINARY, Complex(0, Rational("15e-3")), EXPR_NUM
2937
+ assert_lex3 "1.5e3ri", nil, :tIMAGINARY, Complex(0, Rational("1.5e3")), EXPR_NUM
2938
+ assert_lex3 "1.5e-3ri", nil, :tIMAGINARY, Complex(0, Rational("1.5e-3")), EXPR_NUM
2871
2939
 
2872
2940
  assert_lex3("-10ri", nil,
2873
- :tUMINUS_NUM, "-", :expr_beg,
2874
- :tIMAGINARY, Complex(0, Rational(10)), :expr_end)
2941
+ :tUMINUS_NUM, "-", EXPR_BEG,
2942
+ :tIMAGINARY, Complex(0, Rational(10)), EXPR_NUM)
2875
2943
  end
2876
2944
 
2877
2945
  def test_ruby21_imaginary_literal_with_succeeding_keyword
2878
- skip "Currently does not tokenize correctly"
2879
-
2880
2946
  setup_lexer_class RubyParser::V21
2881
2947
 
2948
+ # 2/4 scenarios are syntax errors on all tested versions so I
2949
+ # deleted them.
2950
+
2882
2951
  assert_lex3("1if", nil,
2883
- :tINTEGER, 1, :expr_end,
2884
- :kIF_MOD, "if", :expr_beg)
2885
- assert_lex3("1rif", nil,
2886
- :tRATIONAL, Rational(1), :expr_end,
2887
- :kIF_MOD, "if", :expr_beg)
2952
+ :tINTEGER, 1, EXPR_NUM,
2953
+ :kIF_MOD, "if", EXPR_PAR)
2888
2954
  assert_lex3("1.0if", nil,
2889
- :tFLOAT, 1.0, :expr_end,
2890
- :kIF_MOD, "if", :expr_beg)
2891
- assert_lex3("1.0rif", nil,
2892
- :tRATIONAL, Rational("1.0"), :expr_end,
2893
- :kIF_MOD, "if", :expr_beg)
2894
-
2895
- flunk
2955
+ :tFLOAT, 1.0, EXPR_NUM,
2956
+ :kIF_MOD, "if", EXPR_PAR)
2896
2957
  end
2897
2958
  end