Reject fresh returns of non-struct types

Author: olwang

src/checks/body.rs

@@ -1,7 +1,7 @@
 use crate::analyzer::Analyzer;
 use crate::diagnostic::{Diagnostic, code};
 use crate::hir::{HirBindingKind, HirBlock, HirExpr, HirStmt, HirTypeKind};
-use crate::syntax::ast::{Callee, FunctionDecl, Item};
+use crate::syntax::ast::{Callee, FunctionDecl, Item, TypeRef};
 
 use super::local::{
     BodyState, FreshReturnIssue, FreshReturnIssueKind, LocalAnalysis, ManagedToLocalUse, MovedUse,
@@ -249,6 +249,7 @@ fn check_fresh_returns(
     if !function.returns_fresh {
         return;
     }
+    check_fresh_return_type(analyzer, function);
     for issue in local_analysis.fresh_return_issues() {
         match &issue.kind {
             FreshReturnIssueKind::NotClean { name } => {
@@ -262,6 +263,28 @@ fn check_fresh_returns(
     }
 }
 
+fn check_fresh_return_type(analyzer: &mut Analyzer<'_>, function: &FunctionDecl) {
+    let Some(return_ty) = &function.return_ty else {
+        return;
+    };
+    let target = fresh_return_target_type(return_ty);
+    match analyzer.hir.type_kind(&target.name) {
+        Some(HirTypeKind::Struct) | None => {}
+        Some(HirTypeKind::Class) | Some(HirTypeKind::Resource) => {
+            invalid_fresh_return_type_diagnostic(analyzer, function, target);
+        }
+    }
+}
+
+fn fresh_return_target_type(return_ty: &TypeRef) -> &TypeRef {
+    if matches!(return_ty.name.as_str(), "Result" | "Option")
+        && let Some(first_arg) = return_ty.args.first()
+    {
+        return first_arg;
+    }
+    return_ty
+}
+
 fn managed_to_local_diagnostic(analyzer: &mut Analyzer<'_>, managed_to_local: ManagedToLocalUse) {
     analyzer.diagnostics.push(
         Diagnostic::error(
@@ -631,6 +654,30 @@ fn freshness_unknown_diagnostic(
     );
 }
 
+fn invalid_fresh_return_type_diagnostic(
+    analyzer: &mut Analyzer<'_>,
+    function: &FunctionDecl,
+    target: &TypeRef,
+) {
+    analyzer.diagnostics.push(
+        Diagnostic::error(
+            code::INVALID_FRESH_RETURN_TYPE,
+            format!(
+                "function `{}` declares `fresh {}` but `{}` is not a struct.",
+                function.name, target.name, target.name
+            ),
+            target.span.clone(),
+            "invalid fresh type",
+        )
+        .with_cause("RSScript `fresh` is a shallow guarantee for newly created struct shells.")
+        .with_fix(
+            "use_struct_fresh_type",
+            "Return a struct type as fresh, or remove `fresh` from this return contract.",
+            "manual",
+        ),
+    );
+}
+
 fn trusted_fresh_ident(analyzer: &Analyzer<'_>, name: &str) -> bool {
     analyzer.hir.type_kind(name) == Some(HirTypeKind::Struct)
         || analyzer

src/diagnostic.rs

@@ -18,6 +18,7 @@ pub mod code {
     pub const LOCAL_VALUE_RETAINED: &str = "RS0501";
     pub const FRESH_RETURN_NOT_CLEAN: &str = "RS0601";
     pub const FRESHNESS_UNKNOWN: &str = "RS0602";
+    pub const INVALID_FRESH_RETURN_TYPE: &str = "RS0603";
     pub const RESOURCE_FIELD: &str = "RS0701";
     pub const RESOURCE_ESCAPE: &str = "RS0702";
     pub const LOCAL_CAPTURED_BY_MANAGED_CLOSURE: &str = "RS0801";
@@ -274,6 +275,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "freshness unknown",
         explanation: "The MVP checker could not prove the returned value is fresh. Current proof support trusts clean locals, struct constructors, and known fresh calls.",
     },
+    DiagnosticExplanation {
+        code: code::INVALID_FRESH_RETURN_TYPE,
+        title: "invalid fresh return type",
+        explanation: "`fresh` may only be used with struct types. Classes and resources are not fresh values.",
+    },
     DiagnosticExplanation {
         code: code::RESOURCE_FIELD,
         title: "resource field",

tests/fixtures/fail/fresh-result-class-type.rss

@@ -0,0 +1,10 @@
+// expect: RS0603
+mode: managed
+
+class User {
+    name: String
+}
+
+fn load_user() -> Result<fresh User, UserError> {
+    return User(name: "Ada")
+}

tests/fixtures/fail/fresh-return-class-type.rss

@@ -0,0 +1,10 @@
+// expect: RS0603
+mode: managed
+
+class User {
+    name: String
+}
+
+fn current_user() -> fresh User {
+    return User(name: "Ada")
+}