rbs-relaxed 3.9.0.1

data/lib/rbs/repository.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RBS
+  class Repository
+    DEFAULT_STDLIB_ROOT = Pathname(_ = __dir__) + "../../stdlib"
+
+    class GemRBS
+      attr_reader :name
+      attr_reader :paths
+
+      def initialize(name:)
+        @name = name
+        @paths = []
+        @versions = nil
+      end
+
+      def versions
+        load! unless @versions
+        @versions or raise
+      end
+
+      def load!
+        @versions = {}
+        versions = @versions or raise
+
+        paths.each do |gem_path|
+          gem_path.each_child(false) do |child|
+            next unless Gem::Version.correct?(child.to_s)
+
+            if version = Gem::Version.create(child.to_s)
+              unless version.prerelease?
+                path = gem_path + child
+
+                if prev = versions[version]
+                  RBS.logger.info { "Overwriting gem RBS in repository: gem=#{name}, prev_path=#{prev.path}, new_path=#{path}" }
+                end
+
+                versions[version] = VersionPath.new(gem: self, version: version, path: path)
+              end
+            end
+          end
+        end
+      end
+
+      def version_names
+        versions.keys.sort_by(&:version)
+      end
+
+      def oldest_version
+        oldest = version_names.first or raise
+        versions[oldest] or raise
+      end
+
+      def latest_version
+        latest = version_names.last or raise
+        versions[latest] or raise
+      end
+
+      def find_best_version(version)
+        best_version = Repository.find_best_version(version, version_names)
+        versions[best_version]
+      end
+
+      def empty?
+        versions.empty?
+      end
+    end
+
+    VersionPath = _ = Struct.new(:gem, :version, :path, keyword_init: true)
+
+    attr_reader :dirs
+    attr_reader :gems
+
+    def initialize(no_stdlib: false)
+      @dirs = []
+      @gems = {}
+
+      unless no_stdlib
+        add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def self.default
+      new()
+    end
+
+    def self.find_best_version(version, candidates)
+      candidates = candidates.sort
+      return candidates.last || raise unless version
+
+      if v = candidates.reverse.bsearch {|v| v <= version ? true : false }
+        v
+      else
+        candidates.first or raise
+      end
+    end
+
+    def add(dir)
+      dirs << dir
+
+      dir.each_child(false) do |child|
+        gem_name = child.to_s
+        gem_rbs = (gems[gem_name] ||= GemRBS.new(name: gem_name))
+        gem_rbs.paths << dir + child
+      end
+    end
+
+    def lookup(gem, version)
+      _, set = lookup_path(gem, version)
+      set&.path
+    end
+
+    def lookup_path(gem, version)
+      if gem_rbs = gems[gem]
+        unless gem_rbs.empty?
+          set = if version and v = Gem::Version.create(version)&.release
+            gem_rbs.find_best_version(v)
+          else
+            gem_rbs.latest_version
+          end
+
+          [gem_rbs, set]
+        end
+      end
+    end
+  end
+end

data/lib/rbs/resolver/constant_resolver.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RBS
+  module Resolver
+    class ConstantResolver
+      class Table
+        attr_reader :children_table, :toplevel
+        attr_reader :constants_table
+
+        def initialize(environment)
+          @children_table = {}
+          @toplevel = {}
+
+          @constants_table = {}
+
+          environment.class_decls.each_key do |name|
+            children_table[name] = {}
+          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 "#{parent} not found by #{name}"
+            else
+              table = toplevel
+            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
+
+              table = children_table[parent] or raise
+              constant = constant_of_constant(name, entry)
+            else
+              table = toplevel
+              constant = constant_of_constant(name, entry)
+            end
+
+            table[name.name] = constant
+          end
+        end
+
+        def children(name)
+          children_table[name]
+        end
+
+        def constant(name)
+          constants_table[name]
+        end
+
+        def constant_of_module(name, entry)
+          type = Types::ClassSingleton.new(
+            name: name,
+            location: nil
+          )
+
+          Constant.new(name: name, type: type, entry: entry)
+        end
+
+        def constant_of_constant(name, entry)
+          Constant.new(name: name, type: entry.decl.type, entry: entry)
+        end
+      end
+
+      attr_reader :builder, :table
+      attr_reader :context_constants_cache, :child_constants_cache
+
+      def initialize(builder:)
+        @builder = builder
+        @table = Table.new(builder.env)
+        @context_constants_cache = {}
+        @child_constants_cache = {}
+      end
+
+      def resolve(name, context:)
+        cs = constants(context) or raise "Broken context is given"
+        cs[name]
+      end
+
+      def constants(context)
+        unless context_constants_cache.key?(context)
+          load_context_constants(context)
+        end
+
+        context_constants_cache[context]
+      end
+
+      def resolve_child(module_name, name)
+        children(module_name)[name]
+      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
+
+        child_constants_cache[module_name] or raise
+      end
+
+      def load_context_constants(context)
+        # @type var consts: Hash[Symbol, Constant]
+        consts = {}
+
+        if last = context&.[](1)
+          constants_from_ancestors(last, constants: consts)
+        else
+          constants_from_ancestors(BuiltinNames::Object.name, constants: consts)
+        end
+
+        constants_from_context(context, constants: consts) or return
+        constants_itself(context, constants: consts)
+
+        context_constants_cache[context] = consts
+      end
+
+      def load_child_constants(name)
+        # @type var constants: Hash[Symbol, Constant]
+        constants = {}
+
+        if table.children(name)
+          builder.ancestor_builder.instance_ancestors(name).ancestors.reverse_each do |ancestor|
+            if ancestor.is_a?(Definition::Ancestor::Instance)
+              if ancestor.name == BuiltinNames::Object.name
+                if name != BuiltinNames::Object.name
+                  next
+                end
+              end
+
+              case ancestor.source
+              when AST::Members::Include, :super, nil
+                consts = table.children(ancestor.name) or raise
+                constants.merge!(consts)
+              end
+            end
+          end
+        end
+
+        child_constants_cache[name] = constants
+      end
+
+      def constants_from_context(context, constants:)
+        if context
+          parent, last = context
+
+          constants_from_context(parent, constants: constants) or return false
+
+          if last
+            consts = table.children(builder.env.normalize_module_name(last)) or return false
+            constants.merge!(consts)
+          end
+        end
+
+        true
+      end
+
+      def constants_from_ancestors(module_name, constants:)
+        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)
+          constants.merge!(table.toplevel)
+        end
+
+        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
+              consts = table.children(ancestor.name) or raise
+              if ancestor.name == BuiltinNames::Object.name && entry.is_a?(Environment::ClassEntry)
+                # Insert toplevel constants as ::Object's constants
+                consts.merge!(table.toplevel)
+              end
+              constants.merge!(consts)
+            end
+          end
+        end
+      end
+
+      def constants_itself(context, constants:)
+        if context
+          _, typename = context
+
+          if typename
+            if (ns = typename.namespace).empty?
+              constant = table.toplevel[typename.name] or raise
+            else
+              hash = table.children(ns.to_type_name) or raise
+              constant = hash[typename.name]
+            end
+
+            constants[typename.name] = constant
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/resolver/type_name_resolver.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RBS
+  module Resolver
+    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.type_alias_decls.keys)
+        all_names.merge(env.class_alias_decls.keys)
+      end
+
+      def try_cache(query)
+        cache.fetch(query) do
+          result = yield
+          cache[query] = result
+        end
+      end
+
+      def resolve(type_name, context:)
+        if type_name.absolute?
+          return type_name
+        end
+
+        try_cache([type_name, context]) do
+          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(head, context)
+        if context
+          parent, child = context
+          case child
+          when false
+            resolve_in(head, parent)
+          when TypeName
+            name = TypeName.new(name: head, namespace: child.to_namespace)
+            has_name?(name) || resolve_in(head, parent)
+          end
+        else
+          has_name?(TypeName.new(name: head, namespace: Namespace.root))
+        end
+      end
+
+      def has_name?(full_name)
+        if all_names.include?(full_name)
+          full_name
+        end
+      end
+    end
+  end
+end

data/lib/rbs/sorter.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module RBS
+  class Sorter
+    include RBS::AST
+
+    attr_reader :path, :stdout
+
+    def initialize(path, stdout: $stdout)
+      @path = path
+      @stdout = stdout
+    end
+
+    def run
+      stdout.puts "Opening #{path}..."
+
+      buffer = Buffer.new(name: path, content: path.read)
+      _, _, sigs = Parser.parse_signature(buffer)
+
+      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
+      end
+    end
+
+    def sort_decl(decl)
+      case decl
+      when Declarations::Class, Declarations::Module, Declarations::Interface
+        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
+
+        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
+            :public
+          when Members::Private
+            :private
+          when Members::MethodDefinition, Members::AttrReader, Members::AttrWriter, Members::AttrAccessor
+            visibility_annotated_members << member.update(visibility: member.visibility || current_visibility)
+            current_visibility
+          else
+            visibility_annotated_members << member
+            current_visibility
+          end
+        end
+
+        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
+              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
+            partitioned[:other_decls] << member
+          end
+        end
+
+        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
+end

data/lib/rbs/substitution.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RBS
+  class Substitution
+    attr_reader :mapping
+    attr_accessor :instance_type
+
+    def empty?
+      mapping.empty? && instance_type.nil?
+    end
+
+    def initialize()
+      @mapping = {}
+    end
+
+    def add(from:, to:)
+      mapping[from] = to
+    end
+
+    def self.build(variables, types, instance_type: nil, &block)
+      unless variables.size == types.size
+        raise "Broken substitution: variables=#{variables}, types=#{types}"
+      end
+
+      mapping = variables.zip(types).to_h
+
+      self.new.tap do |subst|
+        mapping.each do |v, t|
+          type = block_given? ? yield(t) : t
+          subst.add(from: v, to: type)
+        end
+
+        subst.instance_type = instance_type
+      end
+    end
+
+    def apply(ty)
+      case ty
+      when Types::Variable
+        # @type var ty: Types::Variable
+        mapping[ty.name] || ty
+      when Types::Bases::Instance
+        if t = instance_type
+          t
+        else
+          ty
+        end
+      else
+        ty
+      end
+    end
+
+    alias [] apply
+
+    def without(*vars)
+      Substitution.new.tap do |subst|
+        subst.mapping.merge!(mapping)
+        vars.each do |var|
+          subst.mapping.delete(var)
+        end
+
+        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