fastererer 0.12.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee0a8fc9f430360ccef546a4f391fdb3112801f6fb2c56204900f0dca8214063
-  data.tar.gz: a477c6a7b4b9f19011ea89bee00aa193d562f91981dd38e5136cd88fd7ebca14
+  metadata.gz: de024ad42cbd1fb10608607fd4b8f4bbe0c6ff58414f001fea232aee478d2c40
+  data.tar.gz: 2c2722e7fedbe2d4d8542b41db6ad37d61020bea79b5e437305651549cb8c6d5
 SHA512:
-  metadata.gz: 4d239a4233228c45cc0c0ea28ef00110a8d2ea6476c258ef8f68d3f5b443a66cc48724f47529bb6eb787857843a3c7a4d84aed4aeda09c3a2266880c65ccb14a
-  data.tar.gz: 6ac88eca14ca854edc0e549b4ddbd6cd9b39796fb9658c10e3c16399b65a7341cea039c0d18fbb9e243406fe8503072ec25ba1a9671dba35d77f0549995bc7ea
+  metadata.gz: c67fad403a643c864bc7989ca2bb0346802c143baef0bf5bd211a6b6a294abf81dcea1d031a8cf9adca452ee3d83cf58dc75f04297b2ab05fb87c23cfa73cd01
+  data.tar.gz: f034537ef76b425c479ff9dff2304859f869543f7bddad5c2596baa68d4d39525584b65f8c132ca7bc7918049408951c2f02446ae8181929e0c6b4f42695043f

data/CHANGELOG.md

@@ -8,6 +8,36 @@ Versions 0.11.0 and earlier were released as [`fasterer`](https://github.com/Dam
 
 ## [Unreleased]
 
+## [1.0.0] - 2026-06-05
+
+First stable release of `fastererer` after the fork.
+
+### Changed
+
+- [#9]: Migrate from `ruby_parser` to Ruby's native Prism parser. Prism ships with Ruby itself,
+  so this drops the `ruby_parser`, `sexp_processor`, and `racc` dependencies and keeps the
+  analyzer in step with current and future Ruby syntax, including Ruby 4.0.
+
+### Added
+
+- [#9]: Detect speedups reached through a safe-navigation chain (e.g. `arr&.first`,
+  `arr&.select { … }.first`), which the previous S-expression scanner skipped.
+- [#9]: Detect speedups inside `rescue` bodies — getter-vs-`attr_reader`,
+  setter-vs-`attr_writer`, and proc-call-vs-`yield` offenses are now scanned in rescue clauses.
+- [#15]: Offense output now mirrors RuboCop's format with a `Performance/RuleName` rule name and a
+  [fast-ruby](https://github.com/fastruby/fast-ruby) documentation link, e.g.
+  `path:line: W: Performance/ForLoopVsEach: For loop is slower than using each. (url)`.
+
+### Fixed
+
+- [#9]: Block calls inside a nested scope (a singleton class or a nested method definition) are
+  no longer misattributed to the enclosing method.
+- [#9]: Unparseable source now raises a clear error instead of silently reporting no offenses.
+- [#28]: `hash_merge_bang_vs_hash_brackets` now flags `Hash#update`, an alias of `Hash#merge!`, but
+  only when the receiver is provably a Hash (a `{}` literal, `Hash.new`, or `Hash[...]`). Because
+  `update` is also defined on `ActiveRecord`, `ActionController::Parameters`, and others, a bare
+  `obj.update(k => v)` is left untouched to avoid false positives.
+
 ## [0.12.0] - 2026-05-18
 
 ### Added
@@ -106,8 +136,12 @@ Versions 0.11.0 and earlier were released as [`fasterer`](https://github.com/Dam
 
 [Keep a Changelog]: https://keepachangelog.com
 [Semantic Versioning]: https://semver.org/spec/v2.0.0.html
-[Unreleased]: https://github.com/ExtractableMedia/fastererer/compare/v0.12.0...HEAD
+[Unreleased]: https://github.com/ExtractableMedia/fastererer/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/ExtractableMedia/fastererer/compare/v0.12.0...v1.0.0
 [0.12.0]: https://github.com/ExtractableMedia/fastererer/compare/v0.11.0...v0.12.0
 [#1]: https://github.com/ExtractableMedia/fastererer/pull/1
 [#2]: https://github.com/ExtractableMedia/fastererer/pull/2
+[#9]: https://github.com/ExtractableMedia/fastererer/pull/9
+[#15]: https://github.com/ExtractableMedia/fastererer/pull/15
+[#28]: https://github.com/ExtractableMedia/fastererer/issues/28
 [#42]: https://github.com/ExtractableMedia/fastererer/pull/42

data/README.md

@@ -53,20 +53,28 @@ Fastererer exits with status `1` when offenses are found, making it suitable for
 
 ## Example output
 
+Each offense is reported on a single line, following the same shape as
+RuboCop and its plugins (`path:line: SEVERITY: Department/RuleName: message.
+(url)`), so the rule name and a link to documentation are always visible:
+
 ```text
-app/models/post.rb:57 Array#select.first is slower than Array#detect.
-app/models/post.rb:61 Array#select.first is slower than Array#detect.
+app/models/post.rb:57: W: Performance/SelectFirstVsDetect: Array#select.first is slower than Array#detect. (https://github.com/fastruby/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code)
+app/models/post.rb:61: W: Performance/SelectFirstVsDetect: Array#select.first is slower than Array#detect. (https://github.com/fastruby/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code)
 
-db/seeds/cities.rb:15 Hash#keys.each is slower than Hash#each_key.
-db/seeds/cities.rb:33 Hash#keys.each is slower than Hash#each_key.
+db/seeds/cities.rb:15: W: Performance/KeysEachVsEachKey: Hash#keys.each is slower than Hash#each_key. N.B. Hash#each_key cannot be used if the hash is modified during the each block. (https://github.com/fastruby/fast-ruby#hasheach_key-instead-of-hashkeyseach-code)
 
-test/options_test.rb:84 Hash#merge! with one argument is slower than Hash#[].
+test/options_test.rb:84: W: Performance/HashMergeBangVsHashBrackets: Hash#merge! with one argument is slower than Hash#[]. (https://github.com/fastruby/fast-ruby#hashmerge-vs-hash-code)
 
-test/module_test.rb:272 Don't rescue NoMethodError, rather check with respond_to?.
+test/module_test.rb:272: W: Performance/RescueVsRespondTo: Don't rescue NoMethodError, rather check with respond_to?. (https://github.com/fastruby/fast-ruby#beginrescue-vs-respond_to-for-control-flow-code)
 
-spec/cache/mem_cache_store_spec.rb:161 Using tr is faster than gsub when replacing a single character in a string with another single character.
+spec/cache/mem_cache_store_spec.rb:161: W: Performance/GsubVsTr: Using tr is faster than gsub when replacing a single character in a string with another single character. (https://github.com/fastruby/fast-ruby#stringgsub-vs-stringtr-code)
 ```
 
+The rule name (e.g. `Performance/SelectFirstVsDetect`) is derived from the
+underlying snake_case rule key (e.g. `select_first_vs_detect`), which is what
+you reference in `.fastererer.yml` under `speedups:` to disable a rule.
+Descriptions and documentation URLs live in `config/locales/en.yml`.
+
 ## Configuration
 
 Configuration lives in a `.fastererer.yml` file at the root of your project (or any ancestor

data/config/locales/en.yml

@@ -0,0 +1,60 @@
+en:
+  fastererer:
+    rules:
+      rescue_vs_respond_to:
+        description: "Don't rescue NoMethodError, rather check with respond_to?"
+        url: "https://github.com/fastruby/fast-ruby#beginrescue-vs-respond_to-for-control-flow-code"
+      module_eval:
+        description: "Using module_eval is slower than define_method"
+        url: "https://github.com/fastruby/fast-ruby#define_method-vs-module_eval-for-defining-methods-code"
+      shuffle_first_vs_sample:
+        description: "Array#shuffle.first is slower than Array#sample"
+        url: "https://github.com/fastruby/fast-ruby#arrayshufflefirst-vs-arraysample-code"
+      for_loop_vs_each:
+        description: "For loop is slower than using each"
+        url: "https://github.com/fastruby/fast-ruby#enumerableeach-vs-for-loop-code"
+      each_with_index_vs_while:
+        description: "Using each_with_index is slower than while loop"
+        url: "https://github.com/fastruby/fast-ruby#enumerableeach_with_index-vs-while-loop-code"
+      map_flatten_vs_flat_map:
+        description: "Array#map.flatten(1) is slower than Array#flat_map"
+        url: "https://github.com/fastruby/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code"
+      reverse_each_vs_reverse_each:
+        description: "Array#reverse.each is slower than Array#reverse_each"
+        url: "https://github.com/fastruby/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code"
+      select_first_vs_detect:
+        description: "Array#select.first is slower than Array#detect"
+        url: "https://github.com/fastruby/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code"
+      sort_vs_sort_by:
+        description: "Enumerable#sort is slower than Enumerable#sort_by"
+        url: "https://github.com/fastruby/fast-ruby#enumerablesort-vs-enumerablesort_by-code"
+      fetch_with_argument_vs_block:
+        description: "Hash#fetch with second argument is slower than Hash#fetch with block"
+        url: "https://github.com/fastruby/fast-ruby#hashfetch-with-argument-vs-hashfetch--block-code"
+      keys_each_vs_each_key:
+        description: "Hash#keys.each is slower than Hash#each_key. N.B. Hash#each_key cannot be used if the hash is modified during the each block"
+        url: "https://github.com/fastruby/fast-ruby#hasheach_key-instead-of-hashkeyseach-code"
+      hash_merge_bang_vs_hash_brackets:
+        description: "Hash#merge!/#update with one argument is slower than Hash#[]"
+        url: "https://github.com/fastruby/fast-ruby#hashmerge-vs-hash-code"
+      block_vs_symbol_to_proc:
+        description: "Calling argumentless methods within blocks is slower than using symbol to proc"
+        url: "https://github.com/fastruby/fast-ruby#block-vs-symbolto_proc-code"
+      proc_call_vs_yield:
+        description: "Calling blocks with call is slower than yielding"
+        url: "https://github.com/fastruby/fast-ruby#proccall-and-block-arguments-vs-yield-code"
+      gsub_vs_tr:
+        description: "Using tr is faster than gsub when replacing a single character in a string with another single character"
+        url: "https://github.com/fastruby/fast-ruby#stringgsub-vs-stringtr-code"
+      select_last_vs_reverse_detect:
+        description: "Array#select.last is slower than Array#reverse.detect"
+        url: "https://github.com/fastruby/fast-ruby#enumerableselectlast-vs-enumerablereversedetect-code"
+      getter_vs_attr_reader:
+        description: "Use attr_reader for reading ivars"
+        url: "https://github.com/fastruby/fast-ruby#attr_accessor-vs-getter-and-setter-code"
+      setter_vs_attr_writer:
+        description: "Use attr_writer for writing to ivars"
+        url: "https://github.com/fastruby/fast-ruby#attr_accessor-vs-getter-and-setter-code"
+      include_vs_cover_on_range:
+        description: "Use #cover? instead of #include? on ranges"
+        url: "https://github.com/fastruby/fast-ruby#cover-vs-include-code"

data/lib/fastererer/analyzer.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'prism'
 require 'fastererer/method_definition'
 require 'fastererer/method_call'
 require 'fastererer/rescue_call'
+require 'fastererer/offense'
 require 'fastererer/offense_collector'
 require 'fastererer/parser'
 require 'fastererer/scanners/method_call_scanner'
@@ -20,75 +22,47 @@ module Fastererer
     end
 
     def scan
-      sexp_tree = Fastererer::Parser.parse(@file_content)
-      traverse_sexp_tree(sexp_tree)
+      root_node = Fastererer::Parser.parse(@file_content)
+      root_node.accept(AnalyzerVisitor.new(errors))
     end
 
     def errors
       @errors ||= Fastererer::OffenseCollector.new
     end
+  end
 
-    private
-
-    def traverse_sexp_tree(sexp_tree)
-      return unless sexp_tree.is_a?(Sexp)
-
-      token = sexp_tree.first
-      scan_by_token(token, sexp_tree)
-
-      if %i[call iter].include?(token)
-        descend_into_call(sexp_tree)
-      else
-        sexp_tree.each { |element| traverse_sexp_tree(element) }
-      end
-    end
-
-    def descend_into_call(sexp_tree)
-      method_call = MethodCall.new(sexp_tree)
-      traverse_sexp_tree(method_call.receiver_element) if method_call.receiver_element
-      traverse_sexp_tree(method_call.arguments_element)
-      traverse_sexp_tree(method_call.block_body) if method_call.block?
+  class AnalyzerVisitor < Prism::Visitor
+    def initialize(offenses)
+      super()
+      @offenses = offenses
     end
 
-    def scan_by_token(token, element)
-      case token
-      when :defn
-        scan_method_definitions(element)
-      when :call, :iter
-        scan_method_calls(element)
-      when :for
-        scan_for_loop(element)
-      when :resbody
-        scan_rescue(element)
-      end
+    def visit_call_node(node)
+      collect(MethodCallScanner.new(node))
+      super
     end
 
-    def scan_method_definitions(element)
-      method_definition_scanner = MethodDefinitionScanner.new(element)
-
-      return unless method_definition_scanner.offense_detected?
-
-      errors.push(method_definition_scanner.offense)
+    def visit_def_node(node)
+      collect(MethodDefinitionScanner.new(node))
+      super
     end
 
-    def scan_method_calls(element)
-      method_call_scanner = MethodCallScanner.new(element)
-
-      return unless method_call_scanner.offense_detected?
-
-      errors.push(method_call_scanner.offense)
+    def visit_for_node(node)
+      @offenses.push(Fastererer::Offense.new(:for_loop_vs_each, node.location.start_line))
+      super
     end
 
-    def scan_for_loop(element)
-      errors.push(Fastererer::Offense.new(:for_loop_vs_each, element.line))
+    def visit_rescue_node(node)
+      collect(RescueCallScanner.new(node))
+      super
     end
 
-    def scan_rescue(element)
-      rescue_call_scanner = RescueCallScanner.new(element)
-
-      return unless rescue_call_scanner.offense_detected?
+    private
 
-      errors.push(rescue_call_scanner.offense)
+    def collect(scanner)
+      @offenses.push(scanner.offense) if scanner.offense_detected?
     end
   end
+
+  private_constant :AnalyzerVisitor
 end

data/lib/fastererer/explanation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'rule_catalog'
+require_relative 'rule_name'
+
+module Fastererer
+  class Explanation
+    def self.for(offense_name)
+      @instances ||= {}
+      @instances[offense_name.to_sym] ||= new(offense_name)
+    end
+
+    attr_reader :offense_name
+
+    def initialize(offense_name)
+      @offense_name = offense_name.to_sym
+      @row = RuleCatalog.fetch(@offense_name)
+    end
+
+    def description
+      row.fetch('description')
+    end
+
+    def url
+      row.fetch('url')
+    end
+
+    def rule_name
+      @rule_name ||= RuleName.from(offense_name)
+    end
+
+    def to_s
+      "#{rule_name}: #{description.delete_suffix('.')}. (#{url})"
+    end
+
+    private
+
+    attr_reader :row
+  end
+end

data/lib/fastererer/file_traverser.rb

@@ -5,6 +5,7 @@ require 'English'
 
 require_relative 'analyzer'
 require_relative 'config'
+require_relative 'explanation'
 require_relative 'painter'
 
 module Fastererer
@@ -56,7 +57,7 @@ module Fastererer
     def scan_file(path)
       analyzer = Analyzer.new(path)
       analyzer.scan
-    rescue RubyParser::SyntaxError, Racc::ParseError, Timeout::Error => e
+    rescue Fastererer::ParseError, SystemCallError, SystemStackError, EncodingError => e
       parse_error_paths.push(ErrorData.new(path, e.class, e.message).to_s)
     else
       if offenses_grouped_by_type(analyzer).any?
@@ -81,16 +82,22 @@ module Fastererer
     end
 
     def output(analyzer)
-      offenses_grouped_by_type(analyzer).each do |error_group_name, error_occurences|
-        error_occurences.map(&:line_number).each do |line|
+      offenses_grouped_by_type(analyzer).each_value do |error_occurrences|
+        explanation = error_occurrences.first.explanation
+
+        error_occurrences.map(&:line_number).each do |line|
           file_and_line = "#{analyzer.file_path}:#{line}"
-          print "#{Painter.paint(file_and_line, :red)} #{Fastererer::Offense::EXPLANATIONS[error_group_name]}.\n"
+          print "#{Painter.paint(file_and_line, :red)}: #{severity}: #{explanation}\n"
         end
       end
 
       print "\n"
     end
 
+    def severity
+      @severity ||= Painter.paint('W', :magenta)
+    end
+
     def offenses_grouped_by_type(analyzer)
       analyzer.errors.group_by(&:name).delete_if do |offense_name, _|
         ignored_speedups.include?(offense_name)
@@ -100,9 +107,7 @@ module Fastererer
     def output_parse_errors
       return if parse_error_paths.none?
 
-      puts 'Fastererer was unable to process some files because the'
-      puts 'internal parser is not able to read some characters or'
-      puts 'has timed out. Unprocessable files were:'
+      puts 'Fastererer was unable to process some files. Unprocessable files were:'
       puts '-----------------------------------------------------'
       puts parse_error_paths
       puts

data/lib/fastererer/method_call.rb

@@ -1,95 +1,130 @@
 # frozen_string_literal: true
 
+require 'prism'
+
 module Fastererer
   class MethodCall
-    attr_reader :element, :receiver, :method_name, :arguments, :block_body, :block_argument_names
+    attr_reader :element
 
-    alias name method_name
+    def self.build(node)
+      node.is_a?(Prism::LambdaNode) ? LambdaCall.new(node) : new(node)
+    end
 
-    def initialize(element)
-      @element = element
-      set_call_element
-      set_receiver
-      set_method_name
-      set_arguments
-      set_block_presence
-      set_block_body
-      set_block_argument_names
+    def initialize(node)
+      @element = node
     end
 
-    def block?
-      @block_present || false
+    def receiver
+      @receiver ||= ReceiverFactory.build(element.receiver)
     end
 
-    def receiver_element
-      call_element[1]
+    def method_name
+      element.name
     end
 
-    def arguments_element
-      call_element.sexp_body(3) || []
+    def name
+      method_name
     end
 
-    def lambda_literal?
-      call_element.sexp_type == :lambda
+    def arguments
+      @arguments ||= argument_nodes.map { |argument| Argument.new(argument) }
     end
 
-    private
+    def block_body
+      @block_body ||= block_statements
+    end
 
-    attr_reader :call_element
+    def block_argument_names
+      @block_argument_names ||= positional_block_parameter_names
+    end
 
-    # TODO: explanation
-    def set_call_element
-      @call_element = case element.sexp_type
-                      when :call
-                        @element
-                      when :iter
-                        @element[1]
-                      end
+    def block?
+      !block_node.nil?
     end
 
-    def set_receiver
-      @receiver = ReceiverFactory.new(receiver_element)
+    def lambda_literal?
+      false
     end
 
-    def set_method_name
-      @method_name = call_element[2]
+    # Provably a Hash: bare `Hash.new`/`Hash[...]` (any args — every `Hash[...]` yields a Hash),
+    # not qualified `Foo::Hash`. The is_a?(ConstantReadNode) check is load-bearing:
+    # ConstantPathNode#name is :Hash too, so the type (not the name) excludes qualified constants.
+    # unwrap_parentheses lets `(Hash).new` match, as the receiver factory normalizes its input.
+    def hash?
+      return false unless %i[new []].include?(method_name)
+
+      constant = ReceiverFactory.unwrap_parentheses(element.receiver)
+      constant.is_a?(Prism::ConstantReadNode) && constant.name == :Hash
     end
 
-    def set_arguments
-      @arguments = arguments_element.map { |argument| Argument.new(argument) }
+    private
+
+    def block_node
+      @block_node ||= element.block
     end
 
-    def set_block_presence
-      if element.sexp_type == :iter || (arguments.last && arguments.last.type == :block_pass)
-        @block_present = true
-      end
+    def argument_nodes
+      element.arguments&.arguments || []
     end
 
-    def set_block_body
-      @block_body = element[3] if block?
+    def block_statements
+      return unless block_node.is_a?(Prism::BlockNode)
+
+      body = block_node.body
+      body.body if body.is_a?(Prism::StatementsNode)
     end
 
-    # TODO: write specs for lambdas and procs
-    def set_block_argument_names
-      @block_argument_names = if block? && element[2].is_a?(Sexp) # HACK: for lambdas
-                                element[2].drop(1).map { |argument| argument }
-                              end || []
+    # Only single positional params convert to &:sym, so a splat or keyword param must not count
+    # toward block_argument_names.one?
+    def positional_block_parameter_names
+      return [] unless block_node.is_a?(Prism::BlockNode)
+
+      params = block_node.parameters
+      return [] unless params.is_a?(Prism::BlockParametersNode) && params.parameters
+
+      positional = params.parameters.requireds + params.parameters.optionals
+      positional.map { |param| param.is_a?(Prism::MultiTargetNode) ? nil : param.name }
     end
   end
 
-  # For now, used for determening if the
-  # receiver is a reference or a method call.
-  class ReceiverFactory
-    def self.new(receiver_info)
-      return unless receiver_info.is_a?(Sexp)
-
-      case receiver_info.sexp_type
-      when :lvar
-        VariableReference.new(receiver_info)
-      when :call, :iter
-        MethodCall.new(receiver_info)
-      when :array, :dot2, :dot3, :lit
-        Primitive.new(receiver_info)
+  # A `-> {}` lambda literal. Checks ignore it, so its call attributes are inert
+  class LambdaCall < MethodCall
+    def receiver = nil
+    def method_name = :lambda
+    def arguments = []
+    def block_body = nil
+    def block_argument_names = []
+    def block? = true
+    def lambda_literal? = true
+  end
+
+  module ReceiverFactory
+    PRIMITIVE_NODE_TYPES = [Prism::ArrayNode, Prism::RangeNode, Prism::IntegerNode,
+                            Prism::FloatNode, Prism::SymbolNode, Prism::StringNode,
+                            Prism::HashNode].freeze
+
+    def self.build(node)
+      return unless node
+
+      node = unwrap_parentheses(node)
+      case node
+      # A ConstantPathNode's #name is the unqualified tail only (Foo::Bar => :Bar), which is all
+      # the symbol-to-proc check needs; revisit if a check ever needs the fully-qualified path.
+      when Prism::LocalVariableReadNode, Prism::ConstantReadNode,
+           Prism::ConstantPathNode then VariableReference.new(node)
+      when Prism::CallNode then MethodCall.build(node)
+      when *PRIMITIVE_NODE_TYPES then Primitive.new(node)
+      end
+    end
+
+    # Peels a single parenthesis level, so `((x))` stays wrapped — matches how callers normalize
+    def self.unwrap_parentheses(node)
+      if node.is_a?(Prism::ParenthesesNode) &&
+         node.body.is_a?(Prism::StatementsNode) &&
+         node.body.body.size == 1
+        node.body.body.first
+      else
+        node
       end
     end
   end
@@ -97,45 +132,70 @@ module Fastererer
   class VariableReference
     attr_reader :name
 
-    def initialize(reference_info)
-      @reference_info = reference_info
-      @name = reference_info[1]
+    def initialize(node)
+      @name = node.name
+    end
+
+    # A bare local/constant reference can't be proven to hold a Hash
+    def hash?
+      false
     end
   end
 
   class Argument
     attr_reader :element
 
-    def initialize(element)
-      @element = element
-    end
+    def initialize(node)
+      @element = node
+    end
+
+    TYPE_BY_NODE_CLASS = {
+      Prism::KeywordHashNode => :hash,
+      Prism::HashNode => :hash,
+      Prism::StringNode => :string,
+      Prism::IntegerNode => :integer,
+      Prism::SymbolNode => :symbol,
+      Prism::FloatNode => :float,
+      Prism::RegularExpressionNode => :regexp,
+      Prism::NilNode => :nil,
+      Prism::TrueNode => :boolean,
+      Prism::FalseNode => :boolean,
+      Prism::LocalVariableReadNode => :variable,
+      Prism::CallNode => :method_call
+    }.freeze
 
     def type
-      @type ||= @element[0]
+      @type ||= TYPE_BY_NODE_CLASS[element.class] || :unknown
     end
 
     def value
-      @value ||= @element[1]
+      return @value if defined?(@value)
+
+      @value = case element
+               when Prism::StringNode then element.unescaped
+               when Prism::IntegerNode, Prism::FloatNode then element.value
+               when Prism::SymbolNode then element.unescaped.to_sym
+               end
     end
   end
 
   class Primitive
     attr_reader :element
 
-    def initialize(element)
-      @element = element
-    end
-
-    def type
-      @type ||= @element[0]
+    def initialize(node)
+      @element = node
     end
 
     def range?
-      %i[dot2 dot3 lit].include?(type)
+      element.is_a?(Prism::RangeNode)
     end
 
     def array?
-      type == :array
+      element.is_a?(Prism::ArrayNode)
+    end
+
+    def hash?
+      element.is_a?(Prism::HashNode)
     end
   end
 end