steep 0.20.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 566e77aa4db03cb06ae80569f4db9f5409e65199b1af4af9fc6f2598e911f694
-  data.tar.gz: 41f1d54c5196fdec7cc58751899aec208066d845eef717234bb37266313c7d8d
+  metadata.gz: c290301da65ed473b092cd6c2ea39eebe02f566124a1fa32e0f420d290513cbf
+  data.tar.gz: ca4fca20e9f3f0b19c57b98d6cdfce0023aeeff8cd0fcd2ee0fc91346e5e0816
 SHA512:
-  metadata.gz: 46366ed11a6328a6a237c52042ef49eb12d5ce3db111fb55c5038109b62aa471ba6634c8c060575f6862658dcc0f388684a083f9a691becd6d90f076acb05908
-  data.tar.gz: 9cb15861e6de6b5209dd82745f1c7cf67c212e3e15cc9c1f92956b84089801f994c7c1cd79ff8972f37da229530e7354d237ce4a74ce844083daf656936286dc
+  metadata.gz: 76c3b0c76e303bcc558bf20efeebe3ddaa3caef432f5d325261261f6d8431f5bbd36bc44af9a4a4dd6a90f2db30ac35ca044181b25063890c0e68c5499d7792c
+  data.tar.gz: a5fa8fba718f599806d9d0ad62a66c138261469d41694bb39ebafe1b8736ad255e890c55f0e3b4f180f4e0212f0b65b31b5957b5c337cba42d1129b9e935e577

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## master
 
+## 0.25.0 (2020-08-18)
+
+* Improve `op_send` typing ([#186](https://github.com/soutaro/steep/pull/186))
+* Improve `op_asgn` typing ([#189](https://github.com/soutaro/steep/pull/189))
+* Better multi-assignment support ([#183](https://github.com/soutaro/steep/pull/183), [#184](https://github.com/soutaro/steep/pull/184))
+* Support for loop and class variables ([#182](https://github.com/soutaro/steep/pull/182))
+* Fix tuple typing ([#181](https://github.com/soutaro/steep/pull/181))
+
+## 0.24.0 (2020-08-11)
+
+* Update RBS to 0.10 ([#180](https://github.com/soutaro/steep/pull/180))
+
+## 0.23.0 (2020-08-06)
+
+* Fix literal typing with hint ([#179](https://github.com/soutaro/steep/pull/179))
+* Fix literal type subtyping ([#178](https://github.com/soutaro/steep/pull/178))
+
+## 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))
@@ -39,7 +68,7 @@
 
 * Fix constant resolution ([#143](https://github.com/soutaro/steep/pull/143))
 * Fix RBS diagnostics line number in LSP ([#142](https://github.com/soutaro/steep/pull/142))
-* Fix crash caused by hover on `def` in LSP ([#140](https://github.com/soutaro/steep/pull/140)) 
+* Fix crash caused by hover on `def` in LSP ([#140](https://github.com/soutaro/steep/pull/140))
 
 ## 0.16.0 (2020-05-19)
 

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

@@ -288,7 +288,7 @@ module Steep
         def expand_alias(type)
           unfolded = case type
                      when AST::Types::Name::Alias
-                       unfolded = unfold(type.name)
+                       unfold(type.name)
                      else
                        type
                      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/ast/types/union.rb

@@ -29,7 +29,10 @@ module Steep
               type
             end
           end.compact.uniq.yield_self do |tys|
-            if tys.length == 1
+            case tys.length
+            when 0
+              AST::Types::Bot.new
+            when 1
               tys.first
             else
               new(types: tys.sort_by(&:hash), location: location)

data/lib/steep/drivers/check.rb

@@ -60,6 +60,10 @@ module Steep
                   Steep.log_error source_file.status.error
                 end
               end
+            when Project::Target::SignatureOtherErrorStatus
+              Steep.log_error status.error
+            else
+              Steep.logger.error { "Unexpected status: #{status.class}" }
             end
           end
         end

data/lib/steep/project/target.rb

@@ -79,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
@@ -160,7 +161,18 @@ module Steep
               else
                 yield env, check, Time.now
               end
+            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
+              Steep.log_error exn
               @status = SignatureOtherErrorStatus.new(error: exn, timestamp: Time.now)
             end
           end
@@ -183,8 +195,10 @@ module Steep
         type_check_sources = []
 
         target_sources.each do |file|
-          if file.type_check(check, timestamp)
-            type_check_sources << file
+          Steep.logger.tagged("path=#{file.path}") do
+            if file.type_check(check, timestamp)
+              type_check_sources << file
+            end
           end
         end
 
@@ -205,7 +219,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

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()}"
@@ -111,7 +111,7 @@ def #{content.method_name}: #{content.method_type}
 ```
 HOVER
           if (comment = content.comment_string)
-            string << "\n----\n\n#{comment.string}\n"
+            string << "\n----\n\n#{comment}\n"
           end
 
           if content.definition.method_types.size > 1

data/lib/steep/server/signature_worker.rb

@@ -112,6 +112,9 @@ module Steep
                         target.signature_files.each_key.with_object({}) do |path, hash|
                           hash[path] = []
                         end
+                      when Project::Target::SignatureOtherErrorStatus
+                        Steep.log_error status.error
+                        {}
                       else
                         Steep.logger.info "Unexpected target status: #{status.class}"
                         {}

data/lib/steep/signature/errors.rb

@@ -19,6 +19,19 @@ module Steep
         end
       end
 
+      class DuplicatedDefinitionError < Base
+        attr_reader :name
+
+        def initialize(name:, location:)
+          @name = name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\sDuplicatedDefinitionError: name=#{name}"
+        end
+      end
+
       class UnknownTypeNameError < Base
         attr_reader :name
 
@@ -48,6 +61,21 @@ module Steep
           io.puts "#{loc_to_s}\tInvalidTypeApplicationError: name=#{name}, expected=[#{params.join(", ")}], actual=[#{args.join(", ")}]"
         end
       end
+
+      class InvalidMethodOverloadError < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          @class_name = class_name
+          @method_name = method_name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tInvalidMethodOverloadError: class_name=#{class_name}, method_name=#{method_name}"
+        end
+      end
     end
   end
 end

data/lib/steep/signature/validator.rb

@@ -53,6 +53,7 @@ module Steep
         validate_decl
         validate_const
         validate_global
+        validate_alias
       end
 
       def validate_type(type)
@@ -99,6 +100,7 @@ module Steep
         env.constant_decls.each do |name, entry|
           rescue_validation_errors do
             Steep.logger.debug "Validating constant `#{name}`..."
+            builder.ensure_namespace!(name.namespace, location: entry.decl.location)
             validate_type entry.decl.type
           end
         end
@@ -117,7 +119,9 @@ module Steep
         env.alias_decls.each do |name, entry|
           rescue_validation_errors do
             Steep.logger.debug "Validating alias `#{name}`..."
-            validate_type(entry.decl.type)
+            builder.expand_alias(name).tap do |type|
+              validate_type(type)
+            end
           end
         end
       end
@@ -136,6 +140,12 @@ module Steep
           name: factory.type_name(exn.type_name),
           location: exn.location
         )
+      rescue RBS::InvalidOverloadMethodError => exn
+        @errors << Errors::InvalidMethodOverloadError.new(
+          class_name: factory.type_name(exn.type_name),
+          method_name: exn.method_name,
+          location: exn.members[0].location
+        )
       end
     end
   end

data/lib/steep/source.rb

@@ -79,6 +79,7 @@ module Steep
       end
 
       mapping = {}
+
       construct_mapping(node: node, annotations: annotations, mapping: mapping)
 
       annotations.each do |annot|
@@ -185,7 +186,7 @@ module Steep
           construct_mapping(node: node.children[0], annotations: annotations, mapping: mapping, line_range: nil)
         end
 
-        if node.loc.else
+        if node.children.last
           else_node = node.children.last
           else_start = node.loc.else.last_line
           else_end = node.loc.end.line

data/lib/steep/subtyping/check.rb

@@ -9,6 +9,84 @@ module Steep
         @cache = {}
       end
 
+      def instance_super_types(type_name, args:)
+        type_name_1 = factory.type_name_1(type_name)
+        ancestors = factory.definition_builder.one_instance_ancestors(type_name_1)
+
+        subst = unless args.empty?
+                  args_ = args.map {|type| factory.type_1(type) }
+                  RBS::Substitution.build(ancestors.params, args_)
+                end
+
+        ancestors.each_ancestor.map do |ancestor|
+          name = factory.type_name(ancestor.name)
+
+          case ancestor
+          when RBS::Definition::Ancestor::Instance
+            args = ancestor.args.map do |type|
+              type = type.sub(subst) if subst
+              factory.type(type)
+            end
+
+            if ancestor.name.class?
+              AST::Types::Name::Instance.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            else
+              AST::Types::Name::Interface.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            end
+          when RBS::Definition::Ancestor::Singleton
+            AST::Types::Name::Class.new(
+              name: name,
+              constructor: nil,
+              location: nil
+            )
+          end
+        end
+      end
+
+      def singleton_super_types(type_name)
+        type_name_1 = factory.type_name_1(type_name)
+        ancestors = factory.definition_builder.one_singleton_ancestors(type_name_1)
+
+        ancestors.each_ancestor.map do |ancestor|
+          name = factory.type_name(ancestor.name)
+
+          case ancestor
+          when RBS::Definition::Ancestor::Instance
+            args = ancestor.args.map do |type|
+              factory.type(type)
+            end
+
+            if ancestor.name.class?
+              AST::Types::Name::Instance.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            else
+              AST::Types::Name::Interface.new(
+                name: name,
+                args: args,
+                location: nil
+              )
+            end
+          when RBS::Definition::Ancestor::Singleton
+            AST::Types::Name::Class.new(
+              name: name,
+              constructor: nil,
+              location: nil
+            )
+          end
+        end
+      end
+
       def check(relation, constraints:, self_type:, assumption: Set.new, trace: Trace.new)
         Steep.logger.tagged "#{relation.sub_type} <: #{relation.super_type}" do
           prefix = trace.size
@@ -102,15 +180,6 @@ module Steep
               constraints: constraints
             )
 
-          when relation.sub_type.is_a?(AST::Types::Literal)
-            check(
-              Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type),
-              self_type: self_type,
-              assumption: assumption,
-              trace: trace,
-              constraints: constraints
-            )
-
           when relation.sub_type.is_a?(AST::Types::Union)
             results = relation.sub_type.types.map do |sub_type|
               check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
@@ -175,30 +244,45 @@ module Steep
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
 
-          when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
-            if (pairs = extract_nominal_pairs(relation))
-              results = pairs.flat_map do |(sub, sup)|
-                Relation.new(sub_type: sub, super_type: sup).yield_self do |rel|
-                  [rel, rel.flip]
-                end
-              end.map do |relation|
-                check(relation,
-                       self_type: self_type,
-                       assumption: assumption,
-                       trace: trace,
-                       constraints: constraints)
-              end
+          when relation.super_type.is_a?(AST::Types::Name::Interface)
+            sub_interface = factory.interface(relation.sub_type, private: false)
+            super_interface = factory.interface(relation.super_type, private: false)
 
-              if results.all?(&:success?)
-                results.first
+            check_interface(sub_interface,
+                            super_interface,
+                            self_type: self_type,
+                            assumption: assumption,
+                            trace: trace,
+                            constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
+            if relation.sub_type.name == relation.super_type.name && relation.sub_type.class == relation.super_type.class
+              if arg_type?(relation.sub_type) && arg_type?(relation.super_type)
+                check_type_arg(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
               else
-                results.find(&:failure?)
+                success(constraints: constraints)
               end
             else
-              sub_interface = factory.interface(relation.sub_type, private: false)
-              super_interface = factory.interface(relation.super_type, private: false)
-
-              check_interface(sub_interface, super_interface, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+              possible_sub_types = case relation.sub_type
+                                   when AST::Types::Name::Instance
+                                     instance_super_types(relation.sub_type.name, args: relation.sub_type.args)
+                                   when AST::Types::Name::Class
+                                     singleton_super_types(relation.sub_type.name)
+                                   else
+                                     []
+                                   end
+
+              unless possible_sub_types.empty?
+                success_any?(possible_sub_types) do |sub_type|
+                  check(Relation.new(sub_type: sub_type, super_type: relation.super_type),
+                        self_type: self_type,
+                        assumption: assumption,
+                        trace: trace,
+                        constraints: constraints)
+                end
+              else
+                failure(error: Result::Failure::UnknownPairError.new(relation: relation), trace: trace)
+              end
             end
 
           when relation.sub_type.is_a?(AST::Types::Proc) && relation.super_type.is_a?(AST::Types::Proc)
@@ -234,16 +318,17 @@ module Steep
                       trace: trace)
             end
 
-          when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Name::Base)
-            tuple_interface = factory.interface(relation.sub_type, private: false)
-            type_interface = factory.interface(relation.super_type, private: false)
+          when relation.sub_type.is_a?(AST::Types::Tuple) && AST::Builtin::Array.instance_type?(relation.super_type)
+            tuple_element_type = AST::Types::Union.build(
+              types: relation.sub_type.types,
+              location: relation.sub_type.location
+            )
 
-            check_interface(tuple_interface,
-                            type_interface,
-                            self_type: self_type,
-                            assumption: assumption,
-                            trace: trace,
-                            constraints: constraints)
+            check(Relation.new(sub_type: tuple_element_type, super_type: relation.super_type.args[0]),
+                  self_type: self_type,
+                  assumption: assumption,
+                  trace: trace,
+                  constraints: constraints)
 
           when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
             if Set.new(relation.sub_type.elements.keys).superset?(Set.new(relation.super_type.elements.keys))
@@ -276,6 +361,32 @@ module Steep
                             trace: trace,
                             constraints: constraints)
 
+          when relation.super_type.is_a?(AST::Types::Literal)
+            case
+            when relation.super_type.value == true && AST::Builtin::TrueClass.instance_type?(relation.sub_type)
+              success(constraints: constraints)
+            when relation.super_type.value == false && AST::Builtin::FalseClass.instance_type?(relation.sub_type)
+              success(constraints: constraints)
+            else
+              failure(error: Result::Failure::UnknownPairError.new(relation: relation),
+                      trace: trace)
+            end
+
+          when relation.super_type.is_a?(AST::Types::Nil) && AST::Builtin::NilClass.instance_type?(relation.sub_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Nil) && AST::Builtin::NilClass.instance_type?(relation.super_type)
+            success(constraints: constraints)
+
+          when relation.sub_type.is_a?(AST::Types::Literal)
+            check(
+              Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type),
+              self_type: self_type,
+              assumption: assumption,
+              trace: trace,
+              constraints: constraints
+            )
+
           else
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
@@ -283,6 +394,80 @@ module Steep
         end
       end
 
+      def definition_for_type(type)
+        type_name = factory.type_name_1(type.name)
+
+        case type
+        when AST::Types::Name::Instance
+          factory.definition_builder.build_instance(type_name)
+        when AST::Types::Name::Class
+          factory.definition_builder.build_singleton(type_name)
+        when AST::Types::Name::Interface
+          factory.definition_builder.build_interface(type_name)
+        else
+          raise
+        end
+      end
+
+      def arg_type?(type)
+        case type
+        when AST::Types::Name::Instance, AST::Types::Name::Interface
+          type.args.size > 0
+        else
+          false
+        end
+      end
+
+      def check_type_arg(relation, self_type:, assumption:, trace:, constraints:)
+        sub_args = relation.sub_type.args
+        sup_args = relation.super_type.args
+
+        sup_def = definition_for_type(relation.super_type)
+        sup_params = sup_def.type_params_decl
+
+        success_all?(sub_args.zip(sup_args, sup_params.each)) do |sub_arg, sup_arg, sup_param|
+          case sup_param.variance
+          when :covariant
+            check(Relation.new(sub_type: sub_arg, super_type: sup_arg), self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+          when :contravariant
+            check(Relation.new(sub_type: sup_arg, super_type: sub_arg), self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+          when :invariant
+            rel = Relation.new(sub_type: sub_arg, super_type: sup_arg)
+            success_all?([rel, rel.flip]) do |r|
+              check(r, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+            end
+          end
+        end
+      end
+
+      def success_all?(collection, &block)
+        results = collection.map do |obj|
+          result = yield(obj)
+
+          if result.failure?
+            return result
+          end
+
+          result
+        end
+
+        results[0]
+      end
+
+      def success_any?(collection, &block)
+        results = collection.map do |obj|
+          result = yield(obj)
+
+          if result.success?
+            return result
+          end
+
+          result
+        end
+
+        results[0]
+      end
+
       def extract_nominal_pairs(relation)
         sub_type = relation.sub_type
         super_type = relation.super_type
@@ -316,20 +501,7 @@ module Steep
           return true
         end
 
-        case
-        when relation.sub_type == relation.super_type
-          true
-        when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
-          if (pairs = extract_nominal_pairs(relation))
-            pairs.all? do |(s, t)|
-              same_type?(Relation.new(sub_type: s, super_type: t), assumption: assumption)
-            end
-          else
-            false
-          end
-        else
-          false
-        end
+        relation.sub_type == relation.super_type
       end
 
       def check_interface(sub_interface, super_interface, self_type:, assumption:, trace:, constraints:)