Class: RuboCop::AST::Node

Inherits:
Parser::AST::Node
  • Object
show all
Extended by:
RuboCop::AST::NodePattern::Macros
Includes:
Descendence, Sexp
Defined in:
lib/rubocop/ast/node.rb

Overview

‘RuboCop::AST::Node` is a subclass of `Parser::AST::Node`. It provides access to parent nodes and an object-oriented way to traverse an AST with the power of `Enumerable`.

It has predicate methods for every node type, like this:

Examples:

node.send_type?    # Equivalent to: `node.type == :send`
node.op_asgn_type? # Equivalent to: `node.type == :op_asgn`

# Non-word characters (other than a-zA-Z0-9_) in type names are omitted.
node.defined_type? # Equivalent to: `node.type == :defined?`

# Find the first lvar node under the receiver node.
lvar_node = node.each_descendant.find(&:lvar_type?)

Constant Summary collapse

COMPARISON_OPERATORS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.

<=> isn’t included here, because it doesn’t return a boolean.

%i[== === != <= >= > <].to_set.freeze
TRUTHY_LITERALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[str dstr xstr int float sym dsym array
hash regexp true irange erange complex
rational regopt].to_set.freeze
FALSEY_LITERALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[false nil].to_set.freeze
LITERALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

(TRUTHY_LITERALS + FALSEY_LITERALS).freeze
COMPOSITE_LITERALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[dstr xstr dsym array hash irange
erange regexp].to_set.freeze
BASIC_LITERALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

(LITERALS - COMPOSITE_LITERALS).freeze
MUTABLE_LITERALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[str dstr xstr array hash
regexp irange erange].to_set.freeze
IMMUTABLE_LITERALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

(LITERALS - MUTABLE_LITERALS).freeze
EQUALS_ASSIGNMENTS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[lvasgn ivasgn cvasgn gvasgn
casgn masgn].to_set.freeze
SHORTHAND_ASSIGNMENTS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[op_asgn or_asgn and_asgn].to_set.freeze
ASSIGNMENTS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

(EQUALS_ASSIGNMENTS + SHORTHAND_ASSIGNMENTS).freeze
BASIC_CONDITIONALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[if while until].to_set.freeze
CONDITIONALS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

(BASIC_CONDITIONALS + %i[case case_match]).freeze
POST_CONDITION_LOOP_TYPES =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[while_post until_post].to_set.freeze
LOOP_TYPES =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

(POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze
VARIABLES =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[ivar gvar cvar lvar].to_set.freeze
REFERENCES =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[nth_ref back_ref].to_set.freeze
KEYWORDS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[alias and break case class def defs defined?
kwbegin do else ensure for if module next
not or postexe redo rescue retry return self
super zsuper then undef until when while
yield].to_set.freeze
OPERATOR_KEYWORDS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[and or].to_set.freeze
SPECIAL_KEYWORDS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%w[__FILE__ __LINE__ __ENCODING__].to_set.freeze
ARGUMENT_TYPES =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

%i[arg optarg restarg kwarg kwoptarg kwrestarg
blockarg forward_arg shadowarg].to_set.freeze

Instance Method Summary collapse

Methods included from RuboCop::AST::NodePattern::Macros

def_node_matcher, def_node_search

Methods included from Descendence

#child_nodes, #descendants, #each_child_node, #each_descendant, #each_node

Methods included from Sexp

#s

Constructor Details

#initialize(type, children = EMPTY_CHILDREN, properties = EMPTY_PROPERTIES) ⇒ Node

Returns a new instance of Node.

See Also:



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/rubocop/ast/node.rb', line 92

def initialize(type, children = EMPTY_CHILDREN, properties = EMPTY_PROPERTIES)
  @mutable_attributes = {}

  # ::AST::Node#initialize freezes itself.
  super

  # #parent= may be invoked multiple times for a node because there are
  # pending nodes while constructing AST and they are replaced later.
  # For example, `lvar` and `send` type nodes are initially created as an
  # `ident` type node and fixed to the appropriate type later.
  # So, the #parent attribute needs to be mutable.
  each_child_node do |child_node|
    child_node.parent = self unless child_node.complete?
  end
end

Instance Method Details

#ancestors ⇒ Array<Node>

Returns an array of ancestor nodes. This is a shorthand for ‘node.each_ancestor.to_a`.

Returns:

  • (Array<Node>) —

    an array of ancestor nodes



247
248
249
 
# File 'lib/rubocop/ast/node.rb', line 247

def ancestors
  each_ancestor.to_a
end

#argument? ⇒ Boolean

Returns:

  • (Boolean) 


464
465
466
 
# File 'lib/rubocop/ast/node.rb', line 464

def argument?
  parent&.send_type? && parent.arguments.include?(self)
end

#argument_type? ⇒ Boolean

Returns:

  • (Boolean) 


468
469
470
 
# File 'lib/rubocop/ast/node.rb', line 468

def argument_type?
  ARGUMENT_TYPES.include?(type)
end

#assignment? ⇒ Boolean

Returns:

  • (Boolean) 


416
417
418
 
# File 'lib/rubocop/ast/node.rb', line 416

def assignment?
  ASSIGNMENTS.include?(type)
end

#assignment_or_similar?(node = self) ⇒ Object

Some cops treat the shovel operator as a kind of assignment.



355
356
357
 
# File 'lib/rubocop/ast/node.rb', line 355

def_node_matcher :assignment_or_similar?, <<~PATTERN
  {assignment? (send _recv :<< ...)}
PATTERN

#basic_conditional? ⇒ Boolean

Returns:

  • (Boolean) 


420
421
422
 
# File 'lib/rubocop/ast/node.rb', line 420

def basic_conditional?
  BASIC_CONDITIONALS.include?(type)
end

#basic_literal? ⇒ Boolean

Returns:

  • (Boolean) 


363
364
365
 
# File 'lib/rubocop/ast/node.rb', line 363

def basic_literal?
  BASIC_LITERALS.include?(type)
end

#boolean_type? ⇒ Boolean

Returns:

  • (Boolean) 


472
473
474
 
# File 'lib/rubocop/ast/node.rb', line 472

def boolean_type?
  true_type? || false_type?
end

#call_type? ⇒ Boolean

Returns:

  • (Boolean) 


456
457
458
 
# File 'lib/rubocop/ast/node.rb', line 456

def call_type?
  send_type? || csend_type?
end

#chained? ⇒ Boolean

Returns:

  • (Boolean) 


460
461
462
 
# File 'lib/rubocop/ast/node.rb', line 460

def chained?
  parent&.call_type? && eql?(parent.receiver)
end

#class_constructor?(node = self) ⇒ Object 



512
513
514
515
516
517
518
519
520
521
 
# File 'lib/rubocop/ast/node.rb', line 512

def_node_matcher :class_constructor?, <<~PATTERN
  {
    (send #global_const?({:Class :Module :Struct}) :new ...)
    (send #global_const?(:Data) :define ...)
    ({block numblock} {
      (send #global_const?({:Class :Module :Struct}) :new ...)
      (send #global_const?(:Data) :define ...)
    } ...)
  }
PATTERN

#class_definition?(node = self) ⇒ Object 



530
531
532
533
534
 
# File 'lib/rubocop/ast/node.rb', line 530

def_node_matcher :class_definition?, <<~PATTERN
  {(class _ _ $_)
   (sclass _ $_)
   ({block numblock} (send #global_const?({:Struct :Class}) :new ...) _ $_)}
PATTERN

#complete! ⇒ Object 



144
145
146
147
 
# File 'lib/rubocop/ast/node.rb', line 144

def complete!
  @mutable_attributes.freeze
  each_child_node(&:complete!)
end

#complete? ⇒ Boolean

Returns:

  • (Boolean) 


149
150
151
 
# File 'lib/rubocop/ast/node.rb', line 149

def complete?
  @mutable_attributes.frozen?
end

#conditional? ⇒ Boolean

Returns:

  • (Boolean) 


424
425
426
 
# File 'lib/rubocop/ast/node.rb', line 424

def conditional?
  CONDITIONALS.include?(type)
end

#const_name ⇒ Object 



293
294
295
296
297
298
299
300
301
302
 
# File 'lib/rubocop/ast/node.rb', line 293

def const_name
  return unless const_type?

  namespace, name = *self
  if namespace && !namespace.cbase_type?
    "#{namespace.const_name}::#{name}"
  else
    name.to_s
  end
end

#defined_module ⇒ Object 



314
315
316
317
 
# File 'lib/rubocop/ast/node.rb', line 314

def defined_module
  namespace, name = *defined_module0
  s(:const, namespace, name) if name
end

#defined_module_name ⇒ Object 



319
320
321
 
# File 'lib/rubocop/ast/node.rb', line 319

def defined_module_name
  (const = defined_module) && const.const_name
end

#each_ancestor ⇒ self, Enumerator #each_ancestor(type) ⇒ self, Enumerator #each_ancestor(type_a, type_b, ...) ⇒ self, Enumerator

Calls the given block for each ancestor node from parent to root. If no block is given, an ‘Enumerator` is returned.

Overloads:

  • #each_ancestor ⇒ self, Enumerator

    Yield all nodes.

  • #each_ancestor(type) ⇒ self, Enumerator

    Yield only nodes matching the type.

    Parameters:

    • type (Symbol) —

      a node type

  • #each_ancestor(type_a, type_b, ...) ⇒ self, Enumerator

    Yield only nodes matching any of the types.

    Parameters:

    • type_a (Symbol) —

      a node type

    • type_b (Symbol) —

      a node type

Yield Parameters:

  • node (Node) —

    each ancestor node

Returns:

  • (self) —

    if a block is given

  • (Enumerator) —

    if no block is given



235
236
237
238
239
240
241
 
# File 'lib/rubocop/ast/node.rb', line 235

def each_ancestor(*types, &block)
  return to_enum(__method__, *types) unless block

  visit_ancestors(types, &block)

  self
end

#empty_source? ⇒ Boolean

Returns:

  • (Boolean) 


349
350
351
 
# File 'lib/rubocop/ast/node.rb', line 349

def empty_source?
  source_length.zero?
end

#equals_asgn? ⇒ Boolean

Returns:

  • (Boolean) 


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

def equals_asgn?
  EQUALS_ASSIGNMENTS.include?(type)
end

#falsey_literal? ⇒ Boolean

Returns:

  • (Boolean) 


371
372
373
 
# File 'lib/rubocop/ast/node.rb', line 371

def falsey_literal?
  FALSEY_LITERALS.include?(type)
end

#first_line ⇒ Object 



261
262
263
 
# File 'lib/rubocop/ast/node.rb', line 261

def first_line
  loc.line
end

#global_const?(node = self, name) ⇒ Object 



509
 
# File 'lib/rubocop/ast/node.rb', line 509

def_node_matcher :global_const?, '(const {nil? cbase} %1)'

#guard_clause? ⇒ Boolean

Returns:

  • (Boolean) 


484
485
486
487
488
 
# File 'lib/rubocop/ast/node.rb', line 484

def guard_clause?
  node = and_type? || or_type? ? rhs : self

  node.match_guard_clause?
end

#immutable_literal? ⇒ Boolean

Returns:

  • (Boolean) 


379
380
381
 
# File 'lib/rubocop/ast/node.rb', line 379

def immutable_literal?
  IMMUTABLE_LITERALS.include?(type)
end

#keyword? ⇒ Boolean

Returns:

  • (Boolean) 


437
438
439
440
441
442
 
# File 'lib/rubocop/ast/node.rb', line 437

def keyword?
  return true if special_keyword? || (send_type? && prefix_not?)
  return false unless KEYWORDS.include?(type)

  !OPERATOR_KEYWORDS.include?(type) || loc.operator.is?(type.to_s)
end

#lambda?(node = self) ⇒ Object 



503
 
# File 'lib/rubocop/ast/node.rb', line 503

def_node_matcher :lambda?, '({block numblock} (send nil? :lambda) ...)'

#lambda_or_proc?(node = self) ⇒ Object 



506
 
# File 'lib/rubocop/ast/node.rb', line 506

def_node_matcher :lambda_or_proc?, '{lambda? proc?}'

#last_line ⇒ Object 



265
266
267
 
# File 'lib/rubocop/ast/node.rb', line 265

def last_line
  loc.last_line
end

#left_sibling ⇒ Node?

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms

Returns:

  • (Node, nil) —

    the left (aka previous) sibling



187
188
189
190
191
192
 
# File 'lib/rubocop/ast/node.rb', line 187

def left_sibling
  i = sibling_index
  return if i.nil? || i.zero?

  parent.children[i - 1].freeze
end

#left_siblings ⇒ Array<Node>

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms

Returns:

  • (Array<Node>) —

    the left (aka previous) siblings



197
198
199
200
201
 
# File 'lib/rubocop/ast/node.rb', line 197

def left_siblings
  return [].freeze unless parent

  parent.children[0...sibling_index].freeze
end

#line_count ⇒ Object 



269
270
271
272
273
 
# File 'lib/rubocop/ast/node.rb', line 269

def line_count
  return 0 unless source_range

  source_range.last_line - source_range.first_line + 1
end

#literal? ⇒ Boolean

Returns:

  • (Boolean) 


359
360
361
 
# File 'lib/rubocop/ast/node.rb', line 359

def literal?
  LITERALS.include?(type)
end

#loop_keyword? ⇒ Boolean

NOTE: ‘loop { }` is a normal method call and thus not a loop keyword.

Returns:

  • (Boolean) 


433
434
435
 
# File 'lib/rubocop/ast/node.rb', line 433

def loop_keyword?
  LOOP_TYPES.include?(type)
end

#match_guard_clause?(node = self) ⇒ Object 



491
492
493
 
# File 'lib/rubocop/ast/node.rb', line 491

def_node_matcher :match_guard_clause?, <<~PATTERN
  [${(send nil? {:raise :fail} ...) return break next} single_line?]
PATTERN

#module_definition?(node = self) ⇒ Object 



537
538
539
540
 
# File 'lib/rubocop/ast/node.rb', line 537

def_node_matcher :module_definition?, <<~PATTERN
  {(module _ $_)
   ({block numblock} (send #global_const?(:Module) :new ...) _ $_)}
PATTERN

#multiline? ⇒ Boolean

Predicates

Returns:

  • (Boolean) 


341
342
343
 
# File 'lib/rubocop/ast/node.rb', line 341

def multiline?
  line_count > 1
end

#mutable_literal? ⇒ Boolean

Returns:

  • (Boolean) 


375
376
377
 
# File 'lib/rubocop/ast/node.rb', line 375

def mutable_literal?
  MUTABLE_LITERALS.include?(type)
end

#nonempty_line_count ⇒ Object 



275
276
277
 
# File 'lib/rubocop/ast/node.rb', line 275

def nonempty_line_count
  source.lines.grep(/\S/).size
end

#numeric_type? ⇒ Boolean

Returns:

  • (Boolean) 


476
477
478
 
# File 'lib/rubocop/ast/node.rb', line 476

def numeric_type?
  int_type? || float_type? || rational_type? || complex_type?
end

#operator_keyword? ⇒ Boolean

Returns:

  • (Boolean) 


448
449
450
 
# File 'lib/rubocop/ast/node.rb', line 448

def operator_keyword?
  OPERATOR_KEYWORDS.include?(type)
end

#parent ⇒ Node?

Returns the parent node, or ‘nil` if the receiver is a root node.

Returns:

  • (Node, nil) —

    the parent node or ‘nil`



126
127
128
 
# File 'lib/rubocop/ast/node.rb', line 126

def parent
  @mutable_attributes[:parent]
end

#parent? ⇒ Boolean

Returns:

  • (Boolean) 


135
136
137
 
# File 'lib/rubocop/ast/node.rb', line 135

def parent?
  !!parent
end

#parent_module_name ⇒ Object

Searching the AST



325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/rubocop/ast/node.rb', line 325

def parent_module_name
  # what class or module is this method/constant/etc definition in?
  # returns nil if answer cannot be determined
  ancestors = each_ancestor(:class, :module, :sclass, :casgn, :block)
  result    = ancestors.map do |ancestor|
    parent_module_name_part(ancestor) do |full_name|
      return nil unless full_name

      full_name
    end
  end.compact.reverse.join('::')
  result.empty? ? 'Object' : result
end

#parenthesized_call? ⇒ Boolean

Returns:

  • (Boolean) 


452
453
454
 
# File 'lib/rubocop/ast/node.rb', line 452

def parenthesized_call?
  loc.respond_to?(:begin) && loc.begin && loc.begin.is?('(')
end

#post_condition_loop? ⇒ Boolean

Returns:

  • (Boolean) 


428
429
430
 
# File 'lib/rubocop/ast/node.rb', line 428

def post_condition_loop?
  POST_CONDITION_LOOP_TYPES.include?(type)
end

#proc?(node = self) ⇒ Object 



496
497
498
499
500
 
# File 'lib/rubocop/ast/node.rb', line 496

def_node_matcher :proc?, <<~PATTERN
  {(block (send nil? :proc) ...)
   (block (send #global_const?(:Proc) :new) ...)
   (send #global_const?(:Proc) :new)}
PATTERN

#pure? ⇒ Boolean

Some expressions are evaluated for their value, some for their side effects, and some for both. If we know that expressions are useful only for their return values, and have no side effects, that means we can reorder them, change the number of times they are evaluated, or replace them with other expressions which are equivalent in value. So, is evaluation of this node free of side effects?

Returns:

  • (Boolean) 


582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
 
# File 'lib/rubocop/ast/node.rb', line 582

def pure?
  # Be conservative and return false if we're not sure
  case type
  when :__FILE__, :__LINE__, :const, :cvar, :defined?, :false, :float,
       :gvar, :int, :ivar, :lvar, :nil, :str, :sym, :true, :regopt
    true
  when :and, :array, :begin, :case, :dstr, :dsym, :eflipflop, :ensure,
       :erange, :for, :hash, :if, :iflipflop, :irange, :kwbegin, :not,
       :or, :pair, :regexp, :until, :until_post, :when, :while,
       :while_post
    child_nodes.all?(&:pure?)
  else
    false
  end
end

#range_type? ⇒ Boolean

Returns:

  • (Boolean) 


480
481
482
 
# File 'lib/rubocop/ast/node.rb', line 480

def range_type?
  irange_type? || erange_type?
end

#receiver(node = self) ⇒ Object 



286
287
288
 
# File 'lib/rubocop/ast/node.rb', line 286

def_node_matcher :receiver, <<~PATTERN
  {(send $_ ...) ({block numblock} (call $_ ...) ...)}
PATTERN

#reference? ⇒ Boolean

Returns:

  • (Boolean) 


404
405
406
 
# File 'lib/rubocop/ast/node.rb', line 404

def reference?
  REFERENCES.include?(type)
end

#right_sibling ⇒ Node?

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms

Returns:

  • (Node, nil) —

    the right (aka next) sibling



178
179
180
181
182
 
# File 'lib/rubocop/ast/node.rb', line 178

def right_sibling
  return unless parent

  parent.children[sibling_index + 1].freeze
end

#right_siblings ⇒ Array<Node>

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms

Returns:

  • (Array<Node>) —

    the right (aka next) siblings



206
207
208
209
210
 
# File 'lib/rubocop/ast/node.rb', line 206

def right_siblings
  return [].freeze unless parent

  parent.children[sibling_index + 1..].freeze
end

#root? ⇒ Boolean

Returns:

  • (Boolean) 


140
141
142
 
# File 'lib/rubocop/ast/node.rb', line 140

def root?
  !parent
end

#send_type? ⇒ Boolean

Most nodes are of ‘send’ type, so this method is defined separately to make this check as fast as possible.

Returns:

  • (Boolean) 


119
120
121
 
# File 'lib/rubocop/ast/node.rb', line 119

def send_type?
  false
end

#shorthand_asgn? ⇒ Boolean

Returns:

  • (Boolean) 


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

def shorthand_asgn?
  SHORTHAND_ASSIGNMENTS.include?(type)
end

#sibling_index ⇒ Integer?

Returns the index of the receiver node in its siblings. (Sibling index uses zero based numbering.) Use is discouraged, this is a potentially slow method.

Returns:

  • (Integer, nil) —

    the index of the receiver node in its siblings



171
172
173
 
# File 'lib/rubocop/ast/node.rb', line 171

def sibling_index
  parent&.children&.index { |sibling| sibling.equal?(self) }
end

#single_line? ⇒ Boolean

Returns:

  • (Boolean) 


345
346
347
 
# File 'lib/rubocop/ast/node.rb', line 345

def single_line?
  line_count == 1
end

#source ⇒ String?

NOTE: Some rare nodes may have no source, like ‘s(:args)` in `foo {}`

Returns:

  • (String, nil) 


253
254
255
 
# File 'lib/rubocop/ast/node.rb', line 253

def source
  loc.expression&.source
end

#source_length ⇒ Object 



279
280
281
 
# File 'lib/rubocop/ast/node.rb', line 279

def source_length
  source_range ? source_range.size : 0
end

#source_range ⇒ Object 



257
258
259
 
# File 'lib/rubocop/ast/node.rb', line 257

def source_range
  loc.expression
end

#special_keyword? ⇒ Boolean

Returns:

  • (Boolean) 


444
445
446
 
# File 'lib/rubocop/ast/node.rb', line 444

def special_keyword?
  SPECIAL_KEYWORDS.include?(source)
end

#str_content(node = self) ⇒ Object 



291
 
# File 'lib/rubocop/ast/node.rb', line 291

def_node_matcher :str_content, '(str $_)'

#struct_constructor?(node = self) ⇒ Object

Deprecated.

Use ‘:class_constructor?`



525
526
527
 
# File 'lib/rubocop/ast/node.rb', line 525

def_node_matcher :struct_constructor?, <<~PATTERN
  ({block numblock} (send #global_const?(:Struct) :new ...) _ $_)
PATTERN

#truthy_literal? ⇒ Boolean

Returns:

  • (Boolean) 


367
368
369
 
# File 'lib/rubocop/ast/node.rb', line 367

def truthy_literal?
  TRUTHY_LITERALS.include?(type)
end

#updated(type = nil, children = nil, properties = {}) ⇒ Object

Override ‘AST::Node#updated` so that `AST::Processor` does not try to mutate our ASTs. Since we keep references from children to parents and not just the other way around, we cannot update an AST and share identical subtrees. Rather, the entire AST must be copied any time any part of it is changed.



160
161
162
163
164
 
# File 'lib/rubocop/ast/node.rb', line 160

def updated(type = nil, children = nil, properties = {})
  properties[:location] ||= @location
  klass = RuboCop::AST::Builder::NODE_MAP[type || @type] || Node
  klass.new(type || @type, children || @children, properties)
end

#value_used? ⇒ Boolean

Some expressions are evaluated for their value, some for their side effects, and some for both If we know that an expression is useful only for its side effects, that means we can transform it in ways which preserve the side effects, but change the return value So, does the return value of this node matter? If we changed it to ‘(…; nil)`, might that affect anything?

rubocop:disable Metrics/MethodLength

Returns:

  • (Boolean) 


551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
 
# File 'lib/rubocop/ast/node.rb', line 551

def value_used?
  # Be conservative and return true if we're not sure.
  return false if parent.nil?

  case parent.type
  when :array, :defined?, :dstr, :dsym, :eflipflop, :erange, :float,
       :hash, :iflipflop, :irange, :not, :pair, :regexp, :str, :sym,
       :when, :xstr
    parent.value_used?
  when :begin, :kwbegin
    begin_value_used?
  when :for
    for_value_used?
  when :case, :if
    case_if_value_used?
  when :while, :until, :while_post, :until_post
    while_until_value_used?
  else
    true
  end
end

#variable? ⇒ Boolean

Returns:

  • (Boolean) 


400
401
402
 
# File 'lib/rubocop/ast/node.rb', line 400

def variable?
  VARIABLES.include?(type)
end