steep 0.11.1 → 0.12.0

data/lib/steep/drivers/check.rb

@@ -1,124 +1,88 @@
 module Steep
   module Drivers
     class Check
-      attr_reader :source_paths
-      attr_reader :signature_dirs
       attr_reader :stdout
       attr_reader :stderr
+      attr_reader :command_line_patterns
 
-      attr_accessor :accept_implicit_any
       attr_accessor :dump_all_types
-      attr_accessor :fallback_any_is_error
-      attr_accessor :allow_missing_definitions
 
-      attr_reader :labeling
+      include Utils::DriverHelper
 
-      include Utils::EachSignature
-
-      def initialize(source_paths:, signature_dirs:, stdout:, stderr:)
-        @source_paths = source_paths
-        @signature_dirs = signature_dirs
+      def initialize(stdout:, stderr:)
         @stdout = stdout
         @stderr = stderr
+        @command_line_patterns = []
 
-        self.accept_implicit_any = false
         self.dump_all_types = false
-        self.fallback_any_is_error = false
-        self.allow_missing_definitions = true
-      end
-
-      def options
-        Project::Options.new.tap do |opt|
-          opt.allow_missing_definitions = allow_missing_definitions
-          opt.fallback_any_is_error = fallback_any_is_error
-        end
       end
 
       def run
-        project = Project.new(Project::SyntaxErrorRaisingListener.new)
-
-        source_paths.each do |path|
-          each_file_in_path(".rb", path) do |file_path|
-            file = Project::SourceFile.new(path: file_path, options: options)
-            file.content = file_path.read
-            project.source_files[file_path] = file
-          end
-        end
-
-        signature_dirs.each do |path|
-          each_file_in_path(".rbi", path) do |file_path|
-            file = Project::SignatureFile.new(path: file_path)
-            file.content = file_path.read
-            project.signature_files[file_path] = file
+        project = load_config()
+
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources(command_line_patterns)
+        loader.load_signatures()
+
+        type_check(project)
+
+        if self.dump_all_types
+          project.targets.each do |target|
+            case (status = target.status)
+            when Project::Target::TypeCheckStatus
+              target.source_files.each_value do |file|
+                case (file_status = file.status)
+                when Project::SourceFile::TypeCheckStatus
+                  output_types(file_status.typing)
+                end
+              end
+            end
           end
         end
 
-        project.type_check
-
-        case signature = project.signature
-        when Project::SignatureLoaded
-          output_type_check_result(project)
-          project.has_type_error? ? 1 : 0
-        when Project::SignatureHasError
-          output_signature_errors(project)
-          1
-        end
-      end
-
-      def output_type_check_result(project)
-        # @type var project: Project
-
-        if dump_all_types
-          project.source_files.each_value do |file|
-            lines = []
-
-            if typing = file.typing
-              typing.nodes.each_value do |node|
-                begin
-                  type = typing.type_of(node: node)
-                  lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, type]
-                rescue
-                  lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, nil]
+        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::TypeCheckStatus
+              status.type_check_sources.each do |source_file|
+                source_file.errors.each do |error|
+                  error.print_to stdout
                 end
               end
-
-              lines.sort {|x,y| y <=> x }.reverse_each do |line|
-                source = line[3].loc.expression.source
-                stdout.puts "#{line[0]}:(#{line[2].join(",")}):(#{line[1].join(",")}):\t#{line[3].type}:\t#{line[4]}\t(#{source.split(/\n/).first})"
-              end
             end
           end
         end
 
-        project.source_files.each_value do |file|
-          file.errors&.each do |error|
-            error.print_to stdout
-          end
+        if project.targets.all? {|target| target.status.is_a?(Project::Target::TypeCheckStatus) && target.errors.empty? }
+          Steep.logger.info "No type error found"
+          return 0
         end
+
+        1
       end
 
-      def output_signature_errors(project)
-        project.signature.errors.each do |error|
-          case error
-          when Interface::Instantiated::InvalidMethodOverrideError
-            stdout.puts "😱 #{error.message}"
-            error.result.trace.each do |s, t|
-              case s
-              when Interface::Method
-                stdout.puts "  #{s.name}(#{s.type_name}) <: #{t.name}(#{t.type_name})"
-              when Interface::MethodType
-                stdout.puts "  #{s} <: #{t} (#{s.location&.name||"?"}:#{s.location&.start_line||"?"})"
-              else
-                stdout.puts "  #{s} <: #{t}"
-              end
-            end
-            stdout.puts "  🚨 #{error.result.error.message}"
-          when Interface::Instantiated::InvalidIvarOverrideError
-            stdout.puts "😱 #{error.message}"
-          else
-            stdout.puts "😱 #{error.inspect}"
+      def output_types(typing)
+        lines = []
+
+        typing.nodes.each_value do |node|
+          begin
+            type = typing.type_of(node: node)
+            lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, type]
+          rescue
+            lines << [node.loc.expression.source_buffer.name, [node.loc.last_line,node.loc.last_column], [node.loc.first_line, node.loc.column], node, nil]
           end
         end
+
+        lines.sort {|x,y| y <=> x }.reverse_each do |line|
+          source = line[3].loc.expression.source
+          stdout.puts "#{line[0]}:(#{line[2].join(",")}):(#{line[1].join(",")}):\t#{line[3].type}:\t#{line[4]}\t(#{source.split(/\n/).first})"
+        end
       end
     end
   end

data/lib/steep/drivers/init.rb

@@ -0,0 +1,54 @@
+module Steep
+  module Drivers
+    class Init
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_accessor :force_write
+
+      include Utils::DriverHelper
+
+      TEMPLATE = <<~EOF
+      # target :lib do
+      #   signature "sig"
+      # 
+      #   check "lib"                       # Directory name
+      #   check "Gemfile"                   # File name
+      #   check "app/models/**/*.rb"        # Glob
+      #   # ignore "lib/templates/*.rb"        
+      #   
+      #   # library "pathname", "set"       # Standard libraries
+      #   # library "strong_json"           # Gems
+      # end
+
+      # target :spec do
+      #   signature "sig", "sig-private"
+      # 
+      #   check "spec"
+      # 
+      #   # library "pathname", "set"       # Standard libraries
+      #   # library "rspec"
+      # end
+      EOF
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @force_write = false
+      end
+
+      def run
+        path = steepfile || Pathname("Steepfile")
+
+        if path.file? && !force_write
+          stdout.puts "#{path} already exists, --force to overwrite"
+          return 1
+        end
+
+        stdout.puts "Writing #{path}..."
+        path.write(TEMPLATE)
+
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/langserver.rb

@@ -1,192 +1,283 @@
 module Steep
   module Drivers
     class Langserver
-      attr_reader :source_dirs
-      attr_reader :signature_dirs
-      attr_reader :options
-      attr_reader :subscribers
-      attr_reader :open_paths
-
-      include Utils::EachSignature
-
-      def initialize(source_dirs:, signature_dirs:)
-        @source_dirs = source_dirs
-        @signature_dirs = signature_dirs
-        @options = Project::Options.new
-        @subscribers = {}
-        @open_paths = Set.new
-
-        subscribe :initialize do |request:, notifier:|
-          LanguageServer::Protocol::Interface::InitializeResult.new(
-            capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
-              text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                open_close: true,
-                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
-              ),
-              hover_provider: true
-            ),
-          )
-        end
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :stdin
+      attr_reader :latest_update_version
+      attr_reader :write_mutex
+      attr_reader :type_check_queue
+      attr_reader :type_check_thread
 
-        subscribe :shutdown do |request:, notifier:|
-          Steep.logger.warn "Shutting down the server..."
-          exit
-        end
+      include Utils::DriverHelper
 
-        subscribe :"textDocument/didOpen" do |request:, notifier:|
-          uri = URI.parse(request[:params][:textDocument][:uri])
-          open_path uri
-          text = request[:params][:textDocument][:text]
-          synchronize_project(uri: uri, text: text, notifier: notifier)
-        end
+      TypeCheckRequest = Struct.new(:version, keyword_init: true)
 
-        subscribe :"textDocument/didClose" do |request:, notifier:|
-          uri = URI.parse(request[:params][:textDocument][:uri])
-          close_path uri
-        end
+      def initialize(stdout:, stderr:, stdin:)
+        @stdout = stdout
+        @stderr = stderr
+        @stdin = stdin
+        @write_mutex = Mutex.new
+        @type_check_queue = Queue.new
+      end
 
-        subscribe :"textDocument/didChange" do |request:, notifier:|
-          uri = URI.parse(request[:params][:textDocument][:uri])
-          text = request[:params][:contentChanges][0][:text]
-          synchronize_project(uri: uri, text: text, notifier: notifier)
-        end
+      def writer
+        @writer ||= LanguageServer::Protocol::Transport::Io::Writer.new(stdout)
+      end
 
-        subscribe :"textDocument/hover" do |request:, notifier:|
-          Steep.logger.warn request.inspect
-          uri = URI.parse(request[:params][:textDocument][:uri])
-          line = request[:params][:position][:line]
-          column = request[:params][:position][:character]
-          respond_to_hover(uri: uri, line: line, column: column, notifier: notifier, id: request[:id])
-        end
+      def reader
+        @reader ||= LanguageServer::Protocol::Transport::Io::Reader.new(stdin)
+      end
+
+      def project
+        @project or raise "Empty #project"
       end
 
-      def respond_to_hover(uri:, line:, column:, notifier:, id:)
-        path = Pathname(uri.path).relative_path_from(Pathname.pwd)
+      def enqueue_type_check(version)
+        @latest_update_version = version
+        type_check_queue << TypeCheckRequest.new(version: version)
+      end
 
-        if path.extname == ".rb"
-          # line in LSP is zero-origin
-          project.type_of(path: path, line: line + 1, column: column) do |type, node|
-            Steep.logger.warn "type = #{type.to_s}"
+      def run
+        @project = load_config()
 
-            start_position = { line: node.location.line - 1, character: node.location.column }
-            end_position = { line: node.location.last_line - 1, character: node.location.last_column }
-            range = { start: start_position, end: end_position }
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources([])
+        loader.load_signatures()
 
-            Steep.logger.warn "node = #{node.type}"
-            Steep.logger.warn "range = #{range.inspect}"
+        start_type_check()
 
-            LanguageServer::Protocol::Interface::Hover.new(
-              contents: { kind: "markdown", value: "`#{type}`" },
-              range: range
-            )
+        reader.read do |request|
+          Steep.logger.tagged "lsp" do
+            Steep.logger.debug { "Received a request: request=#{request.to_json}" }
+            handle_request(request) do |id, result|
+              if id
+                write_mutex.synchronize do
+                  Steep.logger.debug { "Writing response to #{id}: #{result.to_json}" }
+                  writer.write(id: id, result: result)
+                end
+              end
+            end
           end
         end
+
+        0
       end
 
-      def subscribe(method, &callback)
-        @subscribers[method] = callback
+      def write(method:, params:)
+        write_mutex.synchronize do
+          Steep.logger.debug { "Sending request: method=#{method}, params=#{params.to_json}"}
+          writer.write(method: method, params: params)
+        end
       end
 
-      def project
-        @project ||= Project.new.tap do |project|
-          source_dirs.each do |path|
-            each_file_in_path(".rb", path) do |file_path|
-              file = Project::SourceFile.new(path: file_path, options: options)
-              file.content = file_path.read
-              project.source_files[file_path] = file
+      def handle_request(request)
+        id = request[:id]
+        method = request[:method].to_sym
+
+        Steep.logger.tagged "id=#{id}, method=#{method}" do
+          case method
+          when :initialize
+            yield id, LanguageServer::Protocol::Interface::InitializeResult.new(
+              capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
+                text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
+                  change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL
+                ),
+                hover_provider: true,
+                )
+            )
+
+            enqueue_type_check nil
+          when :"textDocument/didChange"
+            uri = URI.parse(request[:params][:textDocument][:uri])
+            path = project.relative_path(Pathname(uri.path))
+            text = request[:params][:contentChanges][0][:text]
+
+            Steep.logger.debug { "path=#{path}, content=#{text.lines.first&.chomp}..." }
+
+            project.targets.each do |target|
+              Steep.logger.tagged "target=#{target.name}" do
+                case
+                when target.source_file?(path)
+                  if text.empty? && !path.file?
+                    Steep.logger.info { "Deleting source file: #{path}..." }
+                    target.remove_source(path)
+                    report_diagnostics path, []
+                  else
+                    Steep.logger.info { "Updating source file: #{path}..." }
+                    target.update_source(path, text)
+                  end
+                when target.possible_source_file?(path)
+                  Steep.logger.info { "Adding source file: #{path}..." }
+                  target.add_source(path, text)
+                when target.signature_file?(path)
+                  if text.empty? && !path.file?
+                    Steep.logger.info { "Deleting signature file: #{path}..." }
+                    target.remove_signature(path)
+                    report_diagnostics path, []
+                  else
+                    Steep.logger.info { "Updating signature file: #{path}..." }
+                    target.update_signature(path, text)
+                  end
+                when target.possible_signature_file?(path)
+                  Steep.logger.info { "Adding signature file: #{path}..." }
+                  target.add_signature(path, text)
+                end
+              end
             end
+
+            version = request[:params][:textDocument][:version]
+            enqueue_type_check version
+          when :"textDocument/hover"
+            uri = URI.parse(request[:params][:textDocument][:uri])
+            path = project.relative_path(Pathname(uri.path))
+            line = request[:params][:position][:line]
+            column = request[:params][:position][:character]
+
+            yield id, response_to_hover(path: path, line: line, column: column)
+
+          when :shutdown
+            yield id, nil
+
+          when :exit
+            type_check_queue << nil
+            type_check_thread.join
+            exit
           end
+        end
+      end
 
-          signature_dirs.each do |path|
-            each_file_in_path(".rbi", path) do |file_path|
-              file = Project::SignatureFile.new(path: file_path)
-              file.content = file_path.read
-              project.signature_files[file_path] = file
+      def start_type_check
+        @type_check_thread = Thread.start do
+          while request = type_check_queue.deq
+            if @latest_update_version == nil || @latest_update_version == request.version
+              run_type_check()
             end
           end
         end
       end
 
-      def open_path?(path)
-        open_paths.member?(path)
+      def run_type_check()
+        Steep.logger.tagged "#run_type_check" do
+          Steep.logger.info { "Running type check..." }
+          type_check project
+
+          Steep.logger.info { "Sending diagnostics..." }
+          project.targets.each do |target|
+            Steep.logger.tagged "target=#{target.name}, status=#{target.status.class}" do
+              Steep.logger.info { "Clearing signature diagnostics..." }
+              target.signature_files.each_value do |file|
+                report_diagnostics file.path, []
+              end
+
+              case (status = target.status)
+              when Project::Target::SignatureValidationErrorStatus
+                Steep.logger.info { "Signature validation error" }
+                status.errors.group_by(&:path).each do |path, errors|
+                  diagnostics = errors.map {|error| diagnostic_for_validation_error(error) }
+                  report_diagnostics path, diagnostics
+                end
+              when Project::Target::TypeCheckStatus
+                Steep.logger.info { "Type check" }
+                status.type_check_sources.each do |source|
+                  diagnostics = case source.status
+                                when Project::SourceFile::TypeCheckStatus
+                                  source.errors.map {|error| diagnostic_for_type_error(error) }
+                                when Project::SourceFile::AnnotationSyntaxErrorStatus
+                                  [diagnostics_raw(source.status.error.message, source.status.location)]
+                                when Project::SourceFile::ParseErrorStatus
+                                  []
+                                end
+
+                  report_diagnostics source.path, diagnostics
+                end
+              when Project::Target::SignatureSyntaxErrorStatus
+                Steep.logger.info { "Signature syntax error" }
+              end
+            end
+          end
+        end
       end
 
-      def open_path(path)
-        open_paths << path
+      def report_diagnostics(path, diagnostics)
+        Steep.logger.info { "Reporting #{diagnostics.size} diagnostics for #{path}..." }
+        write(
+          method: :"textDocument/publishDiagnostics",
+          params: LanguageServer::Protocol::Interface::PublishDiagnosticsParams.new(
+            uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
+            diagnostics: diagnostics,
+          )
+        )
       end
 
-      def close_path(path)
-        open_paths.delete path
+      def diagnostic_for_validation_error(error)
+        LanguageServer::Protocol::Interface::Diagnostic.new(
+          message: StringIO.new("").tap {|io| error.puts(io) }.string,
+          severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: error.location.start_line - 1,
+              character: error.location.start_column,
+              ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: error.location.end_line - 1,
+              character: error.location.end_column,
+              ),
+            )
+        )
       end
 
-      def run
-        writer = LanguageServer::Protocol::Transport::Stdio::Writer.new
-        reader = LanguageServer::Protocol::Transport::Stdio::Reader.new
-        notifier = Proc.new { |method:, params: {}| writer.write(method: method, params: params) }
+      def diagnostics_raw(message, loc)
+        LanguageServer::Protocol::Interface::Diagnostic.new(
+          message: message,
+          severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: loc.start_line - 1,
+              character: loc.start_column,
+              ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: loc.end_line - 1,
+              character: loc.end_column,
+              ),
+            )
+        )
+      end
 
-        reader.read do |request|
-          id = request[:id]
-          method = request[:method].to_sym
-          Steep.logger.warn "Received event: #{method}"
-          subscriber = subscribers[method]
-          if subscriber
-            result = subscriber.call(request: request, notifier: notifier)
-            if id && result
-              writer.write(id: id, result: result)
-            end
-          else
-            Steep.logger.warn "Ignored event: #{method}"
-          end
-        end
+      def diagnostic_for_type_error(error)
+        LanguageServer::Protocol::Interface::Diagnostic.new(
+          message: error.to_s,
+          severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: error.node.loc.line - 1,
+              character: error.node.loc.column,
+              ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: error.node.loc.last_line - 1,
+              character: error.node.loc.last_column,
+              ),
+            )
+        )
       end
 
-      def synchronize_project(uri:, text:, notifier:)
-        path = Pathname(uri.path).relative_path_from(Pathname.pwd)
-
-        case path.extname
-        when ".rb"
-          file = project.source_files[path] || Project::SourceFile.new(path: path, options: options)
-          file.content = text
-          project.source_files[path] = file
-        when ".rbi"
-          file = project.signature_files[path] || Project::SignatureFile.new(path: path)
-          file.content = text
-          project.signature_files[path] = file
-        end
+      def response_to_hover(path:, line:, column:)
+        Steep.logger.info { "path=#{path}, line=#{line}, column=#{column}" }
 
-        project.type_check
-
-        open_paths.each do |uri|
-          Pathname(uri.path).relative_path_from(Pathname.pwd).yield_self do |path|
-            case path.extname
-            when ".rb"
-              file = project.source_files[path] || Project::SourceFile.new(path: path, options: options)
-              diags = (file.errors || []).map do |error|
-                LanguageServer::Protocol::Interface::Diagnostic.new(
-                  message: error.to_s,
-                  severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-                  range: LanguageServer::Protocol::Interface::Range.new(
-                    start: LanguageServer::Protocol::Interface::Position.new(
-                      line: error.node.loc.line - 1,
-                      character: error.node.loc.column,
-                      ),
-                    end: LanguageServer::Protocol::Interface::Position.new(
-                      line: error.node.loc.last_line - 1,
-                      character: error.node.loc.last_column,
-                      ),
-                    )
-                )
-              end
+        # line in LSP is zero-origin
+        project.type_of_node(path: path, line: line + 1, column: column) do |type, node|
+          Steep.logger.warn { "node = #{node.type}, type = #{type.to_s}" }
 
-              notifier.call(
-                method: :"textDocument/publishDiagnostics",
-                params: LanguageServer::Protocol::Interface::PublishDiagnosticsParams.new(
-                  uri: uri,
-                  diagnostics: diags,
-                  ),
-                )
-            end
-          end
+          start_position = { line: node.location.line - 1, character: node.location.column }
+          end_position = { line: node.location.last_line - 1, character: node.location.last_column }
+          range = { start: start_position, end: end_position }
+
+          Steep.logger.warn { "range = #{range.inspect}" }
+
+          LanguageServer::Protocol::Interface::Hover.new(
+            contents: { kind: "markdown", value: "`#{type}`" },
+            range: range
+          )
         end
       end
     end