rbs 3.9.4 → 4.1.1

data/lib/rbs/environment_loader.rb

@@ -50,12 +50,6 @@ module RBS
       when path
         dirs << path
       when library
-        case library
-        when 'rubygems', 'set'
-          RBS.logger.warn "`#{library}` has been moved to core library, so it is always loaded. Remove explicit loading `#{library}`"
-          return
-        end
-
         if libs.add?(Library.new(name: library, version: version)) && resolve_dependencies
           resolve_dependencies(library: library, version: version)
         end
@@ -122,7 +116,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 +155,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.normalized_module_class_entry(type_name) or raise
+          decl = env.module_class_entry(type_name, normalized: true) 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
 
@@ -474,7 +475,7 @@ module RBS
       @type_name = type_name
       @member = member
 
-      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member.name}` in the definition of `#{type_name}`"
+      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member_name(member)}` in the definition of `#{type_name}`"
     end
 
     def location
@@ -482,23 +483,43 @@ module RBS
     end
 
     def self.check!(type_name:, env:, member:)
-      if env.class_decl?(member.name)
+      name = case member
+             when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+               member.name
+             when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+               member.module_name
+             else
+               raise "Unknown member type: #{member.class}"
+             end
+
+      if env.class_decl?(name)
         raise new(type_name: type_name, member: member)
       end
     end
 
     private
 
+    def member_name(member)
+      case member
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        member.name
+      when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+        member.module_name
+      else
+        raise "Unknown member type: #{member.class}"
+      end
+    end
+
     def mixin_name
       case member
-      when AST::Members::Prepend
+      when AST::Members::Prepend, AST::Ruby::Members::PrependMember
         "prepend"
-      when AST::Members::Include
+      when AST::Members::Include, AST::Ruby::Members::IncludeMember
         "include"
-      when AST::Members::Extend
+      when AST::Members::Extend, AST::Ruby::Members::ExtendMember
         "extend"
       else
-        raise
+        raise "Unknown member type: #{member.class}"
       end
     end
   end
@@ -590,17 +611,6 @@ module RBS
     end
   end
 
-  class WillSyntaxError < DefinitionError
-    include DetailedMessageable
-
-    attr_reader :location
-
-    def initialize(message, location:)
-      super "#{Location.to_string(location)}: #{message}"
-      @location = location
-    end
-  end
-
   class TypeParamDefaultReferenceError < DefinitionError
     include DetailedMessageable
 

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