steep 0.17.1 → 0.22.0

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

@@ -112,8 +112,12 @@ 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}"
+                        {}
                       end
 
         diagnostics.each do |path, diags|

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

@@ -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
@@ -45,59 +53,75 @@ module Steep
         validate_decl
         validate_const
         validate_global
+        validate_alias
       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}`..."
+            builder.ensure_namespace!(name.namespace, location: entry.decl.location)
+            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}`..."
+            builder.expand_alias(name).tap do |type|
+              validate_type(type)
+            end
           end
         end
       end
@@ -108,14 +132,20 @@ 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
         )
+      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/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)
@@ -276,6 +369,23 @@ 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)
+
           else
             failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                     trace: trace)
@@ -283,6 +393,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 +500,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:)