steep 0.37.0 → 0.42.0

data/lib/steep/project/file_loader.rb

@@ -1,68 +0,0 @@
-module Steep
-  class Project
-    class FileLoader
-      attr_reader :project
-
-      def initialize(project:)
-        @project = project
-      end
-
-      def each_path_in_patterns(patterns, ext)
-        patterns.each do |path|
-          absolute_path = project.base_dir + path
-
-          if absolute_path.file?
-            yield project.relative_path(absolute_path)
-          else
-            files = if absolute_path.directory?
-                      Pathname.glob("#{absolute_path}/**/*#{ext}")
-                    else
-                      Pathname.glob(absolute_path)
-                    end
-
-            files.sort.each do |source_path|
-              yield project.relative_path(source_path)
-            end
-          end
-        end
-      end
-
-      def load_sources(command_line_patterns)
-        loaded_paths = Set[]
-
-        project.targets.each do |target|
-          Steep.logger.tagged "target=#{target.name}" do
-            target_patterns = command_line_patterns.empty? ? target.source_patterns : command_line_patterns
-
-            each_path_in_patterns(target_patterns, ".rb") do |path|
-              if target.possible_source_file?(path)
-                if loaded_paths.include?(path)
-                  Steep.logger.warn { "Skipping #{target} while loading #{path}... (Already loaded to another target.)" }
-                else
-                  Steep.logger.info { "Adding source file: #{path}" }
-                  target.add_source path, project.absolute_path(path).read
-                  loaded_paths << path
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def load_signatures()
-        project.targets.each do |target|
-          Steep.logger.tagged "target=#{target.name}" do
-            each_path_in_patterns target.signature_patterns, ".rbs" do |path|
-              if target.possible_signature_file?(path)
-                unless target.signature_file?(path)
-                  Steep.logger.info { "Adding signature file: #{path}" }
-                  target.add_signature path, project.absolute_path(path).read
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/steep/project/signature_file.rb

@@ -1,33 +0,0 @@
-module Steep
-  class Project
-    class SignatureFile
-      attr_reader :path
-      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)
-
-      def initialize(path:)
-        @path = path
-        self.content = ""
-      end
-
-      def content=(content)
-        @content_updated_at = Time.now
-        @content = content
-        @status = nil
-      end
-
-      def load!
-        buffer = RBS::Buffer.new(name: path, content: content)
-        decls = RBS::Parser.parse_signature(buffer)
-        @status = DeclarationsStatus.new(declarations: decls, timestamp: Time.now)
-      rescue RBS::Parser::SyntaxError, RBS::Parser::SemanticsError => exn
-        @status = ParseErrorStatus.new(error: exn, timestamp: Time.now)
-      end
-    end
-  end
-end

data/lib/steep/project/source_file.rb

@@ -1,129 +0,0 @@
-module Steep
-  class Project
-    class SourceFile
-      attr_reader :path
-      attr_reader :content
-      attr_reader :content_updated_at
-      attr_reader :factory
-
-      attr_accessor :status
-
-      ParseErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
-      AnnotationSyntaxErrorStatus = Struct.new(:error, :location, :timestamp, keyword_init: true)
-      TypeCheckStatus = Struct.new(:typing, :source, :timestamp, keyword_init: true)
-      TypeCheckErrorStatus = Struct.new(:error, :timestamp, keyword_init: true)
-
-      def initialize(path:)
-        @path = path
-        @content = false
-        self.content = ""
-      end
-
-      def content=(content)
-        @content_updated_at = Time.now
-        @content = content
-        @status = nil
-      end
-
-      def errors
-        case status
-        when TypeCheckStatus
-          status.typing.errors
-        else
-          []
-        end
-      end
-
-      def self.parse(source_code, path:, factory:)
-        Source.parse(source_code, path: path.to_s, factory: factory, labeling: ASTUtils::Labeling.new)
-      end
-
-      def self.type_check(source, subtyping:)
-        annotations = source.annotations(block: source.node, factory: subtyping.factory, current_module: RBS::Namespace.root)
-        const_env = TypeInference::ConstantEnv.new(factory: subtyping.factory, context: [RBS::Namespace.root])
-        type_env = TypeInference::TypeEnv.build(annotations: annotations,
-                                                subtyping: subtyping,
-                                                const_env: const_env,
-                                                signatures: subtyping.factory.env)
-        lvar_env = TypeInference::LocalVariableTypeEnv.empty(
-          subtyping: subtyping,
-          self_type: AST::Builtin::Object.instance_type
-        ).annotate(annotations)
-
-        context = TypeInference::Context.new(
-          block_context: nil,
-          module_context: TypeInference::Context::ModuleContext.new(
-            instance_type: AST::Builtin::Object.instance_type,
-            module_type: AST::Builtin::Object.module_type,
-            implement_name: nil,
-            current_namespace: RBS::Namespace.root,
-            const_env: const_env,
-            class_name: AST::Builtin::Object.module_name,
-            instance_definition: subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name),
-            module_definition: subtyping.factory.definition_builder.build_singleton(AST::Builtin::Object.module_name)
-          ),
-          method_context: nil,
-          break_context: nil,
-          self_type: AST::Builtin::Object.instance_type,
-          type_env: type_env,
-          lvar_env: lvar_env,
-          call_context: TypeInference::MethodCall::TopLevelContext.new
-        )
-
-        typing = Typing.new(source: source, root_context: context)
-
-        construction = TypeConstruction.new(
-          checker: subtyping,
-          annotations: annotations,
-          source: source,
-          context: context,
-          typing: typing
-        )
-
-        construction.synthesize(source.node) if source.node
-
-        typing
-      end
-
-      def type_check(subtyping, env_updated_at)
-        # skip type check
-        return false if status && env_updated_at <= status.timestamp
-
-        now = Time.now
-
-        parse(subtyping.factory) do |source|
-          typing = self.class.type_check(source, subtyping: subtyping)
-          @status = TypeCheckStatus.new(typing: typing, source: source, timestamp: now)
-        rescue RBS::NoTypeFoundError,
-          RBS::NoMixinFoundError,
-          RBS::NoSuperclassFoundError,
-          RBS::DuplicatedMethodDefinitionError,
-          RBS::InvalidTypeApplicationError => exn
-          # Skip logging known signature errors (they are handled with load_signatures(validate: true))
-          @status = TypeCheckErrorStatus.new(error: exn, timestamp: now)
-        rescue => exn
-          Steep.log_error(exn)
-          @status = TypeCheckErrorStatus.new(error: exn, timestamp: now)
-        end
-
-        true
-      end
-
-      def parse(factory)
-        now = Time.now
-
-        if status.is_a?(TypeCheckStatus)
-          yield status.source
-        else
-          yield self.class.parse(content, path: path, factory: factory)
-        end
-      rescue AnnotationParser::SyntaxError => exn
-        Steep.logger.warn { "Annotation syntax error on #{path}: #{exn.inspect}" }
-        @status = AnnotationSyntaxErrorStatus.new(error: exn, location: exn.location, timestamp: now)
-      rescue ::Parser::SyntaxError, EncodingError => exn
-        Steep.logger.warn { "Source parsing error on #{path}: #{exn.inspect}" }
-        @status = ParseErrorStatus.new(error: exn, timestamp: now)
-      end
-    end
-  end
-end

data/lib/steep/server/code_worker.rb

@@ -1,137 +0,0 @@
-module Steep
-  module Server
-    class CodeWorker < BaseWorker
-      LSP = LanguageServer::Protocol
-
-      include Utils
-
-      attr_reader :typecheck_paths
-      attr_reader :queue
-
-      def initialize(project:, reader:, writer:, queue: Queue.new)
-        super(project: project, reader: reader, writer: writer)
-
-        @typecheck_paths = Set[]
-        @queue = queue
-      end
-
-      def enqueue_type_check(target:, path:)
-        Steep.logger.info "Enqueueing type check: #{target.name}::#{path}..."
-        queue << [target, path]
-      end
-
-      def typecheck_file(path, target)
-        Steep.logger.info "Starting type checking: #{target.name}::#{path}..."
-
-        source = target.source_files[path]
-        target.type_check(target_sources: [source], validate_signatures: false)
-
-        if target.status.is_a?(Project::Target::TypeCheckStatus) && target.status.type_check_sources.empty?
-          Steep.logger.debug "Skipped type checking: #{target.name}::#{path}"
-        else
-          Steep.logger.info "Finished type checking: #{target.name}::#{path}"
-        end
-
-        diagnostics = source_diagnostics(source, target.options)
-
-        writer.write(
-          method: :"textDocument/publishDiagnostics",
-          params: LSP::Interface::PublishDiagnosticsParams.new(
-            uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
-            diagnostics: diagnostics
-          )
-        )
-      end
-
-      def source_diagnostics(source, options)
-        case status = source.status
-        when Project::SourceFile::ParseErrorStatus
-          []
-        when Project::SourceFile::AnnotationSyntaxErrorStatus
-          [
-            LSP::Interface::Diagnostic.new(
-              message: "Annotation syntax error: #{status.error.cause.message}",
-              severity: LSP::Constant::DiagnosticSeverity::ERROR,
-              range: LSP::Interface::Range.new(
-                start: LSP::Interface::Position.new(
-                  line: status.location.start_line - 1,
-                  character: status.location.start_column
-                ),
-                end: LSP::Interface::Position.new(
-                  line: status.location.end_line - 1,
-                  character: status.location.end_column
-                )
-              )
-            )
-          ]
-        when Project::SourceFile::TypeCheckStatus
-          status.typing.errors.select {|error| options.error_to_report?(error) }.map do |error|
-            loc = error.location_to_str
-
-            LSP::Interface::Diagnostic.new(
-              message: StringIO.new.tap {|io| error.print_to(io) }.string.gsub(/\A#{Regexp.escape(loc)}: /, "").chomp,
-              severity: LSP::Constant::DiagnosticSeverity::ERROR,
-              range: LSP::Interface::Range.new(
-                start: LSP::Interface::Position.new(
-                  line: error.node.loc.line - 1,
-                  character: error.node.loc.column
-                ),
-                end: LSP::Interface::Position.new(
-                  line: error.node.loc.last_line - 1,
-                  character: error.node.loc.last_column
-                )
-              )
-            )
-          end
-        when Project::SourceFile::TypeCheckErrorStatus
-          []
-        end
-      end
-
-      def handle_request(request)
-        case request[:method]
-        when "initialize"
-          # Don't respond to initialize request, but start type checking.
-          project.targets.each do |target|
-            target.source_files.each_key do |path|
-              if typecheck_paths.include?(path)
-                enqueue_type_check(target: target, path: path)
-              end
-            end
-          end
-
-        when "workspace/executeCommand"
-          if request[:params][:command] == "steep/registerSourceToWorker"
-            paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
-            typecheck_paths.merge(paths)
-          end
-
-        when "textDocument/didChange"
-          update_source(request) do |path, _|
-            source_target, signature_targets = project.targets_for_path(path)
-
-            if source_target
-              if typecheck_paths.include?(path)
-                enqueue_type_check(target: source_target, path: path)
-              end
-            end
-
-            signature_targets.each do |target|
-              target.source_files.each_key do |source_path|
-                if typecheck_paths.include?(source_path)
-                  enqueue_type_check(target: target, path: source_path)
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def handle_job(job)
-        target, path = job
-
-        typecheck_file(path, target)
-      end
-    end
-  end
-end

data/lib/steep/server/signature_worker.rb

@@ -1,152 +0,0 @@
-module Steep
-  module Server
-    class SignatureWorker < BaseWorker
-      attr_reader :queue
-      attr_reader :last_target_validated_at
-
-      def initialize(project:, reader:, writer:, queue: Queue.new)
-        super(project: project, reader: reader, writer: writer)
-
-        @queue = queue
-        @last_target_validated_at = {}
-      end
-
-      def validate_signature_if_required(request)
-        path = source_path(URI.parse(request[:params][:textDocument][:uri]))
-
-        project.targets.each do |target|
-          if target.signature_file?(path)
-            enqueue_target target: target, timestamp: Time.now
-          end
-        end
-      end
-
-      def enqueue_target(target:, timestamp:)
-        Steep.logger.debug "queueing target #{target.name}@#{timestamp}"
-        last_target_validated_at[target] = timestamp
-        queue << [target, timestamp]
-      end
-
-      def handle_request(request)
-        case request[:method]
-        when "initialize"
-          # Don't respond to initialize request, but start type checking.
-          project.targets.each do |target|
-            enqueue_target(target: target, timestamp: Time.now)
-          end
-        when "textDocument/didChange"
-          update_source(request)
-          validate_signature_if_required(request)
-        end
-      end
-
-      def validate_signature(target, timestamp:)
-        Steep.logger.info "Starting signature validation: #{target.name} (#{timestamp})..."
-
-        target.type_check(target_sources: [], validate_signatures: true)
-
-        Steep.logger.info "Finished signature validation: #{target.name} (#{timestamp})"
-
-        diagnostics = case status = target.status
-                      when Project::Target::SignatureSyntaxErrorStatus
-                        target.signature_files.each.with_object({}) do |(path, file), hash|
-                          if file.status.is_a?(Project::SignatureFile::ParseErrorStatus)
-                            location = case error = file.status.error
-                                       when RBS::Parser::SyntaxError
-                                         if error.error_value.is_a?(String)
-                                           buf = RBS::Buffer.new(name: path, content: file.content)
-                                           RBS::Location.new(buffer: buf, start_pos: buf.content.size, end_pos: buf.content.size)
-                                         else
-                                           error.error_value.location
-                                         end
-                                       when RBS::Parser::SemanticsError
-                                         error.location
-                                       else
-                                         raise
-                                       end
-
-                            hash[path] =
-                              [
-                                LSP::Interface::Diagnostic.new(
-                                  message: file.status.error.message,
-                                  severity: LSP::Constant::DiagnosticSeverity::ERROR,
-                                  range: LSP::Interface::Range.new(
-                                    start: LSP::Interface::Position.new(
-                                      line: location.start_line - 1,
-                                      character: location.start_column,
-                                    ),
-                                    end: LSP::Interface::Position.new(
-                                      line: location.end_line - 1,
-                                      character: location.end_column
-                                    )
-                                  )
-                                )
-                              ]
-                          else
-                            hash[path] = []
-                          end
-                        end
-                      when Project::Target::SignatureValidationErrorStatus
-                        error_hash = status.errors.group_by {|error| error.location.buffer.name }
-
-                        target.signature_files.each_key.with_object({}) do |path, hash|
-                          errors = error_hash[path] || []
-                          hash[path] = errors.map do |error|
-                            LSP::Interface::Diagnostic.new(
-                              message: StringIO.new.tap {|io| error.puts(io) }.string.split(/\t/, 2).last,
-                              severity: LSP::Constant::DiagnosticSeverity::ERROR,
-                              range: LSP::Interface::Range.new(
-                                start: LSP::Interface::Position.new(
-                                  line: error.location.start_line - 1,
-                                  character: error.location.start_column,
-                                  ),
-                                end: LSP::Interface::Position.new(
-                                  line: error.location.end_line - 1,
-                                  character: error.location.end_column
-                                )
-                              )
-                            )
-                          end
-                        end
-                      when Project::Target::TypeCheckStatus
-                        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|
-          writer.write(
-            method: :"textDocument/publishDiagnostics",
-            params: LSP::Interface::PublishDiagnosticsParams.new(
-              uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
-              diagnostics: diags
-            )
-          )
-        end
-      end
-
-      def active_job?(target, timestamp)
-        if last_target_validated_at[target] == timestamp
-          sleep 0.1
-          last_target_validated_at[target] == timestamp
-        end
-      end
-
-      def handle_job(job)
-        target, timestamp = job
-
-        if active_job?(target, timestamp)
-          validate_signature(target, timestamp: timestamp)
-        else
-          Steep.logger.info "Skipping signature validation: #{target.name}, queued timestamp=#{timestamp}, latest timestamp=#{last_target_validated_at[target]}"
-        end
-      end
-    end
-  end
-end