Require Result returns for try operator

Author: olwang

src/analyzer.rs

@@ -35,6 +35,7 @@ impl Analyzer<'_> {
         self.check_removed_profile_declarations();
         self.check_duplicate_declarations();
         self.check_signature_explicitness();
+        self.check_try_operator_result_returns();
         self.check_resource_fields();
         self.check_resource_pool_type_arguments();
         self.check_resource_generic_arguments();
@@ -311,6 +312,57 @@ impl Analyzer<'_> {
         }
     }
 
+    fn check_try_operator_result_returns(&mut self) {
+        for (index, item) in self.syntax_program.items.iter().enumerate() {
+            let Item::Function(function) = item else {
+                continue;
+            };
+            if function
+                .return_ty
+                .as_ref()
+                .is_some_and(|return_ty| return_ty.name == "Result")
+            {
+                continue;
+            }
+
+            let start = self
+                .tokens
+                .iter()
+                .position(|token| token.span == function.span)
+                .unwrap_or(0);
+            let end = self
+                .syntax_program
+                .items
+                .iter()
+                .skip(index + 1)
+                .map(item_span)
+                .find_map(|span| self.tokens.iter().position(|token| token.span == *span))
+                .unwrap_or(self.tokens.len());
+
+            for token in &self.tokens[start..end] {
+                if token.symbol("?") {
+                    self.diagnostics.push(
+                        Diagnostic::error(
+                            code::INVALID_TRY_OPERATOR,
+                            format!(
+                                "`?` in `{}` requires the function to return `Result<T, E>`.",
+                                function.name
+                            ),
+                            token.span.clone(),
+                            "invalid try operator",
+                        )
+                        .with_cause("RSScript represents recoverable failure in explicit `Result` return types.")
+                        .with_fix(
+                            "return_result_or_handle_error",
+                            "Change the return type to `Result<..., E>` or handle the error explicitly.",
+                            "manual",
+                        ),
+                    );
+                }
+            }
+        }
+    }
+
     fn check_duplicate_declarations(&mut self) {
         for duplicate in self.hir.duplicate_symbols() {
             self.diagnostics.push(
@@ -702,6 +754,13 @@ fn removed_runtime_effect_replacement(effect_name: &str) -> Option<&'static str>
     }
 }
 
+fn item_span(item: &Item) -> &crate::diagnostic::Span {
+    match item {
+        Item::Type(decl) => &decl.span,
+        Item::Function(function) => &function.span,
+    }
+}
+
 fn duplicate_symbol_label(kind: DuplicateSymbolKind) -> &'static str {
     match kind {
         DuplicateSymbolKind::Function => "function",

src/diagnostic.rs

@@ -13,6 +13,7 @@ pub mod code {
     pub const REMOVED_PROFILE_DECLARATION: &str = "RS0010";
     pub const REMOVED_SHARE_EFFECT: &str = "RS0011";
     pub const REMOVED_RUNTIME_EFFECT: &str = "RS0012";
+    pub const INVALID_TRY_OPERATOR: &str = "RS0013";
     pub const FILE_MODE_VIOLATION: &str = "RS0101";
     pub const UNNAMED_ARGUMENT: &str = "RS0201";
     pub const MISSING_DATA_EFFECT: &str = "RS0202";
@@ -263,6 +264,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "removed runtime effect",
         explanation: "RSScript v0.4.1 uses reductive guarantees. Additive runtime effects such as `io`, `allocates`, `may_panic`, and `may_fail` are not valid effects.",
     },
+    DiagnosticExplanation {
+        code: code::INVALID_TRY_OPERATOR,
+        title: "invalid try operator",
+        explanation: "`?` may only be used inside functions that return a compatible `Result<T, E>` type.",
+    },
     DiagnosticExplanation {
         code: code::FILE_MODE_VIOLATION,
         title: "file mode violation",

tests/fixtures/fail/try-operator-non-result.rss

@@ -0,0 +1,11 @@
+// expect: RS0013
+mode: managed
+
+struct Image {
+    pixels: Buffer
+}
+
+fn load_or_default(path: read Path) -> Image {
+    let image = Image.load(path: read path)?
+    return image
+}