From 58b8d0c139baa9131f2b1e3df3b517cf08854abe Mon Sep 17 00:00:00 2001 From: Kinflou Date: Sat, 24 Oct 2026 23:13:45 +0800 Subject: [PATCH] build proves every declared target; generate resolves by floor comline build checks each language config.idp declares before freezing (core's build_with): a generator handles the version, no dependency declares a higher one, every feature the schemas use is supported there, and past the verified range it warns under generation::unverified-version, which settings can raise to an error. A language this binary has no generator for fails the build. generate resolves through Registry::resolve with the same rules; comline.toml may raise lang_version, never lower it; targets prints each floor with its range; new scaffolds the Rust generator's floor. Fixtures and docs move to rust#1.85.0. --- Cargo.lock | 11 +- Cargo.toml | 10 +- docs/cli.md | 4 +- src/commands/add.rs | 2 +- src/commands/build.rs | 21 +- src/commands/generate.rs | 66 +++--- src/commands/new.rs | 19 +- src/commands/targets.rs | 43 +++- src/gen_config.rs | 120 +++++++---- src/lang_targets.rs | 223 ++++++++++++++++++++ src/main.rs | 1 + tests/cli/build.rs | 107 ++++++++++ tests/cli/generate.rs | 16 +- tests/cli/global.rs | 14 ++ tests/cli/new.rs | 2 + tests/fixtures/chat_project/config.idp | 2 +- tests/fixtures/simple_project/config.idp | 2 +- tests/fixtures/validated_project/config.idp | 2 +- 18 files changed, 554 insertions(+), 111 deletions(-) create mode 100644 src/lang_targets.rs diff --git a/Cargo.lock b/Cargo.lock index b90ecbf..dff2b8a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -381,6 +381,7 @@ dependencies = [ "comline-codegen-rust", "comline-codegen-typescript", "comline-core", + "eyre", "indicatif", "libc", "miette", @@ -398,7 +399,7 @@ dependencies = [ [[package]] name = "comline-codegen" version = "0.1.0" -source = "git+https://github.com/ComlineProject/generation?rev=dbb8530034cd2a8e6d390737b091e8bc2ca7029e#dbb8530034cd2a8e6d390737b091e8bc2ca7029e" +source = "git+https://github.com/ComlineProject/generation?rev=bbfadb25cd34f02974c69cc2f102e667a089f684#bbfadb25cd34f02974c69cc2f102e667a089f684" dependencies = [ "comline-core", "eyre", @@ -408,7 +409,7 @@ dependencies = [ [[package]] name = "comline-codegen-rust" version = "0.1.0" -source = "git+https://github.com/ComlineProject/comline-rust?rev=dbe579776327928a3b31c8a3fef1bbfea16c42ac#dbe579776327928a3b31c8a3fef1bbfea16c42ac" +source = "git+https://github.com/ComlineProject/comline-rust?rev=577bdb2910db8b3aedb6061f5436816836a08942#577bdb2910db8b3aedb6061f5436816836a08942" dependencies = [ "comline-codegen", "comline-core", @@ -418,7 +419,7 @@ dependencies = [ [[package]] name = "comline-codegen-typescript" version = "0.1.0" -source = "git+https://github.com/ComlineProject/comline-typescript?rev=c9b868084ef7a13618944e72ecdf16f91223982a#c9b868084ef7a13618944e72ecdf16f91223982a" +source = "git+https://github.com/ComlineProject/comline-typescript?rev=c72d14efa93135f892c04c6546f690a8e65b6cc1#c72d14efa93135f892c04c6546f690a8e65b6cc1" dependencies = [ "comline-codegen", "comline-core", @@ -428,7 +429,7 @@ dependencies = [ [[package]] name = "comline-core" version = "0.1.0" -source = "git+https://github.com/ComlineProject/core?rev=eb5802f2d8ab12fcf8f9b63afba10d71dcbbc98d#eb5802f2d8ab12fcf8f9b63afba10d71dcbbc98d" +source = "git+https://github.com/ComlineProject/core?rev=a3f9eef50c939b4cd5e7563f96d67c8db4012747#a3f9eef50c939b4cd5e7563f96d67c8db4012747" dependencies = [ "ariadne", "blake3", @@ -455,7 +456,7 @@ dependencies = [ [[package]] name = "comline-core-stdlib" version = "0.1.0" -source = "git+https://github.com/ComlineProject/core?rev=eb5802f2d8ab12fcf8f9b63afba10d71dcbbc98d#eb5802f2d8ab12fcf8f9b63afba10d71dcbbc98d" +source = "git+https://github.com/ComlineProject/core?rev=a3f9eef50c939b4cd5e7563f96d67c8db4012747#a3f9eef50c939b4cd5e7563f96d67c8db4012747" [[package]] name = "concolor" diff --git a/Cargo.toml b/Cargo.toml index 5aaee02..a16b212 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,21 +24,23 @@ tracing-subscriber = { version = "0.3.18", features = ["env-filter", "fmt"] } serde = { version = "1", features = ["derive"] } serde_json = "1.0" toml = "0.8" +# The error type of `comline-core`'s `build_with` check, which `build` passes. +eyre = "0.6.8" # git rev (not crates.io) so this and the `comline-codegen*` crates share one # `comline-core` in the tree. Local dev: see .cargo/config. `deps` is this # crate's opt-in: cross-package `dependencies = {...}` resolution (core#6) — # needs real I/O (git fetch, filesystem), so it's off by default for # `comline-core`'s wasm32 consumers (the playground editor, the language # server); the CLI is the one consumer that actually runs `comline build`. -comline-core = { git = "https://github.com/ComlineProject/core", rev = "eb5802f2d8ab12fcf8f9b63afba10d71dcbbc98d", features = ["deps"] } +comline-core = { git = "https://github.com/ComlineProject/core", rev = "a3f9eef50c939b4cd5e7563f96d67c8db4012747", features = ["deps"] } # All three pinned to revs that agree on one `comline-codegen`, and bumped # together: comline-rust and comline-typescript's codegen crates consume # `comline-codegen`'s types, so the rev below must be byte-identical to the # one *they* pin - Cargo only unifies a git dependency across identical rev # strings, and two copies of `GenRequest` are two incompatible types. -comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "dbb8530034cd2a8e6d390737b091e8bc2ca7029e" } -comline-codegen-rust = { git = "https://github.com/ComlineProject/comline-rust", rev = "dbe579776327928a3b31c8a3fef1bbfea16c42ac", optional = true } -comline-codegen-typescript = { git = "https://github.com/ComlineProject/comline-typescript", rev = "c9b868084ef7a13618944e72ecdf16f91223982a", optional = true } +comline-codegen = { git = "https://github.com/ComlineProject/generation", rev = "bbfadb25cd34f02974c69cc2f102e667a089f684" } +comline-codegen-rust = { git = "https://github.com/ComlineProject/comline-rust", rev = "577bdb2910db8b3aedb6061f5436816836a08942", optional = true } +comline-codegen-typescript = { git = "https://github.com/ComlineProject/comline-typescript", rev = "c72d14efa93135f892c04c6546f690a8e65b6cc1", optional = true } [features] # Which language generators are compiled in. Drop one to shed its whole diff --git a/docs/cli.md b/docs/cli.md index 186b90c..315698c 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -76,7 +76,7 @@ specification_version = 1 code_generation = { languages = { - rust#1.70.0 = {} + rust#1.85.0 = {} } } ``` @@ -305,7 +305,7 @@ comline -p ./schemas generate --target rust ``` • Generating code (in schemas/) - ⚙️ language: rust, version: 1.70.0 + ⚙️ language: rust, version: 1.85.0 main.ids → generated/rust/main.rs other.ids → generated/rust/other.rs ✓ Generated 2 file(s) diff --git a/src/commands/add.rs b/src/commands/add.rs index d91e74e..1de253d 100644 --- a/src/commands/add.rs +++ b/src/commands/add.rs @@ -489,7 +489,7 @@ mod tests { #[test] fn a_manifest_without_dependencies_gets_a_block_at_the_end() { - let manifest = format!("{HEAD}\ncode_generation = {{\n languages = {{\n rust#1.70.0 = {{}}\n }}\n}}\n"); + let manifest = format!("{HEAD}\ncode_generation = {{\n languages = {{\n rust#1.85.0 = {{}}\n }}\n}}\n"); assert_eq!( with_dependency(&manifest, "shared", &fields()), format!( diff --git a/src/commands/build.rs b/src/commands/build.rs index abd883f..8eae910 100644 --- a/src/commands/build.rs +++ b/src/commands/build.rs @@ -1,4 +1,9 @@ //! `comline build` — compile, validate and freeze a new immutable version. +//! +//! Before freezing, every target declared under `code_generation.languages` +//! is proven against the generators this binary was built with +//! ([`lang_targets::check_declared`]): a declaration is a promise consumers +//! rely on. use std::path::Path; @@ -6,7 +11,9 @@ use comline_core::package::build::{self, VersionBump}; use miette::Result; use crate::changes; +use crate::commands::generate::generator_registry; use crate::commands::{core_err, ensure_project}; +use crate::lang_targets; use crate::ui; use crate::watch; @@ -23,11 +30,21 @@ pub fn run(work_dir: &Path, watching: bool) -> Result<()> { fn build_once(work_dir: &Path) -> Result<()> { ui::step(format!("Building project{}", ui::at_path(work_dir))); let spinner = ui::spinner("compiling schemas"); - let result = build::build(work_dir); + let registry = generator_registry(); + let mut target_warnings = Vec::new(); + let result = build::build_with(work_dir, |context| { + target_warnings = lang_targets::check_declared(context, ®istry)?; + Ok(()) + }); ui::finish_spinner(spinner); let result = result.map_err(|e| core_err("build failed", e))?; - for warning in result.context.rendered_warnings() { + for warning in result + .context + .rendered_warnings() + .into_iter() + .chain(target_warnings) + { ui::warn(warning); } diff --git a/src/commands/generate.rs b/src/commands/generate.rs index 0ae14cd..c7978ee 100644 --- a/src/commands/generate.rs +++ b/src/commands/generate.rs @@ -12,7 +12,7 @@ use std::collections::BTreeMap; use std::path::{Path, PathBuf}; -use comline_codegen::{features, GenRequest, Mode, PackageMeta, Registry}; +use comline_codegen::{features, GenRequest, Mode, PackageMeta, Registry, Resolved, Unresolved}; use comline_core::package::build::{self, cas::ObjectStore}; use comline_core::package::config::ir::frozen::FrozenUnit as ConfigUnit; use comline_core::schema::idl::constants::SCHEMA_EXTENSION; @@ -21,6 +21,7 @@ use miette::{miette, IntoDiagnostic, Result, WrapErr}; use crate::commands::{core_err, ensure_project}; use crate::gen_config::{self, ComlineToml, DeclaredLang, Overrides, VersionSpec}; +use crate::lang_targets::{self, TargetError}; use crate::{history, ui, watch}; /// The generator registry, composed from the per-language `comline-codegen-*` @@ -87,19 +88,8 @@ fn generate_once(work_dir: &Path, overrides: &Overrides, dry_run: bool, list: bo return Ok(()); }; - // Languages the congregation declared: `rust#1.70.0` -> ("rust", "1.70.0"). - let declared: Vec = config_units - .iter() - .filter_map(|u| match u { - ConfigUnit::CodeGeneration(g) => { - g.name.split_once('#').map(|(lang, ver)| DeclaredLang { - language: lang.to_owned(), - lang_version: ver.to_owned(), - }) - } - _ => None, - }) - .collect(); + // Languages the congregation declared: `rust#1.85.0` -> ("rust", "1.85.0"). + let declared: Vec = lang_targets::declared(config_units); let spec_version = config_units .iter() @@ -165,18 +155,29 @@ fn generate_once(work_dir: &Path, overrides: &Overrides, dry_run: bool, list: bo // for one named by a `[[generate.target]]`, so it says what to do // about it: `only` is how a consumer whose binary can't produce a // language says so on purpose. - let Some((generator, ext)) = registry.find(&t.language, &t.lang_version) else { - return Err(miette!( - "no generator for `{}` (version `{}`)\n \ - help: this build of comline has no {} generator. Install one that \ - does, or narrow the set in {}:\n \ - [generate]\n only = [...]", - t.language, - t.lang_version, - t.language, - gen_config::FILE_NAME, - )); - }; + let resolved: Resolved = + match lang_targets::resolve(®istry, &context, &t.language, &t.lang_version) { + Ok(resolved) => resolved, + Err(TargetError::Unresolved(Unresolved::UnknownLanguage { .. })) => { + return Err(miette!( + "no generator for `{}` (version `{}`)\n \ + help: this build of comline has no {} generator. Install one that \ + does, or narrow the set in {}:\n \ + [generate]\n only = [...]", + t.language, + t.lang_version, + t.language, + gen_config::FILE_NAME, + )) + } + Err(e) => return Err(miette!("target `{}`: {e}", t.language)), + }; + match lang_targets::unverified(&context, &t.language, &resolved) { + Ok(Some(warning)) => ui::warn(warning), + Ok(None) => {} + Err(error) => return Err(miette!("target `{}`: {error}", t.language)), + } + let (generator, ext) = (resolved.generator.generate, resolved.generator.ext); let versions = expand_versions(&t.versions, work_dir, &live_schemas)?; if mode == Mode::Lib && versions.len() > 1 { @@ -229,11 +230,7 @@ fn generate_once(work_dir: &Path, overrides: &Overrides, dry_run: bool, list: bo // schema and a parent of deeper schemas), not source *text* - // they carry no span to render a snippet against, so there's // nothing for the multi-line branch there to do. - warn_ignored( - &t.language, - &request, - registry.support(&t.language, &t.lang_version), - ); + warn_ignored(&t.language, &request, &resolved); let files = generator(&request).map_err(|e| miette!("`{}` generator: {e}", t.language))?; @@ -402,17 +399,16 @@ fn gen_version_from_commit( /// generates, but without the feature (a TypeScript target with /// `@validators` gets the types, not the checks). An unsupported feature /// needs nothing here: the generator refuses it, naming every use. -fn warn_ignored(language: &str, request: &GenRequest, support: Option) { - let Some(support) = support else { return }; +fn warn_ignored(language: &str, request: &GenRequest, resolved: &Resolved) { let uses = features::used(request.schemas, &features::Options::of(request)); let mut ignored: BTreeMap> = BTreeMap::new(); for u in &uses { - if features::support_for(support, u.feature).state == features::State::Ignored { + if resolved.support(u.feature).state == features::State::Ignored { ignored.entry(u.feature).or_default().push(u); } } for (feature, uses) in ignored { - let s = features::support_for(support, feature); + let s = resolved.support(feature); let mut message = format!("`{language}` ignores {}", feature.title()); if let Some(note) = s.note { message.push_str(&format!(": {note}")); diff --git a/src/commands/new.rs b/src/commands/new.rs index 21728c9..5a20be8 100644 --- a/src/commands/new.rs +++ b/src/commands/new.rs @@ -5,6 +5,7 @@ use std::process::Command; use miette::{IntoDiagnostic, Result, WrapErr}; +use crate::commands::generate::generator_registry; use crate::ui; const GREETING_IDS: &str = "\ @@ -108,7 +109,23 @@ fn package_ident(name: &str) -> String { ident } +/// The language a new project declares: Rust at its generator's floor, the +/// oldest toolchain it generates for. That's the widest promise, and a +/// consumer can raise a version but never lower it, so a higher one would +/// shut older toolchains out for good. A binary built without Rust +/// scaffolds the first language it has. +fn scaffold_language() -> String { + let targets = generator_registry().targets(); + targets + .iter() + .find(|t| t.name == "rust") + .or(targets.first()) + .map(|t| format!("{}#{}", t.name, t.version)) + .unwrap_or_else(|| "rust#1.85.0".to_string()) +} + fn config_idp(name: &str) -> String { + let language = scaffold_language(); format!( "\ congregation {name} @@ -116,7 +133,7 @@ specification_version = 1 code_generation = {{ languages = {{ - rust#1.70.0 = {{}} + {language} = {{}} }} }} " diff --git a/src/commands/targets.rs b/src/commands/targets.rs index e6e6a90..9fc2f25 100644 --- a/src/commands/targets.rs +++ b/src/commands/targets.rs @@ -1,6 +1,7 @@ //! `comline targets` — print every `language#version` this build of -//! `comline` can generate, to stdout; with `--features`, what each of them -//! supports. +//! `comline` can generate, to stdout: each generator's floor, then the +//! versions it handles and has verified. With `--features`, what each of them +//! supports, and from which version. //! //! Reflects how this binary was compiled (which `gen-` Cargo features //! were on), not any particular project — ignores `--path` entirely, same as @@ -10,6 +11,7 @@ use std::collections::BTreeMap; use std::io::Write as _; use comline_codegen::features::{self, Column, Feature}; +use comline_codegen::versions::Versions; use miette::{IntoDiagnostic, Result}; use crate::commands::generate::generator_registry; @@ -23,11 +25,11 @@ pub fn run(with_features: bool, json: bool) -> Result<()> { .targets() .into_iter() .filter_map(|t| { - let support = registry.support(t.name, t.version)?; + let resolved = registry.resolve(t.name, t.version).ok()?; Some(Column { generator: t.name, - version: t.version, - support, + versions: t.versions, + support: resolved.generator.support, }) }) .collect(); @@ -42,16 +44,25 @@ pub fn run(with_features: bool, json: bool) -> Result<()> { } for t in registry.targets() { - writeln!(out, "{}#{}", t.name, t.version).into_diagnostic()?; - let Some(support) = registry - .support(t.name, t.version) + // `name#floor` first: the token `config.idp` takes, so anything + // reading the first word keeps working. Then the range. + writeln!(out, "{}#{} {}", t.name, t.version, range(&t.versions)).into_diagnostic()?; + let Some(resolved) = registry + .resolve(t.name, t.version) + .ok() .filter(|_| with_features) else { continue; }; for &feature in Feature::ALL { - let s = features::support_for(support, feature); + let s = features::support_for(resolved.generator.support, feature); let mut line = format!(" {:<11} {}", s.state.id(), feature.id()); + if let Some(since) = s.since { + line.push_str(&format!( + " from {} (below it, unsupported: {})", + since.version, since.why + )); + } if let Some(note) = s.note { line.push_str(&format!(" - {note}")); } @@ -63,3 +74,17 @@ pub fn run(with_features: bool, json: bool) -> Result<()> { } Ok(()) } + +/// The versions a generator handles, as a reader wants them: from its floor +/// on, where its output changes, and how far it's verified. +fn range(versions: &Versions) -> String { + let mut s = format!("{} or later", versions.floor); + if !versions.changes.is_empty() { + s.push_str(&format!(", changes at {}", versions.changes.join(", "))); + } + s.push_str(&format!("; verified up to {}", versions.verified_up_to)); + if versions.forward_compatible { + s.push_str(", and newer toolchains build its output"); + } + format!("({s})") +} diff --git a/src/gen_config.rs b/src/gen_config.rs index 3aceeaa..87e6dc2 100644 --- a/src/gen_config.rs +++ b/src/gen_config.rs @@ -12,6 +12,7 @@ use std::path::{Path, PathBuf}; use comline_codegen::validation::ValidateOnDecode; +use comline_codegen::versions::LangVersion; use comline_core::schema::idl::annotations; use comline_core::utils::templating::recurse_render; use comline_core::utils::text::closest; @@ -129,8 +130,9 @@ pub struct Target { /// Must match a language the congregation declared under /// `code_generation.languages`. pub language: String, - /// Language/toolchain version selecting the generator (e.g. `1.70.0`). - /// Falls back to the version the congregation declared for this language. + /// Language/toolchain version selecting the generator (e.g. `1.88.0`). + /// Falls back to the version the congregation declared for this language, + /// and may raise it but never lower it. pub lang_version: Option, pub out: Option, pub layout: Option, @@ -477,22 +479,37 @@ pub fn resolve( ) })?; - let lang_version = t - .lang_version - .clone() - .or_else(|| { - declared - .iter() - .find(|d| d.language.eq_ignore_ascii_case(&t.language)) - .map(|d| d.lang_version.clone()) - }) - .ok_or_else(|| { - miette!( - "target `{}` sets no `lang_version` and config.idp does not \ + let declared_version = declared + .iter() + .find(|d| d.language.eq_ignore_ascii_case(&t.language)) + .map(|d| d.lang_version.clone()); + // `comline.toml` may raise the version, never lower it: config.idp's + // is the oldest toolchain the package was proven against. A version + // that doesn't parse is left for the registry to name. + if let (Some(raised), Some(declared_version)) = (&t.lang_version, &declared_version) { + if let (Some(r), Some(d)) = ( + LangVersion::parse(raised), + LangVersion::parse(declared_version), + ) { + if r < d { + return Err(miette!( + "target `{}` sets `lang_version = \"{raised}\"`, below config.idp's `{}#{declared_version}` \ + - {} can raise a target's version, never lower it: the package is only proven \ + from `{declared_version}` on", + t.language, + t.language, + FILE_NAME + )); + } + } + } + let lang_version = t.lang_version.clone().or(declared_version).ok_or_else(|| { + miette!( + "target `{}` sets no `lang_version` and config.idp does not \ declare that language under `code_generation.languages`", - t.language - ) - })?; + t.language + ) + })?; let versions = t .package_versions @@ -591,7 +608,7 @@ mod tests { fn target_package_versions_wins_over_section() { let cfg = parse( "[generate]\npackage_versions = \"all\"\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ package_versions = \"latest\"\n", ); let declared = []; @@ -603,7 +620,7 @@ mod tests { [ DeclaredLang { language: "rust".into(), - lang_version: "1.70.0".into(), + lang_version: "1.85.0".into(), }, DeclaredLang { language: "typescript".into(), @@ -653,7 +670,7 @@ mod tests { ); let declared = [DeclaredLang { language: "rust".into(), - lang_version: "1.70.0".into(), + lang_version: "1.85.0".into(), }]; let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); assert_eq!(resolved.len(), 2); @@ -668,7 +685,7 @@ mod tests { let cfg = parse("[[generate.target]]\nlanguage = \"python\"\nlang_version = \"3.11\"\n"); let declared = [DeclaredLang { language: "rust".into(), - lang_version: "1.70.0".into(), + lang_version: "1.85.0".into(), }]; let err = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()) .unwrap_err() @@ -681,7 +698,7 @@ mod tests { /// there is, as they always were. #[test] fn blocks_stand_alone_when_nothing_is_declared() { - let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n"); + let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n"); let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); assert_eq!(resolved.len(), 1); assert_eq!(resolved[0].language, "rust"); @@ -722,7 +739,7 @@ mod tests { let cfg = parse("[generate]\ndefault_framing = \"jsonrpc\"\n"); let declared = [DeclaredLang { language: "rust".into(), - lang_version: "1.75".into(), + lang_version: "1.80".into(), }]; let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); assert_eq!(resolved[0].default_framing.as_deref(), Some("jsonrpc")); @@ -732,7 +749,7 @@ mod tests { fn target_default_framing_wins_over_section() { let cfg = parse( "[generate]\ndefault_framing = \"jsonrpc\"\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ default_framing = \"datagram\"\n", ); let declared = []; @@ -747,7 +764,7 @@ mod tests { fn external_std_follows_the_mode() { for (mode, expected) in [("code", false), ("lib", true)] { let cfg = parse(&format!( - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ mode = \"{mode}\"\n", )); let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); @@ -760,7 +777,7 @@ mod tests { #[test] fn an_explicit_false_still_inlines_std_in_lib_mode() { let cfg = parse( - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ mode = \"lib\"\nexternal_std = false\n", ); let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); @@ -771,7 +788,7 @@ mod tests { fn the_section_default_applies_to_a_code_target_too() { let cfg = parse( "[generate]\nexternal_std = true\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n", + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n", ); let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); assert!(resolved[0].external_std, "`code`, but asked for explicitly"); @@ -782,7 +799,7 @@ mod tests { #[test] fn either_flag_spelling_overrides_the_mode_default() { let cfg = parse( - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ mode = \"lib\"\n", ); let off = Overrides { @@ -792,7 +809,7 @@ mod tests { let resolved = resolve(&cfg, &[], Path::new("/x"), &off).unwrap(); assert!(!resolved[0].external_std, "--no-external-std"); - let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n"); + let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n"); let on = Overrides { external_std: Some(true), ..Default::default() @@ -801,12 +818,33 @@ mod tests { assert!(resolved[0].external_std, "--external-std"); } + #[test] + fn a_target_may_raise_the_declared_version_but_not_lower_it() { + let declared = [DeclaredLang { + language: "rust".into(), + lang_version: "1.88.0".into(), + }]; + let raised = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.90\"\n"); + let resolved = resolve(&raised, &declared, Path::new("/x"), &Overrides::default()).unwrap(); + assert_eq!(resolved[0].lang_version, "1.90"); + + let lowered = + parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n"); + let err = resolve(&lowered, &declared, Path::new("/x"), &Overrides::default()).unwrap_err(); + let message = err.to_string(); + assert!( + message.contains("below config.idp's `rust#1.88.0`"), + "{message}" + ); + assert!(message.contains("never lower it"), "{message}"); + } + #[test] fn default_framing_absent_is_none() { let cfg = parse("[generate]\n"); let declared = [DeclaredLang { language: "rust".into(), - lang_version: "1.75".into(), + lang_version: "1.80".into(), }]; let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); assert_eq!(resolved[0].default_framing, None); @@ -815,7 +853,7 @@ mod tests { #[test] fn flatten_defaults_to_false_and_is_target_only() { let cfg = parse( - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ mode = \"lib\"\nflatten = true\n", ); let declared = []; @@ -823,7 +861,7 @@ mod tests { assert!(resolved[0].flatten); let cfg = parse( - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\nmode = \"lib\"\n", + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\nmode = \"lib\"\n", ); let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); assert!(!resolved[0].flatten); @@ -834,7 +872,7 @@ mod tests { let cfg = parse("[generate]\n"); let declared = [DeclaredLang { language: "rust".into(), - lang_version: "1.75".into(), + lang_version: "1.80".into(), }]; let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); assert!(!resolved[0].external_std); @@ -845,7 +883,7 @@ mod tests { let cfg = parse("[generate]\nexternal_std = true\n"); let declared = [DeclaredLang { language: "rust".into(), - lang_version: "1.75".into(), + lang_version: "1.80".into(), }]; let resolved = resolve(&cfg, &declared, Path::new("/x"), &Overrides::default()).unwrap(); assert!(resolved[0].external_std); @@ -855,7 +893,7 @@ mod tests { fn target_external_std_wins_over_section() { let cfg = parse( "[generate]\nexternal_std = true\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ external_std = false\n", ); let declared = []; @@ -868,7 +906,7 @@ mod tests { let cfg = parse("[generate]\nexternal_std = false\n"); let declared = [DeclaredLang { language: "rust".into(), - lang_version: "1.75".into(), + lang_version: "1.80".into(), }]; let ov = Overrides { external_std: Some(true), @@ -880,7 +918,7 @@ mod tests { #[test] fn validate_on_decode_defaults_to_off() { - let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n"); + let cfg = parse("[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n"); let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); assert_eq!(resolved[0].validate_on_decode, ValidateOnDecode::Off); } @@ -889,7 +927,7 @@ mod tests { fn validate_on_decode_target_wins_over_section_and_the_flag_over_both() { let cfg = parse( "[generate]\nvalidate_on_decode = \"collect\"\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\ + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\ validate_on_decode = \"first\"\n", ); let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); @@ -907,7 +945,7 @@ mod tests { fn default_framing_is_folded_onto_its_canonical_spelling() { let cfg = parse( "[generate]\ndefault_framing = \"json-rpc\"\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n", + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n", ); let resolved = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap(); assert_eq!(resolved[0].default_framing.as_deref(), Some("jsonrpc")); @@ -917,7 +955,7 @@ mod tests { fn an_unknown_default_framing_names_the_accepted_values_and_a_near_miss() { let cfg = parse( "[generate]\ndefault_framing = \"jsonrcp\"\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n", + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n", ); let error = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap_err(); assert_eq!( @@ -931,7 +969,7 @@ mod tests { fn an_unknown_validate_on_decode_names_the_accepted_values() { let cfg = parse( "[generate]\nvalidate_on_decode = \"always\"\n\n\ - [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n", + [[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n", ); let error = resolve(&cfg, &[], Path::new("/x"), &Overrides::default()).unwrap_err(); assert_eq!( diff --git a/src/lang_targets.rs b/src/lang_targets.rs new file mode 100644 index 0000000..c99cfa0 --- /dev/null +++ b/src/lang_targets.rs @@ -0,0 +1,223 @@ +//! What a package's declared targets promise, and the checks that hold it +//! to them. +//! +//! `config.idp` declares each language a package generates for, with the +//! oldest toolchain its generated code must build on: `rust#1.85.0`. That +//! declaration is a promise consumers rely on, so `comline build` proves +//! every one before a version is frozen ([`check_declared`]), and +//! `comline generate` holds each target to the same rules ([`resolve`]): +//! +//! - A generator in this binary handles the version: not below its floor, +//! and dotted numbers. +//! - It's no lower than any dependency's declaration for the language. A +//! dependency's generated code needs at least its own toolchain. +//! - Every feature the schemas use is supported at that version. +//! - Past what the generator has verified, it warns under +//! [`UNVERIFIED_VERSION`], which a package's settings can raise to an +//! error (`diagnostics."generation::unverified-version".level`). +//! +//! See the *Language target versions* proposal in the docs. + +use comline_codegen::features::{self, Options}; +use comline_codegen::versions::LangVersion; +use comline_codegen::{Registry, Resolved, Unresolved}; +use comline_core::diagnostics::{Diagnostic, DiagnosticCode}; +use comline_core::package::config::ir::context::ProjectContext; +use comline_core::package::config::ir::frozen::FrozenUnit as ConfigUnit; +use comline_core::schema::ir::compiler::settings::severity::resolve_diagnostic_overrides; +use comline_core::schema::ir::frozen::unit::FrozenUnit; +use comline_core::settings::effective::package_settings; +use comline_core::settings::SettingsSpans; + +use crate::gen_config::DeclaredLang; + +/// A target declared or raised past the newest version its generator has +/// verified. A warning: the wire isn't affected, only whoever compiles the +/// output, so there's nothing to accept. +pub const UNVERIFIED_VERSION: DiagnosticCode = + DiagnosticCode::warning("generation::unverified-version"); + +/// The languages a congregation's config declares: `rust#1.85.0` -> +/// (`rust`, `1.85.0`). +pub fn declared(config: &[ConfigUnit]) -> Vec { + config + .iter() + .filter_map(|u| match u { + ConfigUnit::CodeGeneration(g) => { + g.name.split_once('#').map(|(lang, ver)| DeclaredLang { + language: lang.to_owned(), + lang_version: ver.to_owned(), + }) + } + _ => None, + }) + .collect() +} + +/// The highest version any dependency, direct or not, declares for +/// `language`: (the dependency's name, its declaration as written, parsed). +/// An unparsable one is that dependency's own build's business. +fn dependency_minimum( + context: &ProjectContext, + language: &str, +) -> Option<(String, String, LangVersion)> { + context + .dependency_configs + .iter() + .flat_map(|(dependency, config)| { + declared(config) + .into_iter() + .filter(|d| d.language.eq_ignore_ascii_case(language)) + .filter_map(move |d| { + let version = LangVersion::parse(&d.lang_version)?; + Some((dependency.clone(), d.lang_version, version)) + }) + }) + .max_by(|a, b| a.2.cmp(&b.2)) +} + +/// `language#version`'s generator, held to the package's dependencies: an +/// error below the generator's floor, for a version that isn't one, for a +/// language this binary can't generate, or below a dependency's declaration. +pub fn resolve( + registry: &Registry, + context: &ProjectContext, + language: &str, + version: &str, +) -> Result { + let resolved = registry + .resolve(language, version) + .map_err(TargetError::Unresolved)?; + if let Some((dependency, written, minimum)) = dependency_minimum(context, language) { + if resolved.version < minimum { + return Err(TargetError::BelowDependency(format!( + "`{language}#{version}` is older than dependency `{dependency}` allows: it declares \ + `{language}#{written}`, and its generated code needs that toolchain - declare \ + `{language}#{written}` or later" + ))); + } + } + Ok(resolved) +} + +/// Why a target can't be generated. +pub enum TargetError { + Unresolved(Unresolved), + BelowDependency(String), +} + +impl std::fmt::Display for TargetError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + TargetError::Unresolved(unresolved) => unresolved.fmt(f), + TargetError::BelowDependency(message) => f.write_str(message), + } + } +} + +/// What `schemas` use that `resolved` doesn't support at its version, as the +/// generator's own refusal would put it. `None` when there's nothing. +pub fn unsupported( + language: &str, + resolved: &Resolved, + schemas: &[(String, Vec)], + options: &Options, +) -> Option { + let support = resolved.generator.support; + let uses = features::used(schemas, options); + let unsupported = features::unsupported_uses(&uses, support, &resolved.version); + (!unsupported.is_empty()) + .then(|| features::refusal(language, &unsupported, support, &resolved.version)) +} + +/// The [`UNVERIFIED_VERSION`] warning for `resolved`, when it's past what its +/// generator has verified, with the package's diagnostics settings applied: +/// `Ok(Some(_))` to print, `Ok(None)` when verified or silenced, `Err(_)` +/// when the settings make it an error. +pub fn unverified( + context: &ProjectContext, + language: &str, + resolved: &Resolved, +) -> Result, String> { + if resolved.is_verified() { + return Ok(None); + } + let versions = resolved.generator.versions; + let message = format!( + "`{language}#{}` is past what the {language} generator has verified (up to {}): it generates \ + as for {}, and the output may not build on that toolchain ({})", + resolved.version, + versions.verified_up_to, + resolved.boundary(), + UNVERIFIED_VERSION.id + ); + let diagnostic = Diagnostic::new(UNVERIFIED_VERSION, message.clone()); + let (warnings, fatal) = resolve_diagnostic_overrides( + &[], + vec![diagnostic], + &package_settings(context), + &SettingsSpans::default(), + ); + if let Some(error) = fatal.first() { + return Err(format!( + "{} - `diagnostics.\"{}\".level` makes it an error", + error.message, UNVERIFIED_VERSION.id + )); + } + Ok(warnings.first().map(|_| message)) +} + +/// `comline build`'s check: every language `context` declares, proven at its +/// declared version. Returns the warnings to print; every problem is +/// gathered into one error, so a package with several sees them all at once. +pub fn check_declared(context: &ProjectContext, registry: &Registry) -> eyre::Result> { + let config = context.config_frozen.as_deref().unwrap_or_default(); + let schemas: Vec<(String, Vec)> = context + .schema_contexts + .iter() + .filter_map(|sc| { + let sc = sc.borrow(); + let units = sc.frozen_schema.borrow().clone()?; + Some((sc.namespace.join("/"), units)) + }) + .collect(); + + let mut problems = Vec::new(); + let mut warnings = Vec::new(); + for d in declared(config) { + let resolved = match resolve(registry, context, &d.language, &d.lang_version) { + Ok(resolved) => resolved, + Err(TargetError::Unresolved(Unresolved::UnknownLanguage { language })) => { + problems.push(format!( + "`{language}#{}` can't be checked: this build of comline has no {language} generator \ + - build with one that does, or remove the declaration", + d.lang_version + )); + continue; + } + Err(e) => { + problems.push(e.to_string()); + continue; + } + }; + // Options a consumer picks in `comline.toml` aren't the package's + // promise, so only what the schemas themselves use is checked. + if let Some(refusal) = unsupported(&d.language, &resolved, &schemas, &Options::default()) { + problems.push(format!("`{}#{}`: {refusal}", d.language, d.lang_version)); + } + match unverified(context, &d.language, &resolved) { + Ok(Some(warning)) => warnings.push(warning), + Ok(None) => {} + Err(error) => problems.push(error), + } + } + + if problems.is_empty() { + Ok(warnings) + } else { + Err(eyre::eyre!( + "the package's declared targets don't hold (config.idp, `code_generation.languages`):\n\n{}", + problems.join("\n\n") + )) + } +} diff --git a/src/main.rs b/src/main.rs index d73baf0..8c440fa 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,6 +4,7 @@ mod commands; mod error; mod gen_config; mod history; +mod lang_targets; mod ui; mod watch; diff --git a/tests/cli/build.rs b/tests/cli/build.rs index d12adc2..f02b350 100644 --- a/tests/cli/build.rs +++ b/tests/cli/build.rs @@ -22,3 +22,110 @@ fn freezes_an_initial_version() { assert!(project.join(".comline").is_dir()); } + +/// `fixture_project`, declaring `languages` (and anything after) instead. +fn declaring(temp: &std::path::Path, languages: &str, rest: &str) -> std::path::PathBuf { + let project = fixture_project(temp); + std::fs::write( + project.join("config.idp"), + format!( + "congregation simple_project\nspecification_version = 1\n\n\ + code_generation = {{\n languages = {{\n {languages}\n }}\n}}\n{rest}" + ), + ) + .unwrap(); + project +} + +fn build(project: &std::path::Path) -> assert_cmd::assert::Assert { + comline_cmd().current_dir(project).arg("build").assert() +} + +#[test] +fn refuses_a_declaration_below_the_generators_floor_and_freezes_nothing() { + let temp = tempfile::tempdir().unwrap(); + let project = declaring(temp.path(), "rust#1.70.0 = {}", ""); + + build(&project).failure().stderr(predicate::str::contains( + "`rust#1.70.0` is older than the rust generator handles: it needs `rust#1.85.0` or later", + )); + assert!(!project.join(".comline").exists(), "nothing was frozen"); +} + +#[test] +fn refuses_a_language_this_build_cant_check() { + let temp = tempfile::tempdir().unwrap(); + let project = declaring(temp.path(), "python#3.11 = {}", ""); + + build(&project).failure().stderr(predicate::str::contains( + "`python#3.11` can't be checked: this build of comline has no python generator", + )); +} + +#[test] +fn refuses_a_feature_the_declared_target_doesnt_support() { + let temp = tempfile::tempdir().unwrap(); + let project = fixture_project(temp.path()); + std::fs::write( + project.join("src/either.ids"), + "struct Either {\n value: union(string u32)\n}\n", + ) + .unwrap(); + + build(&project) + .failure() + .stderr(predicate::str::contains( + "`rust#1.85.0`: the rust generator doesn't support unions", + )) + .stderr(predicate::str::contains("struct 'Either'")); +} + +#[test] +fn a_version_past_the_verified_range_warns_and_settings_can_make_it_an_error() { + let temp = tempfile::tempdir().unwrap(); + let project = declaring(temp.path(), "typescript#6.0 = {}", ""); + build(&project) + .success() + .stderr(predicate::str::contains( + "`typescript#6.0` is past what the typescript generator has verified (up to 5.9)", + )) + .stderr(predicate::str::contains("generation::unverified-version")); + + let temp = tempfile::tempdir().unwrap(); + let project = declaring( + temp.path(), + "typescript#6.0 = {}", + "\nsettings = {\n diagnostics = {\n generation::unverified-version = {\n level = \"error\"\n }\n }\n}\n", + ); + build(&project) + .failure() + .stderr(predicate::str::contains("makes it an error")); + assert!(!project.join(".comline").exists()); +} + +#[test] +fn refuses_a_declaration_below_a_dependencys() { + let temp = tempfile::tempdir().unwrap(); + let shared = temp.path().join("shared"); + std::fs::create_dir_all(shared.join("src")).unwrap(); + std::fs::write( + shared.join("config.idp"), + "congregation shared\nspecification_version = 1\n\n\ + code_generation = {\n languages = {\n rust#1.90.0 = {}\n }\n}\n", + ) + .unwrap(); + std::fs::write( + shared.join("src/models.ids"), + "struct Thing {\n id: u64\n}\n", + ) + .unwrap(); + let project = declaring( + temp.path(), + "rust#1.85.0 = {}", + "\ndependencies = {\n shared = {\n path = \"../shared\"\n }\n}\n", + ); + + build(&project).failure().stderr(predicate::str::contains( + "`rust#1.85.0` is older than dependency `shared` allows: it declares `rust#1.90.0`", + )); +} diff --git a/tests/cli/generate.rs b/tests/cli/generate.rs index 011f9a8..e863291 100644 --- a/tests/cli/generate.rs +++ b/tests/cli/generate.rs @@ -110,7 +110,7 @@ fn env_out_applies_in_a_multi_target_config() { declare_two_languages(&project); fs::write( project.join("comline.toml"), - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\n\ + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\n\ [[generate.target]]\nlanguage = \"python\"\nlang_version = \"3.11.0\"\n", ) .unwrap(); @@ -157,7 +157,7 @@ fn out_flag_needs_target_when_several_are_configured() { declare_two_languages(&project); fs::write( project.join("comline.toml"), - "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.70.0\"\n\n\ + "[[generate.target]]\nlanguage = \"rust\"\nlang_version = \"1.85.0\"\n\n\ [[generate.target]]\nlanguage = \"python\"\nlang_version = \"3.11.0\"\n", ) .unwrap(); @@ -243,7 +243,7 @@ fn lib_mode_emits_a_crate() { let crate_dir = project.join("generated/rust"); let cargo = fs::read_to_string(crate_dir.join("Cargo.toml")).unwrap(); assert!(cargo.contains("name = \"simple_project\"")); - assert!(cargo.contains("edition = \"2021\"")); + assert!(cargo.contains("edition = \"2024\"")); assert!(cargo.contains("serde = { version = \"1\"")); let lib = fs::read_to_string(crate_dir.join("src/lib.rs")).unwrap(); @@ -513,7 +513,7 @@ fn declare_two_languages(project: &std::path::Path) { fs::write( project.join("config.idp"), "congregation simple_project\nspecification_version = 1\n\n\ - code_generation = {\n languages = {\n rust#1.70.0 = {}\n\ + code_generation = {\n languages = {\n rust#1.85.0 = {}\n\ \x20 python#3.11.0 = {}\n }\n}\n", ) .unwrap(); @@ -652,7 +652,7 @@ fn the_target_line_names_the_mode() { .assert() .success() .stderr(predicate::str::contains( - "language: rust, version: 1.70.0, mode: code", + "language: rust, version: 1.85.0, mode: code", )); comline_cmd() @@ -706,7 +706,7 @@ fn lib_mode_links_comline_std_instead_of_inlining_it() { let crate_dir = project.join("generated/rust"); let cargo = fs::read_to_string(crate_dir.join("Cargo.toml")).unwrap(); assert!(cargo.contains("comline_std = { git"), "{cargo}"); - assert!(cargo.contains("rust-version = \"1.70.0\""), "{cargo}"); + assert!(cargo.contains("rust-version = \"1.85.0\""), "{cargo}"); assert!( !crate_dir.join("src/std.rs").exists(), "std should not be inlined" @@ -764,8 +764,8 @@ fn an_ignored_feature_is_a_warning() { std::fs::write( &config, idp.replace( - "rust#1.70.0 = {}", - "rust#1.70.0 = {}\n typescript#5.0 = {}", + "rust#1.85.0 = {}", + "rust#1.85.0 = {}\n typescript#5.0 = {}", ), ) .unwrap(); diff --git a/tests/cli/global.rs b/tests/cli/global.rs index 7705aae..0989897 100644 --- a/tests/cli/global.rs +++ b/tests/cli/global.rs @@ -48,6 +48,20 @@ fn targets_are_written_to_stdout_as_language_hash_version() { .stderr(predicate::str::is_empty()); } +/// Each line starts with the token `config.idp` takes, the generator's floor, +/// then the range it handles. +#[test] +fn targets_name_each_generators_floor_and_verified_range() { + comline_cmd() + .args(["targets"]) + .assert() + .success() + .stdout(predicate::str::contains( + "rust#1.85.0 (1.85.0 or later; verified up to 1.99, and newer toolchains build its output)", + )) + .stdout(predicate::str::contains("typescript#5.0 (5.0 or later; verified up to 5.9)")); +} + #[test] fn targets_features_lists_each_generators_support() { comline_cmd() diff --git a/tests/cli/new.rs b/tests/cli/new.rs index 12de2a8..6a46f46 100644 --- a/tests/cli/new.rs +++ b/tests/cli/new.rs @@ -26,6 +26,8 @@ fn scaffolds_a_buildable_project() { let config = fs::read_to_string(root.join("config.idp")).unwrap(); assert!(config.contains("congregation my_api")); assert!(config.contains("code_generation")); + // The widest promise: the Rust generator's floor. + assert!(config.contains("rust#1.85.0 = {}"), "{config}"); // the scaffold must actually build comline_cmd() diff --git a/tests/fixtures/chat_project/config.idp b/tests/fixtures/chat_project/config.idp index 9bbae6a..05631c8 100644 --- a/tests/fixtures/chat_project/config.idp +++ b/tests/fixtures/chat_project/config.idp @@ -3,6 +3,6 @@ specification_version = 1 code_generation = { languages = { - rust#1.70.0 = {} + rust#1.85.0 = {} } } diff --git a/tests/fixtures/simple_project/config.idp b/tests/fixtures/simple_project/config.idp index 052b109..9d26889 100644 --- a/tests/fixtures/simple_project/config.idp +++ b/tests/fixtures/simple_project/config.idp @@ -3,6 +3,6 @@ specification_version = 1 code_generation = { languages = { - rust#1.70.0 = {} + rust#1.85.0 = {} } } diff --git a/tests/fixtures/validated_project/config.idp b/tests/fixtures/validated_project/config.idp index 93b2a92..6e7d8b6 100644 --- a/tests/fixtures/validated_project/config.idp +++ b/tests/fixtures/validated_project/config.idp @@ -3,6 +3,6 @@ specification_version = 1 code_generation = { languages = { - rust#1.70.0 = {} + rust#1.85.0 = {} } }