class Crystal::Macros::TypeNode

Overview

Represents a type in the program, like Int32 or String.

Defined in:

compiler/crystal/macros.cr

Instance Method Summary

Instance methods inherited from class Crystal::Macros::ASTNode

!=(other : ASTNode) : BoolLiteral !=, ==(other : ASTNode) : BoolLiteral ==, class_name : StringLiteral class_name, column_number : StringLiteral | NilLiteral column_number, doc : StringLiteral doc, doc_comment : MacroId doc_comment, end_column_number : StringLiteral | NilLiteral end_column_number, end_line_number : StringLiteral | NilLiteral end_line_number, filename : StringLiteral | NilLiteral filename, id : MacroId id, is_a?(type : TypeNode) : BoolLiteral is_a?, line_number : StringLiteral | NilLiteral line_number, nil? : BoolLiteral nil?, raise(message) : NoReturn raise, stringify : StringLiteral stringify, symbolize : SymbolLiteral symbolize, warning(message : StringLiteral) : NilLiteral warning

Instance Method Detail

def <(other : TypeNode) : BoolLiteral #

Returns true if other is an ancestor of self.


def <=(other : TypeNode) : BoolLiteral #

Returns true if self is the same as other or if other is an ancestor of self.


def >(other : TypeNode) : BoolLiteral #

Returns true if self is an ancestor of other.


def >=(other : TypeNode) : BoolLiteral #

Returns true if other is the same as self or if self is an ancestor of other.


def [](key : SymbolLiteral | MacroId) : TypeNode | NilLiteral #

Returns the type for the given key in this named tuple type. Gives a compile error if this is not a named tuple type.


def abstract? : BoolLiteral #

Returns true if self is abstract, otherwise false.

module One; end

abstract struct Two; end

class Three; end

abstract class Four; end

{{One.abstract?}}   # => false
{{Two.abstract?}}   # => true
{{Three.abstract?}} # => false
{{Four.abstract?}}  # => true

def all_subclasses : ArrayLiteral(TypeNode) #

Returns all subclasses of this type.


def ancestors : ArrayLiteral(TypeNode) #

Returns all ancestors of this type.


def annotation(type : TypeNode) : Annotation | NilLiteral #

Returns the last Annotation with the given type attached to this type or NilLiteral if there are none.


def annotations(type : TypeNode) : ArrayLiteral(Annotation) #

Returns an array of annotations with the given type attached to this type, or an empty ArrayLiteral if there are none.


def annotations : ArrayLiteral(Annotation) #

Returns an array of all annotations attached to this type, or an empty ArrayLiteral if there are none.


def class : TypeNode #

Returns the class of this type. With this you can, for example, obtain class methods by invoking type.class.methods.


def class? : BoolLiteral #

Returns true if self is a #class, otherwise false.

module One; end

class Two; end

struct Three; end

{{One.class?}}   # => false
{{Two.class?}}   # => true
{{Three.class?}} # => false

def class_vars : ArrayLiteral(MetaVar) #

Returns the class variables of this type.


def constant(name : StringLiteral | SymbolLiteral | MacroId) : ASTNode #

Returns a constant defined in this type.

If the constant is a constant (like A = 1), then its value as an ASTNode is returned. If the constant is a type, the type is returned as a TypeNode. Otherwise, NilLiteral is returned.


def constants : ArrayLiteral(MacroId) #

Returns the constants and types defined by this type.


def has_constant?(name : StringLiteral | SymbolLiteral) : BoolLiteral #

Returns true if this type has a constant. For example DEFAULT_OPTIONS (the name you pass to this method is "DEFAULT_OPTIONS" or :DEFAULT_OPTIONS in this cases).


def has_inner_pointers? : BoolLiteral #

Returns whether self contains any inner pointers.

Primitive types, except Void, are expected to not contain inner pointers. Proc and Pointer contain inner pointers. Unions, structs and collection types (tuples, static arrays) have inner pointers if any of their contained types has inner pointers. All other types, including classes, are expected to contain inner pointers.

Types that do not have inner pointers may opt to use atomic allocations, i.e. GC.malloc_atomic rather than GC.malloc. The compiler ensures that, for any type T:

  • Pointer(T).malloc is atomic if and only if T has no inner pointers;
  • T.allocate is atomic if and only if T is a reference type and ReferenceStorage(T) has no inner pointers.

NOTE Like #instance_vars this method must be called from within a method. The result may be incorrect when used in top-level code.


def has_method?(name : StringLiteral | SymbolLiteral) : BoolLiteral #

Returns true if this type has a method. For example default_options (the name you pass to this method is "default_options" or :default_options in this cases).


def includers : ArrayLiteral(TypeNode) #

Returns all the types self is directly included in.


def instance : TypeNode #

Returns the instance type of this type, if it's a class type, or self otherwise. This is the opposite of #class.


def instance_vars : ArrayLiteral(MetaVar) #

Returns the instance variables of this type. Can only be called from within methods (not top-level code), otherwise will return an empty list.


def keys : ArrayLiteral(MacroId) #

Returns the keys in this named tuple type. Gives a compile error if this is not a named tuple type.


def methods : ArrayLiteral(Def) #

Returns the instance methods defined by this type, without including inherited methods.


def module? : BoolLiteral #

Returns true if self is a module, otherwise false.

module One; end

class Two; end

struct Three; end

{{One.module?}}   # => true
{{Two.module?}}   # => false
{{Three.module?}} # => false

def name(*, generic_args : BoolLiteral = true) : MacroId #

Returns the fully qualified name of this type. Optionally without generic_args if self is a generic type; see #type_vars.

class Foo(T); end

module Bar::Baz; end

{{Bar::Baz.name}}                 # => Bar::Baz
{{Foo.name}}                      # => Foo(T)
{{Foo.name(generic_args: false)}} # => Foo

def nilable? : BoolLiteral #

Returns true if nil is an instance of self, otherwise false.

{{String.nilable?}}                   # => false
{{String?.nilable?}}                  # => true
{{Union(String, Bool, Nil).nilable?}} # => true
{{NoReturn.nilable?}}                 # => false
{{Value.nilable?}}                    # => true

def overrides?(type : TypeNode, method : StringLiteral | SymbolLiteral | MacroId) : Bool #

Determines if self overrides any method named method from type type.

class Foo
  def one
    1
  end

  def two
    2
  end
end

class Bar < Foo
  def one
    11
  end
end

{{ Bar.overrides?(Foo, "one") }} # => true
{{ Bar.overrides?(Foo, "two") }} # => false

def private? : BoolLiteral #

Return true if self is private and false otherwise.


def public? : BoolLiteral #

Return true if self is public and false otherwise.


def resolve : TypeNode #

Returns self. This method exists so you can safely call #resolve on a node and resolve it to a type, even if it's a type already.


def resolve? : TypeNode #

Returns self. This method exists so you can safely call #resolve on a node and resolve it to a type, even if it's a type already.


def size : NumberLiteral #

Returns the number of elements in this tuple type or tuple metaclass type. Gives a compile error if this is not one of those types.


def struct? : BoolLiteral #

Returns true if self is a struct, otherwise false.

module One; end

class Two; end

struct Three; end

{{One.struct?}}   # => false
{{Two.struct?}}   # => false
{{Three.struct?}} # => true

def subclasses : ArrayLiteral(TypeNode) #

Returns the direct subclasses of this type.


def superclass : TypeNode | NilLiteral #

Returns the direct superclass of this type.


def type_vars : ArrayLiteral(TypeNode) #

Returns the type variables of the generic type. If the type is not generic, an empty array is returned.


def union? : BoolLiteral #

Returns true if self is a union type, otherwise false.

See also: #union_types.

{{String.union?}}              # => false
{{String?.union?}}             # => true
{{Union(String, Bool).union?}} # => true

def union_types : ArrayLiteral(TypeNode) #

Returns the types forming a union type, if this is a union type. Otherwise returns this single type inside an array literal (so you can safely call #union_types on any type and treat all types uniformly).

See also: #union?.


def visibility : SymbolLiteral #

Returns visibility of self as :public or :private?