Use syntax AST for resource field checks

Author: olwang

src/analyzer.rs

@@ -3,7 +3,7 @@ use crate::checks;
 use crate::diagnostic::Diagnostic;
 use crate::hir::{FunctionSig, Hir, HirTypeKind};
 use crate::lexer::{Token, lex};
-use crate::syntax::ast::Callee;
+use crate::syntax::ast::{Callee, Item};
 use crate::syntax::parse_source;
 
 pub fn analyze_source(file: &str, source: &str) -> Vec<Diagnostic> {
@@ -137,16 +137,19 @@ impl Analyzer<'_> {
     }
 
     fn check_resource_fields(&mut self) {
-        for decl in self.program.types.values() {
+        for item in &self.syntax_program.items {
+            let Item::Type(decl) = item else {
+                continue;
+            };
             if self.hir.type_kind(&decl.name) == Some(HirTypeKind::Resource) {
                 continue;
             }
             for field in &decl.fields {
-                if self.hir.type_kind(&field.type_name) == Some(HirTypeKind::Resource) {
+                if self.hir.type_kind(&field.ty.name) == Some(HirTypeKind::Resource) {
                     self.diagnostics.push(
                         Diagnostic::error(
                             "RS0701",
-                            format!("resource `{}` cannot be stored in `{}`.", field.type_name, decl.name),
+                            format!("resource `{}` cannot be stored in `{}`.", field.ty.name, decl.name),
                             field.span.clone(),
                             "resource field",
                         )

src/ast.rs

@@ -9,18 +9,6 @@ pub enum FileMode {
     UsesLocal,
 }
 
-#[derive(Debug, Clone)]
-pub struct FieldDecl {
-    pub type_name: String,
-    pub span: Span,
-}
-
-#[derive(Debug, Clone)]
-pub struct TypeDecl {
-    pub name: String,
-    pub fields: Vec<FieldDecl>,
-}
-
 #[derive(Debug, Clone)]
 pub struct Param {
     pub name: String,
@@ -39,7 +27,6 @@ pub struct FunctionDecl {
 #[derive(Debug, Default)]
 pub struct Program {
     pub mode: Option<(FileMode, Span)>,
-    pub types: HashMap<String, TypeDecl>,
     pub functions: HashMap<String, FunctionDecl>,
 }
 
@@ -66,7 +53,7 @@ impl Parser<'_> {
                 self.parse_mode();
             } else if self.at_ident("class") || self.at_ident("struct") || self.at_ident("resource")
             {
-                self.parse_type_decl();
+                self.skip_type_decl();
             } else if self.at_ident("pub") || self.at_ident("async") || self.at_ident("fn") {
                 self.parse_function_decl();
             } else {
@@ -94,52 +81,17 @@ impl Parser<'_> {
         self.index += 1;
     }
 
-    fn parse_type_decl(&mut self) {
+    fn skip_type_decl(&mut self) {
         self.index += 1;
-        let Some(name) = self.take_ident_name() else {
+        if self.take_ident_name().is_none() {
             return;
-        };
-        let mut fields = Vec::new();
+        }
         if !self.at_symbol("{") {
             return;
         }
-        self.index += 1;
         let body_end = self
-            .find_matching(self.index - 1, "{", "}")
+            .find_matching(self.index, "{", "}")
             .unwrap_or(self.tokens.len() - 1);
-        let mut i = self.index;
-        while i < body_end {
-            if self.tokens[i].is_ident_text("drop") {
-                i = skip_block(self.tokens, i).unwrap_or(body_end);
-                continue;
-            }
-            let field_name_index = i;
-            if ident_name(&self.tokens[field_name_index]).is_some()
-                && self
-                    .tokens
-                    .get(field_name_index + 1)
-                    .is_some_and(|token| token.symbol(":"))
-            {
-                let mut type_start = field_name_index + 2;
-                let is_handle = self
-                    .tokens
-                    .get(type_start)
-                    .is_some_and(|token| token.is_ident_text("handle"));
-                if is_handle {
-                    type_start += 1;
-                }
-                if let Some(type_name) = first_type_name(self.tokens, type_start, body_end) {
-                    fields.push(FieldDecl {
-                        type_name,
-                        span: self.tokens[field_name_index].span.clone(),
-                    });
-                }
-            }
-            i += 1;
-        }
-        self.program
-            .types
-            .insert(name.clone(), TypeDecl { name, fields });
         self.index = body_end + 1;
     }
 
@@ -292,11 +244,6 @@ pub fn find_matching(
     None
 }
 
-fn skip_block(tokens: &[Token], start: usize) -> Option<usize> {
-    let open = (start..tokens.len()).find(|index| tokens[*index].symbol("{"))?;
-    find_matching(tokens, open, "{", "}").map(|index| index + 1)
-}
-
 fn first_type_name(tokens: &[Token], start: usize, end: usize) -> Option<String> {
     (start..end).find_map(|index| match &tokens[index].kind {
         TokenKind::Ident(value) => Some(value.clone()),