Reject unsupported ownership surface syntax

Author: olwang

src/analyzer.rs

@@ -163,6 +163,7 @@ impl Analyzer<'_> {
                 if param.effect.is_none()
                     && !param.ty.name.is_empty()
                     && param.ty.name != "share"
+                    && !type_ref_has_surface_reference(&param.ty, self.tokens)
                     && !is_copy_type(&param.ty)
                 {
                     self.diagnostics.push(
@@ -747,3 +748,12 @@ fn type_ref_name(ty: &TypeRef) -> String {
         .join(", ");
     format!("{}<{args}>", ty.name)
 }
+
+fn type_ref_has_surface_reference(ty: &TypeRef, tokens: &[Token]) -> bool {
+    tokens.iter().any(|token| {
+        token.symbol("&")
+            && token.span.file == ty.span.file
+            && token.span.line == ty.span.line
+            && token.span.column + token.span.length <= ty.span.column
+    })
+}

src/checks/forbidden.rs

@@ -5,6 +5,64 @@ use crate::lexer::TokenKind;
 pub(crate) fn check(analyzer: &mut Analyzer<'_>) {
     check_operator_overload_attempts(analyzer);
     check_implicit_conversion_attempts(analyzer);
+    check_own_struct_attempts(analyzer);
+    check_surface_reference_attempts(analyzer);
+}
+
+fn check_own_struct_attempts(analyzer: &mut Analyzer<'_>) {
+    for index in 0..analyzer.tokens.len().saturating_sub(1) {
+        if analyzer.tokens[index].is_ident_text("own")
+            && analyzer.tokens[index + 1].is_ident_text("struct")
+        {
+            analyzer.diagnostics.push(
+                Diagnostic::error(
+                    code::OWN_STRUCT_ATTEMPT,
+                    "`own struct` is not part of RSScript v0.4.1.",
+                    analyzer.tokens[index].span.clone(),
+                    "own struct attempt",
+                )
+                .with_cause("v0.4.1 has only `class`, `struct`, and `resource` type declarations.")
+                .with_fix(
+                    "choose_type_kind",
+                    "Use `struct` for inline values, `class` for managed identity, or `resource` for deterministic cleanup.",
+                    "manual",
+                ),
+            );
+        }
+    }
+}
+
+fn check_surface_reference_attempts(analyzer: &mut Analyzer<'_>) {
+    for index in 0..analyzer.tokens.len() {
+        if !analyzer.tokens[index].symbol("&") || is_boolean_and(analyzer, index) {
+            continue;
+        }
+        analyzer.diagnostics.push(
+            Diagnostic::error(
+                code::SURFACE_REFERENCE_ATTEMPT,
+                "surface reference syntax is not part of RSScript.",
+                analyzer.tokens[index].span.clone(),
+                "surface reference attempt",
+            )
+            .with_cause("RSScript uses explicit data effects instead of `&T` or `&mut T` syntax.")
+            .with_fix(
+                "use_data_effect",
+                "Use a parameter effect such as `value: read T` or `value: mut T`.",
+                "manual",
+            ),
+        );
+    }
+}
+
+fn is_boolean_and(analyzer: &Analyzer<'_>, index: usize) -> bool {
+    analyzer
+        .tokens
+        .get(index.wrapping_sub(1))
+        .is_some_and(|token| token.symbol("&"))
+        || analyzer
+            .tokens
+            .get(index + 1)
+            .is_some_and(|token| token.symbol("&"))
 }
 
 fn check_implicit_conversion_attempts(analyzer: &mut Analyzer<'_>) {

src/diagnostic.rs

@@ -35,6 +35,8 @@ pub mod code {
     pub const TAKE_HANDLE_FIELD: &str = "RS0901";
     pub const OPERATOR_OVERLOAD_ATTEMPT: &str = "RS1001";
     pub const IMPLICIT_CONVERSION_ATTEMPT: &str = "RS1002";
+    pub const OWN_STRUCT_ATTEMPT: &str = "RS1003";
+    pub const SURFACE_REFERENCE_ATTEMPT: &str = "RS1004";
 
     pub const REVIEW_MODE_CHANGED: &str = "RSR001";
     pub const REVIEW_FUNCTION_REMOVED: &str = "RSR002";
@@ -371,6 +373,16 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "implicit conversion attempt",
         explanation: "RSScript rejects cast-style conversion syntax. Conversions must be visible named APIs such as `Type.from(value: read x)`.",
     },
+    DiagnosticExplanation {
+        code: code::OWN_STRUCT_ATTEMPT,
+        title: "own struct attempt",
+        explanation: "RSScript v0.4.1 has exactly three type declaration kinds: `class`, `struct`, and `resource`. There is no `own struct`.",
+    },
+    DiagnosticExplanation {
+        code: code::SURFACE_REFERENCE_ATTEMPT,
+        title: "surface reference attempt",
+        explanation: "RSScript does not expose `&T` or `&mut T` syntax. Use explicit parameter effects such as `read`, `mut`, and `take`.",
+    },
 ];
 
 pub fn format_diagnostics_json(diagnostics: &[Diagnostic]) -> String {

tests/fixtures/fail/own-struct-declaration.rss

@@ -0,0 +1,10 @@
+// expect: RS1003
+mode: managed
+
+own struct Buffer {
+    bytes: Bytes
+}
+
+fn make_buffer(bytes: read Bytes) -> fresh Buffer {
+    return Buffer(bytes: read bytes)
+}

tests/fixtures/fail/surface-mut-reference-parameter.rss

@@ -0,0 +1,6 @@
+// expect: RS1004
+mode: managed
+
+fn clear(buffer: &mut Buffer) -> Unit {
+    Buffer.clear(buffer: mut buffer)
+}

tests/fixtures/fail/surface-reference-parameter.rss

@@ -0,0 +1,6 @@
+// expect: RS1004
+mode: managed
+
+fn hash(data: &Bytes) -> UInt64 {
+    return Bytes.hash(data: read data)
+}