Validate file feature declarations

Author: olwang

README.md

@@ -122,7 +122,7 @@ Files are managed-only by default. Advanced capabilities must be declared with `
 features: local
 ```
 
-The MVP implements only `local`. Future feature names such as `native`, `unsafe`, `async`, and `device` are reserved for capabilities that change review risk or require checker/runtime support. Ordinary libraries like JSON, File, Image, HTTP, Map, and Regex are not features.
+The MVP implements only `local`. Future feature names such as `native`, `unsafe`, `async`, `device`, `ffi`, and `reflection` are reserved for capabilities that change review risk or require checker/runtime support. Ordinary libraries like JSON, File, Image, HTTP, Map, and Regex are not features.
 
 ### Reviewable at the boundary
 

RSScript_v0.5_Spec.md

@@ -2544,7 +2544,7 @@ manage operation
 effects(retains(...))
 with resource
 ResourcePool
-file features such as local/native/unsafe/async/device
+file features such as local/native/unsafe/async/device/ffi/reflection
 native / unsafe
 unknown external call
 writes to managed state
@@ -2562,6 +2562,8 @@ async        elevated risk
 native       high risk
 unsafe       high risk
 device       high risk
+ffi          high risk
+reflection   elevated risk
 ```
 
 This file-level risk does not require every helper function in the file to be classified as must-review. Region classification still depends on the function's own semantic facts and propagated callee risk.

src/analyzer.rs

@@ -66,6 +66,7 @@ pub(crate) struct Analyzer<'a> {
 impl Analyzer<'_> {
     fn run(&mut self) {
         self.check_single_feature_declaration();
+        self.check_unknown_file_features();
         self.check_removed_profile_declarations();
         self.check_unsupported_syntax();
         self.check_duplicate_declarations();
@@ -101,6 +102,27 @@ impl Analyzer<'_> {
         }
     }
 
+    fn check_unknown_file_features(&mut self) {
+        for feature in &self.syntax_program.unknown_features {
+            self.diagnostics.push(
+                Diagnostic::error(
+                    code::UNKNOWN_FILE_FEATURE,
+                    format!("Unknown file feature `{}`.", feature.name),
+                    feature.span.clone(),
+                    "unknown feature",
+                )
+                .with_cause(
+                    "File features must be review-relevant capabilities recognized by this compiler.",
+                )
+                .with_fix(
+                    "remove_or_correct_feature",
+                    "Remove the feature name or replace it with a supported feature such as `local`.",
+                    "manual",
+                ),
+            );
+        }
+    }
+
     fn check_removed_profile_declarations(&mut self) {
         for span in &self.syntax_program.profile_spans {
             self.diagnostics.push(

src/diagnostic.rs

@@ -16,6 +16,7 @@ pub mod code {
     pub const INVALID_TRY_OPERATOR: &str = "RS0013";
     pub const INVALID_NOALLOC_ALLOCATION: &str = "RS0014";
     pub const UNSUPPORTED_SYNTAX: &str = "RS0015";
+    pub const UNKNOWN_FILE_FEATURE: &str = "RS0016";
     pub const FEATURE_VIOLATION: &str = "RS0101";
     pub const UNNAMED_ARGUMENT: &str = "RS0201";
     pub const MISSING_DATA_EFFECT: &str = "RS0202";
@@ -290,6 +291,11 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "invalid noalloc allocation",
         explanation: "`effects(noalloc)` forbids obvious allocation sites such as value construction and `manage` migration.",
     },
+    DiagnosticExplanation {
+        code: code::UNKNOWN_FILE_FEATURE,
+        title: "unknown file feature",
+        explanation: "A `features:` header may only list review-relevant capabilities known to this compiler version. Unknown feature names are rejected so typos do not silently change review risk.",
+    },
     DiagnosticExplanation {
         code: code::FEATURE_VIOLATION,
         title: "feature violation",

src/review.rs

@@ -1101,21 +1101,25 @@ fn feature_name(feature: &FileFeature) -> &'static str {
         FileFeature::Unsafe => "unsafe",
         FileFeature::Async => "async",
         FileFeature::Device => "device",
+        FileFeature::Ffi => "ffi",
+        FileFeature::Reflection => "reflection",
     }
 }
 
 fn review_map_file_risk(features: &[FileFeature]) -> ReviewMapFileRisk {
     if features.iter().any(|feature| {
         matches!(
             feature,
-            FileFeature::Native | FileFeature::Unsafe | FileFeature::Device
+            FileFeature::Native | FileFeature::Unsafe | FileFeature::Device | FileFeature::Ffi
         )
     }) {
         ReviewMapFileRisk::High
-    } else if features
-        .iter()
-        .any(|feature| matches!(feature, FileFeature::Local | FileFeature::Async))
-    {
+    } else if features.iter().any(|feature| {
+        matches!(
+            feature,
+            FileFeature::Local | FileFeature::Async | FileFeature::Reflection
+        )
+    }) {
         ReviewMapFileRisk::Elevated
     } else {
         ReviewMapFileRisk::Low
@@ -1136,6 +1140,8 @@ fn review_map_feature_reason(feature: &str) -> Option<&'static str> {
         "unsafe" => Some("unsafe capability enabled"),
         "async" => Some("async control-flow capability enabled"),
         "device" => Some("device capability enabled"),
+        "ffi" => Some("ffi boundary capability enabled"),
+        "reflection" => Some("reflection capability enabled"),
         _ => None,
     }
 }

src/rust_lower.rs

@@ -318,10 +318,14 @@ impl<'a> RustLowerer<'a> {
         out.push_str(
             "// Runtime hooks are intentionally explicit while Rust lowering is stabilizing.\n",
         );
-        if self.program.has_feature(FileFeature::Local) {
-            out.push_str("// RSScript features: local\n");
-        } else {
+        let feature_names = lowered_feature_names(&self.program.features);
+        if feature_names.is_empty() {
             out.push_str("// RSScript features: <none>\n");
+        } else {
+            out.push_str(&format!(
+                "// RSScript features: {}\n",
+                feature_names.join(", ")
+            ));
         }
         out.push('\n');
 
@@ -1758,6 +1762,24 @@ fn rust_package_main(program: &Program, package_name: &str) -> Option<String> {
     ))
 }
 
+fn lowered_feature_names(features: &[FileFeature]) -> Vec<&'static str> {
+    let mut names = features
+        .iter()
+        .map(|feature| match feature {
+            FileFeature::Local => "local",
+            FileFeature::Native => "native",
+            FileFeature::Unsafe => "unsafe",
+            FileFeature::Async => "async",
+            FileFeature::Device => "device",
+            FileFeature::Ffi => "ffi",
+            FileFeature::Reflection => "reflection",
+        })
+        .collect::<Vec<_>>();
+    names.sort_unstable();
+    names.dedup();
+    names
+}
+
 fn is_runnable_main(function: &FunctionDecl) -> bool {
     runnable_main_kind(function).is_some()
 }

src/syntax/ast.rs

@@ -7,11 +7,20 @@ pub enum FileFeature {
     Unsafe,
     Async,
     Device,
+    Ffi,
+    Reflection,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UnknownFileFeature {
+    pub name: String,
+    pub span: Span,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Program {
     pub features: Vec<FileFeature>,
+    pub unknown_features: Vec<UnknownFileFeature>,
     pub feature_spans: Vec<Span>,
     pub profile_spans: Vec<Span>,
     pub items: Vec<Item>,

src/syntax/parser.rs

@@ -2,7 +2,7 @@ use crate::lexer::{Token, TokenKind, lex};
 use crate::syntax::ast::{
     BinaryOp, Block, CallArg, Callee, DataEffect, EffectDecl, Expr, FieldDecl, FileFeature,
     FunctionDecl, GenericBound, GenericParam, IfStmt, Item, LetKind, LetStmt, LoopStmt, Param,
-    Program, ReturnStmt, Stmt, TypeDecl, TypeKind, TypeRef, WithStmt,
+    Program, ReturnStmt, Stmt, TypeDecl, TypeKind, TypeRef, UnknownFileFeature, WithStmt,
 };
 
 pub fn parse_source(file: &str, source: &str) -> Program {
@@ -19,17 +19,25 @@ struct Parser<'a> {
     index: usize,
 }
 
+struct ParsedFeatures {
+    features: Vec<FileFeature>,
+    unknown_features: Vec<UnknownFileFeature>,
+}
+
 impl Parser<'_> {
     fn parse_program(&mut self) -> Program {
         let mut features = Vec::new();
+        let mut unknown_features = Vec::new();
         let mut feature_spans = Vec::new();
         let mut profile_spans = Vec::new();
         let mut items = Vec::new();
 
         while !self.is_eof() {
             if self.at_ident("features") && self.peek_symbol(1, ":") {
                 feature_spans.push(self.tokens[self.index].span.clone());
-                features.extend(self.parse_features());
+                let parsed = self.parse_features();
+                features.extend(parsed.features);
+                unknown_features.extend(parsed.unknown_features);
             } else if self.at_ident("profile") && self.peek_symbol(1, ":") {
                 profile_spans.push(self.tokens[self.index].span.clone());
                 self.index += 1;
@@ -49,27 +57,40 @@ impl Parser<'_> {
 
         Program {
             features,
+            unknown_features,
             feature_spans,
             profile_spans,
             items,
         }
     }
 
-    fn parse_features(&mut self) -> Vec<FileFeature> {
+    fn parse_features(&mut self) -> ParsedFeatures {
         self.index += 2;
         let end = declaration_line_end(self.tokens, self.index);
         let mut features = Vec::new();
+        let mut unknown_features = Vec::new();
         while self.index < end {
             if self.at_symbol(",") {
                 self.index += 1;
                 continue;
             }
-            if let Some(feature) = parse_file_feature(self.tokens.get(self.index)) {
+            let token = self.tokens.get(self.index);
+            if let Some(feature) = parse_file_feature(token) {
                 features.push(feature);
+            } else if let Some(token) = token
+                && !matches!(token.kind, TokenKind::Eof)
+            {
+                unknown_features.push(UnknownFileFeature {
+                    name: token.text(),
+                    span: token.span.clone(),
+                });
             }
             self.index += 1;
         }
-        features
+        ParsedFeatures {
+            features,
+            unknown_features,
+        }
     }
 
     fn parse_type_decl(&mut self) -> Option<TypeDecl> {
@@ -1080,6 +1101,10 @@ fn parse_file_feature(token: Option<&Token>) -> Option<FileFeature> {
         Some(FileFeature::Async)
     } else if token.is_ident_text("device") {
         Some(FileFeature::Device)
+    } else if token.is_ident_text("ffi") {
+        Some(FileFeature::Ffi)
+    } else if token.is_ident_text("reflection") {
+        Some(FileFeature::Reflection)
     } else {
         None
     }

tests/checker.rs

@@ -1642,6 +1642,28 @@ async fn fetch(url: read Url) -> Result<fresh Bytes, NetworkError>
     assert!(analyze_source("net.rssi", source).is_empty());
 }
 
+#[test]
+fn checker_rejects_unknown_file_features() {
+    let source = r#"
+features: local, locall
+
+fn main() -> Unit {
+    return Unit
+}
+"#;
+    let program = parse_source("features.rss", source);
+
+    assert_eq!(program.features.len(), 1);
+    assert_eq!(program.unknown_features.len(), 1);
+    assert_eq!(program.unknown_features[0].name, "locall");
+    let diagnostics = analyze_source("features.rss", source);
+    assert!(
+        diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.code == "RS0016")
+    );
+}
+
 #[test]
 fn review_map_marks_public_rssi_signatures_review_required() {
     let source = r#"
@@ -1886,15 +1908,18 @@ fn update(counter: read Counter) -> Unit {
 #[test]
 fn review_map_reports_file_features() {
     let source = r#"
-features: local, native
+features: local, native, ffi, reflection
 
 fn process() -> Unit {
     return Unit
 }
 "#;
     let map = review_map_sources(vec![("features.rss", source)]);
 
-    assert_eq!(map.files[0].features, vec!["local", "native"]);
+    assert_eq!(
+        map.files[0].features,
+        vec!["ffi", "local", "native", "reflection"]
+    );
     assert_eq!(map.files[0].risk, ReviewMapFileRisk::High);
     assert!(
         map.files[0]
@@ -1908,12 +1933,26 @@ fn process() -> Unit {
             .iter()
             .any(|reason| reason == "native boundary capability enabled")
     );
+    assert!(
+        map.files[0]
+            .reasons
+            .iter()
+            .any(|reason| reason == "ffi boundary capability enabled")
+    );
+    assert!(
+        map.files[0]
+            .reasons
+            .iter()
+            .any(|reason| reason == "reflection capability enabled")
+    );
     let human = format_review_map_human(&map);
-    assert!(human.contains("features.rss: features local, native; risk high"));
+    assert!(human.contains("features.rss: features ffi, local, native, reflection; risk high"));
     let json: Value =
         serde_json::from_str(&format_review_map_json(&map)).expect("review map JSON should parse");
-    assert_eq!(json["files"][0]["features"][0], "local");
-    assert_eq!(json["files"][0]["features"][1], "native");
+    assert_eq!(json["files"][0]["features"][0], "ffi");
+    assert_eq!(json["files"][0]["features"][1], "local");
+    assert_eq!(json["files"][0]["features"][2], "native");
+    assert_eq!(json["files"][0]["features"][3], "reflection");
     assert_eq!(json["files"][0]["risk"], "high");
     assert!(
         json["files"][0]["reasons"]

tests/fixtures/fail/unknown-file-feature.rss

@@ -0,0 +1,6 @@
+// expect: RS0016
+features: locall
+
+fn main() -> Unit {
+    return Unit
+}