Reject allocating calls in noalloc functions

Author: olwang

src/analyzer.rs

@@ -712,14 +712,22 @@ impl Analyzer<'_> {
             Expr::Call {
                 callee, args, span, ..
             } => {
-                if let Callee::Name(name) = callee
-                    && self.hir.type_kind(name).is_some()
-                {
-                    self.noalloc_allocation_diagnostic(
-                        function_name,
-                        span,
-                        format!("constructor `{name}` creates a new value."),
-                    );
+                match self.hir.resolve_call(callee) {
+                    CallResolution::Resolved { signature, kind } => {
+                        if matches!(kind, ResolvedCalleeKind::Constructor { .. }) {
+                            self.noalloc_allocation_diagnostic(
+                                function_name,
+                                span,
+                                format!(
+                                    "constructor `{}` creates a new value.",
+                                    callee_display(callee)
+                                ),
+                            );
+                        } else if !signature.effects.iter().any(|effect| effect == "noalloc") {
+                            self.allocating_call_diagnostic(function_name, callee, span);
+                        }
+                    }
+                    CallResolution::EnumVariant | CallResolution::Unknown => {}
                 }
                 for arg in args {
                     self.check_noalloc_expr(function_name, &arg.value);
@@ -1397,6 +1405,33 @@ impl Analyzer<'_> {
         );
     }
 
+    fn allocating_call_diagnostic(
+        &mut self,
+        function_name: &str,
+        callee: &Callee,
+        span: &crate::diagnostic::Span,
+    ) {
+        self.diagnostics.push(
+            Diagnostic::error(
+                code::INVALID_NOALLOC_CALL,
+                format!(
+                    "`{function_name}` is declared noalloc but calls possibly allocating function `{}`.",
+                    callee_display(callee)
+                ),
+                span.clone(),
+                "possibly allocating call in noalloc function",
+            )
+            .with_cause(
+                "A `noalloc` function may only call enum variants or functions also declared `effects(noalloc)`.",
+            )
+            .with_fix(
+                "remove_noalloc_or_call_noalloc",
+                "Remove `noalloc`, or call only APIs whose signatures are declared `effects(noalloc)`.",
+                "manual",
+            ),
+        );
+    }
+
     fn non_pure_call_diagnostic(
         &mut self,
         function_name: &str,

src/diagnostic.rs

@@ -20,6 +20,7 @@ pub mod code {
     pub const DUPLICATE_FILE_FEATURE: &str = "RS0017";
     pub const INVALID_NO_BLOCK_CALL: &str = "RS0018";
     pub const INVALID_NO_PANIC_CALL: &str = "RS0019";
+    pub const INVALID_NOALLOC_CALL: &str = "RS0020";
     pub const FEATURE_VIOLATION: &str = "RS0101";
     pub const UNNAMED_ARGUMENT: &str = "RS0201";
     pub const MISSING_DATA_EFFECT: &str = "RS0202";
@@ -317,6 +318,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "invalid no_panic call",
         explanation: "`effects(no_panic)` is a guarantee that the function does not intentionally panic. Calls inside it must target constructors, enum variants, or functions also declared `effects(no_panic)`.",
     },
+    DiagnosticExplanation {
+        code: code::INVALID_NOALLOC_CALL,
+        title: "invalid noalloc call",
+        explanation: "`effects(noalloc)` is a guarantee that the function performs no heap allocation. Calls inside it must target enum variants or functions also declared `effects(noalloc)`, while direct constructors and `manage` are allocation diagnostics.",
+    },
     DiagnosticExplanation {
         code: code::FEATURE_VIOLATION,
         title: "feature violation",

tests/fixtures/fail/noalloc-plain-call.rss

@@ -0,0 +1,11 @@
+// expect: RS0020
+
+fn may_allocate(value: Int) -> Int {
+    return value
+}
+
+fn promised_noalloc(value: Int) -> Int
+    effects(noalloc)
+{
+    return may_allocate(value: value)
+}

tests/fixtures/pass/noalloc-helper-call.rss

@@ -0,0 +1,11 @@
+fn cheap_id(value: Int) -> Int
+    effects(noalloc)
+{
+    return value
+}
+
+fn cheap_wrapper(value: Int) -> Int
+    effects(noalloc)
+{
+    return cheap_id(value: value)
+}