rbs 3.0.0.dev.1 → 3.0.0.dev.3

data/sig/collection/config/lockfile_generator.rbs

@@ -13,18 +13,18 @@ module RBS
         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? }
+        attr_reader definition: Bundler::Definition
 
-        @gem_queue: Array[gem_queue_entry]
+        # A hash table to look up a spec from name of the gem
+        attr_reader gem_hash: Hash[String, Bundler::LazySpecification]
 
-        def self.generate: (config: Config, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Lockfile
+        def self.generate: (config: Config, definition: Bundler::Definition, ?with_lockfile: boolish) -> Lockfile
 
-        def initialize: (config: Config, gemfile_lock_path: Pathname, with_lockfile: boolish) -> void
+        def initialize: (config: Config, definition: Bundler::Definition, with_lockfile: boolish) -> void
 
         def generate: () -> void
 
@@ -34,14 +34,12 @@ module RBS
         #
         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
+        # Inserts a entry to lockfile of a gem and its dependencies, if not included in `ignored_gems:`
+        #
+        def assign_gem: (name: String, version: String?, src_data: Sources::source_entry?, ignored_gems: Set[String]) -> 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.

data/sig/collection/config.rbs

@@ -23,7 +23,7 @@ module RBS
 
       def self.find_config_path: () -> Pathname?
 
-      def self.generate_lockfile: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> [Config, Lockfile]
+      def self.generate_lockfile: (config_path: Pathname, definition: Bundler::Definition, ?with_lockfile: boolish) -> [Config, Lockfile]
 
       def self.from_path: (Pathname path) -> Config
 

data/sig/collection/sources.rbs

@@ -1,8 +1,8 @@
 module RBS
   module Collection
     module Sources
-      def self.from_config_entry: (Git::source_entry) -> Git
-                                | (source_entry) -> t
+      def self.from_config_entry: (Git::source_entry, base_directory: Pathname) -> Git
+                                | (source_entry, base_directory: Pathname) -> t
 
       interface _Source
         def has?: (String name, String? version) -> boolish
@@ -13,11 +13,12 @@ module RBS
         def dependencies_of: (String name, String version) -> Array[manifest_dependency]?
       end
 
-      type t = Git | Stdlib | Rubygems
+      type t = Git | Stdlib | Rubygems | Local
 
       type source_entry = Git::source_entry
                         | Stdlib::source_entry
                         | Rubygems::source_entry
+                        | Local::source_entry
 
       type manifest_entry = {
         "dependencies" => Array[manifest_dependency]?,
@@ -78,28 +79,34 @@ module RBS
 
         def cp_r: (Pathname, Pathname) -> void
 
-        # Ensure the git repository status is expected one
+        # Ensure the git repository exists, and
         #
-        # * It exists, and
-        # * The `HEAD` is the `revision`
+        # * When `revision` is a commit hash, the commit exists in the local repository, or
+        # * When `revision` is a branch name, the latest version is fetched from `origin`
+        #
+        # It may require a network connection to fetch or clone the repository from remote.
+        #
+        # * If `revision` is a commit hash and the commit doesn't exists in the local repository, it runs `git fetch`
+        # * If `revision` is a branch name, it runs `git fetch` once per instance
         #
         def setup!: [T] () { () -> T } -> T
                   | () -> void
 
         def need_to_fetch?: (String revision) -> bool
 
+        # The full path of local git repository
         def git_dir: () -> Pathname
 
+        # The full path of `repo_dir` in the local git repository
         def gem_repo_dir: () -> Pathname
 
-        def with_revision: [T] () { () -> T } -> T
-
         # Returns `true` if `revision` looks like a commit hash
-        #
         def commit_hash?: () -> bool
 
+        # Executes a git command, raises an error if failed
         def git: (*String cmd, **untyped opt) -> String
 
+        # Executes a git command, returns `nil` if failed
         def git?: (*String cmd, **untyped opt) -> String?
 
         def sh!: (*String cmd, **untyped opt) -> String
@@ -120,6 +127,34 @@ module RBS
         def gems_versions: () -> Hash[String, Set[String]]
       end
 
+      class Local
+        include Base
+
+        type source_entry = {
+          'type' => 'local',
+          'path' => String,
+        }
+
+        attr_reader path: Pathname
+        attr_reader full_path: Pathname
+
+        def initialize: (path: String, base_directory: Pathname) -> 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: (String name, String version) -> manifest_entry?
+
+        private
+
+        def _install: (Pathname src, Pathname dest) -> void
+      end
+
       # signatures that are bundled in rbs gem under the stdlib/ directory
       class Stdlib
 

data/sig/constant.rbs

@@ -2,7 +2,7 @@ module RBS
   class Constant
     type constant_entry = Environment::ClassEntry
                         | Environment::ModuleEntry
-                        | Environment::SingleEntry[TypeName, AST::Declarations::Constant]
+                        | Environment::ConstantEntry
 
     attr_reader name: TypeName
 

data/sig/declarations.rbs

@@ -1,7 +1,7 @@
 module RBS
   module AST
     module Declarations
-      type t = Class | Module | Interface | Constant | Global | Alias
+      type t = Class | Module | Interface | Constant | Global | TypeAlias | ClassAlias | ModuleAlias
 
       class Base
       end
@@ -135,7 +135,7 @@ module RBS
         include _ToJson
       end
 
-      class Interface
+      class Interface < Base
         type member = Members::t
 
         # interface _Foo end
@@ -166,7 +166,7 @@ module RBS
         include _ToJson
       end
 
-      class Alias < Base
+      class TypeAlias < Base
         # type loc[T] = Location[T, bot]
         # ^^^^                            keyword
         #      ^^^                        name
@@ -223,6 +223,39 @@ module RBS
         include _HashEqual
         include _ToJson
       end
+
+      class AliasDecl < Base
+        # module Foo = Bar
+        # ^^^^^^             keyword
+        #        ^^^         new_name
+        #            ^       eq
+        #              ^^^   old_name
+        #
+        # class Foo = Bar
+        # ^^^^^              keyword
+        #
+        type loc = Location[:keyword | :new_name | :eq | :old_name, bot]
+
+        attr_reader new_name: TypeName
+
+        attr_reader old_name: TypeName
+
+        attr_reader location: loc?
+
+        attr_reader comment: Comment?
+
+        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
+
+        include _HashEqual
+      end
+
+      class ClassAlias < AliasDecl
+        include _ToJson
+      end
+
+      class ModuleAlias < AliasDecl
+        include _ToJson
+      end
     end
   end
 end

data/sig/definition.rbs

@@ -119,7 +119,7 @@ module RBS
     end
 
     type self_type = Types::ClassSingleton | Types::ClassInstance | Types::Interface
-    type definition_entry = Environment::ModuleEntry | Environment::ClassEntry | Environment::SingleEntry[TypeName, AST::Declarations::Interface]
+    type definition_entry = Environment::ModuleEntry | Environment::ClassEntry | Environment::InterfaceEntry
 
     attr_reader type_name: TypeName
     attr_reader entry: definition_entry

data/sig/definition_builder.rbs

@@ -5,7 +5,6 @@ module RBS
   #
   class DefinitionBuilder
     attr_reader env: Environment
-    attr_reader type_name_resolver: TypeNameResolver
     attr_reader ancestor_builder: AncestorBuilder
     attr_reader method_builder: MethodBuilder
 

data/sig/directives.rbs

@@ -0,0 +1,61 @@
+module RBS
+  module AST
+    module Directives
+      type t = Use
+
+      class Base
+      end
+
+      # ```
+      # use Foo, Foo::Bar as FBar, Foo:Baz::*
+      # ```
+      #
+      class Use < Base
+        type clause = SingleClause | WildcardClause
+
+        class SingleClause
+          # Foo::Bar
+          # ^^^^^^^^       type_name
+          #
+          # Foo::Bar as X
+          #          ^^    keyword
+          #             ^  new_name
+          #
+          type loc = Location[:type_name, :keyword | :new_name]
+
+          attr_reader type_name: TypeName
+
+          attr_reader new_name: Symbol?
+
+          attr_reader location: loc?
+
+          def initialize: (type_name: TypeName, new_name: Symbol?, location: loc?) -> void
+        end
+
+        class WildcardClause
+          # Foo::Bar::*
+          # ^^^^^^^^^^    namespace
+          #           ^   star
+          #
+          type loc = Location[:namespace | :star, bot]
+
+          attr_reader namespace: Namespace
+
+          attr_reader location: loc?
+
+          def initialize: (namespace: Namespace, location: loc?) -> void
+        end
+
+        # use Foo
+        # ^^^       keyword
+        type loc = Location[:keyword, bot]
+
+        attr_reader clauses: Array[clause]
+
+        attr_reader location: loc?
+
+        def initialize: (clauses: Array[clause], location: loc?) -> void
+      end
+    end
+  end
+end

data/sig/environment.rbs

@@ -13,9 +13,11 @@ module RBS
     end
 
     module ContextUtil
-      def calculate_context: (Array[_NamedDecl]) -> Array[Namespace]
+      def calculate_context: (Array[_NamedDecl]) -> Resolver::context
     end
 
+    # Name of object, it's (multiple) declarations with the outer module declarations
+    #
     class MultiEntry[M < _ModuleOrClass]
       class D[M < _ModuleOrClass]
         attr_reader decl: M
@@ -25,9 +27,9 @@ module RBS
 
         include ContextUtil
 
-        @context: Array[Namespace]
+        @context: Resolver::context
 
-        def context: () -> Array[Namespace]
+        def context: () -> Resolver::context
       end
 
       attr_reader name: TypeName
@@ -55,6 +57,8 @@ module RBS
     class ClassEntry < MultiEntry[AST::Declarations::Class]
     end
 
+    # Name of object, it's (single) declaration, and the outer module declarations
+    #
     class SingleEntry[N, D]
       attr_reader name: N
       attr_reader decl: D
@@ -64,36 +68,68 @@ module RBS
 
       include ContextUtil
 
-      @context: Array[Namespace]
+      @context: Resolver::context
+
+      def context: () -> Resolver::context
+    end
+
+    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias]
+    end
+
+    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias]
+    end
+
+    class InterfaceEntry < SingleEntry[TypeName, AST::Declarations::Interface]
+    end
 
-      def context: () -> Array[Namespace]
+    class TypeAliasEntry < SingleEntry[TypeName, AST::Declarations::TypeAlias]
     end
 
-    # Top level declarations.
+    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant]
+    end
+
+    class GlobalEntry < SingleEntry[Symbol, AST::Declarations::Global]
+    end
+
+    # Top level declarations
     attr_reader declarations: Array[AST::Declarations::t]
 
+    # Class declarations
     attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
-    attr_reader interface_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Interface]]
-    attr_reader alias_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Alias]]
-    attr_reader constant_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Constant]]
-    attr_reader global_decls: Hash[Symbol, SingleEntry[Symbol, AST::Declarations::Global]]
+
+    attr_reader class_alias_decls: Hash[TypeName, ModuleAliasEntry | ClassAliasEntry]
+
+    # Interface declarations
+    attr_reader interface_decls: Hash[TypeName, InterfaceEntry]
+
+    # Type alias declarations
+    attr_reader type_alias_decls: Hash[TypeName, TypeAliasEntry]
+
+    # Constant declarations
+    attr_reader constant_decls: Hash[TypeName, ConstantEntry]
+
+    # Global declarations
+    attr_reader global_decls: Hash[Symbol, GlobalEntry]
+
+    attr_reader buffer_directives: Hash[Buffer, Array[AST::Directives::t]]
 
     def initialize: () -> void
 
     def initialize_copy: (Environment) -> void
 
+    # Construct an environment from EnvironmentLoader
+    #
     def self.from_loader: (EnvironmentLoader) -> Environment
 
-    def cache_name: [N, D] (Hash[N, SingleEntry[N, D]] cache, name: N, decl: D, outer: Array[module_decl]) -> SingleEntry[N, D]
-
-    def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
+    def add_signature: (buffer: Buffer, directives: Array[AST::Directives::t], decls: Array[AST::Declarations::t]) -> void
 
-    # Insert a toplevel declaration into the env.
+    # Insert a toplevel declaration into the environment
     #
     def <<: (AST::Declarations::t decl) -> self
 
-    # Runs generics type params validation over each class definitions.
-    def validate_type_params: () -> void
+    # Insert a declaration into the environment
+    #
+    private def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
 
     # Resolve all type names in the environment to absolute type names.
     # Relative type name will be left if absolute type name cannot be found.
@@ -103,29 +139,114 @@ module RBS
     #
     def resolve_type_names: (?only: Set[AST::Declarations::t]?) -> Environment
 
-    def resolve_declaration: (TypeNameResolver resolver, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
+    def inspect: () -> String
 
-    def resolve_member: (TypeNameResolver, AST::Members::t, context: Array[Namespace]) -> AST::Members::t
+    @buffers: Array[Buffer]
 
-    def resolve_method_type: (TypeNameResolver, RBS::MethodType, context: Array[Namespace]) -> RBS::MethodType
+    def buffers: () -> Array[Buffer]
 
-    def resolve_type_params: (TypeNameResolver resolver, Array[AST::TypeParam], context: Array[Namespace]) ->  Array[AST::TypeParam]
+    def buffers_decls: () -> Hash[Buffer, Array[AST::Declarations::t]]
 
-    def absolute_type: (TypeNameResolver, Types::t, context: Array[Namespace]) -> Types::t
+    # Remove declarations and directives that are loaded from `buffers`
+    #
+    def unload: (Set[Buffer] buffers) -> Environment
 
-    def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName
+    # Returns true if an interface with the type name is defined
+    #
+    def interface_name?: (TypeName) -> bool
 
-    def inspect: () -> String
+    # Returns true if a type alias with the type name is defined
+    #
+    def type_alias_name?: (TypeName) -> bool
 
-    @buffers: Array[Buffer]
+    # Returns true if a module or class with the type name is defined
+    #
+    def module_name?: (TypeName) -> bool
 
-    def buffers: () -> Array[Buffer]
+    # Returns true if the type name is defined
+    #
+    def type_name?: (TypeName) -> bool
 
-    def buffers_decls: () -> Hash[Buffer, Array[AST::Declarations::t]]
+    # Returns if a constant of the name is defined
+    #
+    def constant_name?: (TypeName) -> bool
+
+    # Returns true if the type name is defined by constant declaration
+    #
+    def constant_decl?: (TypeName) -> bool
+
+    # Returns true if the type name is defined by class declaration
+    #
+    def class_decl?: (TypeName) -> bool
+
+    # Returns true if the type name is defined by module declaration
+    #
+    def module_decl?: (TypeName) -> bool
+
+    # Returns true if the type name is a module alias
+    #
+    def module_alias?: (TypeName) -> bool
+
+    # Returns true if the type name is a class alias
+    def class_alias?: (TypeName) -> bool
+
+    def class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | nil)
+
+    # Returns ClassEntry if the class definition is found, normalized in case of alias
+    #
+    def normalized_class_entry: (TypeName) -> ClassEntry?
+
+    def module_entry: (TypeName) -> (ModuleEntry | ModuleAliasEntry | nil)
+
+    # Returns ModuleEntry if the module definition is found, normalized in case of alias
+    #
+    def normalized_module_entry: (TypeName) -> ModuleEntry?
+
+    def constant_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
+
+    def module_class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
 
-    # Construct new environment without declarations tested `true` by block.
-    # Construction of new environment is done with `<<` so that nested declarations will work well.
+    def normalized_module_class_entry: (TypeName) -> (ClassEntry | ModuleEntry | nil)
+
+    @normalize_module_name_cache: Hash[TypeName, TypeName | false | nil]
+
+    # Returns the original module name that is defined with `module` declaration
+    #
+    # * Calls `#absolute!` for relative module names
+    # * Returns `nil` if the rhs name cannot be found
+    # * Returns `false` if the name is cyclic
+    #
+    def normalize_module_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Returns the original module name that is defined with `module` declaration
+    #
+    # * Raises an error if given type name is not module
+    # * Calls `#absolute!` for relative module names
+    # * Returns the name itself if the name cannot be normalized to a class/module
+    #
+    def normalize_module_name: (TypeName) -> TypeName
+
+    # Runs generics type params validation over each class definitions
+    def validate_type_params: () -> void
+
+    private
+
+    # Returns a context for inside given decls
     #
-    def reject: () { (AST::Declarations::t) -> boolish } -> Environment
+    def resolver_context: (*module_decl) -> Resolver::context
+
+    def append_context: (Resolver::context, module_decl) -> Resolver::context
+
+    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
+
+    def resolve_member: (Resolver::TypeNameResolver, UseMap map, AST::Members::t, context: Resolver::context) -> AST::Members::t
+
+    def resolve_method_type: (Resolver::TypeNameResolver, UseMap map, RBS::MethodType, context: Resolver::context) -> RBS::MethodType
+
+    def resolve_type_params: (Resolver::TypeNameResolver resolver, UseMap map, Array[AST::TypeParam], context: Resolver::context) ->  Array[AST::TypeParam]
+
+    def absolute_type: (Resolver::TypeNameResolver, UseMap map, Types::t, context: Resolver::context) -> Types::t
+
+    def absolute_type_name: (Resolver::TypeNameResolver, UseMap map, TypeName, context: Resolver::context) -> TypeName
   end
 end

data/sig/environment_loader.rbs

@@ -100,7 +100,7 @@ module RBS
     #
     def self.gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
 
-    def each_decl: () { (AST::Declarations::t, Buffer, source, Pathname) -> void } -> void
+    def each_signature: () { (source, Pathname, Buffer, Array[AST::Declarations::t], Array[AST::Directives::t]) -> void } -> void
 
     def each_dir: { (source, Pathname) -> void } -> void
 

data/sig/errors.rbs

@@ -174,7 +174,7 @@ module RBS
   end
 
   # The *overloading* method definition cannot find *non-overloading* method definition
-  # 
+  #
   class InvalidOverloadMethodError < DefinitionError
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol
@@ -280,4 +280,25 @@ module RBS
 
     def initialize: (type_name: TypeName, method_name: Symbol?, params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
   end
+
+  # A module/class alias declaration has inconsistent right-hand-side
+  #
+  # ```rbs
+  # module Foo = Object     # Error
+  # class Bar = Kernel      # Error
+  # ```
+  #
+  class InconsistentClassModuleAliasError < BaseError
+    attr_reader alias_entry: Environment::ModuleAliasEntry | Environment::ClassAliasEntry
+
+    def initialize: (Environment::ModuleAliasEntry | Environment::ClassAliasEntry) -> void
+  end
+
+  # A module/class alias declaration is cyclic
+  #
+  class CyclicClassAliasDefinitionError < BaseError
+    attr_reader alias_entry: Environment::ModuleAliasEntry | Environment::ClassAliasEntry
+
+    def initialize: (Environment::ModuleAliasEntry | Environment::ClassAliasEntry) -> void
+  end
 end

data/sig/locator.rbs

@@ -10,14 +10,22 @@ module RBS
                    | AST::TypeParam
                    | AST::Declarations::Class::Super
                    | AST::Declarations::Module::Self
+                   | AST::Directives::t
+                   | AST::Directives::Use::clause
+
+    # The buffer the location points to
+    #
+    attr_reader buffer: Buffer
 
     # Array of _top-level_ declarations.
     #
     attr_reader decls: Array[AST::Declarations::t]
 
-    def initialize: (decls: Array[AST::Declarations::t]) -> void
+    # Array of directives.
+    #
+    attr_reader dirs: Array[AST::Directives::t]
 
-    def buffer: () -> Buffer
+    def initialize: (buffer: Buffer, decls: Array[AST::Declarations::t], dirs: Array[AST::Directives::t]) -> void
 
     # Returns list of components.
     # Inner component comes first.
@@ -29,6 +37,10 @@ module RBS
     #
     def find2: (line: Integer, column: Integer) -> [Symbol?, Array[component]]?
 
+    private
+
+    def find_in_directive: (Integer pos, AST::Directives::t, Array[component]) -> bool
+
     def find_in_decl: (Integer pos, decl: AST::Declarations::t, array: Array[component]) -> bool
 
     def find_in_member: (Integer pos, member: AST::Members::t, array: Array[component]) -> bool