rbs 2.8.4 → 3.0.0.dev.2

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
+
+    class TypeAliasEntry < SingleEntry[TypeName, AST::Declarations::TypeAlias]
+    end
 
-      def context: () -> Array[Namespace]
+    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant]
     end
 
-    # Top level declarations.
+    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,18 +139,6 @@ 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 resolve_member: (TypeNameResolver, AST::Members::t, context: Array[Namespace]) -> AST::Members::t
-
-    def resolve_method_type: (TypeNameResolver, RBS::MethodType, context: Array[Namespace]) -> RBS::MethodType
-
-    def resolve_type_params: (TypeNameResolver resolver, Array[AST::TypeParam], context: Array[Namespace]) ->  Array[AST::TypeParam]
-
-    def absolute_type: (TypeNameResolver, Types::t, context: Array[Namespace]) -> Types::t
-
-    def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName
-
     def inspect: () -> String
 
     @buffers: Array[Buffer]
@@ -127,5 +151,103 @@ module RBS
     # Construction of new environment is done with `<<` so that nested declarations will work well.
     #
     def reject: () { (AST::Declarations::t) -> boolish } -> Environment
+
+    # Returns true if an interface with the type name is defined
+    #
+    def interface_name?: (TypeName) -> bool
+
+    # Returns true if a type alias with the type name is defined
+    #
+    def type_alias_name?: (TypeName) -> bool
+
+    # Returns true if a module or class with the type name is defined
+    #
+    def module_name?: (TypeName) -> bool
+
+    # Returns true if the type name is defined
+    #
+    def type_name?: (TypeName) -> bool
+
+    # 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)
+
+    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 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

@@ -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.
     #
@@ -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

@@ -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
@@ -259,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/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/parser.rbs

@@ -6,15 +6,13 @@ module RBS
     # If no token is left in the input, it returns `nil`.
     #
     # ```ruby
+    # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
     # RBS::Parser.parse_method_type("() -> void", range: 0...)                   # => `() -> void`
     # RBS::Parser.parse_method_type("() -> void () -> String", range: 11...)     # => `() -> String`
     # RBS::Parser.parse_method_type("() -> void () -> String", range: 23...)     # => nil
     # ```
     #
-    # `line` and `column` is deprecated and are ignored.
-    #
-    def self.parse_method_type: (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol]) -> MethodType?
-                              | (Buffer | String, ?line: top, ?column: top, ?variables: Array[Symbol]) -> MethodType
+    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol]) -> MethodType?
 
     # Parse a type and return it
     #
@@ -22,22 +20,17 @@ module RBS
     # If no token is left in the input, it returns `nil`.
     #
     # ```ruby
+    # RBS::Parser.parse_type("String")                          # => `String`
     # RBS::Parser.parse_type("String", range: 0...)             # => `String`
     # RBS::Parser.parse_type("String Integer", pos: 7...)       # => `Integer`
     # RBS::Parser.parse_type("String Integer", pos: 14...)      # => nil
     # ```
     #
-    # `line` and `column` is deprecated and are ignored.
-    #
-    def self.parse_type: (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol]) -> Types::t?
-                       | (Buffer | String, ?line: top, ?column: top, ?variables: Array[Symbol]) -> Types::t
+    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol]) -> Types::t?
 
     # Parse whole RBS file and return an array of declarations
     #
-    # `line` and `column` is deprecated and are ignored.
-    #
-    def self.parse_signature: (Buffer | String) -> Array[AST::Declarations::t]
-                            | (Buffer | String, ?line: top, ?column: top) -> Array[AST::Declarations::t]
+    def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     KEYWORDS: Hash[String, bot]
 
@@ -45,11 +38,11 @@ module RBS
 
     def self.buffer: (String | Buffer source) -> Buffer
 
-    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, boolish eof) -> Types::t?
+    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> Types::t?
 
-    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, boolish eof) -> MethodType?
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> MethodType?
 
-    def self._parse_signature: (Buffer, Integer end_pos) -> Array[AST::Declarations::t]
+    def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     class LocatedValue
     end

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

data/sig/resolver/constant_resolver.rbs

@@ -37,7 +37,7 @@ module RBS
 
         def constant_of_module: (TypeName name, Environment::ClassEntry | Environment::ModuleEntry) -> Constant
 
-        def constant_of_constant: (TypeName name, Environment::SingleEntry[TypeName, AST::Declarations::Constant]) -> Constant
+        def constant_of_constant: (TypeName name, Environment::ConstantEntry) -> Constant
       end
 
       attr_reader builder: DefinitionBuilder
@@ -65,7 +65,6 @@ module RBS
       #    ^  <- constant_name
       # ```
       #
-      # Find the
       def resolve_child: (TypeName module_name, Symbol constant_name) -> Constant?
 
       # Returns the table of all constants accessible with `::` (colon2) operator.

data/sig/shims/bundler.rbs

@@ -0,0 +1,31 @@
+module Bundler
+  class LockfileParser
+    def initialize: (String) -> void
+
+    def specs: () -> Array[LazySpecification]
+  end
+
+  class LazySpecification
+    def name: () -> String
+
+    def version: () -> String
+
+    def dependencies: () -> Array[Gem::Dependency]
+  end
+
+  class Dependency < Gem::Dependency
+    attr_reader autorequire: Array[String]?
+  end
+
+  class Definition
+    def lockfile: () -> Pathname
+
+    def locked_gems: () -> LockfileParser
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  def self.default_lockfile: () -> Pathname
+
+  def self.definition: () -> Definition
+end

data/sig/shims/rubygems.rbs

@@ -0,0 +1,15 @@
+module Gem
+  class Specification
+    attr_reader version (): Version
+
+    attr_reader gem_dir (): String
+
+    def self.find_by_name: (String name, *String requirements) -> instance
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  class Dependency
+    def name: () -> String
+  end
+end

data/sig/shims.rbs

@@ -1,25 +1,3 @@
-module Gem
-  class Specification
-    attr_reader version (): Version
-
-    attr_reader gem_dir (): String
-
-    def self.find_by_name: (String name, *String requirements) -> instance
-  end
-end
-
-module Bundler
-  class LockfileParser
-    def initialize: (String) -> void
-    def specs: () -> Array[LazySpecification]
-  end
-
-  class LazySpecification
-    def name: () -> String
-    def version: () -> String
-  end
-end
-
 module RDoc
   class Store
     def initialize: (?String? path, ?Symbol? type) -> void

data/sig/substitution.rbs

@@ -38,5 +38,11 @@ module RBS
 
     # Returns true if given substitution is identity.
     def empty?: () -> bool
+
+    alias [] apply
+
+    # (s1 + s2)[t] == s2[s1[t]]
+    # 
+    def +: (Substitution) -> Substitution
   end
 end

data/sig/use_map.rbs

@@ -0,0 +1,35 @@
+module RBS
+  class Environment
+    # ```rb
+    # map = UseMap.build(environment)
+    #
+    # map.resolve?(TypeName("TN"))   # => nil or resolved type name
+    # ```
+    #
+    class UseMap
+      class Table
+        attr_reader known_types: Set[TypeName]
+
+        attr_reader children: Hash[Namespace, Set[TypeName]]
+
+        def initialize: () -> void
+
+        def compute_children: () -> self
+      end
+
+      attr_reader use_dirs: Array[AST::Directives::Use]
+
+      @map: Hash[Symbol, TypeName]
+
+      @table: Table
+
+      def initialize: (table: Table) -> void
+
+      def resolve?: (TypeName) -> TypeName?
+
+      def resolve: (TypeName) -> TypeName
+
+      def build_map: (AST::Directives::Use::clause) -> self
+    end
+  end
+end

data/sig/validator.rbs

@@ -2,7 +2,7 @@ module RBS
   class Validator
     attr_reader env: Environment
 
-    attr_reader resolver: TypeNameResolver
+    attr_reader resolver: Resolver::TypeNameResolver
 
     attr_reader definition_builder: DefinitionBuilder
 
@@ -10,11 +10,11 @@ module RBS
 
     attr_reader type_alias_regularity: TypeAliasRegularity
 
-    def initialize: (env: Environment, resolver: TypeNameResolver) -> void
+    def initialize: (env: Environment, resolver: Resolver::TypeNameResolver) -> void
 
     # Validates the presence of type names and type application arity match.
     #
-    def validate_type: (Types::t, context: TypeNameResolver::context) -> void
+    def validate_type: (Types::t, context: Resolver::context) -> void
 
     # Validates type alias definition:
     #
@@ -25,7 +25,7 @@ module RBS
     #
     # It yields the rhs type if block is given, so that you can validate the rhs type.
     #
-    def validate_type_alias: (entry: Environment::SingleEntry[TypeName, AST::Declarations::Alias]) ?{ (Types::t rhs_type) -> void } -> void
+    def validate_type_alias: (entry: Environment::TypeAliasEntry) ?{ (Types::t rhs_type) -> void } -> void
 
     # Validates the type parameters in generic methods.
     #
@@ -42,11 +42,18 @@ module RBS
     #
     def validate_type_params: (Array[AST::TypeParam] params, type_name: TypeName, ?method_name: Symbol?, location: Location[untyped, untyped]?) -> void
 
+    # Validates class alias declaration
+    #
+    # - The right hand side can be normalized
+    # - No mixing alias declaration between class and modules
+    # 
+    def validate_class_alias: (entry: Environment::ClassAliasEntry | Environment::ModuleAliasEntry) -> void
+
     private
 
     # Resolves relative type names to absolute type names in given context.
     # Yields the type when the type name resolution using `#resolver` fails.
     #
-    def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t
+    def absolute_type: (Types::t, context: Resolver::context) { (Types::t) -> TypeName } -> Types::t
   end
 end