feat(ir): drop Function.synchronous, add Function.parameters, KindValue::Unit

core/src/schema/idl/grammar.rs

@@ -710,6 +710,17 @@ pub mod grammar {
         Named(ScopedIdentifier),
         Array(Box<ArrayType>),
         Union(UnionType),
+        Unit(UnitType),
+    }
+
+    /// The unit type `()` - an explicit "reply, but no value" (an empty ack),
+    /// distinct from omitting `->` entirely, which means "no reply at all".
+    #[derive(Debug, Clone)]
+    pub struct UnitType {
+        #[rust_sitter::leaf(text = "(")]
+        _open: (),
+        #[rust_sitter::leaf(text = ")")]
+        _close: (),
     }
 
     /// Array type: Type[] or Type[SIZE]

core/src/schema/ir/compiler/interpreted/kind_search.rs

@@ -99,7 +99,10 @@ pub enum KindValue {
     Primitive(Primitive),
     EnumVariant(String, Option<Box<KindValue>>),
     Union(Vec<KindValue>),
-    Namespaced(String, Option<Box<KindValue>>)
+    Namespaced(String, Option<Box<KindValue>>),
+    /// The unit type `()` - a reply carrying no value. Distinct from a
+    /// function with no `_return` at all (no reply).
+    Unit,
 }
 
 impl KindValue {
@@ -127,6 +130,7 @@ impl KindValue {
                 // TODO: Properly implement, it was testing at this stage
                 (namespace.clone(), None)
             }
+            KindValue::Unit => ("()".to_owned(), None),
         }
     }
 }

core/src/schema/ir/compiler/interpreter/incremental.rs

@@ -183,9 +183,9 @@ impl IncrementalInterpreter {
 
                             FrozenUnit::Function {
                                 name: func_name,
+                                parameters: annotation_units(&func.annotations()),
                                 arguments,
                                 _return: return_type,
-                                synchronous: true,
                                 docstring: func.docstring().unwrap_or_default(),
                                 throws: func.throws().into_iter().collect(),
                                 span: func.span,
@@ -371,6 +371,10 @@ fn build_kind_value(
         );
     }
 
+    if matches!(type_def, crate::schema::idl::grammar::Type::Unit(_)) {
+        return KindValue::Unit;
+    }
+
     let type_name = type_to_string(type_def);
 
     match (type_name.as_str(), value) {
@@ -415,6 +419,7 @@ fn type_to_string(type_def: &crate::schema::idl::grammar::Type) -> String {
             let members: Vec<String> = union_type.members().iter().map(type_to_string).collect();
             format!("union({})", members.join(" "))
         }
+        crate::schema::idl::grammar::Type::Unit(_) => "()".to_string(),
     }
 }
 

core/src/schema/ir/diff.rs

@@ -544,6 +544,7 @@ fn kind_to_string(kind: &KindValue) -> String {
             let parts: Vec<String> = members.iter().map(kind_to_string).collect();
             format!("union({})", parts.join(" | "))
         }
+        KindValue::Unit => "()".to_string(),
     }
 }
 

core/src/schema/ir/frozen/unit.rs

@@ -81,8 +81,12 @@ pub enum FrozenUnit {
     },
     Function {
         docstring: String,
+        // `@key = value` function annotations (per-call settings: `@timeout_ms`,
+        // `@idempotent`, ...) as `Property { name, expression }`, same shape as
+        // `Protocol` / `Struct` carry. Open namespace - a consumer acts on the
+        // keys it knows and ignores the rest.
+        parameters: Vec<FrozenUnit>,
         name: String,
-        synchronous: bool,
         // direction: Box<FrozenUnit>,
         arguments: Vec<FrozenArgument>,
         _return: Option<KindValue>,

core/src/schema/ir/validation/validator.rs

@@ -401,6 +401,9 @@ fn validate_type(
             // type today (it's only ever used to represent one variant inside
             // an Enum's own `variants` list, not as a referenceable type).
         }
+        KindValue::Unit => {
+            // `()` - the empty-reply type. Nothing to resolve.
+        }
     }
 }
 

core/tests/schema/ir/generation.rs

@@ -403,6 +403,48 @@ protocol EventService {
         }
     }
 
+    #[test]
+    fn test_protocol_unit_return_ir() {
+        // `-> ()` freezes as `_return: Some(KindValue::Unit)` - an empty
+        // reply - where a function with no `->` freezes as `_return: None`.
+        use comline_core::schema::ir::compiler::interpreted::kind_search::KindValue;
+
+        let code = r#"
+protocol TxService {
+    function commit() -> ();
+    function log(str);
+}
+"#;
+        let ir_units = IncrementalInterpreter::from_source(code);
+        match &ir_units[0] {
+            comline_core::schema::ir::frozen::unit::FrozenUnit::Protocol { functions, .. } => {
+                match &functions[0] {
+                    comline_core::schema::ir::frozen::unit::FrozenUnit::Function {
+                        name,
+                        _return,
+                        ..
+                    } => {
+                        assert_eq!(name, "commit");
+                        assert_eq!(_return, &Some(KindValue::Unit));
+                    }
+                    _ => panic!("Expected Function"),
+                }
+                match &functions[1] {
+                    comline_core::schema::ir::frozen::unit::FrozenUnit::Function {
+                        name,
+                        _return,
+                        ..
+                    } => {
+                        assert_eq!(name, "log");
+                        assert_eq!(_return, &None);
+                    }
+                    _ => panic!("Expected Function"),
+                }
+            }
+            _ => panic!("Expected Protocol"),
+        }
+    }
+
     #[test]
     fn test_struct_and_field_spans_are_populated() {
         let code = "struct User {\n    id: u64\n    name: str\n}\n";

core/tests/schema/parser/comprehensive.rs

@@ -363,6 +363,13 @@ enum DayOfWeek {
         assert!(grammar::parse(code).is_ok());
     }
 
+    #[test]
+    fn test_protocol_unit_return() {
+        // `-> ()` is an explicit empty reply, distinct from no `->` at all.
+        let code = "protocol API { function commit() -> (); }";
+        assert!(grammar::parse(code).is_ok());
+    }
+
     #[test]
     fn test_protocol_multiple_args() {
         let code = "protocol API { function process(str, u32, bool) -> s64; }";