steep 1.1.1 → 1.2.0.pre.1

data/sig/steep/services/content_change.rbs

@@ -2,34 +2,36 @@ module Steep
   module Services
     class ContentChange
       class Position
-        attr_reader line: untyped
+        attr_reader line: Integer
 
-        attr_reader column: untyped
+        attr_reader column: Integer
 
-        def initialize: (line: untyped, column: untyped) -> void
+        def initialize: (line: Integer, column: Integer) -> void
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
         alias eql? ==
 
-        def hash: () -> untyped
+        def hash: () -> Integer
       end
 
-      attr_reader range: untyped
+      type range = [Position, Position]
 
-      attr_reader text: untyped
+      attr_reader range: range?
 
-      def initialize: (text: untyped, ?range: untyped?) -> void
+      attr_reader text: String
 
-      def ==: (untyped other) -> untyped
+      def initialize: (text: String, ?range: range?) -> void
+
+      def ==: (untyped other) -> bool
 
       alias eql? ==
 
-      def hash: () -> untyped
+      def hash: () -> Integer
 
-      def self.string: (untyped string) -> untyped
+      def self.string: (String) -> ContentChange
 
-      def apply_to: (untyped text) -> untyped
+      def apply_to: (String text) -> String
     end
   end
 end

data/sig/steep/services/file_loader.rbs

@@ -1,13 +1,21 @@
 module Steep
   module Services
     class FileLoader
-      attr_reader base_dir: untyped
+      attr_reader base_dir: Pathname
 
-      def initialize: (base_dir: untyped) -> void
+      def initialize: (base_dir: Pathname) -> void
 
-      def each_path_in_patterns: (untyped pattern, ?untyped commandline_patterns) { (untyped) -> untyped } -> untyped
+      # Yields relative paths included in `pattern` from `base_dir`
+      #
+      def each_path_in_patterns: (Project::Pattern pattern, ?Array[String] commandline_patterns) { (Pathname) -> void } -> void
+                               | (Project::Pattern pattern, ?Array[String] commandline_patterns) -> Enumerator[Pathname, void]
 
-      def load_changes: (untyped pattern, ?untyped command_line_patterns, changes: untyped) -> untyped
+      # Returns changes that represents loading files from file system merged with ones given as `changes:`
+      #
+      # ```
+      # changes = loader.load_changes(target.pattern, command_line_patterns, changes: changes_from_editor)
+      # ```
+      def load_changes: (Project::Pattern pattern, ?Array[String] command_line_patterns, changes: Hash[Pathname, Array[ContentChange]]) -> Hash[Pathname, Array[ContentChange]]
     end
   end
 end

data/sig/steep/services/hover_provider/singleton_methods.rbs

@@ -2,7 +2,7 @@ module Steep
   module Services
     module HoverProvider
       module SingletonMethods
-        def content_for: (service: untyped, path: untyped, line: untyped, column: untyped) -> untyped
+        def content_for: (service: TypeCheckService, path: Pathname, line: Integer, column: Integer) -> (Ruby | RBS | nil)
       end
 
       extend SingletonMethods

data/sig/steep/services/path_assignment.rbs

@@ -1,21 +1,21 @@
 module Steep
   module Services
     class PathAssignment
-      attr_reader index: untyped
+      attr_reader index: Integer
 
-      attr_reader max_index: untyped
+      attr_reader max_index: Integer
 
-      attr_reader cache: untyped
+      attr_reader cache: Hash[Pathname, Integer]
 
-      def initialize: (index: untyped, max_index: untyped) -> void
+      def initialize: (index: Integer, max_index: Integer) -> void
 
-      def self.all: () -> untyped
+      def self.all: () -> PathAssignment
 
-      def =~: (untyped path) -> untyped
+      def =~: (Pathname path) -> bool
 
       alias === =~
 
-      def self.index_for: (path: untyped, max_index: untyped) -> untyped
+      def self.index_for: (path: String, max_index: Integer) -> Integer
     end
   end
 end

data/sig/steep/services/signature_service.rbs

@@ -1,91 +1,118 @@
 module Steep
   module Services
     class SignatureService
-      attr_reader status: untyped
+      type status = SyntaxErrorStatus | AncestorErrorStatus | LoadedStatus
+
+      attr_reader status: status
 
       class SyntaxErrorStatus
-        attr_reader files: untyped
+        attr_reader files: Hash[Pathname, FileStatus]
+
+        attr_reader changed_paths: Set[Pathname]
 
-        attr_reader changed_paths: untyped
+        attr_reader diagnostics: Array[Diagnostic::Signature::Base]
 
-        attr_reader diagnostics: untyped
+        attr_reader last_builder: RBS::DefinitionBuilder
 
-        attr_reader last_builder: untyped
+        @rbs_index: Index::RBSIndex?
 
-        def initialize: (files: untyped, changed_paths: untyped, diagnostics: untyped, last_builder: untyped) -> void
+        def initialize: (files: Hash[Pathname, FileStatus], changed_paths: Set[Pathname], diagnostics: Array[Diagnostic::Signature::Base], last_builder: RBS::DefinitionBuilder) -> void
 
-        def rbs_index: () -> untyped
+        def rbs_index: () -> Index::RBSIndex
       end
 
       class AncestorErrorStatus
-        attr_reader files: untyped
+        attr_reader files: Hash[Pathname, FileStatus]
+
+        attr_reader changed_paths: Set[Pathname]
 
-        attr_reader changed_paths: untyped
+        attr_reader diagnostics: Array[Diagnostic::Signature::Base]
 
-        attr_reader diagnostics: untyped
+        attr_reader last_builder: RBS::DefinitionBuilder
 
-        attr_reader last_builder: untyped
+        @rbs_index: Index::RBSIndex?
 
-        def initialize: (files: untyped, changed_paths: untyped, diagnostics: untyped, last_builder: untyped) -> void
+        def initialize: (files: Hash[Pathname, FileStatus], changed_paths: Set[Pathname], diagnostics: Array[Diagnostic::Signature::Base], last_builder: RBS::DefinitionBuilder) -> void
 
-        def rbs_index: () -> untyped
+        def rbs_index: () -> Index::RBSIndex
       end
 
       class LoadedStatus
-        attr_reader files: untyped
+        attr_reader files: Hash[Pathname, FileStatus]
+
+        attr_reader builder: RBS::DefinitionBuilder
+
+        @rbs_index: Index::RBSIndex?
+
+        @subtyping: Subtyping::Check?
+
+        def initialize: (files: Hash[Pathname, FileStatus], builder: RBS::DefinitionBuilder) -> void
+
+        def subtyping: () -> Subtyping::Check
+
+        def rbs_index: () -> Index::RBSIndex
+      end
 
-        attr_reader builder: untyped
+      class FileStatus
+        attr_reader path: Pathname
 
-        def initialize: (files: untyped, builder: untyped) -> void
+        attr_reader content: String
 
-        def subtyping: () -> untyped
+        attr_reader decls: Array[RBS::AST::Declarations::t] | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
 
-        def rbs_index: () -> untyped
+        def initialize: (
+          path: Pathname,
+          content: String,
+          decls: Array[RBS::AST::Declarations::t] | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
+        ) -> void
       end
 
-      FileStatus: untyped
+      def initialize: (env: RBS::Environment) -> void
 
-      def initialize: (env: untyped) -> void
+      def self.load_from: (RBS::EnvironmentLoader loader) -> SignatureService
 
-      def self.load_from: (untyped loader) -> untyped
+      @env_rbs_paths: Set[Pathname]?
 
-      def env_rbs_paths: () -> untyped
+      def env_rbs_paths: () -> Set[Pathname]
 
-      def each_rbs_path: () { (untyped) -> untyped } -> untyped
+      def each_rbs_path: () { (Pathname) -> void } -> void
+                       | () -> Enumerator[Pathname, void]
 
-      def files: () -> untyped
+      def files: () -> Hash[Pathname, FileStatus]
 
-      def pending_changed_paths: () -> untyped
+      def pending_changed_paths: () -> Set[Pathname]
 
-      def latest_env: () -> untyped
+      def latest_env: () -> RBS::Environment
 
-      def latest_builder: () -> untyped
+      def latest_builder: () -> RBS::DefinitionBuilder
 
-      def latest_rbs_index: () -> untyped
+      def latest_rbs_index: () -> Index::RBSIndex
 
-      def current_subtyping: () -> (untyped | nil)
+      def current_subtyping: () -> Subtyping::Check?
 
-      def apply_changes: (untyped files, untyped changes) -> untyped
+      def apply_changes: (Hash[Pathname, FileStatus] files, Server::ChangeBuffer::changes changes) -> Hash[Pathname, FileStatus]
 
-      def update: (untyped changes) -> untyped
+      def update: (Server::ChangeBuffer::changes changes) -> void
 
-      def update_env: (untyped updated_files, paths: untyped) -> untyped
+      def update_env: (
+        Hash[Pathname, FileStatus] updated_files, paths: Set[Pathname]
+      ) -> (RBS::DefinitionBuilder::AncestorBuilder | Array[Diagnostic::Signature::Base])
 
-      def rescue_rbs_error: (untyped errors) { () -> untyped } -> untyped
+      def rescue_rbs_error: (Array[RBS::BaseError] errors) { () -> void } -> void
 
-      def update_builder: (ancestor_builder: untyped, paths: untyped) -> untyped
+      def update_builder: (ancestor_builder: RBS::DefinitionBuilder::AncestorBuilder, paths: Set[Pathname]) -> RBS::DefinitionBuilder
 
-      def type_names: (paths: untyped, env: untyped) -> untyped
+      def type_names: (paths: Set[Pathname], env: RBS::Environment) -> Set[RBS::TypeName]
 
-      def const_decls: (paths: untyped, env: untyped) -> untyped
+      def const_decls: (paths: Set[Pathname], env: RBS::Environment) -> Hash[RBS::TypeName, RBS::Environment::SingleEntry[RBS::TypeName, RBS::AST::Declarations::Constant]]
 
-      def global_decls: (paths: untyped, ?env: untyped) -> untyped
+      def global_decls: (paths: Set[Pathname], ?env: RBS::Environment) -> Hash[Symbol, RBS::Environment::SingleEntry[Symbol, RBS::AST::Declarations::Global]]
 
-      def type_name_from_decl: (untyped decl, set: untyped) -> untyped
+      def type_name_from_decl: (RBS::AST::Declarations::t decl, set: Set[RBS::TypeName]) -> void
 
-      def add_descendants: (graph: untyped, names: untyped, set: untyped) -> untyped
+      def add_descendants: (graph: RBS::AncestorGraph, names: Set[RBS::TypeName], set: Set[RBS::TypeName]) -> void
 
-      def add_nested_decls: (env: untyped, names: untyped, set: untyped) -> untyped
+      def add_nested_decls: (env: RBS::Environment, names: Set[RBS::TypeName], set: Set[RBS::TypeName]) -> void
     end
   end
 end

data/sig/steep/services/type_check_service.rbs

@@ -1,93 +1,107 @@
 module Steep
   module Services
     class TypeCheckService
-      attr_reader project: untyped
+      attr_reader project: Project
 
-      attr_reader signature_validation_diagnostics: untyped
+      attr_reader signature_validation_diagnostics: Hash[Symbol, Hash[Pathname, Array[Diagnostic::Signature::Base]]]
 
-      attr_reader source_files: untyped
+      attr_reader source_files: Hash[Pathname, SourceFile]
 
-      attr_reader signature_services: untyped
+      attr_reader signature_services: Hash[Symbol, SignatureService]
 
       class SourceFile
-        attr_reader path: untyped
+        attr_reader path: Pathname
 
-        attr_reader target: untyped
+        attr_reader target: Project::Target
 
-        attr_reader content: untyped
+        attr_reader content: String
 
-        attr_reader node: untyped
+        attr_reader node: Parser::AST::Node | nil | false
 
-        attr_reader typing: untyped
+        attr_reader typing: Typing?
 
-        attr_reader errors: untyped
+        attr_reader errors: Array[Diagnostic::Ruby::Base]?
 
-        def initialize: (path: untyped, node: untyped, content: untyped, typing: untyped, errors: untyped) -> void
+        def initialize: (
+          path: Pathname,
+          node: Parser::AST::Node | nil | false,
+          content: String,
+          typing: Typing?,
+          errors: Array[Diagnostic::Ruby::Base]?
+        ) -> void
 
-        def self.with_syntax_error: (path: untyped, content: untyped, error: untyped) -> untyped
+        def self.with_syntax_error: (path: Pathname, content: String, error: Diagnostic::Ruby::SyntaxError) -> SourceFile
 
-        def self.with_typing: (path: untyped, content: untyped, typing: untyped, node: untyped) -> untyped
+        def self.with_typing: (path: Pathname, content: String, typing: Typing, node: Parser::AST::Node?) -> SourceFile
 
-        def self.no_data: (path: untyped, content: untyped) -> untyped
+        def self.no_data: (path: Pathname, content: String) -> SourceFile
 
-        def update_content: (untyped content) -> untyped
+        def update_content: (String content) -> SourceFile
 
-        def diagnostics: () -> untyped
+        def diagnostics: () -> Array[Diagnostic::Ruby::Base]
       end
 
       class TargetRequest
-        attr_reader target: untyped
+        attr_reader target: Project::Target
 
-        attr_reader source_paths: untyped
+        attr_reader source_paths: Set[Pathname]
 
-        def initialize: (target: untyped) -> void
+        @signature_updated: bool
+
+        def initialize: (target: Project::Target) -> void
 
         def signature_updated!: (?bool value) -> self
 
-        def signature_updated?: () -> untyped
+        def signature_updated?: () -> bool
 
-        def empty?: () -> untyped
+        def empty?: () -> bool
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
         alias eql? ==
 
-        def hash: () -> untyped
+        def hash: () -> Integer
       end
 
-      def initialize: (project: untyped) -> void
+      def initialize: (project: Project) -> void
 
-      def signature_diagnostics: () -> untyped
+      def signature_diagnostics: () -> Hash[Pathname, Array[Diagnostic::Signature::Base]]
 
-      def has_diagnostics?: () -> untyped
+      def has_diagnostics?: () -> bool
 
-      def diagnostics: () -> untyped
+      def diagnostics: () -> Hash[Pathname, Array[Diagnostic::Ruby::Base | Diagnostic::Signature::Base]]
 
-      def each_diagnostics: () { (untyped) -> untyped } -> untyped
+      def each_diagnostics: () { ([Pathname, Array[Diagnostic::Ruby::Base] | Array[Diagnostic::Signature::Base]]) -> void } -> void
+                          | () -> Enumerator[[Pathname, Array[Diagnostic::Ruby::Base] | Array[Diagnostic::Signature::Base]], void]
 
-      def update: (changes: untyped) -> untyped
+      def update: (changes: Server::ChangeBuffer::changes) -> Hash[Project::Target, TargetRequest]
 
-      def update_and_check: (changes: untyped, assignment: untyped) ?{ () -> untyped } -> untyped
+      def update_and_check: (
+        changes: Server::ChangeBuffer::changes,
+        assignment: PathAssignment
+      ) {
+        ([Pathname, Array[Diagnostic::Signature::Base] | Array[Diagnostic::Ruby::Base]]) -> void
+      } -> void
 
-      def validate_signature: (path: untyped) { (untyped) -> untyped } -> untyped
+      def validate_signature: (path: Pathname) { ([Pathname, Array[Diagnostic::Signature::Base]]) -> void } -> void
 
-      def typecheck_source: (path: untyped, ?target: untyped) { (untyped) -> untyped } -> (nil | untyped)
+      def typecheck_source: (path: Pathname, ?target: Project::Target?) { ([Pathname, Array[Diagnostic::Ruby::Base]]) -> void } -> void
 
-      def update_signature: (changes: untyped, requests: untyped) -> untyped
+      def update_signature: (changes: Server::ChangeBuffer::changes, requests: Hash[Project::Target, TargetRequest]) -> void
 
-      def update_sources: (changes: untyped, requests: untyped) -> untyped
+      def update_sources: (changes: Server::ChangeBuffer::changes, requests: Hash[Project::Target, TargetRequest]) -> void
 
-      def type_check_file: (target: untyped, subtyping: untyped, path: untyped, text: untyped) -> untyped
+      def type_check_file: (target: Project::Target, subtyping: Subtyping::Check, path: Pathname, text: String) -> SourceFile
 
       def self.type_check: (source: Source, subtyping: Subtyping::Check) -> Typing
 
-      def source_file?: (Pathname path) -> (untyped | nil)
+      def source_file?: (Pathname path) -> Project::Target?
 
-      def signature_file?: (Pathname path) -> untyped
+      def signature_file?: (Pathname path) -> Array[Symbol]?
 
-      def app_signature_file?: (Pathname path) -> untyped
+      def app_signature_file?: (Pathname path) -> Array[Symbol]?
 
-      def lib_signature_file?: (Pathname path) -> untyped
+      def lib_signature_file?: (Pathname path) -> bool
     end
   end
 end

data/sig/steep/subtyping/check.rbs

@@ -1,93 +1,129 @@
 module Steep
   module Subtyping
     class Check
-      attr_reader factory: AST::Types::Factory
+      attr_reader builder: Interface::Builder
 
-      attr_reader cache: untyped
+      attr_reader cache: Cache
 
-      attr_reader assumptions: untyped
+      @assumptions: Set[Relation[untyped]]?
 
-      def initialize: (factory: untyped) -> void
+      @bounds: Array[Hash[Symbol, AST::Types::t?]]
 
-      def with_context: (self_type: untyped, instance_type: untyped, class_type: untyped, constraints: untyped) { () -> untyped } -> untyped
+      @self_type: AST::Types::t?
 
-      def push_assumption: (untyped relation) { () -> untyped } -> untyped
+      @instance_type: AST::Types::t?
 
-      def push_variable_bounds: (untyped params) { () -> untyped } -> untyped
+      @class_type: AST::Types::t?
 
-      def variable_upper_bound: (untyped name) -> (untyped | nil)
+      @constraints: Constraints?
 
-      def self_type: () -> untyped
+      def initialize: (builder: Interface::Builder) -> void
 
-      def instance_type: () -> untyped
+      def factory: () -> AST::Types::Factory
 
-      def class_type: () -> untyped
+      def with_context: [A] (self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t, constraints: Constraints) { () -> A } -> A
 
-      def constraints: () -> untyped
+      def self_type: () -> AST::Types::t
 
-      def each_ancestor: (untyped ancestors) { (untyped) -> untyped } -> untyped
+      def instance_type: () -> AST::Types::t
 
-      def instance_super_types: (untyped type_name, args: untyped) -> untyped
+      def class_type: () -> AST::Types::t
 
-      def singleton_super_types: (untyped type_name) -> untyped
+      def constraints: () -> Constraints
 
-      def check: (untyped relation, constraints: untyped, self_type: untyped, instance_type: untyped, class_type: untyped) -> untyped
+      def push_variable_bounds: [A] (Array[Interface::TypeParam] | Hash[Symbol, AST::Types::t?] params) { () -> A } -> A
 
-      def check_type: (untyped relation) -> untyped
+      def variable_upper_bound: (Symbol name) -> AST::Types::t?
 
-      def cache_bounds: (untyped relation) -> untyped
+      def variable_upper_bounds: () -> Hash[Symbol, AST::Types::t?]
 
-      def alias?: (untyped `type`) -> untyped
+      def push_assumption: [A] (Relation[untyped] relation) { () -> A } -> A
 
-      def cacheable?: (untyped relation) -> untyped
+      def assumptions: () -> Set[Relation[untyped]]
 
-      def true_type?: (untyped `type`) -> untyped
+      def each_ancestor: (RBS::DefinitionBuilder::AncestorBuilder::OneAncestors ancestors) { (RBS::Definition::Ancestor::t) -> void } -> void
+                       | (RBS::DefinitionBuilder::AncestorBuilder::OneAncestors ancestors) -> Enumerator[RBS::Definition::Ancestor::t, void]
 
-      def false_type?: (untyped `type`) -> untyped
+      type super_type = AST::Types::Name::Instance | AST::Types::Name::Interface | AST::Types::Name::Singleton
+
+      def instance_super_types: (RBS::TypeName type_name, args: Array[AST::Types::t]) -> Array[super_type]
+
+      def singleton_super_types: (RBS::TypeName type_name) -> Array[super_type]
+
+      def check: (Relation[AST::Types::t] relation, constraints: Constraints, self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t) -> Result::t
+
+      def check_type: (Relation[AST::Types::t] relation) -> Result::t
+
+      def cache_bounds: (Relation[AST::Types::t] relation) -> Hash[Symbol, AST::Types::t?]
+
+      def alias?: (AST::Types::t `type`) -> bool
+
+      def cacheable?: (Relation[AST::Types::t] relation) -> bool
+
+      def true_type?: (AST::Types::t `type`) -> bool
+
+      def false_type?: (AST::Types::t `type`) -> bool
 
       include Result::Helper
 
-      def check_type0: (untyped relation) -> untyped
+      def check_type0: (Relation[AST::Types::t] relation) -> Result::t
 
-      def definition_for_type: (untyped `type`) -> untyped
+      def definition_for_type: (AST::Types::t `type`) -> RBS::Definition
 
-      def arg_type?: (untyped `type`) -> untyped
+      # Returns true if given `type` is with one or more type arguments.
+      #
+      def arg_type?: (AST::Types::t `type`) -> bool
 
-      def check_type_arg: (untyped relation) -> untyped
+      type application_type = AST::Types::Name::Instance | AST::Types::Name::Interface | AST::Types::Name::Alias
 
-      def same_type?: (untyped relation) -> (true | untyped)
+      def check_type_arg: (Relation[application_type] relation) -> untyped
 
-      def check_interface: (untyped relation) -> untyped
+      def same_type?: (Relation[AST::Types::t] relation) -> bool
 
-      def check_method: (untyped name, untyped relation) -> untyped
+      def check_interface: (Relation[Interface::Shape] relation) -> Result::t
 
-      def check_type_application: (untyped result, untyped type_params, untyped type_args) { () -> untyped } -> untyped
+      def check_method: (Symbol name, Relation[Interface::Shape::Entry] relation) -> Result::t
 
-      def check_generic_method_type: (untyped name, untyped relation) -> untyped
+      def check_generic_method_type: (Symbol name, Relation[Interface::MethodType] relation) -> Result::t
 
-      def check_constraints: (untyped relation, variables: untyped, variance: untyped) -> untyped
+      def check_constraints: (Relation[untyped] relation, variables: Enumerable[Symbol], variance: VariableVariance) -> Result::t
 
-      def check_method_type: (untyped name, untyped relation) -> untyped
+      def check_method_type: (Symbol name, Relation[Interface::MethodType] relation) -> Result::t
 
-      def check_block_given: (untyped name, untyped relation) { () -> untyped } -> untyped
+      # Receives subtyping relation of blocks `b <: b'` where `b` and `b'` are expanded from
+      # subtyping relation of two method types `(...) _b_ -> T <: (...) _b'_ -> S`.
+      #
+      # Returns `true` is the relation is satisfied immediately.
+      # Returns a Relation when the given relation can be expanded to relation between Interface::Block.
+      # Returns a failure otherwise.
+      #
+      def expand_block_given: (Symbol name, Relation[Interface::Block?] relation) -> (Relation[Interface::Block] | true | Result::t)
 
-      def check_function: (untyped name, untyped relation) -> untyped
+      # Receives a subtyping relation between self bindings `S <: S'` that is included in procs or blocks as:
+      #
+      # *             `^() [self: S] -> T <: ^() [self: S'] -> T`           (proc)
+      # * `() { () [self: S'] -> T } -> T <: () { () [self: S] -> T } -> T` (block in method type)
+      #
+      def check_self_type_binding: (Relation[untyped], AST::Types::t? sub_self, AST::Types::t? super_self) -> Result::t?
 
-      def check_method_params: (untyped name, untyped relation) -> untyped
+      def check_function: (Symbol name, Relation[Interface::Function] relation) -> Result::t
 
-      # ```rbs
-      # (Symbol, Relation[MethodType]) -> (Array[[Symbol, Symbol]] | Result::t)
-      # [A] (Symbol, Relation[MethodType]) { (Array[[Symbol, Symbol]]) -> A } -> (A | Result::t)
-      # ````
-      def match_method_type: (untyped name, untyped relation) { (untyped) -> untyped } -> untyped
+      def check_method_params: (Symbol name, Relation[Interface::Function::Params] relation) -> Result::t
 
-      def match_params: (untyped name, untyped relation) -> untyped
+      # Returns `nil` when given two method_types are structually comparable.
+      # Returns a failure otherwise.
+      #
+      def match_method_type_fails?: (Symbol name, Interface::MethodType method_type1, Interface::MethodType method_type2) -> (nil | Result::t)
 
-      def expand_alias: (untyped `type`) { () -> untyped } -> untyped
+      def match_params: (Symbol name, Relation[Interface::Function::Params] relation) -> (Array[[AST::Types::t, AST::Types::t]] | Result::t)
+
+      def expand_alias: (AST::Types::t `type`) -> AST::Types::t
 
       # Returns the shortest type paths for one of the _unknown_ type variables.
       # Returns nil if there is no path.
-      def hole_path: (untyped `type`, ?untyped path) -> untyped
+      def hole_path: (AST::Types::t `type`, ?Array[AST::Types::t] path) -> Array[AST::Types::t]?
+
+      def Relation: [T < Object] (T sub, T sup) -> Relation[T]
     end
   end
 end