mist-go/mist
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 11 Wiki Activity

Golang codegen inside crate

Browse Source
This commit is contained in:
selimaj-dev
2026-04-23 18:59:06 +02:00
parent 195172a293
commit 02c40d7f90
7 changed files with 2 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codegen/Cargo.lock
Generated
-248
View File
@@ -1,248 +0,0 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "block-buffer"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
dependencies = [
"generic-array",
]
[[package]]
name = "cfg-if"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
[[package]]
name = "codegen"
version = "0.1.0"
dependencies = [
"parser",
]
[[package]]
name = "cpufeatures"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
dependencies = [
"libc",
]
[[package]]
name = "crypto-common"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
dependencies = [
"generic-array",
"typenum",
]
[[package]]
name = "digest"
version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
"block-buffer",
"crypto-common",
]
[[package]]
name = "generic-array"
version = "0.14.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
dependencies = [
"typenum",
"version_check",
]
[[package]]
name = "itoa"
version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
[[package]]
name = "libc"
version = "0.2.185"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
[[package]]
name = "memchr"
version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
[[package]]
name = "parser"
version = "0.1.0"
dependencies = [
"pest",
"pest_derive",
"serde",
"serde_json",
]
[[package]]
name = "pest"
version = "2.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e0848c601009d37dfa3430c4666e147e49cdcf1b92ecd3e63657d8a5f19da662"
dependencies = [
"memchr",
"ucd-trie",
]
[[package]]
name = "pest_derive"
version = "2.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11f486f1ea21e6c10ed15d5a7c77165d0ee443402f0780849d1768e7d9d6fe77"
dependencies = [
"pest",
"pest_generator",
]
[[package]]
name = "pest_generator"
version = "2.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8040c4647b13b210a963c1ed407c1ff4fdfa01c31d6d2a098218702e6664f94f"
dependencies = [
"pest",
"pest_meta",
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "pest_meta"
version = "2.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "89815c69d36021a140146f26659a81d6c2afa33d216d736dd4be5381a7362220"
dependencies = [
"pest",
"sha2",
]
[[package]]
name = "proc-macro2"
version = "1.0.106"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
dependencies = [
"proc-macro2",
]
[[package]]
name = "serde"
version = "1.0.228"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
dependencies = [
"serde_core",
"serde_derive",
]
[[package]]
name = "serde_core"
version = "1.0.228"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.228"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.149"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
dependencies = [
"itoa",
"memchr",
"serde",
"serde_core",
"zmij",
]
[[package]]
name = "sha2"
version = "0.10.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
dependencies = [
"cfg-if",
"cpufeatures",
"digest",
]
[[package]]
name = "syn"
version = "2.0.117"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "typenum"
version = "1.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
[[package]]
name = "ucd-trie"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
[[package]]
name = "unicode-ident"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
[[package]]
name = "version_check"
version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
[[package]]
name = "zmij"
version = "1.0.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
codegen/Cargo.toml
-7
View File
@@ -1,7 +0,0 @@
[package]
name = "codegen"
version = "0.1.0"
edition = "2024"
[dependencies]
parser = { path = "../parser" }
codegen/src/lib.rs
-371
View File
@@ -1,371 +0,0 @@
use parser::ast::{BinaryOp, Block, Expression, Postfix, Statement, TopLevel, TypeExpr, VarKind};
pub struct GoCodegen {
output: String,
indent: usize,
}
impl GoCodegen {
pub fn new() -> Self {
Self {
output: String::new(),
indent: 0,
}
}
fn indent_str(&self) -> String {
" ".repeat(self.indent)
}
fn add_indented(&mut self, s: &str) {
self.output.push_str(&format!("{}{}", self.indent_str(), s));
}
fn add(&mut self, s: &str) {
self.output.push_str(s);
}
fn addln(&mut self, s: &str) {
self.add(s);
self.add("\n");
}
fn add_indentedln(&mut self, s: &str) {
self.add_indented(s);
self.add("\n");
}
pub fn generate(&mut self, toplevels: &[TopLevel]) -> String {
for tl in toplevels {
self.generate_toplevel(tl);
}
self.output.clone()
}
fn generate_toplevel(&mut self, tl: &TopLevel) {
match tl {
TopLevel::Import(path) => {
let import_path = path.replace("\"", "");
if import_path.starts_with("./") || import_path.starts_with("/") {
self.addln(&format!("import \"{}\"", import_path));
} else {
self.addln(&format!("import \"{}\"", import_path));
}
self.addln("");
}
TopLevel::StructDecl {
export,
name,
fields,
} => {
let name = if *export { name } else { name };
self.addln(&format!("type {} struct {{", name));
self.indent += 1;
for (field_name, (_, ty)) in &fields.0 {
let go_ty = self.translate_type(ty);
self.addln(&format!("{} {}", field_name, go_ty));
}
self.indent -= 1;
self.addln("}\n");
}
TopLevel::FunctionDecl {
export,
name,
params,
return_type,
body,
} => {
let name = if *export {
format!("{}", name)
} else {
name.clone()
};
let params_str = params
.0
.iter()
.map(|(n, (_, t))| format!("{} {}", n, self.translate_type(t)))
.collect::<Vec<_>>()
.join(", ");
let ret_ty = return_type
.as_ref()
.map(|t| self.translate_type(t))
.unwrap_or_else(|| "".to_string());
if ret_ty.is_empty() {
self.addln(&format!("func {}({}) {{", name, params_str));
} else {
self.addln(&format!("func {}({}) {} {{", name, params_str, ret_ty));
}
self.indent += 1;
self.generate_block(body);
self.indent -= 1;
self.addln("}\n");
}
TopLevel::Package(pkg) => {
self.addln(&format!("package {}", pkg));
self.addln("");
}
}
}
fn translate_type(&self, ty: &TypeExpr) -> String {
match ty {
TypeExpr::Identifier(name) => match name.as_str() {
"int" => "int".to_string(),
"float" | "float64" => "float64".to_string(),
"float32" => "float32".to_string(),
"bool" => "bool".to_string(),
"string" => "string".to_string(),
"byte" => "byte".to_string(),
"rune" => "rune".to_string(),
_ => name.clone(),
},
}
}
fn generate_block(&mut self, block: &Block) {
for stmt in &block.0 {
self.generate_statement(stmt);
}
}
fn generate_statement(&mut self, stmt: &Statement) {
match stmt {
Statement::Expression(expr) => {
self.add_indentedln(&format!("{};", self.generate_expression(expr)));
}
Statement::Block(block) => {
self.add_indentedln("{");
self.indent += 1;
self.generate_block(block);
self.indent -= 1;
self.add_indentedln("}\n");
}
Statement::VarDecl {
kind,
name,
init,
type_,
} => {
let go_kind = match kind {
VarKind::Let | VarKind::Const => "var",
VarKind::Var => "var",
};
let init_expr = init
.as_ref()
.map(|e| format!(" = {}", self.generate_expression(e)))
.unwrap_or_else(|| "".to_string());
let type_expr = type_
.clone()
.map(|t| self.translate_type(&t))
.unwrap_or_default();
self.add_indentedln(&format!(
"{} {} {}{};\n",
go_kind, name, type_expr, init_expr
));
}
Statement::VarAssign { target, value } => {
self.add_indentedln(&format!(
"{} = {};\n",
self.generate_expression(target),
self.generate_expression(value)
));
}
Statement::If {
condition,
then_branch,
else_branch,
} => {
self.add_indented(&format!("if {} ", self.generate_expression(condition)));
self.generate_statement(then_branch);
if let Some(else_br) = else_branch {
self.add_indented("else ");
self.generate_statement(else_br);
}
}
Statement::While { condition, body } => {
self.add_indented(&format!("for {} ", self.generate_expression(condition)));
self.generate_statement(body);
}
Statement::For {
init,
condition,
update,
body,
} => {
let (kind, init_name, init_val) = init;
let init_expr = init_val
.as_ref()
.map(|e| format!(" = {}", self.generate_expression(e)))
.unwrap_or_else(|| "".to_string());
let init_str = format!("{} {}{}", self.var_kind_to_go(kind), init_name, init_expr);
let cond_str = condition
.as_ref()
.map(|e| self.generate_expression(e))
.unwrap_or_else(|| "true".to_string());
let update_str = update
.as_ref()
.map(|s| self.generate_expression(&self.stmt_to_expr(s)))
.unwrap_or_else(|| "".to_string());
self.add_indented(&format!("for {}; {}; {} ", init_str, cond_str, update_str));
self.generate_statement(body);
}
Statement::Return(expr) => {
let ret_val = expr
.as_ref()
.map(|e| self.generate_expression(e))
.unwrap_or_else(|| "".to_string());
self.add_indentedln(&format!("return {};\n", ret_val));
}
Statement::Break => {
self.add_indentedln("break;\n");
}
Statement::Continue => {
self.add_indentedln("continue;\n");
}
}
}
fn stmt_to_expr(&self, stmt: &Statement) -> Expression {
match stmt {
Statement::Expression(e) => e.clone(),
_ => Expression::Identifier(String::new()),
}
}
fn var_kind_to_go(&self, kind: &VarKind) -> String {
match kind {
VarKind::Let | VarKind::Const => "var".to_string(),
VarKind::Var => "var".to_string(),
}
}
fn generate_expression(&self, expr: &Expression) -> String {
match expr {
Expression::Identifier(name) => name.clone(),
Expression::IntLiteral(n) => n.to_string(),
Expression::FloatLiteral(n) => n.to_string(),
Expression::BoolLiteral(b) => b.to_string(),
Expression::StringLiteral(s) => format!("\"{}\"", s),
Expression::Postfix { initial, postfixes } => {
let base = self.generate_expression(initial);
self.apply_postfixes(&base, postfixes)
}
}
}
fn apply_postfixes(&self, base: &str, postfixes: &[Postfix]) -> String {
let mut result = base.to_string();
for postfix in postfixes {
result = match postfix {
Postfix::FieldAccess(field) => format!("{}.{}", result, field),
Postfix::Call(args) => {
let args_str = args
.iter()
.map(|a| self.generate_expression(a))
.collect::<Vec<_>>()
.join(", ");
format!("{}({})", result, args_str)
}
Postfix::Index(idx) => format!("{}[{}]", result, self.generate_expression(idx)),
Postfix::Binary(op, rhs) => {
let op_str = match op {
BinaryOp::Plus => "+",
BinaryOp::Minus => "-",
BinaryOp::Multiply => "*",
BinaryOp::Divide => "/",
BinaryOp::Modulo => "%",
BinaryOp::Equal => "==",
BinaryOp::NotEqual => "!=",
BinaryOp::LessThan => "<",
BinaryOp::GreaterThan => ">",
BinaryOp::LessThanOrEqual => "<=",
BinaryOp::GreaterThanOrEqual => ">=",
};
format!("{} {} {}", result, op_str, self.generate_expression(rhs))
}
};
}
result
}
}
impl Default for GoCodegen {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use parser::ast::{Block, Expression, ParamList, Statement, TopLevel, TypeExpr};
use std::collections::HashMap;
#[test]
fn test_int_literal() {
let cg = GoCodegen::new();
let expr = Expression::IntLiteral(42);
let result = cg.generate_expression(&expr);
assert_eq!(result, "42");
}
#[test]
fn test_string_literal() {
let cg = GoCodegen::new();
let expr = Expression::StringLiteral("hello".to_string());
let result = cg.generate_expression(&expr);
assert_eq!(result, "\"hello\"");
}
#[test]
fn test_function_decl() {
let mut cg = GoCodegen::new();
let toplevel = TopLevel::FunctionDecl {
export: true,
name: "main".to_string(),
params: ParamList(HashMap::new()),
return_type: None,
body: Block(vec![Statement::Return(None)]),
};
cg.generate_toplevel(&toplevel);
let output = cg.output.clone();
assert!(output.contains("func main()"));
}
#[test]
fn test_struct_decl() {
let mut cg = GoCodegen::new();
let mut fields = HashMap::new();
fields.insert(
"x".to_string(),
(true, TypeExpr::Identifier("int".to_string())),
);
let toplevel = TopLevel::StructDecl {
export: true,
name: "Point".to_string(),
fields: ParamList(fields),
};
cg.generate_toplevel(&toplevel);
let output = cg.output.clone();
assert!(output.contains("type Point struct"));
assert!(output.contains("x int"));
}
#[test]
fn test_if_statement() {
let mut cg = GoCodegen::new();
let stmt = Statement::If {
condition: Expression::Identifier("x".to_string()),
then_branch: Box::new(Statement::Return(Some(Expression::IntLiteral(1)))),
else_branch: None,
};
cg.generate_statement(&stmt);
let output = cg.output.clone();
assert!(output.contains("if x"));
}
}