class
   Crystal::Macros::TypeNode
  
  
  Overview
Represents a type in the program, like Int32 or String.
Defined in:
compiler/crystal/macros.crInstance Method Summary
- 
        #<(other : TypeNode) : BoolLiteral
        
          Returns trueif other is an ancestor ofself.
- 
        #<=(other : TypeNode) : BoolLiteral
        
          Returns trueifselfis the same as other or if other is an ancestor ofself.
- 
        #>(other : TypeNode) : BoolLiteral
        
          Returns trueifselfis an ancestor of other.
- 
        #>=(other : TypeNode) : BoolLiteral
        
          Returns trueif other is the same asselfor ifselfis an ancestor of other.
- 
        #[](key : SymbolLiteral | MacroId) : TypeNode | NilLiteral
        
          Returns the type for the given key in this named tuple type. 
- 
        #abstract? : BoolLiteral
        
          Returns trueifselfis abstract, otherwisefalse.
- 
        #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 Annotationwith the giventypeattached to this type orNilLiteralif there are none.
- 
        #annotations(type : TypeNode) : ArrayLiteral(Annotation)
        
          Returns an array of annotations with the given typeattached to this type, or an emptyArrayLiteralif there are none.
- 
        #annotations : ArrayLiteral(Annotation)
        
          Returns an array of all annotations attached to this type, or an empty ArrayLiteralif there are none.
- 
        #class : TypeNode
        
          Returns the class of this type. 
- 
        #class? : BoolLiteral
        
          Returns trueifselfis a#class, otherwisefalse.
- 
        #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 trueif this type has a constant.
- 
        #has_inner_pointers? : BoolLiteral
        
          Returns whether selfcontains any inner pointers.
- 
        #has_method?(name : StringLiteral | SymbolLiteral) : BoolLiteral
        
          Returns trueif this type has a method.
- 
        #includers : ArrayLiteral(TypeNode)
        
          Returns all the types selfis directly included in.
- 
        #instance : TypeNode
        
          Returns the instance type of this type, if it's a class type, or selfotherwise.
- 
        #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 trueifselfis amodule, otherwisefalse.
- 
        #name(*, generic_args : BoolLiteral = true) : MacroId
        
          Returns the fully qualified name of this type. 
- 
        #nilable? : BoolLiteral
        
          Returns trueifnilis an instance ofself, otherwisefalse.
- 
        #overrides?(type : TypeNode, method : StringLiteral | SymbolLiteral | MacroId) : Bool
        
          Determines if selfoverrides any method named method from type type.
- 
        #private? : BoolLiteral
        
          Return trueifselfis private andfalseotherwise.
- 
        #public? : BoolLiteral
        
          Return trueifselfis public andfalseotherwise.
- 
        #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 trueifselfis astruct, otherwisefalse.
- 
        #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 trueifselfis a union type, otherwisefalse.
- 
        #union_types : ArrayLiteral(TypeNode)
        
          Returns the types forming a union type, if this is a union type. 
- 
        #visibility : SymbolLiteral
        
          Returns visibility of selfas:publicor: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
Returns true if self is the same as other or if
other is an ancestor of self.
Returns true if other is the same as self or if
self is an ancestor of other.
Returns the type for the given key in this named tuple type. Gives a compile error if this is not a named tuple type.
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?}}  # => trueReturns the last Annotation with the given type
attached to this type or NilLiteral if there are none.
Returns an array of annotations with the given type
attached to this type, or an empty ArrayLiteral if there are none.
Returns an array of all annotations attached to this
type, or an empty ArrayLiteral if there are none.
Returns the class of this type. With this you can, for example, obtain class
methods by invoking type.class.methods.
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?}} # => falseReturns 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.
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).
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).mallocis atomic if and only if- Thas no inner pointers;
- T.allocateis atomic if and only if- Tis 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.
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).
Returns the instance type of this type, if it's a class type,
or self otherwise. This is the opposite of #class.
Returns the instance variables of this type. Can only be called from within methods (not top-level code), otherwise will return an empty list.
Returns the keys in this named tuple type. Gives a compile error if this is not a named tuple type.
Returns the instance methods defined by this type, without including inherited methods.
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?}} # => falseReturns 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)}} # => FooReturns 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?}}                    # => trueDetermines 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") }} # => falseReturns 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.
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.
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.
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?}} # => trueReturns the type variables of the generic type. If the type is not generic, an empty array is returned.
Returns true if self is a union type, otherwise false.
See also: #union_types.
{{String.union?}}              # => false
{{String?.union?}}             # => true
{{Union(String, Bool).union?}} # => trueReturns 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?.