steep 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 566e77aa4db03cb06ae80569f4db9f5409e65199b1af4af9fc6f2598e911f694
-  data.tar.gz: 41f1d54c5196fdec7cc58751899aec208066d845eef717234bb37266313c7d8d
+  metadata.gz: 6109c6ce90265363be0ef33fe06e517577f3e884a6fc20c921f5d716c4916de1
+  data.tar.gz: 1bcba16bfab23e534eb40b7302dd21e43b487ba6441a02d0da403ac4df54d788
 SHA512:
-  metadata.gz: 46366ed11a6328a6a237c52042ef49eb12d5ce3db111fb55c5038109b62aa471ba6634c8c060575f6862658dcc0f388684a083f9a691becd6d90f076acb05908
-  data.tar.gz: 9cb15861e6de6b5209dd82745f1c7cf67c212e3e15cc9c1f92956b84089801f994c7c1cd79ff8972f37da229530e7354d237ce4a74ce844083daf656936286dc
+  metadata.gz: b8bffda05cd158a3ce849fca2722fcb0d62de0d6307a88d4fa0d3758a7965aef706bccab3b4a634a3343e2c0bbd1cc87bec8e5f5b31cfa52e19a6d3f2931b5eb
+  data.tar.gz: 57cb080c69a71fb31f52bd4e65e37ca1719f46718b02632d2c5af3ff72c8b34eba56f098831558fd7df18afbdec0fd6802d0fbb326c5cb4086c147ba11b5447f

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## 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))

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/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
@@ -175,30 +253,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)
@@ -283,6 +376,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 +483,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:)

data/lib/steep/version.rb

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

data/smoke/class/a.rbs

@@ -18,7 +18,6 @@ class D
   def foo: -> untyped
 end
 
-class E
-  def initialize: () -> untyped
+interface _E
   def foo: -> untyped
 end

data/smoke/class/f.rb

@@ -1,8 +1,10 @@
-# @type var e: E
+# @type var e: _E
 # @type var d: D
 
 e = (_ = nil)
 d = (_ = nil)
 
 e = d
+
+# !expects IncompatibleAssignment: lhs_type=::D, rhs_type=::_E
 d = e

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.6.0", '< 0.7.0'
+  spec.add_runtime_dependency "rbs", "~> 0.7.0"
 end

metadata

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