diff --git a/core/src/codelib_gen/mod.rs b/core/src/codelib_gen/mod.rs deleted file mode 100644 index 1e50349..0000000 --- a/core/src/codelib_gen/mod.rs +++ /dev/null @@ -1,28 +0,0 @@ -// Standard Uses -use std::collections::HashMap; - -// Crate Uses -use crate::schema::ir::frozen::unit::FrozenUnit; - -// External Uses -use once_cell::sync::Lazy; - - -pub type VersionGenerators = Lazy>; -pub type GeneratorFn = fn(&Vec) -> String; -pub type Generator = (GeneratorFn, &'static str); - - -pub mod rust; - -#[allow(unused)] -/// Find a generator function from the external codelib-gen library -pub fn find_generator(name: &str, _version: &str) - -> Option<(&'static GeneratorFn, &'static str)> -{ - match name { - "rust" => Some((&(rust::generate_rust as GeneratorFn), "rs")), - _ => None, - } -} - diff --git a/core/src/codelib_gen/rust.rs b/core/src/codelib_gen/rust.rs deleted file mode 100644 index 4850fcf..0000000 --- a/core/src/codelib_gen/rust.rs +++ /dev/null @@ -1,123 +0,0 @@ -use crate::schema::ir::frozen::unit::FrozenUnit; -use crate::schema::ir::compiler::interpreted::kind_search::{KindValue}; - -pub fn generate_rust(units: &Vec) -> String { - let mut output = String::new(); - - // Add standard header - output.push_str("// Generated by Comline\n"); - output.push_str("use serde::{Serialize, Deserialize};\n\n"); - - for unit in units { - match unit { - FrozenUnit::Struct { name, fields, .. } => { - output.push_str(&generate_struct(name, fields)); - } - FrozenUnit::Enum { name, variants, .. } => { - output.push_str(&generate_enum(name, variants)); - } - FrozenUnit::Protocol { name, functions, .. } => { - output.push_str(&generate_protocol(name, functions)); - } - _ => {} - } - } - - output -} - -fn generate_struct(name: &str, fields: &Vec) -> String { - let mut s = format!("#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct {} {{\n", name); - - for field in fields { - if let FrozenUnit::Field { name, kind_value, .. } = field { - let type_name = map_kind_to_rust_type(kind_value); - s.push_str(&format!(" pub {}: {},\n", name, type_name)); - } - } - - s.push_str("}\n\n"); - s -} - -fn generate_protocol(name: &str, functions: &Vec) -> String { - let mut s = format!("pub trait {} {{\n", name); - - for func in functions { - if let FrozenUnit::Function { name, arguments, _return, .. } = func { - let args_str = arguments.iter().map(|arg| { - format!("{}: {}", arg.name, map_kind_to_rust_type(&arg.kind)) - }).collect::>().join(", "); - - let ret_str = if let Some(ret) = _return { - format!(" -> {}", map_kind_to_rust_type(ret)) - } else { - "".to_string() - }; - - s.push_str(&format!(" fn {}({}){};\n", name, args_str, ret_str)); - } - } - - s.push_str("}\n\n"); - s -} - -fn generate_enum(name: &str, variants: &Vec) -> String { - let mut s = format!("#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]\npub enum {} {{\n", name); - - for variant in variants { - if let FrozenUnit::EnumVariant(kv, _) = variant { - // Extract name from KindValue. - // Usually EnumVariant(String, Option) or Primitive? - // incremental.rs maps it to EnumVariant(name, None). - let variant_name = match kv { - KindValue::EnumVariant(n, _) => n.clone(), - KindValue::Namespaced(n, _) => n.clone(), // Fallback - _ => "Unknown".to_string(), - }; - s.push_str(&format!(" {},\n", variant_name)); - } - } - - s.push_str("}\n\n"); - s -} - -fn map_kind_to_rust_type(kind: &KindValue) -> String { - match kind { - KindValue::Primitive(p) => { - map_str_type(p.name()) - } - KindValue::Namespaced(name, _) => { - map_str_type(name) - } - KindValue::EnumVariant(name, _) => name.clone(), - _ => "/* unknown_kind */".to_string() - } -} - -fn map_str_type(s: &str) -> String { - if s.ends_with("[]") { - let inner = &s[..s.len()-2]; - return format!("Vec<{}>", map_str_type(inner)); - } - match s { - "string" | "str" => "String".to_string(), - "bool" => "bool".to_string(), - "float" => "f64".to_string(), - "int" => "i32".to_string(), // default to i32 for generic int - "u8" => "u8".to_string(), - "u16" => "u16".to_string(), - "u32" => "u32".to_string(), - "u64" => "u64".to_string(), - // IDL spells signed integers with an `s` prefix (s8/s16/s32/s64); - // Rust's own primitives are always `i`-prefixed, so this is a real - // translation, not a passthrough. - "s8" => "i8".to_string(), - "s16" => "i16".to_string(), - "s32" => "i32".to_string(), - "s64" => "i64".to_string(), - other => other.to_string(), - } -} diff --git a/core/src/lib.rs b/core/src/lib.rs index 012cf10..10ba547 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -8,4 +8,5 @@ pub mod package; pub mod autodoc; pub mod utils; pub mod report; -pub mod codelib_gen; +// Code generation moved to `ComlineProject/generation` (`comline-codelib-gen`); +// the CLI is the composition root. See design/generation.md. diff --git a/core/tests/codelib_gen/mod.rs b/core/tests/codelib_gen/mod.rs deleted file mode 100644 index a690570..0000000 --- a/core/tests/codelib_gen/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod rust_gen_tests; diff --git a/core/tests/codelib_gen/rust_gen_tests.rs b/core/tests/codelib_gen/rust_gen_tests.rs deleted file mode 100644 index 9f61abf..0000000 --- a/core/tests/codelib_gen/rust_gen_tests.rs +++ /dev/null @@ -1,103 +0,0 @@ -use comline_core::codelib_gen::rust::generate_rust; -use comline_core::schema::ir::frozen::unit::{FrozenUnit, FrozenArgument}; -use comline_core::schema::ir::compiler::interpreted::kind_search::{KindValue, Primitive}; - -#[test] -fn test_generate_simple_struct() { - let units = vec![ - FrozenUnit::Struct { - docstring: None, - parameters: vec![], - name: "User".to_string(), - fields: vec![ - FrozenUnit::Field { - docstring: None, - parameters: vec![], - optional: false, - name: "id".to_string(), - kind_value: KindValue::Namespaced("s32".to_string(), None), - span: (0, 0), - }, - FrozenUnit::Field { - docstring: None, - parameters: vec![], - optional: false, - name: "username".to_string(), - kind_value: KindValue::Namespaced("string".to_string(), None), - span: (0, 0), - }, - FrozenUnit::Field { - docstring: None, - parameters: vec![], - optional: false, - name: "tags".to_string(), - kind_value: KindValue::Namespaced("string[]".to_string(), None), - span: (0, 0), - } - ], - span: (0, 0), - } - ]; - - let output = generate_rust(&units); - - assert!(output.contains("pub struct User")); - assert!(output.contains("pub id: i32")); - assert!(output.contains("pub username: String")); - assert!(output.contains("pub tags: Vec")); -} - -#[test] -fn test_generate_enum() { - let units = vec![ - FrozenUnit::Enum { - docstring: None, - name: "Status".to_string(), - variants: vec![ - FrozenUnit::EnumVariant(KindValue::EnumVariant("Active".to_string(), None), (0, 0)), - FrozenUnit::EnumVariant(KindValue::EnumVariant("Inactive".to_string(), None), (0, 0)), - ], - span: (0, 0), - } - ]; - - let output = generate_rust(&units); - - assert!(output.contains("pub enum Status")); - assert!(output.contains("Active,")); - assert!(output.contains("Inactive,")); -} - -#[test] -fn test_generate_protocol() { - let units = vec![ - FrozenUnit::Protocol { - docstring: "A user service".to_string(), - name: "UserService".to_string(), - parameters: vec![], - functions: vec![ - FrozenUnit::Function { - docstring: "".to_string(), - name: "get_user".to_string(), - synchronous: true, - arguments: vec![ - FrozenArgument { - name: "id".to_string(), - kind: KindValue::Primitive(Primitive::S32(None)), - span: (0, 0), - } - ], - _return: Some(KindValue::Namespaced("User".to_string(), None)), - throws: vec![], - span: (0, 0), - } - ], - span: (0, 0), - } - ]; - - let output = generate_rust(&units); - - assert!(output.contains("pub trait UserService")); - assert!(output.contains("fn get_user(id: i32) -> User;")); -} diff --git a/core/tests/mod.rs b/core/tests/mod.rs index 98d7530..373cda5 100644 --- a/core/tests/mod.rs +++ b/core/tests/mod.rs @@ -3,5 +3,4 @@ mod package_config; mod package; // Contains schema_loading test mod autodoc; mod utils; -mod codelib_gen; mod cas;