Another new feature in C2 are the struct-functions.

The struct-functions are a syntatic-sugar feature that makes code more readable.

The example below shows how it works:

type Point struct {
    i32 x;
    i32 y;
}

func void Point.add(Point* p, i32 x) {
    p.x = x;
}

func void example() {
    Point p = { 1, 2 }

    // with struct-functions
    p.add(10);

    // without struct-functions (if defined as non struct-function)
    /// point_add(&p, 10);
}

rules

• struct-functions only work on struct/union types
• struct-functions are defined in the same module as the struct (not necessary the same file!)
• for a type type named Foo, struct functions must start with Foo. prefix.
• there cannot be a regular member x and a struct function foo.x.
• a static struct-function is called on the type itself: Foo.myfunc(); It's not allowed to call this on a variable
• a static struct-function has no argument requirements and can only be called on the type: Foo.add(). f.add() is not allowed.
• a (non-static) struct-function is required to have 'Type*' or 'const Type*' as the first argument
• struct-function can also be assigned to variables of type Function with the correct proto-type: callback = Foo.add;
• sub-structs cannot have struct functions

Extra notes:

• it's possible to have public or non-public struct-functions for a public struct.
• a struct-function itself is a regular function and can also be used as such
• it's also possible to use a struct-function call if the variable of struct type is a member of another struct

type Outer struct {
    Inner inner;
}

type Inner struct {
    // ...
}

func void Inner.modify(Inner* inner, /* ... */) {
    // ...
}

func void example() {
    Outer outer;
    outer.inner.modify(/* ... */);
    // translates to Inner.modify(&outer.inner);
}

• the following is ok, since a struct-function is not a real dereference

    Type* t = nil;
    t.init();

for more examples, see the tests in c2compiler/test/Functions/struct_functions/

bigger example

Or another example, which also uses the opaque pointers: Module inner offers an API:

module inner;

import stdlib;
import stdio;

public type Shape struct {
    u8 sides;
    // ..
} @(opaque)

// a non-public struct-function
func void Shape.init(Shape* shape, u8 sides) {
   shape.sides = sides;
}

// a static struct-function, called as Shape.create(..)
public func Shape* Shape.create(u8 sides) {
    Shape* shape = stdlib.malloc(sizeof(Shape));
    shape.init(sides);
    return shape;
}

// a public, const struct-function, first argument: const Shape*
public func void Shape.print(const Shape* shape) {
    stdio.printf("shape with %d sides\n", shape.sides);
}

// a public, struct-function, first argument: Shape*
public func void Shape.free(Shape* shape) {
    stdlib.free(shape);
}

which is used by module outer:

module outer;

import inner local;

func void example() {
    Shape* s = Shape.create(3);
    s.print();
    s.free();
}

NOTE: outer is not allowed to access Shape's regular members directly.