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, KeywordBeginNode, KeywordSplatNode, LambdaNode, MasgnNode, MlhsNode, ModuleNode, NextNode, OpAsgnNode, OrNode, PairNode, RangeNode, RationalNode, RegexpNode, ResbodyNode, RescueNode, ReturnNode, SelfClassNode, SendNode, StrNode, SuperNode, SymbolNode, UntilNode, VarNode, 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
Instance Method Summary collapse
-
#ancestors ⇒ Array<Node>
Returns an array of ancestor nodes.
- #any_block_type? ⇒ Boolean
- #any_def_type? ⇒ Boolean
- #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
-
#loc?(which_loc) ⇒ Boolean
Shortcut to safely check if a location is present.
-
#loc_is?(which_loc, str) ⇒ Boolean
Shortcut to safely test a particular location, even if this location does not exist or is ‘nil`.
-
#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
- #recursive_basic_literal? ⇒ Boolean
- #recursive_literal? ⇒ Boolean
- #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
-
#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`).
-
#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.
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
# File 'lib/rubocop/ast/node.rb', line 145 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`.
310 311 312 |
# File 'lib/rubocop/ast/node.rb', line 310 def ancestors each_ancestor.to_a end |
#any_block_type? ⇒ Boolean
539 540 541 |
# File 'lib/rubocop/ast/node.rb', line 539 def any_block_type? GROUP_FOR_TYPE[type] == :any_block end |
#any_def_type? ⇒ Boolean
519 520 521 |
# File 'lib/rubocop/ast/node.rb', line 519 def any_def_type? GROUP_FOR_TYPE[type] == :any_def end |
#argument? ⇒ Boolean
515 516 517 |
# File 'lib/rubocop/ast/node.rb', line 515 def argument? parent&.send_type? && parent.arguments.include?(self) end |
#argument_type? ⇒ Boolean
523 524 525 |
# File 'lib/rubocop/ast/node.rb', line 523 def argument_type? GROUP_FOR_TYPE[type] == :argument end |
#assignment? ⇒ Boolean
467 468 469 |
# File 'lib/rubocop/ast/node.rb', line 467 def assignment? ASSIGNMENTS.include?(type) end |
#assignment_or_similar?(node = self) ⇒ Object
Some cops treat the shovel operator as a kind of assignment.
417 418 419 |
# File 'lib/rubocop/ast/node.rb', line 417 def_node_matcher :assignment_or_similar?, "{assignment? (send _recv :<< ...)}\n" |
#basic_conditional? ⇒ Boolean
471 472 473 |
# File 'lib/rubocop/ast/node.rb', line 471 def basic_conditional? BASIC_CONDITIONALS.include?(type) end |
#basic_literal? ⇒ Boolean
425 426 427 |
# File 'lib/rubocop/ast/node.rb', line 425 def basic_literal? BASIC_LITERALS.include?(type) end |
#boolean_type? ⇒ Boolean
527 528 529 |
# File 'lib/rubocop/ast/node.rb', line 527 def boolean_type? GROUP_FOR_TYPE[type] == :boolean end |
#call_type? ⇒ Boolean
507 508 509 |
# File 'lib/rubocop/ast/node.rb', line 507 def call_type? GROUP_FOR_TYPE[type] == :call end |
#chained? ⇒ Boolean
511 512 513 |
# File 'lib/rubocop/ast/node.rb', line 511 def chained? parent&.call_type? && eql?(parent.receiver) end |
#class_constructor?(node = self) ⇒ Object
587 588 589 590 591 592 593 594 595 596 |
# File 'lib/rubocop/ast/node.rb', line 587 def_node_matcher :class_constructor?, "{\n (send #global_const?({:Class :Module :Struct}) :new ...)\n (send #global_const?(:Data) :define ...)\n (any_block {\n (send #global_const?({:Class :Module :Struct}) :new ...)\n (send #global_const?(:Data) :define ...)\n } ...)\n}\n" |
#class_definition?(node = self) ⇒ Object
605 606 607 608 609 |
# File 'lib/rubocop/ast/node.rb', line 605 def_node_matcher :class_definition?, "{(class _ _ $_)\n (sclass _ $_)\n (any_block (send #global_const?({:Struct :Class}) :new ...) _ $_)}\n" |
#complete! ⇒ Object
207 208 209 210 |
# File 'lib/rubocop/ast/node.rb', line 207 def complete! @mutable_attributes.freeze each_child_node(&:complete!) end |
#complete? ⇒ Boolean
212 213 214 |
# File 'lib/rubocop/ast/node.rb', line 212 def complete? @mutable_attributes.frozen? end |
#conditional? ⇒ Boolean
475 476 477 |
# File 'lib/rubocop/ast/node.rb', line 475 def conditional? CONDITIONALS.include?(type) end |
#const_name ⇒ Object
356 357 358 359 360 361 362 363 364 |
# File 'lib/rubocop/ast/node.rb', line 356 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
376 377 378 379 |
# File 'lib/rubocop/ast/node.rb', line 376 def defined_module namespace, name = *defined_module0 s(:const, namespace, name) if name end |
#defined_module_name ⇒ Object
381 382 383 |
# File 'lib/rubocop/ast/node.rb', line 381 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.
298 299 300 301 302 303 304 |
# File 'lib/rubocop/ast/node.rb', line 298 def each_ancestor(*types, &block) return to_enum(__method__, *types) unless block visit_ancestors(types, &block) self end |
#empty_source? ⇒ Boolean
411 412 413 |
# File 'lib/rubocop/ast/node.rb', line 411 def empty_source? source_length.zero? end |
#equals_asgn? ⇒ Boolean
459 460 461 |
# File 'lib/rubocop/ast/node.rb', line 459 def equals_asgn? EQUALS_ASSIGNMENTS.include?(type) end |
#falsey_literal? ⇒ Boolean
433 434 435 |
# File 'lib/rubocop/ast/node.rb', line 433 def falsey_literal? FALSEY_LITERALS.include?(type) end |
#first_line ⇒ Object
324 325 326 |
# File 'lib/rubocop/ast/node.rb', line 324 def first_line loc.line end |
#global_const?(node = self, name) ⇒ Object
584 |
# File 'lib/rubocop/ast/node.rb', line 584 def_node_matcher :global_const?, '(const {nil? cbase} %1)' |
#guard_clause? ⇒ Boolean
543 544 545 546 547 |
# File 'lib/rubocop/ast/node.rb', line 543 def guard_clause? node = operator_keyword? ? rhs : self node.match_guard_clause? end |
#immutable_literal? ⇒ Boolean
441 442 443 |
# File 'lib/rubocop/ast/node.rb', line 441 def immutable_literal? IMMUTABLE_LITERALS.include?(type) end |
#keyword? ⇒ Boolean
488 489 490 491 492 493 |
# File 'lib/rubocop/ast/node.rb', line 488 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
578 |
# File 'lib/rubocop/ast/node.rb', line 578 def_node_matcher :lambda?, '(any_block (send nil? :lambda) ...)' |
#lambda_or_proc?(node = self) ⇒ Object
581 |
# File 'lib/rubocop/ast/node.rb', line 581 def_node_matcher :lambda_or_proc?, '{lambda? proc?}' |
#last_line ⇒ Object
328 329 330 |
# File 'lib/rubocop/ast/node.rb', line 328 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
250 251 252 253 254 255 |
# File 'lib/rubocop/ast/node.rb', line 250 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
260 261 262 263 264 |
# File 'lib/rubocop/ast/node.rb', line 260 def left_siblings return [].freeze unless parent parent.children[0...sibling_index].freeze end |
#line_count ⇒ Object
332 333 334 335 336 |
# File 'lib/rubocop/ast/node.rb', line 332 def line_count return 0 unless source_range source_range.last_line - source_range.first_line + 1 end |
#literal? ⇒ Boolean
421 422 423 |
# File 'lib/rubocop/ast/node.rb', line 421 def literal? LITERALS.include?(type) end |
#loc?(which_loc) ⇒ Boolean
Shortcut to safely check if a location is present
551 552 553 554 555 |
# File 'lib/rubocop/ast/node.rb', line 551 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`
559 560 561 562 563 |
# File 'lib/rubocop/ast/node.rb', line 559 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.
484 485 486 |
# File 'lib/rubocop/ast/node.rb', line 484 def loop_keyword? LOOP_TYPES.include?(type) end |
#match_guard_clause?(node = self) ⇒ Object
566 567 568 |
# File 'lib/rubocop/ast/node.rb', line 566 def_node_matcher :match_guard_clause?, "[${(send nil? {:raise :fail} ...) return break next} single_line?]\n" |
#module_definition?(node = self) ⇒ Object
612 613 614 615 |
# File 'lib/rubocop/ast/node.rb', line 612 def_node_matcher :module_definition?, "{(module _ $_)\n (any_block (send #global_const?(:Module) :new ...) _ $_)}\n" |
#multiline? ⇒ Boolean
Predicates
403 404 405 |
# File 'lib/rubocop/ast/node.rb', line 403 def multiline? line_count > 1 end |
#mutable_literal? ⇒ Boolean
437 438 439 |
# File 'lib/rubocop/ast/node.rb', line 437 def mutable_literal? MUTABLE_LITERALS.include?(type) end |
#nonempty_line_count ⇒ Object
338 339 340 |
# File 'lib/rubocop/ast/node.rb', line 338 def nonempty_line_count source.lines.grep(/\S/).size end |
#numeric_type? ⇒ Boolean
531 532 533 |
# File 'lib/rubocop/ast/node.rb', line 531 def numeric_type? GROUP_FOR_TYPE[type] == :numeric end |
#operator_keyword? ⇒ Boolean
499 500 501 |
# File 'lib/rubocop/ast/node.rb', line 499 def operator_keyword? OPERATOR_KEYWORDS.include?(type) end |
#parent ⇒ Node?
Returns the parent node, or ‘nil` if the receiver is a root node.
189 190 191 |
# File 'lib/rubocop/ast/node.rb', line 189 def parent @mutable_attributes[:parent] end |
#parent? ⇒ Boolean
198 199 200 |
# File 'lib/rubocop/ast/node.rb', line 198 def parent? !!parent end |
#parent_module_name ⇒ Object
Searching the AST
387 388 389 390 391 392 393 394 395 396 397 398 399 |
# File 'lib/rubocop/ast/node.rb', line 387 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
503 504 505 |
# File 'lib/rubocop/ast/node.rb', line 503 def parenthesized_call? loc_is?(:begin, '(') end |
#post_condition_loop? ⇒ Boolean
479 480 481 |
# File 'lib/rubocop/ast/node.rb', line 479 def post_condition_loop? POST_CONDITION_LOOP_TYPES.include?(type) end |
#proc?(node = self) ⇒ Object
571 572 573 574 575 |
# File 'lib/rubocop/ast/node.rb', line 571 def_node_matcher :proc?, "{(block (send nil? :proc) ...)\n (block (send #global_const?(:Proc) :new) ...)\n (send #global_const?(:Proc) :new)}\n" |
#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?
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 |
# File 'lib/rubocop/ast/node.rb', line 655 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
535 536 537 |
# File 'lib/rubocop/ast/node.rb', line 535 def range_type? GROUP_FOR_TYPE[type] == :range end |
#receiver(node = self) ⇒ Object
349 350 351 |
# File 'lib/rubocop/ast/node.rb', line 349 def_node_matcher :receiver, "{(send $_ ...) (any_block (call $_ ...) ...)}\n" |
#recursive_basic_literal? ⇒ Boolean
449 |
# File 'lib/rubocop/ast/node.rb', line 449 def_recursive_literal_predicate :basic_literal |
#recursive_literal? ⇒ Boolean
448 |
# File 'lib/rubocop/ast/node.rb', line 448 def_recursive_literal_predicate :literal |
#reference? ⇒ Boolean
455 456 457 |
# File 'lib/rubocop/ast/node.rb', line 455 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
241 242 243 244 245 |
# File 'lib/rubocop/ast/node.rb', line 241 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
269 270 271 272 273 |
# File 'lib/rubocop/ast/node.rb', line 269 def right_siblings return [].freeze unless parent parent.children[sibling_index + 1..].freeze end |
#root? ⇒ Boolean
203 204 205 |
# File 'lib/rubocop/ast/node.rb', line 203 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.
182 183 184 |
# File 'lib/rubocop/ast/node.rb', line 182 def send_type? false end |
#shorthand_asgn? ⇒ Boolean
463 464 465 |
# File 'lib/rubocop/ast/node.rb', line 463 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.
234 235 236 |
# File 'lib/rubocop/ast/node.rb', line 234 def sibling_index parent&.children&.index { |sibling| sibling.equal?(self) } end |
#single_line? ⇒ Boolean
407 408 409 |
# File 'lib/rubocop/ast/node.rb', line 407 def single_line? line_count == 1 end |
#source ⇒ String?
NOTE: Some rare nodes may have no source, like ‘s(:args)` in `foo {}`
316 317 318 |
# File 'lib/rubocop/ast/node.rb', line 316 def source loc.expression&.source end |
#source_length ⇒ Object
342 343 344 |
# File 'lib/rubocop/ast/node.rb', line 342 def source_length source_range ? source_range.size : 0 end |
#source_range ⇒ Object
320 321 322 |
# File 'lib/rubocop/ast/node.rb', line 320 def source_range loc.expression end |
#special_keyword? ⇒ Boolean
495 496 497 |
# File 'lib/rubocop/ast/node.rb', line 495 def special_keyword? SPECIAL_KEYWORDS.include?(source) end |
#str_content(node = self) ⇒ Object
354 |
# File 'lib/rubocop/ast/node.rb', line 354 def_node_matcher :str_content, '(str $_)' |
#struct_constructor?(node = self) ⇒ Object
Use ‘:class_constructor?`
600 601 602 |
# File 'lib/rubocop/ast/node.rb', line 600 def_node_matcher :struct_constructor?, "(any_block (send #global_const?(:Struct) :new ...) _ $_)\n" |
#truthy_literal? ⇒ Boolean
429 430 431 |
# File 'lib/rubocop/ast/node.rb', line 429 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`)
164 165 166 167 168 169 |
# File 'lib/rubocop/ast/node.rb', line 164 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.
223 224 225 226 227 |
# File 'lib/rubocop/ast/node.rb', line 223 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?
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 |
# File 'lib/rubocop/ast/node.rb', line 625 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
451 452 453 |
# File 'lib/rubocop/ast/node.rb', line 451 def variable? VARIABLES.include?(type) end |