Gecko [ beriskala.com ]

Name	Size	Permission	Date
annotate	[ DIR ]	drwxr-xr-x	2026-05-05 23:07
collection	[ DIR ]	drwxr-xr-x	2026-05-05 23:07
prototype	[ DIR ]	drwxr-xr-x	2026-05-05 23:07
rdoc	[ DIR ]	drwxr-xr-x	2026-05-05 23:07
resolver	[ DIR ]	drwxr-xr-x	2026-05-05 23:07
shims	[ DIR ]	drwxr-xr-x	2026-05-05 23:07
ancestor_builder.rbs	7.36 KB	-rw-r--r--	2026-04-07 17:42
ancestor_graph.rbs	1.27 KB	-rw-r--r--	2026-04-07 17:42
annotation.rbs	556 B	-rw-r--r--	2026-04-07 17:42
buffer.rbs	718 B	-rw-r--r--	2026-04-07 17:42
builtin_names.rbs	847 B	-rw-r--r--	2026-04-07 17:42
cli.rbs	2.15 KB	-rw-r--r--	2026-04-07 17:42
collection.rbs	41 B	-rw-r--r--	2026-04-07 17:42
comment.rbs	495 B	-rw-r--r--	2026-04-07 17:42
constant.rbs	502 B	-rw-r--r--	2026-04-07 17:42
constant_table.rbs	1.1 KB	-rw-r--r--	2026-04-07 17:42
declarations.rbs	6.79 KB	-rw-r--r--	2026-04-07 17:42
definition.rbs	5.06 KB	-rw-r--r--	2026-04-07 17:42
definition_builder.rbs	5.48 KB	-rw-r--r--	2026-04-07 17:42
environment.rbs	4.27 KB	-rw-r--r--	2026-04-07 17:42
environment_loader.rbs	3.83 KB	-rw-r--r--	2026-04-07 17:42
environment_walker.rbs	1.79 KB	-rw-r--r--	2026-04-07 17:42
errors.rbs	8.42 KB	-rw-r--r--	2026-04-07 17:42
factory.rbs	77 B	-rw-r--r--	2026-04-07 17:42
location.rbs	3.3 KB	-rw-r--r--	2026-04-07 17:42
locator.rbs	1.62 KB	-rw-r--r--	2026-04-07 17:42
manifest.yaml	129 B	-rw-r--r--	2026-04-07 17:42
members.rbs	7.05 KB	-rw-r--r--	2026-04-07 17:42
method_builder.rbs	3.17 KB	-rw-r--r--	2026-04-07 17:42
method_types.rbs	1.55 KB	-rw-r--r--	2026-04-07 17:42
namespace.rbs	3.46 KB	-rw-r--r--	2026-04-07 17:42
parser.rbs	2.32 KB	-rw-r--r--	2026-04-07 17:42
rbs.rbs	384 B	-rw-r--r--	2026-04-07 17:42
repository.rbs	2.41 KB	-rw-r--r--	2026-04-07 17:42
shims.rbs	1.34 KB	-rw-r--r--	2026-04-07 17:42
sorter.rbs	499 B	-rw-r--r--	2026-04-07 17:42
substitution.rbs	1.38 KB	-rw-r--r--	2026-04-07 17:42
type_alias_dependency.rbs	585 B	-rw-r--r--	2026-04-07 17:42
type_alias_regularity.rbs	2.89 KB	-rw-r--r--	2026-04-07 17:42
type_name_resolver.rbs	618 B	-rw-r--r--	2026-04-07 17:42
type_param.rbs	2.16 KB	-rw-r--r--	2026-04-07 17:42
typename.rbs	2.11 KB	-rw-r--r--	2026-04-07 17:42
types.rbs	11.57 KB	-rw-r--r--	2026-04-07 17:42
util.rbs	128 B	-rw-r--r--	2026-04-07 17:42
validator.rbs	1.93 KB	-rw-r--r--	2026-04-07 17:42
variance_calculator.rbs	2.56 KB	-rw-r--r--	2026-04-07 17:42
vendorer.rbs	1.44 KB	-rw-r--r--	2026-04-07 17:42
version.rbs	33 B	-rw-r--r--	2026-04-07 17:42
writer.rbs	2.91 KB	-rw-r--r--	2026-04-07 17:42

Rename

module RBS
  # DefinitionBuilder translates TypeName to Definition of the type
  #
  # The translation goes three steps:
  #
  # 1. Calculate _ancestors_ of the type with AncestorBuilder
  # 2. Calculate _partial_ definitions of each ancestor
  # 3. Merge _partial_ definitions
  #
  # A _partial_ definition is a definition of one type name, in terms of it doesn't have methods of super classes nor included modules.
  #
  #
  class DefinitionBuilder
    attr_reader env: Environment
    attr_reader type_name_resolver: TypeNameResolver
    attr_reader ancestor_builder: AncestorBuilder
    attr_reader method_builder: MethodBuilder

def initialize: (env: Environment, ?ancestor_builder: AncestorBuilder?, ?method_builder: MethodBuilder?) -> void

def build_interface: (TypeName) -> Definition

# Returns a Definition of a instance of given type name.
    #
    # If TypeName is a module and `no_self_types` is `true`, it won't have methods of _self type constraints_.
    # This typically happens when definition is being calculated for mixin.
    #
    def build_instance: (TypeName, ?no_self_types: bool) -> Definition

def build_singleton: (TypeName) -> Definition

def validate_super_class!: (TypeName, Environment::ClassEntry) -> void

def ensure_namespace!: (Namespace, location: Location[untyped, untyped]?) -> void

def build_singleton0: (TypeName) -> Definition

def merge_definition: (src: Definition, dest: Definition, subst: Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void

def merge_method: (TypeName, Hash[Symbol, Definition::Method], Symbol, Definition::Method, Substitution, ?implemented_in: :keep | TypeName | nil, ?keep_super: bool) -> void

def merge_variable: (Hash[Symbol, Definition::Variable], Symbol, Definition::Variable, Substitution, ?keep_super: bool) -> void

def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
                 | [A] (TypeName, cache: Hash[A, Definition | false | nil], key: A) { () -> Definition } -> Definition

def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void

def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void

def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?

def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void

# Add methods from `methods` to Definition
    #
    # * `methods`:
    # * `interface_methods`: Methods of interfaces mixed into the type
    # * `self_constraints_methods`: Methods of the self constraints methods
    # * `super_interface_method`: `true` to have super method of existing method (`true` is the Definition is the target module)
    #
    def define_methods: (
      Definition,
      methods: MethodBuilder::Methods,
      interface_methods: Hash[Symbol, Definition::Method],
      methods_with_self: Hash[Symbol, Definition::Method]?,
      super_interface_method: bool
    ) -> void

# Define methods on singleton type
    #
    def define_methods_singleton: (
      Definition,
      methods: MethodBuilder::Methods,
      interface_methods: Hash[Symbol, Definition::Method]
    ) -> void

# Define methods on instance type
    #
    def define_methods_instance: (
      Definition,
      methods: MethodBuilder::Methods,
      interface_methods: Hash[Symbol, Definition::Method]
    ) -> void

# Define methods on module instance type
    #
    # * Pass `nil` to `module_self_methods:` to build a module instance type that will be mixed in to other modules/classes
    # * Pass methods from self-type-constraints to build a module instance type alone (to type check itself)
    #
    def define_methods_module_instance: (
      Definition,
      methods: MethodBuilder::Methods,
      interface_methods: Hash[Symbol, Definition::Method],
      module_self_methods: Hash[Symbol, Definition::Method]?
    ) -> void

# Validates presence of type names recursively.
    # Assumes the type names are already resolved.
    #
    def validate_type_presence: (Types::t) -> void

def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void

# Expand a type alias of given name without type arguments.
    # Raises an error if the type alias requires arguments.
    #
    # Assume `type foo[T] = [T, T]`:
    #
    # ```
    # expand_alias("::foo")   # => error
    # ```
    #
    def expand_alias: (TypeName) -> Types::t

# Expand a type alias of given name with arguments of `untyped`.
    #
    # Assume `type foo[T] = [T, T]`:
    #
    # ```
    # expand_alias1("::foo")   # => [untyped, untyped]
    # ```
    #
    def expand_alias1: (TypeName) -> Types::t

# Expand a type alias of given name with `args`.
    #
    # Assume `type foo[T] = [T, T]`:
    #
    # ```
    # expand_alias2("::foo", ["::Integer"])   # => [::Integer, ::Integer]
    # ```
    #
    def expand_alias2: (TypeName, Array[Types::t] args) -> Types::t

def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
  end
end