steep 1.3.0 → 1.4.0.dev.2

data/sig/steep/diagnostic/signature.rbs

@@ -146,23 +146,11 @@ module Steep
       class ModuleSelfTypeError < Base
         attr_reader name: RBS::TypeName
 
-        attr_reader ancestor: RBS::DefinitionBuilder::AncestorBuilder::OneAncestors
+        attr_reader ancestor: RBS::Definition::Ancestor::Instance
 
         attr_reader relation: Subtyping::Relation[AST::Types::t]
 
-        def initialize: (name: RBS::TypeName, ancestor: RBS::DefinitionBuilder::AncestorBuilder::OneAncestors, relation: Subtyping::Relation[AST::Types::t], location: location?) -> void
-
-        def header_line: () -> String
-      end
-
-      class ClassVariableDuplicationError < Base
-        attr_reader class_name: RBS::TypeName
-
-        attr_reader other_class_name: RBS::TypeName
-
-        attr_reader variable_name: Symbol
-
-        def initialize: (class_name: RBS::TypeName, other_class_name: RBS::TypeName, variable_name: Symbol, location: RBS::Location[untyped, untyped]) -> void
+        def initialize: (name: RBS::TypeName, ancestor: RBS::Definition::Ancestor::Instance, relation: Subtyping::Relation[AST::Types::t], location: location?) -> void
 
         def header_line: () -> String
       end
@@ -242,6 +230,22 @@ module Steep
         def header_line: () -> String
       end
 
+      class InconsistentClassModuleAliasError < Base
+        attr_reader decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias
+
+        def initialize: (decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias) -> void
+
+        def header_line: () -> String
+      end
+
+      class CyclicClassAliasDefinitionError < Base
+        attr_reader decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias
+
+        def initialize: (decl: RBS::AST::Declarations::ModuleAlias | RBS::AST::Declarations::ClassAlias) -> void
+
+        def header_line: () -> String
+      end
+
       def self.from_rbs_error: (RBS::BaseError error, factory: AST::Types::Factory) -> Base
     end
   end

data/sig/steep/index/rbs_index.rbs

@@ -2,89 +2,139 @@ module Steep
   module Index
     class RBSIndex
       class TypeEntry
-        attr_reader type_name: untyped
-
-        attr_reader declarations: untyped
-
-        attr_reader references: untyped
-
-        def initialize: (type_name: untyped) -> void
-
-        def add_declaration: (untyped decl) -> untyped
-
-        def add_reference: (untyped ref) -> untyped
+        attr_reader type_name: RBS::TypeName
+
+        type decl = RBS::AST::Declarations::Class
+                  | RBS::AST::Declarations::Module
+                  | RBS::AST::Declarations::Interface
+                  | RBS::AST::Declarations::TypeAlias
+                  | RBS::AST::Declarations::ClassAlias
+                  | RBS::AST::Declarations::ModuleAlias
+
+        type ref = RBS::AST::Members::MethodDefinition
+                 | RBS::AST::Members::AttrWriter
+                 | RBS::AST::Members::AttrReader
+                 | RBS::AST::Members::AttrAccessor
+                 | RBS::AST::Members::Include
+                 | RBS::AST::Members::Extend
+                 | RBS::AST::Members::InstanceVariable
+                 | RBS::AST::Members::ClassVariable
+                 | RBS::AST::Members::ClassInstanceVariable
+                 | RBS::AST::Declarations::Module
+                 | RBS::AST::Declarations::Class
+                 | RBS::AST::Declarations::Constant
+                 | RBS::AST::Declarations::Global
+                 | RBS::AST::Declarations::TypeAlias
+                 | RBS::AST::Declarations::ClassAlias
+                 | RBS::AST::Declarations::ModuleAlias
+
+        attr_reader declarations: Set[decl]
+
+        attr_reader references: Set[ref]
+
+        def initialize: (type_name: RBS::TypeName) -> void
+
+        def add_declaration: (decl decl) -> self
+
+        def add_reference: (ref) -> self
       end
 
       class MethodEntry
-        attr_reader method_name: untyped
+        attr_reader method_name: method_name
 
-        attr_reader declarations: untyped
+        type decl = RBS::AST::Members::MethodDefinition
+                  | RBS::AST::Members::Alias
+                  | RBS::AST::Members::AttrWriter
+                  | RBS::AST::Members::AttrReader
+                  | RBS::AST::Members::AttrAccessor
 
-        attr_reader references: untyped
+        type ref = RBS::AST::Members::Alias
 
-        def initialize: (method_name: untyped) -> void
+        attr_reader declarations: Set[decl]
 
-        def add_declaration: (untyped decl) -> untyped
+        attr_reader references: Set[ref]
+
+        def initialize: (method_name: method_name) -> void
+
+        def add_declaration: (decl) -> self
       end
 
       class ConstantEntry
-        attr_reader const_name: untyped
+        attr_reader const_name: RBS::TypeName
 
-        attr_reader declarations: untyped
+        type decl = RBS::AST::Declarations::Constant
 
-        def initialize: (const_name: untyped) -> void
+        attr_reader declarations: Set[decl]
 
-        def add_declaration: (untyped decl) -> untyped
+        def initialize: (const_name: RBS::TypeName) -> void
+
+        def add_declaration: (decl) -> self
       end
 
       class GlobalEntry
-        attr_reader global_name: untyped
+        attr_reader global_name: Symbol
+
+        type decl = RBS::AST::Declarations::Global
 
-        attr_reader declarations: untyped
+        attr_reader declarations: Set[decl]
 
-        def initialize: (global_name: untyped) -> void
+        def initialize: (global_name: Symbol) -> void
 
-        def add_declaration: (untyped decl) -> untyped
+        def add_declaration: (decl) -> self
       end
 
-      attr_reader type_index: untyped
+      attr_reader type_index: Hash[RBS::TypeName, TypeEntry]
 
-      attr_reader method_index: untyped
+      attr_reader method_index: Hash[method_name, MethodEntry]
 
-      attr_reader const_index: untyped
+      attr_reader const_index: Hash[RBS::TypeName, ConstantEntry]
 
-      attr_reader global_index: untyped
+      attr_reader global_index: Hash[Symbol, GlobalEntry]
 
       def initialize: () -> void
 
-      def entry: (?type_name: untyped?, ?method_name: untyped?, ?const_name: untyped?, ?global_name: untyped?) -> untyped
+      def entry: (type_name: RBS::TypeName) -> TypeEntry
+               | (method_name: method_name) -> MethodEntry
+               | (const_name: RBS::TypeName) -> ConstantEntry
+               | (global_name: Symbol) -> GlobalEntry
 
-      def each_entry: () { () -> untyped } -> untyped
+      def each_entry: () { (TypeEntry | MethodEntry | ConstantEntry | GlobalEntry) -> void } -> void
+                    | () -> Enumerator[TypeEntry | MethodEntry | ConstantEntry | GlobalEntry, void]
 
-      def add_type_declaration: (untyped type_name, untyped declaration) -> untyped
+      def add_type_declaration: (RBS::TypeName type_name, TypeEntry::decl declaration) -> TypeEntry
 
-      def add_method_declaration: (untyped method_name, untyped member) -> untyped
+      def add_method_declaration: (method_name, MethodEntry::decl member) -> MethodEntry
 
-      def add_constant_declaration: (untyped const_name, untyped decl) -> untyped
+      def add_constant_declaration: (RBS::TypeName const_name, ConstantEntry::decl decl) -> ConstantEntry
 
-      def add_global_declaration: (untyped global_name, untyped decl) -> untyped
+      def add_global_declaration: (Symbol global_name, GlobalEntry::decl decl) -> GlobalEntry
 
-      def each_declaration: (?type_name: untyped?, ?method_name: untyped?, ?const_name: untyped?, ?global_name: untyped?) { () -> untyped } -> untyped
+      def each_declaration: (type_name: RBS::TypeName) { (TypeEntry) -> void } -> void
+                          | (type_name: RBS::TypeName) -> Enumerator[TypeEntry, void]
+                          | (method_name: method_name) { (MethodEntry) -> void } -> void
+                          | (method_name: method_name) -> Enumerator[MethodEntry, void]
+                          | (const_name: RBS::TypeName) { (ConstantEntry) -> void } -> void
+                          | (const_name: RBS::TypeName) -> Enumerator[ConstantEntry, void]
+                          | (global_name: Symbol) { (GlobalEntry) -> void } -> void
+                          | (global_name: Symbol) -> Enumerator[GlobalEntry, void]
 
-      def add_type_reference: (untyped type_name, untyped ref) -> untyped
+      # `type_name` is referred from `ref`
+      #
+      def add_type_reference: (RBS::TypeName type_name, TypeEntry::ref ref) -> TypeEntry
 
-      def each_reference: (?type_name: untyped?) { () -> untyped } -> untyped
+      def each_reference: (type_name: RBS::TypeName) { (TypeEntry::ref) -> void } -> void
+                        | (type_name: RBS::TypeName) -> Enumerator[TypeEntry::ref, void]
 
       class Builder
-        attr_reader index: untyped
+        attr_reader index: RBSIndex
 
-        def initialize: (index: untyped) -> void
+        def initialize: (index: RBSIndex) -> void
 
-        def member: (untyped type_name, untyped member) -> untyped
+        def member: (RBS::TypeName type_name, RBS::AST::Members::t | RBS::AST::Declarations::t member) -> void
 
-        def type_reference: (untyped `type`, from: untyped) -> untyped
+        def type_reference: (RBS::Types::t, from: TypeEntry::ref) -> void
 
-        def env: (untyped env) -> untyped
+        def env: (RBS::Environment env) -> void
       end
     end
   end

data/sig/steep/project/dsl.rbs

@@ -2,53 +2,55 @@ module Steep
   class Project
     class DSL
       class TargetDSL
-        attr_reader name: untyped
+        attr_reader name: Symbol
 
-        attr_reader sources: untyped
+        attr_reader sources: Array[String]
 
-        attr_reader libraries: untyped
+        attr_reader libraries: Array[String]
 
-        attr_reader signatures: untyped
+        attr_reader signatures: Array[String]
 
-        attr_reader ignored_sources: untyped
+        attr_reader ignored_sources: Array[String]
 
-        attr_reader stdlib_root: untyped
+        attr_reader stdlib_root: Pathname?
 
-        attr_reader core_root: untyped
+        attr_reader core_root: Pathname?
 
-        attr_reader repo_paths: untyped
+        attr_reader repo_paths: Array[Pathname]
 
         attr_reader code_diagnostics_config: untyped
 
-        attr_reader project: untyped
+        attr_reader project: Project?
 
-        attr_reader collection_config_path: untyped
+        attr_reader collection_config_path: Pathname?
 
         NONE: untyped
 
-        def initialize: (untyped name, ?sources: untyped, ?libraries: untyped, ?signatures: untyped, ?ignored_sources: untyped, ?repo_paths: untyped, ?code_diagnostics_config: ::Hash[untyped, untyped], ?project: untyped?, ?collection_config_path: untyped) -> void
+        def project!: () -> Project
 
-        def initialize_copy: (untyped other) -> untyped
+        def initialize: (Symbol name, ?sources: Array[String], ?libraries: Array[String], ?signatures: Array[String], ?ignored_sources: Array[String], ?repo_paths: Array[Pathname], ?code_diagnostics_config: ::Hash[untyped, untyped], ?project: Project?, ?collection_config_path: Pathname?) -> void
 
-        def check: (*untyped args) -> untyped
+        def initialize_copy: (instance other) -> void
 
-        def ignore: (*untyped args) -> untyped
+        def check: (*String args) -> void
 
-        def library: (*untyped args) -> untyped
+        def ignore: (*String args) -> void
 
-        def typing_options: (?untyped? level, **untyped hash) -> untyped
+        def library: (*String args) -> void
 
-        def signature: (*untyped args) -> untyped
+        def typing_options: (?untyped level, **untyped hash) -> void
 
-        def update: (?name: untyped, ?sources: untyped, ?libraries: untyped, ?ignored_sources: untyped, ?signatures: untyped, ?project: untyped) -> untyped
+        def signature: (*String args) -> void
 
-        def no_builtin!: (?bool value) -> untyped
+        def update: (?name: Symbol, ?sources: Array[String], ?libraries: Array[String], ?signatures: Array[String], ?ignored_sources: Array[String], ?project: Project?) -> TargetDSL
 
-        def vendor: (?::String dir, ?stdlib: untyped?, ?gems: untyped?) -> untyped
+        def no_builtin!: (?bool value) -> void
 
-        def stdlib_path: (core_root: untyped, stdlib_root: untyped) -> untyped
+        def vendor: (?::String dir, ?stdlib: untyped?, ?gems: untyped?) -> void
 
-        def repo_path: (*untyped paths) -> untyped
+        def stdlib_path: (core_root: String, stdlib_root: String) -> void
+
+        def repo_path: (*String paths) -> void
 
         # Configure the code diagnostics printing setup.
         #
@@ -71,24 +73,27 @@ module Steep
         # configure_code_diagnostics(D::Ruby.lenient)
         # ```
         #
-        def configure_code_diagnostics: (?untyped? hash) { (untyped) -> untyped } -> untyped
+        def configure_code_diagnostics: (Hash[untyped, untyped] hash) -> void
+                                      | () { (Hash[untyped, untyped]) -> void } -> void
 
-        def collection_config: (untyped path) -> untyped
+        def collection_config: (Pathname path) -> void
 
-        def disable_collection: () -> untyped
+        def disable_collection: () -> void
       end
 
       attr_reader project: untyped
 
-      def self.templates: () -> untyped
+      @@templates: Hash[Symbol, TargetDSL]
+
+      def self.templates: () -> Hash[Symbol, TargetDSL]
 
-      def initialize: (project: untyped) -> void
+      def initialize: (project: Project) -> void
 
-      def self.register_template: (untyped name, untyped target) -> untyped
+      def self.register_template: (Symbol name, TargetDSL target) -> void
 
-      def self.parse: (untyped project, untyped code, ?filename: ::String) -> untyped
+      def self.parse: (Project project, String code, ?filename: String) -> void
 
-      def target: (untyped name, ?template: untyped?) ?{ () -> untyped } -> untyped
+      def target: (Symbol name, ?template: Symbol?) ?{ (TargetDSL) [self: TargetDSL] -> void } -> void
     end
   end
 end

data/sig/steep/project/options.rbs

@@ -1,13 +1,25 @@
 module Steep
   class Project
     class Options
-      PathOptions: untyped
+      class PathOptions
+        attr_reader core_root: Pathname?
 
-      attr_reader libraries: untyped
+        attr_reader stdlib_root: Pathname?
 
-      attr_accessor paths: untyped
+        attr_reader repo_paths: Array[Pathname]
 
-      attr_accessor collection_lock: untyped
+        def initialize: (?core_root: Pathname?, ?stdlib_root: Pathname?, ?repo_paths: Array[Pathname]) -> void
+
+        def customized_stdlib?: () -> bool
+
+        def customized_core?: () -> bool
+      end
+
+      attr_reader libraries: Array[String]
+
+      attr_accessor paths: PathOptions
+
+      attr_accessor collection_lock: RBS::Collection::Config::Lockfile
 
       def initialize: () -> void
     end

data/sig/steep/project/target.rbs

@@ -1,9 +1,9 @@
 module Steep
   class Project
     class Target
-      attr_reader name: untyped
+      attr_reader name: Symbol
 
-      attr_reader options: untyped
+      attr_reader options: Options
 
       attr_reader source_pattern: Pattern
 
@@ -11,15 +11,15 @@ module Steep
 
       attr_reader code_diagnostics_config: untyped
 
-      def initialize: (name: untyped, options: untyped, source_pattern: untyped, signature_pattern: untyped, code_diagnostics_config: untyped) -> void
+      def initialize: (name: Symbol, options: Options, source_pattern: Pattern, signature_pattern: Pattern, code_diagnostics_config: untyped) -> void
 
-      def possible_source_file?: (untyped path) -> untyped
+      def possible_source_file?: (Pathname path) -> bool
 
-      def possible_signature_file?: (untyped path) -> untyped
+      def possible_signature_file?: (Pathname path) -> bool
 
-      def new_env_loader: (project: untyped) -> untyped
+      def new_env_loader: (project: Project) -> RBS::EnvironmentLoader
 
-      def self.construct_env_loader: (options: untyped, project: untyped) -> untyped
+      def self.construct_env_loader: (options: Options, project: Project) -> RBS::EnvironmentLoader
     end
   end
 end

data/sig/steep/server/interaction_worker.rbs

@@ -23,11 +23,11 @@ module Steep
 
       def process_completion: (untyped job) -> untyped
 
-      def format_completion_item_for_rbs: (untyped sig_service, untyped type_name, untyped context, untyped job, untyped prefix) -> (nil | untyped)
+      def format_completion_item_for_rbs: (Services::SignatureService sig_service, untyped type_name, untyped context, untyped job, untyped prefix) -> (nil | untyped)
 
       def format_comment: (untyped comment) -> (untyped | nil)
 
-      def format_comments: (untyped comments) -> (untyped | nil)
+      def format_comments: (Array[RBS::AST::Comment] comments) -> untyped?
 
       def format_completion_item: (untyped item) -> untyped
 

data/sig/steep/server/lsp_formatter.rbs

@@ -28,8 +28,10 @@ module Steep
       type summarizable_decl = ::RBS::AST::Declarations::Class
                              | ::RBS::AST::Declarations::Module
                              | ::RBS::AST::Declarations::Interface
-                             | ::RBS::AST::Declarations::Alias
-                             
+                             | ::RBS::AST::Declarations::TypeAlias
+                             | ::RBS::AST::Declarations::ClassAlias
+                             | ::RBS::AST::Declarations::ModuleAlias
+
       def self?.declaration_summary: (summarizable_decl) -> String
     end
   end

data/sig/steep/services/completion_provider.rbs

@@ -51,6 +51,12 @@ module Steep
         attr_reader full_name: RBS::TypeName
 
         def initialize: (env: RBS::Environment, identifier: Symbol, range: Range, type: AST::Types::t, full_name: RBS::TypeName) -> void
+
+        def class?: () -> bool
+
+        def module?: () -> bool
+
+        def comments: () -> Array[RBS::AST::Comment]
       end
 
       class MethodNameItem

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

@@ -5,17 +5,19 @@ module Steep
         class TypeAliasContent
           attr_reader location: ::RBS::Location[untyped, untyped]
 
-          attr_reader decl: ::RBS::AST::Declarations::Alias
+          attr_reader decl: ::RBS::AST::Declarations::TypeAlias
 
-          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::Alias) -> void
+          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::TypeAlias) -> void
         end
 
         class ClassContent
           attr_reader location: ::RBS::Location[untyped, untyped]
 
-          attr_reader decl: ::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module
+          type decl = ::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module | ::RBS::AST::Declarations::ClassAlias | ::RBS::AST::Declarations::ModuleAlias
 
-          def initialize: (location: ::RBS::Location[untyped, untyped], decl: ::RBS::AST::Declarations::Class | ::RBS::AST::Declarations::Module) -> void
+          attr_reader decl: decl
+
+          def initialize: (location: ::RBS::Location[untyped, untyped], decl: decl) -> void
         end
 
         class InterfaceContent

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

@@ -82,23 +82,27 @@ module Steep
 
           type decl = ::RBS::Environment::ClassEntry
                     | ::RBS::Environment::ModuleEntry
-                    | ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]
+                    | ::RBS::Environment::ClassAliasEntry
+                    | ::RBS::Environment::ModuleAliasEntry
+                    | ::RBS::Environment::ConstantEntry
 
           attr_reader decl: decl
 
           attr_reader class_decl(): ::RBS::Environment::ClassEntry | ::RBS::Environment::ModuleEntry | nil
 
-          attr_reader constant_decl(): ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]?
+          attr_reader class_alias(): ::RBS::Environment::ClassAliasEntry | ::RBS::Environment::ModuleAliasEntry | nil
+
+          attr_reader constant_decl(): ::RBS::Environment::ConstantEntry?
 
           def initialize: (location: Parser::Source::Range, full_name: ::RBS::TypeName, type: AST::Types::t, decl: decl) -> void
 
           def comments: () -> Array[::RBS::AST::Comment]
 
           # Returns true if `decl` is a class/module definition
-          def class_or_module?: () -> (::RBS::Environment::ClassEntry | ::RBS::Environment::ModuleEntry | nil)
+          def class_or_module?: () -> bool
 
           # Returns true if `decl` is a constant definition
-          def constant?: () -> ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]?
+          def constant?: () -> bool
         end
 
         type content = TypeContent | VariableContent | MethodCallContent | DefinitionContent | ConstantContent | TypeAssertionContent

data/sig/steep/services/signature_service.rbs

@@ -1,5 +1,12 @@
 module Steep
   module Services
+    # SignatureService takes care of two sets of RBS files.
+    #
+    # 1. RBS files loaded from `EnvironmentLoader` -- usually type signatures of libraries
+    # 2. RBS files managed in editors -- usually type signatures of the development target (app or gem)
+    #
+    # The files in #2 are managed throuth `#status` and the changes are tracked.
+    #
     class SignatureService
       type status = SyntaxErrorStatus | AncestorErrorStatus | LoadedStatus
 
@@ -65,17 +72,25 @@ module Steep
         def constant_resolver: () -> RBS::Resolver::ConstantResolver
       end
 
+      # A file has one of the three states:
+      #
+      # 1. The parsing succeeded and loaded a list of declarations
+      # 2. The content has a syntax error and parsing failed
+      # 3. Other unexpected error
+      #
       class FileStatus
         attr_reader path: Pathname
 
         attr_reader content: String
 
-        attr_reader decls: Array[RBS::AST::Declarations::t] | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
+        type signature = [RBS::Buffer, Array[RBS::AST::Directives::t], Array[RBS::AST::Declarations::t]]
+
+        attr_reader signature: signature | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
 
         def initialize: (
           path: Pathname,
           content: String,
-          decls: Array[RBS::AST::Declarations::t] | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
+          signature: signature | Diagnostic::Signature::UnexpectedError | RBS::ParsingError
         ) -> void
       end
 
@@ -85,11 +100,17 @@ module Steep
 
       @env_rbs_paths: Set[Pathname]?
 
+      # All RBS paths in environment, both dependency RBS and target RBS
+      #
       def env_rbs_paths: () -> Set[Pathname]
 
+      # Yield all RBS paths in the environment, both dependency RBS and target RBS
+      #
       def each_rbs_path: () { (Pathname) -> void } -> void
                        | () -> Enumerator[Pathname, void]
 
+      # The Target files
+      #
       def files: () -> Hash[Pathname, FileStatus]
 
       def pending_changed_paths: () -> Set[Pathname]
@@ -106,10 +127,13 @@ module Steep
 
       def apply_changes: (Hash[Pathname, FileStatus] files, Server::ChangeBuffer::changes changes) -> Hash[Pathname, FileStatus]
 
+      # The entry point to apply the edit to the signatures
+      #
       def update: (Server::ChangeBuffer::changes changes) -> void
 
       def update_env: (
-        Hash[Pathname, FileStatus] updated_files, paths: Set[Pathname]
+        Hash[Pathname, FileStatus] updated_files,
+        paths: Set[Pathname]
       ) -> (RBS::DefinitionBuilder::AncestorBuilder | Array[Diagnostic::Signature::Base])
 
       def rescue_rbs_error: (Array[RBS::BaseError] errors) { () -> void } -> void

data/sig/steep/signature/validator.rbs

@@ -9,7 +9,7 @@ module Steep
 
       @errors: Array[Diagnostic::Signature::Base]
 
-      @type_name_resolver: RBS::TypeNameResolver?
+      @type_name_resolver: RBS::Resolver::TypeNameResolver?
 
       @validator: RBS::Validator?
 
@@ -26,7 +26,7 @@ module Steep
 
       def builder: () -> RBS::DefinitionBuilder
 
-      def type_name_resolver: () -> RBS::TypeNameResolver
+      def type_name_resolver: () -> RBS::Resolver::TypeNameResolver
 
       def validator: () -> RBS::Validator
 
@@ -60,13 +60,17 @@ module Steep
 
       def validate_const: () -> void
 
-      def validate_one_constant: (RBS::TypeName name, RBS::Environment::SingleEntry[RBS::TypeName, RBS::AST::Declarations::Constant] entry) -> void
+      def validate_one_constant: (RBS::TypeName name, RBS::Environment::ConstantEntry entry) -> void
 
       def validate_global: () -> void
 
-      def validate_one_global: (Symbol name, RBS::Environment::SingleEntry[Symbol, RBS::AST::Declarations::Global]) -> void
+      def validate_one_global: (Symbol name, RBS::Environment::GlobalEntry) -> void
 
-      def validate_one_alias: (RBS::TypeName name, ?RBS::Environment::SingleEntry[RBS::TypeName, RBS::AST::Declarations::Alias] entry) -> void
+      def validate_one_alias: (RBS::TypeName name, ?RBS::Environment::TypeAliasEntry entry) -> void
+
+      def validate_one_class_decl: (RBS::TypeName) -> void
+                                 
+      def validate_one_class_alias: (RBS::TypeName, RBS::Environment::ClassAliasEntry | RBS::Environment::ModuleAliasEntry) -> void
 
       def validate_alias: () -> void
 

data/sig/steep/type_construction.rbs

@@ -80,7 +80,7 @@ module Steep
 
     def with_method_constr: (untyped method_name, untyped node, args: untyped, self_type: untyped, definition: untyped) { (untyped) -> untyped } -> untyped
 
-    def implement_module: (module_name: untyped, annotations: untyped, ?super_name: untyped?) -> untyped
+    def implement_module: (module_name: RBS::TypeName, annotations: AST::Annotation::Collection, ?super_name: RBS::TypeName?) -> AST::Annotation::Implements::Module?
 
     def default_module_context: (untyped implement_module_name, nesting: untyped) -> untyped
 

data/sig/steep/type_inference/constant_env.rbs

@@ -21,6 +21,8 @@ module Steep
 
       def children: (RBS::TypeName module_name) -> Hash[Symbol, constant_tuple]
 
+      def decompose_constant!: (RBS::Constant? constant) -> constant_tuple
+
       def decompose_constant: (RBS::Constant? constant) -> constant_tuple?
     end
   end

data/smoke/diagnostics-rbs/test_expectations.yml

@@ -54,7 +54,7 @@
         character: 22
       end:
         line: 1
-        character: -1
+        character: 28
     severity: ERROR
     message: Cannot inherit from a module `::Kernel`
     code: RBS::InheritModuleError