Require ResourcePool bindings to be local

Author: olwang

src/checks/body.rs

@@ -29,13 +29,29 @@ pub(crate) fn check(analyzer: &mut Analyzer<'_>) {
         check_retained_closure_captures(analyzer, &local_analysis);
         check_take_handle_fields(analyzer, &local_analysis);
         check_fresh_returns(analyzer, &local_analysis, &function);
+        if let Some(body) = &hir_body {
+            check_resource_pool_bindings(analyzer, body);
+        }
         let mut state = local_analysis.initial_state();
         if let Some(block) = hir_body.as_ref().and_then(|body| body.block.as_ref()) {
             check_block(analyzer, &local_analysis, block, &mut state);
         }
     }
 }
 
+fn check_resource_pool_bindings(analyzer: &mut Analyzer<'_>, body: &crate::hir::HirFunctionBody) {
+    for binding in &body.bindings {
+        if binding.kind == HirBindingKind::ManagedLet
+            && binding
+                .type_name
+                .as_deref()
+                .is_some_and(is_resource_pool_type)
+        {
+            resource_pool_not_local_diagnostic(analyzer, &binding.name, binding.span.clone());
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Flow {
     Fallthrough,
@@ -549,6 +565,10 @@ fn type_root_name(type_name: &str) -> &str {
         .map_or(type_name, |(root, _)| root)
 }
 
+fn is_resource_pool_type(type_name: &str) -> bool {
+    type_root_name(type_name) == "ResourcePool"
+}
+
 fn resource_is_active_at(
     local_analysis: &LocalAnalysis,
     binding: &str,
@@ -595,6 +615,27 @@ fn resource_pool_lease_escape_diagnostic(
     );
 }
 
+fn resource_pool_not_local_diagnostic(
+    analyzer: &mut Analyzer<'_>,
+    binding: &str,
+    span: crate::diagnostic::Span,
+) {
+    analyzer.diagnostics.push(
+        Diagnostic::error(
+            code::RESOURCE_POOL_NOT_LOCAL,
+            format!("ResourcePool binding `{binding}` must be local."),
+            span,
+            "ResourcePool must be local",
+        )
+        .with_cause("ResourcePool owns long-lived resources and must not be hidden behind an ordinary managed binding.")
+        .with_fix(
+            "make_resource_pool_local",
+            format!("Declare `{binding}` with `local` instead of `let`."),
+            "machine-applicable",
+        ),
+    );
+}
+
 fn resource_capture_diagnostic(
     analyzer: &mut Analyzer<'_>,
     binding: &str,

src/diagnostic.rs

@@ -23,6 +23,7 @@ pub mod code {
     pub const RESOURCE_ESCAPE: &str = "RS0702";
     pub const INVALID_RESOURCE_POOL_TYPE: &str = "RS0703";
     pub const RESOURCE_GENERIC_ARGUMENT: &str = "RS0704";
+    pub const RESOURCE_POOL_NOT_LOCAL: &str = "RS0705";
     pub const LOCAL_CAPTURED_BY_MANAGED_CLOSURE: &str = "RS0801";
     pub const TAKE_HANDLE_FIELD: &str = "RS0901";
     pub const OPERATOR_OVERLOAD_ATTEMPT: &str = "RS1001";
@@ -302,6 +303,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "resource in ordinary generic type",
         explanation: "Resource values may only be held by explicit resource APIs such as `ResourcePool<T: Resource>`; ordinary generic containers must not be instantiated with resource types.",
     },
+    DiagnosticExplanation {
+        code: code::RESOURCE_POOL_NOT_LOCAL,
+        title: "ResourcePool must be local",
+        explanation: "`ResourcePool<T>` must be held in a local binding so its resource lifetime and pool ownership stay explicit.",
+    },
     DiagnosticExplanation {
         code: code::LOCAL_CAPTURED_BY_MANAGED_CLOSURE,
         title: "local captured by managed closure",

tests/fixtures/fail/resourcepool-managed-binding.rss

@@ -0,0 +1,17 @@
+// expect: RS0705
+mode: uses-local
+
+resource DbConnection {
+    fd: Int
+
+    drop {
+        Db.close(fd: fd)
+    }
+}
+
+fn bad_pool(url: read Url) -> Unit {
+    let pool = ResourcePool<DbConnection>.new(
+        create: || DbConnection.open(url: read url),
+        max_size: 4,
+    )
+}