From 4b63fc8be716d0139c98844618c2655c81d14678 Mon Sep 17 00:00:00 2001 From: Kinflou Date: Tue, 3 Nov 2026 19:45:32 +0800 Subject: [PATCH 1/3] deps: move to the bounded core, generation, generators and language server (core#98 step 10) --- app/src/sim/shape.ts | 2 +- fixtures/generators/Cargo.toml | 2 +- wasm/Cargo.toml | 10 +- wasm/src/lib.rs | 447 ++++++++++++++++++++++++++------- 4 files changed, 368 insertions(+), 93 deletions(-) diff --git a/app/src/sim/shape.ts b/app/src/sim/shape.ts index f6f9fb9..e0de842 100644 --- a/app/src/sim/shape.ts +++ b/app/src/sim/shape.ts @@ -68,7 +68,7 @@ export type TypeRef = | { kind: "prim"; name: string } | { kind: "ref"; name: string } /** `len` is a fixed array's length (`u8[4]`); absent for `T[]`. */ - | { kind: "array"; of: TypeRef; len?: number } + | { kind: "array"; of: TypeRef; len?: number; max?: number } | { kind: "unit" } | { kind: "union"; of: TypeRef[] }; diff --git a/fixtures/generators/Cargo.toml b/fixtures/generators/Cargo.toml index c0fb32c..3a0b368 100644 --- a/fixtures/generators/Cargo.toml +++ b/fixtures/generators/Cargo.toml @@ -11,7 +11,7 @@ publish = false [dependencies] # The rev wasm/Cargo.toml pins, so the protocol and IR format match. -comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "ac4425c32f88f98a2a3bfb971a209c173c6559a8" } +comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "32ed2254ca36d2614862aa4b33da0bc50f2334bc" } [profile.release] opt-level = "s" diff --git a/wasm/Cargo.toml b/wasm/Cargo.toml index 23fa8a8..aaeb72f 100644 --- a/wasm/Cargo.toml +++ b/wasm/Cargo.toml @@ -12,13 +12,13 @@ crate-type = ["cdylib", "rlib"] # The same crates the CLI and the language server compose — by git rev, so the # playground runs *that* code, not a re-implementation. Keep the `comline-core` # rev identical across all of them (one `comline-core` in the tree). -comline-core = { git = "https://github.com/ComlineProject/core", rev = "525939352b79538ce5e9b41ae6713ee6bd26a25e" } -comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "ac4425c32f88f98a2a3bfb971a209c173c6559a8" } -comline-codegen-rust = { git = "https://github.com/ComlineProject/comline-rust", rev = "8d0d659d100d41d64d203a7890a6b15471cde802" } -comline-codegen-typescript = { git = "https://github.com/ComlineProject/comline-typescript", rev = "37cd70f96260325f37a39be6a15cb858d2e069dc" } +comline-core = { git = "https://github.com/ComlineProject/core", rev = "8f5dc91f1c1c91e192585c3e4b80128621047499" } +comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "32ed2254ca36d2614862aa4b33da0bc50f2334bc" } +comline-codegen-rust = { git = "https://github.com/ComlineProject/comline-rust", rev = "ed48badcb8a89e1ba42cea21a02a3bfb1c498b44" } +comline-codegen-typescript = { git = "https://github.com/ComlineProject/comline-typescript", rev = "3b8f5feb0e0a74db36379652463e957f2a5d11f8" } # The LSP's analysis layer (diagnostics / hover / completion / semantic tokens), # without its `tower-lsp` server — builds for wasm32. -comline-language-server = { git = "https://github.com/ComlineProject/language-server", rev = "2c123328723d34f2a7d4be6df6bf9a3f9194c699", default-features = false } +comline-language-server = { git = "https://github.com/ComlineProject/language-server", rev = "78b2d185ef36fb116ea2845e7dc981b84d944c63", default-features = false } lsp-types = "0.94" rust-sitter = "0.4.5" # parse-error types diff --git a/wasm/src/lib.rs b/wasm/src/lib.rs index c95684d..0e2ca82 100644 --- a/wasm/src/lib.rs +++ b/wasm/src/lib.rs @@ -29,15 +29,17 @@ use comline_core::package::config::ir::frozen::FrozenUnit as ConfigUnit; use comline_core::package::config::ir::interpreter::ProjectInterpreter; use comline_core::schema::idl::annotations::{FramingValue, DEFAULT_FORMAT, DEFAULT_FRAMING}; use comline_core::schema::idl::grammar::Declaration; -use comline_core::schema::ir::frozen::types::TypeRef as FrozenType; use comline_core::schema::ir::compiler::interpreter::incremental::IncrementalInterpreter; use comline_core::schema::ir::context::SchemaContext; use comline_core::schema::ir::frozen::schema_ir_hash; +use comline_core::schema::ir::frozen::types::{PrimitiveType, TypeRef as FrozenType}; use comline_core::schema::ir::frozen::unit::FrozenUnit; use comline_core::schema::ir::validation; use comline_core::utils::codemap::CodeMap; -use comline_codegen::protocol::{self, Description, FileOut, LanguageInfo, Request, Response, TargetLanguage}; +use comline_codegen::protocol::{ + self, Description, FileOut, LanguageInfo, Request, Response, TargetLanguage, +}; use comline_codegen::versions::LangVersion; use comline_codegen::{GenerateRequest, Mode, PackageMeta}; @@ -142,7 +144,12 @@ struct GenerateResult { pub fn generate_project(files: JsValue, target: &str, mode: &str) -> JsValue { let req = match generate_request(files, target, mode) { Ok(req) => req, - Err(error) => return to_js(&GenerateResult { files: vec![], error: Some(error) }), + Err(error) => { + return to_js(&GenerateResult { + files: vec![], + error: Some(error), + }) + } }; let generated = match req.target.language.as_str() { @@ -178,7 +185,10 @@ struct EncodedRequest { /// `Option>` as a `Uint8Array` (or `null`), not an array of numbers. mod serde_bytes_opt { - pub fn serialize(bytes: &Option>, s: S) -> Result { + pub fn serialize( + bytes: &Option>, + s: S, + ) -> Result { match bytes { Some(bytes) => s.serialize_bytes(bytes), None => s.serialize_none(), @@ -192,11 +202,19 @@ mod serde_bytes_opt { /// or `{ request: null, error }`. #[wasm_bindgen] pub fn encode_request(files: JsValue, target: &str, mode: &str) -> JsValue { - let encoded = generate_request(files, target, mode) - .and_then(|req| protocol::encode(&Request::generate(req)).map_err(|e| format!("the request doesn't encode: {e}"))); + let encoded = generate_request(files, target, mode).and_then(|req| { + protocol::encode(&Request::generate(req)) + .map_err(|e| format!("the request doesn't encode: {e}")) + }); to_js(&match encoded { - Ok(request) => EncodedRequest { request: Some(request), error: None }, - Err(error) => EncodedRequest { request: None, error: Some(error) }, + Ok(request) => EncodedRequest { + request: Some(request), + error: None, + }, + Err(error) => EncodedRequest { + request: None, + error: Some(error), + }, }) } @@ -214,11 +232,17 @@ pub fn decode_response(bytes: &[u8]) -> JsValue { Ok(files) => GenerateResult { files: files .into_iter() - .map(|f| GeneratedFile { contents: String::from_utf8_lossy(&f.contents).into_owned(), path: f.path }) + .map(|f| GeneratedFile { + contents: String::from_utf8_lossy(&f.contents).into_owned(), + path: f.path, + }) .collect(), error: None, }, - Err(error) => GenerateResult { files: vec![], error: Some(error) }, + Err(error) => GenerateResult { + files: vec![], + error: Some(error), + }, }; to_js(&result) } @@ -262,17 +286,33 @@ struct CheckedDescription { #[wasm_bindgen] pub fn check_description(bytes: &[u8], who: &str, target: &str) -> JsValue { to_js(&match checked_description(bytes, who, target) { - Ok(info) => CheckedDescription { language: Some(info.id.clone()), floor: Some(info.versions.floor.clone()), error: None }, - Err(error) => CheckedDescription { language: None, floor: None, error: Some(error) }, + Ok(info) => CheckedDescription { + language: Some(info.id.clone()), + floor: Some(info.versions.floor.clone()), + error: None, + }, + Err(error) => CheckedDescription { + language: None, + floor: None, + error: Some(error), + }, }) } fn checked_description(bytes: &[u8], who: &str, target: &str) -> Result { let description = match protocol::decode::(bytes) { Ok(Response::Describe(d)) => d, - Ok(Response::Error { message }) => return Err(format!("{who} refused to describe itself: {message}")), - Ok(Response::Generate(_) | Response::Render(_)) => return Err(format!("{who} answered `Describe` with generated files")), - Err(e) => return Err(format!("{who} answered with something that isn't a protocol response: {e}")), + Ok(Response::Error { message }) => { + return Err(format!("{who} refused to describe itself: {message}")) + } + Ok(Response::Generate(_) | Response::Render(_)) => { + return Err(format!("{who} answered `Describe` with generated files")) + } + Err(e) => { + return Err(format!( + "{who} answered with something that isn't a protocol response: {e}" + )) + } }; check_versions(&description, who)?; let (language, version) = target_language(target)?; @@ -284,8 +324,14 @@ fn check_versions(description: &Description, who: &str) -> Result<(), String> { let (min, max) = description.protocols; let ours = protocol::PROTOCOL_VERSION; if !(min..=max).contains(&ours) { - let theirs = if min == max { min.to_string() } else { format!("{min} to {max}") }; - return Err(format!("{who} speaks generator protocol {theirs}, and this playground speaks protocol {ours}")); + let theirs = if min == max { + min.to_string() + } else { + format!("{min} to {max}") + }; + return Err(format!( + "{who} speaks generator protocol {theirs}, and this playground speaks protocol {ours}" + )); } let ir = protocol::IR_FORMAT; if !description.ir_formats.contains(&ir) { @@ -309,9 +355,17 @@ fn list(items: impl Iterator) -> String { /// The entry of `description` for `language#version`: the newest floor at /// or below the version. The CLI's `external::select`. -fn select<'d>(who: &str, description: &'d Description, language: &str, version: &str) -> Result<&'d LanguageInfo, String> { - let offered: Vec<&LanguageInfo> = - description.languages.iter().filter(|l| l.id.eq_ignore_ascii_case(language)).collect(); +fn select<'d>( + who: &str, + description: &'d Description, + language: &str, + version: &str, +) -> Result<&'d LanguageInfo, String> { + let offered: Vec<&LanguageInfo> = description + .languages + .iter() + .filter(|l| l.id.eq_ignore_ascii_case(language)) + .collect(); if offered.is_empty() { return Err(format!( "{who} doesn't generate `{language}`; it offers {}", @@ -352,19 +406,30 @@ fn checked_files(bytes: &[u8], cap: usize) -> Result, String> { let generated = match protocol::decode::(bytes) { Ok(Response::Generate(generated)) => generated, Ok(Response::Error { message }) => return Err(format!("{who}: {message}")), - Ok(Response::Describe(_)) => return Err(format!("{who} answered `Generate` with a description")), - Ok(Response::Render(_)) => return Err(format!("{who} answered `Generate` with rendered documentation")), + Ok(Response::Describe(_)) => { + return Err(format!("{who} answered `Generate` with a description")) + } + Ok(Response::Render(_)) => { + return Err(format!( + "{who} answered `Generate` with rendered documentation" + )) + } Err(e) => return Err(format!("{who}'s response doesn't decode: {e}")), }; let mut total = 0usize; for file in &generated.files { check_path(&file.path).map_err(|why| { - format!("{who} returned the path `{}`, which {why}; nothing was written", file.path.escape_debug()) + format!( + "{who} returned the path `{}`, which {why}; nothing was written", + file.path.escape_debug() + ) })?; total = total.saturating_add(file.contents.len()); } if total > cap { - return Err(format!("{who} generated {total} bytes, over the {cap}-byte limit; nothing was written")); + return Err(format!( + "{who} generated {total} bytes, over the {cap}-byte limit; nothing was written" + )); } Ok(generated.files) } @@ -402,7 +467,8 @@ fn check_path(path: &str) -> Result<(), &'static str> { /// packages are in memory, and core refuses `encodings` there), with no /// `comline.toml` overrides. fn generate_request(files: JsValue, target: &str, mode: &str) -> Result { - let files: Vec = serde_wasm_bindgen::from_value(files).map_err(|e| format!("bad file list: {e}"))?; + let files: Vec = + serde_wasm_bindgen::from_value(files).map_err(|e| format!("bad file list: {e}"))?; let (_, schemas, declared) = interpret_project(&files); if schemas.is_empty() { return Err("no schema parses".to_string()); @@ -422,7 +488,10 @@ fn generate_request(files: JsValue, target: &str, mode: &str) -> Result Result (CompileProjectResult, Vec<(String, Vec)>, Vec) { +) -> ( + CompileProjectResult, + Vec<(String, Vec)>, + Vec, +) { let mut context = ProjectInterpreter::from_config_source(CONGREGATION).expect("static congregation parses"); // The encodings the package declares, for `encodings::fill`. The @@ -486,11 +559,19 @@ fn interpret_project( let decls = pr.document.map(|d| d.0); if let Some(decls) = &decls { - context.schema_contexts.push(Rc::new(RefCell::new( - SchemaContext::with_declarations(decls.clone(), segments.clone(), CodeMap::new()), - ))); + context + .schema_contexts + .push(Rc::new(RefCell::new(SchemaContext::with_declarations( + decls.clone(), + segments.clone(), + CodeMap::new(), + )))); } - parsed.push(Parsed { segments, decls, parse_diags }); + parsed.push(Parsed { + segments, + decls, + parse_diags, + }); } // Second pass: interpret + validate each file against the whole context. @@ -521,11 +602,17 @@ fn interpret_project( // prints; only the `Err` arm means the schema would fail to build. let (diagnostics, ok) = match validation::validate(&units) { Ok(warnings) => ( - warnings.into_iter().map(|w| validation_diagnostic(&f.source, w)).collect(), + warnings + .into_iter() + .map(|w| validation_diagnostic(&f.source, w)) + .collect(), true, ), Err(errors) => ( - errors.into_iter().map(|e| validation_diagnostic(&f.source, e)).collect(), + errors + .into_iter() + .map(|e| validation_diagnostic(&f.source, e)) + .collect(), false, ), }; @@ -678,11 +765,20 @@ struct FieldShape { #[derive(Serialize)] #[serde(tag = "kind", rename_all = "lowercase")] enum TypeDef { - Struct { name: String, fields: Vec }, - Enum { name: String, variants: Vec }, + Struct { + name: String, + fields: Vec, + }, + Enum { + name: String, + variants: Vec, + }, /// `type Name = target`: a name for another type, so a field of this /// type renders as, and encodes as, the target. - Alias { name: String, of: TypeRef }, + Alias { + name: String, + of: TypeRef, + }, } /// A type reference in a signature: core's frozen `TypeRef`, with each named @@ -690,16 +786,25 @@ enum TypeDef { #[derive(Serialize)] #[serde(tag = "kind", rename_all = "lowercase")] enum TypeRef { - Prim { name: String }, - Ref { name: String }, - /// `len` is a fixed array's length (`u8[4]`); absent for `T[]`. + Prim { + name: String, + }, + Ref { + name: String, + }, + /// `len` is a fixed array's length (`u8[4]`), `max` a bounded one's + /// maximum (`u8[max 4]`); both absent for an unbounded `T[]`. Array { of: Box, #[serde(skip_serializing_if = "Option::is_none")] len: Option, + #[serde(skip_serializing_if = "Option::is_none")] + max: Option, }, Unit, - Union { of: Vec }, + Union { + of: Vec, + }, } /// Parse and freeze every file, then describe each frozen schema's protocols, @@ -736,11 +841,20 @@ fn describe_schema(ns_path: &str, units: &[FrozenUnit], known: &HashSet<&str>) - let errors: Vec = units .iter() .filter_map(|u| match u { - FrozenUnit::Error { ordinal, name, message, fields, .. } => Some(ErrorShape { + FrozenUnit::Error { + ordinal, + name, + message, + fields, + .. + } => Some(ErrorShape { ordinal: *ordinal, name: name.clone(), message: message.clone(), - fields: fields.iter().filter_map(|f| field_shape(f, known)).collect(), + fields: fields + .iter() + .filter_map(|f| field_shape(f, known)) + .collect(), }), _ => None, }) @@ -751,7 +865,10 @@ fn describe_schema(ns_path: &str, units: &[FrozenUnit], known: &HashSet<&str>) - .filter_map(|u| match u { FrozenUnit::Struct { name, fields, .. } => Some(TypeDef::Struct { name: name.clone(), - fields: fields.iter().filter_map(|f| field_shape(f, known)).collect(), + fields: fields + .iter() + .filter_map(|f| field_shape(f, known)) + .collect(), }), FrozenUnit::Enum { name, variants, .. } => Some(TypeDef::Enum { name: name.clone(), @@ -768,7 +885,12 @@ fn describe_schema(ns_path: &str, units: &[FrozenUnit], known: &HashSet<&str>) - let protocols = units .iter() .filter_map(|u| match u { - FrozenUnit::Protocol { name, parameters, functions, .. } => Some(ProtocolShape { + FrozenUnit::Protocol { + name, + parameters, + functions, + .. + } => Some(ProtocolShape { name: name.clone(), framing: framing_of(parameters), functions: functions @@ -805,12 +927,16 @@ fn describe_schema(ns_path: &str, units: &[FrozenUnit], known: &HashSet<&str>) - /// already written into it when the package declares one, else the /// built-in default, `datagram@2`. fn framing_of(params: &[FrozenUnit]) -> String { - FramingValue::of_protocol(params).map_or(DEFAULT_FRAMING, |f| f.name).to_string() + FramingValue::of_protocol(params) + .map_or(DEFAULT_FRAMING, |f| f.name) + .to_string() } fn field_shape(u: &FrozenUnit, known: &HashSet<&str>) -> Option { match u { - FrozenUnit::Field { name, ty, optional, .. } => Some(FieldShape { + FrozenUnit::Field { + name, ty, optional, .. + } => Some(FieldShape { name: name.clone(), ty: type_ref(ty, known), optional: *optional, @@ -826,15 +952,29 @@ fn enum_variant_name(u: &FrozenUnit) -> Option { } } -fn fn_shape(index: u32, u: &FrozenUnit, errors: &[ErrorShape], known: &HashSet<&str>) -> Option { +fn fn_shape( + index: u32, + u: &FrozenUnit, + errors: &[ErrorShape], + known: &HashSet<&str>, +) -> Option { match u { - FrozenUnit::Function { name, arguments, _return, throws, .. } => Some(FnShape { + FrozenUnit::Function { + name, + arguments, + _return, + throws, + .. + } => Some(FnShape { name: name.clone(), index, oneway: _return.is_none(), args: arguments .iter() - .map(|a| ArgShape { name: a.name.clone(), ty: type_ref(&a.ty, known) }) + .map(|a| ArgShape { + name: a.name.clone(), + ty: type_ref(&a.ty, known), + }) .collect(), returns: _return.as_ref().map(|k| type_ref(k, known)), throws: throws @@ -864,10 +1004,25 @@ fn type_ref(ty: &FrozenType, known: &HashSet<&str>) -> TypeRef { FrozenType::Union(members) => TypeRef::Union { of: members.iter().map(|m| type_ref(m, known)).collect(), }, - FrozenType::Primitive(p) => TypeRef::Prim { name: p.name().to_string() }, - FrozenType::Array { element, length } => TypeRef::Array { + FrozenType::Primitive(p) => TypeRef::Prim { + name: p.name().to_string(), + }, + // Text is an array of `char` (`char[max 64]`): one string input. + FrozenType::Array { element, .. } + if matches!(**element, FrozenType::Primitive(PrimitiveType::Char)) => + { + TypeRef::Prim { + name: "string".to_string(), + } + } + FrozenType::Array { + element, + length, + max, + } => TypeRef::Array { of: Box::new(type_ref(element, known)), len: *length, + max: *max, }, FrozenType::Named(n) if known.contains(n.as_str()) => TypeRef::Ref { name: n.clone() }, FrozenType::Named(n) => TypeRef::Prim { name: n.clone() }, @@ -930,33 +1085,70 @@ mod tests { for good in ["a.rs", "src/lib.rs", "a/b/c.ts", "..a", "a.."] { assert_eq!(check_path(good), Ok(()), "{good}"); } - for bad in ["", "/etc/passwd", "../x", "a/../b", "./a", "a//b", "a/", "a\\b", "c:/x", "a/b:c", "a\0b"] { + for bad in [ + "", + "/etc/passwd", + "../x", + "a/../b", + "./a", + "a//b", + "a/", + "a\\b", + "c:/x", + "a/b:c", + "a\0b", + ] { assert!(check_path(bad).is_err(), "{bad:?}"); } } fn response(files: Vec) -> Vec { - protocol::encode(&Response::Generate(protocol::Generated { files, diagnostics: vec![] })).unwrap() + protocol::encode(&Response::Generate(protocol::Generated { + files, + diagnostics: vec![], + })) + .unwrap() } #[test] fn a_bad_path_refuses_the_whole_response() { let files = vec![ - FileOut { path: "ok.rs".into(), contents: b"fine".to_vec() }, - FileOut { path: "../escape.rs".into(), contents: vec![] }, + FileOut { + path: "ok.rs".into(), + contents: b"fine".to_vec(), + }, + FileOut { + path: "../escape.rs".into(), + contents: vec![], + }, ]; let error = checked_files(&response(files), GENERATED_CAP).unwrap_err(); - assert!(error.contains("`../escape.rs`") && error.contains("nothing was written"), "{error}"); + assert!( + error.contains("`../escape.rs`") && error.contains("nothing was written"), + "{error}" + ); } #[test] fn an_error_response_or_garbage_is_refused() { - let error = protocol::encode(&Response::Error { message: "no".into() }).unwrap(); - assert_eq!(checked_files(&error, GENERATED_CAP).unwrap_err(), "the generator: no"); - assert!(checked_files(b"not cbor", GENERATED_CAP).unwrap_err().contains("doesn't decode")); + let error = protocol::encode(&Response::Error { + message: "no".into(), + }) + .unwrap(); + assert_eq!( + checked_files(&error, GENERATED_CAP).unwrap_err(), + "the generator: no" + ); + assert!(checked_files(b"not cbor", GENERATED_CAP) + .unwrap_err() + .contains("doesn't decode")); } - fn description(protocols: (u32, u32), ir_formats: Vec, languages: &[(&str, &str)]) -> Vec { + fn description( + protocols: (u32, u32), + ir_formats: Vec, + languages: &[(&str, &str)], + ) -> Vec { let languages = languages .iter() .map(|(id, floor)| LanguageInfo { @@ -971,7 +1163,13 @@ mod tests { support: vec![], }) .collect(); - protocol::encode(&Response::Describe(Description { languages, protocols, ir_formats, renderers: vec![] })).unwrap() + protocol::encode(&Response::Describe(Description { + languages, + protocols, + ir_formats, + renderers: vec![], + })) + .unwrap() } const WHO: &str = "generator `g.wasm`"; @@ -979,34 +1177,87 @@ mod tests { #[test] fn a_description_is_checked_as_the_cli_checks_it() { let (p, ir) = (protocol::PROTOCOL_VERSION, protocol::IR_FORMAT); - let good = description((p, p), vec![ir], &[("rust", "1.0.0"), ("rust", "1.80.0"), ("rust", "9.0.0")]); + let good = description( + (p, p), + vec![ir], + &[("rust", "1.0.0"), ("rust", "1.80.0"), ("rust", "9.0.0")], + ); let picked = checked_description(&good, WHO, "rust").unwrap(); assert_eq!(picked.versions.floor, "1.80.0"); - let error = checked_description(&description((7, 7), vec![ir], &[("rust", "1.0.0")]), WHO, "rust").unwrap_err(); - assert_eq!(error, format!("{WHO} speaks generator protocol 7, and this playground speaks protocol {p}")); - let error = checked_description(&description((p + 1, p + 3), vec![ir], &[]), WHO, "rust").unwrap_err(); - assert!(error.contains(&format!("protocol {} to {}", p + 1, p + 3)), "{error}"); + let error = checked_description( + &description((7, 7), vec![ir], &[("rust", "1.0.0")]), + WHO, + "rust", + ) + .unwrap_err(); + assert_eq!( + error, + format!("{WHO} speaks generator protocol 7, and this playground speaks protocol {p}") + ); + let error = checked_description(&description((p + 1, p + 3), vec![ir], &[]), WHO, "rust") + .unwrap_err(); + assert!( + error.contains(&format!("protocol {} to {}", p + 1, p + 3)), + "{error}" + ); - let error = checked_description(&description((p, p), vec![ir + 1], &[("rust", "1.0.0")]), WHO, "rust").unwrap_err(); - assert_eq!(error, format!("{WHO} reads IR format {}, and this playground writes IR format {ir}", ir + 1)); + let error = checked_description( + &description((p, p), vec![ir + 1], &[("rust", "1.0.0")]), + WHO, + "rust", + ) + .unwrap_err(); + assert_eq!( + error, + format!( + "{WHO} reads IR format {}, and this playground writes IR format {ir}", + ir + 1 + ) + ); - let error = checked_description(&description((p, p), vec![ir], &[("go", "1.0")]), WHO, "rust").unwrap_err(); - assert_eq!(error, format!("{WHO} doesn't generate `rust`; it offers `go`")); + let error = checked_description( + &description((p, p), vec![ir], &[("go", "1.0")]), + WHO, + "rust", + ) + .unwrap_err(); + assert_eq!( + error, + format!("{WHO} doesn't generate `rust`; it offers `go`") + ); - let error = checked_description(&description((p, p), vec![ir], &[("rust", "9.0.0")]), WHO, "rust").unwrap_err(); + let error = checked_description( + &description((p, p), vec![ir], &[("rust", "9.0.0")]), + WHO, + "rust", + ) + .unwrap_err(); assert_eq!( error, - format!("{WHO} handles `rust` from `9.0.0` on, not `{}`", comline_codegen_rust::LANG_VERSION) + format!( + "{WHO} handles `rust` from `9.0.0` on, not `{}`", + comline_codegen_rust::LANG_VERSION + ) ); } #[test] fn a_description_that_isnt_one_is_refused() { - let error = protocol::encode(&Response::Error { message: "no".into() }).unwrap(); - assert_eq!(checked_description(&error, WHO, "rust").unwrap_err(), format!("{WHO} refused to describe itself: no")); - assert!(checked_description(&response(vec![]), WHO, "rust").unwrap_err().contains("with generated files")); - assert!(checked_description(b"junk", WHO, "rust").unwrap_err().contains("isn't a protocol response")); + let error = protocol::encode(&Response::Error { + message: "no".into(), + }) + .unwrap(); + assert_eq!( + checked_description(&error, WHO, "rust").unwrap_err(), + format!("{WHO} refused to describe itself: no") + ); + assert!(checked_description(&response(vec![]), WHO, "rust") + .unwrap_err() + .contains("with generated files")); + assert!(checked_description(b"junk", WHO, "rust") + .unwrap_err() + .contains("isn't a protocol response")); } #[test] @@ -1018,12 +1269,20 @@ mod tests { #[test] fn output_over_the_cap_is_refused() { let files = vec![ - FileOut { path: "a".into(), contents: vec![0; 8] }, - FileOut { path: "b".into(), contents: vec![0; 9] }, + FileOut { + path: "a".into(), + contents: vec![0; 8], + }, + FileOut { + path: "b".into(), + contents: vec![0; 9], + }, ]; let bytes = response(files); assert_eq!(checked_files(&bytes, 17).map(|f| f.len()), Ok(2)); - assert!(checked_files(&bytes, 16).unwrap_err().contains("over the 16-byte limit")); + assert!(checked_files(&bytes, 16) + .unwrap_err() + .contains("over the 16-byte limit")); } use comline_core::schema::ir::frozen::unit::ConfigValue; @@ -1041,10 +1300,18 @@ mod tests { // emit as JSON-RPC rendered as datagram in the playground - the // one place the two are compared side by side. for spelling in ["jsonrpc", "json-rpc", "jsonrpc-2.0"] { - assert_eq!(framing_of(&framing_param(spelling)), "jsonrpc", "{spelling}"); + assert_eq!( + framing_of(&framing_param(spelling)), + "jsonrpc", + "{spelling}" + ); } for spelling in ["datagram", "comline.datagram"] { - assert_eq!(framing_of(&framing_param(spelling)), "datagram", "{spelling}"); + assert_eq!( + framing_of(&framing_param(spelling)), + "datagram", + "{spelling}" + ); } } @@ -1054,7 +1321,10 @@ mod tests { name: "framing".to_string(), value: ConfigValue::Dict(vec![ ("name".to_string(), ConfigValue::Str("json-rpc".to_string())), - ("method_names".to_string(), ConfigValue::Name("qualified".to_string())), + ( + "method_names".to_string(), + ConfigValue::Name("qualified".to_string()), + ), ]), }]; assert_eq!(framing_of(&dict), "jsonrpc"); @@ -1064,8 +1334,7 @@ mod tests { fn a_type_alias_is_described_and_references_to_it_are_refs() { let files = vec![FileInput { path: "alias.ids".to_string(), - source: "type Handle = string\n\nstruct Account {\n owner: Handle\n}\n" - .to_string(), + source: "type Handle = string\n\nstruct Account {\n owner: Handle\n}\n".to_string(), }]; let (_, frozen, _) = interpret_project(&files); let known: HashSet<&str> = frozen @@ -1082,12 +1351,18 @@ mod tests { let schema = serde_json::to_value(describe_schema(ns, units, &known)).unwrap(); let types = schema["types"].as_array().unwrap(); - let alias = types.iter().find(|t| t["name"] == "Handle").expect("alias described"); + let alias = types + .iter() + .find(|t| t["name"] == "Handle") + .expect("alias described"); assert_eq!( *alias, serde_json::json!({"kind":"alias","name":"Handle","of":{"kind":"prim","name":"string"}}) ); - let account = types.iter().find(|t| t["name"] == "Account").expect("struct described"); + let account = types + .iter() + .find(|t| t["name"] == "Account") + .expect("struct described"); assert_eq!( account["fields"][0]["ty"], serde_json::json!({"kind":"ref","name":"Handle"}) From eae457bc4eb459ceebb308e134565eab53e2f082 Mon Sep 17 00:00:00 2001 From: Kinflou Date: Tue, 3 Nov 2026 19:46:28 +0800 Subject: [PATCH 2/3] deps: the language server's branch head --- wasm/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wasm/Cargo.toml b/wasm/Cargo.toml index aaeb72f..886bdc8 100644 --- a/wasm/Cargo.toml +++ b/wasm/Cargo.toml @@ -18,7 +18,7 @@ comline-codegen-rust = { git = "https://github.com/ComlineProject/comline-rust", comline-codegen-typescript = { git = "https://github.com/ComlineProject/comline-typescript", rev = "3b8f5feb0e0a74db36379652463e957f2a5d11f8" } # The LSP's analysis layer (diagnostics / hover / completion / semantic tokens), # without its `tower-lsp` server — builds for wasm32. -comline-language-server = { git = "https://github.com/ComlineProject/language-server", rev = "78b2d185ef36fb116ea2845e7dc981b84d944c63", default-features = false } +comline-language-server = { git = "https://github.com/ComlineProject/language-server", rev = "bb0fa4a86e0dd62c362e5a5a26891b1db4b4c371", default-features = false } lsp-types = "0.94" rust-sitter = "0.4.5" # parse-error types From f69185c410d3055d611f3eda99fcd5d1e5fc26a8 Mon Sep 17 00:00:00 2001 From: Kinflou Date: Tue, 3 Nov 2026 20:21:14 +0800 Subject: [PATCH 3/3] deps: generation, generators and language server with validate_on_decode = collect (core#98) --- fixtures/generators/Cargo.toml | 2 +- wasm/Cargo.toml | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/fixtures/generators/Cargo.toml b/fixtures/generators/Cargo.toml index 3a0b368..72abc71 100644 --- a/fixtures/generators/Cargo.toml +++ b/fixtures/generators/Cargo.toml @@ -11,7 +11,7 @@ publish = false [dependencies] # The rev wasm/Cargo.toml pins, so the protocol and IR format match. -comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "32ed2254ca36d2614862aa4b33da0bc50f2334bc" } +comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "c303722c447ded28d50d7cf32b3164916fa76e5f" } [profile.release] opt-level = "s" diff --git a/wasm/Cargo.toml b/wasm/Cargo.toml index 886bdc8..1bf31dd 100644 --- a/wasm/Cargo.toml +++ b/wasm/Cargo.toml @@ -13,12 +13,12 @@ crate-type = ["cdylib", "rlib"] # playground runs *that* code, not a re-implementation. Keep the `comline-core` # rev identical across all of them (one `comline-core` in the tree). comline-core = { git = "https://github.com/ComlineProject/core", rev = "8f5dc91f1c1c91e192585c3e4b80128621047499" } -comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "32ed2254ca36d2614862aa4b33da0bc50f2334bc" } -comline-codegen-rust = { git = "https://github.com/ComlineProject/comline-rust", rev = "ed48badcb8a89e1ba42cea21a02a3bfb1c498b44" } -comline-codegen-typescript = { git = "https://github.com/ComlineProject/comline-typescript", rev = "3b8f5feb0e0a74db36379652463e957f2a5d11f8" } +comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "c303722c447ded28d50d7cf32b3164916fa76e5f" } +comline-codegen-rust = { git = "https://github.com/ComlineProject/comline-rust", rev = "2d50fbff670d883c92c363793e888158bb15b7a0" } +comline-codegen-typescript = { git = "https://github.com/ComlineProject/comline-typescript", rev = "ea9b9e2c70bbd87d99cc028543f73c8ee7749e1c" } # The LSP's analysis layer (diagnostics / hover / completion / semantic tokens), # without its `tower-lsp` server — builds for wasm32. -comline-language-server = { git = "https://github.com/ComlineProject/language-server", rev = "bb0fa4a86e0dd62c362e5a5a26891b1db4b4c371", default-features = false } +comline-language-server = { git = "https://github.com/ComlineProject/language-server", rev = "91189530cdcb72dacb96eff6e2a67c3f14da8282", default-features = false } lsp-types = "0.94" rust-sitter = "0.4.5" # parse-error types