steep 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c7d4a0ac0c0bbae681b48b3a435baf1e30f67ed36ae86a9cf6e4546d6e30485
-  data.tar.gz: a22966a8fd94bed71ad1398d2587b7d84cfc8ba157a47da8b7289f2dae51b8d8
+  metadata.gz: a2c1abcf64958fd547dbb336a0489d9e310e71bc66d208a67c6328c1ac09e62b
+  data.tar.gz: eecd4d437442a85356525c31d10697d73f06fd319930371a7f2710b77f3e86a3
 SHA512:
-  metadata.gz: 31b10b5a6ac174dafee25cf2c9baaf725218e7c8e7969437557982dcc9c4c1704f8fb87bdd2a583eb9e538fee06376fe068ba2f8f64a5f18ec55919d3d49f9f4
-  data.tar.gz: 5f3db5481934cba32b3b45a92b2a9e2dc796507b3b99c2bdcc9c1a991b9ee6982dad1f5824c478abc7a483ba8ad17fab13ac48e6e13429daf465f3c025e66a40
+  metadata.gz: 57957103491d678aa843f9155a757d9f903968d272e2d117b659bcb46659ada397cf82db1bf4e54e25f77a5548db32b6ea2da7be0fba6920d033340c44448c19
+  data.tar.gz: 94eeb79af2e1fdab28b5f2c6237e343d9f174d7ff5a65c9d25d3860e042820027c1f4fab8c6571492967c74b37161572b8ab1dea91d8d60d0e7f2c1cbf4c31fe

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,12 @@
 
 ## master
 
+## 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))

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/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, :inherited_method, 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,21 +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,
-                                                inherited_method: inherited_method?(method, type))
+                                                def_type: def_type,
+                                                inherited_method: inherited_method?(method, definition))
                   end
                 end
               end
@@ -295,8 +304,15 @@ module Steep
         index
       end
 
-      def inherited_method?(method, type)
-        method.implemented_in&.name&.name != type.name&.name
+      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

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/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

@@ -52,6 +52,13 @@ module Steep
           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/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,7 +190,7 @@ HOVER
               new_text: "#{item.identifier}#{method_type_snippet}",
               range: range
             ),
-            documentation: item.definition.comment&.string,
+            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
           )

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
@@ -256,9 +255,9 @@ module Steep
           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_)
+              entry = checker.factory.env.class_decls[absolute_name_]
               AST::Annotation::Implements::Module.new(name: absolute_name,
-                                                      args: decl.type_params.each.map(&:name))
+                                                      args: entry.type_params.each.map(&:name))
             end
           end
         end
@@ -269,7 +268,7 @@ module Steep
         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 +276,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
         )
@@ -362,9 +374,11 @@ module Steep
 
           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))
+            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
@@ -565,6 +579,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,
@@ -1992,9 +2007,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 +2767,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 +2970,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/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.18.0"
+  VERSION = "0.19.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", '< 0.5.0'
+  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.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-06 00:00:00.000000000 Z
+date: 2020-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -190,20 +190,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.6.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.6.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.7.0
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -463,7 +463,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Gradual Typing for Ruby