Reject invalid pure effect contracts

Author: olwang

src/analyzer.rs

@@ -4,7 +4,7 @@ use crate::checks;
 use crate::diagnostic::{Diagnostic, code};
 use crate::hir::{DuplicateSymbolKind, Hir, HirTypeKind};
 use crate::lexer::{Token, lex};
-use crate::syntax::ast::{Callee, EffectDecl, Expr, Item, Stmt, TypeRef};
+use crate::syntax::ast::{Callee, DataEffect, EffectDecl, Expr, Item, Stmt, TypeRef};
 use crate::syntax::parse_source;
 
 pub fn analyze_source(file: &str, source: &str) -> Vec<Diagnostic> {
@@ -187,6 +187,60 @@ impl Analyzer<'_> {
                     );
                 }
             }
+
+            if function
+                .effects
+                .iter()
+                .any(|effect| matches!(effect, EffectDecl::Name(name) if name == "pure"))
+            {
+                for param in function
+                    .params
+                    .iter()
+                    .filter(|param| param.effect == Some(DataEffect::Mut))
+                {
+                    self.diagnostics.push(
+                        Diagnostic::error(
+                            code::INVALID_PURE_EFFECT,
+                            format!(
+                                "`{}` is declared pure but parameter `{}` is mutable.",
+                                function.name, param.name
+                            ),
+                            param.span.clone(),
+                            "mutable parameter in pure function",
+                        )
+                        .with_cause("A `pure` function must not mutate reachable managed state.")
+                        .with_fix(
+                            "remove_pure_or_mut",
+                            "Remove `pure`, or change the parameter to `read` if the function does not mutate it.",
+                            "manual",
+                        ),
+                    );
+                }
+
+                for effect in function
+                    .effects
+                    .iter()
+                    .filter(|effect| matches!(effect, EffectDecl::Retains(_)))
+                {
+                    self.diagnostics.push(
+                        Diagnostic::error(
+                            code::INVALID_PURE_EFFECT,
+                            format!(
+                                "`{}` is declared pure but also retains a parameter.",
+                                function.name
+                            ),
+                            function.span.clone(),
+                            "retention in pure function",
+                        )
+                        .with_cause("A `pure` function must not retain parameters after returning.")
+                        .with_fix(
+                            "remove_pure_or_retains",
+                            format!("Remove `pure` or remove `{}`.", effect_display(effect)),
+                            "manual",
+                        ),
+                    );
+                }
+            }
         }
     }
 
@@ -553,6 +607,13 @@ fn effect_name(effect: &EffectDecl) -> &str {
     }
 }
 
+fn effect_display(effect: &EffectDecl) -> String {
+    match effect {
+        EffectDecl::Name(name) => name.clone(),
+        EffectDecl::Retains(param) => format!("retains({param})"),
+    }
+}
+
 fn duplicate_symbol_label(kind: DuplicateSymbolKind) -> &'static str {
     match kind {
         DuplicateSymbolKind::Function => "function",

src/diagnostic.rs

@@ -9,6 +9,7 @@ pub mod code {
     pub const DUPLICATE_FILE_MODE: &str = "RS0006";
     pub const UNKNOWN_RETAINED_PARAMETER: &str = "RS0007";
     pub const MISSING_PARAMETER_EFFECT: &str = "RS0008";
+    pub const INVALID_PURE_EFFECT: &str = "RS0009";
     pub const FILE_MODE_VIOLATION: &str = "RS0101";
     pub const UNNAMED_ARGUMENT: &str = "RS0201";
     pub const MISSING_DATA_EFFECT: &str = "RS0202";
@@ -236,6 +237,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "missing parameter data effect",
         explanation: "Non-Copy parameters must declare `read`, `mut`, or `take` in the function signature so call effects are review-visible.",
     },
+    DiagnosticExplanation {
+        code: code::INVALID_PURE_EFFECT,
+        title: "invalid pure effect",
+        explanation: "`effects(pure)` is a guarantee that the function does not mutate reachable managed state and does not retain parameters.",
+    },
     DiagnosticExplanation {
         code: code::FILE_MODE_VIOLATION,
         title: "file mode violation",

tests/fixtures/fail/pure-mut-parameter.rss

@@ -0,0 +1,12 @@
+// expect: RS0009
+mode: managed
+
+struct Image {
+    pixels: Buffer
+}
+
+fn normalize(image: mut Image) -> Image
+    effects(pure)
+{
+    return image
+}

tests/fixtures/fail/pure-retains-parameter.rss

@@ -0,0 +1,12 @@
+// expect: RS0009
+mode: managed
+
+struct Image {
+    pixels: Buffer
+}
+
+fn memoize(image: read Image) -> Image
+    effects(pure, retains(image))
+{
+    return image
+}

tests/fixtures/pass/pure-read-function.rss

@@ -0,0 +1,11 @@
+mode: managed
+
+struct StringView {
+    value: String
+}
+
+fn normalize_path(path: read String) -> fresh StringView
+    effects(pure)
+{
+    return StringView(value: read path)
+}