rbs 3.9.2 → 4.0.0.dev.1

data/lib/rbs/environment.rb

@@ -2,8 +2,6 @@
 
 module RBS
   class Environment
-    attr_reader :declarations
-
     attr_reader :class_decls
     attr_reader :interface_decls
     attr_reader :type_alias_decls
@@ -11,116 +9,17 @@ module RBS
     attr_reader :global_decls
     attr_reader :class_alias_decls
 
-    attr_reader :signatures
-
-    module ContextUtil
-      def calculate_context(decls)
-        decls.inject(nil) do |context, decl| #$ Resolver::context
-          if (_, last = context)
-            last or raise
-            [context, last + decl.name]
-          else
-            [nil, decl.name.absolute!]
-          end
-        end
-      end
-    end
-
-    class MultiEntry
-      D = _ = Struct.new(:decl, :outer, keyword_init: true) do
-        # @implements D[M]
-
-        include ContextUtil
-
-        def context
-          @context ||= calculate_context(outer + [decl])
-        end
-      end
-
-      attr_reader :name
-      attr_reader :decls
-
-      def initialize(name:)
-        @name = name
-        @decls = []
-      end
-
-      def insert(decl:, outer:)
-        decls << D.new(decl: decl, outer: outer)
-        @primary = nil
-      end
-
-      def validate_type_params
-        unless decls.empty?
-          hd_decl, *tl_decls = decls
-          raise unless hd_decl
-
-          hd_params = hd_decl.decl.type_params
-
-          tl_decls.each do |tl_decl|
-            tl_params = tl_decl.decl.type_params
-
-            unless compatible_params?(hd_params, tl_params)
-              raise GenericParameterMismatchError.new(name: name, decl: _ = tl_decl.decl)
-            end
-          end
-        end
-      end
-
-      def compatible_params?(ps1, ps2)
-        if ps1.size == ps2.size
-          ps1 == AST::TypeParam.rename(ps2, new_names: ps1.map(&:name))
-        end
-      end
-
-      def type_params
-        primary.decl.type_params
-      end
-
-      def primary
-        raise "Not implemented"
-      end
-    end
-
-    class ModuleEntry < MultiEntry
-      def self_types
-        decls.flat_map do |d|
-          d.decl.self_types
-        end.uniq
-      end
-
-      def primary
-        @primary ||= begin
-                       validate_type_params
-                       decls.first or raise("decls cannot be empty")
-                     end
-      end
-    end
-
-    class ClassEntry < MultiEntry
-      def primary
-        @primary ||= begin
-                       validate_type_params
-                       decls.find {|d| d.decl.super_class } || decls.first or raise("decls cannot be empty")
-                     end
-      end
-    end
+    attr_reader :sources
 
     class SingleEntry
       attr_reader :name
-      attr_reader :outer
+      attr_reader :context
       attr_reader :decl
 
-      def initialize(name:, decl:, outer:)
+      def initialize(name:, decl:, context:)
         @name = name
         @decl = decl
-        @outer = outer
-      end
-
-      include ContextUtil
-
-      def context
-        @context ||= calculate_context(outer)
+        @context = context
       end
     end
 
@@ -143,9 +42,7 @@ module RBS
     end
 
     def initialize
-      @signatures = {}
-      @declarations = []
-
+      @sources = []
       @class_decls = {}
       @interface_decls = {}
       @type_alias_decls = {}
@@ -156,9 +53,7 @@ module RBS
     end
 
     def initialize_copy(other)
-      @signatures = other.signatures.dup
-      @declarations = other.declarations.dup
-
+      @sources = other.sources.dup
       @class_decls = other.class_decls.dup
       @interface_decls = other.interface_decls.dup
       @type_alias_decls = other.type_alias_decls.dup
@@ -370,7 +265,7 @@ module RBS
       @normalize_module_name_cache[name] = normalized_type_name
     end
 
-    def insert_decl(decl, outer:, namespace:)
+    def insert_rbs_decl(decl, context:, namespace:)
       case decl
       when AST::Declarations::Class, AST::Declarations::Module
         name = decl.name.with_prefix(namespace)
@@ -384,9 +279,9 @@ module RBS
         unless class_decls.key?(name)
           case decl
           when AST::Declarations::Class
-            class_decls[name] ||= ClassEntry.new(name: name)
+            class_decls[name] ||= ClassEntry.new(name)
           when AST::Declarations::Module
-            class_decls[name] ||= ModuleEntry.new(name: name)
+            class_decls[name] ||= ModuleEntry.new(name)
           end
         end
 
@@ -394,17 +289,17 @@ module RBS
 
         case
         when decl.is_a?(AST::Declarations::Module) && existing_entry.is_a?(ModuleEntry)
-          existing_entry.insert(decl: decl, outer: outer)
+          existing_entry << [context, decl]
         when decl.is_a?(AST::Declarations::Class) && existing_entry.is_a?(ClassEntry)
-          existing_entry.insert(decl: decl, outer: outer)
+          existing_entry << [context, decl]
         else
-          raise DuplicatedDeclarationError.new(name, decl, existing_entry.decls[0].decl)
+          raise DuplicatedDeclarationError.new(name, decl, existing_entry.primary_decl)
         end
 
-        prefix = outer + [decl]
-        ns = name.to_namespace
+        inner_context = [context, name] #: Resolver::context
+        inner_namespace = name.to_namespace
         decl.each_decl do |d|
-          insert_decl(d, outer: prefix, namespace: ns)
+          insert_rbs_decl(d, context: inner_context, namespace: inner_namespace)
         end
 
       when AST::Declarations::Interface
@@ -414,7 +309,7 @@ module RBS
           raise DuplicatedDeclarationError.new(name, decl, interface_entry.decl)
         end
 
-        interface_decls[name] = InterfaceEntry.new(name: name, decl: decl, outer: outer)
+        interface_decls[name] = InterfaceEntry.new(name: name, decl: decl, context: context)
 
       when AST::Declarations::TypeAlias
         name = decl.name.with_prefix(namespace)
@@ -423,7 +318,7 @@ module RBS
           raise DuplicatedDeclarationError.new(name, decl, entry.decl)
         end
 
-        type_alias_decls[name] = TypeAliasEntry.new(name: name, decl: decl, outer: outer)
+        type_alias_decls[name] = TypeAliasEntry.new(name: name, decl: decl, context: context)
 
       when AST::Declarations::Constant
         name = decl.name.with_prefix(namespace)
@@ -433,18 +328,18 @@ module RBS
           when ClassAliasEntry, ModuleAliasEntry, ConstantEntry
             raise DuplicatedDeclarationError.new(name, decl, entry.decl)
           when ClassEntry, ModuleEntry
-            raise DuplicatedDeclarationError.new(name, decl, *entry.decls.map(&:decl))
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
           end
         end
 
-        constant_decls[name] = ConstantEntry.new(name: name, decl: decl, outer: outer)
+        constant_decls[name] = ConstantEntry.new(name: name, decl: decl, context: context)
 
       when AST::Declarations::Global
         if entry = global_decls[decl.name]
           raise DuplicatedDeclarationError.new(decl.name, decl, entry.decl)
         end
 
-        global_decls[decl.name] = GlobalEntry.new(name: decl.name, decl: decl, outer: outer)
+        global_decls[decl.name] = GlobalEntry.new(name: decl.name, decl: decl, context: context)
 
       when AST::Declarations::ClassAlias, AST::Declarations::ModuleAlias
         name = decl.new_name.with_prefix(namespace)
@@ -454,35 +349,109 @@ module RBS
           when ClassAliasEntry, ModuleAliasEntry, ConstantEntry
             raise DuplicatedDeclarationError.new(name, decl, entry.decl)
           when ClassEntry, ModuleEntry
-            raise DuplicatedDeclarationError.new(name, decl, *entry.decls.map(&:decl))
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
           end
         end
 
         case decl
         when AST::Declarations::ClassAlias
-          class_alias_decls[name] = ClassAliasEntry.new(name: name, decl: decl, outer: outer)
+          class_alias_decls[name] = ClassAliasEntry.new(name: name, decl: decl, context: context)
         when AST::Declarations::ModuleAlias
-          class_alias_decls[name] = ModuleAliasEntry.new(name: name, decl: decl, outer: outer)
+          class_alias_decls[name] = ModuleAliasEntry.new(name: name, decl: decl, context: context)
+        end
+      end
+    end
+
+    def insert_ruby_decl(decl, context:, namespace:)
+      case decl
+      when AST::Ruby::Declarations::ClassDecl
+        name = decl.class_name.with_prefix(namespace)
+
+        if entry = constant_entry(name)
+          if entry.is_a?(ConstantEntry) || entry.is_a?(ModuleAliasEntry) || entry.is_a?(ClassAliasEntry)
+            raise DuplicatedDeclarationError.new(name, decl, entry.decl)
+          end
+          if entry.is_a?(ModuleEntry)
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
+          end
+        end
+
+        entry = ClassEntry.new(name)
+        class_decls[name] = entry
+
+        entry << [context, decl]
+
+        inner_context = [context, name] #: Resolver::context
+        decl.each_decl do |member|
+          insert_ruby_decl(member, context: inner_context, namespace: name.to_namespace)
+        end
+
+      when AST::Ruby::Declarations::ModuleDecl
+        name = decl.module_name.with_prefix(namespace)
+
+        if entry = constant_entry(name)
+          if entry.is_a?(ConstantEntry) || entry.is_a?(ModuleAliasEntry) || entry.is_a?(ClassAliasEntry)
+            raise DuplicatedDeclarationError.new(name, decl, entry.decl)
+          end
+          if entry.is_a?(ClassEntry)
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
+          end
+        end
+
+        entry = ModuleEntry.new(name)
+        class_decls[name] = entry
+
+        entry << [context, decl]
+
+        inner_context = [context, name] #: Resolver::context
+        decl.each_decl do |member|
+          insert_ruby_decl(member, context: inner_context, namespace: name.to_namespace)
         end
       end
     end
 
-    def <<(decl)
-      declarations << decl
-      insert_decl(decl, outer: [], namespace: Namespace.root)
-      self
+    def add_source(source)
+      sources << source
+
+      case source
+      when Source::RBS
+        source.declarations.each do |decl|
+          insert_rbs_decl(decl, context: nil, namespace: Namespace.root)
+        end
+      when Source::Ruby
+        source.declarations.each do |dir|
+          insert_ruby_decl(dir, context: nil, namespace: Namespace.root)
+        end
+      end
+    end
+
+    def each_rbs_source(&block)
+      if block
+        sources.each do |source|
+          if source.is_a?(Source::RBS)
+            yield source
+          end
+        end
+      else
+        enum_for(:each_rbs_source)
+      end
     end
 
-    def add_signature(buffer:, directives:, decls:)
-      signatures[buffer] = [directives, decls]
-      decls.each do |decl|
-        self << decl
+    def each_ruby_source(&block)
+      if block
+        sources.each do |source|
+          if source.is_a?(Source::Ruby)
+            yield source
+          end
+        end
+      else
+        enum_for(:each_ruby_source)
       end
     end
 
     def validate_type_params
       class_decls.each_value do |decl|
-        decl.primary
+        decl.validate_type_params
       end
     end
 
@@ -501,7 +470,7 @@ module RBS
         if only && !only.member?(decl)
           decl
         else
-          resolve_declaration(resolver, map, decl, outer: [], prefix: Namespace.root)
+          resolve_declaration(resolver, map, decl, context: nil, prefix: Namespace.root)
         end
       end
 
@@ -519,12 +488,22 @@ module RBS
       table.known_types.merge(interface_decls.keys)
       table.compute_children
 
-      signatures.each do |buffer, (dirs, decls)|
-        resolve = dirs.find { _1.is_a?(AST::Directives::ResolveTypeNames) } #: AST::Directives::ResolveTypeNames?
+      each_rbs_source do |source|
+        resolve = source.directives.find { _1.is_a?(AST::Directives::ResolveTypeNames) } #: AST::Directives::ResolveTypeNames?
         if !resolve || resolve.value
-          _, decls = resolve_signature(resolver, table, dirs, decls)
+          _, decls = resolve_signature(resolver, table, source.directives, source.declarations)
+        else
+          decls = source.declarations
+        end
+        env.add_source(Source::RBS.new(source.buffer, source.directives, decls))
+      end
+
+      each_ruby_source do |source|
+        decls = source.declarations.map do |decl|
+          resolve_ruby_decl(resolver, decl, context: nil, prefix: Namespace.root)
         end
-        env.add_signature(buffer: buffer, directives: dirs, decls: decls)
+
+        env.add_source(Source::Ruby.new(source.buffer, source.prism_result, decls, source.diagnostics))
       end
 
       env
@@ -545,7 +524,7 @@ module RBS
       end
     end
 
-    def resolve_declaration(resolver, map, decl, outer:, prefix:)
+    def resolve_declaration(resolver, map, decl, context:, prefix:)
       if decl.is_a?(AST::Declarations::Global)
         # @type var decl: AST::Declarations::Global
         return AST::Declarations::Global.new(
@@ -557,14 +536,11 @@ module RBS
         )
       end
 
-      context = resolver_context(*outer)
-
       case decl
       when AST::Declarations::Class
         outer_context = context
         inner_context = append_context(outer_context, decl)
 
-        outer_ = outer + [decl]
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Class.new(
           name: decl.name.with_prefix(prefix),
@@ -585,7 +561,7 @@ module RBS
                 resolver,
                 map,
                 member,
-                outer: outer_,
+                context: inner_context,
                 prefix: prefix_
               )
             else
@@ -601,7 +577,6 @@ module RBS
         outer_context = context
         inner_context = append_context(outer_context, decl)
 
-        outer_ = outer + [decl]
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Module.new(
           name: decl.name.with_prefix(prefix),
@@ -622,7 +597,7 @@ module RBS
                 resolver,
                 map,
                 member,
-                outer: outer_,
+                context: inner_context,
                 prefix: prefix_
               )
             else
@@ -685,6 +660,61 @@ module RBS
       end
     end
 
+    def resolve_ruby_decl(resolver, decl, context:, prefix:)
+      case decl
+      when AST::Ruby::Declarations::ClassDecl
+        full_name = decl.class_name.with_prefix(prefix)
+        inner_context = [context, full_name] #: Resolver::context
+        inner_prefix = full_name.to_namespace
+
+        AST::Ruby::Declarations::ClassDecl.new(decl.buffer, full_name, decl.node).tap do |resolved|
+          decl.members.each do |member|
+            case member
+            when AST::Ruby::Declarations::Base
+              resolved.members << resolve_ruby_decl(resolver, member, context: inner_context, prefix: inner_prefix)
+            when AST::Ruby::Members::Base
+              resolved.members << resolve_ruby_member(resolver, member, context: inner_context)
+            else
+              raise "Unknown member type: #{member.class}"
+            end
+          end
+        end
+
+      when AST::Ruby::Declarations::ModuleDecl
+        full_name = decl.module_name.with_prefix(prefix)
+        inner_context = [context, full_name] #: Resolver::context
+        inner_prefix = full_name.to_namespace
+
+        AST::Ruby::Declarations::ModuleDecl.new(decl.buffer, full_name, decl.node).tap do |resolved|
+          decl.members.each do |member|
+            case member
+            when AST::Ruby::Declarations::Base
+              resolved.members << resolve_ruby_decl(resolver, member, context: inner_context, prefix: inner_prefix)
+            else
+              raise "Unknown member type: #{member.class}"
+            end
+          end
+        end
+
+      else
+        raise "Unknown declaration type: #{decl.class}"
+      end
+    end
+
+    def resolve_ruby_member(resolver, member, context:)
+      case member
+      when AST::Ruby::Members::DefMember
+        AST::Ruby::Members::DefMember.new(
+          member.buffer,
+          member.name,
+          member.node,
+          member.method_type.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        )
+      else
+        raise "Unknown member type: #{member.class}"
+      end
+    end
+
     def resolve_member(resolver, map, member, context:)
       case member
       when AST::Members::MethodDefinition
@@ -800,7 +830,7 @@ module RBS
     end
 
     def absolute_type_name(resolver, map, type_name, context:)
-      type_name = map.resolve(type_name)
+      type_name = map.resolve(type_name) if map
       resolver.resolve(type_name, context: context) || type_name
     end
 
@@ -816,15 +846,16 @@ module RBS
     end
 
     def buffers
-      signatures.keys
+      sources.map(&:buffer)
     end
 
     def unload(buffers)
       env = Environment.new
+      bufs = buffers.to_set
 
-      signatures.each do |buf, (dirs, decls)|
-        next if buffers.include?(buf)
-        env.add_signature(buffer: buf, directives: dirs, decls: decls)
+      each_rbs_source do |source|
+        next if bufs.include?(source.buffer)
+        env.add_source(source)
       end
 
       env

data/lib/rbs/environment_loader.rb

@@ -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

@@ -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