fix(compiler): preserve declared resource schemas across branches

Author: ffonion

src/compiler/typing/state.rs

@@ -361,12 +361,35 @@ impl LocalTypeState {
             if merged != BoundType::Unknown {
                 self.by_slot.insert(slot, merged);
             }
-            if lhs.schema(slot) == rhs.schema(slot)
-                && let Some(schema) = lhs.schema(slot).cloned()
+            let lhs_schema = lhs.schema(slot);
+            let rhs_schema = rhs.schema(slot);
+            let one_sided_declared_resource =
+                match (lhs.has_declared_schema(slot), rhs.has_declared_schema(slot)) {
+                    (true, false) => lhs_schema
+                        .filter(|schema| schema.contains_resource())
+                        .cloned(),
+                    (false, true) => rhs_schema
+                        .filter(|schema| schema.contains_resource())
+                        .cloned(),
+                    _ => None,
+                };
+            let declared_schema = if lhs.has_declared_schema(slot)
+                && rhs.has_declared_schema(slot)
+                && lhs_schema == rhs_schema
             {
+                lhs_schema.cloned()
+            } else {
+                one_sided_declared_resource
+            };
+            let merged_schema = if lhs_schema == rhs_schema {
+                lhs_schema.cloned()
+            } else {
+                declared_schema.clone()
+            };
+            if let Some(schema) = merged_schema {
                 self.schemas.insert(slot, schema);
             }
-            if lhs.has_declared_schema(slot) && rhs.has_declared_schema(slot) {
+            if declared_schema.is_some() {
                 self.declared_schema_slots.insert(slot);
             }
             if lhs.is_optional(slot) || rhs.is_optional(slot) {
@@ -443,3 +466,25 @@ pub(crate) struct HostCallableSignature {
     #[cfg_attr(not(feature = "runtime"), allow(dead_code))]
     pub(crate) runtime_builtin: bool,
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::host_api::ResourceTypeKey;
+
+    use super::*;
+
+    #[test]
+    fn branch_merge_preserves_one_sided_declared_resource_schema() {
+        let slot = 7;
+        let schema = TypeSchema::Resource(ResourceTypeKey::new("sqlite.connection").unwrap());
+        let mut declared_branch = LocalTypeState::default();
+        declared_branch.set_with_schema_origin(slot, BoundType::Int, Some(schema.clone()), true);
+        let empty_branch = LocalTypeState::default();
+
+        let mut merged = LocalTypeState::default();
+        merged.merge_from_branches(&declared_branch, &empty_branch);
+
+        assert_eq!(merged.schema(slot), Some(&schema));
+        assert!(merged.has_declared_schema(slot));
+    }
+}

tests/host_resource_type_inference_tests.rs

@@ -695,6 +695,10 @@ use sqlite;
 fn query(db: resource<sqlite.connection>) -> int {
     sqlite::query(&db, "SELECT 1")
 }
+fn forwarded(db: resource<sqlite.connection>) -> int {
+    query(&db);
+    query(&db)
+}
 "#,
         CompileSourceFileOptions::default().with_host_api_catalog(test_catalog()),
     )

tests/semantic_model_exact_tests.rs

@@ -116,6 +116,56 @@ fn analyze_modules(root: &str, overrides: &[(&str, &str)]) -> SemanticModel {
     model
 }
 
+#[test]
+fn declared_resource_schema_survives_cross_module_parameter_forwarding() {
+    let root = r#"
+use io;
+use outer;
+let db = io::open("db");
+outer::run(db, true);
+"#;
+    let outer = r#"
+use inner;
+pub fn run(db: resource<db.session>, use_first: bool) -> string {
+    let mut failed: bool = false;
+    if use_first {
+        if !inner::session_exists(&db) {
+            failed = true;
+        }
+    }
+    if failed == false {
+        if use_first && !inner::run_exists(&db) {
+            failed = true;
+        }
+    }
+    if failed == false {
+        inner::read(&db)
+    } else {
+        "missing"
+    }
+}
+"#;
+    let inner = r#"
+use io;
+pub fn session_exists(db: resource<db.session>) -> bool {
+    io::read(&db) != ""
+}
+pub fn run_exists(db: resource<db.session>) -> bool {
+    io::read(&db) != ""
+}
+pub fn read(db: resource<db.session>) -> string {
+    io::read(&db)
+}
+"#;
+
+    let model = analyze_modules(root, &[("outer", outer), ("inner", inner)]);
+    assert!(
+        model.diagnostics().is_empty(),
+        "resource schema must survive module linking and forwarding: {:?}",
+        model.diagnostics()
+    );
+}
+
 /// The completion labels at a position in the given source, in order.
 fn labels(model: &SemanticModel, offset: usize) -> Vec<String> {
     model