steep 0.43.1 → 0.46.0

data/lib/steep/project/dsl.rb

@@ -7,21 +7,21 @@ module Steep
         attr_reader :libraries
         attr_reader :signatures
         attr_reader :ignored_sources
-        attr_reader :vendor_dir
-        attr_reader :strictness_level
-        attr_reader :typing_option_hash
+        attr_reader :stdlib_root
+        attr_reader :core_root
         attr_reader :repo_paths
+        attr_reader :code_diagnostics_config
 
-        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [])
+        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {})
           @name = name
           @sources = sources
           @libraries = libraries
           @signatures = signatures
           @ignored_sources = ignored_sources
-          @vendor_dir = nil
-          @strictness_level = :default
-          @typing_option_hash = {}
+          @core_root = nil
+          @stdlib_root = nil
           @repo_paths = []
+          @code_diagnostics_config = code_diagnostics_config
         end
 
         def initialize_copy(other)
@@ -30,10 +30,10 @@ module Steep
           @libraries = other.libraries.dup
           @signatures = other.signatures.dup
           @ignored_sources = other.ignored_sources.dup
-          @vendor_dir = other.vendor_dir
-          @strictness_level = other.strictness_level
-          @typing_option_hash = other.typing_option_hash
           @repo_paths = other.repo_paths.dup
+          @core_root = other.core_root
+          @stdlib_root = other.stdlib_root
+          @code_diagnostics_config = other.code_diagnostics_config.dup
         end
 
         def check(*args)
@@ -48,9 +48,52 @@ module Steep
           libraries.push(*args)
         end
 
-        def typing_options(level = @strictness_level, **hash)
-          @strictness_level = level
-          @typing_option_hash = hash
+        def typing_options(level = nil, **hash)
+          Steep.logger.error "#typing_options is deprecated and has no effect as of version 0.46.0. Update your Steepfile as follows for (almost) equivalent setting:"
+
+          messages = []
+
+          messages << "# D = Steep::Diagnostic                          # Define a constant to shorten namespace"
+
+          case level
+          when :strict
+            messages << "configure_code_diagnostics(D::Ruby.strict)       # :strict"
+          when :default
+            messages << "configure_code_diagnostics(D::Ruby.default)      # :default"
+          when :lenient
+            messages << "configure_code_diagnostics(D::Ruby.lenient)      # :lenient"
+          end
+
+          messages.each do |msg|
+            Steep.logger.error "  #{msg}"
+          end
+
+          config = []
+
+          if hash[:allow_missing_definitions]
+            config << "hash[D::Ruby::MethodDefinitionMissing] = nil   # allow_missing_definitions"
+          end
+
+          if hash[:allow_fallback_any]
+            config << "hash[D::Ruby::FallbackAny] = nil               # allow_fallback_any"
+          end
+
+          if hash[:allow_unknown_constant_assignment]
+            config << "hash[D::Ruby::UnknownConstantAssigned] = nil   # allow_unknown_constant_assignment"
+          end
+
+          if hash[:allow_unknown_method_calls]
+            config << "hash[D::Ruby::NoMethod] = nil                  # allow_unknown_method_calls"
+          end
+
+          unless config.empty?
+            Steep.logger.error "  configure_code_diagnostics do |hash|"
+            config.each do |c|
+              Steep.logger.error "    #{c}"
+            end
+            Steep.logger.error "  end"
+          end
+
         end
 
         def signature(*args)
@@ -68,20 +111,50 @@ module Steep
         end
 
         def no_builtin!(value = true)
-          Steep.logger.error "`no_builtin!` in Steepfile is deprecated and ignored. Use `vendor` instead."
+          Steep.logger.error "`#no_builtin!` in Steepfile is deprecated and ignored. Use `#stdlib_path` instead."
         end
 
         def vendor(dir = "vendor/sigs", stdlib: nil, gems: nil)
-          if stdlib || gems
-            Steep.logger.warn { "#vendor with stdlib: or gems: keyword is deprecated." }
-          end
+          Steep.logger.error "`#vendor` in Steepfile is deprecated and ignored. Use `#stdlib_path` instead."
+        end
 
-          @vendor_dir = Pathname(dir)
+        def stdlib_path(core_root:, stdlib_root:)
+          @core_root = core_root ? Pathname(core_root) : core_root
+          @stdlib_root = stdlib_root ? Pathname(stdlib_root) : stdlib_root
         end
 
         def repo_path(*paths)
           @repo_paths.push(*paths.map {|s| Pathname(s) })
         end
+
+        # Configure the code diagnostics printing setup.
+        #
+        # Yields a hash, and the update the hash in the block.
+        #
+        # ```rb
+        # D = Steep::Diagnostic
+        #
+        # configure_code_diagnostics do |hash|
+        #   # Assign one of :error, :warning, :information, :hint or :nil to error classes.
+        #   hash[D::Ruby::UnexpectedPositionalArgument] = :error
+        # end
+        # ```
+        #
+        # Passing a hash is also allowed.
+        #
+        # ```rb
+        # D = Steep::Diagnostic
+        #
+        # configure_code_diagnostics(D::Ruby.lenient)
+        # ```
+        #
+        def configure_code_diagnostics(hash = nil)
+          if hash
+            code_diagnostics_config.merge!(hash)
+          end
+
+          yield code_diagnostics_config if block_given?
+        end
       end
 
       attr_reader :project
@@ -107,7 +180,9 @@ module Steep
       end
 
       def self.parse(project, code, filename: "Steepfile")
-        self.new(project: project).instance_eval(code, filename)
+        Steep.logger.tagged filename do
+          self.new(project: project).instance_eval(code, filename)
+        end
       end
 
       def target(name, template: nil, &block)
@@ -115,10 +190,12 @@ module Steep
                    self.class.templates[template]&.dup&.update(name: name) or
                      raise "Unknown template: #{template}, available templates: #{@@templates.keys.join(", ")}"
                  else
-                   TargetDSL.new(name)
+                   TargetDSL.new(name, code_diagnostics_config: Diagnostic::Ruby.default.dup)
                  end
 
-        target.instance_eval(&block) if block_given?
+        Steep.logger.tagged "target=#{name}" do
+          target.instance_eval(&block) if block_given?
+        end
 
         source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
         signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
@@ -129,18 +206,13 @@ module Steep
           signature_pattern: signature_pattern,
           options: Options.new.tap do |options|
             options.libraries.push(*target.libraries)
-            options.repository_paths.push(*target.repo_paths)
-            options.vendor_path = target.vendor_dir
-
-            case target.strictness_level
-            when :strict
-              options.apply_strict_typing_options!
-            when :lenient
-              options.apply_lenient_typing_options!
-            end
-
-            options.merge!(target.typing_option_hash)
-          end
+            options.paths = Options::PathOptions.new(
+              core_root: target.core_root,
+              stdlib_root: target.stdlib_root,
+              repo_paths: target.repo_paths
+            )
+          end,
+          code_diagnostics_config: target.code_diagnostics_config
         ).tap do |target|
           project.targets << target
         end

data/lib/steep/project/options.rb

@@ -1,63 +1,22 @@
 module Steep
   class Project
     class Options
-      attr_accessor :allow_fallback_any
-      attr_accessor :allow_missing_definitions
-      attr_accessor :allow_unknown_constant_assignment
-      attr_accessor :allow_unknown_method_calls
-      attr_accessor :vendor_path
-      attr_reader :libraries
-      attr_reader :repository_paths
-
-      def initialize
-        apply_default_typing_options!
-        self.vendor_path = nil
-
-        @libraries = []
-        @repository_paths = []
-      end
-
-      def apply_default_typing_options!
-        self.allow_fallback_any = true
-        self.allow_missing_definitions = true
-        self.allow_unknown_constant_assignment = false
-        self.allow_unknown_method_calls = false
-      end
-
-      def apply_strict_typing_options!
-        self.allow_fallback_any = false
-        self.allow_missing_definitions = false
-        self.allow_unknown_constant_assignment = false
-        self.allow_unknown_method_calls = false
-      end
-
-      def apply_lenient_typing_options!
-        self.allow_fallback_any = true
-        self.allow_missing_definitions = true
-        self.allow_unknown_constant_assignment = true
-        self.allow_unknown_method_calls = true
-      end
+      PathOptions = Struct.new(:core_root, :stdlib_root, :repo_paths, keyword_init: true) do
+        def customized_stdlib?
+          stdlib_root != nil
+        end
 
-      def error_to_report?(error)
-        case
-        when error.is_a?(Diagnostic::Ruby::FallbackAny)
-          !allow_fallback_any
-        when error.is_a?(Diagnostic::Ruby::MethodDefinitionMissing)
-          !allow_missing_definitions
-        when error.is_a?(Diagnostic::Ruby::NoMethod)
-          !allow_unknown_method_calls
-        when error.is_a?(Diagnostic::Ruby::UnknownConstantAssigned)
-          !allow_unknown_constant_assignment
-        else
-          true
+        def customized_core?
+          core_root != nil
         end
       end
 
-      def merge!(hash)
-        self.allow_fallback_any = hash[:allow_fallback_any] if hash.key?(:allow_fallback_any)
-        self.allow_missing_definitions = hash[:allow_missing_definitions] if hash.key?(:allow_missing_definitions)
-        self.allow_unknown_constant_assignment = hash[:allow_unknown_constant_assignment] if hash.key?(:allow_unknown_constant_assignment)
-        self.allow_unknown_method_calls = hash[:allow_unknown_method_calls] if hash.key?(:allow_unknown_method_calls)
+      attr_reader :libraries
+      attr_accessor :paths
+
+      def initialize
+        @paths = PathOptions.new(repo_paths: [])
+        @libraries = []
       end
     end
   end

data/lib/steep/project/target.rb

@@ -6,12 +6,14 @@ module Steep
 
       attr_reader :source_pattern
       attr_reader :signature_pattern
+      attr_reader :code_diagnostics_config
 
-      def initialize(name:, options:, source_pattern:, signature_pattern:)
+      def initialize(name:, options:, source_pattern:, signature_pattern:, code_diagnostics_config:)
         @name = name
         @options = options
         @source_pattern = source_pattern
         @signature_pattern = signature_pattern
+        @code_diagnostics_config = code_diagnostics_config
 
         @source_files = {}
         @signature_files = {}
@@ -30,16 +32,27 @@ module Steep
       end
 
       def self.construct_env_loader(options:, project:)
-        repo = RBS::Repository.new(no_stdlib: options.vendor_path)
-        options.repository_paths.each do |path|
+        repo = RBS::Repository.new(no_stdlib: options.paths.customized_stdlib?)
+
+        if options.paths.stdlib_root
+          repo.add(project.absolute_path(options.paths.stdlib_root))
+        end
+
+        options.paths.repo_paths.each do |path|
           repo.add(project.absolute_path(path))
         end
 
-        loader = RBS::EnvironmentLoader.new(
-          core_root: options.vendor_path ? nil : RBS::EnvironmentLoader::DEFAULT_CORE_ROOT,
-          repository: repo
-        )
-        loader.add(path: options.vendor_path) if options.vendor_path
+        core_root_path =
+          if options.paths.customized_core?
+            if options.paths.core_root
+              project.absolute_path(options.paths.core_root)
+            end
+          else
+            RBS::EnvironmentLoader::DEFAULT_CORE_ROOT
+          end
+
+        loader = RBS::EnvironmentLoader.new(core_root: core_root_path, repository: repo)
+
         options.libraries.each do |lib|
           name, version = lib.split(/:/, 2)
           loader.add(library: name, version: version)

data/lib/steep/server/interaction_worker.rb

@@ -7,6 +7,8 @@ module Steep
       HoverJob = Struct.new(:id, :path, :line, :column, keyword_init: true)
       CompletionJob = Struct.new(:id, :path, :line, :column, :trigger, keyword_init: true)
 
+      LSP = LanguageServer::Protocol
+
       attr_reader :service
 
       def initialize(project:, reader:, writer:, queue: Queue.new)
@@ -65,7 +67,7 @@ module Steep
           uri = URI.parse(params[:textDocument][:uri])
           path = project.relative_path(Pathname(uri.path))
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
-          trigger = params[:context][:triggerCharacter]
+          trigger = params.dig(:context, :triggerCharacter)
 
           queue << CompletionJob.new(id: id, path: path, line: line, column: column, trigger: trigger)
         end
@@ -77,11 +79,12 @@ module Steep
             Steep.logger.info { "path=#{job.path}, line=#{job.line}, column=#{job.column}" }
 
             hover = Services::HoverContent.new(service: service)
-            content = hover.content_for(path: job.path, line: job.line, column: job.column+1)
+            content = hover.content_for(path: job.path, line: job.line, column: job.column)
             if content
               range = content.location.yield_self do |location|
-                start_position = { line: location.line - 1, character: location.column }
-                end_position = { line: location.last_line - 1, character: location.last_column }
+                lsp_range = location.as_lsp_range
+                start_position = { line: lsp_range[:start][:line], character: lsp_range[:start][:character] }
+                end_position = { line: lsp_range[:end][:line], character: lsp_range[:end][:character] }
                 { start: start_position, end: end_position }
               end
 
@@ -99,6 +102,36 @@ module Steep
 
       def format_hover(content)
         case content
+        when Services::HoverContent::TypeAliasContent
+          comment = content.decl.comment&.string || ''
+
+          <<-MD
+#{comment}
+
+```rbs
+#{retrieve_decl_information(content.decl)}
+```
+          MD
+        when Services::HoverContent::InterfaceContent
+          comment = content.decl.comment&.string || ''
+
+          <<-MD
+#{comment}
+
+```rbs
+#{retrieve_decl_information(content.decl)}
+```
+          MD
+        when Services::HoverContent::ClassContent
+          comment = content.decl.comment&.string || ''
+
+          <<-MD
+#{comment}
+
+```rbs
+#{retrieve_decl_information(content.decl)}
+```
+          MD
         when Services::HoverContent::VariableContent
           "`#{content.name}`: `#{content.type.to_s}`"
         when Services::HoverContent::MethodCallContent
@@ -151,32 +184,207 @@ HOVER
         Steep.logger.tagged("#response_to_completion") do
           Steep.measure "Generating response" do
             Steep.logger.info "path: #{job.path}, line: #{job.line}, column: #{job.column}, trigger: #{job.trigger}"
+            case
+            when target = project.target_for_source_path(job.path)
+              file = service.source_files[job.path] or return
+              subtyping = service.signature_services[target.name].current_subtyping or return
+
+              provider = Services::CompletionProvider.new(source_text: file.content, path: job.path, subtyping: subtyping)
+              items = begin
+                        provider.run(line: job.line, column: job.column)
+                      rescue Parser::SyntaxError
+                        []
+                      end
+
+              completion_items = items.map do |item|
+                format_completion_item(item)
+              end
+
+              Steep.logger.debug "items = #{completion_items.inspect}"
+
+              LSP::Interface::CompletionList.new(
+                is_incomplete: false,
+                items: completion_items
+              )
+            when (_, targets = project.targets_for_path(job.path))
+              target = targets[0] or return
+              sig_service = service.signature_services[target.name]
+              relative_path = job.path
+              buffer = RBS::Buffer.new(name: relative_path, content: sig_service.files[relative_path].content)
+              pos = buffer.loc_to_pos([job.line, job.column])
+              prefix = buffer.content[0...pos].reverse[/\A[\w\d]*/].reverse
+
+              case sig_service.status
+              when Steep::Services::SignatureService::SyntaxErrorStatus, Steep::Services::SignatureService::AncestorErrorStatus
+                return
+              end
+
+              decls = sig_service.files[relative_path].decls
+              locator = RBS::Locator.new(decls: decls)
+
+              hd, tail = locator.find2(line: job.line, column: job.column)
+
+              namespace = []
+              tail.each do |t|
+                case t
+                when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
+                  namespace << t.name.to_namespace
+                end
+              end
+              context = []
 
-            target = project.target_for_source_path(job.path) or return
-            file = service.source_files[job.path] or return
-            subtyping = service.signature_services[target.name].current_subtyping or return
+              namespace.each do |ns|
+                context.map! { |n| ns + n }
+                context << ns
+              end
+
+              context.map!(&:absolute!)
+
+              class_items = sig_service.latest_env.class_decls.keys.map { |type_name|
+                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+              }.compact
+
+              alias_items = sig_service.latest_env.alias_decls.keys.map { |type_name|
+                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+              }.compact
+
+              interface_items = sig_service.latest_env.interface_decls.keys.map {|type_name|
+                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+              }.compact
 
-            provider = Services::CompletionProvider.new(source_text: file.content, path: job.path, subtyping: subtyping)
-            items = begin
-                      provider.run(line: job.line, column: job.column)
-                    rescue Parser::SyntaxError
-                      []
-                    end
+              completion_items = class_items + alias_items + interface_items
 
-            completion_items = items.map do |item|
-              format_completion_item(item)
+              LSP::Interface::CompletionList.new(
+                is_incomplete: false,
+                items: completion_items
+              )
             end
+          end
+        end
+      end
+
+      def format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+        range = LanguageServer::Protocol::Interface::Range.new(
+          start: LanguageServer::Protocol::Interface::Position.new(
+            line: job.line - 1,
+            character: job.column - prefix.size
+          ),
+          end: LanguageServer::Protocol::Interface::Position.new(
+            line: job.line - 1,
+            character: job.column - prefix.size
+          )
+        )
 
-            Steep.logger.debug "items = #{completion_items.inspect}"
+        name = relative_name_in_context(type_name, context).to_s
 
-            LSP::Interface::CompletionList.new(
-              is_incomplete: false,
-              items: completion_items
-            )
+        return unless name.start_with?(prefix)
+
+        case type_name.kind
+        when :class
+          class_decl = sig_service.latest_env.class_decls[type_name]&.decls[0]&.decl or raise
+
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: "#{name}",
+            documentation:  format_comment(class_decl.comment),
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: name
+            ),
+            kind: LSP::Constant::CompletionItemKind::CLASS,
+            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
+
+          )
+        when :alias
+          alias_decl = sig_service.latest_env.alias_decls[type_name]&.decl or raise
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: "#{name}",
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: name
+            ),
+            documentation: format_comment(alias_decl.comment),
+            # https://github.com/microsoft/vscode-languageserver-node/blob/6d78fc4d25719b231aba64a721a606f58b9e0a5f/client/src/common/client.ts#L624-L650
+            kind: LSP::Constant::CompletionItemKind::FIELD,
+            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
+          )
+        when :interface
+          interface_decl = sig_service.latest_env.interface_decls[type_name]&.decl or raise
+
+          LanguageServer::Protocol::Interface::CompletionItem.new(
+            label: "#{name}",
+            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+              range: range,
+              new_text: name
+            ),
+            documentation: format_comment(interface_decl.comment),
+            kind: LanguageServer::Protocol::Constant::CompletionItemKind::INTERFACE,
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+          )
+        end
+      end
+
+      def format_comment(comment)
+        if comment
+          LSP::Interface::MarkupContent.new(
+            kind: LSP::Constant::MarkupKind::MARKDOWN,
+            value: comment.string
+          )
+        end
+      end
+
+      def name_and_params(name, params)
+        if params.empty?
+          "#{name}"
+        else
+          ps = params.each.map do |param|
+            s = ""
+            if param.skip_validation
+              s << "unchecked "
+            end
+            case param.variance
+            when :invariant
+              # nop
+            when :covariant
+              s << "out "
+            when :contravariant
+              s << "in "
+            end
+            s + param.name.to_s
+          end
+
+          "#{name}[#{ps.join(", ")}]"
+        end
+      end
+
+      def name_and_args(name, args)
+        if name && args
+          if args.empty?
+            "#{name}"
+          else
+            "#{name}[#{args.join(", ")}]"
           end
         end
       end
 
+      def retrieve_decl_information(decl)
+        case decl
+        when RBS::AST::Declarations::Class
+          super_class = if super_class = decl.super_class
+                          " < #{name_and_args(super_class.name, super_class.args)}"
+                        end
+          "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+        when RBS::AST::Declarations::Module
+          self_type = unless decl.self_types.empty?
+                        " : #{decl.self_types.join(", ")}"
+                      end
+          "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+        when RBS::AST::Declarations::Alias
+          "type #{decl.name} = #{decl.type}"
+        when RBS::AST::Declarations::Interface
+          "interface #{name_and_params(decl.name, decl.type_params)}"
+        end
+    end
+
       def format_completion_item(item)
         range = LanguageServer::Protocol::Interface::Range.new(
           start: LanguageServer::Protocol::Interface::Position.new(
@@ -297,6 +505,17 @@ HOVER
 
         params.join(", ")
       end
+
+      def relative_name_in_context(type_name, context)
+        context.each do |namespace|
+          if (type_name.to_s == namespace.to_type_name.to_s || type_name.namespace.to_s == "::")
+            return RBS::TypeName.new(namespace: RBS::Namespace.empty, name: type_name.name)
+          elsif type_name.to_s.start_with?(namespace.to_s)
+            return TypeName(type_name.to_s.sub(namespace.to_type_name.to_s, '')).relative!
+          end
+        end
+        type_name
+      end
     end
   end
 end