Diagnose unsupported syntax before lowering

Author: olwang

RSScript_v0.5_Spec.md

@@ -2365,6 +2365,7 @@ take of handle field
 implicit conversion attempt
 operator overload attempt
 feature violation
+unsupported syntax
 unmappable rustc diagnostic
 native boundary violation
 ```

src/analyzer.rs

@@ -5,7 +5,8 @@ use crate::diagnostic::{Diagnostic, code};
 use crate::hir::{DuplicateSymbolKind, Hir, HirTypeKind};
 use crate::lexer::{Token, lex};
 use crate::syntax::ast::{
-    Callee, DataEffect, EffectDecl, Expr, GenericBound, GenericParam, Item, Stmt, TypeKind, TypeRef,
+    Block, Callee, DataEffect, EffectDecl, Expr, GenericBound, GenericParam, Item, Stmt, TypeKind,
+    TypeRef,
 };
 use crate::syntax::parse_source;
 
@@ -90,6 +91,7 @@ impl Analyzer<'_> {
     fn run(&mut self) {
         self.check_single_feature_declaration();
         self.check_removed_profile_declarations();
+        self.check_unsupported_syntax();
         self.check_duplicate_declarations();
         self.check_signature_explicitness();
         self.check_generic_constraints();
@@ -142,6 +144,112 @@ impl Analyzer<'_> {
         }
     }
 
+    fn check_unsupported_syntax(&mut self) {
+        let bodies = self
+            .syntax_program
+            .items
+            .iter()
+            .filter_map(|item| match item {
+                Item::Function(function) => Some(function.body.clone()),
+                Item::Type(_) => None,
+            })
+            .collect::<Vec<_>>();
+        for body in &bodies {
+            self.check_unsupported_syntax_block(body);
+        }
+    }
+
+    fn check_unsupported_syntax_block(&mut self, block: &Block) {
+        for statement in &block.statements {
+            self.check_unsupported_syntax_stmt(statement);
+        }
+    }
+
+    fn check_unsupported_syntax_stmt(&mut self, statement: &Stmt) {
+        match statement {
+            Stmt::Let(stmt) => {
+                if let Some(value) = &stmt.value {
+                    self.check_unsupported_syntax_expr(value);
+                }
+            }
+            Stmt::Return(stmt) => {
+                if let Some(value) = &stmt.value {
+                    self.check_unsupported_syntax_expr(value);
+                }
+            }
+            Stmt::With(stmt) => {
+                self.check_unsupported_syntax_expr(&stmt.resource);
+                self.check_unsupported_syntax_block(&stmt.body);
+            }
+            Stmt::If(stmt) => {
+                self.check_unsupported_syntax_expr(&stmt.condition);
+                self.check_unsupported_syntax_block(&stmt.then_body);
+                if let Some(else_body) = &stmt.else_body {
+                    self.check_unsupported_syntax_block(else_body);
+                }
+            }
+            Stmt::Loop(stmt) => {
+                if let Some(condition) = &stmt.condition {
+                    self.check_unsupported_syntax_expr(condition);
+                }
+                self.check_unsupported_syntax_block(&stmt.body);
+            }
+            Stmt::Expr(expr) => self.check_unsupported_syntax_expr(expr),
+            Stmt::Break(_) | Stmt::Continue(_) => {}
+            Stmt::Unknown(span) => self.unsupported_syntax(
+                span.clone(),
+                "unsupported statement",
+                "This statement is outside the current RSScript parser surface.",
+            ),
+        }
+    }
+
+    fn check_unsupported_syntax_expr(&mut self, expr: &Expr) {
+        match expr {
+            Expr::Binary { left, right, .. } => {
+                self.check_unsupported_syntax_expr(left);
+                self.check_unsupported_syntax_expr(right);
+            }
+            Expr::Field { base, .. } => self.check_unsupported_syntax_expr(base),
+            Expr::Index { base, index, .. } => {
+                self.check_unsupported_syntax_expr(base);
+                self.check_unsupported_syntax_expr(index);
+            }
+            Expr::Call { args, .. } => {
+                for arg in args {
+                    self.check_unsupported_syntax_expr(&arg.value);
+                }
+            }
+            Expr::Effect { value, .. } | Expr::Manage { value, .. } | Expr::Try { value, .. } => {
+                self.check_unsupported_syntax_expr(value);
+            }
+            Expr::Closure { body, .. } => self.check_unsupported_syntax_block(body),
+            Expr::Ident(_, _) | Expr::Number(_, _) | Expr::String(_, _) => {}
+            Expr::Unknown(span) => self.unsupported_syntax(
+                span.clone(),
+                "unsupported expression",
+                "This expression is outside the current RSScript parser surface.",
+            ),
+        }
+    }
+
+    fn unsupported_syntax(&mut self, span: crate::diagnostic::Span, label: &str, cause: &str) {
+        self.diagnostics.push(
+            Diagnostic::error(
+                code::UNSUPPORTED_SYNTAX,
+                "unsupported RSScript syntax.",
+                span,
+                label,
+            )
+            .with_cause(cause)
+            .with_fix(
+                "rewrite_supported_syntax",
+                "Rewrite this construct using the currently supported RSScript syntax.",
+                "manual",
+            ),
+        );
+    }
+
     fn check_signature_explicitness(&mut self) {
         for item in &self.syntax_program.items {
             let Item::Function(function) = item else {

src/diagnostic.rs

@@ -15,6 +15,7 @@ pub mod code {
     pub const REMOVED_RUNTIME_EFFECT: &str = "RS0012";
     pub const INVALID_TRY_OPERATOR: &str = "RS0013";
     pub const INVALID_NOALLOC_ALLOCATION: &str = "RS0014";
+    pub const UNSUPPORTED_SYNTAX: &str = "RS0015";
     pub const FEATURE_VIOLATION: &str = "RS0101";
     pub const UNNAMED_ARGUMENT: &str = "RS0201";
     pub const MISSING_DATA_EFFECT: &str = "RS0202";
@@ -279,6 +280,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "invalid try operator",
         explanation: "`?` may only be used inside functions that return a compatible `Result<T, E>` type.",
     },
+    DiagnosticExplanation {
+        code: code::UNSUPPORTED_SYNTAX,
+        title: "unsupported syntax",
+        explanation: "The frontend parser could not lower this source construct into the supported RSScript AST. The checker reports this before Rust lowering so unsupported source does not become generated Rust `todo!()` code.",
+    },
     DiagnosticExplanation {
         code: code::INVALID_NOALLOC_ALLOCATION,
         title: "invalid noalloc allocation",

tests/fixtures/fail/unsupported-with-syntax.rss

@@ -0,0 +1,7 @@
+// expect: RS0015
+
+fn bad(path: read Path) -> Unit {
+    with File.open(path: read path) {
+        return Unit
+    }
+}