prism 1.9.0 → 2.0.0.rc2

data/lib/prism/pattern.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 # :markup: markdown
+#--
+# rbs_inline: enabled
 
 module Prism
   # A pattern is an object that wraps a Ruby pattern matching expression. The
@@ -41,7 +43,9 @@ module Prism
     class CompilationError < StandardError
       # Create a new CompilationError with the given representation of the node
       # that caused the error.
-      def initialize(repr)
+      #
+      #: (String repr) -> void
+      def initialize(repr) # :nodoc:
         super(<<~ERROR)
           prism was unable to compile the pattern you provided into a usable
           expression. It failed on to understand the node represented by:
@@ -57,10 +61,13 @@ module Prism
     end
 
     # The query that this pattern was initialized with.
-    attr_reader :query
+    attr_reader :query #: String
+    # @rbs @compiled: Proc?
 
     # Create a new pattern with the given query. The query should be a string
     # containing a Ruby pattern matching expression.
+    #
+    #: (String query) -> void
     def initialize(query)
       @query = query
       @compiled = nil
@@ -68,6 +75,8 @@ module Prism
 
     # Compile the query into a callable object that can be used to match against
     # nodes.
+    #
+    #: () -> Proc
     def compile
       result = Prism.parse("case nil\nin #{query}\nend")
 
@@ -84,7 +93,10 @@ module Prism
     # pattern. If a block is given, it will be called with each node that
     # matches the pattern. If no block is given, an enumerator will be returned
     # that will yield each node that matches the pattern.
-    def scan(root)
+    #
+    #: (node root) -> Enumerator[node, void]
+    #: (node root) { (node) -> void } -> void
+    def scan(root, &blk)
       return to_enum(:scan, root) unless block_given?
 
       @compiled ||= compile
@@ -100,23 +112,33 @@ module Prism
 
     # Shortcut for combining two procs into one that returns true if both return
     # true.
-    def combine_and(left, right)
+    #
+    #: (Proc left, Proc right) -> Proc
+    def combine_and(left, right) # :nodoc:
       ->(other) { left.call(other) && right.call(other) }
     end
 
     # Shortcut for combining two procs into one that returns true if either
     # returns true.
-    def combine_or(left, right)
+    #
+    #: (Proc left, Proc right) -> Proc
+    def combine_or(left, right) # :nodoc:
       ->(other) { left.call(other) || right.call(other) }
     end
 
-    # Raise an error because the given node is not supported.
-    def compile_error(node)
+    # Raise an error because the given node is not supported. Note purposefully
+    # not typing this method since it is a no return method that Steep does not
+    # understand.
+    #
+    #: (node node) -> bot
+    def compile_error(node) # :nodoc:
       raise CompilationError, node.inspect
     end
 
     # in [foo, bar, baz]
-    def compile_array_pattern_node(node)
+    #
+    #: (ArrayPatternNode node) -> Proc
+    def compile_array_pattern_node(node) # :nodoc:
       compile_error(node) if !node.rest.nil? || node.posts.any?
 
       constant = node.constant
@@ -141,15 +163,19 @@ module Prism
     end
 
     # in foo | bar
-    def compile_alternation_pattern_node(node)
+    #
+    #: (AlternationPatternNode node) -> Proc
+    def compile_alternation_pattern_node(node) # :nodoc:
       combine_or(compile_node(node.left), compile_node(node.right))
     end
 
     # in Prism::ConstantReadNode
-    def compile_constant_path_node(node)
+    #
+    #: (ConstantPathNode node) -> Proc
+    def compile_constant_path_node(node) # :nodoc:
       parent = node.parent
 
-      if parent.is_a?(ConstantReadNode) && parent.slice == "Prism"
+      if (parent.is_a?(ConstantReadNode) || parent.is_a?(ConstantPathNode)) && parent.slice == Prism.name
         name = node.name
         raise CompilationError, node.inspect if name.nil?
 
@@ -161,12 +187,16 @@ module Prism
 
     # in ConstantReadNode
     # in String
-    def compile_constant_read_node(node)
+    #
+    #: (ConstantReadNode node) -> Proc
+    def compile_constant_read_node(node) # :nodoc:
       compile_constant_name(node, node.name)
     end
 
     # Compile a name associated with a constant.
-    def compile_constant_name(node, name)
+    #
+    #: ((ConstantPathNode | ConstantReadNode) node, Symbol name) -> Proc
+    def compile_constant_name(node, name) # :nodoc:
       if Prism.const_defined?(name, false)
         clazz = Prism.const_get(name)
 
@@ -182,9 +212,14 @@ module Prism
 
     # in InstanceVariableReadNode[name: Symbol]
     # in { name: Symbol }
-    def compile_hash_pattern_node(node)
+    #
+    #: (HashPatternNode node) -> Proc
+    def compile_hash_pattern_node(node) # :nodoc:
       compile_error(node) if node.rest
-      compiled_constant = compile_node(node.constant) if node.constant
+
+      if (constant = node.constant)
+        compiled_constant = compile_node(constant)
+      end
 
       preprocessed =
         node.elements.to_h do |element|
@@ -212,12 +247,16 @@ module Prism
     end
 
     # in nil
-    def compile_nil_node(node)
+    #
+    #: (NilNode node) -> Proc
+    def compile_nil_node(node) # :nodoc:
       ->(attribute) { attribute.nil? }
     end
 
     # in /foo/
-    def compile_regular_expression_node(node)
+    #
+    #: (RegularExpressionNode node) -> Proc
+    def compile_regular_expression_node(node) # :nodoc:
       regexp = Regexp.new(node.unescaped, node.closing[1..])
 
       ->(attribute) { regexp === attribute }
@@ -225,7 +264,9 @@ module Prism
 
     # in ""
     # in "foo"
-    def compile_string_node(node)
+    #
+    #: (StringNode node) -> Proc
+    def compile_string_node(node) # :nodoc:
       string = node.unescaped
 
       ->(attribute) { string === attribute }
@@ -233,7 +274,9 @@ module Prism
 
     # in :+
     # in :foo
-    def compile_symbol_node(node)
+    #
+    #: (SymbolNode node) -> Proc
+    def compile_symbol_node(node) # :nodoc:
       symbol = node.unescaped.to_sym
 
       ->(attribute) { symbol === attribute }
@@ -241,7 +284,9 @@ module Prism
 
     # Compile any kind of node. Dispatch out to the individual compilation
     # methods based on the type of node.
-    def compile_node(node)
+    #
+    #: (node node) -> Proc
+    def compile_node(node) # :nodoc:
       case node
       when AlternationPatternNode
         compile_alternation_pattern_node(node)

data/lib/prism/reflection.rb

@@ -9,6 +9,9 @@ if you are looking to modify the template
 ++
 =end
 
+#--
+# rbs_inline: enabled
+
 module Prism
   # The Reflection module provides the ability to reflect on the structure of
   # the syntax tree itself, as opposed to looking at a single syntax tree. This
@@ -18,9 +21,11 @@ module Prism
     # for all other field types.
     class Field
       # The name of the field.
-      attr_reader :name
+      attr_reader :name #: Symbol
 
       # Initializes the field with the given name.
+      #
+      #: (Symbol name) -> void
       def initialize(name)
         @name = name
       end
@@ -94,9 +99,11 @@ module Prism
     # the bitset should be accessed through their query methods.
     class FlagsField < Field
       # The names of the flags in the bitset.
-      attr_reader :flags
+      attr_reader :flags #: Array[Symbol]
 
       # Initializes the flags field with the given name and flags.
+      #
+      #: (Symbol name, Array[Symbol] flags) -> void
       def initialize(name, flags)
         super(name)
         @flags = flags
@@ -104,6 +111,8 @@ module Prism
     end
 
     # Returns the fields for the given node.
+    #
+    #: (singleton(Node) node) -> Array[Field]
     def self.fields_for(node)
       case node.type
       when :alias_global_variable_node
@@ -206,6 +215,8 @@ module Prism
         [LocationField.new(:operator_loc), NodeField.new(:variable)]
       when :ensure_node
         [LocationField.new(:ensure_keyword_loc), OptionalNodeField.new(:statements), LocationField.new(:end_keyword_loc)]
+      when :error_recovery_node
+        [OptionalNodeField.new(:unexpected)]
       when :false_node
         []
       when :find_pattern_node
@@ -221,7 +232,7 @@ module Prism
       when :forwarding_parameter_node
         []
       when :forwarding_super_node
-        [OptionalNodeField.new(:block)]
+        [LocationField.new(:keyword_loc), OptionalNodeField.new(:block)]
       when :global_variable_and_write_node
         [ConstantField.new(:name), LocationField.new(:name_loc), LocationField.new(:operator_loc), NodeField.new(:value)]
       when :global_variable_operator_write_node
@@ -247,7 +258,7 @@ module Prism
       when :implicit_rest_node
         []
       when :in_node
-        [NodeField.new(:pattern), OptionalNodeField.new(:statements), LocationField.new(:in_loc), OptionalLocationField.new(:then_loc)]
+        [NodeField.new(:pattern), OptionalNodeField.new(:statements), LocationField.new(:in_keyword_loc), OptionalLocationField.new(:then_keyword_loc)]
       when :index_and_write_node
         [FlagsField.new(:flags, [:safe_navigation?, :variable_call?, :attribute_write?, :ignore_visibility?]), OptionalNodeField.new(:receiver), OptionalLocationField.new(:call_operator_loc), LocationField.new(:opening_loc), OptionalNodeField.new(:arguments), LocationField.new(:closing_loc), OptionalNodeField.new(:block), LocationField.new(:operator_loc), NodeField.new(:value)]
       when :index_operator_write_node
@@ -305,13 +316,11 @@ module Prism
       when :match_last_line_node
         [FlagsField.new(:flags, [:ignore_case?, :extended?, :multi_line?, :once?, :euc_jp?, :ascii_8bit?, :windows_31j?, :utf_8?, :forced_utf8_encoding?, :forced_binary_encoding?, :forced_us_ascii_encoding?]), LocationField.new(:opening_loc), LocationField.new(:content_loc), LocationField.new(:closing_loc), StringField.new(:unescaped)]
       when :match_predicate_node
-        [NodeField.new(:value), NodeField.new(:pattern), LocationField.new(:operator_loc)]
+        [NodeField.new(:value), NodeField.new(:pattern), LocationField.new(:keyword_loc)]
       when :match_required_node
         [NodeField.new(:value), NodeField.new(:pattern), LocationField.new(:operator_loc)]
       when :match_write_node
         [NodeField.new(:call), NodeListField.new(:targets)]
-      when :missing_node
-        []
       when :module_node
         [ConstantListField.new(:locals), LocationField.new(:module_keyword_loc), NodeField.new(:constant_path), OptionalNodeField.new(:body), LocationField.new(:end_keyword_loc), ConstantField.new(:name)]
       when :multi_target_node
@@ -322,6 +331,8 @@ module Prism
         [OptionalNodeField.new(:arguments), LocationField.new(:keyword_loc)]
       when :nil_node
         []
+      when :no_block_parameter_node
+        [LocationField.new(:operator_loc), LocationField.new(:keyword_loc)]
       when :no_keywords_parameter_node
         [LocationField.new(:operator_loc), LocationField.new(:keyword_loc)]
       when :numbered_parameters_node
@@ -391,19 +402,19 @@ module Prism
       when :super_node
         [LocationField.new(:keyword_loc), OptionalLocationField.new(:lparen_loc), OptionalNodeField.new(:arguments), OptionalLocationField.new(:rparen_loc), OptionalNodeField.new(:block)]
       when :symbol_node
-        [FlagsField.new(:flags, [:forced_utf8_encoding?, :forced_binary_encoding?, :forced_us_ascii_encoding?]), OptionalLocationField.new(:opening_loc), OptionalLocationField.new(:value_loc), OptionalLocationField.new(:closing_loc), StringField.new(:unescaped)]
+        [FlagsField.new(:flags, [:forced_utf8_encoding?, :forced_binary_encoding?, :forced_us_ascii_encoding?]), OptionalLocationField.new(:opening_loc), LocationField.new(:content_loc), OptionalLocationField.new(:closing_loc), StringField.new(:unescaped)]
       when :true_node
         []
       when :undef_node
         [NodeListField.new(:names), LocationField.new(:keyword_loc)]
       when :unless_node
-        [LocationField.new(:keyword_loc), NodeField.new(:predicate), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements), OptionalNodeField.new(:else_clause), OptionalLocationField.new(:end_keyword_loc)]
+        [LocationField.new(:unless_keyword_loc), NodeField.new(:predicate), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements), OptionalNodeField.new(:else_clause), OptionalLocationField.new(:end_keyword_loc)]
       when :until_node
-        [FlagsField.new(:flags, [:begin_modifier?]), LocationField.new(:keyword_loc), OptionalLocationField.new(:do_keyword_loc), OptionalLocationField.new(:closing_loc), NodeField.new(:predicate), OptionalNodeField.new(:statements)]
+        [FlagsField.new(:flags, [:begin_modifier?]), LocationField.new(:until_keyword_loc), OptionalLocationField.new(:do_keyword_loc), OptionalLocationField.new(:end_keyword_loc), NodeField.new(:predicate), OptionalNodeField.new(:statements)]
       when :when_node
-        [LocationField.new(:keyword_loc), NodeListField.new(:conditions), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements)]
+        [LocationField.new(:when_keyword_loc), NodeListField.new(:conditions), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements)]
       when :while_node
-        [FlagsField.new(:flags, [:begin_modifier?]), LocationField.new(:keyword_loc), OptionalLocationField.new(:do_keyword_loc), OptionalLocationField.new(:closing_loc), NodeField.new(:predicate), OptionalNodeField.new(:statements)]
+        [FlagsField.new(:flags, [:begin_modifier?]), LocationField.new(:while_keyword_loc), OptionalLocationField.new(:do_keyword_loc), OptionalLocationField.new(:end_keyword_loc), NodeField.new(:predicate), OptionalNodeField.new(:statements)]
       when :x_string_node
         [FlagsField.new(:flags, [:forced_utf8_encoding?, :forced_binary_encoding?]), LocationField.new(:opening_loc), LocationField.new(:content_loc), LocationField.new(:closing_loc), StringField.new(:unescaped)]
       when :yield_node