Added 2 tests and asthelpers.go

internal/zig/asthelpers.go

@@ -0,0 +1,136 @@
+package zig
+
+// Id creates an identifier expression.
+func Id(name string) *Identifier {
+	return &Identifier{Name: name}
+}
+
+// Lit creates a literal expression.
+func Lit(kind, value string) *Literal {
+	return &Literal{Kind: kind, Value: value}
+}
+
+// FieldAccess creates a field access expression.
+func FieldAccess(recv Expr, field string) *FieldAccessExpr {
+	return &FieldAccessExpr{Receiver: recv, Field: field}
+}
+
+// Call creates a function call expression.
+func Call(fun Expr, args ...Expr) *CallExpr {
+	return &CallExpr{Fun: fun, Args: args}
+}
+
+// InitList creates an initializer list expression.
+func InitList(exprs ...Expr) *InitListExpr {
+	if len(exprs) == 0 {
+		return &InitListExpr{Empty: true}
+	}
+	return &InitListExpr{Values: exprs}
+}
+
+// DeclareFn creates a function declaration with flags.
+func DeclareFn(name string, retType TypeExpr, body *Block, params []*ParamDecl, flags FnFlags) *FnDecl {
+	return &FnDecl{
+		Name:       name,
+		ReturnType: retType,
+		Body:       body,
+		Flags:      flags,
+		Params:     params,
+	}
+}
+
+// NewExprStmt creates an expression statement.
+func NewExprStmt(expr Expr) *ExprStmt {
+	return &ExprStmt{Expr: expr}
+}
+
+// DeclareVarStmt creates a variable or const declaration statement.
+func DeclareVarStmt(constant bool, names []string, typ TypeExpr, value Expr) *VarDeclStmt {
+	return &VarDeclStmt{
+		Const:   constant,
+		Pattern: VarPattern{Names: names},
+		Type:    typ,
+		Value:   value,
+	}
+}
+
+// DeclareGlobalVar creates a global variable declaration with flags.
+func DeclareGlobalVar(name string, value Expr, flags GlobalVarFlags) *GlobalVarDecl {
+	return &GlobalVarDecl{
+		Flags: flags,
+		Name:  name,
+		Value: value,
+	}
+}
+
+// Return creates a return statement.
+func Return(value Expr) *ReturnStmt {
+	return &ReturnStmt{Value: value}
+}
+
+// If creates an if statement.
+func If(cond Expr, then, els Stmt) *IfStmt {
+	return &IfStmt{Cond: cond, Then: then, Else: els}
+}
+
+// NewBlock creates a block of statements.
+func NewBlock(stmts ...Stmt) *Block {
+	return &Block{Stmts: stmts}
+}
+
+// NewBlock creates a block statement containing a block of statements.
+func NewBlockStmt(stmts ...Stmt) *BlockStmt {
+	return &BlockStmt{
+		Block: &Block{Stmts: stmts},
+	}
+}
+
+// Try creates a try expression.
+func Try(expr Expr) *TryExpr {
+	return &TryExpr{Expr: expr}
+}
+
+// Binary creates a binary expression.
+func Binary(op string, left, right Expr) *BinaryExpr {
+	return &BinaryExpr{Op: op, Left: left, Right: right}
+}
+
+// Param creates a function parameter declaration.
+func Param(name string, typ TypeExpr) *ParamDecl {
+	return &ParamDecl{Name: name, Type: typ}
+}
+
+// StructDecl creates a struct declaration with the given fields/members.
+func StructDecl(fields ...*ContainerMember) *ContainerDecl {
+	return &ContainerDecl{
+		Kind:   "struct",
+		Fields: fields,
+	}
+}
+
+// Field creates a struct field (optionally with initializer).
+func Field(name string, typ TypeExpr, byteAlign *Expr, value Expr) *ContainerMember {
+	return &ContainerMember{
+		Field: &ContainerField{
+			Name:      name,
+			Type:      typ,
+			ByteAlign: byteAlign,
+			Value:     value,
+		},
+	}
+}
+
+// Method creates a method (function declaration) as a struct member.
+func Method(fn *FnDecl) *ContainerMember {
+	return &ContainerMember{Decl: fn}
+}
+
+// OptionalType creates an optional type (?T).
+func OptionalType(base TypeExpr) *PrefixTypeExpr {
+	return &PrefixTypeExpr{Op: "?", Base: base}
+}
+
+// PointerType creates a pointer type (*T).
+func PointerType(base TypeExpr) *PrefixTypeExpr {
+	return &PrefixTypeExpr{Op: "*", Base: base}
+}