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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/prototype/runtime.rb

@@ -1,667 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'runtime/helpers'
-require_relative 'runtime/value_object_generator'
-require_relative 'runtime/reflection'
-
-module RBS
-  module Prototype
-    class Runtime
-      class Todo
-        def initialize(builder:)
-          @builder = builder
-        end
-
-        def skip_mixin?(type_name:, module_name:, mixin_class:)
-          return false unless @builder.env.module_class_entry(type_name.absolute!)
-          return false unless @builder.env.module_class_entry(module_name.absolute!)
-
-          mixin_decls(type_name).any? do |decl|
-            decl.instance_of?(mixin_class) && decl.name == module_name.absolute!
-          end
-        end
-
-        def skip_singleton_method?(module_name:, method:, accessibility:)
-          return false unless @builder.env.module_class_entry(module_name.absolute!)
-
-          method_definition = @builder.build_singleton(module_name.absolute!).methods[method.name]
-          return false unless method_definition
-
-          method_definition.accessibility == accessibility
-        end
-
-        def skip_instance_method?(module_name:, method:, accessibility:)
-          return false unless @builder.env.module_class_entry(module_name.absolute!)
-
-          method_definition = @builder.build_instance(module_name.absolute!).methods[method.name]
-          return false unless method_definition
-
-          method_definition.accessibility == accessibility
-        end
-
-        def skip_constant?(module_name:, name:)
-          namespace = Namespace.new(path: module_name.split('::').map(&:to_sym), absolute: true)
-          @builder.env.constant_decl?(TypeName.new(namespace: namespace, name: name))
-        end
-
-        private
-
-        def mixin_decls(type_name)
-          type_name_absolute = type_name.absolute!
-          @mixin_decls_cache ||= {} #: Hash[TypeName, Array[AST::Members::Mixin]]
-          @mixin_decls_cache.fetch(type_name_absolute) do
-            @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].decls.flat_map do |d|
-              d.decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
-            end
-          end
-        end
-      end
-      private_constant :Todo
-
-      include Prototype::Helpers
-      include Runtime::Helpers
-
-      attr_reader :patterns
-      attr_reader :env
-      attr_reader :merge
-      attr_reader :todo
-      attr_reader :owners_included
-      attr_accessor :outline
-
-      def initialize(patterns:, env:, merge:, todo: false, owners_included: [])
-        @patterns = patterns
-        @decls = nil
-        @modules = {}
-        @env = env
-        @merge = merge
-        @owners_included = owners_included.map do |name|
-          Object.const_get(name)
-        end
-        @outline = false
-        @todo = todo
-      end
-
-      def target?(const)
-        name = const_name(const)
-        return false unless name
-
-        patterns.any? do |pattern|
-          if pattern.end_with?("*")
-            (name || "").start_with?(pattern.chop)
-          else
-            name == pattern
-          end
-        end
-      end
-
-      def todo_object
-        @todo_object ||= Todo.new(builder: builder) if todo
-      end
-
-      def builder
-        @builder ||= DefinitionBuilder.new(env: env)
-      end
-
-      def parse(file)
-        require file
-      end
-
-      def decls
-        unless @decls
-          @decls = []
-          @modules = ObjectSpace.each_object(Module)
-            .map { |mod| [const_name(mod), mod] }
-            .select { |name, _| name }
-            .to_h
-          @modules.select { |name, mod| target?(mod) }.sort_by { |name, _| name }.each do |_, mod|
-            case mod
-            when Class
-              generate_class mod
-            when Module
-              generate_module mod
-            end
-          end
-        end
-
-        @decls or raise
-      end
-
-      private def each_mixined_module(type_name, mod)
-        each_mixined_module_one(type_name, mod) do |module_name, module_full_name, is_prepend|
-          yield module_name, module_full_name, is_prepend ? AST::Members::Prepend : AST::Members::Include
-        end
-        each_mixined_module_one(type_name, mod.singleton_class) do |module_name, module_full_name, _|
-          yield module_name, module_full_name, AST::Members::Extend
-        end
-      end
-
-      private def each_mixined_module_one(type_name, mod)
-        supers = Set[] #: Set[Module]
-        prepends = mod.ancestors.take_while { |m| !mod.equal?(m) }.to_set
-
-        mod.included_modules.each do |mix|
-          supers.merge(mix.included_modules)
-        end
-
-        if mod.is_a?(Class)
-          if superclass = mod.superclass
-            superclass.included_modules.each do |mix|
-              supers << mix
-              supers.merge(mix.included_modules)
-            end
-          end
-        end
-
-        mod.included_modules.uniq.each do |mix|
-          if !supers.include?(mix) || prepends.include?(mix)
-            unless const_name(mix)
-              RBS.logger.warn("Skipping anonymous module #{mix} included in #{mod}")
-            else
-              module_name = module_full_name = to_type_name(const_name!(mix), full_name: true)
-              if module_full_name.namespace == type_name.namespace
-                module_name = TypeName.new(name: module_full_name.name, namespace: Namespace.empty)
-              end
-
-              yield module_name, module_full_name, prepends.include?(mix)
-            end
-          end
-        end
-      end
-
-      def method_type(method)
-        untyped = Types::Bases::Any.new(location: nil)
-
-        required_positionals = [] #: Array[Types::Function::Param]
-        optional_positionals = [] #: Array[Types::Function::Param]
-        rest = nil #: Types::Function::Param?
-        trailing_positionals = [] #: Array[Types::Function::Param]
-        required_keywords = {} #: Hash[Symbol, Types::Function::Param]
-        optional_keywords = {} #: Hash[Symbol, Types::Function::Param]
-        rest_keywords = nil #: Types::Function::Param?
-
-        requireds = required_positionals
-
-        block = nil #: Types::Block?
-
-        method.parameters.each do |(kind, name)|
-          case kind
-          when :req
-            requireds << Types::Function::Param.new(name: name, type: untyped)
-          when :opt
-            requireds = trailing_positionals
-            optional_positionals << Types::Function::Param.new(name: name, type: untyped)
-          when :rest
-            requireds = trailing_positionals
-            name = nil if name == :* # For `def f(...) end` syntax
-            rest = Types::Function::Param.new(name: name, type: untyped)
-          when :keyreq
-            name or raise
-            required_keywords[name] = Types::Function::Param.new(name: nil, type: untyped)
-          when :key
-            name or raise
-            optional_keywords[name] = Types::Function::Param.new(name: nil, type: untyped)
-          when :keyrest
-            rest_keywords = Types::Function::Param.new(name: nil, type: untyped)
-          when :block
-            block = Types::Block.new(
-              type: Types::Function.empty(untyped).update(rest_positionals: Types::Function::Param.new(name: nil, type: untyped)),
-              required: true,
-              self_type: nil
-            )
-          end
-        end
-
-        block ||= block_from_ast_of(method)
-
-        return_type = if method.name == :initialize
-                        Types::Bases::Void.new(location: nil)
-                      else
-                        untyped
-                      end
-        method_type = Types::Function.new(
-          required_positionals: required_positionals,
-          optional_positionals: optional_positionals,
-          rest_positionals: rest,
-          trailing_positionals: trailing_positionals,
-          required_keywords: required_keywords,
-          optional_keywords: optional_keywords,
-          rest_keywords: rest_keywords,
-          return_type: return_type,
-        )
-
-        MethodType.new(
-          location: nil,
-          type_params: [],
-          type: method_type,
-          block: block
-        )
-      end
-
-      def merge_rbs(module_name, members, instance: nil, singleton: nil)
-        if merge
-          if env.class_decls[module_name.absolute!]
-            # @type var kind: AST::Members::MethodDefinition::kind
-            case
-            when instance
-              method = builder.build_instance(module_name.absolute!).methods[instance]
-              method_name = instance
-              kind = :instance
-            when singleton
-              method = builder.build_singleton(module_name.absolute!).methods[singleton]
-              method_name = singleton
-              kind = :singleton
-            end
-
-            if method
-              members << AST::Members::MethodDefinition.new(
-                name: method_name,
-                overloads: method.method_types.map {|type|
-                  AST::Members::MethodDefinition::Overload.new(
-                    annotations: [],
-                    method_type: type.update.tap do |ty|
-                      def ty.to_s
-                        location or raise
-                        location.source
-                      end
-                    end
-                  )
-                },
-                kind: kind,
-                location: nil,
-                comment: method.comments[0],
-                annotations: method.annotations,
-                overloading: false,
-                visibility: nil
-              )
-              return
-            end
-          end
-
-          yield
-        else
-          yield
-        end
-      end
-
-      def target_method?(mod, instance: nil, singleton: nil)
-        case
-        when instance
-          method = mod.instance_method(instance)
-          method.owner == mod || owners_included.any? {|m| method.owner == m }
-        when singleton
-          method = mod.singleton_class.instance_method(singleton)
-          method.owner == mod.singleton_class || owners_included.any? {|m| method.owner == m.singleton_class }
-        else
-          raise
-        end
-      end
-
-      def generate_methods(mod, module_name, members)
-        module_name_absolute = to_type_name(const_name!(mod), full_name: true).absolute!
-        mod.singleton_methods.select {|name| target_method?(mod, singleton: name) }.sort.each do |name|
-          method = mod.singleton_class.instance_method(name)
-          next if todo_object&.skip_singleton_method?(module_name: module_name_absolute, method: method, accessibility: :public)
-
-          if can_alias?(mod.singleton_class, method)
-            members << AST::Members::Alias.new(
-              new_name: method.name,
-              old_name: method.original_name,
-              kind: :singleton,
-              location: nil,
-              comment: nil,
-              annotations: [],
-            )
-          else
-            merge_rbs(module_name, members, singleton: name) do
-              RBS.logger.info "missing #{module_name}.#{name} #{method.source_location}"
-
-              members << AST::Members::MethodDefinition.new(
-                name: method.name,
-                overloads: [
-                  AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
-                ],
-                kind: :singleton,
-                location: nil,
-                comment: nil,
-                annotations: [],
-                overloading: false,
-                visibility: nil
-              )
-            end
-          end
-        end
-
-        public_instance_methods = mod.public_instance_methods.select {|name| target_method?(mod, instance: name) }
-        unless public_instance_methods.empty?
-          public_instance_methods.sort.each do |name|
-            method = mod.instance_method(name)
-            next if todo_object&.skip_instance_method?(module_name: module_name_absolute, method: method, accessibility: :public)
-
-            if can_alias?(mod, method)
-              members << AST::Members::Alias.new(
-                new_name: method.name,
-                old_name: method.original_name,
-                kind: :instance,
-                location: nil,
-                comment: nil,
-                annotations: [],
-              )
-            else
-              merge_rbs(module_name, members, instance: name) do
-                RBS.logger.info "missing #{module_name}##{name} #{method.source_location}"
-
-                members << AST::Members::MethodDefinition.new(
-                  name: method.name,
-                  overloads: [
-                    AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
-                  ],
-                  kind: :instance,
-                  location: nil,
-                  comment: nil,
-                  annotations: [],
-                  overloading: false,
-                  visibility: nil
-                )
-              end
-            end
-          end
-        end
-
-        private_instance_methods = mod.private_instance_methods.select {|name| target_method?(mod, instance: name) }
-        unless private_instance_methods.empty?
-          added = false
-          members << AST::Members::Private.new(location: nil)
-
-          private_instance_methods.sort.each do |name|
-            method = mod.instance_method(name)
-            next if todo_object&.skip_instance_method?(module_name: module_name_absolute, method: method, accessibility: :private)
-
-            added = true
-            if can_alias?(mod, method)
-              members << AST::Members::Alias.new(
-                new_name: method.name,
-                old_name: method.original_name,
-                kind: :instance,
-                location: nil,
-                comment: nil,
-                annotations: [],
-              )
-            else
-              merge_rbs(module_name, members, instance: name) do
-                RBS.logger.info "missing #{module_name}##{name} #{method.source_location}"
-
-                members << AST::Members::MethodDefinition.new(
-                  name: method.name,
-                  overloads: [
-                    AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
-                  ],
-                  kind: :instance,
-                  location: nil,
-                  comment: nil,
-                  annotations: [],
-                  overloading: false,
-                  visibility: nil
-                )
-              end
-            end
-          end
-
-          members.pop unless added
-        end
-      end
-
-      private def can_alias?(mod, method)
-        return false if method.name == method.original_name
-
-        begin
-          mod.instance_method(method.original_name) && true
-        rescue NameError
-          false
-        end
-      end
-
-      def generate_constants(mod, decls)
-        module_name = const_name!(mod)
-        Reflection.constants_of(mod, false).sort.each do |name|
-          next if todo_object&.skip_constant?(module_name: module_name, name: name)
-
-          begin
-            value = mod.const_get(name)
-          rescue StandardError, LoadError => e
-            RBS.logger.warn("Skipping constant #{name} of #{mod} since #{e}")
-            next
-          end
-
-          next if Reflection.object_class(value).equal?(Class)
-          next if Reflection.object_class(value).equal?(Module)
-
-          unless Reflection.object_class(value).name
-            RBS.logger.warn("Skipping constant #{name} #{value} of #{mod} as an instance of anonymous class")
-            next
-          end
-
-          type = case value
-                 when true, false
-                   Types::Bases::Bool.new(location: nil)
-                 when nil
-                   Types::Optional.new(
-                     type: Types::Bases::Any.new(location: nil),
-                     location: nil
-                   )
-                 when ARGF
-                   Types::ClassInstance.new(name: TypeName.parse("::RBS::Unnamed::ARGFClass"), args: [], location: nil)
-                 when ENV
-                   Types::ClassInstance.new(name: TypeName.parse("::RBS::Unnamed::ENVClass"), args: [], location: nil)
-                 else
-                   value_type_name = to_type_name(const_name!(Reflection.object_class(value)), full_name: true).absolute!
-                   args = type_args(value_type_name)
-                   Types::ClassInstance.new(name: value_type_name, args: args, location: nil)
-                 end
-
-          decls << AST::Declarations::Constant.new(
-            name: to_type_name(name.to_s),
-            type: type,
-            location: nil,
-            comment: nil
-          )
-        end
-      end
-
-      def generate_super_class(mod)
-        superclass = mod.superclass
-
-        if superclass.nil? || superclass == ::Object
-          nil
-        elsif const_name(superclass).nil?
-          RBS.logger.warn("Skipping anonymous superclass #{superclass} of #{mod}")
-          nil
-        else
-          super_name = to_type_name(const_name!(superclass), full_name: true).absolute!
-          super_args = type_args(super_name)
-          AST::Declarations::Class::Super.new(name: super_name, args: super_args, location: nil)
-        end
-      end
-
-      def generate_class(mod)
-        type_name_absolute = to_type_name(const_name!(mod), full_name: true).absolute!
-        type_name = to_type_name(const_name!(mod))
-        outer_decls = ensure_outer_module_declarations(mod)
-
-        # Check if a declaration exists for the actual module
-        decl = outer_decls.detect do |decl|
-          decl.is_a?(AST::Declarations::Class) && decl.name.name == only_name(mod).to_sym
-        end #: AST::Declarations::Class?
-
-        unless decl
-          if StructGenerator.generatable?(mod)
-            decl = StructGenerator.new(mod).build_decl
-          elsif DataGenerator.generatable?(mod)
-            decl = DataGenerator.new(mod).build_decl
-          else
-            decl = AST::Declarations::Class.new(
-              name: to_type_name(only_name(mod)),
-              type_params: type_params(mod),
-              super_class: generate_super_class(mod),
-              members: [],
-              annotations: [],
-              location: nil,
-              comment: nil
-            )
-          end
-
-          outer_decls << decl
-        end
-
-        generate_mixin(mod, decl, type_name, type_name_absolute)
-
-        unless mod < Struct || (RUBY_VERSION >= '3.2' && mod < Data)
-          generate_methods(mod, type_name, decl.members) unless outline
-        end
-
-        generate_constants mod, decl.members
-      end
-
-      def generate_module(mod)
-        name = const_name(mod)
-
-        unless name
-          RBS.logger.warn("Skipping anonymous module #{mod}")
-          return
-        end
-
-        type_name_absolute = to_type_name(name, full_name: true).absolute!
-        type_name = to_type_name(name)
-        outer_decls = ensure_outer_module_declarations(mod)
-
-        # Check if a declaration exists for the actual class
-        decl = outer_decls.detect do |decl|
-          decl.is_a?(AST::Declarations::Module) && decl.name.name == only_name(mod).to_sym
-        end #: AST::Declarations::Module?
-
-        unless decl
-          decl = AST::Declarations::Module.new(
-            name: to_type_name(only_name(mod)),
-            type_params: type_params(mod),
-            self_types: [],
-            members: [],
-            annotations: [],
-            location: nil,
-            comment: nil
-          )
-
-          outer_decls << decl
-        end
-
-        generate_mixin(mod, decl, type_name, type_name_absolute)
-
-        generate_methods(mod, type_name, decl.members) unless outline
-
-        generate_constants mod, decl.members
-      end
-
-      def generate_mixin(mod, decl, type_name, type_name_absolute)
-        each_mixined_module(type_name, mod) do |module_name, module_full_name, mixin_class|
-          next if todo_object&.skip_mixin?(type_name: type_name_absolute, module_name: module_full_name, mixin_class: mixin_class)
-
-          args = type_args(module_full_name)
-          decl.members << mixin_class.new(
-            name: module_name,
-            args: args,
-            location: nil,
-            comment: nil,
-            annotations: []
-          )
-        end
-      end
-
-      # Generate/find outer module declarations
-      # This is broken down into another method to comply with `DRY`
-      # This generates/finds declarations in nested form & returns the last array of declarations
-      def ensure_outer_module_declarations(mod)
-        # @type var outer_module_names: Array[String]
-        *outer_module_names, _ = const_name!(mod).split(/::/) #=> parent = [A, B], mod = C
-        # Copy the entries in ivar @decls, not .dup
-        destination = @decls || [] #: Array[AST::Declarations::Class::member]
-
-        outer_module_names&.each_with_index do |outer_module_name, i|
-          current_name = outer_module_names.take(i+1).join('::')
-          outer_module = @modules[current_name]
-          outer_decl = destination.detect do |decl|
-            case outer_module
-            when Class
-              decl.is_a?(AST::Declarations::Class) && decl.name.name == outer_module_name.to_sym
-            when Module
-              decl.is_a?(AST::Declarations::Module) && decl.name.name == outer_module_name.to_sym
-            end
-          end #: AST::Declarations::Class | AST::Declarations::Module | nil
-
-          # Insert AST::Declarations if declarations are not added previously
-          unless outer_decl
-            outer_module or raise
-
-            if outer_module.is_a?(Class)
-              outer_decl = AST::Declarations::Class.new(
-                name: to_type_name(outer_module_name),
-                type_params: type_params(outer_module),
-                super_class: generate_super_class(outer_module),
-                members: [],
-                annotations: [],
-                location: nil,
-                comment: nil
-              )
-            else
-              outer_decl = AST::Declarations::Module.new(
-                name: to_type_name(outer_module_name),
-                type_params: type_params(outer_module),
-                self_types: [],
-                members: [],
-                annotations: [],
-                location: nil,
-                comment: nil
-              )
-            end
-
-            destination << outer_decl
-          end
-
-          destination = outer_decl.members
-        end
-
-        # Return the array of declarations checked out at the end
-        destination
-      end
-
-      def type_args(type_name)
-        if class_decl = env.class_decls.fetch(type_name.absolute!, nil)
-          class_decl.type_params.size.times.map { Types::Bases::Any.new(location: nil) }
-        else
-          []
-        end
-      end
-
-      def type_params(mod)
-        type_name = to_type_name(const_name!(mod), full_name: true)
-        if class_decl = env.class_decls[type_name.absolute!]
-          class_decl.type_params
-        else
-          []
-        end
-      end
-
-      def block_from_ast_of(method)
-        begin
-          ast = RubyVM::AbstractSyntaxTree.of(method)
-        rescue ArgumentError
-          return # When the method is defined in eval
-        rescue RuntimeError => error
-          raise unless error.message.include?("prism")
-          return # When the method was compiled by prism
-        end
-
-        if ast && ast.type == :SCOPE
-          block_from_body(ast)
-        end
-      end
-    end
-  end
-end