ast_builder.c2

/* Copyright 2022-2026 Bas van den Berg
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

module ast_builder;

import ast local;
import ast_context local;
import attr_handler;
import attr local;
import component;
import diagnostics;
import number_radix local;
import src_loc local;
import string_pool;

import stdlib local;

public type Builder struct @(opaque) {
    Context* context;           // no ownership
    diagnostics.Diags* diags;   // no ownership
    string_pool.Pool* auxPool;  // no ownership
    component.Component* comp;  // no ownership
    Module* mod;                // no ownership
    AST* ast;
    u32 ast_idx;
    u32 c2_name;
    u32 main_name;
    bool is_interface;
    bool is_private;

    Attr[8] attrs;
    u32 num_attrs;

    attr_handler.Handler* attr_handler; // no ownership
}

public fn Builder* create(Context* context,
                            diagnostics.Diags* diags,
                            string_pool.Pool* auxPool,
                            u32 c2_name,
                            u32 main_name,
                            attr_handler.Handler* attr_handler_)
{
    Builder* b = calloc(1, sizeof(Builder));
    b.context = context;
    b.diags = diags;
    b.auxPool = auxPool;
    b.c2_name = c2_name;
    b.main_name = main_name;
    b.attr_handler = attr_handler_;

    return b;
}

public fn void Builder.free(Builder* b) {
    free(b);
}

public fn void Builder.setComponent(Builder* b, component.Component* comp) {
    b.comp = comp;
    b.mod = nil;
    b.is_interface = !comp.hasSources();
    b.is_private = comp.isExternalSourceLib();  // all non-exported modules created here will be private
}

public fn void Builder.actOnModule(Builder* b,
                                   u32 mod_name,
                                   SrcLoc mod_loc,
                                   u32 filename,
                                   bool is_interface,
                                   bool is_generated) {
    assert(b.comp);
    if (mod_name == b.c2_name && !is_interface) {
        b.diags.error(mod_loc, "module name 'c2' is reserved");
        stdlib.exit(-1);
    }
    if (mod_name == b.main_name) {
        b.diags.error(mod_loc, "module name 'main' is reserved");
        stdlib.exit(-1);
    }

    b.mod = b.comp.getOrAddModule(mod_name, b.is_private);
    b.ast = b.mod.add(b.auxPool, filename, is_interface, is_generated);
    b.ast_idx = b.ast.getIdx();

    // NOTE: make special ImportDecl to add own symbols
    ImportDecl* i = ImportDecl.create(b.context, mod_name, mod_loc, 0, 0, b.ast_idx, true);
    Decl* d = (Decl*)i;
    d.setUsed();
    d.setChecked();
    i.setDest(b.mod);
    d.setType(QualType.create((Type*)b.mod.getType()));
    b.ast.addImport(i);
}

public fn void Builder.actOnImport(Builder* b,
                                   u32 mod_name,
                                   SrcLoc mod_loc,
                                   u32 alias_name,
                                   SrcLoc alias_loc,
                                   bool islocal) {
    if (b.ast.getNameIdx() == mod_name) {
        if (mod_loc) {
            // reject self imports, no error for implicit imports (eg: varargs)
            b.diags.error(mod_loc, "cannot import own module '%s'", idx2name(mod_name));
        }
        return;
    }

    ImportDecl* old = b.ast.findImport(mod_name);
    if (old) {
        if (mod_loc) {
            // reject duplicate imports, no error for implicit imports
            b.diags.error(mod_loc, "duplicate import of module '%s'", idx2name(mod_name));
            b.diags.note(old.asDecl().getLoc(), "previous import is here");
        }
        return;
    }

    if (alias_name) {
        if (alias_name == mod_name) {
            b.diags.error(alias_loc, "alias name is same as module name");
            return;
        }
        // Note: other clashes are done by Scope later
    }

    ImportDecl* d = ImportDecl.create(b.context,
                                      mod_name,
                                      mod_loc,
                                      alias_name,
                                      alias_loc,
                                      b.ast_idx,
                                      islocal);
    b.ast.addImport(d);
}

public fn Decl* Builder.actOnAliasType(Builder* b,
                                       u32 name,
                                       SrcLoc loc,
                                       bool is_public,
                                       const TypeRefHolder* ref) {
    is_public |= b.is_interface;
    AliasTypeDecl* d = AliasTypeDecl.create(b.context, name, loc, is_public, b.ast_idx, ref);
    b.ast.addTypeDecl(d.asDecl());
    Decl* dd = (Decl*)d;
    if (b.is_interface) dd.setExternal();
    b.addSymbol(name, dd);
    return dd;
}

public fn Decl* Builder.actOnFunctionTypeDecl(Builder* b,
                                              u32 name,
                                              SrcLoc loc,
                                              bool is_public,
                                              const TypeRefHolder* rtype,
                                              VarDecl** params,
                                              u32 num_params,
                                              bool is_variadic)
{
    is_public |= b.is_interface;
    FunctionDecl* fd = FunctionDecl.create(b.context,
                                           name,
                                           loc,
                                           is_public,
                                           b.ast_idx,
                                           rtype,
                                           nil,
                                           params,
                                           num_params,
                                           is_variadic,
                                           DefKind.Type);

    FunctionTypeDecl* d = FunctionTypeDecl.create(b.context, fd);
    b.ast.addTypeDecl(d.asDecl());
    Decl* dd = (Decl*)d;
    if (b.is_interface) {
        dd.setExternal();
        fd.asDecl().setExternal();
    }
    b.addSymbol(name, dd);
    return dd;
}

public fn Decl* Builder.actOnFunctionType(Builder* b,
                                          const TypeRefHolder* rtype,
                                          VarDecl** params,
                                          u32 num_params,
                                          bool is_variadic,
                                          DefKind def_kind)
{
    FunctionDecl* fd = FunctionDecl.create(b.context,
                                           0, 0, false,
                                           b.ast_idx,
                                           rtype,
                                           nil,
                                           params,
                                           num_params,
                                           is_variadic,
                                           def_kind);
    return (Decl*)fd;
}

public fn StructTypeDecl* Builder.actOnStructType(Builder* b,
                                                    u32 name,
                                                    SrcLoc loc,
                                                    bool is_public,
                                                    bool is_struct,
                                                    bool is_global,
                                                    Decl** members,
                                                    u32 num_members)
{
    is_public |= b.is_interface;
    StructTypeDecl* d = StructTypeDecl.create(b.context,
                                              name,
                                              loc,
                                              is_public,
                                              b.ast_idx,
                                              is_struct,
                                              is_global,
                                              members,
                                              num_members);
    if (is_global) {
        b.ast.addTypeDecl(d.asDecl());
        b.addSymbol(name, d.asDecl());
    }
    if (b.is_interface) d.asDecl().setExternal();
    return d;
}

public fn VarDecl* Builder.actOnStructMember(Builder* b,
                                               u32 name,
                                               SrcLoc loc,
                                               bool is_public,
                                               const TypeRefHolder* ref,
                                               Expr* bitfield)
{
    is_public |= b.is_interface;
    return VarDecl.createStructMember(b.context,
                                      name,
                                      loc,
                                      is_public,
                                      ref,
                                      b.ast_idx,
                                      bitfield);
}

public fn FieldInitInfo* Builder.actOnFieldInitInfo(Builder* b, StructTypeDecl* std) {
    return std.createFieldInfo(b.context);
}

public fn Decl* Builder.actOnGlobalVarDecl(Builder* b,
                                            u32 name,
                                            SrcLoc loc,
                                            bool is_public,
                                            TypeRefHolder* ref,
                                            SrcLoc assignLoc,
                                            bool has_embed,
                                            Expr* initValue)
{
    is_public |= b.is_interface;
    VarDecl* vd = VarDecl.create(b.context,
                                 VarDeclKind.GlobalVar,
                                 name,
                                 loc,
                                 is_public,
                                 ref,
                                 b.ast_idx,
                                 assignLoc,
                                 has_embed,
                                 initValue);
    Decl* d = vd.asDecl();
    b.ast.addVarDecl(d);
    b.addSymbol(name, d);
    if (b.is_interface) d.setExternal();

    return d;
}

public fn VarDecl* Builder.actOnFunctionParam(Builder* b,
                                                u32 name,
                                                SrcLoc loc,
                                                bool is_public,
                                                const TypeRefHolder* ref,
                                                SrcLoc assignLoc,
                                                Expr* initValue)
{
    is_public |= b.is_interface;
    return VarDecl.create(b.context,
                          VarDeclKind.FunctionParam,
                          name,
                          loc,
                          is_public,
                          ref,
                          b.ast_idx,
                          assignLoc,
                          false,
                          initValue);
}

public fn Stmt* Builder.actOnDeclStmt(Builder* b, VarDecl** decl, u32 count)
{
    return (Stmt*)DeclStmt.create(b.context, decl, count);
}

public fn VarDecl* Builder.actOnVarDecl(Builder* b,
                                        u32 name,
                                        SrcLoc loc,
                                        const TypeRefHolder* ref,
                                        SrcLoc assignLoc,
                                        Expr* initValue,
                                        bool has_local,
                                        bool has_init_call)
{
    VarDecl* d = VarDecl.create(b.context,
                                VarDeclKind.LocalVar,
                                name,
                                loc,
                                false,
                                ref,
                                b.ast_idx,
                                assignLoc,
                                false,
                                initValue);
    d.setLocal(has_local);
    d.setInitCall(has_init_call);
    return d;
}

fn void Builder.storeAttr(Builder* b, Decl* d, const Attr* a) {
    d.setHasAttr();
    b.ast.storeAttr(d, a);
}

public fn void Builder.actOnArrayValue(Builder* b,
                                         u32 name,
                                         SrcLoc loc,
                                         Expr* initValue)
{
    ArrayValue* avd = ArrayValue.create(b.context, name, loc, initValue);
    b.ast.addArrayValue(avd);
}

fn void Builder.actOnFunctionAttr(Builder* b, Decl* d, const Attr* a) {
    FunctionDecl* fd = (FunctionDecl*)d;

    switch (a.kind) {
    case Export:
        d.setAttrExport();
        break;
    case Unused:
        d.setAttrUnused();
        break;
    case UnusedParams:
        fd.setAttrUnusedParams();
        break;
    case Section:
        b.storeAttr(d, a);
        break;
    case NoReturn:
        fd.setAttrNoReturn();
        break;
    case Inline:
        fd.setAttrInline();
        break;
    case Weak:
        if (!d.isPublic()) b.diags.error(a.loc, "weak declarations must be public");
        fd.setAttrWeak();
        break;
    case CName:
    case CDef:
        b.storeAttr(d, a);
        break;
    case Constructor:
        fd.setAttrConstructor();
        break;
    case Destructor:
        fd.setAttrDestructor();
        break;
    case Pure:
        fd.setAttrPure();
        break;
    case Deprecated:
        fd.setAttrDeprecated();
        b.storeAttr(d, a);
        break;
    default:
        b.diags.error(a.loc, "attribute '%s' is not applicable to functions", a.kind2name());
        break;
    }
}

fn void Builder.actOnStructAttr(Builder* b, Decl* d, const Attr* a) {
    StructTypeDecl* std = (StructTypeDecl*)d;

    switch (a.kind) {
    case Export:
        d.setAttrExport();
        break;
    case Packed:
        std.setPacked();
        break;
    case Unused:
        d.setAttrUnused();
        break;
    case Section:
        b.diags.error(a.loc, "attribute '%s' cannot be applied to type declarations",
                      a.kind2name());
        break;
    case Aligned:
        std.setAttrAlignment(a.value.number);
        break;
    case Opaque:
        if (!d.isPublic()) {
            b.diags.error(a.loc, "opaque declaration must be public");
        }
        std.setOpaque();
        break;
    case CName:
        b.storeAttr(d, a);
        break;
    case NoTypeDef:
        if (b.is_interface) {
            std.setAttrNoTypeDef();
        } else {
            b.diags.error(a.loc, "attribute '%s' can only be used in interfaces",
                          a.kind2name());
        }
        break;
    default:
        b.diags.error(a.loc, "attribute '%s' is not applicable to structs",
                      a.kind2name());
        break;
    }
}

fn bool Builder.actOnTypeAttr(Builder* b, Decl* d, const Attr* a) {
    switch (a.kind) {
    case Export:
        d.setAttrExport();
        break;
    case Packed:
        b.diags.error(a.loc, "attribute '%s' can only be applied to struct/union types",
                      a.kind2name());
        return false;
    case Unused:
        d.setAttrUnused();
        break;
    case Opaque:
        b.diags.error(a.loc, "attribute '%s' can only be applied to struct/union types",
                      a.kind2name());
        return false;
    case CName:
        b.storeAttr(d, a);
        break;
    default:
        b.diags.error(a.loc, "attribute '%s' is not applicable to Enum/Alias types",
                      a.kind2name());
        return false;
    }
    return true;
}

fn void Builder.actOnVarAttr(Builder* b, Decl* d, const Attr* a) {
    VarDecl* vd = (VarDecl*)d;

    if (vd.getKind() == FunctionParam) {
        b.actOnParamAttr(vd, a);
        return;
    }

    switch (a.kind) {
    case Export:
        d.setAttrExport();
        break;
    case Unused:
        d.setAttrUnused();
        break;
    case Section:
        b.storeAttr(d, a);
        break;
    case Aligned:
        b.storeAttr(d, a);
        break;
    case Weak:
        if (!d.isPublic()) b.diags.error(a.loc, "weak declarations must be public");
        vd.setAttrWeak();
        break;
    case CName:
    case CDef:
        b.storeAttr(d, a);
        break;
    case Embed:
        b.storeAttr(d, a);
        break;
    default:
        b.diags.error(a.loc, "attribute '%s' is not applicable to variables",
                      a.kind2name());
        break;
    }
}

public fn bool Builder.hasOpaqueAttr(Builder* b) {
    for (u32 i=0; i<b.num_attrs; i++) {
        const Attr* a = &b.attrs[i];
        if (b.attrs[i].kind == Opaque) return true;
    }
    return false;
}

public fn bool Builder.hasEmbedAttr(Builder* b) {
    for (u32 i=0; i<b.num_attrs; i++) {
        const Attr* a = &b.attrs[i];
        if (b.attrs[i].kind == Embed) return true;
    }
    return false;
}

fn bool Builder.actOnParamAttr(Builder* b, VarDecl* d, const Attr* a) {
    switch (a.kind) {
    case PrintfFormat:
        d.setFormatAttr(Printf);
        return true;
    case ScanfFormat:
        d.setFormatAttr(Scanf);
        return true;
    case AutoFile:
        if (d.hasAutoAttr()) break;
        d.setAttrAutoFile();
        return true;
    case AutoLine:
        if (d.hasAutoAttr()) break;
        d.setAttrAutoLine();
        return true;
    case AutoFunc:
        if (d.hasAutoAttr()) break;
        d.setAttrAutoFunc();
        return true;
    default:
        b.diags.error(a.loc, "attribute '%s' cannot be applied to function parameters",
                      ast.idx2name(a.name));
        return false;
    }
    b.diags.error(a.loc, "invalid combination of attributes");
    return false;
}

public fn bool Builder.actOnAttr(Builder* b, const Attr* a) {
    switch (a.kind) {
    case CName:
    case CDef:
        if (!b.is_interface) {
            b.diags.error(a.loc, "attribute '%s' can only be used in interface files", a.kind2name());
            return false;
        }
        break;
    default:
        break;
    }

    if (a.kind != Unknown) {
        switch (a.checkArgument()) {
        case NoArg:
            b.diags.error(a.loc, "attribute '%s' has no argument", a.kind2name());
            return false;
        case Arg:
            b.diags.error(a.loc, "attribute '%s' needs an argument", a.kind2name());
            return false;
        case Number:
            b.diags.error(a.value.loc, "attribute '%s' needs a number argument", a.kind2name());
            return false;
        case String:
            b.diags.error(a.value.loc, "attribute '%s' needs a string argument", a.kind2name());
            return false;
        case Power2:
            b.diags.error(a.value.loc, "requested alignment is not a power of 2");
            return false;
        case Ok:
            break;
        }
    }

    // always store attribute and apply later in applyAttributes()
    if (b.num_attrs == elemsof(b.attrs)) {
        b.diags.error(a.loc, "too many attributes");
        return false;
    }

    b.attrs[b.num_attrs] = *a;
    b.num_attrs++;
    return true;
}

public fn void Builder.clearAttributes(Builder* b) {
    b.num_attrs = 0;
}

fn void Builder.applyAttribute(Builder* b, Decl* d, const Attr* a) {
    DeclKind dk = d.getKind();
    switch (dk) {
    case Function:
        b.actOnFunctionAttr(d, a);
        break;
    case StructType:
        b.actOnStructAttr(d, a);
        break;
    case EnumType:
        b.actOnTypeAttr(d, a);
        break;
    case FunctionType:
        // store in inner type also (for needed for type decl, other for when used)
        // check result of first, otherwise we get the same error twice
        if (!b.actOnTypeAttr(d, a)) return;

        FunctionTypeDecl* ftd = (FunctionTypeDecl*)d;
        b.applyAttribute((Decl*)ftd.getDecl(), a);
        break;
    case AliasType:
        b.actOnTypeAttr(d, a);
        break;
    case Variable:
        b.actOnVarAttr(d, a);
        break;
    default:
        assert(0);
        return;
    }
}

public fn void Builder.applyAttributes(Builder* b, Decl* d, u32 count) {
    assert(d);
    assert(count <= b.num_attrs);
    for (u32 i = 0; i < count; i++) {
        const Attr* a = &b.attrs[b.num_attrs - count + i];

        if (a.kind == Unknown) {
            if (!b.attr_handler.handle(d, a)) b.storeAttr(d, a);
        } else {
            b.applyAttribute(d, a);
        }
    }
    b.num_attrs -= count;
}

public fn QualType Builder.actOnBuiltinType(Builder*, BuiltinKind kind) {
    return getBuiltinQT(kind);
}

public fn QualType Builder.actOnVoidType(Builder*) {
    return getVoidQT();
}

public fn QualType Builder.actOnPointerType(Builder*, QualType inner) {
    QualType ptr = QualType.create(ast.getPointerType(inner));

    // canonical can be either self or a pointer to elem's canonical type
    QualType canon = inner.getCanonicalType();
    if (inner.getTypeOrNil() == canon.getTypeOrNil()) {
        canon = ptr;
    } else {
        canon = QualType.create(ast.getPointerType(canon));
        canon.setCanonicalType(canon);
    }
    ptr.setCanonicalType(canon);

    return ptr;
}

public fn QualType Builder.actOnArrayType(Builder* b,
                                          QualType elem,
                                          bool has_size,
                                          u32 size,
                                          bool is_enum_index,
                                          QualType index_type) {
    ArrayType* t = ArrayType.create(b.context, elem, has_size, size, is_enum_index, index_type);
    QualType a = QualType.create((Type*)t);

    // canonical can be either self or a pointer to elem's canonical type
    QualType canon = elem.getCanonicalType();
    if (elem.getTypeOrNil() == canon.getTypeOrNil()) {
        canon = a;
    } else {
        ArrayType* t2 = ArrayType.create(b.context, canon, has_size, size, is_enum_index, index_type);
        // Note: keep same quals here, even if canonical type may be a PointerType!
        canon = QualType.create((Type*)t2);
    }
    a.setCanonicalType(canon);

    return a;
}

public fn QualType Builder.actOnIncrementalArrayType(Builder* b, QualType elem) {
    ArrayType* t = ArrayType.createIncremental(b.context, elem);
    QualType a = QualType.create((Type*)t);

    // canonical can be either self or a pointer to elem's canonical type
    QualType canon = elem.getCanonicalType();
    if (elem.getTypeOrNil() == canon.getTypeOrNil()) {
        canon = a;
    } else {
        ArrayType* t2 = ArrayType.createIncremental(b.context, canon);
        // Note: keep same quals here, even if canonical type may be a PointerType!
        canon = QualType.create((Type*)t2);
    }
    a.setCanonicalType(canon);

    return a;
}

public fn FunctionDecl* Builder.actOnFunctionDecl(Builder* b,
                                                    u32 name,
                                                    SrcLoc loc,
                                                    bool is_public,
                                                    const TypeRefHolder* rtype,
                                                    const Ref* prefix,
                                                    VarDecl** params,
                                                    u32 num_params,
                                                    bool is_variadic,
                                                    bool is_local)
{
    is_public |= b.is_interface & !is_local;
    FunctionDecl* f = FunctionDecl.create(b.context,
                                          name,
                                          loc,
                                          is_public,
                                          b.ast_idx,
                                          rtype,
                                          prefix,
                                          params,
                                          num_params,
                                          is_variadic,
                                          is_local ? DefKind.Local : DefKind.Global);
    b.ast.addFunc(f);
    if (!is_local) {
        if (!prefix) b.addSymbol(name, f.asDecl());
        if (b.is_interface) f.asDecl().setExternal();
    }
    return f;
}

public fn FunctionDecl* Builder.actOnTemplateFunctionDecl(Builder* b,
                                                            u32 name,
                                                            SrcLoc loc,
                                                            bool is_public,
                                                            const TypeRefHolder* rtype,
                                                            u32 template_name,
                                                            SrcLoc template_loc,
                                                            VarDecl** params,
                                                            u32 num_params,
                                                            bool is_variadic)
{
    if (b.is_interface) b.diags.error(loc, "template functions are not allow in interfaces");
    is_public |= b.is_interface;
    FunctionDecl* f = FunctionDecl.createTemplate(b.context,
                                                  name,
                                                  loc,
                                                  is_public,
                                                  b.ast_idx,
                                                  rtype,
                                                  template_name,
                                                  template_loc,
                                                  params,
                                                  num_params,
                                                  is_variadic);
    b.ast.addFunc(f);
    b.addSymbol(name, f.asDecl());
    if (b.is_interface) f.asDecl().setExternal();
    return f;
}

public fn void Builder.actOnFunctionBody(Builder*, FunctionDecl* f, CompoundStmt* body) {
    f.setBody(body);
}

public fn EnumConstantDecl* Builder.actOnEnumConstant(Builder* b,
                                                      u32 name,
                                                      SrcLoc loc,
                                                      bool is_public,
                                                      Expr* init_expr) {
    return EnumConstantDecl.create(b.context, name, loc, is_public, b.ast_idx, init_expr);
}

public fn Decl* Builder.actOnEnumType(Builder* b,
                                        u32 name,
                                        SrcLoc loc,
                                        bool is_public,
                                        bool is_incr,
                                        QualType implType,
                                        EnumConstantDecl** constants,
                                        u32 num_constants)
{
    is_public |= b.is_interface;
    EnumTypeDecl* d = EnumTypeDecl.create(b.context,
                                          name,
                                          loc,
                                          is_public,
                                          b.ast_idx,
                                          implType,
                                          is_incr,
                                          constants,
                                          num_constants);
    b.ast.addTypeDecl(d.asDecl());
    b.addSymbol(name, d.asDecl());
    return (Decl*)d;
}

public fn Stmt* Builder.actOnAsmStmt(Builder* b,
                                       SrcLoc loc,
                                       bool is_basic,
                                       bool is_volatile,
                                       u32 num_outputs,
                                       u32 num_inputs,
                                       const u32* names, // can be nil
                                       ExprList* constraints,
                                       ExprList* exprs,
                                       ExprList* clobbers,
                                       Expr* asm_string)
{
    return (Stmt*)AsmStmt.create(b.context,
                                      loc,
                                      is_basic, is_volatile,
                                      num_outputs, num_inputs,
                                      names,
                                      constraints,
                                      exprs,
                                      clobbers,
                                      asm_string);
}

public fn CompoundStmt* Builder.actOnCompoundStmt(Builder* b,
                                                  SrcLoc endLoc,
                                                  Stmt** stmts,
                                                  u32 count) {
    return CompoundStmt.create(b.context, endLoc, stmts, count);
}

public fn Stmt* Builder.actOnReturnStmt(Builder* b, SrcLoc loc, Expr* ret) {
    return (Stmt*)ReturnStmt.create(b.context, loc, ret);
}

public fn Stmt* Builder.actOnIfStmt(Builder* b, SrcLoc loc, Stmt* cond, Stmt* then, Stmt* else_stmt) {
    return (Stmt*)IfStmt.create(b.context, loc, cond, then, else_stmt);
}

public fn Stmt* Builder.actOnWhileStmt(Builder* b, SrcLoc loc, Stmt* cond, Stmt* then) {
    return (Stmt*)WhileStmt.create(b.context, loc, cond, then);
}

public fn Stmt* Builder.actOnForStmt(Builder* b,
                                     SrcLoc loc,
                                     Stmt* init,
                                     Expr* cond,
                                     Expr* incr,
                                     Stmt* body) {
    return (Stmt*)ForStmt.create(b.context, loc, init, cond, incr, body);
}

public fn Stmt* Builder.actOnSwitchStmt(Builder* b,
                                        SrcLoc loc,
                                        Stmt* cond,
                                        SwitchCase** cases, u32 num_cases,
                                        bool has_default) {
    return (Stmt*)SwitchStmt.create(b.context, loc, cond, cases, num_cases, has_default);
}

public fn SwitchCase* Builder.actOnCase(Builder* b,
                                        SrcLoc loc,
                                        bool is_default,
                                        Expr** conds, u32 num_conds,
                                        Stmt** stmts, u32 num_stmts) {
    return SwitchCase.create(b.context, loc, is_default,
                             conds, num_conds, stmts, num_stmts);
}

public fn Stmt* Builder.actOnAssertStmt(Builder* b, SrcLoc loc, Expr* inner) {
    return (Stmt*)AssertStmt.create(b.context, loc, inner);
}

public fn Stmt* Builder.actOnBreakStmt(Builder* b, SrcLoc loc) {
    return (Stmt*)BreakStmt.create(b.context, loc);
}

public fn Stmt* Builder.actOnContinueStmt(Builder* b, SrcLoc loc) {
    return (Stmt*)ContinueStmt.create(b.context, loc);
}

public fn Stmt* Builder.actOnFallthroughStmt(Builder* b, SrcLoc loc) {
    return (Stmt*)FallthroughStmt.create(b.context, loc);
}

public fn Stmt* Builder.actOnLabelStmt(Builder* b, u32 name, SrcLoc loc, Stmt* stmt) {
    return (Stmt*)LabelStmt.create(b.context, name, loc, stmt);
}

public fn Stmt* Builder.actOnGotoStmt(Builder* b, u32 name, SrcLoc loc) {
    return (Stmt*)GotoStmt.create(b.context, name, loc);
}

public fn IdentifierExpr* Builder.actOnIdentifier(Builder* b, SrcLoc loc, u32 name) {
    return IdentifierExpr.create(b.context, loc, name);
}

public fn Expr* Builder.actOnIntegerLiteral(Builder* b, SrcLoc loc, u32 src_len, u64 value, Radix radix, BuiltinKind kind) {
    return (Expr*)IntegerLiteral.create(b.context, loc, src_len, value, radix, kind);
}

public fn Expr* Builder.actOnFloatLiteral(Builder* b, SrcLoc loc, u32 src_len, f64 value, Radix radix, BuiltinKind kind) {
    return (Expr*)FloatLiteral.create(b.context, loc, src_len, value, radix, kind);
}

public fn Expr* Builder.actOnCharLiteral(Builder* b, SrcLoc loc, u32 src_len, u8 value, Radix radix) {
    return (Expr*)CharLiteral.create(b.context, loc, src_len, value, radix);
}

public fn Expr* Builder.actOnStringLiteral(Builder* b, SrcLoc loc, u32 src_len, u32 value, u32 len) {
    return (Expr*)StringLiteral.create(b.context, loc, src_len, value, len);
}

public fn Expr* Builder.actOnNilExpr(Builder* b, SrcLoc loc) {
    return (Expr*)NilExpr.create(b.context, loc);
}

public fn Expr* Builder.actOnParenExpr(Builder* b, SrcLoc loc, u32 src_len, Expr* inner) {
    return (Expr*)ParenExpr.create(b.context, loc, src_len, inner);
}

public fn Expr* Builder.actOnUnaryOperator(Builder* b, SrcLoc loc, UnaryOpcode opcode, Expr* inner) {
    return (Expr*)UnaryOperator.create(b.context, loc, opcode, inner);
}

public fn Expr* Builder.actOnBinaryOperator(Builder* b,
                                            SrcLoc loc,
                                            BinaryOpcode opcode,
                                            Expr* lhs,
                                            Expr* rhs) {
    return (Expr*)BinaryOperator.create(b.context, loc, opcode, lhs, rhs);
}

public fn Expr* Builder.actOnConditionalOperator(Builder* b,
                                                 SrcLoc questionLoc,
                                                 SrcLoc colonLoc,
                                                 Expr* cond,
                                                 Expr* lhs,
                                                 Expr* rhs) {
    return (Expr*)ConditionalOperator.create(b.context,
                                                  questionLoc,
                                                  colonLoc,
                                                  cond,
                                                  lhs,
                                                  rhs);
}

public fn Expr* Builder.actOnBooleanConstant(Builder* b, SrcLoc loc, bool value) {
    return (Expr*)BooleanLiteral.create(b.context, loc, value);
}

public fn Expr* Builder.actOnBuiltinExpr(Builder* b,
                                         SrcLoc loc, u32 src_len,
                                         Expr* inner,
                                         BuiltinExprKind kind) {
    return (Expr*)BuiltinExpr.create(b.context, loc, src_len, inner, kind);
}

public fn Expr* Builder.actOnOffsetOfExpr(Builder* b,
                                          SrcLoc loc, u32 src_len,
                                          Expr* structExpr,
                                          Expr* member) {
    return (Expr*)BuiltinExpr.createOffsetOf(b.context, loc, src_len, structExpr, member);
}

public fn Expr* Builder.actOnToContainerExpr(Builder* b,
                                             SrcLoc loc, u32 src_len,
                                             Expr* structExpr,
                                             Expr* member,
                                             Expr* pointer) {
    return (Expr*)BuiltinExpr.createToContainer(b.context,
                                                     loc, src_len,
                                                     structExpr,
                                                     member,
                                                     pointer);
}

public fn Expr* Builder.actOnTypeExpr(Builder* b, SrcLoc loc, u32 src_len, const TypeRefHolder* ref) {
    return (Expr*)TypeExpr.create(b.context, loc, src_len, ref);
}

public fn Expr* Builder.actOnBitOffsetExpr(Builder* b, SrcLoc loc, Expr* lhs, Expr* rhs) {
    return (Expr*)BitOffsetExpr.create(b.context, loc, lhs, rhs);
}

public fn Expr* Builder.actOnArraySubscriptExpr(Builder* b, SrcLoc loc, u32 src_len, Expr* base, Expr* idx) {
    return (Expr*)ArraySubscriptExpr.create(b.context, loc, src_len, base, idx);
}

public fn Expr* Builder.actOnCallExpr(Builder* b,
                                      SrcLoc loc, SrcLoc endLoc,
                                      Expr* func,
                                      Expr** args,
                                      u32 num_args) {
    return (Expr*)CallExpr.create(b.context, loc, endLoc, func, args, num_args);
}

public fn Expr* Builder.actOnTemplateCallExpr(Builder* b,
                                              SrcLoc loc, SrcLoc endLoc,
                                              Expr* func,
                                              Expr** args,
                                              u32 num_args,
                                              const TypeRefHolder* ref) {
    return (Expr*)CallExpr.createTemplate(b.context, loc, endLoc, func, args, num_args, b.ast_idx, ref);
}

public fn Expr* Builder.actOnExplicitCast(Builder* b,
                                          SrcLoc loc, u32 src_len,
                                          const TypeRefHolder* ref,
                                          Expr* inner, bool c_style) {
    return (Expr*)ExplicitCastExpr.create(b.context, loc, src_len, ref, inner, c_style);
}

public fn Expr* Builder.actOnMemberExpr(Builder* b, Expr* base, const Ref* refs, u32 refcount) {
    return (Expr*)MemberExpr.create(b.context, base, refs, refcount);
}

public fn Expr* Builder.actOnRange(Builder* b, SrcLoc loc, Expr* lhs, Expr* rhs) {
    return (Expr*)RangeExpr.create(b.context, loc, lhs, rhs);
}

public fn Expr* Builder.actOnInitList(Builder* b,
                                      SrcLoc loc,
                                      SrcLoc endLoc,
                                      Expr** values,
                                      u32 num_values) {
    return (Expr*)InitListExpr.create(b.context, loc, endLoc, values, num_values);
}

public fn Expr* Builder.actOnFieldDesignatedInit(Builder* b,
                                                 SrcLoc loc,
                                                 u32 field,
                                                 Expr* initValue) {
    return (Expr*)FieldDesignatedInitExpr.create(b.context, loc, field, initValue);
}

public fn Expr* Builder.actOnArrayDesignatedInit(Builder* b,
                                                 SrcLoc loc,
                                                 Expr* designator,
                                                 Expr* initValue) {
    return (Expr*)ArrayDesignatedInitExpr.create(b.context, loc, designator, initValue);
}

public fn void Builder.actOnStaticAssert(Builder* b, SrcLoc loc, Expr* lhs, Expr* rhs) {
    StaticAssert* d = StaticAssert.create(b.context, b.ast_idx, loc, lhs, rhs);
    b.ast.addStaticAssert(d);
}


public fn void Builder.insertImplicitCast(Builder* b,
                                          ImplicitCastKind kind,
                                          Expr** e_ptr,
                                          QualType qt) {
    Expr* inner = *e_ptr;
    Expr* ic = (Expr*)ImplicitCastExpr.create(b.context, inner.getLoc(), kind, inner);
    ic.setType(qt);
    *e_ptr = ic;
}

public fn void Builder.addSymbol(Builder* b, u32 name_idx, Decl* d) {
    Decl* old = b.mod.findSymbol(name_idx);
    if (old) {
        b.diags.error(d.getLoc(), "redefinition of '%s'", idx2name(name_idx));
        b.diags.note(old.getLoc(), "previous definition is here");
    } else {
        b.mod.addSymbol(name_idx, d);
    }
}

public fn Expr* Builder.actOnNamedArgument(Builder* b, SrcLoc loc, u32 name, Expr* inner) {
    return (Expr*)NamedArgument.create(b.context, loc, name, inner);
}

public fn Expr* Builder.actOnAlternate(Builder* b, Expr* original, Expr* generated) {
    return (Expr*)AlternateExpr.create(b.context, original, generated);
}