# class Crystal::Macros::TypeNode

- Crystal::Macros::TypeNode
- Crystal::Macros::ASTNode

##
Overview

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

##
Defined in:

compiler/crystal/macros.cr

##
Instance Method Summary

- #<(other : TypeNode) : BoolLiteral

  Returns `true` if other is an ancestor of `self`.

- #<=(other : TypeNode) : BoolLiteral

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

- #>(other : TypeNode) : BoolLiteral

  Returns `true` if `self` is an ancestor of other.

- #>=(other : TypeNode) : BoolLiteral

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

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

  Returns the type for the given key in this named tuple type.

- #abstract? : BoolLiteral

  Returns `true` if `self` is abstract, otherwise `false`.

- #all_subclasses : ArrayLiteral(TypeNode)

  Returns all subclasses of this type.

- #ancestors : ArrayLiteral(TypeNode)

  Returns all ancestors of this type.

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

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

- #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.

- #annotations : ArrayLiteral(Annotation)

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

- #class : TypeNode

  Returns the class of this type.

- #class? : BoolLiteral

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

- #class_vars : ArrayLiteral(MetaVar)

  Returns the class variables of this type.

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

  Returns a constant defined in this type.

- #constants : ArrayLiteral(MacroId)

  Returns the constants and types defined by this type.

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

  Returns `true` if this type has a constant.

- #has_inner_pointers? : BoolLiteral

  Returns whether `self` contains any inner pointers.

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

  Returns `true` if this type has a method.

- #includers : ArrayLiteral(TypeNode)

  Returns all the types `self` is directly included in.

- #instance : TypeNode

  Returns the instance type of this type, if it's a class type, or `self` otherwise.

- #instance_vars : ArrayLiteral(MetaVar)

  Returns the instance variables of this type.

- #keys : ArrayLiteral(MacroId)

  Returns the keys in this named tuple type.

- #methods : ArrayLiteral(Def)

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

- #module? : BoolLiteral

  Returns `true` if `self` is a `module`, otherwise `false`.

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

  Returns the fully qualified name of this type.

- #nilable? : BoolLiteral

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

- #overrides?(type : TypeNode, method : StringLiteral | SymbolLiteral | MacroId) : BoolLiteral

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

- #private? : BoolLiteral

  Return `true` if `self` is private and `false` otherwise.

- #public? : BoolLiteral

  Return `true` if `self` is public and `false` otherwise.

- #resolve : TypeNode

  Returns `self`.

- #resolve? : TypeNode

  Returns `self`.

- #size : NumberLiteral

  Returns the number of elements in this tuple type or tuple metaclass type.

- #struct? : BoolLiteral

  Returns `true` if `self` is a `struct`, otherwise `false`.

- #subclasses : ArrayLiteral(TypeNode)

  Returns the direct subclasses of this type.

- #superclass : TypeNode | NilLiteral

  Returns the direct superclass of this type.

- #type_vars : ArrayLiteral(TypeNode)

  Returns the type variables of the generic type.

- #union? : BoolLiteral

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

- #union_types : ArrayLiteral(TypeNode)

  Returns the types forming a union type, if this is a union type.

- #visibility : SymbolLiteral

  Returns visibility of `self` as `:public` or `:private?`

### 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) : BoolLiteral #

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?`