Built-in annotations

    Tells the compiler how to link a C library. This is explained in the lib section.

    Extern

    Marking a Crystal struct with this annotation makes it possible to use it in lib declarations:

    You can also make a struct behave like a C union (this can be pretty unsafe):

    2. @[Extern(union: true)]
    3.   property int = 0
    4.   property char = '\0'
    5. end
    7. s = Int32OrChar.new
    9. s.int # => 65
    11. s.int = 66
    12. s.char # => 'B'

    ThreadLocal

    The @[ThreadLocal] annotation can be applied to class variables and C external variables. It makes them be thread local.

    Marks a as packed, which prevents the automatic insertion of padding bytes between fields. This is typically only needed if the C library explicitly uses packed structs.

    AlwaysInline

    Gives a hint to the compiler to always inline a method:

    1. @[AlwaysInline]
    2. def foo
    3. end

    NoInline

    Tells the compiler to never inline a method call. This has no effect if the method yields, since functions which yield are always inlined.

    Marks a method or lib fun as returning twice. The C setjmp is an example of such a function.

    Raises

    CallConvention

    Indicates the call convention of a . For example:

    1. lib LibFoo
    2.   @[CallConvention("X86_StdCall")]
    3.   fun foo : Int32
    4. end

    The list of valid call conventions is:

    • C (the default)
    • Fast
    • Cold
    • WebKit_JS
    • AnyReg
    • X86_StdCall
    • X86_FastCall

    They are explained here.

    Marks an as a “flags enum”, which changes the behaviour of some of its methods, like to_s.