prism 1.4.0 → 1.7.0

data/sig/prism/node_ext.rbs

@@ -1,46 +1,40 @@
 module Prism
+  class Node
+    def deprecated: (*String replacements) -> void
+  end
+
   class InterpolatedMatchLastLineNode < Node
-    # Returns a numeric value that represents the flags that were used to create
-    # the regular expression.
     def options: () -> Integer
   end
 
   class InterpolatedRegularExpressionNode < Node
-    # Returns a numeric value that represents the flags that were used to create
-    # the regular expression.
     def options: () -> Integer
   end
 
   class MatchLastLineNode < Node
-    # Returns a numeric value that represents the flags that were used to create
-    # the regular expression.
     def options: () -> Integer
   end
 
   class RegularExpressionNode < Node
-    # Returns a numeric value that represents the flags that were used to create
-    # the regular expression.
     def options: () -> Integer
   end
 
   class InterpolatedStringNode < Node
-    # Returns true if this node was represented as a heredoc in the source code.
-    def heredoc?: () -> bool?
+    def heredoc?: () -> bool
   end
 
   class InterpolatedXStringNode < Node
-    # Returns true if this node was represented as a heredoc in the source code.
-    def heredoc?: () -> bool?
+    def heredoc?: () -> bool
   end
 
   class StringNode < Node
-    # Returns true if this node was represented as a heredoc in the source code.
-    def heredoc?: () -> bool?
+    def heredoc?: () -> bool
+    def to_interpolated: () -> InterpolatedStringNode
   end
 
   class XStringNode < Node
-    # Returns true if this node was represented as a heredoc in the source code.
-    def heredoc?: () -> bool?
+    def heredoc?: () -> bool
+    def to_interpolated: () -> InterpolatedXStringNode
   end
 
   class ImaginaryNode < Node
@@ -49,10 +43,16 @@ module Prism
 
   class RationalNode < Node
     def value: () -> Rational
+    def numeric: () -> (IntegerNode | FloatNode)
   end
 
   class ConstantReadNode < Node
-    def full_name_parts: () -> [Symbol]
+    def full_name_parts: () -> Array[Symbol]
+    def full_name: () -> String
+  end
+
+  class ConstantWriteNode < Node
+    def full_name_parts: () -> Array[Symbol]
     def full_name: () -> String
   end
 
@@ -65,11 +65,18 @@ module Prism
 
     def full_name_parts: () -> Array[Symbol]
     def full_name: () -> String
+    def child: () -> (ConstantReadNode | MissingNode)
   end
 
   class ConstantPathTargetNode < Node
     def full_name_parts: () -> Array[Symbol]
     def full_name: () -> String
+    def child: () -> (ConstantReadNode | MissingNode)
+  end
+
+  class ConstantTargetNode < Node
+    def full_name_parts: () -> Array[Symbol]
+    def full_name: () -> String
   end
 
   class ParametersNode < Node
@@ -79,4 +86,64 @@ module Prism
   class CallNode < Node
     def full_message_loc: () -> Location?
   end
+
+  class CallOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class ClassVariableOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class ConstantOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class ConstantPathOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class GlobalVariableOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class IndexOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class InstanceVariableOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class LocalVariableOperatorWriteNode < Node
+    def operator: () -> Symbol
+    def operator_loc: () -> Location
+  end
+
+  class CaseMatchNode < Node
+    def consequent: () -> ElseNode?
+  end
+
+  class CaseNode < Node
+    def consequent: () -> ElseNode?
+  end
+
+  class IfNode < Node
+    def consequent: () -> (ElseNode | IfNode | nil)
+  end
+
+  class RescueNode < Node
+    def consequent: () -> RescueNode?
+  end
+
+  class UnlessNode < Node
+    def consequent: () -> ElseNode?
+  end
 end

data/sig/prism/parse_result/comments.rbs

@@ -0,0 +1,38 @@
+module Prism
+  class ParseResult < Result
+    class Comments
+      interface _Target
+        def start_offset: () -> Integer
+        def end_offset: () -> Integer
+        def encloses?: (comment) -> bool
+        def leading_comment: (comment) -> void
+        def trailing_comment: (comment) -> void
+      end
+
+      class NodeTarget
+        include _Target
+
+        attr_reader node: node
+
+        def initialize: (node) -> void
+      end
+
+      class LocationTarget
+        include _Target
+
+        attr_reader location: Location
+
+        def initialize: (Location location) -> void
+      end
+
+      attr_reader parse_result: ParseResult
+
+      def initialize: (ParseResult parse_result) -> void
+      def attach!: () -> void
+
+      private
+
+      def nearest_targets: (node, comment) -> [_Target?, _Target, _Target?]
+    end
+  end
+end

data/sig/prism/parse_result.rbs

@@ -24,6 +24,7 @@ module Prism
     def code_units_offset: (Integer byte_offset, Encoding encoding) -> Integer
     def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
     def code_units_column: (Integer byte_offset, Encoding encoding) -> Integer
+    def deep_freeze: () -> void
 
     def self.for: (String source) -> Source
   end
@@ -145,6 +146,7 @@ module Prism
 
     def initialize: (Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
     def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
+    def encoding: () -> Encoding
     def success?: () -> bool
     def failure?: () -> bool
     def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
@@ -155,6 +157,7 @@ module Prism
 
     def initialize: (ProgramNode value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
     def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
+    def errors_format: () -> String
   end
 
   class LexResult < Result
@@ -181,6 +184,7 @@ module Prism
     def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
     def pretty_print: (untyped q) -> untyped
     def ==: (untyped other) -> bool
+    def deep_freeze: () -> void
   end
 
   class Scope

data/sig/prism/reflection.rbs

@@ -45,6 +45,6 @@ module Prism
       def initialize: (Symbol name, Array[Symbol] flags) -> void
     end
 
-    def self.fields_for: (node_singleton node) -> Array[Field]
+    def self.fields_for: (singleton(Node) node) -> Array[Field]
   end
 end

data/sig/prism.rbs

@@ -6,6 +6,10 @@ module Prism
   BACKEND: :CEXT | :FFI
   VERSION: String
 
+  class CurrentVersionError < ArgumentError
+    def initialize: (String version) -> void
+  end
+
   # Methods taking a Ruby source code string:
 
   def self.parse: (

data/src/diagnostic.c

@@ -1,3 +1,5 @@
+/* :markup: markdown */
+
 /*----------------------------------------------------------------------------*/
 /* This file is generated by the templates/template.rb script and should not  */
 /* be modified manually. See                                                  */
@@ -8,7 +10,7 @@
 
 #include "prism/diagnostic.h"
 
-#define PM_DIAGNOSTIC_ID_MAX 319
+#define PM_DIAGNOSTIC_ID_MAX 324
 
 /** This struct holds the data for each diagnostic. */
 typedef struct {
@@ -152,6 +154,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_CONDITIONAL_WHILE_PREDICATE]        = { "expected a predicate expression for the `while` statement", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT] = { "expected a constant after the `::` operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_ENDLESS]                        = { "could not parse the endless method body", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_DEF_ENDLESS_PARAMETERS]             = { "could not parse the endless method parameters", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_ENDLESS_SETTER]                 = { "invalid method name; a setter method cannot be defined in an endless method definition", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_NAME]                           = { "unexpected %s; expected a method name", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_DEF_PARAMS_TERM]                    = { "expected a delimiter to close the parameters", PM_ERROR_LEVEL_SYNTAX },
@@ -192,6 +195,8 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_EXPECT_FOR_DELIMITER]               = { "unexpected %s; expected a 'do', newline, or ';' after the 'for' loop collection", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_IDENT_REQ_PARAMETER]         = { "expected an identifier for the required parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_IN_DELIMITER]                = { "expected a delimiter after the patterns of an `in` clause", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_EXPECT_LPAREN_AFTER_NOT_LPAREN]     = { "expected a `(` immediately after `not`", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_EXPECT_LPAREN_AFTER_NOT_OTHER]      = { "expected a `(` after `not`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_LPAREN_REQ_PARAMETER]        = { "expected a `(` to start a required parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_MESSAGE]                     = { "unexpected %s; expecting a message to send to the receiver", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_EXPECT_RBRACKET]                    = { "expected a matching `]`", PM_ERROR_LEVEL_SYNTAX },
@@ -306,6 +311,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_PARAMETER_UNEXPECTED_NO_KW]         = { "unexpected **nil; no keywords marker disallowed after keywords", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS]       = { "unexpected multiple '*' rest patterns in an array pattern", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_CAPTURE_DUPLICATE]          = { "duplicated variable name", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_PATTERN_CAPTURE_IN_ALTERNATIVE]     = { "variable capture in alternative pattern", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET]   = { "expected a pattern expression after the `[` operator", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA]     = { "expected a pattern expression after `,`", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET]   = { "expected a pattern expression after `=>`", PM_ERROR_LEVEL_SYNTAX },
@@ -366,6 +372,7 @@ static const pm_diagnostic_data_t diagnostic_messages[PM_DIAGNOSTIC_ID_MAX] = {
     [PM_ERR_UNEXPECTED_INDEX_KEYWORDS]          = { "unexpected keyword arg given in index assignment; keywords are not allowed in index assignment expressions", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_LABEL]                   = { "unexpected label", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_MULTI_WRITE]             = { "unexpected multiple assignment; multiple assignment is not allowed in this context", PM_ERROR_LEVEL_SYNTAX },
+    [PM_ERR_UNEXPECTED_PARAMETER_DEFAULT_VALUE] = { "unexpected %s; expected a default value for a parameter", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_RANGE_OPERATOR]          = { "unexpected range operator; .. and ... are non-associative and cannot be chained", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_SAFE_NAVIGATION]         = { "&. inside multiple assignment destination", PM_ERROR_LEVEL_SYNTAX },
     [PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT]     = { "unexpected %s, assuming it is closing the parent %s", PM_ERROR_LEVEL_SYNTAX },
@@ -478,6 +485,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_CONDITIONAL_WHILE_PREDICATE: return "conditional_while_predicate";
         case PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT: return "constant_path_colon_colon_constant";
         case PM_ERR_DEF_ENDLESS: return "def_endless";
+        case PM_ERR_DEF_ENDLESS_PARAMETERS: return "def_endless_parameters";
         case PM_ERR_DEF_ENDLESS_SETTER: return "def_endless_setter";
         case PM_ERR_DEF_NAME: return "def_name";
         case PM_ERR_DEF_PARAMS_TERM: return "def_params_term";
@@ -519,6 +527,8 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_EXPECT_FOR_DELIMITER: return "expect_for_delimiter";
         case PM_ERR_EXPECT_IDENT_REQ_PARAMETER: return "expect_ident_req_parameter";
         case PM_ERR_EXPECT_IN_DELIMITER: return "expect_in_delimiter";
+        case PM_ERR_EXPECT_LPAREN_AFTER_NOT_LPAREN: return "expect_lparen_after_not_lparen";
+        case PM_ERR_EXPECT_LPAREN_AFTER_NOT_OTHER: return "expect_lparen_after_not_other";
         case PM_ERR_EXPECT_LPAREN_REQ_PARAMETER: return "expect_lparen_req_parameter";
         case PM_ERR_EXPECT_MESSAGE: return "expect_message";
         case PM_ERR_EXPECT_RBRACKET: return "expect_rbracket";
@@ -634,6 +644,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_PARAMETER_WILD_LOOSE_COMMA: return "parameter_wild_loose_comma";
         case PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS: return "pattern_array_multiple_rests";
         case PM_ERR_PATTERN_CAPTURE_DUPLICATE: return "pattern_capture_duplicate";
+        case PM_ERR_PATTERN_CAPTURE_IN_ALTERNATIVE: return "pattern_capture_in_alternative";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET: return "pattern_expression_after_bracket";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA: return "pattern_expression_after_comma";
         case PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET: return "pattern_expression_after_hrocket";
@@ -695,6 +706,7 @@ pm_diagnostic_id_human(pm_diagnostic_id_t diag_id) {
         case PM_ERR_UNEXPECTED_INDEX_KEYWORDS: return "unexpected_index_keywords";
         case PM_ERR_UNEXPECTED_LABEL: return "unexpected_label";
         case PM_ERR_UNEXPECTED_MULTI_WRITE: return "unexpected_multi_write";
+        case PM_ERR_UNEXPECTED_PARAMETER_DEFAULT_VALUE: return "unexpected_parameter_default_value";
         case PM_ERR_UNEXPECTED_RANGE_OPERATOR: return "unexpected_range_operator";
         case PM_ERR_UNEXPECTED_SAFE_NAVIGATION: return "unexpected_safe_navigation";
         case PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT: return "unexpected_token_close_context";