rbs 2.8.4 → 3.8.1

data/lib/rbs/resolver/constant_resolver.rb

@@ -18,20 +18,33 @@ module RBS
           end
 
           environment.class_decls.each do |name, entry|
+            constant = constant_of_module(name, entry)
+
             unless name.namespace.empty?
               parent = name.namespace.to_type_name
-
-              table = children_table[parent] or raise
-              constant = constant_of_module(name, entry)
+              table = children_table[parent] or raise "#{parent} not found by #{name}"
             else
               table = toplevel
-              constant = constant_of_module(name, entry)
             end
 
             table[name.name] = constant
             constants_table[name] = constant
           end
 
+          environment.class_alias_decls.each do |name, entry|
+            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
+            unless name.namespace.empty?
+              normalized_parent = environment.normalize_module_name?(name.namespace.to_type_name) or raise
+              table = children_table[normalized_parent] or raise
+              table[name.name] = constant
+            else
+              toplevel[name.name] = constant
+            end
+          end
+
           environment.constant_decls.each do |name, entry|
             unless name.namespace.empty?
               parent = name.namespace.to_type_name
@@ -97,6 +110,8 @@ module RBS
       end
 
       def children(module_name)
+        module_name = builder.env.normalize_module_name(module_name)
+
         unless child_constants_cache.key?(module_name)
           load_child_constants(module_name)
         end
@@ -113,6 +128,7 @@ module RBS
         else
           constants_from_ancestors(BuiltinNames::Object.name, constants: consts)
         end
+
         constants_from_context(context, constants: consts) or return
         constants_itself(context, constants: consts)
 
@@ -151,7 +167,7 @@ module RBS
           constants_from_context(parent, constants: constants) or return false
 
           if last
-            consts = table.children(last) or return false
+            consts = table.children(builder.env.normalize_module_name(last)) or return false
             constants.merge!(consts)
           end
         end
@@ -160,14 +176,14 @@ module RBS
       end
 
       def constants_from_ancestors(module_name, constants:)
-        entry = builder.env.class_decls[module_name]
+        entry = builder.env.normalized_module_class_entry(module_name) or raise
 
-        if entry.is_a?(Environment::ModuleEntry)
+        if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
           constants.merge!(table.children(BuiltinNames::Object.name) || raise)
           constants.merge!(table.toplevel)
         end
 
-        builder.ancestor_builder.instance_ancestors(module_name).ancestors.reverse_each do |ancestor|
+        builder.ancestor_builder.instance_ancestors(entry.name).ancestors.reverse_each do |ancestor|
           if ancestor.is_a?(Definition::Ancestor::Instance)
             case ancestor.source
             when AST::Members::Include, :super, nil

data/lib/rbs/resolver/type_name_resolver.rb

@@ -5,14 +5,17 @@ module RBS
     class TypeNameResolver
       attr_reader :all_names
       attr_reader :cache
+      attr_reader :env
 
       def initialize(env)
         @all_names = Set[]
         @cache = {}
+        @env = env
 
         all_names.merge(env.class_decls.keys)
         all_names.merge(env.interface_decls.keys)
-        all_names.merge(env.alias_decls.keys)
+        all_names.merge(env.type_alias_decls.keys)
+        all_names.merge(env.class_alias_decls.keys)
       end
 
       def try_cache(query)
@@ -28,22 +31,53 @@ module RBS
         end
 
         try_cache([type_name, context]) do
-          resolve_in(type_name, context)
+          head, tail = partition(type_name)
+
+          head = resolve_in(head, context)
+
+          if head
+            if tail
+              absolute_name = tail.with_prefix(head.to_namespace)
+              if env.normalize_type_name?(absolute_name)
+                absolute_name
+              end
+            else
+              head
+            end
+          end
+        end
+      end
+
+      def partition(type_name)
+        if type_name.namespace.empty?
+          head = type_name.name
+          tail = nil
+        else
+          head, *tail = type_name.namespace.path
+
+          head or raise
+
+          tail = TypeName.new(
+            name: type_name.name,
+            namespace: Namespace.new(absolute: false, path: tail)
+          )
         end
+
+        [head, tail]
       end
 
-      def resolve_in(type_name, context)
+      def resolve_in(head, context)
         if context
           parent, child = context
           case child
           when false
-            resolve_in(type_name, parent)
+            resolve_in(head, parent)
           when TypeName
-            name = type_name.with_prefix(child.to_namespace)
-            has_name?(name) || resolve_in(type_name, parent)
+            name = TypeName.new(name: head, namespace: child.to_namespace)
+            has_name?(name) || resolve_in(head, parent)
           end
         else
-          has_name?(type_name.absolute!)
+          has_name?(TypeName.new(name: head, namespace: Namespace.root))
         end
       end
 

data/lib/rbs/sorter.rb

@@ -15,153 +15,183 @@ module RBS
       stdout.puts "Opening #{path}..."
 
       buffer = Buffer.new(name: path, content: path.read)
-      sigs = Parser.parse_signature(buffer)
+      _, _, sigs = Parser.parse_signature(buffer)
 
-      sigs.each do |m|
-        sort_decl! m
+      sigs = sigs.map do |m|
+        sort_decl m
       end
 
       stdout.puts "Writing #{path}..."
       path.open('w') do |out|
         writer = RBS::Writer.new(out: out)
-        writer.write sigs
+        writer.write _ = sigs
       end
     end
 
-    def group(member)
-      case member
-      when Declarations::Alias
-        -3
-      when Declarations::Constant
-        -2
-      when Declarations::Class, Declarations::Module
-        -1
-      when Members::Include
-        0.0
-      when Members::Prepend
-        0.2
-      when Members::Extend
-        0.4
-      when Members::ClassVariable
-        1
-      when Members::ClassInstanceVariable
-        2
-      when Members::InstanceVariable
-        3
-      when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
-        if member.kind == :singleton
-          5.0
-        else
-          6.0
-        end
-      when Members::MethodDefinition
-        case member.kind
-        when :singleton_instance
-          4
-        when :singleton
-          if member.name == :new
-            5.2
-          elsif member.visibility == :public
-            5.4
-          else
-            5.6
-          end
-        else
-          if member.name == :initialize
-            6.2
-          elsif member.visibility == :public
-            6.4
-          else
-            6.6
-          end
-        end
-      when Members::Alias
-        if member.singleton?
-          5.4
-        else
-          6.4
-        end
-      else
-        raise
-      end
-    end
-
-    def key(member)
-      case member
-      when Members::Include, Members::Extend, Members::Prepend
-        member.name.to_s
-      when Members::ClassVariable, Members::ClassInstanceVariable, Members::InstanceVariable
-        member.name.to_s
-      when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
-        member.name.to_s
-      when Members::MethodDefinition
-        member.name.to_s
-      when Members::Alias
-        member.new_name.to_s
-      when Declarations::Constant
-        member.name.to_s
-      when Declarations::Alias
-        member.name.to_s
-      when Declarations::Class, Declarations::Module
-        member.name.to_s
-      else
-        raise
-      end
-    end
-
-    def sort_decl!(decl)
+    def sort_decl(decl)
       case decl
       when Declarations::Class, Declarations::Module, Declarations::Interface
-        decl.members.each { |m| sort_decl! m }
+        partitioned = {
+          type_alias_decls: [],
+          constant_decls: [],
+          class_decls: [],
+          mixin_includes: [],
+          mixin_prepends: [],
+          mixin_extends: [],
+          class_variables: [],
+          class_instance_variables: [],
+          instance_variables: [],
+          singleton_attributes: [],
+          instance_attributes: [],
+          module_functions: [],
+          singleton_new_methods: [],
+          public_singleton_methods: [],
+          private_singleton_methods: [],
+          instance_initialize_methods: [],
+          public_instance_methods: [],
+          private_instance_methods: [],
+        } #: partitioned
 
-        current_visibility = :public
-        decl.members.map! do |m|
-          case m
+        members = decl.members.map { |m| sort_decl m }
+        decl = decl.update(members: _ = members)
+
+        visibility_annotated_members = [] #: Array[member]
+
+        decl.members.inject(:public) do |current_visibility, member| #$ AST::Members::visibility
+          case member
           when Members::Public
-            current_visibility = :public
-            nil
+            :public
           when Members::Private
-            current_visibility = :private
-            nil
+            :private
           when Members::MethodDefinition, Members::AttrReader, Members::AttrWriter, Members::AttrAccessor
-            m.update(visibility: m.visibility || current_visibility)
-          else
-            m
-          end
-        end
-        decl.members.compact!
-
-        decl.members.sort! do |m1, m2|
-          group1 = group(m1)
-          group2 = group(m2)
-
-          if group1 == group2
-            key(m1) <=> key(m2)
+            visibility_annotated_members << member.update(visibility: member.visibility || current_visibility)
+            current_visibility
           else
-            group1 <=> group2
+            visibility_annotated_members << member
+            current_visibility
           end
         end
 
-        current_visibility = :public
-        decl.members.map! do |m|
-          case m
-          when Members::MethodDefinition, Members::AttrReader, Members::AttrWriter, Members::AttrAccessor
-            new = m.update(visibility: nil)
-            cur = current_visibility
-            current_visibility = m.visibility
-            if cur != m.visibility
-              [
-                m.visibility == :public ? Members::Public.new(location: nil) : Members::Private.new(location: nil),
-                new
-              ]
+        visibility_annotated_members.each do |member|
+          case member
+          when Declarations::TypeAlias
+            partitioned[:type_alias_decls] << member
+          when Declarations::Constant
+            partitioned[:constant_decls] << member
+          when Declarations::Class, Declarations::Module, Declarations::Interface
+            partitioned[:class_decls] << member
+          when Members::Include
+            partitioned[:mixin_includes] << member
+          when Members::Prepend
+            partitioned[:mixin_prepends] << member
+          when Members::Extend
+            partitioned[:mixin_extends] << member
+          when Members::ClassVariable
+            partitioned[:class_variables] << member
+          when Members::ClassInstanceVariable
+            partitioned[:class_instance_variables] << member
+          when Members::InstanceVariable
+            partitioned[:instance_variables] << member
+          when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
+            if member.kind == :singleton
+              partitioned[:singleton_attributes] << member.update(visibility: nil)
+            else
+              partitioned[:instance_attributes] << member.update(visibility: nil)
+            end
+          when Members::MethodDefinition
+            case member.kind
+            when :singleton_instance
+              partitioned[:module_functions] << member.update(visibility: nil)
+            when :singleton
+              if member.name == :new
+                partitioned[:singleton_new_methods] << member.update(visibility: nil)
+              elsif member.visibility == :public
+                partitioned[:public_singleton_methods] << member.update(visibility: nil)
+              else
+                partitioned[:private_singleton_methods] << member.update(visibility: nil)
+              end
             else
-              new
+              if member.name == :initialize
+                partitioned[:instance_initialize_methods] << member.update(visibility: nil)
+              elsif member.visibility == :public
+                partitioned[:public_instance_methods] << member.update(visibility: nil)
+              else
+                partitioned[:private_instance_methods] << member.update(visibility: nil)
+              end
             end
+          when Members::Alias
+            if member.singleton?
+              partitioned[:public_singleton_methods] << member
+            else
+              partitioned[:public_instance_methods] << member
+            end
+          when Members::Public, Members::Private
+            raise
           else
-            m
+            partitioned[:other_decls] << member
           end
         end
-        decl.members.flatten!
+
+        partitioned[:type_alias_decls].sort_by! {|decl| decl.name.to_s }
+        partitioned[:constant_decls].sort_by! {|decl| decl.name.to_s }
+        partitioned[:class_decls].sort_by! {|decl| decl.name.to_s }
+        partitioned[:mixin_includes].sort_by! {|decl| decl.name.to_s }
+        partitioned[:mixin_prepends].sort_by! {|decl| decl.name.to_s }
+        partitioned[:mixin_extends].sort_by! {|decl| decl.name.to_s }
+        partitioned[:class_variables].sort_by! {|decl| decl.name.to_s }
+        partitioned[:class_instance_variables].sort_by! {|decl| decl.name.to_s }
+        partitioned[:instance_variables].sort_by! {|decl| decl.name.to_s }
+        partitioned[:singleton_attributes].sort_by! {|decl| decl.name.to_s }
+        partitioned[:instance_attributes].sort_by! {|decl| decl.name.to_s }
+        partitioned[:module_functions].sort_by! {|decl| decl.name.to_s }
+        partitioned[:public_singleton_methods].sort_by! {|decl| decl.is_a?(Members::MethodDefinition) ? decl.name.to_s : decl.new_name.to_s }
+        partitioned[:private_singleton_methods].sort_by! {|decl| decl.name.to_s }
+        partitioned[:public_instance_methods].sort_by! {|decl| decl.is_a?(Members::MethodDefinition) ? decl.name.to_s : decl.new_name.to_s }
+        partitioned[:private_instance_methods].sort_by! {|decl| decl.name.to_s }
+
+        members = [] #: Array[member]
+        members.push(*partitioned[:type_alias_decls])
+        members.push(*partitioned[:constant_decls])
+        members.push(*partitioned[:class_decls])
+        members.push(*partitioned[:mixin_includes])
+        members.push(*partitioned[:mixin_prepends])
+        members.push(*partitioned[:mixin_extends])
+        members.push(*partitioned[:class_variables])
+        members.push(*partitioned[:class_instance_variables])
+        members.push(*partitioned[:instance_variables])
+        members.push(*partitioned[:module_functions])
+        members.push(*partitioned[:singleton_attributes])
+
+        current_visibility = :public #: AST::Members::visibility
+
+        members.push(*partitioned[:singleton_new_methods])
+        members.push(*partitioned[:public_singleton_methods])
+
+        if !partitioned[:private_singleton_methods].empty?
+          current_visibility = :private
+          members.push Members::Private.new(location: nil)
+        end
+        members.push(*partitioned[:private_singleton_methods])
+
+        if current_visibility == :private && !partitioned[:public_instance_methods].empty?
+          current_visibility = :public
+          members.push Members::Public.new(location: nil)
+        end
+        members.push(*partitioned[:instance_attributes])
+        members.push(*partitioned[:instance_initialize_methods])
+        members.push(*partitioned[:public_instance_methods])
+
+        if current_visibility == :public && !partitioned[:private_instance_methods].empty?
+          current_visibility = :private
+          members.push Members::Private.new(location: nil)
+        end
+        members.push(*partitioned[:private_instance_methods])
+
+        members.push(*partitioned[:other_decls])
+
+        decl.update(members: _ = members)
+      else
+        decl
       end
     end
   end

data/lib/rbs/substitution.rb

@@ -50,6 +50,8 @@ module RBS
       end
     end
 
+    alias [] apply
+
     def without(*vars)
       Substitution.new.tap do |subst|
         subst.mapping.merge!(mapping)
@@ -60,5 +62,22 @@ module RBS
         subst.instance_type = self.instance_type
       end
     end
+
+    def +(other)
+      return self if other.empty?
+      return other if self.empty?
+
+      Substitution.new.tap do |subst|
+        subst.mapping.merge!(mapping)
+
+        other.mapping.each do |var, type|
+          if mapping.key?(var)
+            subst.add(from: var, to: self[type])
+          else
+            subst.add(from: var, to: type)
+          end
+        end
+      end
+    end
   end
 end

data/lib/rbs/subtractor.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RBS
+  class Subtractor
+    def initialize(minuend, subtrahend)
+      @minuend = minuend
+      @subtrahend = subtrahend
+    end
+
+    def call(minuend = @minuend, context: nil)
+      minuend.map do |decl|
+        case decl
+        when AST::Declarations::Constant
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.constant_name?(name)
+        when AST::Declarations::Interface
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.interface_name?(name)
+        when AST::Declarations::Class, AST::Declarations::Module
+          name = absolute_typename(decl.name, context: context)
+          case
+          when @subtrahend.class_decl?(name) && decl.is_a?(AST::Declarations::Class)
+            filter_members(decl, context: context)
+          when @subtrahend.module_decl?(name) && decl.is_a?(AST::Declarations::Module)
+            filter_members(decl, context: context)
+          when @subtrahend.constant_name?(name)
+            nil
+          else
+            decl
+          end
+        when AST::Declarations::Global
+          decl unless @subtrahend.global_decls[decl.name]
+        when AST::Declarations::TypeAlias
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.type_alias_decls[name]
+        when AST::Declarations::ClassAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.class_alias?(name) || @subtrahend.class_decl?(name)
+        when AST::Declarations::ModuleAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.module_alias?(name) || @subtrahend.module_decl?(name)
+        else
+          raise "unknwon decl: #{(_ = decl).class}"
+        end
+      end.compact
+    end
+
+    private def filter_members(decl, context:)
+      owner = absolute_typename(decl.name, context: context)
+
+      context = _ = [context, decl.name]
+      children = call(decl.each_decl.to_a, context: context) +
+        decl.each_member.reject { |m| member_exist?(owner, m, context: context) }
+      children = filter_redundunt_access_modifiers(children)
+      return nil if children.empty?
+
+      update_decl(decl, members: children)
+    end
+
+    private def member_exist?(owner, member, context:)
+      case member
+      when AST::Members::MethodDefinition
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::Alias
+        method_exist?(owner, member.new_name, member.kind)
+      when AST::Members::AttrReader
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::AttrWriter
+        method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::AttrAccessor
+        # TODO: It unexpectedly removes attr_accessor even if either reader or writer does not exist in the subtrahend.
+        method_exist?(owner, member.name, member.kind) || method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::InstanceVariable
+        ivar_exist?(owner, member.name, :instance)
+      when AST::Members::ClassInstanceVariable
+        ivar_exist?(owner, member.name, :singleton)
+      when AST::Members::ClassVariable
+        cvar_exist?(owner, member.name)
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        mixin_exist?(owner, member, context: context)
+      when AST::Members::Public, AST::Members::Private
+        # They should not be removed even if the subtrahend has them.
+        false
+      else
+        raise "unknown member: #{(_ = member).class}"
+      end
+    end
+
+    private def method_exist?(owner, method_name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::MethodDefinition
+          m.name == method_name && m.kind == kind
+        when AST::Members::Alias
+          m.new_name == method_name && m.kind == kind
+        when AST::Members::AttrReader
+          m.name == method_name && m.kind == kind
+        when AST::Members::AttrWriter
+          :"#{m.name}=" == method_name && m.kind == kind
+        when AST::Members::AttrAccessor
+          (m.name == method_name || :"#{m.name}=" == method_name) && m.kind == kind
+        end
+      end
+    end
+
+    private def ivar_exist?(owner, name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::InstanceVariable
+          m.name == name
+        when AST::Members::Attribute
+          ivar_name = m.ivar_name == false ? nil : m.ivar_name || :"@#{m.name}"
+          ivar_name == name && m.kind == kind
+        end
+      end
+    end
+
+    private def cvar_exist?(owner, name)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::ClassVariable
+          m.name == name
+        end
+      end
+    end
+
+    private def each_member(owner, &block)
+      return enum_for((__method__ or raise), owner) unless block
+
+      entry = @subtrahend.class_decls[owner]
+      return unless entry
+      decls = entry.decls.map { |d| d.decl }
+
+      decls.each { |d| d.members.each { |m| block.call(m) } }
+    end
+
+    private def mixin_exist?(owner, mixin, context:)
+      candidates = typename_candidates(mixin.name, context: context)
+      each_member(owner).any? do |m|
+        case m
+        when mixin.class
+          # @type var m: AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+          candidates.include?(m.name)
+        end
+      end
+    end
+
+    private def filter_redundunt_access_modifiers(decls)
+      decls = decls.dup
+      decls.pop while access_modifier?(decls.last)
+      decls = decls.map.with_index do |decl, i|
+        if access_modifier?(decl) && access_modifier?(decls[i + 1])
+          nil
+        else
+          decl
+        end
+      end.compact
+    end
+
+    private def access_modifier?(decl)
+      decl.is_a?(AST::Members::Public) || decl.is_a?(AST::Members::Private)
+    end
+
+    private def update_decl(decl, members:)
+      case decl
+      when AST::Declarations::Class
+        decl.class.new(name: decl.name, type_params: decl.type_params, super_class: decl.super_class,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      when AST::Declarations::Module
+        decl.class.new(name: decl.name, type_params: decl.type_params, self_types: decl.self_types,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      end
+    end
+
+    private def absolute_typename(name, context:)
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        context = _ = context[0]
+      end
+      name.absolute!
+    end
+
+    private def typename_candidates(name, context:)
+      ret = [name.absolute!, name.relative!]
+      return ret if name.absolute?
+
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        ret.concat [name.absolute!, name.relative!]
+
+        context = _ = context[0]
+      end
+
+      ret
+    end
+  end
+end