Class: RuboCop::NodePattern::Compiler

Inherits:
Object
  • Object
show all
Defined in:
lib/rubocop/node_pattern.rb

Overview

Builds Ruby code which implements a pattern

Constant Summary collapse

RSYM = 
%r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}
ID_CHAR = 
/[a-zA-Z_]/
META = 
/\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
NUMBER = 
/-?\d+(?:\.\d+)?/
TOKEN = 
/\G(?:[\s,]+|#{META}|\#?#{ID_CHAR}+[\!\?]?\(?|%\d*|#{NUMBER}|#{RSYM}|.)/
NODE = 
/\A#{ID_CHAR}+\Z/
PREDICATE = 
/\A#{ID_CHAR}+\?\(?\Z/
WILDCARD = 
/\A_#{ID_CHAR}*\Z/
FUNCALL = 
/\A\##{ID_CHAR}+[\!\?]?\(?\Z/
LITERAL = 
/\A(?:#{RSYM}|#{NUMBER}|nil)\Z/
PARAM = 
/\A%\d*\Z/
CLOSING = 
/\A(?:\)|\}|\])\Z/

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(str, node_var = 'node0') ⇒ Compiler

Returns a new instance of Compiler.



117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/rubocop/node_pattern.rb', line 117

def initialize(str, node_var = 'node0')
  @string   = str
  @root     = node_var

  @temps    = 0  # avoid name clashes between temp variables
  @captures = 0  # number of captures seen
  @unify    = {} # named wildcard -> temp variable number
  @params   = 0  # highest % (param) number seen

  run(node_var)
end

Instance Attribute Details

#match_code ⇒ Object (readonly)

Returns the value of attribute match_code.



115
116
117
 
# File 'lib/rubocop/node_pattern.rb', line 115

def match_code
  @match_code
end

Instance Method Details

#compile_arg(token) ⇒ Object 



384
385
386
387
388
389
390
391
392
393
394
395
396
 
# File 'lib/rubocop/node_pattern.rb', line 384

def compile_arg(token)
  case token
  when WILDCARD  then
    name   = token[1..-1]
    number = @unify[name] || fail_due_to('invalid in arglist: ' + token)
    "temp#{number}"
  when LITERAL   then token
  when PARAM     then get_param(token[1..-1])
  when CLOSING   then fail_due_to("#{token} in invalid position")
  when nil       then fail_due_to('pattern ended prematurely')
  else fail_due_to("invalid token in arglist: #{token.inspect}")
  end
end

#compile_args(tokens) ⇒ Object 



377
378
379
380
381
382
 
# File 'lib/rubocop/node_pattern.rb', line 377

def compile_args(tokens)
  args = []
  args << compile_arg(tokens.shift) until tokens.first == ')'
  tokens.shift # drop the )
  args
end

#compile_ascend(tokens, cur_node, seq_head) ⇒ Object 



322
323
324
325
 
# File 'lib/rubocop/node_pattern.rb', line 322

def compile_ascend(tokens, cur_node, seq_head)
  "(#{cur_node}.parent && " \
    "#{compile_expr(tokens, "#{cur_node}.parent", seq_head)})"
end

#compile_capt_ellip(tokens, cur_node, terms, index) ⇒ Object 



229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/rubocop/node_pattern.rb', line 229

def compile_capt_ellip(tokens, cur_node, terms, index)
  capture = next_capture
  if (term = compile_seq_tail(tokens, "#{cur_node}.children.last"))
    terms << "(#{cur_node}.children.size > #{index})"
    terms << term
    terms << "(#{capture} = #{cur_node}.children[#{index}..-2])"
  else
    terms << "(#{cur_node}.children.size >= #{index})" if index > 0
    terms << "(#{capture} = #{cur_node}.children[#{index}..-1])"
  end
  terms
end

#compile_capture(tokens, cur_node, seq_head) ⇒ Object 



313
314
315
316
 
# File 'lib/rubocop/node_pattern.rb', line 313

def compile_capture(tokens, cur_node, seq_head)
  "(#{next_capture} = #{cur_node}#{'.type' if seq_head}; " \
    "#{compile_expr(tokens, cur_node, seq_head)})"
end

#compile_ellipsis(tokens, cur_node, terms, index) ⇒ Object 



219
220
221
222
223
224
225
226
227
 
# File 'lib/rubocop/node_pattern.rb', line 219

def compile_ellipsis(tokens, cur_node, terms, index)
  if (term = compile_seq_tail(tokens, "#{cur_node}.children.last"))
    terms << "(#{cur_node}.children.size > #{index})"
    terms << term
  elsif index > 0
    terms << "(#{cur_node}.children.size >= #{index})"
  end
  terms
end

#compile_expr(tokens, cur_node, seq_head) ⇒ Object

rubocop:disable Metrics/MethodLength, Metrics/AbcSize



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/rubocop/node_pattern.rb', line 137

def compile_expr(tokens, cur_node, seq_head)
  # read a single pattern-matching expression from the token stream,
  # return Ruby code which performs the corresponding matching operation
  # on 'cur_node' (which is Ruby code which evaluates to an AST node)
  #
  # the 'pattern-matching' expression may be a composite which
  # contains an arbitrary number of sub-expressions
  token = tokens.shift
  case token
  when '('       then compile_seq(tokens, cur_node, seq_head)
  when '{'       then compile_union(tokens, cur_node, seq_head)
  when '['       then compile_intersect(tokens, cur_node, seq_head)
  when '!'       then compile_negation(tokens, cur_node, seq_head)
  when '$'       then compile_capture(tokens, cur_node, seq_head)
  when '^'       then compile_ascend(tokens, cur_node, seq_head)
  when WILDCARD  then compile_wildcard(cur_node, token[1..-1], seq_head)
  when FUNCALL   then compile_funcall(tokens, cur_node, token, seq_head)
  when LITERAL   then compile_literal(cur_node, token, seq_head)
  when PREDICATE then compile_predicate(tokens, cur_node, token, seq_head)
  when NODE      then compile_nodetype(cur_node, token)
  when PARAM     then compile_param(cur_node, token[1..-1], seq_head)
  when CLOSING   then fail_due_to("#{token} in invalid position")
  when nil       then fail_due_to('pattern ended prematurely')
  else fail_due_to("invalid token #{token.inspect}")
  end
end

#compile_expr_with_capture_check(tokens, temp_node, seq_head, before, after) ⇒ Object 



288
289
290
291
292
293
294
295
296
297
 
# File 'lib/rubocop/node_pattern.rb', line 288

def compile_expr_with_capture_check(tokens, temp_node, seq_head, before,
                                    after)
  @captures = before
  expr = compile_expr(tokens, temp_node, seq_head)
  if @captures != after
    fail_due_to('each branch of {} must have same # of captures')
  end

  expr
end

#compile_expr_with_captures(tokens, temp_node, seq_head) {|expr, captures_before, @captures| ... } ⇒ Object

Yields:

  • (expr, captures_before, @captures) 


281
282
283
284
285
286
 
# File 'lib/rubocop/node_pattern.rb', line 281

def compile_expr_with_captures(tokens, temp_node, seq_head)
  captures_before = @captures
  expr = compile_expr(tokens, temp_node, seq_head)

  yield expr, captures_before, @captures
end

#compile_expr_with_index(tokens, cur_node, index) ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/rubocop/node_pattern.rb', line 207

def compile_expr_with_index(tokens, cur_node, index)
  if index.nil?
    # in 'sequence head' position; some expressions are compiled
    # differently at 'sequence head' (notably 'node type' expressions)
    # grep for seq_head to see where it makes a difference
    [compile_expr(tokens, cur_node, true), 0]
  else
    child_node = "#{cur_node}.children[#{index}]"
    [compile_expr(tokens, child_node, false), index + 1]
  end
end

#compile_funcall(tokens, cur_node, method, seq_head) ⇒ Object 



356
357
358
359
360
361
362
363
364
365
366
367
 
# File 'lib/rubocop/node_pattern.rb', line 356

def compile_funcall(tokens, cur_node, method, seq_head)
  # call a method in the context which this pattern-matching
  # code is used in. pass target value as an argument
  method = method[1..-1] # drop the leading #
  if method.end_with?('(') # is there an arglist?
    args = compile_args(tokens)
    method = method[0..-2] # drop the trailing (
    "(#{method}(#{cur_node}#{'.type' if seq_head}),#{args.join(',')})"
  else
    "(#{method}(#{cur_node}#{'.type' if seq_head}))"
  end
end

#compile_intersect(tokens, cur_node, seq_head) ⇒ Object 



299
300
301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/rubocop/node_pattern.rb', line 299

def compile_intersect(tokens, cur_node, seq_head)
  fail_due_to('empty intersection') if tokens.first == ']'

  with_temp_node(cur_node) do |init, temp_node|
    terms = []
    until tokens.first == ']'
      terms << compile_expr(tokens, temp_node, seq_head)
    end
    tokens.shift

    join_terms(init, terms, ' && ')
  end
end

#compile_literal(cur_node, literal, seq_head) ⇒ Object 



342
343
344
 
# File 'lib/rubocop/node_pattern.rb', line 342

def compile_literal(cur_node, literal, seq_head)
  "(#{cur_node}#{'.type' if seq_head} == #{literal})"
end

#compile_negation(tokens, cur_node, seq_head) ⇒ Object 



318
319
320
 
# File 'lib/rubocop/node_pattern.rb', line 318

def compile_negation(tokens, cur_node, seq_head)
  "(!#{compile_expr(tokens, cur_node, seq_head)})"
end

#compile_nodetype(cur_node, type) ⇒ Object 



369
370
371
 
# File 'lib/rubocop/node_pattern.rb', line 369

def compile_nodetype(cur_node, type)
  "(#{cur_node} && #{cur_node}.#{type}_type?)"
end

#compile_param(cur_node, number, seq_head) ⇒ Object 



373
374
375
 
# File 'lib/rubocop/node_pattern.rb', line 373

def compile_param(cur_node, number, seq_head)
  "(#{cur_node}#{'.type' if seq_head} == #{get_param(number)})"
end

#compile_predicate(tokens, cur_node, predicate, seq_head) ⇒ Object 



346
347
348
349
350
351
352
353
354
 
# File 'lib/rubocop/node_pattern.rb', line 346

def compile_predicate(tokens, cur_node, predicate, seq_head)
  if predicate.end_with?('(') # is there an arglist?
    args = compile_args(tokens)
    predicate = predicate[0..-2] # drop the trailing (
    "(#{cur_node}#{'.type' if seq_head}.#{predicate}(#{args.join(',')}))"
  else
    "(#{cur_node}#{'.type' if seq_head}.#{predicate})"
  end
end

#compile_seq(tokens, cur_node, seq_head) ⇒ Object

rubocop:enable Metrics/MethodLength, Metrics/AbcSize



165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/rubocop/node_pattern.rb', line 165

def compile_seq(tokens, cur_node, seq_head)
  fail_due_to('empty parentheses') if tokens.first == ')'
  fail_due_to('parentheses at sequence head') if seq_head

  # 'cur_node' is a Ruby expression which evaluates to an AST node,
  # but we don't know how expensive it is
  # to be safe, cache the node in a temp variable and then use the
  # temp variable as 'cur_node'
  with_temp_node(cur_node) do |init, temp_node|
    terms = compile_seq_terms(tokens, temp_node)

    join_terms(init, terms, ' && ')
  end
end

#compile_seq_tail(tokens, cur_node) ⇒ Object 



242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/rubocop/node_pattern.rb', line 242

def compile_seq_tail(tokens, cur_node)
  tokens.shift
  if tokens.first == ')'
    tokens.shift
    nil
  else
    expr = compile_expr(tokens, cur_node, false)
    fail_due_to('missing )') unless tokens.shift == ')'
    expr
  end
end

#compile_seq_terms(tokens, cur_node) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/rubocop/node_pattern.rb', line 180

def compile_seq_terms(tokens, cur_node)
  ret, size =
    compile_seq_terms_with_size(tokens, cur_node) do |token, terms, index|
      case token
      when '...'.freeze
        return compile_ellipsis(tokens, cur_node, terms, index)
      when '$...'.freeze
        return compile_capt_ellip(tokens, cur_node, terms, index)
      end
    end

  ret << "(#{cur_node}.children.size == #{size})"
end

#compile_seq_terms_with_size(tokens, cur_node) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/rubocop/node_pattern.rb', line 194

def compile_seq_terms_with_size(tokens, cur_node)
  index = nil
  terms = []
  until tokens.first == ')'
    yield tokens.first, terms, index || 0
    term, index = compile_expr_with_index(tokens, cur_node, index)
    terms << term
  end

  tokens.shift # drop concluding )
  [terms, index]
end

#compile_union(tokens, cur_node, seq_head) ⇒ Object 



254
255
256
257
258
259
260
261
 
# File 'lib/rubocop/node_pattern.rb', line 254

def compile_union(tokens, cur_node, seq_head)
  fail_due_to('empty union') if tokens.first == '}'

  with_temp_node(cur_node) do |init, temp_node|
    terms = union_terms(tokens, temp_node, seq_head)
    join_terms(init, terms, ' || ')
  end
end

#compile_wildcard(cur_node, name, seq_head) ⇒ Object 



327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/rubocop/node_pattern.rb', line 327

def compile_wildcard(cur_node, name, seq_head)
  if name.empty?
    'true'
  elsif @unify.key?(name)
    # we have already seen a wildcard with this name before
    # so the value it matched the first time will already be stored
    # in a temp. check if this value matches the one stored in the temp
    "(#{cur_node}#{'.type' if seq_head} == temp#{@unify[name]})"
  else
    n = @unify[name] = next_temp_value
    # double assign to temp#{n} to avoid "assigned but unused variable"
    "(temp#{n} = temp#{n} = #{cur_node}#{'.type' if seq_head}; true)"
  end
end

#emit_capture_list ⇒ Object 



412
413
414
 
# File 'lib/rubocop/node_pattern.rb', line 412

def emit_capture_list
  (1..@captures).map { |n| "capture#{n}" }.join(',')
end

#emit_method_code ⇒ Object 



435
436
437
438
439
440
 
# File 'lib/rubocop/node_pattern.rb', line 435

def emit_method_code
  <<-CODE
    return nil unless #{@match_code}
    block_given? ? yield(#{emit_capture_list}) : (return #{emit_retval})
  CODE
end

#emit_param_list ⇒ Object 



426
427
428
 
# File 'lib/rubocop/node_pattern.rb', line 426

def emit_param_list
  (1..@params).map { |n| "param#{n}" }.join(',')
end

#emit_retval ⇒ Object 



416
417
418
419
420
421
422
423
424
 
# File 'lib/rubocop/node_pattern.rb', line 416

def emit_retval
  if @captures.zero?
    'true'
  elsif @captures == 1
    'capture1'
  else
    "[#{emit_capture_list}]"
  end
end

#emit_trailing_params ⇒ Object 



430
431
432
433
 
# File 'lib/rubocop/node_pattern.rb', line 430

def emit_trailing_params
  params = emit_param_list
  params.empty? ? '' : ",#{params}"
end

#fail_due_to(message) ⇒ Object

Raises:



442
443
444
 
# File 'lib/rubocop/node_pattern.rb', line 442

def fail_due_to(message)
  raise Invalid, "Couldn't compile due to #{message}. Pattern: #{@string}"
end

#get_param(number) ⇒ Object 



402
403
404
405
406
 
# File 'lib/rubocop/node_pattern.rb', line 402

def get_param(number)
  number = number.empty? ? 1 : Integer(number)
  @params = number if number > @params
  number.zero? ? @root : "param#{number}"
end

#join_terms(init, terms, operator) ⇒ Object 



408
409
410
 
# File 'lib/rubocop/node_pattern.rb', line 408

def join_terms(init, terms, operator)
  "(#{init};#{terms.join(operator)})"
end

#next_capture ⇒ Object 



398
399
400
 
# File 'lib/rubocop/node_pattern.rb', line 398

def next_capture
  "capture#{@captures += 1}"
end

#next_temp_value ⇒ Object 



457
458
459
 
# File 'lib/rubocop/node_pattern.rb', line 457

def next_temp_value
  @temps += 1
end

#run(node_var) ⇒ Object 



129
130
131
132
133
134
 
# File 'lib/rubocop/node_pattern.rb', line 129

def run(node_var)
  tokens = @string.scan(TOKEN)
  tokens.reject! { |token| token =~ /\A[\s,]+\Z/ } # drop whitespace
  @match_code = compile_expr(tokens, node_var, false)
  fail_due_to('unbalanced pattern') unless tokens.empty?
end

#union_terms(tokens, temp_node, seq_head) ⇒ Object 



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/rubocop/node_pattern.rb', line 263

def union_terms(tokens, temp_node, seq_head)
  # we need to ensure that each branch of the {} contains the same
  # number of captures (since only one branch of the {} can actually
  # match, the same variables are used to hold the captures for each
  # branch)
  compile_expr_with_captures(tokens,
                             temp_node, seq_head) do |term, before, after|
    terms = [term]
    until tokens.first == '}'
      terms << compile_expr_with_capture_check(tokens, temp_node,
                                               seq_head, before, after)
    end
    tokens.shift

    terms
  end
end

#with_temp_node(cur_node) ⇒ Object 



446
447
448
449
450
451
 
# File 'lib/rubocop/node_pattern.rb', line 446

def with_temp_node(cur_node)
  with_temp_variable do |temp_var|
    # double assign to temp#{n} to avoid "assigned but unused variable"
    yield "#{temp_var} = #{temp_var} = #{cur_node}", temp_var
  end
end

#with_temp_variable {|"temp#{next_temp_value}"| ... } ⇒ Object

Yields:



453
454
455
 
# File 'lib/rubocop/node_pattern.rb', line 453

def with_temp_variable
  yield "temp#{next_temp_value}"
end