steep 1.8.0.dev.1 → 1.8.0.pre.1

data/lib/steep/interface/shape.rb

@@ -1,28 +1,83 @@
 module Steep
   module Interface
     class Shape
+      class MethodOverload
+        attr_reader :method_type
+
+        attr_reader :method_defs
+
+        def initialize(method_type, defs)
+          @method_type = method_type
+          @method_defs = defs.sort_by do |defn|
+            buf = +""
+
+            if loc = defn.type.location
+              buf << loc.buffer.name.to_s
+              buf << ":"
+              buf << loc.start_pos.to_s
+            end
+
+            buf
+          end
+          @method_defs.uniq!
+        end
+
+        def subst(s)
+          overload = MethodOverload.new(method_type.subst(s), [])
+          overload.method_defs.replace(method_defs)
+          overload
+        end
+
+        def method_decls(name)
+          method_defs.map do |defn|
+            type_name = defn.implemented_in || defn.defined_in
+
+            if name == :new && defn.member.is_a?(RBS::AST::Members::MethodDefinition) && defn.member.name == :initialize
+              method_name = SingletonMethodName.new(type_name: type_name, method_name: name)
+            else
+              method_name =
+                if defn.member.kind == :singleton
+                  SingletonMethodName.new(type_name: defn.defined_in, method_name: name)
+                else
+                  # Call the `self?` method an instance method, because the definition is done with instance method definition, not with singleton method
+                  InstanceMethodName.new(type_name: defn.defined_in, method_name: name)
+                end
+            end
+
+            TypeInference::MethodCall::MethodDecl.new(method_def: defn, method_name: method_name)
+          end
+        end
+      end
+
       class Entry
-        def initialize(method_types: nil, private_method:, &block)
-          @method_types = method_types
+        attr_reader :method_name
+
+        def initialize(overloads: nil, private_method:, method_name:, &block)
+          @overloads = overloads
           @generator = block
           @private_method = private_method
+          @method_name = method_name
         end
 
         def force
-          unless @method_types
-            @method_types = @generator&.call
+          unless @overloads
+            @overloads = @generator&.call
             @generator = nil
           end
         end
 
-        def method_types
+        def overloads
           force
-          @method_types or raise
+          @overloads or raise
+        end
+
+        def method_types
+          overloads.map(&:method_type)
         end
 
         def has_method_type?
           force
-          @method_types ? true : false
+          @overloads ? true : false
         end
 
         def to_s
@@ -50,7 +105,7 @@ module Steep
         def initialize(substs:, methods:)
           @substs = substs
           @methods = methods
-          @resolved_methods = methods.transform_values { nil }
+          @resolved_methods = {}
         end
 
         def key?(name)
@@ -72,8 +127,9 @@ module Steep
           resolved_methods[name] ||= begin
             entry = methods[name]
             Entry.new(
-              method_types: entry.method_types.map do |method_type|
-                method_type.subst(subst)
+              method_name: name,
+              overloads: entry.overloads.map do |overload|
+                overload.subst(subst)
               end,
               private_method: entry.private_method?
             )

data/lib/steep/interface/substitution.rb

@@ -82,6 +82,8 @@ module Steep
           !instance_type.is_a?(AST::Types::Instance)
         when AST::Types::Class
           !module_type.is_a?(AST::Types::Class)
+        when AST::Types::Name::Applying
+          type.args.any? {|ty| apply?(ty) }
         else
           type.each_child.any? {|t| apply?(t) }
         end

data/lib/steep/interface/type_param.rb

@@ -6,13 +6,15 @@ module Steep
       attr_reader :variance
       attr_reader :unchecked
       attr_reader :location
+      attr_reader :default_type
 
-      def initialize(name:, upper_bound:, variance:, unchecked:, location: nil)
+      def initialize(name:, upper_bound:, variance:, unchecked:, location: nil, default_type:)
         @name = name
         @upper_bound = upper_bound
         @variance = variance
         @unchecked = unchecked
         @location = location
+        @default_type = default_type
       end
 
       def ==(other)
@@ -20,13 +22,14 @@ module Steep
           other.name == name &&
           other.upper_bound == upper_bound &&
           other.variance == variance &&
-          other.unchecked == unchecked
+          other.unchecked == unchecked &&
+          other.default_type == default_type
       end
 
       alias eql? ==
 
       def hash
-        name.hash ^ upper_bound.hash ^ variance.hash ^ unchecked.hash
+        name.hash ^ upper_bound.hash ^ variance.hash ^ unchecked.hash ^ default_type.hash
       end
 
       def self.rename(params, conflicting_names = params.map(&:name), new_names = conflicting_names.map {|n| AST::Types::Var.fresh_name(n) })
@@ -44,7 +47,8 @@ module Steep
                   upper_bound: param.upper_bound&.subst(subst),
                   variance: param.variance,
                   unchecked: param.unchecked,
-                  location: param.location
+                  location: param.location,
+                  default_type: param.default_type&.subst(subst)
                 )
               else
                 param
@@ -80,19 +84,28 @@ module Steep
         buf
       end
 
-      def update(name: self.name, upper_bound: self.upper_bound, variance: self.variance, unchecked: self.unchecked, location: self.location)
+      def update(name: self.name, upper_bound: self.upper_bound, variance: self.variance, unchecked: self.unchecked, location: self.location, default_type: self.default_type)
         TypeParam.new(
           name: name,
           upper_bound: upper_bound,
           variance: variance,
           unchecked: unchecked,
-          location: location
+          location: location,
+          default_type: default_type
         )
       end
 
       def subst(s)
         if u = upper_bound
-          update(upper_bound: u.subst(s))
+          ub = u.subst(s)
+        end
+
+        if d = default_type
+          dt = d.subst(s)
+        end
+
+        if ub || dt
+          update(upper_bound: ub, default_type: dt)
         else
           self
         end

data/lib/steep/located_value.rb

@@ -0,0 +1,20 @@
+module Steep
+  class LocatedValue
+    attr_reader :value, :location
+
+    def initialize(value:, location:)
+      @value = value
+      @location = location
+    end
+
+    def ==(other)
+      other.is_a?(LocatedValue) && other.value == value
+    end
+
+    alias eql? ==
+
+    def hash
+      value.hash # steep:ignore NoMethod
+    end
+  end
+end

data/lib/steep/server/change_buffer.rb

@@ -24,16 +24,14 @@ module Steep
         end
       end
 
-      def load_files(project:, commandline_args:)
+      def load_files(input)
         Steep.logger.tagged "#load_files" do
           push_buffer do |changes|
-            loader = Services::FileLoader.new(base_dir: project.base_dir)
-
-            Steep.measure "load changes from disk" do
-              project.targets.each do |target|
-                loader.load_changes(target.source_pattern, commandline_args, changes: changes)
-                loader.load_changes(target.signature_pattern, changes: changes)
+            input.each do |filename, content|
+              if content.is_a?(Hash)
+                content = Base64.decode64(content[:text]).force_encoding(Encoding::UTF_8)
               end
+              changes[Pathname(filename.to_s)] = [Services::ContentChange.new(text: content)]
             end
           end
         end

data/lib/steep/server/custom_methods.rb

@@ -0,0 +1,61 @@
+module Steep
+  module Server
+    module CustomMethods
+      module FileLoad
+        METHOD = "$/steep/file/load"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module FileReset
+        METHOD = "$/steep/file/reset"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module TypeCheck
+        METHOD = "$/steep/typecheck"
+
+        def self.request(id, params)
+          { method: METHOD, id: id, params: params }
+        end
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
+
+      module TypeCheck__Start
+        METHOD = "$/steep/typecheck/start"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module TypeCheck__Progress
+        METHOD = "$/steep/typecheck/progress"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
+      module Stats
+        METHOD = "$/steep/stats"
+
+        def self.request(id)
+          { method: METHOD, id: id, params: nil }
+        end
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/delay_queue.rb

@@ -25,12 +25,19 @@ module Steep
             end
 
             if proc.equal?(last_task)
-              proc[]
+              unless @cancelled
+                proc[]
+              end
             end
           end
         end
       end
 
+      def cancel
+        @cancelled = true
+        queue.clear()
+      end
+
       def execute(&block)
         @last_task = block
         scheduled_at = Time.now + delay

data/lib/steep/server/interaction_worker.rb

@@ -82,17 +82,22 @@ module Steep
       def handle_request(request)
         case request[:method]
         when "initialize"
-          load_files(project: project, commandline_args: [])
-          queue_job ApplyChangeJob.new
           writer.write({ id: request[:id], result: nil })
 
         when "textDocument/didChange"
           collect_changes(request)
           queue_job ApplyChangeJob.new
 
-        when "$/file/reset"
-          uri = request[:params][:uri]
-          text = request[:params][:content]
+        when CustomMethods::FileLoad::METHOD
+          params = request[:params] #: CustomMethods::FileLoad::params
+          input = params[:content]
+          load_files(input)
+          queue_job ApplyChangeJob.new
+
+        when CustomMethods::FileReset::METHOD
+          params = request[:params] #: CustomMethods::FileReset::params
+          uri = params[:uri]
+          text = params[:content]
           reset_change(uri: uri, text: text)
           queue_job ApplyChangeJob.new
 
@@ -464,9 +469,11 @@ module Steep
 
             if (items, index = provider.run(line: job.line, column: job.column))
               signatures = items.map do |item|
+                params = item.parameters or raise
+
                 LSP::Interface::SignatureInformation.new(
                   label: item.method_type.to_s,
-                  parameters: item.parameters.map { |param| LSP::Interface::ParameterInformation.new(label: param)},
+                  parameters: params.map { |param| LSP::Interface::ParameterInformation.new(label: param)},
                   active_parameter: item.active_parameter,
                   documentation: item.comment&.yield_self do |comment|
                     LSP::Interface::MarkupContent.new(

data/lib/steep/server/lsp_formatter.rb

@@ -36,7 +36,8 @@ module Steep
               ----
             MD
 
-            method_types = call.method_decls.map(&:method_type)
+            method_decls = call.method_decls.sort_by {|decl| decl.method_name.to_s }
+            method_types = method_decls.map(&:method_type)
 
             if call.is_a?(TypeInference::MethodCall::Special)
               method_types = [
@@ -52,7 +53,8 @@ module Steep
               MD
             end
           when TypeInference::MethodCall::Error
-            method_types = call.method_decls.map {|decl| decl.method_type }
+            method_decls = call.method_decls.sort_by {|decl| decl.method_name.to_s }
+            method_types = method_decls.map {|decl| decl.method_type }
 
             header = <<~MD
               **🚨 No compatible method type found**
@@ -61,8 +63,8 @@ module Steep
             MD
           end
 
-          method_names = call.method_decls.map {|decl| decl.method_name.relative }
-          docs = call.method_decls.map {|decl| [decl.method_name, decl.method_def.comment] }.to_h
+          method_names = method_decls.map {|decl| decl.method_name.relative }
+          docs = method_decls.map {|decl| [decl.method_name, decl.method_def.comment] }.to_h
 
           if header
             io.puts header
@@ -373,8 +375,8 @@ module Steep
             end
             s << param.name.to_s
 
-            if param.upper_bound
-              s << " < #{param.upper_bound.to_s}"
+            if param.upper_bound_type
+              s << " < #{param.upper_bound_type.to_s}"
             end
 
             s