refactor: Use collect_breaking_versions from v2 directly in PG

crates/codegen/language/definition/src/model/manifest.rs

@@ -36,27 +36,15 @@ impl Language {
     }
 
     /// Collects all versions that change the language grammar in a breaking way.
+    ///
+    /// Includes the first supported version.
     pub fn collect_breaking_versions(&self) -> BTreeSet<Version> {
         let first = self.versions.first().unwrap().clone();
         let mut res = BTreeSet::from_iter([first]);
 
         let mut add_spec = |spec: &Option<VersionSpecifier>| {
-            let Some(spec) = spec else {
-                return;
-            };
-
-            match spec.clone() {
-                VersionSpecifier::Never => (),
-                VersionSpecifier::From { from } => {
-                    res.insert(from);
-                }
-                VersionSpecifier::Till { till } => {
-                    res.insert(till);
-                }
-                VersionSpecifier::Range { from, till } => {
-                    res.insert(from);
-                    res.insert(till);
-                }
+            if let Some(spec) = spec {
+                res.extend(spec.versions().cloned());
             }
         };
 

crates/codegen/runtime/cargo/src/runtime/language.rs.jinja2

@@ -30,7 +30,10 @@ use crate::parser_support::{
 #[cfg_attr(feature = "slang_napi_interfaces", napi(namespace = "language"))]
 pub struct Language {
     {%- if not rendering_in_stubs -%}
-        {%- for version in model.parser.referenced_versions -%}
+        {%- for version in model.breaking_versions -%}
+            {% if loop.first %} {# The first supported version may not be referenced by the items #}
+            #[allow(dead_code)]
+            {% endif %}
             pub(crate) version_is_at_least_{{ version | replace(from=".", to="_") }}: bool,
         {%- endfor -%}
     {%- endif -%}
@@ -68,7 +71,7 @@ impl Language {
         if Self::SUPPORTED_VERSIONS.binary_search(&version).is_ok() {
             Ok(Self {
                 {%- if not rendering_in_stubs -%}
-                    {%- for version in model.parser.referenced_versions %}
+                    {%- for version in model.breaking_versions %}
                         version_is_at_least_{{ version | replace(from=".", to="_") }}: Version::new({{ version | split(pat=".") | join(sep=", ") }}) <= version,
                     {%- endfor -%}
                 {%- endif -%}

crates/codegen/runtime/generator/src/model.rs

@@ -13,6 +13,7 @@ use crate::parser::ParserModel;
 pub struct RuntimeModel {
     /// Defines the `Language::SUPPORTED_VERSIONS` field.
     all_versions: BTreeSet<Version>,
+    breaking_versions: BTreeSet<Version>,
     parser: ParserModel,
     ast: AstModel,
     kinds: KindsModel,
@@ -22,6 +23,7 @@ impl RuntimeModel {
     pub fn from_language(language: &Rc<Language>) -> Self {
         Self {
             all_versions: language.versions.iter().cloned().collect(),
+            breaking_versions: language.collect_breaking_versions(),
             ast: AstModel::create(language),
             parser: ParserModel::from_language(language),
             kinds: KindsModel::create(language),

crates/codegen/runtime/generator/src/parser.rs

@@ -3,8 +3,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 use std::rc::Rc;
 
-use codegen_language_definition::model::{Identifier, Language, VersionSpecifier};
-use semver::Version;
+use codegen_language_definition::model::{Identifier, Language};
 use serde::Serialize;
 
 mod codegen;
@@ -16,8 +15,8 @@ use codegen::{
 };
 use grammar::{
     Grammar, GrammarVisitor, KeywordScannerAtomic, KeywordScannerDefinitionRef,
-    ParserDefinitionNode, ParserDefinitionRef, PrecedenceParserDefinitionRef,
-    ScannerDefinitionNode, ScannerDefinitionRef, TriviaParserDefinitionRef,
+    ParserDefinitionNode, ParserDefinitionRef, PrecedenceParserDefinitionRef, ScannerDefinitionRef,
+    TriviaParserDefinitionRef,
 };
 
 /// Newtype for the already generated Rust code, not to be confused with regular strings.
@@ -26,9 +25,6 @@ struct RustCode(String);
 
 #[derive(Default, Serialize)]
 pub struct ParserModel {
-    /// Constructs inner `Language` the state to evaluate the version-dependent branches.
-    referenced_versions: BTreeSet<Version>,
-
     /// Defines the top-level scanner functions in `Language`.
     scanner_functions: BTreeMap<Identifier, RustCode>, // (name of scanner, code)
     // Defines the `Lexer::next_terminal` method.
@@ -61,9 +57,6 @@ struct ScannerContextModel {
 
 #[derive(Default)]
 struct ParserAccumulatorState {
-    /// Constructs inner `Language` the state to evaluate the version-dependent branches.
-    referenced_versions: BTreeSet<Version>,
-
     // Defines the `Lexer::next_terminal` method.
     scanner_contexts: BTreeMap<Identifier, ScannerContextAccumulatorState>,
 
@@ -192,7 +185,6 @@ impl ParserAccumulatorState {
             .collect();
 
         ParserModel {
-            referenced_versions: self.referenced_versions,
             parser_functions: self.parser_functions,
             trivia_parser_functions: self.trivia_parser_functions,
             // These are derived from the accumulated state
@@ -209,15 +201,6 @@ impl GrammarVisitor for ParserAccumulatorState {
             .insert(scanner.name().clone(), Rc::clone(scanner));
     }
 
-    fn keyword_scanner_definition_enter(&mut self, scanner: &KeywordScannerDefinitionRef) {
-        for def in scanner.definitions() {
-            let specifiers = def.enabled.iter().chain(def.reserved.iter());
-
-            self.referenced_versions
-                .extend(specifiers.flat_map(VersionSpecifier::versions).cloned());
-        }
-    }
-
     fn trivia_parser_definition_enter(&mut self, parser: &TriviaParserDefinitionRef) {
         self.set_current_context(parser.context().clone());
 
@@ -254,19 +237,8 @@ impl GrammarVisitor for ParserAccumulatorState {
         );
     }
 
-    fn scanner_definition_node_enter(&mut self, node: &ScannerDefinitionNode) {
-        if let ScannerDefinitionNode::Versioned(_, version_specifier) = node {
-            self.referenced_versions
-                .extend(version_specifier.versions().cloned());
-        }
-    }
-
     fn parser_definition_node_enter(&mut self, node: &ParserDefinitionNode) {
         match node {
-            ParserDefinitionNode::Versioned(_, version_specifier) => {
-                self.referenced_versions
-                    .extend(version_specifier.versions().cloned());
-            }
             ParserDefinitionNode::ScannerDefinition(scanner) => {
                 self.top_level_scanner_names.insert(scanner.name().clone());