prism 2.0.0.rc1-x86_64-linux-gnu

data/sig/generated/prism/node_ext.rbs

@@ -0,0 +1,290 @@
+# Generated from lib/prism/node_ext.rb with RBS::Inline
+
+# --
+#  Here we are reopening the prism module to provide methods on nodes that aren't
+#  templated and are meant as convenience methods.
+# ++
+module Prism
+  class Node
+    # : (*String replacements) -> void
+    def deprecated: (*String replacements) -> void
+  end
+
+  module RegularExpressionOptions
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    #
+    # : (Integer flags) -> Integer
+    def self.options: (Integer flags) -> Integer
+  end
+
+  class InterpolatedMatchLastLineNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    #
+    # : () -> Integer
+    def options: () -> Integer
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    #
+    # : () -> Integer
+    def options: () -> Integer
+  end
+
+  class MatchLastLineNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    #
+    # : () -> Integer
+    def options: () -> Integer
+  end
+
+  class RegularExpressionNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    #
+    # : () -> Integer
+    def options: () -> Integer
+  end
+
+  module HeredocQuery
+    # Returns true if this node was represented as a heredoc in the source code.
+    #
+    # : (String? opening) -> bool?
+    def self.heredoc?: (String? opening) -> bool?
+  end
+
+  class InterpolatedStringNode < Node
+    # Returns true if this node was represented as a heredoc in the source code.
+    #
+    # : () -> bool?
+    def heredoc?: () -> bool?
+  end
+
+  class InterpolatedXStringNode < Node
+    # Returns true if this node was represented as a heredoc in the source code.
+    #
+    # : () -> bool?
+    def heredoc?: () -> bool?
+  end
+
+  class StringNode < Node
+    # Returns true if this node was represented as a heredoc in the source code.
+    #
+    # : () -> bool?
+    def heredoc?: () -> bool?
+
+    # Occasionally it's helpful to treat a string as if it were interpolated so
+    # that there's a consistent interface for working with strings.
+    #
+    # : () -> InterpolatedStringNode
+    def to_interpolated: () -> InterpolatedStringNode
+  end
+
+  class XStringNode < Node
+    # Returns true if this node was represented as a heredoc in the source code.
+    #
+    # : () -> bool?
+    def heredoc?: () -> bool?
+
+    # Occasionally it's helpful to treat a string as if it were interpolated so
+    # that there's a consistent interface for working with strings.
+    #
+    # : () -> InterpolatedXStringNode
+    def to_interpolated: () -> InterpolatedXStringNode
+  end
+
+  class ImaginaryNode < Node
+    # Returns the value of the node as a Ruby Complex.
+    #
+    # : () -> Complex
+    def value: () -> Complex
+  end
+
+  class RationalNode < Node
+    # Returns the value of the node as a Ruby Rational.
+    #
+    # : () -> Rational
+    def value: () -> Rational
+  end
+
+  class ConstantReadNode < Node
+    # Returns the list of parts for the full name of this constant.
+    # For example: [:Foo]
+    #
+    # : () -> Array[Symbol]
+    def full_name_parts: () -> Array[Symbol]
+
+    # Returns the full name of this constant. For example: "Foo"
+    #
+    # : () -> String
+    def full_name: () -> String
+  end
+
+  class ConstantWriteNode < Node
+    # Returns the list of parts for the full name of this constant.
+    # For example: [:Foo]
+    #
+    # : () -> Array[Symbol]
+    def full_name_parts: () -> Array[Symbol]
+
+    # Returns the full name of this constant. For example: "Foo"
+    #
+    # : () -> String
+    def full_name: () -> String
+  end
+
+  class ConstantPathNode < Node
+    # An error class raised when dynamic parts are found while computing a
+    # constant path's full name. For example:
+    # Foo::Bar::Baz -> does not raise because all parts of the constant path are
+    # simple constants
+    # var::Bar::Baz -> raises because the first part of the constant path is a
+    # local variable
+    class DynamicPartsInConstantPathError < StandardError
+    end
+
+    # An error class raised when error recovery nodes are found while computing a
+    # constant path's full name. For example:
+    # Foo:: -> raises because the constant path is missing the last part
+    class ErrorRecoveryNodesInConstantPathError < StandardError
+    end
+
+    # Returns the list of parts for the full name of this constant path.
+    # For example: [:Foo, :Bar]
+    #
+    # : () -> Array[Symbol]
+    def full_name_parts: () -> Array[Symbol]
+
+    # Returns the full name of this constant path. For example: "Foo::Bar"
+    #
+    # : () -> String
+    def full_name: () -> String
+  end
+
+  class ConstantPathTargetNode < Node
+    # Returns the list of parts for the full name of this constant path.
+    # For example: [:Foo, :Bar]
+    #
+    # : () -> Array[Symbol]
+    def full_name_parts: () -> Array[Symbol]
+
+    # Returns the full name of this constant path. For example: "Foo::Bar"
+    #
+    # : () -> String
+    def full_name: () -> String
+  end
+
+  class ConstantTargetNode < Node
+    # Returns the list of parts for the full name of this constant.
+    # For example: [:Foo]
+    #
+    # : () -> Array[Symbol]
+    def full_name_parts: () -> Array[Symbol]
+
+    # Returns the full name of this constant. For example: "Foo"
+    #
+    # : () -> String
+    def full_name: () -> String
+  end
+
+  class ParametersNode < Node
+    # Mirrors the Method#parameters method.
+    #
+    # : () -> Array[[Symbol, Symbol] | [Symbol]]
+    def signature: () -> Array[[ Symbol, Symbol ] | [ Symbol ]]
+  end
+
+  class CallNode < Node
+    # When a call node has the attribute_write flag set, it means that the call
+    # is using the attribute write syntax. This is either a method call to []=
+    # or a method call to a method that ends with =. Either way, the = sign is
+    # present in the source.
+    #
+    # Prism returns the message_loc _without_ the = sign attached, because there
+    # can be any amount of space between the message and the = sign. However,
+    # sometimes you want the location of the full message including the inner
+    # space and the = sign. This method provides that.
+    #
+    # : () -> Location?
+    def full_message_loc: () -> Location?
+  end
+
+  # :stopdoc:
+  class InNode < Node
+    # : () -> String
+    def in: () -> String
+
+    # : () -> Location
+    def in_loc: () -> Location
+
+    # : () -> String?
+    def then: () -> String?
+
+    # : () -> Location?
+    def then_loc: () -> Location?
+  end
+
+  class MatchPredicateNode < Node
+    # : () -> String
+    def operator: () -> String
+
+    # : () -> Location
+    def operator_loc: () -> Location
+  end
+
+  class UnlessNode < Node
+    # : () -> String
+    def keyword: () -> String
+
+    # : () -> Location
+    def keyword_loc: () -> Location
+  end
+
+  class UntilNode < Node
+    # : () -> String
+    def keyword: () -> String
+
+    # : () -> Location
+    def keyword_loc: () -> Location
+
+    # : () -> String?
+    def closing: () -> String?
+
+    # : () -> Location?
+    def closing_loc: () -> Location?
+  end
+
+  class WhenNode < Node
+    # : () -> String
+    def keyword: () -> String
+
+    # : () -> Location
+    def keyword_loc: () -> Location
+  end
+
+  class WhileNode < Node
+    # : () -> String
+    def keyword: () -> String
+
+    # : () -> Location
+    def keyword_loc: () -> Location
+
+    # : () -> String?
+    def closing: () -> String?
+
+    # : () -> Location?
+    def closing_loc: () -> Location?
+  end
+
+  class SymbolNode < Node
+    # : () -> String
+    def value: () -> String
+
+    # : () -> Location
+    def value_loc: () -> Location
+  end
+end

data/sig/generated/prism/node_find.rbs

@@ -0,0 +1,90 @@
+# Generated from lib/prism/node_find.rb with RBS::Inline
+
+module Prism
+  # Finds the Prism AST node corresponding to a given Method, UnboundMethod,
+  # Proc, or Thread::Backtrace::Location. On CRuby, uses node_id from the
+  # instruction sequence for an exact match. On other implementations, falls
+  # back to best-effort matching by source location line number.
+  #
+  # This module is autoloaded so that programs that don't use Prism.find don't
+  # pay for its definition.
+  module NodeFind
+    # Find the node for the given callable or backtrace location.
+    #
+    # : (Method | UnboundMethod | Proc | Thread::Backtrace::Location callable) -> Node?
+    def self.find: (Method | UnboundMethod | Proc | Thread::Backtrace::Location callable) -> Node?
+
+    # Base class that handles parsing a file.
+    class Find
+      private
+
+      # Parse the given file path, returning a ParseResult or nil.
+      #
+      # : (String? file) -> ParseResult?
+      def parse_file: (String? file) -> ParseResult?
+    end
+
+    # Finds the AST node for a Method, UnboundMethod, Proc or Thread::Backtrace::Location
+    # using the #source_range
+    class SourceRangeFind < Find
+      # Find the node for the given callable using the #source_range.
+      #
+      # : (Method | UnboundMethod | Proc | Thread::Backtrace::Location callable) -> Node?
+      def find: (Method | UnboundMethod | Proc | Thread::Backtrace::Location callable) -> Node?
+    end
+
+    # Finds the AST node for a Method, UnboundMethod, or Proc using the node_id
+    # from the instruction sequence.
+    class RubyVMCallableFind < Find
+      # Find the node for the given callable using the ISeq node_id.
+      #
+      # : (Method | UnboundMethod | Proc callable) -> Node?
+      def find: (Method | UnboundMethod | Proc callable) -> Node?
+    end
+
+    # Finds the AST node for a Thread::Backtrace::Location using the node_id
+    # from the backtrace location.
+    class RubyVMBacktraceLocationFind < Find
+      # Find the node for the given backtrace location using node_id.
+      #
+      # : (Thread::Backtrace::Location location) -> Node?
+      def find: (Thread::Backtrace::Location location) -> Node?
+    end
+
+    # Finds the AST node for a Method or UnboundMethod using best-effort line
+    # matching. Used on non-CRuby implementations.
+    class LineMethodFind < Find
+      # Find the node for the given method by matching on name and line.
+      #
+      # : (Method | UnboundMethod callable) -> Node?
+      def find: (Method | UnboundMethod callable) -> Node?
+    end
+
+    # Finds the AST node for a lambda using best-effort line matching. Used
+    # on non-CRuby implementations.
+    class LineLambdaFind < Find
+      # Find the node for the given lambda by matching on line.
+      #
+      # : (Proc callable) -> Node?
+      def find: (Proc callable) -> Node?
+    end
+
+    # Finds the AST node for a non-lambda Proc using best-effort line
+    # matching. Used on non-CRuby implementations.
+    class LineProcFind < Find
+      # Find the node for the given proc by matching on line.
+      #
+      # : (Proc callable) -> Node?
+      def find: (Proc callable) -> Node?
+    end
+
+    # Finds the AST node for a Thread::Backtrace::Location using best-effort
+    # line matching. Used on non-CRuby implementations.
+    class LineBacktraceLocationFind < Find
+      # Find the node for the given backtrace location by matching on line.
+      #
+      # : (Thread::Backtrace::Location location) -> Node?
+      def find: (Thread::Backtrace::Location location) -> Node?
+    end
+  end
+end

data/sig/generated/prism/parse_result/errors.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/prism/parse_result/errors.rb with RBS::Inline
+
+module Prism
+  class ParseResult < Result
+    # An object to represent the set of errors on a parse result. This object
+    # can be used to format the errors in a human-readable way.
+    class Errors
+      # The parse result that contains the errors.
+      attr_reader parse_result: ParseResult
+
+      # Initialize a new set of errors from the given parse result.
+      #
+      # : (ParseResult parse_result) -> void
+      def initialize: (ParseResult parse_result) -> void
+
+      # Formats the errors in a human-readable way and return them as a string.
+      #
+      # : () -> String
+      def format: () -> String
+    end
+  end
+end

data/sig/generated/prism/parse_result/newlines.rbs

@@ -0,0 +1,223 @@
+# Generated from lib/prism/parse_result/newlines.rb with RBS::Inline
+
+module Prism
+  class ParseResult < Result
+    # The :line tracepoint event gets fired whenever the Ruby VM encounters an
+    # expression on a new line. The types of expressions that can trigger this
+    # event are:
+    #
+    # * if statements
+    # * unless statements
+    # * nodes that are children of statements lists
+    #
+    # In order to keep track of the newlines, we have a list of offsets that
+    # come back from the parser. We assign these offsets to the first nodes that
+    # we find in the tree that are on those lines.
+    #
+    # Note that the logic in this file should be kept in sync with the Java
+    # MarkNewlinesVisitor, since that visitor is responsible for marking the
+    # newlines for JRuby/TruffleRuby.
+    #
+    # This file is autoloaded only when `mark_newlines!` is called, so the
+    # re-opening of the various nodes in this file will only be performed in
+    # that case. We do that to avoid storing the extra `@newline` instance
+    # variable on every node if we don't need it.
+    class Newlines < Visitor
+      @lines: Array[bool]
+
+      # Create a new Newlines visitor with the given newline offsets.
+      #
+      # : (Integer lines) -> void
+      def initialize: (Integer lines) -> void
+
+      # Permit block nodes to mark newlines within themselves.
+      #
+      # : (BlockNode node) -> void
+      def visit_block_node: (BlockNode node) -> void
+
+      # Permit lambda nodes to mark newlines within themselves.
+      #
+      # : (LambdaNode node) -> void
+      def visit_lambda_node: (LambdaNode node) -> void
+
+      # Permit def nodes to mark newlines within themselves. The body of an
+      # endless method definition never emits newline events, so in that case
+      # mark every line as already seen while visiting it instead. Nested
+      # scopes (blocks, lambdas, etc.) reset the lines and emit events again.
+      #
+      # : (DefNode node) -> void
+      def visit_def_node: (DefNode node) -> void
+
+      # Permit class nodes to mark newlines within themselves.
+      #
+      # : (ClassNode node) -> void
+      def visit_class_node: (ClassNode node) -> void
+
+      # Permit module nodes to mark newlines within themselves.
+      #
+      # : (ModuleNode node) -> void
+      def visit_module_node: (ModuleNode node) -> void
+
+      # Permit singleton class nodes to mark newlines within themselves.
+      #
+      # : (SingletonClassNode node) -> void
+      def visit_singleton_class_node: (SingletonClassNode node) -> void
+
+      # Statements inside string interpolation do not emit newline events, so
+      # mark every line as already seen while visiting them. Nested scopes
+      # (blocks, lambdas, defs, etc.) reset the lines and emit events again.
+      #
+      # : (EmbeddedStatementsNode node) -> void
+      def visit_embedded_statements_node: (EmbeddedStatementsNode node) -> void
+
+      # The predicate of a while loop is compiled at the end of the loop,
+      # after the body, so any statements it contains (from parentheses)
+      # emit their line events again even if the lines were already seen.
+      #
+      # : (WhileNode node) -> void
+      def visit_while_node: (WhileNode node) -> void
+
+      # The predicate of an until loop is compiled at the end of the loop,
+      # after the body, so any statements it contains (from parentheses)
+      # emit their line events again even if the lines were already seen.
+      #
+      # : (UntilNode node) -> void
+      def visit_until_node: (UntilNode node) -> void
+
+      # Mark if nodes as newlines.
+      #
+      # : (IfNode node) -> void
+      def visit_if_node: (IfNode node) -> void
+
+      # Mark unless nodes as newlines.
+      #
+      # : (UnlessNode node) -> void
+      def visit_unless_node: (UnlessNode node) -> void
+
+      # Permit statements lists to mark newlines within themselves.
+      #
+      # : (StatementsNode node) -> void
+      def visit_statements_node: (StatementsNode node) -> void
+    end
+  end
+
+  class Node
+    @newline_flag: bool
+
+    # : () -> bool
+    def newline_flag?: () -> bool
+
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class BeginNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class ParenthesesNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class IfNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class UnlessNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class UntilNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class WhileNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class RescueModifierNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class LocalVariableWriteNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class InstanceVariableWriteNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class ClassVariableWriteNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class GlobalVariableWriteNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class ConstantWriteNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class ConstantPathWriteNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class MultiWriteNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class CallNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class ArrayNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class HashNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class InterpolatedMatchLastLineNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class InterpolatedStringNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class InterpolatedSymbolNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+
+  class InterpolatedXStringNode < Node
+    # : (Array[bool] lines) -> void
+    def newline_flag!: (Array[bool] lines) -> void
+  end
+end