steep 0.16.3 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b1c04c7f20a2ed355b58570363447b3e8f2bd1710407de1e23c7b9fbe279cb8
-  data.tar.gz: 62101db41144f3fd218ee8478ab377f3414ad1d8a7689ac73356aa28bf7f6842
+  metadata.gz: 566e77aa4db03cb06ae80569f4db9f5409e65199b1af4af9fc6f2598e911f694
+  data.tar.gz: 41f1d54c5196fdec7cc58751899aec208066d845eef717234bb37266313c7d8d
 SHA512:
-  metadata.gz: d8ac130b1adb7755709f4b1590939b442d6d4b4aa5ea38a95423db539a1b52b0c4078abf1a543b92a84477d99846d5ab30060dc26c693f52785de0c205041a2d
-  data.tar.gz: e7ccec14707e49d51b88429ab0922c4e6fbbc190bbafb0e107c30ea681b04415245e40708909fd28458a89a565a816fd88a6bfa1c14b76e24185a2ece153148c
+  metadata.gz: 46366ed11a6328a6a237c52042ef49eb12d5ce3db111fb55c5038109b62aa471ba6634c8c060575f6862658dcc0f388684a083f9a691becd6d90f076acb05908
+  data.tar.gz: 9cb15861e6de6b5209dd82745f1c7cf67c212e3e15cc9c1f92956b84089801f994c7c1cd79ff8972f37da229530e7354d237ce4a74ce844083daf656936286dc

data/.github/workflows/ruby.yml

@@ -14,6 +14,10 @@ jobs:
         container_tag:
         - 2.6.5-bionic
         - 2.7.0-bionic
+        task:
+        - test
+        - smoke
+        - build
     container:
       image: rubylang/ruby:${{ matrix.container_tag }}
     steps:
@@ -24,4 +28,4 @@ jobs:
         gem install bundler
         bundle install --jobs 4 --retry 3
         bin/setup
-        bundle exec rake build test smoke
+        bundle exec rake ${{matrix.task}}

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## master
 
+## 0.20.0 (2020-07-17)
+
+* Support singleton class definitions ([#166](https://github.com/soutaro/steep/pull/166))
+
+## 0.19.0 (2020-07-12)
+
+* Update RBS. ([#157](https://github.com/soutaro/steep/pull/157))
+* No `initialize` in completion. ([#164](https://github.com/soutaro/steep/pull/164))
+* Granular typing option setup. ([#163](https://github.com/soutaro/steep/pull/163))
+
+## 0.18.0 (2020-07-06)
+
+* Sort result of `Pathname#glob` ([#154](https://github.com/soutaro/steep/pull/154))
+* Sort methods in LanguageServer to return non-inherited methods first ([#159](https://github.com/soutaro/steep/pull/159))
+
+## 0.17.1 (2020-06-15)
+
+* Allow RBS gem to be 0.4 ([#153](https://github.com/soutaro/steep/pull/153))
+
+## 0.17.0 (2020-06-13)
+
+* Fix `steep watch` and `steep langserver` to correctly handle error message filterings based on options ([#152](https://github.com/soutaro/steep/pull/152))
+* Fix typing of collections ([#151](https://github.com/soutaro/steep/pull/151))
+
 ## 0.16.3
 
 * Fix `steep watch` ([#147](https://github.com/soutaro/steep/pull/147))

data/lib/steep.rb

@@ -12,6 +12,7 @@ require 'language_server-protocol'
 require "etc"
 require "open3"
 require "stringio"
+require 'uri'
 
 require "rbs"
 

data/lib/steep/ast/types/factory.rb

@@ -8,6 +8,10 @@ module Steep
           @definition_builder = builder
         end
 
+        def type_name_resolver
+          @type_name_resolver ||= RBS::TypeNameResolver.from_env(definition_builder.env)
+        end
+
         def type(type)
           case type
           when RBS::Types::Bases::Any
@@ -277,8 +281,7 @@ module Steep
 
         def unfold(type_name)
           type_name_1(type_name).yield_self do |type_name|
-            decl = definition_builder.env.find_alias(type_name) or raise "Unknown type name: #{type_name}"
-            type(definition_builder.env.absolute_type(decl.type, namespace: type_name.namespace))
+            type(definition_builder.expand_alias(type_name))
           end
         end
 
@@ -331,7 +334,7 @@ module Steep
                   method.method_types.map do |type|
                     method_type(type, self_type: self_type) {|ty| ty.subst(subst) }
                   end,
-                  incompatible: method.attributes.include?(:incompatible)
+                  incompatible: name == :initialize || name == :new
                 )
               end
             end
@@ -339,8 +342,7 @@ module Steep
           when Name::Interface
             Interface::Interface.new(type: self_type, private: private).tap do |interface|
               type_name = type_name_1(type.name)
-              decl = definition_builder.env.find_class(type_name) or raise "Unknown class: #{type_name}"
-              definition = definition_builder.build_interface(type_name, decl)
+              definition = definition_builder.build_interface(type_name)
 
               subst = Interface::Substitution.build(
                 definition.type_params,
@@ -363,7 +365,7 @@ module Steep
               definition = definition_builder.build_singleton(type_name_1(type.name))
 
               instance_type = Name::Instance.new(name: type.name,
-                                                 args: definition.declaration.type_params.each.map {Any.new(location: nil)},
+                                                 args: definition.type_params.map {Any.new(location: nil)},
                                                  location: nil)
               subst = Interface::Substitution.build(
                 [],
@@ -543,12 +545,12 @@ module Steep
 
         def module_name?(type_name)
           name = type_name_1(type_name)
-          env.class?(name) && env.find_class(name).is_a?(RBS::AST::Declarations::Module)
+          entry = env.class_decls[name] and entry.is_a?(RBS::Environment::ModuleEntry)
         end
 
         def class_name?(type_name)
           name = type_name_1(type_name)
-          env.class?(name) && env.find_class(name).is_a?(RBS::AST::Declarations::Class)
+          entry = env.class_decls[name] and entry.is_a?(RBS::Environment::ClassEntry)
         end
 
         def env
@@ -556,13 +558,14 @@ module Steep
         end
 
         def absolute_type(type, namespace:)
-          type(env.absolute_type(type_1(type),
-                                 namespace: namespace_1(namespace)) {|type| type.name.absolute! })
+          absolute_type = type_1(type).map_type_name do |name|
+            absolute_type_name(name, namespace: namespace) || name.absolute!
+          end
+          type(absolute_type)
         end
 
         def absolute_type_name(type_name, namespace:)
-          type(env.absolute_type_name(type_name_1(type_name),
-                                      namespace: namespace_1(namespace)) {|name| name.absolute! })
+          type_name_resolver.resolve(type_name, context: namespace_1(namespace).ascend)
         end
       end
     end

data/lib/steep/drivers/check.rb

@@ -53,18 +53,7 @@ module Steep
               status.type_check_sources.each do |source_file|
                 case source_file.status
                 when Project::SourceFile::TypeCheckStatus
-                  source_file.errors.reject do |error|
-                    case
-                    when error.is_a?(Errors::FallbackAny)
-                      target.options.allow_fallback_any
-                    when error.is_a?(Errors::MethodDefinitionMissing)
-                      target.options.allow_missing_definitions
-                    when error.is_a?(Errors::NoMethod)
-                      target.options.allow_unknown_method_calls
-                    when error.is_a?(Errors::UnknownConstantAssigned)
-                      target.options.allow_unknown_constant_assignment
-                    end
-                  end.each do |error|
+                  source_file.errors.select {|error| target.options.error_to_report?(error) }.each do |error|
                     error.print_to stdout
                   end
                 when Project::SourceFile::TypeCheckErrorStatus

data/lib/steep/project/completion_provider.rb

@@ -10,7 +10,15 @@ module Steep
 
       InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
       LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
-      MethodNameItem = Struct.new(:identifier, :range, :definition, :method_type, keyword_init: true)
+      MethodNameItem = Struct.new(:identifier, :range, :definition, :def_type, :inherited_method, keyword_init: true) do
+        def method_type
+          def_type.type
+        end
+
+        def comment
+          def_type.comment
+        end
+      end
 
       attr_reader :source_text
       attr_reader :path
@@ -231,20 +239,22 @@ module Steep
                        subtyping.factory.definition_builder.build_singleton(type_name)
                      when AST::Types::Name::Interface
                        type_name = subtyping.factory.type_name_1(type.name)
-                       interface = subtyping.factory.env.find_class(type_name)
-                       subtyping.factory.definition_builder.build_interface(type_name, interface)
+                       subtyping.factory.definition_builder.build_interface(type_name)
                      end
 
         if definition
           definition.methods.each do |name, method|
+            next if disallowed_method?(name)
+
             if include_private || method.public?
               if name.to_s.start_with?(prefix)
                 if word_name?(name.to_s)
-                  method.method_types.each do |method_type|
+                  method.defs.each do |def_type|
                     items << MethodNameItem.new(identifier: name,
                                                 range: range,
                                                 definition: method,
-                                                method_type: method_type)
+                                                def_type: def_type,
+                                                inherited_method: inherited_method?(method, definition))
                   end
                 end
               end
@@ -293,6 +303,17 @@ module Steep
 
         index
       end
+
+      def inherited_method?(method, definition)
+        method.implemented_in != definition.type_name
+      end
+
+      def disallowed_method?(name)
+        # initialize isn't invoked by developers when creating
+        # instances of new classes, so don't show it as
+        # an LSP option
+        name == :initialize
+      end
     end
   end
 end

data/lib/steep/project/dsl.rb

@@ -10,6 +10,7 @@ module Steep
         attr_reader :no_builtin
         attr_reader :vendor_dir
         attr_reader :strictness_level
+        attr_reader :typing_option_hash
 
         def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [])
           @name = name
@@ -19,6 +20,7 @@ module Steep
           @ignored_sources = ignored_sources
           @vendor_dir = nil
           @strictness_level = :default
+          @typing_option_hash = {}
         end
 
         def initialize_copy(other)
@@ -29,6 +31,7 @@ module Steep
           @ignored_sources = other.ignored_sources.dup
           @vendor_dir = other.vendor_dir
           @strictness_level = other.strictness_level
+          @typing_option_hash = other.typing_option_hash
         end
 
         def check(*args)
@@ -43,8 +46,9 @@ module Steep
           libraries.push(*args)
         end
 
-        def typing_options(level)
+        def typing_options(level = @strictness_level, **hash)
           @strictness_level = level
+          @typing_option_hash = hash
         end
 
         def signature(*args)
@@ -128,6 +132,8 @@ module Steep
               options.apply_lenient_typing_options!
             end
 
+            options.merge!(target.typing_option_hash)
+
             case target.vendor_dir
             when Array
               options.vendored_stdlib_path = target.vendor_dir[0]

data/lib/steep/project/file.rb

@@ -95,6 +95,13 @@ module Steep
             source: source,
             timestamp: Time.now
           )
+        rescue RBS::NoTypeFoundError,
+          RBS::NoMixinFoundError,
+          RBS::NoSuperclassFoundError,
+          RBS::DuplicatedMethodDefinitionError,
+          RBS::InvalidTypeApplicationError => exn
+          # Skip logging known signature errors (they are handled with load_signatures(validate: true))
+          @status = TypeCheckErrorStatus.new(error: exn)
         rescue => exn
           Steep.log_error(exn)
           @status = TypeCheckErrorStatus.new(error: exn)

data/lib/steep/project/file_loader.rb

@@ -20,7 +20,7 @@ module Steep
                       Pathname.glob(absolute_path)
                     end
 
-            files.each do |source_path|
+            files.sort.each do |source_path|
               yield project.relative_path(source_path)
             end
           end

data/lib/steep/project/hover_content.rb

@@ -4,7 +4,13 @@ module Steep
       TypeContent = Struct.new(:node, :type, :location, keyword_init: true)
       VariableContent = Struct.new(:node, :name, :type, :location, keyword_init: true)
       MethodCallContent = Struct.new(:node, :method_name, :type, :definition, :location, keyword_init: true)
-      DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
+      DefinitionContent = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true) do
+        def comment_string
+          if comments = definition&.comments
+            comments.map {|c| c.string.chomp }.uniq.join("\n----\n")
+          end
+        end
+      end
 
       InstanceMethodName = Struct.new(:class_name, :method_name)
       SingletonMethodName = Struct.new(:class_name, :method_name)
@@ -80,7 +86,7 @@ module Steep
                                           when AST::Types::Name::Instance
                                             method_definition = method_definition_for(factory, receiver_type.name, instance_method: method_name)
                                             if method_definition&.defined_in
-                                              owner_name = factory.type_name(method_definition.defined_in.name.absolute!)
+                                              owner_name = factory.type_name(method_definition.defined_in)
                                               [
                                                 InstanceMethodName.new(owner_name, method_name),
                                                 method_definition
@@ -89,7 +95,7 @@ module Steep
                                           when AST::Types::Name::Class
                                             method_definition = method_definition_for(factory, receiver_type.name, singleton_method: method_name)
                                             if method_definition&.defined_in
-                                              owner_name = factory.type_name(method_definition.defined_in.name.absolute!)
+                                              owner_name = factory.type_name(method_definition.defined_in)
                                               [
                                                 SingletonMethodName.new(owner_name, method_name),
                                                 method_definition

data/lib/steep/project/options.rb

@@ -37,6 +37,28 @@ module Steep
         self.allow_unknown_constant_assignment = true
         self.allow_unknown_method_calls = true
       end
+
+      def error_to_report?(error)
+        case
+        when error.is_a?(Errors::FallbackAny)
+          !allow_fallback_any
+        when error.is_a?(Errors::MethodDefinitionMissing)
+          !allow_missing_definitions
+        when error.is_a?(Errors::NoMethod)
+          !allow_unknown_method_calls
+        when error.is_a?(Errors::UnknownConstantAssigned)
+          !allow_unknown_constant_assignment
+        else
+          true
+        end
+      end
+
+      def merge!(hash)
+        self.allow_fallback_any = hash[:allow_fallback_any] if hash.key?(:allow_fallback_any)
+        self.allow_missing_definitions = hash[:allow_missing_definitions] if hash.key?(:allow_missing_definitions)
+        self.allow_unknown_constant_assignment = hash[:allow_unknown_constant_assignment] if hash.key?(:allow_unknown_constant_assignment)
+        self.allow_unknown_method_calls = hash[:allow_unknown_method_calls] if hash.key?(:allow_unknown_method_calls)
+      end
     end
   end
 end

data/lib/steep/project/target.rb

@@ -15,6 +15,7 @@ module Steep
 
       SignatureSyntaxErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
       SignatureValidationErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
+      SignatureOtherErrorStatus = Struct.new(:timestamp, :error, keyword_init: true)
       TypeCheckStatus = Struct.new(:environment, :subtyping, :type_check_sources, :timestamp, keyword_init: true)
 
       def initialize(name:, options:, source_patterns:, ignore_patterns:, signature_patterns:)
@@ -95,7 +96,7 @@ module Steep
       end
 
       def environment
-        @environment ||= RBS::Environment.new().tap do |env|
+        @environment ||= RBS::Environment.new().yield_self do |env|
           stdlib_root = options.vendored_stdlib_path || RBS::EnvironmentLoader::STDLIB_ROOT
           gem_vendor_path = options.vendored_gems_path
           loader = RBS::EnvironmentLoader.new(stdlib_root: stdlib_root, gem_vendor_path: gem_vendor_path)
@@ -103,6 +104,8 @@ module Steep
             loader.add(library: lib)
           end
           loader.load(env: env)
+
+          env.resolve_type_names
         end
       end
 
@@ -125,34 +128,40 @@ module Steep
           if status.is_a?(TypeCheckStatus) && updated_files.empty?
             yield status.environment, status.subtyping, status.timestamp
           else
-            env = environment.dup
-
-            signature_files.each_value do |file|
-              if file.status.is_a?(SignatureFile::DeclarationsStatus)
-                file.status.declarations.each do |decl|
-                  env << decl
+            begin
+              env = environment.dup
+
+              signature_files.each_value do |file|
+                if file.status.is_a?(SignatureFile::DeclarationsStatus)
+                  file.status.declarations.each do |decl|
+                    env << decl
+                  end
                 end
               end
-            end
 
-            definition_builder = RBS::DefinitionBuilder.new(env: env)
-            factory = AST::Types::Factory.new(builder: definition_builder)
-            check = Subtyping::Check.new(factory: factory)
+              env = env.resolve_type_names
 
-            if validate
-              validator = Signature::Validator.new(checker: check)
-              validator.validate()
+              definition_builder = RBS::DefinitionBuilder.new(env: env)
+              factory = AST::Types::Factory.new(builder: definition_builder)
+              check = Subtyping::Check.new(factory: factory)
 
-              if validator.no_error?
-                yield env, check, Time.now
+              if validate
+                validator = Signature::Validator.new(checker: check)
+                validator.validate()
+
+                if validator.no_error?
+                  yield env, check, Time.now
+                else
+                  @status = SignatureValidationErrorStatus.new(
+                    errors: validator.each_error.to_a,
+                    timestamp: Time.now
+                  )
+                end
               else
-                @status = SignatureValidationErrorStatus.new(
-                  errors: validator.each_error.to_a,
-                  timestamp: Time.now
-                )
+                yield env, check, Time.now
               end
-            else
-              yield env, check, Time.now
+            rescue => exn
+              @status = SignatureOtherErrorStatus.new(error: exn, timestamp: Time.now)
             end
           end
 

data/lib/steep/server/code_worker.rb

@@ -47,7 +47,7 @@ module Steep
 
         Steep.logger.info "Finished type checking: #{path}@#{target.name}"
 
-        diagnostics = source_diagnostics(source)
+        diagnostics = source_diagnostics(source, target.options)
 
         writer.write(
           method: :"textDocument/publishDiagnostics",
@@ -58,7 +58,7 @@ module Steep
         )
       end
 
-      def source_diagnostics(source)
+      def source_diagnostics(source, options)
         case status = source.status
         when Project::SourceFile::ParseErrorStatus
           []
@@ -80,7 +80,7 @@ module Steep
             )
           ]
         when Project::SourceFile::TypeCheckStatus
-          status.typing.errors.map do |error|
+          status.typing.errors.select {|error| options.error_to_report?(error) }.map do |error|
             loc = error.location_to_str
 
             LSP::Interface::Diagnostic.new(

data/lib/steep/server/interaction_worker.rb

@@ -110,7 +110,7 @@ HOVER
 def #{content.method_name}: #{content.method_type}
 ```
 HOVER
-          if (comment = content.definition.comment)
+          if (comment = content.comment_string)
             string << "\n----\n\n#{comment.string}\n"
           end
 
@@ -190,8 +190,9 @@ HOVER
               new_text: "#{item.identifier}#{method_type_snippet}",
               range: range
             ),
-            documentation: item.definition.comment&.string,
-            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+            documentation: item.comment&.string,
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET,
+            sort_text: item.inherited_method ? 'z' : 'a' # Ensure language server puts non-inherited methods before inherited methods
           )
         when Project::CompletionProvider::InstanceVariableItem
           label = "#{item.identifier}: #{item.type}"

data/lib/steep/server/signature_worker.rb

@@ -114,6 +114,7 @@ module Steep
                         end
                       else
                         Steep.logger.info "Unexpected target status: #{status.class}"
+                        {}
                       end
 
         diagnostics.each do |path, diags|

data/lib/steep/signature/validator.rb

@@ -35,6 +35,14 @@ module Steep
         checker.factory.definition_builder
       end
 
+      def type_name_resolver
+        @type_name_resolver ||= RBS::TypeNameResolver.from_env(env)
+      end
+
+      def validator
+        @validator ||= RBS::Validator.new(env: env, resolver: type_name_resolver)
+      end
+
       def factory
         checker.factory
       end
@@ -47,57 +55,69 @@ module Steep
         validate_global
       end
 
-      def validate_one_decl(name, decl)
-        case decl
-        when Declarations::Class
-          rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating class definition `#{name}`..."
-            builder.build_instance(decl.name.absolute!).each_type do |type|
-              env.validate type, namespace: RBS::Namespace.root
+      def validate_type(type)
+        Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
+        validator.validate_type type, context: [RBS::Namespace.root]
+      end
+
+      def validate_one_class(name)
+        rescue_validation_errors do
+          Steep.logger.debug "Validating class definition `#{name}`..."
+          Steep.logger.tagged "#{name}" do
+            builder.build_instance(name).each_type do |type|
+              validate_type type
             end
-            builder.build_singleton(decl.name.absolute!).each_type do |type|
-              env.validate type, namespace: RBS::Namespace.root
+            builder.build_singleton(name).each_type do |type|
+              validate_type type
             end
           end
-        when Declarations::Interface
-          rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating interface `#{name}`..."
-            builder.build_interface(decl.name.absolute!, decl).each_type do |type|
-              env.validate type, namespace: RBS::Namespace.root
+        end
+      end
+
+      def validate_one_interface(name)
+        rescue_validation_errors do
+          Steep.logger.debug "Validating interface `#{name}`..."
+          Steep.logger.tagged "#{name}" do
+            builder.build_interface(name).each_type do |type|
+              validate_type type
             end
           end
         end
       end
 
       def validate_decl
-        env.each_decl do |name, decl|
-          validate_one_decl name, decl
+        env.class_decls.each_key do |name|
+          validate_one_class(name)
+        end
+
+        env.interface_decls.each_key do |name|
+          validate_one_interface(name)
         end
       end
 
       def validate_const
-        env.each_constant do |name, decl|
+        env.constant_decls.each do |name, entry|
           rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating constant `#{name}`..."
-            env.validate(decl.type, namespace: name.namespace)
+            Steep.logger.debug "Validating constant `#{name}`..."
+            validate_type entry.decl.type
           end
         end
       end
 
       def validate_global
-        env.each_global do |name, decl|
+        env.global_decls.each do |name, entry|
           rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating global `#{name}`..."
-            env.validate(decl.type, namespace: RBS::Namespace.root)
+            Steep.logger.debug "Validating global `#{name}`..."
+            validate_type entry.decl.type
           end
         end
       end
 
       def validate_alias
-        env.each_alias do |name, decl|
+        env.alias_decls.each do |name, entry|
           rescue_validation_errors do
-            Steep.logger.debug "#{Location.to_string decl.location}:\tValidating alias `#{name}`..."
-            env.validate(decl.type, namespace: name.namespace)
+            Steep.logger.debug "Validating alias `#{name}`..."
+            validate_type(entry.decl.type)
           end
         end
       end
@@ -108,10 +128,10 @@ module Steep
         @errors << Errors::InvalidTypeApplicationError.new(
           name: factory.type_name(exn.type_name),
           args: exn.args.map {|ty| factory.type(ty) },
-          params: exn.params.each.map(&:name),
+          params: exn.params,
           location: exn.location
         )
-      rescue RBS::NoTypeFoundError => exn
+      rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => exn
         @errors << Errors::UnknownTypeNameError.new(
           name: factory.type_name(exn.type_name),
           location: exn.location

data/lib/steep/type_construction.rb

@@ -37,7 +37,6 @@ module Steep
     attr_reader :source
     attr_reader :annotations
     attr_reader :typing
-    attr_reader :type_env
 
     attr_reader :context
 
@@ -169,7 +168,7 @@ module Steep
 
       super_method = if definition
                        if (this_method = definition.methods[method_name])
-                         if module_context&.class_name == checker.factory.type_name(this_method.defined_in.name.absolute!)
+                         if module_context&.class_name == checker.factory.type_name(this_method.defined_in)
                            this_method.super_method
                          else
                            this_method
@@ -231,6 +230,39 @@ module Steep
       )
     end
 
+    def implement_module(module_name:, super_name: nil, annotations:)
+      if (annotation = annotations.implement_module_annotation)
+        absolute_name(annotation.name.name).yield_self do |absolute_name|
+          if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+            AST::Annotation::Implements::Module.new(
+              name: absolute_name,
+              args: annotation.name.args
+            )
+          else
+            Steep.logger.error "Unknown class name given to @implements: #{annotation.name.name}"
+            nil
+          end
+        end
+      else
+        name = nil
+        name ||= absolute_name(module_name).yield_self do |absolute_name|
+          absolute_name if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+        end
+        name ||= super_name && absolute_name(super_name).yield_self do |absolute_name|
+          absolute_name if checker.factory.class_name?(absolute_name) || checker.factory.module_name?(absolute_name)
+        end
+
+        if name
+          absolute_name_ = checker.factory.type_name_1(name)
+          entry = checker.factory.env.class_decls[absolute_name_]
+          AST::Annotation::Implements::Module.new(
+            name: name,
+            args: entry.type_params.each.map(&:name)
+          )
+        end
+      end
+    end
+
     def for_module(node)
       new_module_name = Names::Module.from_node(node.children.first) or raise "Unexpected module name: #{node.children.first}"
       new_namespace = nested_namespace_for_module(new_module_name)
@@ -241,35 +273,14 @@ module Steep
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
       module_type = AST::Builtin::Module.instance_type
 
-      implement_module_name = yield_self do
-        if (annotation = annots.implement_module_annotation)
-          absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.factory.module_name?(absolute_name)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: annotation.name.args)
-            else
-              Steep.logger.error "Unknown module name given to @implements: #{annotation.name.name}"
-              nil
-            end
-          end
-        else
-          absolute_name(new_module_name).yield_self do |absolute_name|
-            if checker.factory.module_name?(absolute_name)
-              absolute_name_ = checker.factory.type_name_1(absolute_name)
-              decl = checker.factory.env.find_class(absolute_name_)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: decl.type_params.each.map(&:name))
-            end
-          end
-        end
-      end
+      implement_module_name = implement_module(module_name: new_module_name, annotations: annots)
 
       if implement_module_name
         module_name = implement_module_name.name
         module_args = implement_module_name.args.map {|x| AST::Types::Var.new(name: x)}
 
         type_name_ = checker.factory.type_name_1(implement_module_name.name)
-        module_decl = checker.factory.definition_builder.env.find_class(type_name_)
+        module_entry = checker.factory.definition_builder.env.class_decls[type_name_]
         instance_def = checker.factory.definition_builder.build_instance(type_name_)
         module_def = checker.factory.definition_builder.build_singleton(type_name_)
 
@@ -277,9 +288,22 @@ module Steep
           types: [
             AST::Types::Name::Instance.new(name: module_name, args: module_args),
             AST::Builtin::Object.instance_type,
-            module_decl.self_type&.yield_self {|ty|
-              absolute_type = checker.factory.env.absolute_type(ty, namespace: module_decl.name.absolute!.namespace)
-              checker.factory.type(absolute_type)
+            *module_entry.self_types.map {|module_self|
+              type = case
+                     when module_self.name.interface?
+                       RBS::Types::Interface.new(
+                         name: module_self.name,
+                         args: module_self.args,
+                         location: module_self.location
+                       )
+                     when module_self.name.class?
+                       RBS::Types::ClassInstance.new(
+                         name: module_self.name,
+                         args: module_self.args,
+                         location: module_self.location
+                       )
+                     end
+              checker.factory.type(type)
             }
           ].compact
         )
@@ -340,34 +364,7 @@ module Steep
 
       annots = source.annotations(block: node, factory: checker.factory, current_module: new_namespace)
 
-      implement_module_name = yield_self do
-        if (annotation = annots.implement_module_annotation)
-          absolute_name(annotation.name.name).yield_self do |absolute_name|
-            if checker.factory.class_name?(absolute_name)
-              AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: annotation.name.args)
-            else
-              Steep.logger.error "Unknown class name given to @implements: #{annotation.name.name}"
-              nil
-            end
-          end
-        else
-          name = nil
-          name ||= absolute_name(new_class_name).yield_self do |absolute_name|
-            absolute_name if checker.factory.class_name?(absolute_name)
-          end
-          name ||= super_class_name && absolute_name(super_class_name).yield_self do |absolute_name|
-            absolute_name if checker.factory.class_name?(absolute_name)
-          end
-
-          if name
-            absolute_name_ = checker.factory.type_name_1(name)
-            decl = checker.factory.env.find_class(absolute_name_)
-            AST::Annotation::Implements::Module.new(name: name,
-                                                    args: decl.type_params.each.map(&:name))
-          end
-        end
-      end
+      implement_module_name = implement_module(module_name: new_class_name, super_name: super_class_name, annotations: annots)
 
       if annots.implement_module_annotation
         new_class_name = implement_module_name.name
@@ -436,6 +433,83 @@ module Steep
       )
     end
 
+    def for_sclass(node, type)
+      annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
+
+      instance_type = if type.is_a?(AST::Types::Self)
+                        context.self_type
+                      else
+                        type
+                      end
+
+      module_type = case instance_type
+                    when AST::Types::Name::Class
+                      AST::Builtin::Class.instance_type
+                    when AST::Types::Name::Module
+                      AST::Builtin::Module.instance_type
+                    when AST::Types::Name::Instance
+                      instance_type.to_class(constructor: nil)
+                    else
+                      raise "Unexpected type for sclass node: #{type}"
+                    end
+
+      instance_definition = case instance_type
+                            when AST::Types::Name::Class, AST::Types::Name::Module
+                              type_name = checker.factory.type_name_1(instance_type.name)
+                              checker.factory.definition_builder.build_singleton(type_name)
+                            when AST::Types::Name::Instance
+                              type_name = checker.factory.type_name_1(instance_type.name)
+                              checker.factory.definition_builder.build_instance(type_name)
+                            end
+
+      module_definition = case module_type
+                          when AST::Types::Name::Class, AST::Types::Name::Module
+                            type_name = checker.factory.type_name_1(instance_type.name)
+                            checker.factory.definition_builder.build_singleton(type_name)
+                          else
+                            nil
+                          end
+
+      module_context = TypeInference::Context::ModuleContext.new(
+        instance_type: annots.instance_type || instance_type,
+        module_type: annots.self_type || annots.module_type || module_type,
+        implement_name: nil,
+        current_namespace: current_namespace,
+        const_env: self.module_context.const_env,
+        class_name: self.module_context.class_name,
+        module_definition: module_definition,
+        instance_definition: instance_definition
+      )
+
+      type_env = TypeInference::TypeEnv.build(annotations: annots,
+                                              subtyping: checker,
+                                              const_env: self.module_context.const_env,
+                                              signatures: checker.factory.env)
+
+      lvar_env = TypeInference::LocalVariableTypeEnv.empty(
+        subtyping: checker,
+        self_type: module_context.module_type
+      ).annotate(annots)
+
+      body_context = TypeInference::Context.new(
+        method_context: nil,
+        block_context: nil,
+        module_context: module_context,
+        break_context: nil,
+        self_type: module_context.module_type,
+        type_env: type_env,
+        lvar_env: lvar_env
+      )
+
+      self.class.new(
+        checker: checker,
+        source: source,
+        annotations: annots,
+        typing: typing,
+        context: body_context
+      )
+    end
+
     def for_branch(node, truthy_vars: Set.new, type_case_override: nil, break_context: context.break_context)
       annots = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
 
@@ -565,6 +639,7 @@ module Steep
               add_typing(node, type: AST::Builtin.any_type)
             else
               rhs_result = synthesize(rhs, hint: hint || context.lvar_env.declared_types[name]&.type)
+
               constr = rhs_result.constr.update_lvar_env do |lvar_env|
                 lvar_env.assign(name, node: node, type: rhs_result.type) do |declared_type, actual_type, result|
                   typing.add_error(Errors::IncompatibleAssignment.new(node: node,
@@ -1037,10 +1112,10 @@ module Steep
               case child.type
               when :pair
                 key, value = child.children
-                key_types << synthesize(key).type.yield_self do |type|
+                key_types << synthesize(key, hint: key_hint).type.yield_self do |type|
                   select_super_type(type, key_hint)
                 end
-                value_types << synthesize(value).type.yield_self do |type|
+                value_types << synthesize(value, hint: value_hint).type.yield_self do |type|
                   select_super_type(type, value_hint)
                 end
               when :kwsplat
@@ -1115,6 +1190,25 @@ module Steep
             add_typing(node, type: AST::Builtin.nil_type)
           end
 
+        when :sclass
+          yield_self do
+            type, constr = synthesize(node.children[0])
+            constructor = constr.for_sclass(node, type)
+
+            constructor.typing.add_context_for_node(node, context: constructor.context)
+            constructor.typing.add_context_for_body(node, context: constructor.context)
+
+            constructor.synthesize(node.children[1]) if node.children[1]
+
+            if constructor.module_context.instance_definition && module_context.module_definition
+              if constructor.module_context.instance_definition.type_name == module_context.module_definition.type_name
+                module_context.defined_module_methods.merge(constructor.module_context.defined_instance_methods)
+              end
+            end
+
+            add_typing(node, type: AST::Builtin.nil_type)
+          end
+
         when :self
           add_typing node, type: AST::Types::Self.new
 
@@ -1256,7 +1350,7 @@ module Steep
                       end
                     end
                   else
-                    [select_super_type(synthesize(e).type, element_hint)]
+                    [select_super_type(synthesize(e, hint: element_hint).type, element_hint)]
                   end
                 end
                 array_type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: element_types))
@@ -1992,9 +2086,11 @@ module Steep
                      end
                    end
                  rescue => exn
-                   $stderr.puts exn.inspect
-                   exn.backtrace.each do |t|
-                     $stderr.puts t
+                   case exn
+                   when RBS::NoTypeFoundError, RBS::NoMixinFoundError, RBS::NoSuperclassFoundError, RBS::InvalidTypeApplicationError
+                     # ignore known RBS errors.
+                   else
+                     Steep.log_error(exn, message: "Unexpected error in #type_send: #{exn.message} (#{exn.class})")
                    end
 
                    fallback_to_any node do
@@ -2750,13 +2846,18 @@ module Steep
     end
 
     def validate_method_definitions(node, module_name)
+      module_name_1 = checker.factory.type_name_1(module_name.name)
+      member_decl_count = checker.factory.env.class_decls[module_name_1].decls.count {|d| d.decl.each_member.count > 0 }
+
+      return unless member_decl_count == 1
+
       expected_instance_method_names = (module_context.instance_definition&.methods || {}).each.with_object(Set[]) do |(name, method), set|
-        if method.implemented_in == module_context.instance_definition.declaration
+        if method.implemented_in == module_context.instance_definition.type_name
           set << name
         end
       end
       expected_module_method_names = (module_context.module_definition&.methods || {}).each.with_object(Set[]) do |(name, method), set|
-        if method.implemented_in == module_context.module_definition.declaration
+        if method.implemented_in == module_context.module_definition.type_name
           set << name
         end
       end
@@ -2948,7 +3049,7 @@ module Steep
     def to_instance_type(type, args: nil)
       args = args || case type
                      when AST::Types::Name::Class, AST::Types::Name::Module
-                       checker.factory.env.find_class(checker.factory.type_name_1(type.name)).type_params.each.map { AST::Builtin.any_type }
+                       checker.factory.env.class_decls[checker.factory.type_name_1(type.name)].type_params.each.map { AST::Builtin.any_type }
                      else
                        raise "unexpected type to to_instance_type: #{type}"
                      end

data/lib/steep/type_inference/type_env.rb

@@ -31,8 +31,8 @@ module Steep
           annotations.const_types.each do |name, type|
             env.set(const: name, type: type)
           end
-          signatures.name_to_global.each do |name, global|
-            type = signatures.absolute_type(global.type, namespace: RBS::Namespace.root) {|ty| ty.name.absolute! }
+          signatures.global_decls.each do |name, entry|
+            type = entry.decl.type
             env.set(gvar: name, type: subtyping.factory.type(type))
           end
         end

data/lib/steep/typing.rb

@@ -95,6 +95,12 @@ module Steep
         end_pos = node.loc.end.begin_pos
         add_context(begin_pos..end_pos, context: context)
 
+      when :sclass
+        name_node = node.children[0]
+        begin_pos = name_node.loc.expression.end_pos
+        end_pos = node.loc.end.begin_pos
+        add_context(begin_pos..end_pos, context: context)
+
       when :def, :defs
         args_node = case node.type
                     when :def

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.16.3"
+  VERSION = "0.20.0"
 end

data/smoke/extension/a.rbs

@@ -1,9 +1,10 @@
-extension Object (X)
+
+class Object
   def try: [A] { (instance) -> A } -> A
   def f: -> Object
 end
 
-extension Kernel (X)
+module Kernel
   def new_module_method: () -> void
 end
 

data/smoke/extension/e.rbs

@@ -2,7 +2,6 @@ class NumberLike
   def to_number: -> Integer
 end
 
-extension Integer (NumberLike)
-  def `+`: (NumberLike) -> NumberLike
-         | super
+class Integer
+  overload def `+`: (NumberLike) -> NumberLike
 end

data/smoke/interface/a.rbs

@@ -1,12 +1,12 @@
 class A
   def foo: -> _Foo
   def hello: -> void
-end
 
-class A::Object
-  def object?: -> bool
-end
+  class Object
+    def object?: -> bool
+  end
 
-interface A::_Foo
-  def foo: -> Object
+  interface _Foo
+    def foo: -> Object
+  end
 end

data/steep.gemspec

@@ -41,5 +41,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.1"
   spec.add_runtime_dependency "language_server-protocol", "~> 3.14.0.2"
-  spec.add_runtime_dependency "rbs", "~> 0.3.1"
+  spec.add_runtime_dependency "rbs", ">= 0.6.0", '< 0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.16.3
+  version: 0.20.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-27 00:00:00.000000000 Z
+date: 2020-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -188,16 +188,22 @@ dependencies:
   name: rbs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.7.0
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com