steep 0.39.0 → 0.40.0

data/lib/steep/drivers/stats.rb

@@ -22,45 +22,141 @@ module Steep
         loader.load_sources(command_line_patterns)
         loader.load_signatures()
 
-        type_check(project)
+        stderr.puts Rainbow("# Calculating stats:").bold
+        stderr.puts
+
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_read)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_write)
+
+        server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
+        server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
+
+        interaction_worker = Server::WorkerProcess.spawn_worker(:interaction, name: "interaction", steepfile: project.steepfile_path, delay_shutdown: true)
+        signature_worker = Server::WorkerProcess.spawn_worker(:signature, name: "signature", steepfile: project.steepfile_path, delay_shutdown: true)
+        code_workers = Server::WorkerProcess.spawn_code_workers(steepfile: project.steepfile_path, delay_shutdown: true)
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: interaction_worker,
+          signature_worker: signature_worker,
+          code_workers: code_workers
+        )
+
+        main_thread = Thread.start do
+          master.start()
+        end
+        main_thread.abort_on_exception = true
+
+        client_writer.write({ method: :initialize, id: 0 })
+
+        stats_id = -1
+        client_writer.write(
+          {
+            id: stats_id,
+            method: "workspace/executeCommand",
+            params: {
+              command: "steep/stats",
+              arguments: project.all_source_files.map {|path| project.absolute_path(path) }
+            }
+          })
+
+        stats_result = []
+        client_reader.read do |response|
+          if response[:id] == stats_id
+            stats_result.push(*response[:result])
+            break
+          end
+        end
+
+        shutdown_id = -2
+        client_writer.write({ method: :shutdown, id: shutdown_id })
+
+        client_reader.read do |response|
+          if response[:id] == shutdown_id
+            break
+          end
+        end
+
+        client_writer.write({ method: "exit" })
+        main_thread.join()
 
         stdout.puts(
           CSV.generate do |csv|
             csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
-
-            project.targets.each do |target|
-              case (status = target.status)
-              when Project::Target::TypeCheckStatus
-                status.type_check_sources.each do |source_file|
-                  case source_file.status
-                  when Project::SourceFile::TypeCheckStatus
-                    typing = source_file.status.typing
-
-                    typed = 0
-                    untyped = 0
-                    total = 0
-                    typing.method_calls.each_value do |call|
-                      case call
-                      when TypeInference::MethodCall::Typed
-                        typed += 1
-                      when TypeInference::MethodCall::Untyped
-                        untyped += 1
-                      end
-
-                      total += 1
-                    end
-
-                    csv << format_stats(target, source_file.path, "success", typed, untyped, total)
-                  when Project::SourceFile::TypeCheckErrorStatus
-                    csv << format_stats(target, source_file.path, "error", 0, 0, 0)
+            stats_result.each do |row|
+              if row[:type] == "success"
+                csv << [
+                  row[:target],
+                  row[:path],
+                  row[:type],
+                  row[:typed_calls],
+                  row[:untyped_calls],
+                  row[:total_calls],
+                  if row[:total_calls].nonzero?
+                    (row[:typed_calls].to_f / row[:total_calls] * 100).to_i
                   else
-                    csv << format_stats(target, source_file.path, "unknown (#{source_file.status.class.to_s.split(/::/).last})", 0, 0, 0)
+                    100
                   end
-                end
+                ]
+              else
+                csv << [
+                  row[:target],
+                  row[:path],
+                  row[:type],
+                  0,
+                  0,
+                  0,
+                  0
+                ]
               end
             end
           end
         )
+        #
+        # type_check(project)
+        #
+        # stdout.puts(
+        #   CSV.generate do |csv|
+        #     csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
+        #
+        #     project.targets.each do |target|
+        #       case (status = target.status)
+        #       when Project::Target::TypeCheckStatus
+        #         status.type_check_sources.each do |source_file|
+        #           case source_file.status
+        #           when Project::SourceFile::TypeCheckStatus
+        #             typing = source_file.status.typing
+        #
+        #             typed = 0
+        #             untyped = 0
+        #             total = 0
+        #             typing.method_calls.each_value do |call|
+        #               case call
+        #               when TypeInference::MethodCall::Typed
+        #                 typed += 1
+        #               when TypeInference::MethodCall::Untyped
+        #                 untyped += 1
+        #               end
+        #
+        #               total += 1
+        #             end
+        #
+        #             csv << format_stats(target, source_file.path, "success", typed, untyped, total)
+        #           when Project::SourceFile::TypeCheckErrorStatus
+        #             csv << format_stats(target, source_file.path, "error", 0, 0, 0)
+        #           else
+        #             csv << format_stats(target, source_file.path, "unknown (#{source_file.status.class.to_s.split(/::/).last})", 0, 0, 0)
+        #           end
+        #         end
+        #       end
+        #     end
+        #   end
+        # )
 
         0
       end

data/lib/steep/drivers/trace_printer.rb

@@ -9,7 +9,7 @@ module Steep
 
       def print(trace, level: 0)
         trace.each.with_index do |t, i|
-          prefix = " " * (i + level)
+          prefix = "  " * (i + level)
           case t[0]
           when :type
             io.puts "#{prefix}#{t[1]} <: #{t[2]}"
@@ -17,6 +17,10 @@ module Steep
             io.puts "#{prefix}(#{t[3]}) #{t[1]} <: #{t[2]}"
           when :method_type
             io.puts "#{prefix}#{t[1]} <: #{t[2]}"
+          when :interface
+            # nop
+          else
+            Steep.logger.error { "Unexpected trace item: #{t[0]}" }
           end
         end
       end

data/lib/steep/drivers/validate.rb

@@ -22,12 +22,19 @@ module Steep
         project.targets.each do |target|
           Steep.logger.tagged "target=#{target.name}" do
             case (status = target.status)
-            when Project::Target::SignatureSyntaxErrorStatus
-              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
-              printer.print_syntax_errors(status.errors)
-            when Project::Target::SignatureValidationErrorStatus
-              printer = SignatureErrorPrinter.new(stdout: stdout, stderr: stderr)
-              printer.print_semantic_errors(status.errors)
+            when Project::Target::SignatureErrorStatus
+              formatter = Diagnostic::LSPFormatter.new
+              diagnostics = status.errors.group_by {|e| e.location.buffer }.transform_values do |errors|
+                errors.map {|error| formatter.format(error) }
+              end
+
+              diagnostics.each do |buffer, ds|
+                printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
+                ds.each do |d|
+                  printer.print(d)
+                  stdout.puts
+                end
+              end
             end
           end
         end

data/lib/steep/drivers/watch.rb

@@ -8,6 +8,8 @@ module Steep
 
       include Utils::DriverHelper
 
+      LSP = LanguageServer::Protocol
+
       def initialize(stdout:, stderr:)
         @dirs = []
         @stdout = stdout
@@ -58,7 +60,7 @@ module Steep
 
         Steep.logger.info "Watching #{dirs.join(", ")}..."
         listener = Listen.to(*dirs.map(&:to_s)) do |modified, added, removed|
-          stdout.puts "🔬 Type checking updated files..."
+          stdout.puts Rainbow("🔬 Type checking updated files...").bold
 
           version = Time.now.to_i
           Steep.logger.tagged "watch" do
@@ -101,35 +103,50 @@ module Steep
         end.tap(&:start)
 
         begin
-          stdout.puts "👀 Watching directories, Ctrl-C to stop."
+          stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
           client_reader.read do |response|
             case response[:method]
             when "textDocument/publishDiagnostics"
               uri = URI.parse(response[:params][:uri])
               path = project.relative_path(Pathname(uri.path))
+              buffer = RBS::Buffer.new(content: path.read, name: path)
+              printer = DiagnosticPrinter.new(stdout: stdout, buffer: buffer)
 
               diagnostics = response[:params][:diagnostics]
 
               unless diagnostics.empty?
                 diagnostics.each do |diagnostic|
-                  start = diagnostic[:range][:start]
-                  loc = "#{start[:line]+1}:#{start[:character]}"
-                  message = diagnostic[:message].chomp.lines.join("  ")
-
-                  stdout.puts "#{path}:#{loc}: #{message}"
+                  printer.print(diagnostic)
                 end
               end
+            when "window/showMessage"
+              # Assuming ERROR message means unrecoverable error.
+              message = response[:params]
+              if message[:type] == LSP::Constant::MessageType::ERROR
+                stdout.puts "Unexpected error reported... 🚨"
+              end
             end
           end
         rescue Interrupt
+          shutdown_id = -1
           stdout.puts "Shutting down workers..."
-          client_writer.write({ method: :shutdown, id: 10000 })
+          client_writer.write({ method: :shutdown, id: shutdown_id })
+          client_reader.read do |response|
+            if response[:id] == shutdown_id
+              break
+            end
+          end
           client_writer.write({ method: :exit })
           client_writer.io.close()
         end
 
         listener.stop
-        main_thread.join
+        begin
+          main_thread.join
+        rescue Interrupt
+          master.kill
+          main_thread.join
+        end
 
         0
       end

data/lib/steep/drivers/worker.rb

@@ -6,6 +6,7 @@ module Steep
       attr_accessor :steepfile_path
       attr_accessor :worker_type
       attr_accessor :worker_name
+      attr_accessor :delay_shutdown
 
       include Utils::DriverHelper
 
@@ -37,6 +38,10 @@ module Steep
                      raise "Unknown worker type: #{worker_type}"
                    end
 
+          unless delay_shutdown
+            worker.skip_jobs_after_shutdown!
+          end
+
           Steep.logger.info "Starting #{worker_type} worker..."
 
           worker.run()

data/lib/steep/project/options.rb

@@ -40,13 +40,13 @@ module Steep
 
       def error_to_report?(error)
         case
-        when error.is_a?(Errors::FallbackAny)
+        when error.is_a?(Diagnostic::Ruby::FallbackAny)
           !allow_fallback_any
-        when error.is_a?(Errors::MethodDefinitionMissing)
+        when error.is_a?(Diagnostic::Ruby::MethodDefinitionMissing)
           !allow_missing_definitions
-        when error.is_a?(Errors::NoMethod)
+        when error.is_a?(Diagnostic::Ruby::NoMethod)
           !allow_unknown_method_calls
-        when error.is_a?(Errors::UnknownConstantAssigned)
+        when error.is_a?(Diagnostic::Ruby::UnknownConstantAssigned)
           !allow_unknown_constant_assignment
         else
           true

data/lib/steep/project/signature_file.rb

@@ -5,8 +5,6 @@ module Steep
       attr_reader :content
       attr_reader :content_updated_at
 
-      attr_reader :status
-
       ParseErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
       DeclarationsStatus = Struct.new(:declarations, :timestamp, keyword_init: true)
 
@@ -21,6 +19,14 @@ module Steep
         @status = nil
       end
 
+      def status
+        unless @status
+          @status = DeclarationsStatus.new(declarations: [], timestamp: Time.now)
+        end
+
+        @status
+      end
+
       def load!
         buffer = RBS::Buffer.new(name: path, content: content)
         decls = RBS::Parser.parse_signature(buffer)

data/lib/steep/project/stats_calculator.rb

@@ -0,0 +1,80 @@
+module Steep
+  class Project
+    class StatsCalculator
+      SuccessStats = Struct.new(:target, :path, :typed_calls_count, :untyped_calls_count, :error_calls_count, keyword_init: true) do
+        def as_json
+          {
+            type: "success",
+            target: target.name.to_s,
+            path: path.to_s,
+            typed_calls: typed_calls_count,
+            untyped_calls: untyped_calls_count,
+            error_calls: error_calls_count,
+            total_calls: typed_calls_count + untyped_calls_count + error_calls_count
+          }
+        end
+      end
+      ErrorStats = Struct.new(:target, :path, :status, keyword_init: true) do
+        def as_json
+          {
+            type: "error",
+            target: target.name.to_s,
+            path: path.to_s,
+            status: status.class.to_s
+          }
+        end
+      end
+
+      attr_reader :project
+
+      def initialize(project:)
+        @project = project
+      end
+
+      def calc_stats(target, path)
+        source_file = target.source_files[path] or raise
+
+        target.type_check(
+          target_sources: [source_file],
+          validate_signatures: false
+        )
+
+        if target.status.is_a?(Target::TypeCheckStatus)
+          case source_file.status
+          when SourceFile::TypeCheckStatus
+            typing = source_file.status.typing
+
+            typed = 0
+            untyped = 0
+            errors = 0
+            total = 0
+            typing.method_calls.each_value do |call|
+              case call
+              when TypeInference::MethodCall::Typed
+                typed += 1
+              when TypeInference::MethodCall::Untyped
+                untyped += 1
+              when TypeInference::MethodCall::Error, TypeInference::MethodCall::NoMethodError
+                errors += 1
+              else
+                raise
+              end
+            end
+
+            SuccessStats.new(
+              target: target,
+              path: path,
+              typed_calls_count: typed,
+              untyped_calls_count: untyped,
+              error_calls_count: errors
+            )
+          when SourceFile::TypeCheckErrorStatus, SourceFile::AnnotationSyntaxErrorStatus, SourceFile::ParseErrorStatus
+            ErrorStats.new(target: target, path: path, status: source_file.status)
+          end
+        else
+          ErrorStats.new(target: target, path: path, status: target.status)
+        end
+      end
+    end
+  end
+end

data/lib/steep/project/target.rb

@@ -13,9 +13,7 @@ module Steep
 
       attr_reader :status
 
-      SignatureSyntaxErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
-      SignatureValidationErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
-      SignatureOtherErrorStatus = Struct.new(:timestamp, :error, keyword_init: true)
+      SignatureErrorStatus = Struct.new(:timestamp, :errors, keyword_init: true)
       TypeCheckStatus = Struct.new(:environment, :subtyping, :type_check_sources, :timestamp, keyword_init: true)
 
       def initialize(name:, options:, source_patterns:, ignore_patterns:, signature_patterns:)
@@ -137,39 +135,77 @@ module Steep
         @environment ||= RBS::Environment.from_loader(Target.construct_env_loader(options: options))
       end
 
-      def load_signatures(validate:)
-        timestamp = case status
-                    when TypeCheckStatus
-                      status.timestamp
-                    end
-        now = Time.now
-
-        updated_files = []
+      def parse_signatures(timestamp:)
+        updated_signature_files = []
 
         signature_files.each_value do |file|
           if !timestamp || file.content_updated_at >= timestamp
-            updated_files << file
+            Steep.logger.debug { "Loading #{file.path}..."}
+            updated_signature_files << file
             file.load!()
           end
         end
 
-        if signature_files.each_value.all? {|file| file.status.is_a?(SignatureFile::DeclarationsStatus) }
-          if status.is_a?(TypeCheckStatus) && updated_files.empty?
-            yield status.environment, status.subtyping, status.timestamp
-          else
-            begin
-              env = environment.dup
-
-              signature_files.each_value do |file|
-                if file.status.is_a?(SignatureFile::DeclarationsStatus)
-                  file.status.declarations.each do |decl|
-                    env << decl
-                  end
-                end
-              end
+        error_sigs = signature_files.each_value.reject {|file| file.status.is_a?(SignatureFile::DeclarationsStatus) }
 
-              env = env.resolve_type_names
+        if error_sigs.empty?
+          yield updated_signature_files
+        else
+          errors = error_sigs.map do |file|
+            case error = file.status.error
+            when RBS::Parser::SemanticsError
+              Diagnostic::Signature::SyntaxError.new(error, location: error.location)
+            when RBS::Parser::SyntaxError
+              Diagnostic::Signature::SyntaxError.new(error, location: error.error_value.location)
+            end
+          end
+
+          @status = SignatureErrorStatus.new(
+            errors: errors,
+            timestamp: Time.now
+          )
+        end
+      end
+
+      def load_decls(now:)
+        errors = []
+        env = environment.dup
+
+        signature_files.each_value do |file|
+          raise unless file.status.is_a?(SignatureFile::DeclarationsStatus)
+
+          file.status.declarations.each do |decl|
+            env << decl
+          rescue RBS::DuplicatedDeclarationError => exn
+            errors << Diagnostic::Signature::DuplicatedDeclaration.new(
+              type_name: exn.name,
+              location: exn.decls[0].location
+            )
+          end
+        end
 
+        if errors.empty?
+          yield env.resolve_type_names
+        else
+          @status = SignatureErrorStatus.new(
+            errors: errors,
+            timestamp: now
+          )
+        end
+      end
+
+      def load_signatures(validate:)
+        timestamp = case status
+                    when TypeCheckStatus
+                      status.timestamp
+                    end
+        now = Time.now
+
+        parse_signatures(timestamp: timestamp) do |updated_signature_files|
+          if status.is_a?(TypeCheckStatus) && updated_signature_files.empty?
+            yield status.environment, status.subtyping, status.timestamp
+          else
+            load_decls(now: now) do |env|
               definition_builder = RBS::DefinitionBuilder.new(env: env)
               factory = AST::Types::Factory.new(builder: definition_builder)
               check = Subtyping::Check.new(factory: factory)
@@ -181,7 +217,7 @@ module Steep
                 if validator.no_error?
                   yield env, check, now
                 else
-                  @status = SignatureValidationErrorStatus.new(
+                  @status = SignatureErrorStatus.new(
                     errors: validator.each_error.to_a,
                     timestamp: now
                   )
@@ -189,33 +225,8 @@ module Steep
               else
                 yield env, check, Time.now
               end
-            rescue RBS::DuplicatedDeclarationError => exn
-              @status = SignatureValidationErrorStatus.new(
-                errors: [
-                  Signature::Errors::DuplicatedDeclarationError.new(
-                    type_name: exn.name,
-                    location: exn.decls[0].location
-                  )
-                ],
-                timestamp: now
-              )
-            rescue => exn
-              Steep.log_error exn
-              @status = SignatureOtherErrorStatus.new(error: exn, timestamp: now)
-            end
-          end
-
-        else
-          errors = signature_files.each_value.with_object([]) do |file, errors|
-            if file.status.is_a?(SignatureFile::ParseErrorStatus)
-              errors << file.status.error
             end
           end
-
-          @status = SignatureSyntaxErrorStatus.new(
-            errors: errors,
-            timestamp: Time.now
-          )
         end
       end