steep 0.17.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f60fa7be29b63a36a6f25cb94138d558d0bbaa652cb40ab5f2a4a24f1a0d58ac
-  data.tar.gz: 83582c3c37c5afefe079a545860e96a8edce020b891755b49f6a1cbdf53cce04
+  metadata.gz: 6109c6ce90265363be0ef33fe06e517577f3e884a6fc20c921f5d716c4916de1
+  data.tar.gz: 1bcba16bfab23e534eb40b7302dd21e43b487ba6441a02d0da403ac4df54d788
 SHA512:
-  metadata.gz: 38e917a0030c6f0f993d6d0bd6bd9e26bb955cdd08609802df87992f7242933f03f3b35311c53fec9e6f74a12cb5d2237c5e03d6461fc56f44d019b8011ed12e
-  data.tar.gz: 5a5fa1b3502b23d3a9e6c1391de6c3313e8309adbbf353589eda27ed356414201ec2c6f6cdceb01b5f2afd8425a777a3d02921e509ba15674295c65f04bbdc0e
+  metadata.gz: b8bffda05cd158a3ce849fca2722fcb0d62de0d6307a88d4fa0d3758a7965aef706bccab3b4a634a3343e2c0bbd1cc87bec8e5f5b31cfa52e19a6d3f2931b5eb
+  data.tar.gz: 57cb080c69a71fb31f52bd4e65e37ca1719f46718b02632d2c5af3ff72c8b34eba56f098831558fd7df18afbdec0fd6802d0fbb326c5cb4086c147ba11b5447f

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.21.0 (2020-07-20)
+
+* Fix LSP hover ([#168](https://github.com/soutaro/steep/pull/168))
+* Nominal subtyping ([#167](https://github.com/soutaro/steep/pull/167))
+
+## 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))

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

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

@@ -95,8 +95,8 @@ module Steep
 ```
 HOVER
             if content.definition
-              if content.definition.comment
-                string << "\n----\n\n#{content.definition.comment.string}"
+              if content.definition.comments
+                string << "\n----\n\n#{content.definition.comments.map(&:string).join("\n\n")}"
               end
 
               string << "\n----\n\n#{content.definition.method_types.map {|x| "- `#{x}`\n" }.join()}"
@@ -110,8 +110,8 @@ HOVER
 def #{content.method_name}: #{content.method_type}
 ```
 HOVER
-          if (comment = content.definition.comment)
-            string << "\n----\n\n#{comment.string}\n"
+          if (comment = content.comment_string)
+            string << "\n----\n\n#{comment}\n"
           end
 
           if content.definition.method_types.size > 1
@@ -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|