Class: RuboCop::AST::Node
- Inherits:
-
Parser::AST::Node
- Object
- Parser::AST::Node
- RuboCop::AST::Node
- 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:
Direct Known Subclasses
AliasNode, AndNode, ArgNode, ArgsNode, ArrayNode, AsgnNode, BlockNode, BreakNode, CaseMatchNode, CaseNode, CasgnNode, ClassNode, ConstNode, DefNode, DefinedNode, EnsureNode, FloatNode, ForNode, ForwardArgsNode, HashNode, IfNode, InPatternNode, IndexNode, IndexasgnNode, IntNode, KeywordSplatNode, LambdaNode, ModuleNode, NextNode, OpAsgnNode, OrNode, PairNode, RangeNode, RegexpNode, ResbodyNode, RescueNode, ReturnNode, SelfClassNode, SendNode, StrNode, SuperNode, SymbolNode, UntilNode, WhenNode, WhileNode, YieldNode
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
-
#ancestors ⇒ Array<Node>
Returns an array of ancestor nodes.
- #argument? ⇒ Boolean
- #argument_type? ⇒ Boolean
- #assignment? ⇒ Boolean
-
#assignment_or_similar?(node = self) ⇒ Object
Some cops treat the shovel operator as a kind of assignment.
- #basic_conditional? ⇒ Boolean
- #basic_literal? ⇒ Boolean
- #boolean_type? ⇒ Boolean
- #call_type? ⇒ Boolean
- #chained? ⇒ Boolean
- #class_constructor?(node = self) ⇒ Object
- #class_definition?(node = self) ⇒ Object
- #complete! ⇒ Object
- #complete? ⇒ Boolean
- #conditional? ⇒ Boolean
- #const_name ⇒ Object
- #defined_module ⇒ Object
- #defined_module_name ⇒ Object
-
#each_ancestor(*types) {|node| ... } ⇒ self, Enumerator
Calls the given block for each ancestor node from parent to root.
- #empty_source? ⇒ Boolean
- #equals_asgn? ⇒ Boolean
- #falsey_literal? ⇒ Boolean
- #first_line ⇒ Object
- #global_const?(node = self, name) ⇒ Object
- #guard_clause? ⇒ Boolean
- #immutable_literal? ⇒ Boolean
-
#initialize(type, children = EMPTY_CHILDREN, properties = EMPTY_PROPERTIES) ⇒ Node
constructor
A new instance of Node.
- #keyword? ⇒ Boolean
- #lambda?(node = self) ⇒ Object
- #lambda_or_proc?(node = self) ⇒ Object
- #last_line ⇒ Object
-
#left_sibling ⇒ Node?
Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
-
#left_siblings ⇒ Array<Node>
Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
- #line_count ⇒ Object
- #literal? ⇒ Boolean
-
#loop_keyword? ⇒ Boolean
NOTE: ‘loop { }` is a normal method call and thus not a loop keyword.
- #match_guard_clause?(node = self) ⇒ Object
- #module_definition?(node = self) ⇒ Object
-
#multiline? ⇒ Boolean
Predicates.
- #mutable_literal? ⇒ Boolean
- #nonempty_line_count ⇒ Object
- #numeric_type? ⇒ Boolean
- #operator_keyword? ⇒ Boolean
-
#parent ⇒ Node?
Returns the parent node, or ‘nil` if the receiver is a root node.
- #parent? ⇒ Boolean
-
#parent_module_name ⇒ Object
Searching the AST.
- #parenthesized_call? ⇒ Boolean
- #post_condition_loop? ⇒ Boolean
- #proc?(node = self) ⇒ Object
-
#pure? ⇒ Boolean
Some expressions are evaluated for their value, some for their side effects, and some for both.
- #range_type? ⇒ Boolean
- #receiver(node = self) ⇒ Object
- #reference? ⇒ Boolean
-
#right_sibling ⇒ Node?
Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
-
#right_siblings ⇒ Array<Node>
Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
- #root? ⇒ Boolean
-
#send_type? ⇒ Boolean
Most nodes are of ‘send’ type, so this method is defined separately to make this check as fast as possible.
- #shorthand_asgn? ⇒ Boolean
-
#sibling_index ⇒ Integer?
Returns the index of the receiver node in its siblings.
- #single_line? ⇒ Boolean
-
#source ⇒ String?
NOTE: Some rare nodes may have no source, like ‘s(:args)` in `foo {}`.
- #source_length ⇒ Object
- #source_range ⇒ Object
- #special_keyword? ⇒ Boolean
- #str_content(node = self) ⇒ Object
-
#struct_constructor?(node = self) ⇒ Object
deprecated
Deprecated.
Use ‘:class_constructor?`
- #truthy_literal? ⇒ Boolean
-
#updated(type = nil, children = nil, properties = {}) ⇒ Object
Override ‘AST::Node#updated` so that `AST::Processor` does not try to mutate our ASTs.
-
#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?.
- #variable? ⇒ Boolean
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
Constructor Details
#initialize(type, children = EMPTY_CHILDREN, properties = EMPTY_PROPERTIES) ⇒ Node
Returns a new instance of Node.
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`.
247 248 249 |
# File 'lib/rubocop/ast/node.rb', line 247 def ancestors each_ancestor.to_a end |
#argument? ⇒ 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
468 469 470 |
# File 'lib/rubocop/ast/node.rb', line 468 def argument_type? ARGUMENT_TYPES.include?(type) end |
#assignment? ⇒ 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
420 421 422 |
# File 'lib/rubocop/ast/node.rb', line 420 def basic_conditional? BASIC_CONDITIONALS.include?(type) end |
#basic_literal? ⇒ Boolean
363 364 365 |
# File 'lib/rubocop/ast/node.rb', line 363 def basic_literal? BASIC_LITERALS.include?(type) end |
#boolean_type? ⇒ Boolean
472 473 474 |
# File 'lib/rubocop/ast/node.rb', line 472 def boolean_type? true_type? || false_type? end |
#call_type? ⇒ Boolean
456 457 458 |
# File 'lib/rubocop/ast/node.rb', line 456 def call_type? send_type? || csend_type? end |
#chained? ⇒ 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
149 150 151 |
# File 'lib/rubocop/ast/node.rb', line 149 def complete? @mutable_attributes.frozen? end |
#conditional? ⇒ 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.
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
349 350 351 |
# File 'lib/rubocop/ast/node.rb', line 349 def empty_source? source_length.zero? end |
#equals_asgn? ⇒ Boolean
408 409 410 |
# File 'lib/rubocop/ast/node.rb', line 408 def equals_asgn? EQUALS_ASSIGNMENTS.include?(type) end |
#falsey_literal? ⇒ 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
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
379 380 381 |
# File 'lib/rubocop/ast/node.rb', line 379 def immutable_literal? IMMUTABLE_LITERALS.include?(type) end |
#keyword? ⇒ 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
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
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
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.
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
341 342 343 |
# File 'lib/rubocop/ast/node.rb', line 341 def multiline? line_count > 1 end |
#mutable_literal? ⇒ 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
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
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.
126 127 128 |
# File 'lib/rubocop/ast/node.rb', line 126 def parent @mutable_attributes[:parent] end |
#parent? ⇒ 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
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
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?
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
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
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
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
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
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.
119 120 121 |
# File 'lib/rubocop/ast/node.rb', line 119 def send_type? false end |
#shorthand_asgn? ⇒ 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.
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
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 {}`
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
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
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
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
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
400 401 402 |
# File 'lib/rubocop/ast/node.rb', line 400 def variable? VARIABLES.include?(type) end |