class Crystal::Program

• Crystal::Program
• Crystal::NonGenericModuleType
• Crystal::ModuleType
• Crystal::NamedType
• Crystal::Type
• Reference
• Object

Overview

A program contains all types and top-level methods related to one compilation of a program.

It also carries around all information needed to compile a bunch of files: the unions, the symbols used, all global variables, all required files, etc. Because of this, a Program is usually passed around in every step of a compilation to record and query this information.

In a way, a Program is an alternative implementation to having global variables for all of this data, but modeled this way one can easily test and exercise programs because each one has its own definition of the types created, methods instantiated, etc.

Additionally, a Program acts as a regular type (a module) that can have types (the top-level types) and methods (the top-level methods), and which can also include other modules (this happens when you do include Module at the top-level).

Included Modules

• Crystal::DefInstanceContainer

Defined in:

Constant Summary

PKG_CONFIG_PATH = Process.find_executable("pkg-config")

Constructors

• .new

Class Method Summary

• .flag_value(flags, name)

Instance Method Summary

• #add_def(node : Def)
• #add_finished_hook(scope, a_macro, node)
• #add_macro(node : Macro)
• #add_type(types, type : UnionType)
• #add_type(types, type : AliasType)
• #add_type(types, type : VoidType)

  When Void participates in a union, it becomes Nil (users shouldn't deal with real Void values)

• #add_type(types, type : Type)
• #add_type(set, type : Nil)
• #after_inference_types : Set(Crystal::Type)

  Types that have instance vars initializers which need to be visited (transformed) by CleanupTransformer once the semantic analysis finishes.

• #align_of(type)
• #always_inline_annotation
• #argc : Const

  The constant for ARGC_UNSAFE

• #argc? : Const | Nil

  The constant for ARGC_UNSAFE

• #argv : Const

  The constant for ARGV_UNSAFE

• #argv? : Const | Nil

  The constant for ARGV_UNSAFE

• #array
• #array_of(type)

  Returns the Type for Array(type)

• #ast_node
• #bits64?
• #bool
• #call_convention_annotation
• #char
• #check_call_to_deprecated_annotation(node : AnnotationDef) : Nil
• #check_call_to_deprecated_macro(a_macro : Macro, call : Call)
• #check_call_to_deprecated_method(node : Call)
• #check_deprecated_constant(const : Const, node : Path)
• #check_deprecated_type(type : Type, node : Path)
• #check_private(node)
• #class_type

  Returns the Class type

• #class_var_initializers : Array(Crystal::ClassVarInitializer)

  The class var initializers stored to be used by the cleanup transformer

• #cleanup(node, inside_def = false)
• #cleanup_files
• #cleanup_single_type(type, transformer)
• #cleanup_transformer : CleanupTransformer
• #cleanup_type(type, transformer)
• #cleanup_types
• #codegen(node, single_module = false, debug = Debug::Default, frame_pointers = FramePointers::Auto)
• #codegen_target : Crystal::Codegen::Target
• #codegen_target=(codegen_target : Codegen::Target) : Codegen::Target
• #color=(color : Bool)

  If true, error messages can be colorized

• #color? : Bool

  If true, error messages can be colorized

• #colorize(obj)

  Colorizes the given object, depending on whether this program is configured to use colors.

• #combined_union_of(types : Array)
• #compact_types(types) : Array(Type)
• #compact_types(objects, &) : Array(Type)
• #compiled_macros_cache : Hash(String, Crystal::Program::CompiledMacroRun)
• #compiled_macros_cache=(compiled_macros_cache : Hash(String, Crystal::Program::CompiledMacroRun))
• #compiler : Compiler | Nil
• #compiler=(compiler : Compiler | Nil)
• #const_initializers : Array(Crystal::Const)

  Here we store constants, in the order that they are used.

• #const_slices : Hash(String, Crystal::Program::ConstSliceInfo)

  All constant slices constructed via the Slice.literal compiler built-in, indexed by their buffers' internal names (e.g.

• #crystal
• #crystal_path

  Returns a CrystalPath for this program.

• #define_default_new(type)
• #define_default_new_single(type)
• #define_new_methods(new_expansions)
• #deprecated_annotation
• #each_dll_path(& : String, Bool -> )

  Searches among CRYSTAL_LIBRARY_PATH, the compiler's directory, and PATH for every DLL specified in the used @[Link] annotations.

• #enum
• #enumerable
• #evaluate(node, return_type : T.class, debug = Debug::Default) : T forall T
• #evaluate(node, debug = Debug::Default)
• #exception
• #expand_macro(a_macro : Macro, call : Call, scope : Type, path_lookup : Type | Nil = nil, a_def : Def | Nil = nil)
• #expand_macro(node : ASTNode, scope : Type, path_lookup : Type | Nil = nil, free_vars = nil, a_def : Def | Nil = nil)
• #experimental_annotation
• #extern_annotation
• #file_module(filename)
• #file_module?(filename)
• #file_modules : Hash(String, Crystal::FileModule)

  All FileModules indexed by their filename.

• #filename : String | Nil

  The main filename of this program

• #filename=(filename : String | Nil)

  The main filename of this program

• #find_in_path(filename, relative_to = nil) : Array(String) | Nil

  Finds filename in the configured CRYSTAL_PATH for this program, relative to relative_to.

• #finished_hooks : Array(Crystal::Program::FinishedHook)
• #flag_value(name : String) : String | Bool

  Returns the value of a flag in the format "#{key}=#{value}".

• #flags

  Returns the flags for this program.

• #flags_annotation
• #float
• #float32
• #float64
• #has_flag?(name : String)

  Returns true if name is in the program's flags.

• #hash_of(key_type, value_type)

  Returns the Type for Hash(key_type, value_type)

• #hash_type

  Returns the Hash type

• #host_compiler

  Creates a compiler instance with the host as target used for macro_run compilation.

• #host_flag_value(name : String) : String | Bool

  Returns the value of a host flag in the format "#{key}=#{value}".

• #host_flags
• #indexable
• #instance_align_of(type)
• #instance_offset_of(type, element_index)
• #instance_size_of(type)
• #int
• #int128
• #int16
• #int32
• #int64
• #int8
• #int?(int)

  Returns the IntegerType that matches the given Int value

• #int_type(signed, size)
• #interpreted_node_hook : Proc(ASTNode, Bool, Bool, Location | Nil, Nil) | Nil
• #interpreted_node_hook=(interpreted_node_hook : Proc(ASTNode, Bool, Bool, Location | Nil, Nil) | Nil)
• #lib_flags(cross_compiling : Bool = false)
• #link_annotation
• #link_annotations

  Returns every @[Link] annotation in the program parsed as LinkAnnotation

• #literal_expander

  Returns a LiteralExpander useful to expand literal like arrays and hashes into simpler forms.

• #llvm_id
• #llvm_typer
• #lookup_macro_type(name : Path)

  Returns the macro type named by a given AST node in the macro language.

• #lookup_macro_type(name : Union)
• #lookup_macro_type(name : ASTNode)
• #lookup_path_item(name : String, lookup_self, lookup_in_namespace, include_private, location)

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

• #lookup_private_matches(filename, signature, analyze_all = false)
• #macro_compile(filename)
• #macro_expanded_hook : Proc(Nil) | Nil
• #macro_expanded_hook=(macro_expanded_hook : Proc(Nil) | Nil)
• #macro_expander

  Returns a MacroExpander to expand macro code into crystal code.

• #macro_expansion_error_hook : Proc(Exception | Nil, Nil) | Nil
• #macro_expansion_error_hook=(macro_expansion_error_hook : Proc(Exception | Nil, Nil) | Nil)
• #macro_no_return
• #macro_run(filename, args)
• #metaclass

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

• #msvc_compiler_and_flags : Tuple(String, Array(String))

  Detects the current MSVC linker and the relevant linker flags that recreate the MSVC developer prompt's standard library paths.

• #naked_annotation
• #named_tuple
• #named_tuple_of(entries : Hash(String, Type) | NamedTuple)

  Returns the Type for NamedTuple(**entries)

• #named_tuple_of(entries : Array(NamedArgumentType))

  Returns the Type for NamedTuple(**entries)

• #new_parser(source : String, var_scopes = [Set(String).new])

  Returns a new Parser for the given source, sharing the string pool and warnings with this program.

• #new_temp_var(node : ASTNode) : Var
• #new_temp_var(prefix : String | Nil = nil) : Var
• #new_temp_var_name(node : ASTNode) : String

  Returns a unique variable name associated with the given AST node.

• #new_temp_var_name(prefix : String | Nil = nil) : String

  Returns a unique variable name associated with the given prefix.

• #nil
• #nil_type

  Returns the Nil type

• #nil_var

  Returns a Var that has Nil as a type.

• #nilable(type)

  Returns the Type for type | Nil

• #no_inline_annotation
• #no_return
• #node_macro_type(node : ASTNode) : MacroType

  Returns the macro type for a given AST node.

• #normalize(node, inside_exp = false, current_def = nil)
• #number
• #object
• #offset_of(type, element_index)
• #optimization_mode : Crystal::Compiler::OptimizationMode
• #optimization_mode=(optimization_mode : Crystal::Compiler::OptimizationMode)
• #packed_annotation
• #parse_macro_source(generated_source, macro_expansion_pragmas, the_macro, node, vars, current_def = nil, inside_type = false, inside_exp = false, mode : Parser::ParseMode = :normal, visibility : Visibility = :public)
• #parse_macro_source(generated_source, macro_expansion_pragmas, the_macro, node, vars, current_def = nil, inside_type = false, inside_exp = false, visibility : Visibility = :public, &)
• #pointer
• #pointer_of(type)

  Returns the Type for Pointer(type)

• #predefined_constants : Array(Crystal::Const)
• #primitive_annotation
• #proc
• #proc_of(nodes : Array(ASTNode), return_type : Type)

  Returns the Type for Proc(*nodes.map(&.type), return_type)

• #proc_of(types : Array)

  Returns the Type for Proc(*types)

• #process_finished_hooks(visitor)

  Visits all finished hooks with the given visitor

• #progress_tracker : Crystal::ProgressTracker

  A ProgressTracker object which tracks compilation progress.

• #progress_tracker=(progress_tracker : Crystal::ProgressTracker)

  A ProgressTracker object which tracks compilation progress.

• #raises_annotation
• #range
• #range_of(begin_type, end_type)

  Returns the Type for Range(begin_type, end_type)

• #record_require(filename, relative_to) : Nil

  Remembers that the program depends on this require.

• #recorded_requires : Array(Crystal::Program::RecordedRequire)
• #recorded_requires=(recorded_requires : Array(Crystal::Program::RecordedRequire))
• #reference
• #regex
• #requires : Set(String)

  All required files.

• #returns_twice_annotation
• #run(code, filename : String | Nil = nil, debug = Debug::Default)
• #run(code, return_type : T.class, filename : String | Nil = nil, debug = Debug::Default) forall T
• #run_requires(node : Require, filenames, &) : Nil
• #semantic(node : ASTNode, cleanup = true, main_visitor : MainVisitor = MainVisitor.new(self)) : ASTNode

  Runs semantic analysis on the given node, returning a node that's typed.

• #show_error_trace=(show_error_trace : Bool)

  Whether to show error trace

• #show_error_trace? : Bool

  Whether to show error trace

• #size_bit_width
• #size_of(type)
• #slice
• #splat_expansions : Hash(Def, Array(Type))

  Hash that prevents recursive splat expansions.

• #static_array
• #static_array_of(type, size)

  Returns the Type for StaticArray(type, size)

• #stdout : IO

  Default standard output to use in a program, while compiling.

• #stdout=(stdout : IO)

  Default standard output to use in a program, while compiling.

• #string
• #string_pool : StringPool

  A String pool to avoid creating the same strings over and over.

• #struct

  Returns the Struct type

• #symbol
• #symbols : Set(String)

  All symbols (:foo, :bar) found in the program

• #target_feature_annotation
• #target_machine : LLVM::TargetMachine
• #target_machine=(target_machine : LLVM::TargetMachine)
• #tempfiles : Array(String)

  Temporary files which are generated by macro runs that need to be deleted after the compilation is finished.

• #thread_local_annotation
• #to_s(io : IO) : Nil

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

• #top_level_semantic(node, main_visitor : MainVisitor = MainVisitor.new(self))

  Processes type declarations and instance/class/global vars types are guessed or followed according to type annotations.

• #top_level_semantic_complete=(top_level_semantic_complete : Bool)

  This property indicates that the compiler has finished the top-level semantic stage.

• #top_level_semantic_complete? : Bool

  This property indicates that the compiler has finished the top-level semantic stage.

• #tuple
• #tuple_of(types)

  Returns the Type for Tuple(*types)

• #type_combine(types)
• #type_desc
• #type_from_literal_kind(kind : NumberKind)
• #type_merge(first : Type | Nil, second : Type | Nil) : Type | Nil
• #type_merge(types : Array(Type | Nil)) : Type | Nil
• #type_merge(nodes : Enumerable(ASTNode)) : Type | Nil
• #type_merge_union_of(types : Array(Type)) : Type | Nil
• #uint128
• #uint16
• #uint32
• #uint64
• #uint8
• #undefined_class_variable(node, owner, similar_name)
• #undefined_instance_variable(node, owner, similar_name)
• #undefined_variable_message(kind, example_name, owner)
• #union
• #union_of(type1, type2)

  Returns the Type for type1 | type2

• #union_of(types : Array)

  Returns the Type for Union(*types)

• #unions : Hash(Array(UInt64), Crystal::UnionType)

  All created unions in a program, indexed by an array of opaque ids of each type in the union.

• #value
• #vars : Hash(String, Crystal::MetaVar)

  Top-level variables found in a program (only in the main file).

• #virtual_root?(type : VirtualType | VirtualMetaclassType)
• #virtual_root?(type : MetaclassType | GenericClassInstanceMetaclassType | GenericModuleInstanceMetaclassType)
• #virtual_root?(type)

  Returns true if type can be used as a virtual root; that is, it must not be one of Object, Reference, Value, Struct, Number, Int, Float, or their corresponding metaclasses.

• #visit_class_vars_initializers(node)
• #visit_main(node, visitor : MainVisitor = MainVisitor.new(self), process_finished_hooks = false, cleanup = true)
• #visit_with_finished_hooks(node, visitor)
• #void
• #wants_doc=(wants_doc : Bool)

  If true, doc comments are attached to types and methods.

• #wants_doc? : Bool

  If true, doc comments are attached to types and methods.

• #warnings : Crystal::WarningCollection

  Warning settings and all detected warnings.

• #warnings=(warnings : Crystal::WarningCollection)

  Warning settings and all detected warnings.

Constructor Detail

Class Method Detail

Instance Method Detail

def foo(*x)
  foo(x)
end

foo(1)

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

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