rbs 2.8.4 → 3.0.0.dev.1

data/sig/collection/config/lockfile_generator.rbs

@@ -0,0 +1,55 @@
+module RBS
+  module Collection
+    class Config
+      class LockfileGenerator
+        class GemfileLockMismatchError < StandardError
+          @expected: Pathname
+
+          @actual: Pathname
+
+          def initialize: (expected: Pathname, actual: Pathname) -> void
+
+          def message: () -> String
+        end
+
+        attr_reader config: Config
+        attr_reader gemfile_lock: Bundler::LockfileParser
+
+        attr_reader lockfile: Lockfile
+        attr_reader existing_lockfile: Lockfile?
+
+        type gem_queue_entry = { name: String, version: String? }
+
+        @gem_queue: Array[gem_queue_entry]
+
+        def self.generate: (config: Config, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Lockfile
+
+        def initialize: (config: Config, gemfile_lock_path: Pathname, with_lockfile: boolish) -> void
+
+        def generate: () -> void
+
+        private
+
+        # Ensure if current `gemfile_lock_path` is the same with the path saved in `lock`
+        #
+        def validate_gemfile_lock_path!: (lock: Lockfile?, gemfile_lock_path: Pathname) -> void
+
+        def assign_gem: (name: String, version: String?, ignored_gems: Set[String], src_data: Sources::source_entry?) -> void
+
+        def assign_stdlib: (name: String, from_gem: String?) -> void
+
+        def gemfile_lock_gems: () { (untyped) -> void } -> void
+
+        def remove_ignored_gems!: () -> void
+
+        # Find a source of a gem from ones registered in `config.sources`
+        #
+        # Returns `nil` if no source contains the definition of the gem.
+        #
+        def find_source: (name: String) -> Sources::t?
+
+        def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
+      end
+    end
+  end
+end

data/sig/collection/config.rbs

@@ -6,39 +6,6 @@ module RBS
         def initialize: () -> void
       end
 
-      class LockfileGenerator
-        attr_reader config: Config
-        attr_reader lock: Config?
-        attr_reader lock_path: Pathname
-        attr_reader gemfile_lock: Bundler::LockfileParser
-
-        type gem_queue_entry = { name: String, version: String? }
-
-        @gem_queue: Array[gem_queue_entry]
-
-        def self.generate: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
-
-        def initialize: (config_path: Pathname, gemfile_lock_path: Pathname, with_lockfile: boolish) -> void
-
-        def generate: () -> Config
-
-        private
-
-        def validate_gemfile_lock_path!: (lock: Config?, gemfile_lock_path: Pathname) -> void
-
-        def assign_gem: (name: String, version: String?) -> void
-
-        def upsert_gem: (gem_entry? old, gem_entry new) -> void
-
-        def gemfile_lock_gems: () { (untyped) -> void } -> void
-
-        def remove_ignored_gems!: () -> void
-
-        def find_source: (name: String) -> Sources::_Source?
-
-        def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
-      end
-
       PATH: Pathname
 
       type gem_entry = {
@@ -48,42 +15,32 @@ module RBS
         'source' => Sources::source_entry?
       }
 
-      @config_path: Pathname
+      attr_reader config_path: Pathname
 
-      @data: untyped
+      attr_reader data: untyped
 
       @sources: Array[Sources::_Source]
 
       def self.find_config_path: () -> Pathname?
 
-      def self.generate_lockfile: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
+      def self.generate_lockfile: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> [Config, Lockfile]
 
       def self.from_path: (Pathname path) -> Config
 
-      def self.lockfile_of: (Pathname config_path) -> Config?
-
       def self.to_lockfile_path: (Pathname config_path) -> Pathname
 
       # config_path is necessary to resolve relative repo_path
       def initialize: (untyped data, config_path: Pathname) -> void
 
-      def add_gem: (gem_entry gem) -> void
-
       def gem: (String gem_name) -> gem_entry?
 
       def repo_path: () -> Pathname
 
-      def sources: () -> Array[Sources::_Source]
+      def repo_path_data: () -> Pathname
 
-      def dump_to: (Pathname) -> void
+      def sources: () -> Array[Sources::t]
 
       def gems: () -> Array[gem_entry]
-
-      def gemfile_lock_path=: (Pathname) -> Pathname
-
-      def gemfile_lock_path: () -> Pathname?
-
-      def check_rbs_availability!: () -> void
     end
   end
 end

data/sig/collection/installer.rbs

@@ -1,7 +1,7 @@
 module RBS
   module Collection
     class Installer
-      attr_reader lockfile: Config
+      attr_reader lockfile: Config::Lockfile
       attr_reader stdout: CLI::_IO
 
       def initialize: (lockfile_path: Pathname, ?stdout: CLI::_IO) -> void

data/sig/collection/sources.rbs

@@ -1,27 +1,32 @@
 module RBS
   module Collection
     module Sources
-      def self.from_config_entry: (source_entry) -> _Source
+      def self.from_config_entry: (Git::source_entry) -> Git
+                                | (source_entry) -> t
 
       interface _Source
-        def has?: (Config::gem_entry) -> boolish
-        def versions: (Config::gem_entry) -> Array[String]
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def has?: (String name, String? version) -> boolish
+        def versions: (String name) -> Array[String]
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
         def to_lockfile: () -> source_entry
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
-        def dependencies_of: (Config::gem_entry) -> Array[{"name" => String}]?
+        def manifest_of: (String name, String version) -> manifest_entry?
+        def dependencies_of: (String name, String version) -> Array[manifest_dependency]?
       end
 
+      type t = Git | Stdlib | Rubygems
+
       type source_entry = Git::source_entry
                         | Stdlib::source_entry
                         | Rubygems::source_entry
 
       type manifest_entry = {
-        "dependencies" => Array[{"name" => String}]?,
+        "dependencies" => Array[manifest_dependency]?,
       }
 
+      type manifest_dependency = { "name" => String }
+
       module Base : _Source
-        def dependencies_of: (Config::gem_entry config_entry) -> Array[{"name" => String}]?
+        def dependencies_of: (String name, String version) -> Array[manifest_dependency]?
       end
 
       class Git
@@ -43,32 +48,45 @@ module RBS
         attr_reader name: String
         attr_reader remote: String
         attr_reader repo_dir: String
+        attr_reader revision: String
 
         def initialize: (name: String, revision: String, remote: String, repo_dir: String?) -> untyped
 
-        def has?: (Config::gem_entry) -> bool
+        def has?: (String name, String? version) -> boolish
 
-        def versions: (Config::gem_entry) -> Array[String]
+        def versions: (String name) -> Array[String]
 
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
 
         def to_lockfile: () -> source_entry
 
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
+        def manifest_of: (String name, String version) -> manifest_entry?
+
+        def resolved_revision: () -> String
 
         private
 
+        @need_setup: bool
+
         @git_dir: Pathname?
 
         @resolved_revision: String?
 
-        def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
+        @gems_versions: Hash[String, Set[String]]?
+
+        def _install: (dest: Pathname , name: String, version: String) -> void
 
         def cp_r: (Pathname, Pathname) -> void
 
-        def setup!: (revision: String) -> void
+        # Ensure the git repository status is expected one
+        #
+        # * It exists, and
+        # * The `HEAD` is the `revision`
+        #
+        def setup!: [T] () { () -> T } -> T
+                  | () -> void
 
-        def need_to_fetch?: (String revision ) -> bool
+        def need_to_fetch?: (String revision) -> bool
 
         def git_dir: () -> Pathname
 
@@ -76,15 +94,30 @@ module RBS
 
         def with_revision: [T] () { () -> T } -> T
 
-        def resolved_revision: () -> String
-
-        def resolve_revision: () -> String
+        # Returns `true` if `revision` looks like a commit hash
+        #
+        def commit_hash?: () -> bool
 
         def git: (*String cmd, **untyped opt) -> String
 
+        def git?: (*String cmd, **untyped opt) -> String?
+
         def sh!: (*String cmd, **untyped opt) -> String
 
-        def format_config_entry: (Config::gem_entry) -> String
+        def format_config_entry: (String name, String version) -> String
+
+        type metadata = { 'name' => String, 'version' => String, 'source' => source_entry }
+
+        def metadata_content: (name: String, version: String) -> metadata
+
+        # Write `.rbs_meta.yaml`
+        def write_metadata: (dir: Pathname, name: String, version: String) -> void
+
+        # Load `.rbs_meta.yaml` from the `dir`, where is the destination of the RBS file installation, and return the cleaned up content
+        #
+        def load_metadata: (dir: Pathname) -> metadata
+
+        def gems_versions: () -> Hash[String, Set[String]]
       end
 
       # signatures that are bundled in rbs gem under the stdlib/ directory
@@ -101,19 +134,19 @@ module RBS
         # polyfill of singleton module
         def self.instance: () -> instance
 
-        def has?: (Config::gem_entry) -> boolish
+        def has?: (String name, String? version) -> boolish
 
-        def versions: (Config::gem_entry) -> Array[String]
+        def versions: (String name) -> Array[String]
 
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
 
         def to_lockfile: () -> source_entry
 
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
+        def manifest_of: (String name, String version) -> manifest_entry?
 
         private
 
-        def lookup: (Config::gem_entry) -> Pathname?
+        def lookup: (String name, String? version) -> Pathname?
       end
 
       # sig/ directory
@@ -127,15 +160,19 @@ module RBS
         # polyfill of singleton module
         def self.instance: () -> instance
 
-        def has?: (Config::gem_entry) -> boolish
-        def versions: (Config::gem_entry) -> Array[String]
-        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def has?: (String name, String? version) -> boolish
+
+        def versions: (String name) -> Array[String]
+
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
+
         def to_lockfile: () -> source_entry
-        def manifest_of: (Config::gem_entry) -> manifest_entry?
+
+        def manifest_of: (String name, String version) -> manifest_entry?
 
         private
 
-        def gem_sig_path: (Config::gem_entry) -> [Gem::Specification, Pathname]?
+        def gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
       end
     end
   end

data/sig/definition_builder.rbs

@@ -1,14 +1,7 @@
 module RBS
   # DefinitionBuilder translates TypeName to Definition of the type
   #
-  # The translation goes three steps:
-  #
-  # 1. Calculate _ancestors_ of the type with AncestorBuilder
-  # 2. Calculate _partial_ definitions of each ancestor
-  # 3. Merge _partial_ definitions
-  #
-  # A _partial_ definition is a definition of one type name, in terms of it doesn't have methods of super classes nor included modules.
-  #
+  # It also provides semantic utilities that depends on Environment.
   #
   class DefinitionBuilder
     attr_reader env: Environment
@@ -16,96 +9,32 @@ module RBS
     attr_reader ancestor_builder: AncestorBuilder
     attr_reader method_builder: MethodBuilder
 
-    attr_reader instance_cache: Hash[[TypeName, bool], Definition | false | nil]
+    attr_reader instance_cache: Hash[TypeName, Definition | false | nil]
     attr_reader singleton_cache: Hash[TypeName, Definition | false | nil]
     attr_reader singleton0_cache: Hash[TypeName, Definition | false | nil]
     attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
 
     def initialize: (env: Environment, ?ancestor_builder: AncestorBuilder?, ?method_builder: MethodBuilder?) -> void
 
+    # Returns a Definition of a interface
+    #
     def build_interface: (TypeName) -> Definition
 
-    # Returns a Definition of a instance of given type name.
+    # Returns a Definition of an instance type
     #
     # If TypeName is a module and `no_self_types` is `true`, it won't have methods of _self type constraints_.
     # This typically happens when definition is being calculated for mixin.
     #
-    def build_instance: (TypeName, ?no_self_types: bool) -> Definition
+    def build_instance: (TypeName) -> Definition
 
+    # Returns a Definition of a singleton type
     def build_singleton: (TypeName) -> Definition
 
-    def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
-
-    def ensure_namespace!: (Namespace, location: Location[untyped, untyped]?) -> void
-
-    def build_singleton0: (TypeName) -> Definition
-
-    def merge_definition: (src: Definition, dest: Definition, subst: Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
-
-    def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void
-
-    def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable, Substitution, ?keep_super: bool) -> void
-
-    def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
-                 | [A] (TypeName, cache: Hash[A, Definition | false | nil], key: A) { () -> Definition } -> Definition
-
-    def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
-
-    def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
-
-    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
-
-    def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
-
-    # Add methods from `methods` to Definition
-    #
-    # * `methods`:
-    # * `interface_methods`: Methods of interfaces mixed into the type
-    # * `self_constraints_methods`: Methods of the self constraints methods
-    # * `super_interface_method`: `true` to have super method of existing method (`true` is the Definition is the target module)
-    #
-    def define_methods: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method],
-      methods_with_self: Hash[Symbol, Definition::Method]?,
-      super_interface_method: bool
-    ) -> void
-
-    # Define methods on singleton type
-    #
-    def define_methods_singleton: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method]
-    ) -> void
-
-    # Define methods on instance type
-    #
-    def define_methods_instance: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method]
-    ) -> void
-
-    # Define methods on module instance type
+    # Validates the given Namespace and its ancestor namespaces exists
     #
-    # * Pass `nil` to `module_self_methods:` to build a module instance type that will be mixed in to other modules/classes
-    # * Pass methods from self-type-constraints to build a module instance type alone (to type check itself)
+    # Raises NoTypeFoundError
     #
-    def define_methods_module_instance: (
-      Definition,
-      methods: MethodBuilder::Methods,
-      interface_methods: Hash[Symbol, Definition::Method],
-      module_self_methods: Hash[Symbol, Definition::Method]?
-    ) -> void
-
-    # Validates presence of type names recursively.
-    # Assumes the type names are already resolved.
-    #
-    def validate_type_presence: (Types::t) -> void
-
-    def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void
+    def ensure_namespace!: (Namespace, location: Location[untyped, untyped]?) -> void
 
     # Expand a type alias of given name without type arguments.
     # Raises an error if the type alias requires arguments.
@@ -138,6 +67,90 @@ module RBS
     #
     def expand_alias2: (TypeName, Array[Types::t] args) -> Types::t
 
+    # Validates presence of type names recursively
+    #
+    # Assumes the type names are already resolved.
+    # Raises NoTypeFoundError in case of failure.
+    #
+    def validate_type_presence: (Types::t) -> void
+
+    # Validates presence of an absolute type name
+    #
+    # Raises NoTypeFoundError in case of error.
+    #
+    def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void
+
+    # Returns a new DefinitionBuilder with updated Environment, AncestorBuilder, and exceptions
+    #
     def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
+
+    private
+
+    def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
+
+    def build_singleton0: (TypeName) -> Definition
+
+    # Returns `interface_methods` from given array of interface ancestors
+    #
+    def interface_methods: (Array[Definition::Ancestor::Instance] interface_ancestors) -> interface_methods
+
+    def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
+
+    def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
+
+    def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
+
+    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
+
+    def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
+
+    # Add method definition to `methods`, which will be merged to `class_definition` after defining all methods at this *level* -- class, module, or interface
+    #
+    # `class_definition` is a definition of given type, but it has definitions of prior levels.
+    #
+    def define_method: (
+      Hash[Symbol, Definition::Method] methods,
+      Definition class_definition,
+      MethodBuilder::Methods::Definition method_definition,
+      Substitution subst,
+      defined_in: TypeName,
+      ?implemented_in: TypeName?
+    ) -> void
+
+    # The `interface_methods` type describes the association between the interface name to its name and the *mixin* to a module
+    #
+    type interface_methods = Hash[
+      Definition::Ancestor::Instance,
+      [MethodBuilder::Methods, AST::Members::Include | AST::Members::Extend]
+    ]
+
+    # Add method definitions from `module_methods` to `definition`
+    #
+    # It also processes interface mixins, with duplication detection.
+    # It doesn't process module mixins.
+    #
+    def import_methods: (
+      Definition definition,
+      TypeName module_name,
+      MethodBuilder::Methods module_methods,
+      interface_methods interface_methods,
+      Substitution subst
+    ) -> void
+
+    # Updates `definition` with methods and variables of `type_name` that can be a module or a class
+    #
+    # It processes includes and prepends recursively.
+    #
+    def define_instance: (Definition definition, TypeName type_name, Substitution subst) -> void
+
+    def define_interface: (Definition definition, TypeName type_name, Substitution subst) -> void
+
+    # Returns a substitution that corresponds to type application
+    #
+    # ```
+    # tapp_subst(`::Array`, [`::Integer`]) # => Subsitution.build([:Elem], [`::Integer`])
+    # ```
+    #
+    def tapp_subst: (TypeName, Array[Types::t]) -> Substitution
   end
 end

data/sig/environment_loader.rbs

@@ -81,7 +81,7 @@ module RBS
     def resolve_dependencies: (library: String, version: String?) -> void
 
     # Add repository path and libraries via rbs_collection.lock.yaml.
-    def add_collection: (Collection::Config collection_config) -> void
+    def add_collection: (Collection::Config::Lockfile lockfile) -> void
 
     # This is helper function to test if RBS for a library is available or not.
     #

data/sig/errors.rbs

@@ -123,6 +123,23 @@ module RBS
     def other_locations: () -> Array[Location[untyped, untyped]?]
   end
 
+  # An interface mixin causes a duplication of a method definition
+  #
+  # ```rbs
+  # interface _Foo1
+  #   def foo: () -> void
+  # end
+  #
+  # interface _Foo2
+  #   def foo: () -> void
+  # end
+  #
+  # class Foo
+  #   include _Foo1
+  #   include _Foo2    # <= The error will be reported here (or the line of _Foo1)
+  # end
+  # ```
+  #
   class DuplicatedInterfaceMethodDefinitionError < DefinitionError
     type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
     type mixin_member = AST::Members::Include | AST::Members::Extend
@@ -138,6 +155,8 @@ module RBS
     def qualified_method_name: () -> String
   end
 
+  # The `alias` member declares an alias from unknown method
+  #
   class UnknownMethodAliasError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader original_name: Symbol
@@ -154,6 +173,8 @@ module RBS
     def initialize: (name: TypeName, entry: Environment::ClassEntry) -> void
   end
 
+  # The *overloading* method definition cannot find *non-overloading* method definition
+  # 
   class InvalidOverloadMethodError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol

data/sig/members.rbs

@@ -15,6 +15,26 @@ module RBS
       type visibility = :public | :private
 
       class MethodDefinition < Base
+        class Overload
+          attr_reader method_type: MethodType
+
+          attr_reader annotations: Array[Annotation]
+
+          def initialize: (method_type: MethodType, annotations: Array[Annotation]) -> void
+
+          def ==: (untyped) -> bool
+
+          def hash: () -> Integer
+
+          alias eql? ==
+
+          def update: (?annotations: Array[Annotation], ?method_type: MethodType) -> Overload
+
+          def sub: (Substitution) -> Overload
+
+          include _ToJson
+        end
+
         type kind = :instance | :singleton | :singleton_instance
 
         # def foo: () -> void
@@ -26,31 +46,35 @@ module RBS
         #         ^^^                              keyword
         #             ^^^^^                        kind
         #                  ^^^                     name
-        #                                    ^^^   overload
+        #                                    ^^^   overloading
         #
-        type loc = Location[:keyword | :name, :kind | :overload | :visibility]
+        type loc = Location[:keyword | :name, :kind | :overloading | :visibility]
 
         attr_reader name: Symbol
         attr_reader kind: kind
-        attr_reader types: Array[MethodType]
+        attr_reader overloads: Array[Overload]
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
-        attr_reader overload: bool
+        attr_reader overloading: bool
         attr_reader visibility: visibility?
 
-        def initialize: (name: Symbol, kind: kind, types: Array[MethodType], annotations: Array[Annotation], location: loc?, comment: Comment?, overload: boolish, ?visibility: visibility?) -> void
+        def initialize: (name: Symbol, kind: kind, overloads: Array[Overload], annotations: Array[Annotation], location: loc?, comment: Comment?, overloading: bool, visibility: visibility?) -> void
 
         include _HashEqual
         include _ToJson
 
+        # Returns true if the `def` is to define instance method
         def instance?: () -> bool
 
+        # Returns true if the `def` is to define singleton method
         def singleton?: () -> bool
 
-        def overload?: () -> bool
+        # Returns true if the `def` is overloading (== with `...`)
+        #
+        def overloading?: () -> bool
 
-        def update: (?name: Symbol, ?kind: kind, ?types: Array[MethodType], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overload: boolish, ?visibility: visibility?) -> MethodDefinition
+        def update: (?name: Symbol, ?kind: kind, ?overloads: Array[Overload], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overloading: bool, ?visibility: visibility?) -> MethodDefinition
       end
 
       module Var

data/sig/prototype/node_usage.rbs

@@ -0,0 +1,20 @@
+module RBS
+  module Prototype
+    class NodeUsage
+      include Helpers
+      
+      type node = RubyVM::AbstractSyntaxTree::Node
+
+      attr_reader node: node
+
+      attr_reader conditional_nodes: Set[node]
+
+      def initialize: (node) -> void
+
+      def calculate: (node, conditional: bool) -> void
+
+      def each_conditional_node: () { (node) -> void } -> void
+                               | () -> Enumerator[node, void]
+    end
+  end
+end