Add core interface signature support

Author: olwang

README.md

@@ -363,6 +363,7 @@ Rust source lowering
 runtime crate type surface
 source map JSON for generated Rust packages
 rustc diagnostic remapping through source maps
+core `.rssi` interface signatures
 ```
 
 The first milestone is not a production runtime.
@@ -372,7 +373,7 @@ The first milestone is a strong review-first checker that can validate the langu
 Current CLI surface:
 
 ```sh
-rss check [--json] <file.rss>
+rss check [--json] [--interface <file.rssi> ...] <file.rss>
 rss check --explain <code>
 rss fmt <file.rss>
 rss review [--json] --diff <old.rss> <new.rss>

core/collections/map.rssi

@@ -0,0 +1,9 @@
+struct Map<K, V>
+
+pub fn Map.insert<K, V>(
+    map: mut Map<K, V>,
+    key: read K,
+    value: read V,
+) -> Unit
+    effects(retains(value))
+

core/fs/file.rssi

@@ -0,0 +1,12 @@
+resource File
+
+pub fn File.open(path: read Path) -> fresh File
+
+pub fn File.open_read(path: read Path) -> fresh File
+
+pub fn File.open_write(path: read Path) -> fresh File
+
+pub fn File.read_all(file: mut File) -> fresh Bytes
+
+pub fn File.write(file: mut File, data: read Bytes) -> Unit
+

core/image/image.rssi

@@ -0,0 +1,10 @@
+struct Image
+
+pub fn Image.load(path: read Path) -> fresh Image
+
+pub fn Image.resize(image: mut Image, width: Int, height: Int) -> Unit
+
+pub fn Image.save(image: read Image, path: read Path) -> Unit
+
+pub fn Image.inspect(image: read Image) -> Unit
+

core/json/json.rssi

@@ -0,0 +1,9 @@
+struct JsonValue
+
+pub fn Json.parse(text: read String) -> Result<fresh JsonValue, JsonError>
+
+pub fn Json.field_string(
+    value: read JsonValue,
+    name: read String,
+) -> Result<String, JsonError>
+

core/resource/resource_pool.rssi

@@ -0,0 +1,11 @@
+mode: uses-local
+
+struct ResourcePool<T: Resource>
+
+pub fn ResourcePool.new<T: Resource>(
+    create: read Closure,
+    max_size: Int,
+) -> fresh ResourcePool<T>
+
+pub fn ResourcePool.borrow<T: Resource>(pool: mut ResourcePool<T>) -> T
+

src/analyzer.rs

@@ -13,6 +13,29 @@ pub fn analyze_source(file: &str, source: &str) -> Vec<Diagnostic> {
     let tokens = lex(file, source);
     let syntax_program = parse_source(file, source);
     let hir = Hir::from_syntax(&syntax_program);
+    analyze_program(tokens, syntax_program, hir)
+}
+
+pub fn analyze_source_with_interfaces(
+    file: &str,
+    source: &str,
+    interfaces: &[(&str, &str)],
+) -> Vec<Diagnostic> {
+    let tokens = lex(file, source);
+    let syntax_program = parse_source(file, source);
+    let interface_programs = interfaces
+        .iter()
+        .map(|(file, source)| parse_source(file, source))
+        .collect::<Vec<_>>();
+    let hir = Hir::from_syntax_with_interfaces(&syntax_program, &interface_programs);
+    analyze_program(tokens, syntax_program, hir)
+}
+
+fn analyze_program(
+    tokens: Vec<Token>,
+    syntax_program: crate::syntax::ast::Program,
+    hir: Hir,
+) -> Vec<Diagnostic> {
     let mut analyzer = Analyzer {
         tokens: &tokens,
         syntax_program,

src/hir.rs

@@ -316,44 +316,63 @@ pub struct Hir {
 
 impl Hir {
     pub fn from_syntax(program: &SyntaxProgram) -> Self {
+        Self::from_syntax_with_interfaces(program, &[])
+    }
+
+    pub fn from_syntax_with_interfaces(
+        program: &SyntaxProgram,
+        interfaces: &[SyntaxProgram],
+    ) -> Self {
         let mut hir = Self::default();
         hir.insert_builtins();
-        let mut type_symbols = HashMap::new();
-        let mut callable_symbols = HashMap::new();
+        let mut type_symbols: HashMap<String, (DuplicateSymbolKind, Span)> = HashMap::new();
+        let mut callable_symbols: HashMap<String, (DuplicateSymbolKind, Span)> = HashMap::new();
+        for interface in interfaces {
+            hir.collect_item_signatures(interface, &mut type_symbols, &mut callable_symbols);
+        }
+        hir.collect_item_signatures(program, &mut type_symbols, &mut callable_symbols);
+        hir.collect_body_facts(program);
+        hir
+    }
+
+    fn collect_item_signatures(
+        &mut self,
+        program: &SyntaxProgram,
+        type_symbols: &mut HashMap<String, (DuplicateSymbolKind, Span)>,
+        callable_symbols: &mut HashMap<String, (DuplicateSymbolKind, Span)>,
+    ) {
         for item in &program.items {
             match item {
                 Item::Function(function) => {
                     record_duplicate_symbol(
-                        &mut hir.duplicate_symbols,
-                        &mut callable_symbols,
+                        &mut self.duplicate_symbols,
+                        callable_symbols,
                         DuplicateSymbolKind::Function,
                         &function.name,
                         &function.span,
                     );
-                    hir.insert_function(function_sig_from_decl(function));
+                    self.insert_function(function_sig_from_decl(function));
                 }
                 Item::Type(type_decl) => {
-                    record_duplicate_fields(&mut hir.duplicate_symbols, type_decl);
+                    record_duplicate_fields(&mut self.duplicate_symbols, type_decl);
                     record_duplicate_symbol(
-                        &mut hir.duplicate_symbols,
-                        &mut type_symbols,
+                        &mut self.duplicate_symbols,
+                        type_symbols,
                         DuplicateSymbolKind::Type,
                         &type_decl.name,
                         &type_decl.span,
                     );
                     record_duplicate_symbol(
-                        &mut hir.duplicate_symbols,
-                        &mut callable_symbols,
+                        &mut self.duplicate_symbols,
+                        callable_symbols,
                         DuplicateSymbolKind::Constructor,
                         &type_decl.name,
                         &type_decl.span,
                     );
-                    hir.insert_type(type_info_from_decl(type_decl));
+                    self.insert_type(type_info_from_decl(type_decl));
                 }
             }
         }
-        hir.collect_body_facts(program);
-        hir
     }
 
     pub fn resolve_function(&self, namespace: Option<&str>, name: &str) -> Option<&FunctionSig> {
@@ -1301,9 +1320,10 @@ fn callee_display(callee: &Callee) -> String {
 }
 
 fn function_sig_from_decl(function: &FunctionDecl) -> FunctionSig {
+    let (namespace, name) = split_function_name(&function.name);
     FunctionSig {
-        namespace: None,
-        name: function.name.clone(),
+        namespace,
+        name,
         is_async: function.is_async,
         params: function.params.iter().map(param_sig_from_decl).collect(),
         return_type: function.return_ty.as_ref().map(type_ref_name),
@@ -1320,6 +1340,14 @@ fn function_sig_from_decl(function: &FunctionDecl) -> FunctionSig {
     }
 }
 
+fn split_function_name(name: &str) -> (Option<String>, String) {
+    if let Some((namespace, name)) = name.rsplit_once('.') {
+        (Some(namespace.to_string()), name.to_string())
+    } else {
+        (None, name.to_string())
+    }
+}
+
 fn type_ref_name(ty: &TypeRef) -> String {
     if ty.args.is_empty() {
         return ty.name.clone();

src/lib.rs

@@ -7,7 +7,7 @@ mod review;
 mod rust_lower;
 pub mod syntax;
 
-pub use analyzer::analyze_source;
+pub use analyzer::{analyze_source, analyze_source_with_interfaces};
 pub use diagnostic::{
     Diagnostic, DiagnosticExplanation, Severity, explain_diagnostic_code,
     format_diagnostic_explanation, format_diagnostics_human, format_diagnostics_json,

src/main.rs

@@ -5,11 +5,11 @@ use std::process::ExitCode;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use rsscript::{
-    Diagnostic, analyze_source, check_generated_rust_package, explain_diagnostic_code,
-    format_diagnostic_explanation, format_diagnostics_human, format_diagnostics_json,
-    format_review_human, format_review_json, format_review_map_human, format_review_map_json,
-    lower_source_to_rust, lower_source_to_rust_package, parse_source_map_json,
-    remap_rustc_diagnostic_json_lines, review_map_sources, review_sources,
+    Diagnostic, analyze_source, analyze_source_with_interfaces, check_generated_rust_package,
+    explain_diagnostic_code, format_diagnostic_explanation, format_diagnostics_human,
+    format_diagnostics_json, format_review_human, format_review_json, format_review_map_human,
+    format_review_map_json, lower_source_to_rust, lower_source_to_rust_package,
+    parse_source_map_json, remap_rustc_diagnostic_json_lines, review_map_sources, review_sources,
     write_generated_rust_package,
 };
 
@@ -44,8 +44,8 @@ fn run_check(args: &[String]) -> ExitCode {
         return ExitCode::SUCCESS;
     }
 
-    let (json, path) = parse_path_args(args);
-    let Some(path) = path else {
+    let options = parse_check_args(args);
+    let Some(path) = options.path else {
         print_usage();
         return ExitCode::from(2);
     };
@@ -58,8 +58,23 @@ fn run_check(args: &[String]) -> ExitCode {
         }
     };
 
-    let diagnostics = analyze_source(path, &source);
-    if json {
+    let interfaces = match read_interface_sources(&options.interfaces) {
+        Ok(interfaces) => interfaces,
+        Err(error) => {
+            eprintln!("{error}");
+            return ExitCode::from(2);
+        }
+    };
+    let interface_refs = interfaces
+        .iter()
+        .map(|interface| (interface.path.as_str(), interface.contents.as_str()))
+        .collect::<Vec<_>>();
+    let diagnostics = if interface_refs.is_empty() {
+        analyze_source(path, &source)
+    } else {
+        analyze_source_with_interfaces(path, &source, &interface_refs)
+    };
+    if options.json {
         println!("{}", format_diagnostics_json(&diagnostics));
     } else if diagnostics.is_empty() {
         println!("{path}: ok");
@@ -376,6 +391,39 @@ struct LowerOptions<'a> {
     out_dir: Option<&'a str>,
 }
 
+struct CheckOptions<'a> {
+    json: bool,
+    path: Option<&'a str>,
+    interfaces: Vec<&'a str>,
+}
+
+fn parse_check_args(args: &[String]) -> CheckOptions<'_> {
+    let mut json = false;
+    let mut path = None;
+    let mut interfaces = Vec::new();
+    let mut index = 0;
+
+    while let Some(arg) = args.get(index) {
+        if arg == "--json" {
+            json = true;
+        } else if arg == "--interface" {
+            index += 1;
+            if let Some(interface) = args.get(index) {
+                interfaces.push(interface.as_str());
+            }
+        } else if path.is_none() {
+            path = Some(arg.as_str());
+        }
+        index += 1;
+    }
+
+    CheckOptions {
+        json,
+        path,
+        interfaces,
+    }
+}
+
 fn parse_lower_args(args: &[String]) -> LowerOptions<'_> {
     let mut emit_rust = false;
     let mut path = None;
@@ -401,6 +449,25 @@ fn parse_lower_args(args: &[String]) -> LowerOptions<'_> {
     }
 }
 
+struct InterfaceSource {
+    path: String,
+    contents: String,
+}
+
+fn read_interface_sources(paths: &[&str]) -> Result<Vec<InterfaceSource>, String> {
+    paths
+        .iter()
+        .map(|path| {
+            fs::read_to_string(path)
+                .map(|contents| InterfaceSource {
+                    path: (*path).to_string(),
+                    contents,
+                })
+                .map_err(|error| format!("failed to read interface {path}: {error}"))
+        })
+        .collect()
+}
+
 fn default_runtime_path() -> Result<PathBuf, String> {
     let path = env::current_dir()
         .map_err(|error| format!("failed to read current directory: {error}"))?
@@ -600,7 +667,7 @@ fn read_review_map_file(path: &Path) -> Result<ReviewMapSource, String> {
 
 fn print_usage() {
     eprintln!("usage:");
-    eprintln!("  rsscript check [--json] <file.rss>");
+    eprintln!("  rsscript check [--json] [--interface <file.rssi> ...] <file.rss>");
     eprintln!("  rsscript check --explain <code>");
     eprintln!("  rsscript fmt <file.rss>");
     eprintln!("  rsscript lower --rust <file.rss>");