rbs 2.8.4 → 3.8.1

data/lib/rbs/constant_table.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class ConstantTable
-    attr_reader :definition_builder
-    attr_reader :constant_scopes_cache
-
-    def env
-      definition_builder.env
-    end
-
-    def resolver
-      @resolver ||= TypeNameResolver.from_env(env)
-    end
-
-    def initialize(builder:)
-      @definition_builder = builder
-      @constant_scopes_cache = {}
-    end
-
-    def absolute_type(type, context:)
-      type.map_type_name do |type_name, location|
-        absolute_type_name(type_name, context: context, location: location)
-      end
-    end
-
-    def absolute_type_name(type_name, context:, location:)
-      resolver.resolve(type_name, context: context) or
-        raise NoTypeFoundError.new(type_name: type_name, location: location)
-    end
-
-    def name_to_constant(name)
-      case
-      when entry = env.constant_decls[name]
-        type = absolute_type(entry.decl.type, context: entry.context)
-        Constant.new(name: name, type: type, entry: entry)
-      when entry = env.class_decls[name]
-        type = Types::ClassSingleton.new(name: name, location: nil)
-        Constant.new(name: name, type: type, entry: entry)
-      end
-    end
-
-    def split_name(name)
-      name.namespace.path + [name.name]
-    end
-
-    def resolve_constant_reference(name, context:)
-      raise "Context cannot be empty: Specify `[Namespace.root]`" if context.empty?
-
-      head, *tail = split_name(name)
-
-      raise unless head
-
-      head_constant = case
-                      when name.absolute?
-                        name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                      when context == [Namespace.root]
-                        name_to_constant(TypeName.new(name: head, namespace: Namespace.root))
-                      else
-                        resolve_constant_reference_context(head, context: context) ||
-                          context.first.yield_self do |first_context|
-                            raise unless first_context
-                            resolve_constant_reference_inherit(head, scopes: constant_scopes(first_context.to_type_name))
-                          end
-                      end
-
-      tail.inject(head_constant) do |constant, name|
-        if constant
-          resolve_constant_reference_inherit(
-            name,
-            scopes: constant_scopes(constant.name),
-            no_object: constant.name != BuiltinNames::Object.name
-          )
-        end
-      end
-    end
-
-    def resolve_constant_reference_context(name, context:)
-      head, *tail = context
-
-      if head
-        if head.path.last == name
-          name_to_constant(head.to_type_name)
-        else
-          name_to_constant(TypeName.new(name: name, namespace: head)) ||
-            resolve_constant_reference_context(name, context: tail)
-        end
-      end
-    end
-
-    def resolve_constant_reference_inherit(name, scopes:, no_object: false)
-      scopes.each do |context|
-        if context.path == [:Object]
-          unless no_object
-            constant = name_to_constant(TypeName.new(name: name, namespace: context)) ||
-              name_to_constant(TypeName.new(name: name, namespace: Namespace.root))
-          end
-        else
-          constant = name_to_constant(TypeName.new(name: name, namespace: context))
-        end
-
-        return constant if constant
-      end
-
-      nil
-    end
-
-    def constant_scopes(name)
-      constant_scopes_cache[name] ||= constant_scopes0(name, scopes: [])
-    end
-
-    def constant_scopes_module(name, scopes:)
-      entry = env.class_decls[name]
-      namespace = name.to_namespace
-
-      entry.decls.each do |d|
-        d.decl.members.each do |member|
-          case member
-          when AST::Members::Include
-            if member.name.class?
-              constant_scopes_module absolute_type_name(member.name, context: d.context, location: member.location),
-                                     scopes: scopes
-            end
-          end
-        end
-      end
-
-      scopes.unshift namespace
-    end
-
-    def constant_scopes0(name, scopes: [])
-      entry = env.class_decls[name]
-      namespace = name.to_namespace
-
-      case entry
-      when Environment::ClassEntry
-        unless name == BuiltinNames::BasicObject.name
-          super_name = entry.primary.decl.super_class&.yield_self do |super_class|
-            absolute_type_name(super_class.name, context: entry.primary.context, location: entry.primary.decl.location)
-          end || BuiltinNames::Object.name
-
-          constant_scopes0 super_name, scopes: scopes
-        end
-
-        entry.decls.each do |d|
-          d.decl.members.each do |member|
-            case member
-            when AST::Members::Include
-              if member.name.class?
-                constant_scopes_module absolute_type_name(member.name, context: d.context, location: member.location),
-                                       scopes: scopes
-              end
-            end
-          end
-        end
-
-        scopes.unshift namespace
-
-      when Environment::ModuleEntry
-        constant_scopes0 BuiltinNames::Module.name, scopes: scopes
-        constant_scopes_module name, scopes: scopes
-      end
-
-      scopes
-    end
-  end
-end

data/lib/rbs/parser_compat/lexer_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-RBS.print_warning {
-  "RBS::Parser::LexerError is deprecated and will be deleted in RBS 2.0."
-}
-RBS::Parser::LexerError = RBS::ParsingError

data/lib/rbs/parser_compat/located_value.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-RBS.print_warning {
-  "RBS::Parser::LocatedValue is deprecated and will be deleted in RBS 2.0."
-}
-class RBS::Parser::LocatedValue
-end

data/lib/rbs/parser_compat/semantics_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-RBS.print_warning {
-  "RBS::Parser::SemanticsError is deprecated and will be deleted in RBS 2.0."
-}
-RBS::Parser::SemanticsError = RBS::ParsingError

data/lib/rbs/parser_compat/syntax_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-RBS.print_warning {
-  "RBS::Parser::SyntaxError is deprecated and will be deleted in RBS 2.0."
-}
-RBS::Parser::SyntaxError = RBS::ParsingError

data/lib/rbs/test/spy.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module Test
-  end
-end

data/lib/rbs/type_name_resolver.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class TypeNameResolver
-    Query = _ = Struct.new(:type_name, :context, keyword_init: true)
-
-    attr_reader :all_names
-    attr_reader :cache
-
-    def initialize()
-      @all_names = Set[]
-      @cache = {}
-    end
-
-    def self.from_env(env)
-      new.add_names(env.class_decls.keys)
-        .add_names(env.interface_decls.keys)
-        .add_names(env.alias_decls.keys)
-    end
-
-    def add_names(names)
-      all_names.merge(names)
-      self
-    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
-
-      query = Query.new(type_name: type_name, context: context)
-      try_cache(query) do
-        path_head, *path_tail = type_name.split
-        raise unless path_head
-
-        name_head = TypeName.new(name: path_head, namespace: Namespace.empty)
-
-        absolute_head = context.find do |namespace|
-          # @type break: TypeName
-          full_name = name_head.with_prefix(namespace)
-          has_name?(full_name) and break full_name
-        end
-
-        case absolute_head
-        when TypeName
-          has_name?(Namespace.new(path: absolute_head.to_namespace.path.push(*path_tail), absolute: true).to_type_name)
-        when Namespace
-          # This cannot happen because the `context.find` doesn't return a Namespace.
-          raise
-        end
-      end
-    end
-
-    def has_name?(full_name)
-      if all_names.include?(full_name)
-        full_name
-      end
-    end
-  end
-end

data/sig/constant_table.rbs

@@ -1,30 +0,0 @@
-module RBS
-  class ConstantTable
-    attr_reader definition_builder: DefinitionBuilder
-    attr_reader constant_scopes_cache: Hash[TypeName, Array[Namespace]]
-    attr_reader resolver: TypeNameResolver
-    attr_reader env(): Environment
-
-    def initialize: (builder: DefinitionBuilder) -> void
-
-    def absolute_type: (Types::t, context: Array[Namespace]) -> Types::t
-
-    def absolute_type_name: (TypeName, context: Array[Namespace], location: Location[untyped, untyped]?) -> TypeName
-
-    def name_to_constant: (TypeName) -> Constant?
-
-    def split_name: (TypeName) -> Array[Symbol]
-
-    def resolve_constant_reference: (TypeName name, context: Array[Namespace]) -> Constant?
-
-    def resolve_constant_reference_context: (Symbol, context: Array[Namespace]) -> Constant?
-
-    def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: boolish) -> Constant?
-
-    def constant_scopes: (TypeName) -> Array[Namespace]
-
-    def constant_scopes_module: (TypeName, scopes: Array[Namespace]) -> Array[Namespace]
-
-    def constant_scopes0: (TypeName, ?scopes: Array[Namespace]) -> Array[Namespace]
-  end
-end

data/sig/shims/abstract_syntax_tree.rbs

@@ -1,25 +0,0 @@
-class RubyVM
-  module AbstractSyntaxTree
-    def self.parse: (String src) -> Node
-
-    def self.parse_file: (String pathname) -> Node
-
-    def self.of: (untyped proc) -> Node
-
-    class Node
-      attr_reader children (): Array[untyped]
-
-      attr_reader first_column (): Integer
-
-      attr_reader first_lineno (): Integer
-
-      attr_reader last_column (): Integer
-
-      attr_reader last_lineno (): Integer
-
-      attr_reader type (): Symbol
-
-      def inspect: () -> String
-    end
-  end
-end

data/sig/shims/pp.rbs

@@ -1,3 +0,0 @@
-class PP
-  def self.pp: (untyped obj, IO out, ?Integer width) -> void
-end

data/sig/shims/ripper.rbs

@@ -1,8 +0,0 @@
-class Ripper
-  def self.lex: (String src, ?String filename, ?Integer lineno, ?raise_errors: bool) -> Array[[[Integer, Integer], Symbol, String, Lexer::State]]
-
-  class Lexer
-    class State
-    end
-  end
-end

data/sig/shims.rbs

@@ -1,69 +0,0 @@
-module Gem
-  class Specification
-    attr_reader version (): Version
-
-    attr_reader gem_dir (): String
-
-    def self.find_by_name: (String name, *String requirements) -> instance
-  end
-end
-
-module Bundler
-  class LockfileParser
-    def initialize: (String) -> void
-    def specs: () -> Array[LazySpecification]
-  end
-
-  class LazySpecification
-    def name: () -> String
-    def version: () -> String
-  end
-end
-
-module RDoc
-  class Store
-    def initialize: (?String? path, ?Symbol? type) -> void
-
-    def find_class_or_module: (String) -> ClassModule?
-
-    def load_all: () -> void
-  end
-
-  module RI
-    module Paths
-      type path_type = :system | :site | :home | :gem | :extra
-
-      type gem_filter = :latest | :all
-
-      def self.each: (?bool system, ?bool site, ?bool home, ?gem_filter | false gems, *String extra_dirs) { (String, path_type) -> void } -> void
-    end
-  end
-
-  class Context < CodeObject
-
-  end
-
-  class ClassModule < Context
-    def constants: () -> Array[Constant]
-
-    def method_list: () -> Array[AnyMethod]
-
-    def attributes: () -> Array[Attr]
-  end
-
-  class Markup
-    class Document
-      include Enumerable[Document]
-
-      def each: () { (Document) -> void } -> void
-              | () -> Enumerator[Document, void]
-
-      def file: () -> String?
-
-      def accept: (untyped) -> String
-    end
-
-    class ToMarkdown
-    end
-  end
-end

data/sig/type_name_resolver.rbs

@@ -1,26 +0,0 @@
-module RBS
-  class TypeNameResolver
-    type context = Array[Namespace]
-
-    class Query
-      attr_reader type_name: TypeName
-      attr_reader context: Array[Namespace]
-
-      def initialize: (type_name: TypeName, context: context) -> void
-    end
-
-    attr_reader all_names: Set[TypeName]
-
-    attr_reader cache: Hash[Query, TypeName?]
-
-    def self.from_env: (Environment) -> TypeNameResolver
-
-    def add_names: (Array[TypeName]) -> self
-
-    def resolve: (TypeName, context: context) -> TypeName?
-
-    def has_name?: (TypeName) -> TypeName?
-
-    def try_cache: (Query) { () -> TypeName? } -> TypeName?
-  end
-end

data/stdlib/minitest/0/manifest.yaml

@@ -1,2 +0,0 @@
-dependencies:
-  - name: mutex_m

data/stdlib/prime/0/integer-extension.rbs

@@ -1,41 +0,0 @@
-%a{annotate:rdoc:skip}
-class Integer
-  # <!--
-  #   rdoc-file=lib/prime.rb
-  #   - each_prime(ubound) { |prime| ... }
-  # -->
-  # Iterates the given block over all prime numbers.
-  #
-  # See `Prime`#each for more details.
-  #
-  def self.each_prime: (Integer) { (Integer) -> void } -> void
-
-  # <!--
-  #   rdoc-file=lib/prime.rb
-  #   - from_prime_division(pd)
-  # -->
-  # Re-composes a prime factorization and returns the product.
-  #
-  # See Prime#int_from_prime_division for more details.
-  #
-  def self.from_prime_division: (Array[[ String ]]) -> Integer
-
-  # <!--
-  #   rdoc-file=lib/prime.rb
-  #   - prime_division(generator = Prime::Generator23.new)
-  # -->
-  # Returns the factorization of `self`.
-  #
-  # See Prime#prime_division for more details.
-  #
-  def prime_division: (?Prime::PseudoPrimeGenerator) -> Array[[ Integer, Integer ]]
-
-  # <!--
-  #   rdoc-file=lib/prime.rb
-  #   - prime?()
-  # -->
-  # Returns true if `self` is a prime number, else returns false. Not recommended
-  # for very big integers (> 10**23).
-  #
-  def prime?: () -> bool
-end

data/stdlib/prime/0/manifest.yaml

@@ -1,2 +0,0 @@
-dependencies:
-  - name: singleton