steep 0.17.1 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1ad7c49806193ddc567206eff7d74ad184bf6e339f15f5a06b54eac2a44798d
-  data.tar.gz: 7738b5ccd9339e7de6643e8d87b8e3eaf7a0f36a42a4667848ea29cc3637d34a
+  metadata.gz: 1008a3723d59bab0d00afb4b385ee2752d8679461416eba84e48cc9ae479b0a4
+  data.tar.gz: 58c470fe9d8c619d9d0767a392ab6557b6dc50b007c6c99ff6ad27a79a88ecd4
 SHA512:
-  metadata.gz: 68c6694af012124101dbf7d345fd4cab56582968a58cb462c4336558547089a403604606991585d12c5165b2955002f5905fe6b75788e7bab677cb9b6229f1ec
-  data.tar.gz: 25437e503f4630e92b9fa7cdb31701ae809209f8e300812736a6acacdd181882fd380d277dd672334ae88698198c5ea4a2e0d7d83761614d75db86cf49d9d49e
+  metadata.gz: 6f1074ca3634f9df53f361f78a4838912cb7420918f72afdb08e49ab9d64bbe97177780a54648526ff3947b36ab2f0fb2fec3fce73ed97ce0b835359c81ff52d
+  data.tar.gz: b1c5b3fb447832fb648a56b4d827592ba0ddd719e384795786e27201a32305ce36a0d93edde61c94a311708599dd7090359bc1f15ae04ef0fa3717bd897cb580

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,33 @@
 
 ## master
 
+## 0.22.0 (2020-08-03)
+
+* Improve signature validation ([#175](https://github.com/soutaro/steep/pull/175), [#177](https://github.com/soutaro/steep/pull/177))
+* Fix boolean literal typing ([#172](https://github.com/soutaro/steep/pull/172))
+* Make exit code success when Steep has unreported type errors ([#171](https://github.com/soutaro/steep/pull/171))
+* Allow `./` prefix for signature pattern ([#170](https://github.com/soutaro/steep/pull/170))
+
+## 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))

data/Gemfile

@@ -5,3 +5,10 @@ gemspec
 
 gem "with_steep_types", path: "test/gems/with_steep_types"
 gem "without_steep_types", path: "test/gems/without_steep_types"
+
+gem "rake"
+gem "minitest", "~> 5.0"
+gem "racc", "~> 1.4"
+gem "minitest-reporters"
+gem "minitest-hooks"
+gem "stackprof"

data/bin/steep-prof

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "stackprof"
+
+mode = (ENV["STEEP_STACKPROF_MODE"] || :wall).to_sym
+out = ENV["STEEP_STACKPROF_OUT"] || "tmp/stackprof-#{mode}-steep.dump"
+
+def exit(*)
+
+end
+
+
+STDERR.puts "Running profiler: mode=#{mode}, out=#{out}"
+StackProf.run(mode: mode, out: out) do
+  load File.join(__dir__, "../exe/steep")
+end

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/ast/types/literal.rb

@@ -49,6 +49,10 @@ module Steep
                     Builtin::String
                   when Symbol
                     Builtin::Symbol
+                  when true
+                    Builtin::TrueClass
+                  when false
+                    Builtin::FalseClass
                   else
                     raise "Unexpected literal type: #{value.inspect}"
                   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:)
@@ -78,6 +79,7 @@ module Steep
       def self.test_pattern(patterns, path, ext:)
         patterns.any? do |pattern|
           p = pattern.end_with?(File::Separator) ? pattern : pattern + File::Separator
+          p.delete_prefix!('./')
           (path.to_s.start_with?(p) && path.extname == ext) || File.fnmatch(pattern, path.to_s)
         end
       end
@@ -95,7 +97,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 +105,8 @@ module Steep
             loader.add(library: lib)
           end
           loader.load(env: env)
+
+          env.resolve_type_names
         end
       end
 
@@ -125,34 +129,50 @@ 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 RBS::DuplicatedDeclarationError => exn
+              @status = SignatureValidationErrorStatus.new(
+                errors: [
+                  Signature::Errors::DuplicatedDefinitionError.new(
+                    name: exn.name,
+                    location: exn.decls[0].location
+                  )
+                ],
+                timestamp: Time.now
+              )
+            rescue => exn
+              @status = SignatureOtherErrorStatus.new(error: exn, timestamp: Time.now)
             end
           end
 
@@ -196,7 +216,7 @@ module Steep
       def errors
         case status
         when TypeCheckStatus
-          source_files.each_value.flat_map(&:errors)
+          source_files.each_value.flat_map(&:errors).select { |error | options.error_to_report?(error) }
         else
           []
         end