steep 0.40.0 → 0.44.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,39 +0,0 @@
-module Steep
-  class Project
-    class SignatureFile
-      attr_reader :path
-      attr_reader :content
-      attr_reader :content_updated_at
-
-      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 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)
-        @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/project/stats_calculator.rb

@@ -1,80 +0,0 @@
-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/server/code_worker.rb

@@ -1,150 +0,0 @@
-module Steep
-  module Server
-    class CodeWorker < BaseWorker
-      LSP = LanguageServer::Protocol
-
-      TypeCheckJob = Struct.new(:target, :path, keyword_init: true)
-      StatsJob = Struct.new(:request, :paths, keyword_init: true)
-
-      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 << TypeCheckJob.new(target: target, path: 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 calculate_stats(request_id, paths)
-        calculator = Project::StatsCalculator.new(project: project)
-
-        stats = paths.map do |path|
-          if typecheck_paths.include?(path)
-            if target = project.target_for_source_path(path)
-              calculator.calc_stats(target, path)
-            end
-          end
-        end.compact
-
-        writer.write(
-          id: request_id,
-          result: stats.map(&:as_json)
-        )
-      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
-          formatter = Diagnostic::LSPFormatter.new()
-          status.typing.errors.select {|error| options.error_to_report?(error) }.map {|error| formatter.format(error) }
-        when Project::SourceFile::TypeCheckErrorStatus
-          []
-        end
-      end
-
-      def handle_request(request)
-        case request[:method]
-        when "initialize"
-          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
-
-          writer.write({ id: request[:id], result: nil })
-
-        when "workspace/executeCommand"
-          Steep.logger.info { "Executing command: #{request[:params][:command]}, arguments=#{request[:params][:arguments].map(&:inspect).join(", ")}" }
-          case request[:params][:command]
-          when "steep/registerSourceToWorker"
-            paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
-            typecheck_paths.merge(paths)
-          when "steep/stats"
-            paths = request[:params][:arguments].map {|arg| source_path(URI.parse(arg)) }
-            queue << StatsJob.new(paths: paths, request: request)
-          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)
-        case job
-        when TypeCheckJob
-          typecheck_file(job.path, job.target)
-        when StatsJob
-          calculate_stats(job.request[:id], job.paths)
-        end
-      end
-    end
-  end
-end