rbs 4.1.0.pre.2-java

data/sig/variance_calculator.rbs

@@ -0,0 +1,87 @@
+module RBS
+  # Calculate the use variances of type variables in declaration.
+  #
+  # ```rb
+  # calculator = VarianceCalculator.new(builder: builder)
+  #
+  # # Calculates variances in a method type
+  # result = calculator.in_method_type(method_type: method_type, variables: variables)
+  #
+  # # Calculates variances in a inheritance/mixin/...
+  # result = calculator.in_inherit(name: name, args: args, variables: variables)
+  #
+  # # Calculates variances in a type alias
+  # result = calculator.in_type_alias(name: name, args: args, variables: variables)
+  # ```
+  #
+  # See `RBS::VarianceCalculator::Result` for information recorded in the `Result` object.
+  #
+  class VarianceCalculator
+    type variance = :unused | :covariant | :contravariant | :invariant
+
+    # Result contains the set of type variables and it's variance in a occurrence.
+    #
+    # ```rb
+    # # Enumerates recorded type variables
+    # result.each do |name, variance|
+    #   # name is the name of a type variable
+    #   # variance is one of :unused | :covariant | :contravariant | :invariant
+    # end
+    # ```
+    #
+    # You can test with `compatible?` method if the type variable occurrences are compatible with specified (annotated) variance.
+    #
+    # ```rb
+    # # When T is declared as `out T`
+    # result.compatible?(:T, with_annotation: :covariant)
+    #
+    # # When T is declared as `in T`
+    # result.compatible?(:T, with_annotation: :contravariant)
+    #
+    # # When T is declared as `T`
+    # result.compatible?(:T, with_annotation: :invariant)
+    # ```
+    #
+    class Result
+      attr_reader result: Hash[Symbol, variance]
+
+      def initialize: (variables: Array[Symbol]) -> void
+
+      def covariant: (Symbol) -> void
+
+      def contravariant: (Symbol) -> void
+
+      def invariant: (Symbol) -> void
+
+      def each: () { ([Symbol, variance]) -> void } -> void
+
+      def include?: (Symbol) -> bool
+
+      def compatible?: (Symbol, with_annotation: variance) -> bool
+
+      def incompatible?: (Array[AST::TypeParam]) -> Set[Symbol]?
+    end
+
+    attr_reader builder: DefinitionBuilder
+
+    def initialize: (builder: DefinitionBuilder) -> void
+
+    def env: () -> Environment
+
+    def in_method_type: (method_type: MethodType, variables: Array[Symbol]) -> Result
+
+    def in_inherit: (name: TypeName, args: Array[Types::t], variables: Array[Symbol]) -> Result
+
+    # The type name must be normalized
+    #
+    def in_type_alias: (name: TypeName) -> Result
+
+    private
+
+    def type: (Types::t, result: Result, context: variance) -> void
+
+    def function: (Types::function, result: Result, context: variance) -> void
+
+    def negate: (variance) -> variance
+  end
+end

data/sig/vendorer.rbs

@@ -0,0 +1,51 @@
+module RBS
+  # Copies RBS files loaded through `loader` under `vendor_dir`.
+  #
+  # Core libraries and library RBS files will be copied.
+  #
+  # ```rb
+  # loader = RBS::EnvironmentLoader.new()
+  #
+  # loader.add(library: set)               # Libraries will be copied.
+  # loader.add(library: "minitest", version: "1.2.3")
+  #
+  # loader.add(path: Pathname("sig"))      # Dirs will be ignored.
+  #
+  # vendorer = RBS::Vendorer.new(vendor_dir: Pathname("vendor/rbs"), loader: loader)
+  # vendorer.clean!
+  # vendorer.copy!
+  # ```
+  #
+  # The result will be:
+  #
+  # ```
+  # vendor/rbs/core            => Will include core RBSs
+  # vendor/rbs/set-0           => Will include `set` library RBSs.
+  # vendor/rbs/minitest-1.2.3  => Will include `minitest` library RBSs.
+  # ```
+  #
+  # The vendored RBSs will be loaded through :dir source.
+  #
+  # ```rb
+  # loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: true))
+  # loader.add(path: Pathname("vendor/rbs"))
+  # loader.add(path: Pathname("sig"))
+  # ```
+  #
+  class Vendorer
+    attr_reader vendor_dir: Pathname
+    attr_reader loader: EnvironmentLoader
+
+    def initialize: (vendor_dir: Pathname, loader: EnvironmentLoader) -> void
+
+    # Copy RBS files into `vendor_dir`.
+    # Ensures the `vendor_dir` exists.
+    def copy!: () -> void
+
+    # Deletes `vendor_dir` and its content if exists.
+    #
+    def clean!: () -> void
+
+    def ensure_dir: [A] () { () -> A } -> A
+  end
+end

data/sig/version.rbs

@@ -0,0 +1,3 @@
+module RBS
+  VERSION: String
+end

data/sig/visitor.rbs

@@ -0,0 +1,47 @@
+module RBS
+  module AST
+    class Visitor
+      def visit_all: (Enumerable[(Members::Base | Declarations::Base)] nodes) -> void
+
+      def visit: ((Members::Base | Declarations::Base) node) -> void
+
+      def visit_declaration_global: (Declarations::Global node) -> void
+
+      def visit_declaration_class: (Declarations::Class node) -> void
+
+      def visit_declaration_module: (Declarations::Module node) -> void
+
+      def visit_declaration_constant: (Declarations::Constant node) -> void
+
+      def visit_declaration_type_alias: (Declarations::TypeAlias node) -> void
+
+      def visit_declaration_interface: (Declarations::Interface node) -> void
+
+      def visit_member_alias: (Members::Alias node) -> void
+
+      def visit_member_class_instance_variable: (Members::ClassInstanceVariable node) -> void
+
+      def visit_member_class_variable: (Members::ClassVariable node) -> void
+
+      def visit_member_instance_variable: (Members::InstanceVariable node) -> void
+
+      def visit_member_private: (Members::Private node) -> void
+
+      def visit_member_public: (Members::Public node) -> void
+
+      def visit_member_method_definition: (Members::MethodDefinition node) -> void
+
+      def visit_member_attr_reader: (Members::AttrReader node) -> void
+
+      def visit_member_attr_writer: (Members::AttrWriter node) -> void
+
+      def visit_member_attr_accessor: (Members::AttrAccessor node) -> void
+
+      def visit_member_include: (Members::Include node) -> void
+
+      def visit_member_prepend: (Members::Prepend node) -> void
+
+      def visit_member_extend: (Members::Extend node) -> void
+    end
+  end
+end

data/sig/wasm/deserializer.rbs

@@ -0,0 +1,66 @@
+module RBS
+  module WASM
+    # Rebuilds RBS::AST objects from the binary buffer produced by
+    # `rbs_serialize_node` (src/serialize.c), driven by SerializationSchema.
+    class Deserializer
+      @bytes: String
+
+      @buffer: Buffer
+
+      @encoding: Encoding
+
+      @pos: Integer
+
+      @class_cache: Hash[String, untyped]
+
+      # Deserialize a buffer produced for a whole signature, returning
+      # `[directives, declarations]` to match RBS::Parser._parse_signature.
+      def self.deserialize: (String bytes, Buffer buffer) -> untyped
+
+      # Deserialize a bare node list (RBS::Parser._parse_type_params).
+      def self.deserialize_node_list: (String bytes, Buffer buffer) -> Array[untyped]
+
+      # Deserialize the token stream from rbs_wasm_lex (RBS::Parser._lex).
+      def self.deserialize_tokens: (String bytes, Buffer buffer) -> Array[[ Symbol, Location ]]
+
+      def initialize: (String bytes, Buffer buffer) -> void
+
+      # Reads the next node and returns the reconstructed Ruby value.
+      def read_node: () -> untyped
+
+      def read_node_list: () -> Array[untyped]
+
+      def read_tokens: () -> Array[[ Symbol, Location ]]
+
+      private
+
+      def read_struct: (Array[untyped] entry) -> untyped
+
+      def read_field: (untyped reader) -> untyped
+
+      def read_hash: () -> Hash[untyped, untyped]
+
+      def read_count: () -> Integer
+
+      def read_location: (Array[untyped]? loc_children) -> Location?
+
+      def read_location_value: () -> Location?
+
+      def read_location_value_list: () -> Array[Location?]
+
+      def read_attr_ivar_name: () -> (Symbol | false | nil)
+
+      def read_range: () -> [ Integer, Integer ]?
+
+      def read_u8: () -> Integer
+
+      def read_u32: () -> Integer
+
+      def read_i32: () -> Integer
+
+      def read_string: (Encoding encoding) -> String
+
+      def class_for: (String name) -> untyped
+    end
+  end
+end

data/sig/wasm/serialization_schema.rbs

@@ -0,0 +1,13 @@
+module RBS
+  module WASM
+    # Generated from config.yml. See `templates/lib/rbs/wasm/serialization_schema.rb.erb`.
+    module SerializationSchema
+      # The node tag used for interned symbols (`rbs_ast_symbol`).
+      SYMBOL_TAG: Integer
+
+      # Indexed by node tag. Each entry describes how to decode one node; see the
+      # generated file for the exact shape.
+      SCHEMA: Array[Array[untyped]?]
+    end
+  end
+end

data/sig/writer.rbs

@@ -0,0 +1,127 @@
+module RBS
+  # Writer prints RBS AST to String.
+  #
+  class Writer
+    interface _IO
+      def puts: (*untyped) -> void
+
+      def flush: () -> void
+    end
+
+    # Channel to output the result.
+    #
+    attr_reader out: _IO
+
+    # Array of indentations.
+    #
+    attr_reader indentation: Array[String]
+
+    def initialize: (out: _IO) -> void
+
+    # Output the array of declarations.
+    # It automatically inserts empty lines between the declarations.
+    #
+    def write: (Array[AST::Declarations::t | AST::Directives::t]) -> void
+
+    def preserve?: () -> bool
+
+    def preserve!: (?preserve: bool) -> self
+
+    private
+
+    @preserve: bool
+
+    # Increases the indentation and yields the block.
+    #
+    def indent: (?Integer size) { () -> void } -> void
+
+    # Returns the current indentation of lines.
+    #
+    def prefix: () -> String
+
+    # Prints a string.
+    # Automatically appends the `#prefix` and newline at the end.
+    #
+    def puts: (?String) -> void
+
+    # Prints a (possibly) multi-line string.
+    #
+    # Drops `leading_spaces` of spaces at the beginning of each line.
+    #
+    # ```ruby
+    # put_lines(<<TEXT, leading_spaces: 0)
+    # Hello
+    #   world!
+    # TEXT
+    #
+    # # Outputs
+    # # Hello
+    # #   world!
+    #
+    # put_lines(<<TEXT, leading_spaces: 2)
+    # Hello
+    #   world!
+    # TEXT
+    #
+    # # Outputs
+    # # Hello
+    # # world!
+    # ```
+    #
+    # This is for `Location#source`.
+    # The `#source` returns the text spans from the beginning to end of the element.
+    # It will look like the following.
+    #
+    # ```rbs
+    # module Foo
+    #   type t = Integer     # the definition of `t` starts from line=2, column=2
+    #          | String
+    #          | :false      # the definition of `t` ends from line=4, column=17
+    # end
+    # ```
+    #
+    # The expected output will be something like:
+    #
+    # ```rbs
+    # type t = Integer       # Extracted from `Foo` definition and keeps the line breaks
+    #        | String
+    #        | :false
+    # ```
+    #
+    # And it can be done with a `#put_lines(source, leading_spaces: 2)` call.
+    #
+    def put_lines: (String, leading_spaces: Integer) -> void
+
+    def write_loc_source: (_Located) { () -> void } -> void
+
+    def format_annotation: (AST::Annotation) -> String
+
+    def write_use_directive: (AST::Directives::Use) -> void
+
+    def write_annotation: (Array[AST::Annotation]) -> void
+
+    def write_comment: (AST::Comment?) -> void
+
+    def write_decl: (AST::Declarations::t) -> void
+
+    def write_member: (AST::Declarations::Module::member) -> void
+
+    def name_and_params: (TypeName, Array[AST::TypeParam]) -> String?
+
+    def name_and_args: (TypeName, Array[Types::t]) -> String?
+
+    def write_alias: (AST::Declarations::TypeAlias) -> void
+
+    def method_name: (Symbol) -> String
+
+    def write_def: (AST::Members::MethodDefinition) -> void
+
+    def attribute: (:reader | :writer | :accessor, AST::Members::Attribute) -> void
+
+    interface _Located
+      def location: () -> Location[untyped, untyped]?
+    end
+
+    def preserve_empty_line: (_Located?, _Located) -> void
+  end
+end