abstract class Crystal::Type

• Crystal::Type
• Reference
• Object

Overview

Abstract base class of all types

Included Modules

• Crystal::Annotatable

Direct Known Subclasses

• Crystal::AutocastType
• Crystal::GenericClassInstanceMetaclassType
• Crystal::GenericInstanceType
• Crystal::GenericModuleInstanceMetaclassType
• Crystal::NamedType
• Crystal::TypeParameter
• Crystal::TypeSplat
• Crystal::UnionType
• Crystal::VirtualMetaclassType
• Crystal::VirtualType

Defined in:

Constant Summary

ONE_ARG = [Arg.new("a1")]

SuggestableDefName = /\A[a-z_]/

Constructors

• .merge!(type1 : Type, type2 : Type) : Type
• .merge!(types_or_nodes) : Type
• .new(program : Program)

Class Method Summary

• .common_descendent(type1 : TupleInstanceType, type2 : TupleInstanceType)
• .common_descendent(type1 : NamedTupleInstanceType, type2 : NamedTupleInstanceType)
• .common_descendent(type1 : ProcInstanceType, type2 : ProcInstanceType)
• .common_descendent(type1 : NonGenericModuleType | GenericModuleInstanceType, type2 : AliasType)
• .common_descendent(type1 : NonGenericModuleType | GenericModuleInstanceType, type2 : UnionType)
• .common_descendent(type1 : NonGenericModuleType | GenericModuleInstanceType, type2 : VirtualType)
• .common_descendent(type1 : NonGenericModuleType | GenericModuleInstanceType, type2 : GenericClassType)
• .common_descendent(type1 : GenericModuleInstanceType, type2 : GenericModuleInstanceType)
• .common_descendent(type1 : GenericModuleInstanceType, type2 : GenericModuleType)
• .common_descendent(type1 : NonGenericModuleType | GenericModuleInstanceType, type2 : Type)
• .common_descendent(type1 : GenericClassInstanceType, type2 : GenericClassType)
• .common_descendent(type1 : GenericClassType, type2 : GenericClassInstanceType)
• .common_descendent(type1 : GenericInstanceType, type2 : GenericInstanceType)
• .common_descendent(type1 : MetaclassType, type2 : VirtualMetaclassType)
• .common_descendent(type1 : VirtualMetaclassType, type2 : MetaclassType)
• .common_descendent(type1 : VirtualMetaclassType, type2 : VirtualMetaclassType)
• .common_descendent(type1 : GenericClassInstanceMetaclassType | GenericModuleInstanceMetaclassType, type2 : MetaclassType | VirtualMetaclassType)
• .common_descendent(type1 : MetaclassType | VirtualMetaclassType, type2 : GenericClassInstanceMetaclassType | GenericModuleInstanceMetaclassType)
• .common_descendent(type1 : UnionType, type2 : Type)
• .common_descendent(type1 : AliasType, type2 : AliasType)
• .common_descendent(type1 : AliasType, type2 : Type)
• .common_descendent(type1 : TypeDefType, type2 : UnionType)
• .common_descendent(type1 : TypeDefType, type2 : AliasType)
• .common_descendent(type1 : TypeDefType, type2 : Type)
• .common_descendent(type1 : VirtualType, type2 : VirtualType)
• .common_descendent(type1 : VirtualType, type2 : AliasType)
• .common_descendent(type1 : VirtualType, type2 : UnionType)
• .common_descendent(type1 : VirtualType, type2 : Type)
• .common_descendent(type1 : NilType, type2 : VoidType)
• .common_descendent(type1 : GenericClassType, type2 : GenericClassType)
• .common_descendent(type1 : Type, type2 : AliasType)
• .common_descendent(type1 : Type, type2 : UnionType)
• .common_descendent(type1 : Type, type2 : VirtualType)
• .common_descendent(type1 : Type, type2 : GenericClassType)
• .common_descendent(type1 : Type, type2 : Type)

  Given two types T and U, returns a common descendent V such that V <= T and V <= U.

• .least_common_ancestor(type1 : MetaclassType | GenericClassInstanceMetaclassType, type2 : MetaclassType | GenericClassInstanceMetaclassType)
• .least_common_ancestor(type1 : NonGenericModuleType | GenericModuleInstanceType | GenericClassType, type2 : NonGenericModuleType | GenericModuleInstanceType | GenericClassType)
• .least_common_ancestor(type1 : GenericClassType, type2 : ClassType | GenericClassInstanceType)
• .least_common_ancestor(type1 : NonGenericModuleType | GenericModuleInstanceType | GenericClassType, type2 : Type)
• .least_common_ancestor(type1 : ClassType | GenericClassInstanceType, type2 : GenericClassType)
• .least_common_ancestor(type1 : Type, type2 : NonGenericModuleType | GenericModuleInstanceType | GenericClassType)
• .least_common_ancestor(type1 : TupleInstanceType, type2 : TupleInstanceType)
• .least_common_ancestor(type1 : NamedTupleInstanceType, type2 : NamedTupleInstanceType)
• .least_common_ancestor(type1 : ClassType | GenericClassInstanceType, type2 : ClassType | GenericClassInstanceType)
• .least_common_ancestor(type1 : Type, type2 : Type)

  Given two non-union types T and U, returns their least common ancestor LCA(T, U) such that the following properties are satisfied:

• .merge(nodes : Enumerable(ASTNode)) : Type | Nil
• .merge(types : Array(Type)) : Type | Nil

Instance Method Summary

• #abstract?

  Returns true if this type is abstract.

• #abstract_leaf?

  Returns true if this type is abstract and it has no concrete subclasses.

• #add_including_type(mod)
• #add_instance_var_initializer(name, value, meta_vars)
• #add_subclass(subclass)
• #all?(&)

  Yields self and returns true if the block returns a truthy value.

• #all_class_vars
• #all_instance_vars
• #all_instance_vars_count
• #all_subclasses

  Returns all subclasses of this type, including subclasses of subclasses recursively.

• #allowed_in_lib?

  Returns true if this type can be used in a lib declaration: in a fun, struct/union member, or typedef.

• #allows_instance_vars?

  Returns true if this type can have instance vars.

• #ancestors
• #append_cover(array)
• #append_to_expand_union_types(types)
• #bool_type?
• #can_be_stored?

  Returns true if this type can be assigned to an instance or class variable, or used in a generic type argument.

• #check_method_missing(signature, call)
• #check_restriction_exception

  Checks whether an exception needs to be raised because of a restriction failure.

• #class?
• #class_var_owner

  Returns the type that owns class vars for a type.

• #class_vars
• #compatible_with?(type)
• #cover
• #cover_size
• #declare_instance_var(name, type : Type, annotations = nil)
• #define_method_from_method_missing(method_missing, signature, original_call)
• #defs : Hash(String, Array(DefWithMetadata)) | Nil

  Returns the methods defined in this type, indexed by their name.

• #depth
• #devirtualize

  Returns the non-virtual type of a given type (returns self if self is already non-virtual)

• #doc : String | Nil

  Returns any doc comments associated to this type.

• #double_variadic?
• #each_cover(&)
• #each_namespace(& : ModuleType -> ) : Nil

  Yields each namespace this type belongs to, excluding the Program itself.

• #extern?

  Returns true if this is an extern C struct or union (#extern_union? tells which one)

• #extern_union?

  Returns true if this is an extern C union (#extern? will be true too)

• #ffi_arg_type : FFI::Type

  Returns an FFI::Type to be used as a C function argument.

• #ffi_type : FFI::Type

  Must return an FFI::Type for this type.

• #filter_by(other_type : Type)
• #filter_by_responds_to(name)
• #generic_nest
• #generic_type
• #get_instance_var_initializer(name)
• #has_def?(name)
• #has_def_without_parents?(name)
• #has_in_type_vars?(type)
• #has_inner_pointers?

  Returns true if the type has inner pointers.

• #has_instance_var_initializer?(name)
• #has_protected_access_to?(type, allow_same_namespace = true)

  Determines if self can access type assuming it's a protected access.

• #implements?(other_type : Type)
• #implicitly_converted_in_c_to?(expected_type)

  Returns true if this type can be implicitly converted to expected_type when this is a lib fun argument, without involving to_unsafe or numeric conversions.

• #includes_type?(type)
• #including_types
• #index_of_instance_var(name)
• #inspect(io : IO) : Nil

  Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

• #instance_type
• #instance_vars
• #leaf?

  Returns true if this type has no subclasses.

• #llvm_name(io)
• #llvm_name
• #locations : Array(Location) | Nil

  Returns all locations where this type is declared

• #lookup_class_var(name)
• #lookup_class_var?(name)
• #lookup_defs(name : String, lookup_ancestors_for_new : Bool = false)
• #lookup_defs(name : String, all_defs : Array(Def), lookup_ancestors_for_new : Bool | Nil = false)
• #lookup_defs_with_modules(name)
• #lookup_defs_without_parents(name : String, all_defs : Array(Def))
• #lookup_defs_without_parents(name : String)
• #lookup_first_def(name, block)
• #lookup_instance_var(name : String)
• #lookup_instance_var(node : InstanceVar | ReadInstanceVar | MetaVar)
• #lookup_instance_var?(name : String)
• #lookup_macro(name, args : Array, named_args)

  Looks up a macro with the given name and matching the given args and named_args.

• #lookup_macros(name)

  Looks up macros with the given name.

• #lookup_matches(signature, owner = self, path_lookup = self, matches_array = nil, analyze_all = false)
• #lookup_matches_with_modules(signature, owner = self, path_lookup = self, matches_array = nil, analyze_all = false)
• #lookup_matches_without_parents(signature, owner = self, path_lookup = self, matches_array = nil, analyze_all = false)
• #lookup_method_missing
• #lookup_name(name)
• #lookup_new_in_ancestors?

  Should .new be looked up in ancestors?

• #lookup_path(path : Path, lookup_in_namespace = true, include_private = false, location = path.location) : Type | ASTNode | Nil

  Looks up a path (for example: Foo::Bar::Baz) relative to self.

• #lookup_path(names : Array(String), lookup_in_namespace = true, include_private = false, location = nil) : Type | ASTNode | Nil

  Looks up a path (for example: Foo::Bar::Baz) relative to self.

• #lookup_path_item(name : String, lookup_self, lookup_in_namespace, include_private, location) : Type | ASTNode | Nil

  Looks up a single path item relative to *self`.

• #lookup_similar_def(name, args_size, block)
• #lookup_similar_def_name(name, args_size, block)
• #lookup_similar_instance_var_name(ivar_name : String)
• #lookup_similar_instance_var_name(name)
• #lookup_similar_path(node : Path)
• #lookup_similar_path(names : Array(String), lookup_in_namespace = true)
• #lookup_type(node : ASTNode, self_type = self.instance_type, allow_typeof = true, free_vars : Hash(String, TypeVar) | Nil = nil, find_root_generic_type_parameters = true) : Type

  Searches the type that corresponds to the given node, relative to self.

• #lookup_type?(node : ASTNode, self_type = self.instance_type, allow_typeof = true, free_vars : Hash(String, TypeVar) | Nil = nil, find_root_generic_type_parameters = true) : Type | Nil

  Similar to #lookup_type, but returns nil if a type can't be found.

• #lookup_type_var(node : Path, free_vars : Hash(String, TypeVar) | Nil = nil, find_root_generic_type_parameters = true, remove_alias = true) : Type | ASTNode

  Similar to #lookup_type, but the result might also be an ASTNode, for example when looking N relative to a StaticArray.

• #lookup_type_var?(node : Path, free_vars : Hash(String, TypeVar) | Nil = nil, raise = false, find_root_generic_type_parameters = true) : Type | ASTNode | Nil

  Similar to #lookup_type_var, but might return nil.

• #macros : Hash(String, Array(Macro)) | Nil

  Returns all macros defines in this type, indexed by their name.

• #metaclass : Type

  Returns this type's metaclass, which holds class methods for this type.

• #metaclass?
• #module?
• #namespace : ModuleType

  The namespace this type belongs to.

• #nil_type?
• #nilable?
• #no_return?
• #opaque_id

  An opaque id of every type.

• #packed?

  Returns true if this type has the @[Packed] annotation on it (only applicable for C structs)

• #parents
• #passed_as_self?

  Returns true if this type is passed as a self argument in the codegen phase.

• #passed_by_value?

  Returns true if this type passed by value (if it's not a primitive type).

• #pointer?
• #pretty_print(pp)
• #private=(set_private)
• #private?
• #proc?
• #program : Crystal::Program

  Returns the program where this type belongs.

• #reference_like?

  Returns true if this type inherits from Reference or if this is a union type where all types are reference types or nil.

• #remove_alias
• #remove_alias_if_simple
• #remove_indirection
• #remove_literal
• #remove_typedef
• #replace_type_parameters(instance) : Type

  Replace type parameters in this type with the type parameters of the given instance type.

• #restrict(other : Nil, context)
• #restrict(other : AliasType, context)
• #restrict(other : UnionType, context)
• #restrict(other : VirtualType, context)
• #restrict(other : GenericClassType, context)
• #restrict(other : Type, context)
• #restrict(other : Self, context)
• #restrict(other : TypeOf, context)
• #restrict(other : Union, context)
• #restrict(other : Path, context)
• #restrict(other : Generic, context)
• #restrict(other : Metaclass, context)
• #restrict(other : ProcNotation, context)
• #restrict(other : Underscore, context)
• #restrict(other : Arg, context)
• #restrict(other : NumberLiteral, context)
• #restrict(other : Splat, context)
• #restrict(other : ASTNode, context)
• #restriction_of?(other : UnionType, owner, self_free_vars = nil, other_free_vars = nil)
• #restriction_of?(other : VirtualType, owner, self_free_vars = nil, other_free_vars = nil)
• #restriction_of?(other : AliasType, owner, self_free_vars = nil, other_free_vars = nil)
• #restriction_of?(other : Type, owner, self_free_vars = nil, other_free_vars = nil)
• #restriction_of?(other : ASTNode, owner, self_free_vars = nil, other_free_vars = nil)
• #same_namespace?(other)

  Returns true if self and other are in the same namespace.

• #sizeof_type

  Returns the type that has to be used in sizeof and instance_sizeof computations

• #splat_index
• #struct?

  Returns true if this type is a struct.

• #subclasses : Array(Type)

  Returns direct subclasses of this type.

• #superclass : Type | Nil

  Returns this type's superclass, or nil if it doesn't have one

• #to_s(io : IO) : Nil

  Appends a short String representation of this object which includes its class name and its object address.

• #to_s(*, generic_args : Bool = true)
• #to_s_with_options(io : IO, skip_union_parens : Bool = false, generic_args : Bool = true, codegen : Bool = false) : Nil
• #type_desc
• #type_var?(name)

  Returns true if name if an unbound type variable in this (generic) type.

• #type_vars
• #types
• #types?
• #unbound?
• #virtual?
• #virtual_metaclass?
• #virtual_type
• #virtual_type!
• #void?

Constructor Detail

Class Method Detail

typeof(begin
  x = uninitialized T
  x.is_a?(U) ? x : raise ""
end)

Instance Method Detail

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

class Foo
  class Bar
    class Baz
    end
  end
end

class Foo
  class Bar
    class Baz
    end
  end
end

class Foo
  class Bar(T)
  end

  class Baz
  end
end

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>