@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-4

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/repository.rb

@@ -1,127 +0,0 @@
-# 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/resolver/constant_resolver.rb

@@ -1,219 +0,0 @@
-# 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/resolver/type_name_resolver.rb

@@ -1,91 +0,0 @@
-# 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/sorter.rb

@@ -1,198 +0,0 @@
-# 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