Guide zero duration migration

Author: CryZe

crates/splitscript-syntax/src/migration.rs

@@ -98,6 +98,7 @@ pub enum ForeignSpellingContext {
     StaticTypeReceiver,
     Method,
     ValuePath,
+    AttachedProcessValuePath,
     Operator,
 }
 
@@ -595,6 +596,14 @@ const DURATION_SPELLINGS: &[ForeignSpelling] = &[
         "SplitScript uses `Duration` instead of `TimeSpan` for timer durations",
         "replace this C# type name"
     ),
+    type_spelling!(
+        SourceLanguage::CSharp,
+        ForeignSpellingContext::ValuePath,
+        "Duration.Zero",
+        "Duration.zero()",
+        "SplitScript constructs a zero duration with `Duration.zero()`",
+        "replace this C# static property"
+    ),
 ];
 
 macro_rules! numeric_spelling {
@@ -632,7 +641,7 @@ const NUMERIC_SPELLINGS: &[ForeignSpelling] = &[
 
 const ASL_PROCESS_IDENTITY_SPELLINGS: &[ForeignSpelling] = &[ForeignSpelling {
     source: SourceLanguage::Asl,
-    context: ForeignSpellingContext::ValuePath,
+    context: ForeignSpellingContext::AttachedProcessValuePath,
     spelling: "game.ProcessName",
     replacement: ForeignSpellingReplacement::Text("process.name()"),
     message: "ASL `game.ProcessName` is `process.name()` in SplitScript",

docs/ROADMAP_ARCHIVE.md

@@ -8,6 +8,12 @@
 - Applying all offered edits now has regression coverage proving that the
   result is canonical, compilable `Duration.fromSeconds(...)` and
   `Duration.fromMilliseconds(...)` source.
+- Added the corpus-proven C# static-property rewrite from `TimeSpan.Zero` to
+  the canonical constructor call `Duration.zero()`; no compatibility property
+  was introduced.
+- Separated ordinary value-path migrations from rewrites that require an
+  attached native process, so process availability no longer leaks into
+  unrelated fixes.
 - Kept JavaScript `${...}` out of typo recovery because it is valid
   SplitScript source with observably different literal-dollar semantics.
 

src/typeck/call_resolution.rs

@@ -1244,8 +1244,15 @@ impl Checker {
                         self.errors.push(diagnostic);
                         return None;
                     }
-                    if let Some(rule) =
-                        foreign_spelling(&spelling, ForeignSpellingContext::ValuePath)
+                    let ordinary_rule =
+                        foreign_spelling(&spelling, ForeignSpellingContext::ValuePath);
+                    let attached_process_rule = foreign_spelling(
+                        &spelling,
+                        ForeignSpellingContext::AttachedProcessValuePath,
+                    );
+                    if let Some((rule, requires_attached_process)) = ordinary_rule
+                        .map(|rule| (rule, false))
+                        .or_else(|| attached_process_rule.map(|rule| (rule, true)))
                     {
                         let mut diagnostic = Diagnostic::type_error(rule.message, span)
                             .with_primary_label(rule.primary_label);
@@ -1269,7 +1276,7 @@ impl Checker {
                                 self.standard_library.state_provider(provider).value_name
                                     == "process"
                             });
-                        if process_is_available {
+                        if !requires_attached_process || process_is_available {
                             diagnostic = diagnostic.with_machine_applicable_fix(
                                 rule.fix_title,
                                 span,

tests/compiler/diagnostics_migration.rs

@@ -845,6 +845,54 @@ fn common_timespan_constructors_have_composable_machine_fixes() {
         .expect("applying every constructor migration fix should produce valid source");
 }
 
+#[test]
+fn timespan_zero_migrates_to_the_duration_constructor() {
+    use splitscript::FixApplicability;
+
+    let source = r#"
+        state "game.exe" {}
+
+        gameTime {
+            return TimeSpan.Zero
+        }
+    "#;
+    let parsed = splitscript::parse_recovering(source).unwrap();
+    assert_eq!(parsed.diagnostics().len(), 1);
+    let type_edit = &parsed.diagnostics()[0].fixes[0].edits[0];
+    assert_eq!(
+        &source[type_edit.span.start..type_edit.span.end],
+        "TimeSpan"
+    );
+    assert_eq!(type_edit.replacement, "Duration");
+
+    let mut fixed = source.to_owned();
+    fixed.replace_range(
+        type_edit.span.start..type_edit.span.end,
+        &type_edit.replacement,
+    );
+    let diagnostics = splitscript::compile(&fixed)
+        .expect_err("the C# static property still needs a constructor-call rewrite");
+    assert_eq!(diagnostics.len(), 1);
+    let diagnostic = &diagnostics[0];
+    assert_eq!(
+        &fixed[diagnostic.span.start..diagnostic.span.end],
+        "Duration.Zero"
+    );
+    assert_eq!(diagnostic.fixes.len(), 1);
+    assert_eq!(
+        diagnostic.fixes[0].applicability,
+        FixApplicability::MachineApplicable
+    );
+    let value_edit = &diagnostic.fixes[0].edits[0];
+    assert_eq!(value_edit.replacement, "Duration.zero()");
+    fixed.replace_range(
+        value_edit.span.start..value_edit.span.end,
+        &value_edit.replacement,
+    );
+
+    splitscript::compile(&fixed).expect("the fully migrated zero duration should compile");
+}
+
 #[test]
 fn legacy_process_identity_points_to_the_attached_process_api() {
     use splitscript::FixApplicability;