rbs 3.10.0 → 4.0.0.dev.1

data/lib/rbs/environment_loader.rb

@@ -51,7 +51,7 @@ module RBS
         dirs << path
       when library
         case library
-        when 'pathname'
+        when 'rubygems', 'set'
           RBS.logger.warn "`#{library}` has been moved to core library, so it is always loaded. Remove explicit loading `#{library}`"
           return
         end
@@ -122,7 +122,7 @@ module RBS
         decls.each do |decl|
           loaded << [decl, path, source]
         end
-        env.add_signature(buffer: buffer, directives: dirs, decls: decls)
+        env.add_source(Source::RBS.new(buffer, dirs, decls))
       end
 
       loaded
@@ -161,7 +161,7 @@ module RBS
           next if files.include?(path)
 
           files << path
-          buffer = Buffer.new(name: path.to_s, content: path.read(encoding: "UTF-8"))
+          buffer = Buffer.new(name: path, content: path.read(encoding: "UTF-8"))
 
           _, dirs, decls = Parser.parse_signature(buffer)
 

data/lib/rbs/errors.rb

@@ -93,7 +93,7 @@ module RBS
       params =
         case
         when type_name.class?
-          decl = env.module_class_entry(type_name, normalized: true) or raise
+          decl = env.normalized_module_class_entry(type_name) or raise
           decl.type_params
         when type_name.interface?
           env.interface_decls.fetch(type_name).decl.type_params
@@ -371,7 +371,7 @@ module RBS
     def initialize(name:, entry:)
       @name = name
       @entry = entry
-      super "#{Location.to_string entry.primary.decl.location}: Superclass mismatch: #{name}"
+      super "#{Location.to_string entry.primary_decl.location}: Superclass mismatch: #{name}"
     end
   end
 
@@ -408,10 +408,11 @@ module RBS
     attr_reader :name
     attr_reader :decl
 
-    def initialize(name:, decl:)
+    def initialize(name:, decl:, location: nil)
       @name = name
       @decl = decl
-      super "#{Location.to_string decl.location}: Generic parameters mismatch: #{name}"
+      location ||= decl.location
+      super "#{Location.to_string location}: Generic parameters mismatch: #{name}"
     end
   end
 

data/lib/rbs/inline_parser/comment_association.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RBS
+  class InlineParser
+    class CommentAssociation
+      attr_reader :blocks, :associated_blocks, :start_line_map, :end_line_map
+
+      def initialize(blocks)
+        @blocks = blocks.sort_by {|block| block.start_line }
+        @associated_blocks = Set[].compare_by_identity
+
+        @start_line_map = {}
+        @end_line_map = {}
+
+        blocks.each do |block|
+          if block.leading?
+            end_line_map[block.end_line] = block
+          else
+            start_line_map[block.start_line] = block
+          end
+        end
+      end
+
+      def self.build(buffer, result)
+        blocks = AST::Ruby::CommentBlock.build(buffer, result.comments)
+        new(blocks)
+      end
+
+      class Reference
+        attr_reader :block
+
+        def initialize(block, association)
+          @block = block
+          @associated_blocks = association
+        end
+
+        def associate!
+          @associated_blocks << block
+          self
+        end
+
+        def associated?
+          @associated_blocks.include?(block)
+        end
+      end
+
+      def leading_block(node)
+        start_line = node.location.start_line
+
+        if block = end_line_map.fetch(start_line - 1, nil)
+          Reference.new(block, associated_blocks)
+        end
+      end
+
+      def leading_block!(node)
+        if ref = leading_block(node)
+          unless ref.associated?
+            ref.associate!.block
+          end
+        end
+      end
+
+      def trailing_block(node)
+        location =
+          if node.is_a?(Prism::Node)
+            node.location
+          else
+            node
+          end #: Prism::Location
+        end_line = location.end_line
+        if block = start_line_map.fetch(end_line, nil)
+          Reference.new(block, associated_blocks)
+        end
+      end
+
+      def trailing_block!(node)
+        if ref = trailing_block(node)
+          unless ref.associated?
+            ref.associate!.block
+          end
+        end
+      end
+
+      def each_enclosed_block(node)
+        if block_given?
+          start_line = node.location.start_line
+          end_line = node.location.end_line
+
+          if start_line+1 < end_line
+            ((start_line + 1)...end_line).each do |line|
+              if block = end_line_map.fetch(line, nil)
+                unless associated_blocks.include?(block)
+                  associated_blocks << block
+                  yield block
+                end
+              end
+            end
+          end
+        else
+          enum_for :each_enclosed_block, node
+        end
+      end
+
+      def each_unassociated_block
+        if block_given?
+          blocks.each do |block|
+            unless associated_blocks.include?(block)
+              yield block
+            end
+          end
+        else
+          enum_for :each_unassociated_block
+        end
+      end
+    end
+  end
+end

data/lib/rbs/inline_parser.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module RBS
+  class InlineParser
+    class Result
+      attr_reader :buffer, :prism_result, :declarations, :diagnostics
+
+      def initialize(buffer, prism)
+        @buffer = buffer
+        @prism_result = prism
+        @declarations = []
+        @diagnostics = []
+      end
+    end
+
+    module Diagnostic
+      class Base
+        attr_reader :message, :location
+
+        def initialize(location, message)
+          @location = location
+          @message = message
+        end
+      end
+
+      NotImplementedYet = _ = Class.new(Base)
+      NonConstantClassName = _ = Class.new(Base)
+      NonConstantModuleName = _ = Class.new(Base)
+      TopLevelMethodDefinition = _ = Class.new(Base)
+      UnusedInlineAnnotation = _ = Class.new(Base)
+      AnnotationSyntaxError = _ = Class.new(Base)
+    end
+
+    def self.parse(buffer, prism)
+      result = Result.new(buffer, prism)
+
+      Parser.new(result).visit(prism.value)
+
+      result
+    end
+
+    class Parser < Prism::Visitor
+      attr_reader :module_nesting, :result, :comments
+
+      include AST::Ruby::Helpers::ConstantHelper
+      include AST::Ruby::Helpers::LocationHelper
+
+      def initialize(result)
+        @result = result
+        @module_nesting = []
+        @comments = CommentAssociation.build(result.buffer, result.prism_result)
+      end
+
+      def buffer
+        result.buffer
+      end
+
+      def current_module
+        module_nesting.last
+      end
+
+      def current_module!
+        current_module || raise("#current_module is nil")
+      end
+
+      def diagnostics
+        result.diagnostics
+      end
+
+      def push_module_nesting(mod)
+        module_nesting.push(mod)
+        yield
+      ensure
+        module_nesting.pop()
+      end
+
+      def skip_node?(node)
+        if ref = comments.leading_block(node)
+          if ref.block.each_paragraph([]).any? { _1.is_a?(AST::Ruby::Annotations::SkipAnnotation) }
+            ref.associate!
+            return true
+          end
+        end
+
+        false
+      end
+
+      def visit_class_node(node)
+        return if skip_node?(node)
+
+        unless class_name = constant_as_type_name(node.constant_path)
+          diagnostics << Diagnostic::NonConstantClassName.new(
+            rbs_location(node.constant_path.location),
+            "Class name must be a constant"
+          )
+          return
+        end
+
+        class_decl = AST::Ruby::Declarations::ClassDecl.new(buffer, class_name, node)
+        insert_declaration(class_decl)
+        push_module_nesting(class_decl) do
+          visit_child_nodes(node)
+        end
+
+        comments.each_enclosed_block(node) do |block|
+          report_unused_block(block)
+        end
+      end
+
+      def visit_module_node(node)
+        return if skip_node?(node)
+
+        unless module_name = constant_as_type_name(node.constant_path)
+          diagnostics << Diagnostic::NonConstantModuleName.new(
+            rbs_location(node.constant_path.location),
+            "Module name must be a constant"
+          )
+          return
+        end
+
+        module_decl = AST::Ruby::Declarations::ModuleDecl.new(buffer, module_name, node)
+        insert_declaration(module_decl)
+        push_module_nesting(module_decl) do
+          visit_child_nodes(node)
+        end
+
+        comments.each_enclosed_block(node) do |block|
+          report_unused_block(block)
+        end
+      end
+
+      def visit_def_node(node)
+        return if skip_node?(node)
+
+        if node.receiver
+          diagnostics << Diagnostic::NotImplementedYet.new(
+            rbs_location(node.receiver.location),
+            "Singleton method definition is not supported yet"
+          )
+          return
+        end
+
+        case current = current_module
+        when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
+          leading_block = comments.leading_block!(node)
+
+          if node.end_keyword_loc
+            # Not an end-less def
+            end_loc = node.rparen_loc || node.parameters&.location || node.name_loc
+            trailing_block = comments.trailing_block!(end_loc)
+          end
+
+          method_type, leading_unuseds, trailing_unused = AST::Ruby::Members::MethodTypeAnnotation.build(leading_block, trailing_block, [])
+          report_unused_annotation(trailing_unused, *leading_unuseds)
+
+          defn = AST::Ruby::Members::DefMember.new(buffer, node.name, node, method_type)
+          current.members << defn
+
+          # Skip other comments in `def` node
+          comments.each_enclosed_block(node) do |block|
+            comments.associated_blocks << block
+          end
+        else
+          diagnostics << Diagnostic::TopLevelMethodDefinition.new(
+            rbs_location(node.name_loc),
+            "Top-level method definition is not supported"
+          )
+        end
+      end
+
+      def insert_declaration(decl)
+        if current_module
+          current_module.members << decl
+        else
+          result.declarations << decl
+        end
+      end
+
+      def report_unused_annotation(*annotations)
+        annotations.each do |annotation|
+          case annotation
+          when AST::Ruby::CommentBlock::AnnotationSyntaxError
+            diagnostics << Diagnostic::AnnotationSyntaxError.new(
+              annotation.location, "Syntax error: " + annotation.error.error_message
+            )
+          when AST::Ruby::Annotations::Base
+            diagnostics << Diagnostic::UnusedInlineAnnotation.new(
+              annotation.location, "Unused inline rbs annotation"
+            )
+          end
+        end
+      end
+
+      def report_unused_block(block)
+        block.each_paragraph([]) do |paragraph|
+          case paragraph
+          when Location
+            # noop
+          else
+            report_unused_annotation(paragraph)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/location_aux.rb

@@ -28,6 +28,14 @@ module RBS
 
     WithChildren = self
 
+    def start_pos
+      buffer.absolute_position(_start_pos) || raise
+    end
+
+    def end_pos
+      buffer.absolute_position(_end_pos) || raise
+    end
+
     def name
       buffer.name
     end
@@ -49,11 +57,11 @@ module RBS
     end
 
     def start_loc
-      @start_loc ||= buffer.pos_to_loc(start_pos)
+      @start_loc ||= buffer.top_buffer.pos_to_loc(start_pos)
     end
 
     def end_loc
-      @end_loc ||= buffer.pos_to_loc(end_pos)
+      @end_loc ||= buffer.top_buffer.pos_to_loc(end_pos)
     end
 
     def range
@@ -61,7 +69,7 @@ module RBS
     end
 
     def source
-      @source ||= (buffer.content[range] || raise)
+      @source ||= (buffer.top_buffer.content[range] || raise)
     end
 
     def to_s
@@ -134,5 +142,29 @@ module RBS
     def required_key?(name)
       _required_keys.include?(name)
     end
+
+    def local_location
+      loc = Location.new(buffer.detach, _start_pos, _end_pos)
+
+      each_optional_key do |key|
+        value = self[key]
+        if value
+          loc.add_optional_child(key, value._start_pos...value._end_pos)
+        else
+          loc.add_optional_child(key, nil)
+        end
+      end
+
+      each_required_key do |key|
+        value = self[key] or raise
+        loc.add_required_child(key, value._start_pos...value._end_pos)
+      end
+
+      loc #: self
+    end
+
+    def local_source
+      local_location.source
+    end
   end
 end

data/lib/rbs/parser_aux.rb

@@ -35,11 +35,6 @@ module RBS
       [buf, dirs, decls]
     end
 
-    def self.parse_type_params(source, module_type_params: true)
-      buf = buffer(source)
-      _parse_type_params(buf, 0, buf.last_position, module_type_params)
-    end
-
     def self.magic_comment(buf)
       start_pos = 0
 
@@ -76,7 +71,7 @@ module RBS
     def self.buffer(source)
       case source
       when String
-        Buffer.new(content: source, name: "a.rbs")
+        Buffer.new(content: source, name: Pathname("a.rbs"))
       when Buffer
         source
       end
@@ -115,5 +110,15 @@ module RBS
       ).each_with_object({}) do |keyword, hash| #$ Hash[String, bot]
         hash[keyword] = _ = nil
       end
+
+    def self.parse_inline_leading_annotation(source, range, variables: [])
+      buf = buffer(source)
+      _parse_inline_leading_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
+    end
+
+    def self.parse_inline_trailing_annotation(source, range, variables: [])
+      buf = buffer(source)
+      _parse_inline_trailing_annotation(buf, range.begin || 0, range.end || buf.last_position, variables)
+    end
   end
 end

data/lib/rbs/prototype/runtime.rb

@@ -50,8 +50,8 @@ module RBS
           type_name_absolute = type_name.absolute!
           @mixin_decls_cache ||= {} #: Hash[TypeName, Array[AST::Members::Mixin]]
           @mixin_decls_cache.fetch(type_name_absolute) do
-            @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].decls.flat_map do |d|
-              d.decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
+            @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].each_decl.flat_map do |decl|
+              decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
             end
           end
         end

data/lib/rbs/resolver/constant_resolver.rb

@@ -32,7 +32,7 @@ module RBS
           end
 
           environment.class_alias_decls.each do |name, entry|
-            normalized_entry = environment.module_class_entry(name, normalized: true) or next
+            normalized_entry = environment.normalized_module_class_entry(name) or next
             constant = constant_of_module(name, normalized_entry)
 
             # Insert class/module aliases into `children_table` and `toplevel` table
@@ -176,7 +176,7 @@ module RBS
       end
 
       def constants_from_ancestors(module_name, constants:)
-        entry = builder.env.module_class_entry(module_name, normalized: true) or raise
+        entry = builder.env.normalized_module_class_entry(module_name) or raise
 
         if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
           constants.merge!(table.children(BuiltinNames::Object.name) || raise)