prism 0.26.0 → 0.28.0

data/rbi/prism/parse_result.rbi

@@ -2,13 +2,13 @@
 
 class Prism::Source
   sig { returns(String) }
-  attr_reader :source
+  def source; end
 
   sig { returns(Integer) }
-  attr_reader :start_line
+  def start_line; end
 
   sig { returns(T::Array[Integer]) }
-  attr_reader :offsets
+  def offsets; end
 
   sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
   def initialize(source, start_line = 1, offsets = []); end
@@ -16,6 +16,9 @@ class Prism::Source
   sig { returns(Encoding) }
   def encoding; end
 
+  sig { returns(T::Array[Integer]) }
+  def lines; end
+
   sig { params(byte_offset: Integer, length: Integer).returns(String) }
   def slice(byte_offset, length); end
 
@@ -41,15 +44,29 @@ class Prism::Source
   def code_units_column(byte_offset, encoding); end
 end
 
+class Prism::ASCIISource < Prism::Source
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_offset(byte_offset); end
+
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_column(byte_offset); end
+
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_offset(byte_offset, encoding); end
+
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_column(byte_offset, encoding); end
+end
+
 class Prism::Location
   sig { returns(Prism::Source) }
-  attr_reader :source
+  def source; end
 
   sig { returns(Integer) }
-  attr_reader :start_offset
+  def start_offset; end
 
   sig { returns(Integer) }
-  attr_reader :length
+  def length; end
 
   sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
   def initialize(source, start_offset, length); end
@@ -78,6 +95,9 @@ class Prism::Location
   sig { returns(String) }
   def inspect; end
 
+  sig { returns(T::Array[String]) }
+  def source_lines; end
+
   sig { returns(String) }
   def slice; end
 
@@ -134,13 +154,16 @@ class Prism::Location
 
   sig { params(other: Prism::Location).returns(Prism::Location) }
   def join(other); end
+
+  sig { params(string: String).returns(Prism::Location) }
+  def adjoin(string); end
 end
 
 class Prism::Comment
   abstract!
 
   sig { returns(Prism::Location) }
-  attr_reader :location
+  def location; end
 
   sig { params(location: Prism::Location).void }
   def initialize(location); end
@@ -173,10 +196,10 @@ end
 
 class Prism::MagicComment
   sig { returns(Prism::Location) }
-  attr_reader :key_loc
+  def key_loc; end
 
   sig { returns(Prism::Location) }
-  attr_reader :value_loc
+  def value_loc; end
 
   sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
   def initialize(key_loc, value_loc); end
@@ -196,16 +219,16 @@ end
 
 class Prism::ParseError
   sig { returns(Symbol) }
-  attr_reader :type
+  def type; end
 
   sig { returns(String) }
-  attr_reader :message
+  def message; end
 
   sig { returns(Prism::Location) }
-  attr_reader :location
+  def location; end
 
   sig { returns(Symbol) }
-  attr_reader :level
+  def level; end
 
   sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
   def initialize(type, message, location, level); end
@@ -219,16 +242,16 @@ end
 
 class Prism::ParseWarning
   sig { returns(Symbol) }
-  attr_reader :type
+  def type; end
 
   sig { returns(String) }
-  attr_reader :message
+  def message; end
 
   sig { returns(Prism::Location) }
-  attr_reader :location
+  def location; end
 
   sig { returns(Symbol) }
-  attr_reader :level
+  def level; end
 
   sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
   def initialize(type, message, location, level); end
@@ -240,32 +263,27 @@ class Prism::ParseWarning
   def inspect; end
 end
 
-class Prism::ParseResult
-  Value = type_member
-
-  sig { returns(Value) }
-  attr_reader :value
+class Prism::Result
+  sig { params(comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
 
   sig { returns(T::Array[Prism::Comment]) }
-  attr_reader :comments
+  def comments; end
 
   sig { returns(T::Array[Prism::MagicComment]) }
-  attr_reader :magic_comments
+  def magic_comments; end
 
   sig { returns(T.nilable(Prism::Location)) }
-  attr_reader :data_loc
+  def data_loc; end
 
   sig { returns(T::Array[Prism::ParseError]) }
-  attr_reader :errors
+  def errors; end
 
   sig { returns(T::Array[Prism::ParseWarning]) }
-  attr_reader :warnings
+  def warnings; end
 
   sig { returns(Prism::Source) }
-  attr_reader :source
-
-  sig { params(value: Value, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+  def source; end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -280,15 +298,48 @@ class Prism::ParseResult
   def failure?; end
 end
 
+class Prism::ParseResult < Prism::Result
+  sig { params(value: Prism::ProgramNode, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  sig { returns(Prism::ProgramNode) }
+  def value; end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+end
+
+class Prism::LexResult < Prism::Result
+  sig { params(value: T::Array[T.untyped], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  sig { returns(T::Array[T.untyped]) }
+  def value; end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+end
+
+class Prism::ParseLexResult < Prism::Result
+  sig { params(value: [Prism::ProgramNode, T::Array[T.untyped]], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
+  def value; end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+end
+
 class Prism::Token
   sig { returns(Prism::Source) }
-  attr_reader :source
+  def source; end
 
   sig { returns(Symbol) }
-  attr_reader :type
+  def type; end
 
   sig { returns(String) }
-  attr_reader :value
+  def value; end
 
   sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
   def initialize(source, type, value, location); end

data/rbi/prism/reflection.rbi

@@ -4,11 +4,11 @@ module Prism::Reflection
 end
 
 class Prism::Reflection::Field
-  sig { returns(Symbol) }
-  attr_reader :name
-
   sig { params(name: Symbol).void }
   def initialize(name); end
+
+  sig { returns(Symbol) }
+  def name; end
 end
 
 class Prism::Reflection::NodeField < Prism::Reflection::Field
@@ -38,24 +38,18 @@ end
 class Prism::Reflection::OptionalLocationField < Prism::Reflection::Field
 end
 
-class Prism::Reflection::UInt8Field < Prism::Reflection::Field
+class Prism::Reflection::IntegerField < Prism::Reflection::Field
 end
 
-class Prism::Reflection::UInt32Field < Prism::Reflection::Field
+class Prism::Reflection::FloatField < Prism::Reflection::Field
 end
 
 class Prism::Reflection::FlagsField < Prism::Reflection::Field
-  sig { returns(T::Array[Symbol]) }
-  attr_reader :flags
-
   sig { params(name: Symbol, flags: T::Array[Symbol]).void }
   def initialize(name, flags); end
-end
-
-class Prism::Reflection::IntegerField < Prism::Reflection::Field
-end
 
-class Prism::Reflection::DoubleField < Prism::Reflection::Field
+  sig { returns(T::Array[Symbol]) }
+  def flags; end
 end
 
 module Prism::Reflection

data/rbi/prism/translation/ripper.rbi

@@ -1,12 +1,10 @@
 # typed: strict
 
 class Prism::Translation::Ripper < Prism::Compiler
-  Result = type_member
-
   sig { returns(T::Boolean) }
   def error?; end
 
-  sig { returns(T.nilable(Result)) }
+  sig { returns(T.untyped) }
   def parse; end
 
   sig { params(source: String, filename: String, lineno: Integer, raise_errors: T.untyped).returns(T.untyped) }
@@ -15,11 +13,3 @@ class Prism::Translation::Ripper < Prism::Compiler
   sig { params(source: String, filename: String, lineno: Integer, raise_errors: T.untyped).returns(T.untyped) }
   def self.sexp(source, filename = "-", lineno = 1, raise_errors: false); end
 end
-
-class Prism::Translation::Ripper::SexpBuilder < Prism::Translation::Ripper
-  Result = type_member { { fixed: T::Array[T.untyped] } }
-end
-
-class Prism::Translation::Ripper::SexpBuilderPP < Prism::Translation::Ripper::SexpBuilder
-  Result = type_member { { fixed: T::Array[T.untyped] } }
-end

data/rbi/prism.rbi

@@ -7,28 +7,28 @@ module Prism
   sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
   def self.dump_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[T::Array[T.untyped]]) }
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
   def self.lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[T::Array[T.untyped]]) }
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
   def self.lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::ParseResult[T::Array[T.untyped]]) }
+  sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
   def self.lex_compat(source, **options); end
 
   sig { params(source: String).returns(T::Array[T.untyped]) }
   def self.lex_ripper(source); end
 
-  sig { params(source: String, serialized: String).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
   def self.load(source, serialized); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
   def self.parse(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
   def self.parse_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
   def self.parse_stream(stream, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
   sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
@@ -37,10 +37,10 @@ module Prism
   sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
   def self.parse_file_comments(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[[Prism::ProgramNode, T::Array[T.untyped]]]) }
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
   def self.parse_lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[[Prism::ProgramNode, T::Array[T.untyped]]]) }
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
   def self.parse_lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
   sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }

data/sig/prism/dsl.rbs

@@ -118,7 +118,7 @@ module Prism
     def ConstantPathAndWriteNode: (ConstantPathNode target, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ConstantPathAndWriteNode
 
     # Create a new ConstantPathNode node
-    def ConstantPathNode: (Prism::node? parent, ConstantReadNode | MissingNode child, Location delimiter_loc, ?Source source, ?Location location) -> ConstantPathNode
+    def ConstantPathNode: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, ?Source source, ?Location location) -> ConstantPathNode
 
     # Create a new ConstantPathOperatorWriteNode node
     def ConstantPathOperatorWriteNode: (ConstantPathNode target, Location operator_loc, Prism::node value, Symbol operator, ?Source source, ?Location location) -> ConstantPathOperatorWriteNode
@@ -127,7 +127,7 @@ module Prism
     def ConstantPathOrWriteNode: (ConstantPathNode target, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ConstantPathOrWriteNode
 
     # Create a new ConstantPathTargetNode node
-    def ConstantPathTargetNode: (Prism::node? parent, ConstantReadNode | MissingNode child, Location delimiter_loc, ?Source source, ?Location location) -> ConstantPathTargetNode
+    def ConstantPathTargetNode: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, ?Source source, ?Location location) -> ConstantPathTargetNode
 
     # Create a new ConstantPathWriteNode node
     def ConstantPathWriteNode: (ConstantPathNode target, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ConstantPathWriteNode
@@ -400,7 +400,7 @@ module Prism
     def RetryNode: (?Source source, ?Location location) -> RetryNode
 
     # Create a new ReturnNode node
-    def ReturnNode: (Location keyword_loc, ArgumentsNode? arguments, ?Source source, ?Location location) -> ReturnNode
+    def ReturnNode: (Integer flags, Location keyword_loc, ArgumentsNode? arguments, ?Source source, ?Location location) -> ReturnNode
 
     # Create a new SelfNode node
     def SelfNode: (?Source source, ?Location location) -> SelfNode

data/sig/prism/inspect_visitor.rbs

@@ -0,0 +1,22 @@
+module Prism
+  class InspectVisitor < Visitor
+    class Replace
+      attr_reader value: String
+
+      def initialize: (String value) -> void
+    end
+
+    attr_reader indent: String
+    attr_reader commands: Array[[String | node | Replace, String]]
+
+    def initialize: (?String indent) -> void
+    def compose: () -> String
+
+    def self.compose: (node node) -> String
+
+    private
+
+    def inspect_node: (String name, node node) -> String
+    def inspect_location: (Location? location) -> String
+  end
+end