feat(compiler): parse declared resource type keys

Author: ffonion

src/compiler/parser/mod.rs

@@ -17,7 +17,7 @@ use crate::builtins::{
 };
 use crate::compiler::modules::{UseDecl, UsePathSegment};
 use crate::compiler::source_map::{SourceId, Span};
-use crate::host_api::{HostApiCatalog, HostFunctionSchema};
+use crate::host_api::{HostApiCatalog, HostFunctionSchema, ResourceTypeKey};
 
 pub(crate) use self::expressions::host_generic_type_arg_arity;
 use self::lexer::{Lexer, ParserFormatArg, Token, TokenKind, is_ident_continue, is_ident_start};

src/compiler/parser/statements.rs

@@ -966,6 +966,24 @@ impl Parser {
                 "bool" => TypeSchema::Bool,
                 "string" => TypeSchema::String,
                 "bytes" => TypeSchema::Bytes,
+                "resource" => {
+                    self.expect(&TokenKind::Less, "expected '<' before resource type key")?;
+                    let mut key = self.expect_ident("expected resource type key")?;
+                    while self.match_kind(&TokenKind::Dot) {
+                        key.push('.');
+                        key.push_str(
+                            &self.expect_ident("expected resource type key segment after '.'")?,
+                        );
+                    }
+                    self.expect(&TokenKind::Greater, "expected '>' after resource type key")?;
+                    let key = ResourceTypeKey::new(key.clone()).map_err(|error| ParseError {
+                        span: Some(span),
+                        code: None,
+                        line: self.current_line(),
+                        message: format!("invalid resource type key '{key}': {error}"),
+                    })?;
+                    TypeSchema::Resource(key)
+                }
                 "array" => {
                     if self.match_kind(&TokenKind::Less) {
                         let element = self.parse_declared_type_schema()?;

tests/host_resource_type_inference_tests.rs

@@ -686,6 +686,27 @@ fn default_analysis_resolves_standard_catalog_calls_and_annotations() {
     );
 }
 
+#[test]
+fn declared_resource_type_parses_qualified_key_and_resolves_borrow_call() {
+    let model = analyze_source_from_string_with_options(
+        "resource_param.rss",
+        r#"
+use sqlite;
+fn query(db: resource<sqlite.connection>) -> int {
+    sqlite::query(&db, "SELECT 1")
+}
+"#,
+        CompileSourceFileOptions::default().with_host_api_catalog(test_catalog()),
+    )
+    .expect("qualified resource type declaration should parse and analyze");
+
+    assert!(
+        model.diagnostics().is_empty(),
+        "declared resource parameter should resolve exactly: {:?}",
+        model.diagnostics()
+    );
+}
+
 #[cfg(feature = "runtime")]
 #[test]
 fn explicit_analysis_catalog_is_not_augmented_by_standard_catalog() {