steep 1.10.0 → 2.0.0

data/lib/steep/services/hover_provider/ruby.rb

@@ -1,57 +1,8 @@
 module Steep
   module Services
     module HoverProvider
-      class Ruby
-        TypeContent = _ = Struct.new(:node, :type, :location, keyword_init: true)
-        VariableContent = _ = Struct.new(:node, :name, :type, :location, keyword_init: true)
-        TypeAssertionContent = _ = Struct.new(:node, :original_type, :asserted_type, :location, keyword_init: true)
-        MethodCallContent = _ = Struct.new(:node, :method_call, :location, keyword_init: true)
-        DefinitionContent = _ = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
-        ConstantContent = _ = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
-          # @implements ConstantContent
-
-          def comments
-            case
-            when decl = class_decl
-              decl.decls.map {|d| d.decl.comment }
-            when decl = class_alias
-              [decl.decl.comment]
-            when decl = constant_decl
-              [decl.decl.comment]
-            else
-              raise
-            end.compact
-          end
-
-          def class_decl
-            case decl
-            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
-              decl
-            end
-          end
-
-          def class_alias
-            case decl
-            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
-              decl
-            end
-          end
-
-          def constant_decl
-            if decl.is_a?(::RBS::Environment::ConstantEntry)
-              decl
-            end
-          end
-
-          def constant?
-            constant_decl ? true : false
-          end
-
-          def class_or_module?
-            (class_decl || class_alias) ?  true : false
-          end
-        end
 
+      class Ruby
         attr_reader :service
 
         def initialize(service:)
@@ -85,7 +36,10 @@ module Steep
           source = source.without_unrelated_defs(line: line, column: column)
           resolver = ::RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
           pos = source.buffer.loc_to_pos([line, column])
-          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: pos)
+          [
+            Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: pos),
+            subtyping
+          ]
         rescue
           nil
         end
@@ -112,10 +66,15 @@ module Steep
 
         def content_for(target:, path:, line:, column:)
           file = service.source_files[path] or return
-          typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
-          node, *parents = typing.source.find_nodes(line: line, column: column)
+          (typing, subtyping = typecheck(target, path: path, content: file.content, line: line, column: column)) or return
+          locator = Locator::Ruby.new(typing.source)
+          result = locator.find(line, column)
+
+          case result
+          when Locator::NodeResult
+            node = result.node
+            parents = result.parents
 
-          if node && parents
             case node.type
             when :lvar
               var_name = node.children[0]
@@ -130,7 +89,7 @@ module Steep
               )
 
             when :lvasgn
-              var_name, rhs = node.children
+              var_name, _rhs = node.children
               context = typing.cursor_context.context or raise
               type = context.type_env[var_name] || typing.type_of(node: node)
 
@@ -197,15 +156,6 @@ module Steep
                   decl: entry
                 )
               end
-            when :assertion
-              original_node, _ = node.children
-
-              original_type = typing.type_of(node: original_node)
-              asserted_type = typing.type_of(node: node)
-
-              if original_type != asserted_type
-                return TypeAssertionContent.new(node: node, original_type: original_type, asserted_type: asserted_type, location: node.location.expression)
-              end
             end
 
             TypeContent.new(
@@ -213,8 +163,117 @@ module Steep
               type: typing.type_of(node: node),
               location: node.location.expression
             )
+
+          when Locator::TypeAssertionResult
+            context = typing.cursor_context.context or raise
+            pos = typing.source.buffer.loc_to_pos([line, column])
+
+            nesting = context.module_context.nesting
+            type_vars = context.variable_context.type_params.map { _1.name }
+
+            if (name, location = result.locate_type_name(pos, nesting, subtyping, type_vars))
+              if content = type_name_content(subtyping.factory.env, name, location)
+                return content
+              end
+            end
+
+            assertion_node = result.node.node
+            original_node = assertion_node.children[0] or raise
+
+            original_type = typing.type_of(node: original_node)
+            asserted_type = typing.type_of(node: assertion_node)
+
+            if original_type != asserted_type
+              TypeAssertionContent.new(
+                node: assertion_node,
+                original_type: original_type,
+                asserted_type: asserted_type,
+                location: assertion_node.location.expression
+              )
+            else
+              TypeContent.new(
+                node: assertion_node,
+                type: typing.type_of(node: assertion_node),
+                location: assertion_node.location.expression
+              )
+            end
+
+          when Locator::TypeApplicationResult
+            begin
+              context = typing.cursor_context.context or raise
+              pos = typing.source.buffer.loc_to_pos([line, column])
+
+              nesting = context.module_context.nesting
+              type_vars = context.variable_context.type_params.map { _1.name }
+
+              if (name, location = result.locate_type_name(pos, nesting, subtyping, type_vars))
+                if content = type_name_content(subtyping.factory.env, name, location)
+                  return content
+                end
+              end
+
+              nil
+            rescue ::RBS::ParsingError
+              return nil
+            end
           end
         end
+
+        def type_name_content(environment, type_name, location)
+          case
+          when type_name.class?
+            if entry = environment.module_class_entry(type_name)
+              decl = case entry
+              when ::RBS::Environment::ModuleEntry, ::RBS::Environment::ClassEntry
+                entry.primary_decl
+              else
+                entry.decl
+              end
+
+              ClassTypeContent.new(
+                location: location,
+                decl: decl
+              )
+            end
+          when type_name.interface?
+            if entry = environment.interface_decls.fetch(type_name, nil)
+              InterfaceTypeContent.new(
+                location: location,
+                decl: entry.decl
+              )
+            end
+          when type_name.alias?
+            if entry = environment.type_alias_decls.fetch(type_name, nil)
+              TypeAliasContent.new(
+                location: location,
+                decl: entry.decl
+              )
+            end
+          end
+        end
+
+        def content_for_inline(target:, path:, line:, column:)
+          signature = service.signature_services.fetch(target.name)
+          source = signature.latest_env.sources.find do
+            if _1.is_a?(::RBS::Source::Ruby)
+              _1.buffer.name == path
+            end
+          end
+
+          return unless source.is_a?(::RBS::Source::Ruby)
+
+          locator = Locator::Inline.new(source)
+          result = locator.find(line, column)
+
+          case result
+          when Locator::InlineTypeNameResult
+            return type_name_content(signature.latest_env, result.type_name, result.location)
+          else
+            Steep.logger.fatal { { result: result.class }.inspect }
+          end
+
+          nil
+        end
       end
     end
   end

data/lib/steep/services/hover_provider/singleton_methods.rb

@@ -6,6 +6,10 @@ module Steep
           project = service.project
 
           case
+          when target = project.target_for_inline_source_path(path)
+            service = Ruby.new(service: service)
+            service.content_for_inline(target: target, path: path, line: line, column: column) ||
+              service.content_for(target: target, path: path, line: line, column: column)
           when target = project.target_for_source_path(path)
             Ruby.new(service: service).content_for(target: target, path: path, line: line, column: column)
           when target = project.target_for_signature_path(path)

data/lib/steep/services/signature_service.rb

@@ -76,19 +76,36 @@ module Steep
         end
       end
 
-      FileStatus = _ = Struct.new(:path, :content, :signature, keyword_init: true)
+      RBSFileStatus = _ = Struct.new(:path, :content, :source, keyword_init: true)
 
       attr_reader :implicitly_returns_nil
 
-      def initialize(env:, implicitly_returns_nil:)
-        builder = RBS::DefinitionBuilder.new(env: env)
-        @status = LoadedStatus.new(builder: builder, files: {}, implicitly_returns_nil: implicitly_returns_nil)
+      def initialize(status:, implicitly_returns_nil:)
+        @status = status
         @implicitly_returns_nil = implicitly_returns_nil
       end
 
       def self.load_from(loader, implicitly_returns_nil:)
         env = RBS::Environment.from_loader(loader).resolve_type_names
-        new(env: env, implicitly_returns_nil: implicitly_returns_nil)
+        builder = RBS::DefinitionBuilder.new(env: env)
+        status = LoadedStatus.new(builder: builder, files: {}, implicitly_returns_nil: implicitly_returns_nil)
+        new(status: status, implicitly_returns_nil: implicitly_returns_nil)
+      rescue RBS::ParsingError => exn
+        # When library RBS contains syntax error, load only *core* libraries and set `SyntaxErrorStatus`.
+        core_loader = RBS::EnvironmentLoader.new(core_root: loader.core_root)
+        core_env = RBS::Environment.from_loader(core_loader).resolve_type_names
+        status = SyntaxErrorStatus.new(
+          files: {},
+          changed_paths: Set[],
+          diagnostics: [Diagnostic::Signature.from_rbs_error(exn, factory: _ = nil)],
+          last_builder: RBS::DefinitionBuilder.new(env: core_env)
+        )
+        service = new(status: status, implicitly_returns_nil: implicitly_returns_nil)
+        # Add the failed library path to env_rbs_paths so it's recognized as a library path by TypeCheckService
+        if exn.location
+          service.env_rbs_paths << Pathname(exn.location.buffer.name)
+        end
+        service
       end
 
       def env_rbs_paths
@@ -154,51 +171,101 @@ module Steep
       def apply_changes(files, changes)
         Steep.logger.tagged "#apply_changes" do
           Steep.measure2 "Applying change" do |sampler|
-            changes.each.with_object({}) do |pair, update|  # $ Hash[Pathname, FileStatus]
-              path, cs = pair
+            changes.each.with_object({}) do |(path, cs), update|  # $ Hash[Pathname, file_status]
               sampler.sample "#{path}" do
-                old_text = files[path]&.content
-                content = cs.inject(old_text || "") {|text, change| change.apply_to(text) }
-
-                content ||= "" # It was not clear why `content` can be `nil`, but it happens with `master_test`.
-                buffer = RBS::Buffer.new(name: path, content: content)
-
-                update[path] =
-                  begin
-                    FileStatus.new(path: path, content: content, signature: RBS::Parser.parse_signature(buffer))
-                  rescue ArgumentError => exn
-                    error = Diagnostic::Signature::UnexpectedError.new(
-                      message: exn.message,
-                      location: RBS::Location.new(buffer: buffer, start_pos: 0, end_pos: content.size)
-                    )
-                    FileStatus.new(path: path, content: content, signature: error)
-                  rescue RBS::ParsingError => exn
-                    FileStatus.new(path: path, content: content, signature: exn)
+                old_file = files.fetch(path, nil)
+
+                case old_file
+                when RBSFileStatus
+                  old_text = old_file.content
+                  new_file = load_rbs_file(path, old_text, cs)
+                when RBS::Source::Ruby
+                  old_text = old_file.buffer.content
+                  new_file = load_ruby_file(path, old_text, cs)
+                when nil
+                  # New file: Detect based on the file name
+                  if path.extname == ".rbs"
+                    # RBS File
+                    new_file = load_rbs_file(path, "", cs)
+                  else
+                    # Ruby File
+                    new_file = load_ruby_file(path, "", cs)
                   end
+                end
+
+                update[path] = new_file
               end
             end
           end
         end
       end
 
+      def load_rbs_file(path, old_text, changes)
+        content = changes.reduce(old_text) do |text, change| # $ String
+          change.apply_to(text)
+        end
+
+        buffer = RBS::Buffer.new(name: path, content: content)
+        source =
+          begin
+            _, dirs, decls = RBS::Parser.parse_signature(buffer)
+            RBS::Source::RBS.new(buffer, dirs, decls)
+          rescue ArgumentError => exn
+            Diagnostic::Signature::UnexpectedError.new(
+              message: exn.message,
+              location: RBS::Location.new(buffer: buffer, start_pos: 0, end_pos: content.size)
+            )
+          rescue RBS::ParsingError => exn
+            exn
+          end
+
+        RBSFileStatus.new(path: path, content: content, source: source)
+      end
+
+      def load_ruby_file(path, old_text, changes)
+        content = changes.reduce(old_text) do |text, change| # $ String
+          change.apply_to(text)
+        end
+
+        buffer = RBS::Buffer.new(name: path, content: content)
+        prism = Prism.parse(buffer.content, filepath: path.to_s)
+        result = RBS::InlineParser.parse(buffer, prism)
+        RBS::Source::Ruby.new(buffer, prism, result.declarations, result.diagnostics)
+      end
+
+      def error_file?(file)
+        case file
+        when RBSFileStatus
+          !file.source.is_a?(RBS::Source::RBS)
+        when RBS::Source::Ruby
+          false
+        end
+      end
+
       def update(changes)
         Steep.logger.tagged "#update" do
           updates = apply_changes(files, changes)
           paths = Set.new(updates.each_key)
           paths.merge(pending_changed_paths)
 
-          if updates.each_value.any? {|file| !file.signature.is_a?(Array) }
+          if updates.each_value.any? {|file| error_file?(file) }
             diagnostics = [] #: Array[Diagnostic::Signature::Base]
 
             updates.each_value do |file|
-              unless file.signature.is_a?(Array)
-                diagnostic = if file.signature.is_a?(Diagnostic::Signature::Base)
-                               file.signature
-                             else
-                               # factory is not used here because the error is a syntax error.
-                               Diagnostic::Signature.from_rbs_error(file.signature, factory: _ = nil)
-                             end
-                diagnostics << diagnostic
+              if error_file?(file)
+                if file.is_a?(RBSFileStatus)
+                  diagnostic =
+                    case file.source
+                    when Diagnostic::Signature::Base
+                      file.source
+                    when RBS::ParsingError
+                      Diagnostic::Signature.from_rbs_error(file.source, factory: _ = nil)
+                    else
+                      raise "file (#{file.path}) must be an error"
+                    end
+
+                  diagnostics << diagnostic
+                end
               end
             end
 
@@ -235,30 +302,26 @@ module Steep
       def update_env(updated_files, paths:)
         Steep.logger.tagged "#update_env" do
           errors = [] #: Array[RBS::BaseError]
-          new_decls = Set[].compare_by_identity #: Set[RBS::AST::Declarations::t]
+          new_decls = Set[].compare_by_identity #: Set[RBS::AST::Declarations::t | RBS::AST::Ruby::Declarations::t]
 
           env =
             Steep.measure "Deleting out of date decls" do
-              bufs = latest_env.buffers.select {|buf| paths.include?(buf.name) }
-              latest_env.unload(Set.new(bufs))
+              latest_env.unload(paths)
             end
 
           Steep.measure "Loading new decls" do
             updated_files.each_value do |content|
-              case content.signature
-              when RBS::ParsingError
-                errors << content.signature
-              when Diagnostic::Signature::UnexpectedError
-                return [content.signature]
-              else
-                begin
-                  buffer, dirs, decls = content.signature
-                  env.add_signature(buffer: buffer, directives: dirs, decls: decls)
-                  new_decls.merge(decls)
-                rescue RBS::LoadingError => exn
-                  errors << exn
-                end
+              case content
+              when RBSFileStatus
+                (source = content.source).is_a?(RBS::Source::RBS) or raise "Cannot be an error"
+                env.add_source(source)
+                new_decls.merge(source.declarations)
+              when RBS::Source::Ruby
+                env.add_source(content)
+                new_decls.merge(content.declarations)
               end
+            rescue RBS::LoadingError => exn
+              errors << exn
             end
           end
 
@@ -339,13 +402,25 @@ module Steep
       end
 
       def type_names(paths:, env:)
-        env.declarations.each.with_object(Set[]) do |decl, set|
-          if decl.location
-            if paths.include?(Pathname(decl.location.buffer.name))
-              type_name_from_decl(decl, set: set)
-            end
+
+        Hash.new {}
+        set = Set[] #: Set[RBS::TypeName]
+
+        env.each_rbs_source do |source|
+          next unless paths.include?(source.buffer.name)
+          source.each_type_name do |type_name|
+            set << type_name
           end
         end
+
+        env.each_ruby_source do |source|
+          next unless paths.include?(source.buffer.name)
+          source.each_type_name do |type_name|
+            set << type_name
+          end
+        end
+
+        set
       end
 
       def const_decls(paths:, env:)

data/lib/steep/services/type_check_service.rb

@@ -53,17 +53,40 @@ module Steep
             errors
           when typing && ignores
             errors = [] #: Array[Diagnostic::Ruby::Base]
+            error_lines = [] #: Array[Integer]
 
-            errors.concat(
-              typing.errors.delete_if do |diagnostic|
-                case diagnostic.location
-                when ::Parser::Source::Range
-                  ignores.ignore?(diagnostic.location.first_line, diagnostic.location.last_line, diagnostic.diagnostic_code)
-                when RBS::Location
-                  ignores.ignore?(diagnostic.location.start_line, diagnostic.location.end_line, diagnostic.diagnostic_code)
+            used_comments = Set[].compare_by_identity #: Set[Source::IgnoreRanges::ignore]
+
+            typing.errors.each do |diagnostic|
+              case diagnostic.location
+              when ::Parser::Source::Range
+                error_lines |= (diagnostic.location.first_line..diagnostic.location.last_line).to_a
+                if ignore = ignores.ignore?(diagnostic.location.first_line, diagnostic.location.last_line, diagnostic.diagnostic_code)
+                  used_comments << ignore
+                  next
+                end
+              when RBS::Location
+                if ignore = ignores.ignore?(diagnostic.location.start_line, diagnostic.location.end_line, diagnostic.diagnostic_code)
+                  used_comments << ignore
+                  next
                 end
               end
-            )
+
+              errors << diagnostic
+            end
+
+            ignores.each_ignore do |ignore|
+              next if used_comments.include?(ignore)
+
+              case ignore
+              when Array
+                location = RBS::Location.new(ignore[0].location.buffer, ignore[0].location.start_pos, ignore[1].location.end_pos)
+              else
+                location = ignore.location
+              end
+
+              errors << Diagnostic::Ruby::RedundantIgnoreComment.new(location: location)
+            end
 
             ignores.error_ignores.each do |ignore|
               errors << Diagnostic::Ruby::InvalidIgnoreComment.new(comment: ignore.comment)
@@ -119,10 +142,6 @@ module Steep
         signature_diagnostics
       end
 
-      def has_diagnostics?
-        each_diagnostics.count > 0
-      end
-
       def diagnostics
         each_diagnostics.to_h
       end
@@ -156,7 +175,9 @@ module Steep
           Steep.measure "validation" do
             service = signature_services.fetch(target.name)
 
-            raise "#{path} is not library nor signature of #{target.name}" unless target.possible_signature_file?(path) || service.env_rbs_paths.include?(path)
+            unless target.possible_signature_file?(path) || target.possible_inline_source_file?(path) || service.env_rbs_paths.include?(path)
+              raise "#{path} is not library nor signature of #{target.name}"
+            end
 
             case service.status
             when SignatureService::SyntaxErrorStatus
@@ -221,6 +242,14 @@ module Steep
               end
             end
 
+            source = service.status.files[path]
+            if source.is_a?(RBS::Source::Ruby)
+              source.diagnostics.each do |d|
+                diagnostic = Diagnostic::Signature::InlineDiagnostic.new(d)
+                diagnostics.push(diagnostic)
+              end
+            end
+
             signature_validation_diagnostics.fetch(target.name)[path] = diagnostics
           end
         end
@@ -240,6 +269,29 @@ module Steep
               source_files[path] = file
 
               file.diagnostics
+            else
+              # Signature loading failed. If the errors originate from library RBS files,
+              # they won't be reported by validate_signature (which filters by user file path).
+              # Report them on source files so the user knows type checking is broken. (#2176)
+              case signature_service.status
+              when SignatureService::SyntaxErrorStatus, SignatureService::AncestorErrorStatus
+                library_errors = signature_service.status.diagnostics.select do |diag|
+                  diag_path = diag.location && Pathname(diag.location.buffer.name)
+                  diag_path &&
+                    signature_service.env_rbs_paths.include?(diag_path) &&
+                    !signature_service.status.files.key?(diag_path)
+                end
+
+                unless library_errors.empty?
+                  text = source_files.fetch(path).content
+                  buffer = RBS::Buffer.new(name: path, content: text)
+                  location = RBS::Location.new(buffer: buffer, start_pos: 0, end_pos: text.size)
+
+                  library_errors.map do |error|
+                    Diagnostic::Ruby::LibraryRBSError.new(error: error, location: location)
+                  end
+                end
+              end
             end
           end
         end
@@ -249,8 +301,9 @@ module Steep
         Steep.logger.tagged "#update_signature" do
           signature_targets = {} #: Hash[Pathname, Project::Target]
           changes.each do |path, changes|
-            target = project.targets.find { _1.possible_signature_file?(path) } or next
-            signature_targets[path] = target
+            if target = project.target_for_signature_path(path) || project.target_for_inline_source_path(path)
+              signature_targets[path] = target
+            end
           end
 
           project.targets.each do |target|
@@ -368,7 +421,10 @@ module Steep
       end
 
       def source_file?(path)
-        source_files.key?(path) || (project.target_for_source_path(path) ? true : false)
+        return true if source_files.key?(path)
+        return true if project.target_for_source_path(path)
+        return true if project.target_for_inline_source_path(path)
+        false
       end
 
       def signature_file?(path)
@@ -378,17 +434,6 @@ module Steep
           targets.keys
         end
       end
-
-      def app_signature_file?(path)
-        target_names = signature_services.select {|_, sig| sig.files.key?(path) }.keys
-        unless target_names.empty?
-          target_names
-        end
-      end
-
-      def lib_signature_file?(path)
-        signature_services.each_value.any? {|sig| sig.env_rbs_paths.include?(path) }
-      end
     end
   end
 end