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

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:



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/rubocop/ast/node.rb', line 155

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



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

def ancestors
  each_ancestor.to_a
end

#any_block_type? ⇒ Boolean

Returns:

  • (Boolean) 


549
550
551
 
# File 'lib/rubocop/ast/node.rb', line 549

def any_block_type?
  GROUP_FOR_TYPE[type] == :any_block
end

#any_def_type? ⇒ Boolean

Returns:

  • (Boolean) 


529
530
531
 
# File 'lib/rubocop/ast/node.rb', line 529

def any_def_type?
  GROUP_FOR_TYPE[type] == :any_def
end

#any_match_pattern_type? ⇒ Boolean

Returns:

  • (Boolean) 


553
554
555
 
# File 'lib/rubocop/ast/node.rb', line 553

def any_match_pattern_type?
  GROUP_FOR_TYPE[type] == :any_match_pattern
end

#any_str_type? ⇒ Boolean

Returns:

  • (Boolean) 


557
558
559
 
# File 'lib/rubocop/ast/node.rb', line 557

def any_str_type?
  GROUP_FOR_TYPE[type] == :any_str
end

#any_sym_type? ⇒ Boolean

Returns:

  • (Boolean) 


561
562
563
 
# File 'lib/rubocop/ast/node.rb', line 561

def any_sym_type?
  GROUP_FOR_TYPE[type] == :any_sym
end

#argument? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#argument_type? ⇒ Boolean

Returns:

  • (Boolean) 


533
534
535
 
# File 'lib/rubocop/ast/node.rb', line 533

def argument_type?
  GROUP_FOR_TYPE[type] == :argument
end

#assignment? ⇒ Boolean

Returns:

  • (Boolean) 


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

def assignment?
  ASSIGNMENTS.include?(type)
end

#assignment_or_similar?(node = self) ⇒ Object

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



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

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

#basic_conditional? ⇒ Boolean

Returns:

  • (Boolean) 


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

def basic_conditional?
  BASIC_CONDITIONALS.include?(type)
end

#basic_literal? ⇒ Boolean

Returns:

  • (Boolean) 


435
436
437
 
# File 'lib/rubocop/ast/node.rb', line 435

def basic_literal?
  BASIC_LITERALS.include?(type)
end

#boolean_type? ⇒ Boolean

Returns:

  • (Boolean) 


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

def boolean_type?
  GROUP_FOR_TYPE[type] == :boolean
end

#call_type? ⇒ Boolean

Returns:

  • (Boolean) 


517
518
519
 
# File 'lib/rubocop/ast/node.rb', line 517

def call_type?
  GROUP_FOR_TYPE[type] == :call
end

#chained? ⇒ Boolean

Returns:

  • (Boolean) 


521
522
523
 
# File 'lib/rubocop/ast/node.rb', line 521

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

#class_constructor?(node = self) ⇒ Object 



609
610
611
612
613
614
615
616
617
618
 
# File 'lib/rubocop/ast/node.rb', line 609

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

#class_definition?(node = self) ⇒ Object 



627
628
629
630
631
 
# File 'lib/rubocop/ast/node.rb', line 627

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

#complete! ⇒ Object 



217
218
219
220
 
# File 'lib/rubocop/ast/node.rb', line 217

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

#complete? ⇒ Boolean

Returns:

  • (Boolean) 


222
223
224
 
# File 'lib/rubocop/ast/node.rb', line 222

def complete?
  @mutable_attributes.frozen?
end

#conditional? ⇒ Boolean

Returns:

  • (Boolean) 


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

def conditional?
  CONDITIONALS.include?(type)
end

#const_name ⇒ Object 



366
367
368
369
370
371
372
373
374
 
# File 'lib/rubocop/ast/node.rb', line 366

def const_name
  return unless const_type? || casgn_type?

  if namespace && !namespace.cbase_type?
    "#{namespace.const_name}::#{short_name}"
  else
    short_name.to_s
  end
end

#defined_module ⇒ Object 



386
387
388
389
 
# File 'lib/rubocop/ast/node.rb', line 386

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

#defined_module_name ⇒ Object 



391
392
393
 
# File 'lib/rubocop/ast/node.rb', line 391

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



308
309
310
311
312
313
314
 
# File 'lib/rubocop/ast/node.rb', line 308

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

  visit_ancestors(types, &block)

  self
end

#empty_source? ⇒ Boolean

Returns:

  • (Boolean) 


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

def empty_source?
  source_length.zero?
end

#equals_asgn? ⇒ Boolean

Returns:

  • (Boolean) 


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

def equals_asgn?
  EQUALS_ASSIGNMENTS.include?(type)
end

#falsey_literal? ⇒ Boolean

Returns:

  • (Boolean) 


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

def falsey_literal?
  FALSEY_LITERALS.include?(type)
end

#first_line ⇒ Object 



334
335
336
 
# File 'lib/rubocop/ast/node.rb', line 334

def first_line
  loc.line
end

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



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

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

#guard_clause? ⇒ Boolean

Returns:

  • (Boolean) 


565
566
567
568
569
 
# File 'lib/rubocop/ast/node.rb', line 565

def guard_clause?
  node = operator_keyword? ? rhs : self

  node.match_guard_clause?
end

#immutable_literal? ⇒ Boolean

Returns:

  • (Boolean) 


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

def immutable_literal?
  IMMUTABLE_LITERALS.include?(type)
end

#keyword? ⇒ Boolean

Returns:

  • (Boolean) 


498
499
500
501
502
503
 
# File 'lib/rubocop/ast/node.rb', line 498

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 



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

def_node_matcher :lambda?, '(any_block (send nil? :lambda) ...)'

#lambda_or_proc?(node = self) ⇒ Object 



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

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

#last_line ⇒ Object 



338
339
340
 
# File 'lib/rubocop/ast/node.rb', line 338

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



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

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



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

def left_siblings
  return [].freeze unless parent

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

#line_count ⇒ Object 



342
343
344
345
346
 
# File 'lib/rubocop/ast/node.rb', line 342

def line_count
  return 0 unless source_range

  source_range.last_line - source_range.first_line + 1
end

#literal? ⇒ Boolean

Returns:

  • (Boolean) 


431
432
433
 
# File 'lib/rubocop/ast/node.rb', line 431

def literal?
  LITERALS.include?(type)
end

#loc?(which_loc) ⇒ Boolean

Shortcut to safely check if a location is present

Returns:

  • (Boolean) 


573
574
575
576
577
 
# File 'lib/rubocop/ast/node.rb', line 573

def loc?(which_loc)
  return false unless loc.respond_to?(which_loc)

  !loc.public_send(which_loc).nil?
end

#loc_is?(which_loc, str) ⇒ Boolean

Shortcut to safely test a particular location, even if this location does not exist or is ‘nil`

Returns:

  • (Boolean) 


581
582
583
584
585
 
# File 'lib/rubocop/ast/node.rb', line 581

def loc_is?(which_loc, str)
  return false unless loc?(which_loc)

  loc.public_send(which_loc).is?(str)
end

#loop_keyword? ⇒ Boolean

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

Returns:

  • (Boolean) 


494
495
496
 
# File 'lib/rubocop/ast/node.rb', line 494

def loop_keyword?
  LOOP_TYPES.include?(type)
end

#match_guard_clause?(node = self) ⇒ Object 



588
589
590
 
# File 'lib/rubocop/ast/node.rb', line 588

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

#module_definition?(node = self) ⇒ Object 



634
635
636
637
 
# File 'lib/rubocop/ast/node.rb', line 634

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

#multiline? ⇒ Boolean

Predicates

Returns:

  • (Boolean) 


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

def multiline?
  line_count > 1
end

#mutable_literal? ⇒ Boolean

Returns:

  • (Boolean) 


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

def mutable_literal?
  MUTABLE_LITERALS.include?(type)
end

#nonempty_line_count ⇒ Object 



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

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

#numeric_type? ⇒ Boolean

Returns:

  • (Boolean) 


541
542
543
 
# File 'lib/rubocop/ast/node.rb', line 541

def numeric_type?
  GROUP_FOR_TYPE[type] == :numeric
end

#operator_keyword? ⇒ Boolean

Returns:

  • (Boolean) 


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

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`



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

def parent
  @mutable_attributes[:parent]
end

#parent? ⇒ Boolean

Returns:

  • (Boolean) 


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

def parent?
  !!parent
end

#parent_module_name ⇒ Object

Searching the AST



397
398
399
400
401
402
403
404
405
406
407
408
409
 
# File 'lib/rubocop/ast/node.rb', line 397

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.filter_map do |ancestor|
    parent_module_name_part(ancestor) do |full_name|
      return nil unless full_name

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

#parenthesized_call? ⇒ Boolean

Returns:

  • (Boolean) 


513
514
515
 
# File 'lib/rubocop/ast/node.rb', line 513

def parenthesized_call?
  loc_is?(:begin, '(')
end

#post_condition_loop? ⇒ Boolean

Returns:

  • (Boolean) 


489
490
491
 
# File 'lib/rubocop/ast/node.rb', line 489

def post_condition_loop?
  POST_CONDITION_LOOP_TYPES.include?(type)
end

#proc?(node = self) ⇒ Object 



593
594
595
596
597
 
# File 'lib/rubocop/ast/node.rb', line 593

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) 


677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
 
# File 'lib/rubocop/ast/node.rb', line 677

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) 


545
546
547
 
# File 'lib/rubocop/ast/node.rb', line 545

def range_type?
  GROUP_FOR_TYPE[type] == :range
end

#receiver(node = self) ⇒ Object 



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

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

#recursive_basic_literal? ⇒ Boolean

Returns:

  • (Boolean) 


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

def_recursive_literal_predicate :basic_literal

#recursive_literal? ⇒ Boolean

Returns:

  • (Boolean) 


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

def_recursive_literal_predicate :literal

#reference? ⇒ Boolean

Returns:

  • (Boolean) 


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

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



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

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



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

def right_siblings
  return [].freeze unless parent

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

#root? ⇒ Boolean

Returns:

  • (Boolean) 


213
214
215
 
# File 'lib/rubocop/ast/node.rb', line 213

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) 


192
193
194
 
# File 'lib/rubocop/ast/node.rb', line 192

def send_type?
  false
end

#shorthand_asgn? ⇒ Boolean

Returns:

  • (Boolean) 


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

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



244
245
246
 
# File 'lib/rubocop/ast/node.rb', line 244

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

#single_line? ⇒ Boolean

Returns:

  • (Boolean) 


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

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) 


326
327
328
 
# File 'lib/rubocop/ast/node.rb', line 326

def source
  loc.expression&.source
end

#source_length ⇒ Object 



352
353
354
 
# File 'lib/rubocop/ast/node.rb', line 352

def source_length
  source_range ? source_range.size : 0
end

#source_range ⇒ Object 



330
331
332
 
# File 'lib/rubocop/ast/node.rb', line 330

def source_range
  loc.expression
end

#special_keyword? ⇒ Boolean

Returns:

  • (Boolean) 


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

def special_keyword?
  SPECIAL_KEYWORDS.include?(source)
end

#str_content(node = self) ⇒ Object 



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

def_node_matcher :str_content, '(str $_)'

#struct_constructor?(node = self) ⇒ Object

Deprecated.

Use ‘:class_constructor?`



622
623
624
 
# File 'lib/rubocop/ast/node.rb', line 622

def_node_matcher :struct_constructor?, <<~PATTERN
  (any_block (send #global_const?(:Struct) :new ...) _ $_)
PATTERN

#truthy_literal? ⇒ Boolean

Returns:

  • (Boolean) 


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

def truthy_literal?
  TRUTHY_LITERALS.include?(type)
end

#type?(*types) ⇒ Boolean

Determine if the node is one of several node types in a single query Allows specific single node types, as well as “grouped” types (e.g. ‘:boolean` for `:true` or `:false`)

Returns:

  • (Boolean) 


174
175
176
177
178
179
 
# File 'lib/rubocop/ast/node.rb', line 174

def type?(*types)
  return true if types.include?(type)

  group_type = GROUP_FOR_TYPE[type]
  !group_type.nil? && types.include?(group_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.



233
234
235
236
237
 
# File 'lib/rubocop/ast/node.rb', line 233

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?

Returns:

  • (Boolean) 


647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
 
# File 'lib/rubocop/ast/node.rb', line 647

def value_used? # rubocop:disable Metrics/MethodLength
  # 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) 


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

def variable?
  VARIABLES.include?(type)
end