%PDF-
%PDF-
Mini Shell
Mini Shell
module RBS
class Environment
type module_decl = AST::Declarations::Class | AST::Declarations::Module
interface _ModuleOrClass
def name: () -> TypeName
def type_params: () -> Array[AST::TypeParam]
end
interface _NamedDecl
def name: () -> TypeName
end
module ContextUtil
def calculate_context: (Array[_NamedDecl]) -> Array[Namespace]
end
class MultiEntry[M < _ModuleOrClass]
class D[M < _ModuleOrClass]
attr_reader decl: M
attr_reader outer: Array[module_decl]
def initialize: (decl: M, outer: Array[module_decl]) -> void
include ContextUtil
@context: Array[Namespace]
def context: () -> Array[Namespace]
end
attr_reader name: TypeName
attr_reader decls: Array[D[M]]
@primary: D[M]?
def initialize: (name: TypeName) -> void
def insert: (decl: M, outer: Array[module_decl]) -> void
def validate_type_params: () -> void
def compatible_params?: (Array[AST::TypeParam], Array[AST::TypeParam]) -> boolish
def type_params: () -> Array[AST::TypeParam]
def primary: () -> D[M]
end
class ModuleEntry < MultiEntry[AST::Declarations::Module]
def self_types: () -> Array[AST::Declarations::Module::Self]
end
class ClassEntry < MultiEntry[AST::Declarations::Class]
end
class SingleEntry[N, D]
attr_reader name: N
attr_reader decl: D
attr_reader outer: Array[module_decl]
def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
include ContextUtil
@context: Array[Namespace]
def context: () -> Array[Namespace]
end
# Top level declarations.
attr_reader declarations: Array[AST::Declarations::t]
attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
attr_reader interface_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Interface]]
attr_reader alias_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Alias]]
attr_reader constant_decls: Hash[TypeName, SingleEntry[TypeName, AST::Declarations::Constant]]
attr_reader global_decls: Hash[Symbol, SingleEntry[Symbol, AST::Declarations::Global]]
def initialize: () -> void
def initialize_copy: (Environment) -> void
def self.from_loader: (EnvironmentLoader) -> Environment
def cache_name: [N, D] (Hash[N, SingleEntry[N, D]] cache, name: N, decl: D, outer: Array[module_decl]) -> SingleEntry[N, D]
def insert_decl: (AST::Declarations::t, outer: Array[module_decl], namespace: Namespace) -> void
# Insert a toplevel declaration into the env.
#
def <<: (AST::Declarations::t decl) -> self
# Runs generics type params validation over each class definitions.
def validate_type_params: () -> void
# Resolve all type names in the environment to absolute type names.
# Relative type name will be left if absolute type name cannot be found.
#
# When `only` is given, it skips other _top-level_ declarations not included in the collection.
# This helps running resolution faster in the case of _partial updates_.
#
def resolve_type_names: (?only: Set[AST::Declarations::t]?) -> Environment
def resolve_declaration: (TypeNameResolver resolver, AST::Declarations::t decl, outer: Array[module_decl], prefix: Namespace) -> AST::Declarations::t
def resolve_member: (TypeNameResolver, AST::Members::t, context: Array[Namespace]) -> AST::Members::t
def resolve_method_type: (TypeNameResolver, RBS::MethodType, context: Array[Namespace]) -> RBS::MethodType
def resolve_type_params: (TypeNameResolver resolver, Array[AST::TypeParam], context: Array[Namespace]) -> Array[AST::TypeParam]
def absolute_type: (TypeNameResolver, Types::t, context: Array[Namespace]) -> Types::t
def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName
def inspect: () -> String
@buffers: Array[Buffer]
def buffers: () -> Array[Buffer]
def buffers_decls: () -> Hash[Buffer, Array[AST::Declarations::t]]
# Construct new environment without declarations tested `true` by block.
# Construction of new environment is done with `<<` so that nested declarations will work well.
#
def reject: () { (AST::Declarations::t) -> boolish } -> Environment
end
end
Zerion Mini Shell 1.0