steep 1.8.0.dev.2 → 1.8.0.pre.2

data/lib/steep/ast/types/proc.rb

@@ -2,16 +2,14 @@ module Steep
   module AST
     module Types
       class Proc
-        attr_reader :location
         attr_reader :type
         attr_reader :self_type
         attr_reader :block
 
-        def initialize(type:, block:, self_type:, location: type.location)
+        def initialize(type:, block:, self_type:)
           @type = type
           @block = block
           @self_type = self_type
-          @location = location
         end
 
         def ==(other)
@@ -28,8 +26,7 @@ module Steep
           self.class.new(
             type: type.subst(s),
             block: block&.subst(s),
-            self_type: self_type&.subst(s),
-            location: location
+            self_type: self_type&.subst(s)
           )
         end
 
@@ -70,16 +67,11 @@ module Steep
           [0] + level_of_children(children)
         end
 
-        def with_location(new_location)
-          self.class.new(location: new_location, block: block, type: type, self_type: self_type)
-        end
-
         def map_type(&block)
           self.class.new(
             type: type.map_type(&block),
             block: self.block&.map_type(&block),
-            self_type: self_type ? yield(self_type) : nil,
-            location: location
+            self_type: self_type ? yield(self_type) : nil
           )
         end
 
@@ -99,8 +91,7 @@ module Steep
 
         def back_type
           Name::Instance.new(name: Builtin::Proc.module_name,
-                             args: [],
-                             location: location)
+                             args: [])
         end
 
         def block_required?

data/lib/steep/ast/types/record.rb

@@ -2,32 +2,37 @@ module Steep
   module AST
     module Types
       class Record
-        attr_reader :location
-        attr_reader :elements
+        attr_reader :elements, :required_keys
 
-        def initialize(elements:, location: nil)
+        def initialize(elements:, required_keys:)
           @elements = elements
-          @location = location
+          @required_keys = required_keys
         end
 
         def ==(other)
-          other.is_a?(Record) && other.elements == elements
+          other.is_a?(Record) && other.elements == elements && other.required_keys == required_keys
         end
 
         def hash
-          self.class.hash ^ elements.hash
+          self.class.hash ^ elements.hash ^ required_keys.hash
         end
 
         alias eql? ==
 
         def subst(s)
-          self.class.new(location: location,
-                         elements: elements.transform_values {|type| type.subst(s) })
+          self.class.new(
+            elements: elements.transform_values {|type| type.subst(s) },
+            required_keys: required_keys
+          )
         end
 
         def to_s
-          strings = elements.keys.sort.map do |key|
-            "#{key.inspect} => #{elements[key]}"
+          strings = elements.keys.sort_by(&:to_s).map do |key|
+            if optional?(key)
+              "?#{key.inspect} => #{elements[key]}"
+            else
+              "#{key.inspect} => #{elements[key]}"
+            end
           end
           "{ #{strings.join(", ")} }"
         end
@@ -53,7 +58,7 @@ module Steep
         def map_type(&block)
           self.class.new(
             elements: elements.transform_values(&block),
-            location: location
+            required_keys: required_keys
           )
         end
 
@@ -61,8 +66,12 @@ module Steep
           [0] + level_of_children(elements.values)
         end
 
-        def with_location(new_location)
-          self.class.new(elements: elements, location: new_location)
+        def required?(key)
+          required_keys.include?(key)
+        end
+
+        def optional?(key)
+          !required_keys.include?(key)
         end
       end
     end

data/lib/steep/ast/types/self.rb

@@ -2,15 +2,7 @@ module Steep
   module AST
     module Types
       class Self
-        attr_reader :location
-
-        def initialize(location: nil)
-          @location = location
-        end
-
-        def self.instance
-          @instance ||= new()
-        end
+        extend SharedInstance
 
         def ==(other)
           other.is_a?(Self)
@@ -45,10 +37,6 @@ module Steep
         def level
           [0]
         end
-
-        def with_location(new_location)
-          self.class.new(location: new_location)
-        end
       end
     end
   end

data/lib/steep/ast/types/shared_instance.rb

@@ -0,0 +1,11 @@
+module Steep
+  module AST
+    module Types
+      module SharedInstance
+        def instance
+          @instance ||= new
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/top.rb

@@ -2,11 +2,7 @@ module Steep
   module AST
     module Types
       class Top
-        attr_reader :location
-
-        def initialize(location: nil)
-          @location = location
-        end
+        extend SharedInstance
 
         def ==(other)
           other.is_a?(Top)
@@ -33,10 +29,6 @@ module Steep
         def level
           [2]
         end
-
-        def with_location(new_location)
-          self.class.new(location: new_location)
-        end
       end
     end
   end

data/lib/steep/ast/types/tuple.rb

@@ -3,11 +3,9 @@ module Steep
     module Types
       class Tuple
         attr_reader :types
-        attr_reader :location
 
-        def initialize(types:, location: nil)
+        def initialize(types:)
           @types = types
-          @location = location
         end
 
         def ==(other)
@@ -22,8 +20,7 @@ module Steep
         alias eql? ==
 
         def subst(s)
-          self.class.new(location: location,
-                         types: types.map {|ty| ty.subst(s) })
+          self.class.new(types: types.map {|ty| ty.subst(s) })
         end
 
         def to_s
@@ -47,10 +44,7 @@ module Steep
         end
 
         def map_type(&block)
-          Tuple.new(
-            types: types.map(&block),
-            location: location
-          )
+          Tuple.new(types: types.map(&block))
         end
 
         def level
@@ -58,7 +52,7 @@ module Steep
         end
 
         def with_location(new_location)
-          self.class.new(types: types, location: new_location)
+          self.class.new(types: types)
         end
       end
     end

data/lib/steep/ast/types/union.rb

@@ -3,15 +3,13 @@ module Steep
     module Types
       class Union
         attr_reader :types
-        attr_reader :location
 
-        def initialize(types:, location: nil)
+        def initialize(types:)
           @types = types
-          @location = location
         end
 
-        def self.build(types:, location: nil)
-          return AST::Types::Bot.new if types.empty?
+        def self.build(types:)
+          return AST::Types::Bot.instance if types.empty?
           if types.size == 1
             return types.first || raise
           end
@@ -25,9 +23,9 @@ module Steep
           end.map do |type|
             case type
             when AST::Types::Any
-              return AST::Types::Any.new(location: location)
+              return AST::Types::Any.instance()
             when AST::Types::Top
-              return AST::Types::Top.new(location: location)
+              return AST::Types::Top.instance
             when AST::Types::Bot
               nil
             else
@@ -36,11 +34,11 @@ module Steep
           end.compact.uniq.yield_self do |tys|
             case tys.size
             when 0
-              AST::Types::Bot.new
+              AST::Types::Bot.instance
             when 1
               tys.first || raise
             else
-              new(types: tys, location: location)
+              new(types: tys)
             end
           end
         end
@@ -57,7 +55,7 @@ module Steep
         alias eql? ==
 
         def subst(s)
-          self.class.build(location: location, types: types.map {|ty| ty.subst(s) })
+          self.class.build(types: types.map {|ty| ty.subst(s) })
         end
 
         def to_s
@@ -81,10 +79,7 @@ module Steep
         end
 
         def map_type(&block)
-          Union.build(
-            types: types.map(&block),
-            location: location
-          )
+          Union.build(types: types.map(&block))
         end
 
         include Helper::ChildrenLevel
@@ -94,7 +89,7 @@ module Steep
         end
 
         def with_location(new_location)
-          self.class.new(types: types, location: new_location)
+          self.class.new(types: types)
         end
       end
     end

data/lib/steep/ast/types/var.rb

@@ -3,11 +3,9 @@ module Steep
     module Types
       class Var
         attr_reader :name
-        attr_reader :location
 
-        def initialize(name:, location: nil)
+        def initialize(name:)
           @name = name
-          @location = location
         end
 
         def ==(other)
@@ -33,7 +31,7 @@ module Steep
         end
 
         def self.fresh(name, location: nil)
-          new(name: fresh_name(name), location: location)
+          new(name: fresh_name(name))
         end
 
         def to_s
@@ -58,15 +56,8 @@ module Steep
           [0]
         end
 
-        def update(name: self.name, location: self.location)
-          self.class.new(
-            name: name,
-            location: location
-          )
-        end
-
-        def with_location(new_location)
-          update(location: new_location)
+        def update(name: self.name)
+          self.class.new(name: name)
         end
       end
     end

data/lib/steep/ast/types/void.rb

@@ -2,12 +2,8 @@ module Steep
   module AST
     module Types
       class Void
-        attr_reader :location
-
-        def initialize(location: nil)
-          @location = location
-        end
-
+        extend SharedInstance
+        
         def ==(other)
           other.is_a?(Void)
         end
@@ -33,10 +29,6 @@ module Steep
         def level
           [0]
         end
-
-        def with_location(new_location)
-          self.class.new(location: new_location)
-        end
       end
     end
   end

data/lib/steep/diagnostic/ruby.rb

@@ -904,8 +904,8 @@ module Steep
       class UnexpectedTypeArgument < Base
         attr_reader :type_arg, :method_type
 
-        def initialize(type_arg:, method_type:)
-          super(node: nil, location: type_arg.location)
+        def initialize(type_arg:, method_type:, location:)
+          super(node: nil, location: location)
           @type_arg = type_arg
           @method_type = method_type
         end
@@ -932,8 +932,8 @@ module Steep
       class TypeArgumentMismatchError < Base
         attr_reader :type_argument, :type_parameter, :result
 
-        def initialize(type_arg:, type_param:, result:)
-          super(node: nil, location: type_arg.location)
+        def initialize(type_arg:, type_param:, result:, location:)
+          super(node: nil, location: location)
           @type_argument = type_arg
           @type_parameter = type_param
           @result = result

data/lib/steep/drivers/check.rb

@@ -61,42 +61,39 @@ module Steep
 
         Steep.logger.info { "Initializing server" }
         initialize_id = request_id()
-        client_writer.write({ method: :initialize, id: initialize_id, params: {} })
+        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
         wait_for_response_id(reader: client_reader, id: initialize_id)
 
         request_guid = SecureRandom.uuid
         Steep.logger.info { "Starting type checking: #{request_guid}" }
-        client_writer.write({ method: "$/typecheck", params: { guid: request_guid } })
+        client_writer.write(Server::CustomMethods::TypeCheck.request(request_guid, { guid: request_guid}))
 
         diagnostic_notifications = [] #: Array[LanguageServer::Protocol::Interface::PublishDiagnosticsParams]
         error_messages = [] #: Array[String]
-        client_reader.read do |response|
+
+        response = wait_for_response_id(reader: client_reader, id: request_guid) do |message|
           case
-          when response[:method] == "textDocument/publishDiagnostics"
-            ds = response[:params][:diagnostics]
+          when message[:method] == "textDocument/publishDiagnostics"
+            ds = message[:params][:diagnostics]
             ds.select! {|d| keep_diagnostic?(d, severity_level: severity_level) }
             if ds.empty?
               stdout.print "."
             else
               stdout.print "F"
             end
-            diagnostic_notifications << response[:params]
+            diagnostic_notifications << message[:params]
             stdout.flush
-          when response[:method] == "window/showMessage"
+          when message[:method] == "window/showMessage"
             # Assuming ERROR message means unrecoverable error.
-            message = response[:params]
+            message = message[:params]
             if message[:type] == LSP::Constant::MessageType::ERROR
               error_messages << message[:message]
             end
-          when response[:method] == "$/progress"
-            if response[:params][:token] == request_guid
-              if response[:params][:value][:kind] == "end"
-                break
-              end
-            end
           end
         end
 
+        Steep.logger.info { "Finished type checking: #{response.inspect}" }
+
         Steep.logger.info { "Shutting down..." }
 
         shutdown_exit(reader: client_reader, writer: client_writer)

data/lib/steep/drivers/checkfile.rb

@@ -125,7 +125,7 @@ module Steep
 
         Steep.logger.info { "Initializing server" }
         initialize_id = request_id()
-        client_writer.write({ method: :initialize, id: initialize_id, params: {} })
+        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
         wait_for_response_id(reader: client_reader, id: initialize_id)
 
         stdin_input.each do |path, content|
@@ -151,11 +151,12 @@ module Steep
         end
 
         ping_guid = master.fresh_request_id()
-        client_writer.write({ method: "$/ping", id: ping_guid, params: {} })
+        client_writer.write({ method: "$/ping", id: ping_guid, params: {}})
         wait_for_response_id(reader: client_reader, id: ping_guid)
 
         request_guid = master.fresh_request_id()
-        request = Server::Master::TypeCheckRequest.new(guid: request_guid)
+        progress = master.work_done_progress(request_guid)
+        request = Server::Master::TypeCheckRequest.new(guid: request_guid, progress: progress)
 
         target_paths.each do |path|
           request.code_paths << project.absolute_path(path)
@@ -164,12 +165,13 @@ module Steep
           request.signature_paths << project.absolute_path(path)
         end
 
-        master.start_type_check(request, last_request: nil, start_progress: true)
+        master.start_type_check(request: request, last_request: nil, report_progress_threshold: 0)
 
         Steep.logger.info { "Starting type checking: #{request_guid}" }
 
         error_messages = [] #: Array[String]
         client_reader.read do |response|
+          Steep.logger.info { response.inspect }
           case
           when response[:method] == "textDocument/publishDiagnostics"
             params = response[:params]
@@ -188,12 +190,8 @@ module Steep
             if message[:type] == LSP::Constant::MessageType::ERROR
               error_messages << message[:message]
             end
-          when response[:method] == "$/progress"
-            if response[:params][:token] == request_guid
-              if response[:params][:value][:kind] == "end"
-                break
-              end
-            end
+          when response[:id] == request_guid
+            break
           end
         end
 

data/lib/steep/drivers/stats.rb

@@ -16,6 +16,7 @@ module Steep
               csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
               stats_result.each do |row|
                 if row[:type] == "success"
+                  # @type var row: Steep::Services::StatsCalculator::SuccessStats::json
                   csv << [
                     row[:target],
                     row[:path],
@@ -30,6 +31,7 @@ module Steep
                     end
                   ]
                 else
+                  # @type var row: Steep::Services::StatsCalculator::ErrorStats::json
                   csv << [
                     row[:target],
                     row[:path],
@@ -57,7 +59,8 @@ module Steep
           rows = [] #: Array[Array[untyped]]
           stats_result.sort_by {|row| row[:path] }.each do |row|
             if row[:type] == "success"
-              rows << [
+                # @type var row: Steep::Services::StatsCalculator::SuccessStats::json
+                rows << [
                 row[:target],
                 row[:path] + "  ",
                 row[:type],
@@ -71,6 +74,7 @@ module Steep
                 end
               ]
             else
+              # @type var row: Steep::Services::StatsCalculator::ErrorStats::json
               rows << [
                 row[:target],
                 row[:path],
@@ -150,27 +154,27 @@ module Steep
         end
 
         initialize_id = request_id()
-        client_writer.write({ method: :initialize, id: initialize_id })
+        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
         wait_for_response_id(reader: client_reader, id: initialize_id)
 
         typecheck_guid = SecureRandom.uuid
-        client_writer.write({ method: "$/typecheck", params: { guid: typecheck_guid }})
+
+        master.job_queue << -> do
+          Steep.logger.info { "Type checking for stats..." }
+          progress = master.work_done_progress(typecheck_guid)
+          master.start_type_check(last_request: nil, progress: progress, include_unchanged: true, report_progress_threshold: 0)
+        end
         wait_for_message(reader: client_reader) do |message|
-          message[:method] == "$/progress" &&
-            message[:params][:token] == typecheck_guid &&
-            message[:params][:value][:kind] == "end"
+          message[:id] == typecheck_guid
         end
 
+        Steep.logger.info { "Finished type checking for stats" }
+
         stats_id = request_id()
-        client_writer.write(
-          {
-            id: stats_id,
-            method: "workspace/executeCommand",
-            params: { command: "steep/stats", arguments: _ = [] }
-          })
+        client_writer.write(Server::CustomMethods::Stats.request(stats_id))
 
         stats_response = wait_for_response_id(reader: client_reader, id: stats_id)
-        stats_result = stats_response[:result]
+        stats_result = stats_response[:result] #: Server::CustomMethods::Stats::result
 
         shutdown_exit(reader: client_reader, writer: client_writer)
         main_thread.join()

data/lib/steep/drivers/utils/driver_helper.rb

@@ -38,9 +38,28 @@ module Steep
           SecureRandom.alphanumeric(10)
         end
 
-        def wait_for_response_id(reader:, id:, unknown_responses: :ignore)
-          wait_for_message(reader: reader, unknown_messages: unknown_responses) do |response|
-            response[:id] == id
+        def wait_for_response_id(reader:, id:, unknown_responses: nil, &block)
+          reader.read do |message|
+            Steep.logger.debug { "Received message waiting for #{id}: #{message.inspect}" }
+
+            response_id = message[:id]
+
+            if response_id == id
+              return message
+            end
+
+            if block
+              yield message
+            else
+              case unknown_responses
+              when :ignore, nil
+                # nop
+              when :log
+                Steep.logger.error { "Unexpected message: #{message.inspect}" }
+              when :raise
+                raise "Unexpected message: #{message.inspect}"
+              end
+            end
           end
         end
 
@@ -83,6 +102,8 @@ module Steep
             severity <= LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION
           end
         end
+
+        (DEFAULT_CLI_LSP_INITIALIZE_PARAMS = {}).freeze
       end
     end
   end

data/lib/steep/drivers/watch.rb

@@ -59,7 +59,7 @@ module Steep
         end
 
         initialize_id = request_id()
-        client_writer.write(method: "initialize", id: initialize_id)
+        client_writer.write(method: "initialize", id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS)
         wait_for_response_id(reader: client_reader, id: initialize_id)
 
         Steep.logger.info "Watching #{dirs.join(", ")}..."
@@ -112,7 +112,7 @@ module Steep
             end
           end
 
-          client_writer.write(method: "$/typecheck", params: { guid: nil })
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, { guid: nil }))
 
           stdout.puts Rainbow("done!").bold
         end.tap(&:start)
@@ -120,7 +120,7 @@ module Steep
         begin
           stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
 
-          client_writer.write(method: "$/typecheck", params: { guid: nil })
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, { guid: nil }))
 
           client_reader.read do |response|
             case response[:method]