flarelint 0.1.0

package/src/parser.rs

@@ -0,0 +1,215 @@
+use oxc_allocator::Allocator;
+use oxc_ast::ast::Program;
+use oxc_parser::Parser;
+use oxc_span::SourceType;
+use std::fs;
+use std::path::{Path, PathBuf};
+use walkdir::WalkDir;
+
+use crate::diagnostics::SourceLocation;
+
+#[derive(Debug, Clone)]
+pub struct SourceScript<'a> {
+    pub content: &'a str,
+    pub source_type: SourceType,
+    pub byte_offset: usize,
+    pub is_astro_frontmatter: bool,
+}
+
+#[derive(Debug)]
+pub struct ParsedFile<'a> {
+    pub path: PathBuf,
+    pub full_source: String,
+    pub scripts: Vec<SourceScript<'a>>,
+}
+
+pub struct AstUnit<'a> {
+    pub program: Program<'a>,
+    pub byte_offset: usize,
+    pub script_source: &'a str,
+}
+
+pub fn is_supported_source_file(path: &Path) -> bool {
+    let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+    matches!(
+        ext,
+        "js" | "mjs" | "cjs" | "ts" | "mts" | "cts" | "jsx" | "tsx" | "astro"
+    )
+}
+
+pub fn is_routes_json_file(path: &Path) -> bool {
+    path.file_name()
+        .and_then(|n| n.to_str())
+        .is_some_and(|name| name == "_routes.json")
+}
+
+pub fn discover_files(root: &Path) -> Vec<PathBuf> {
+    if root.is_file() {
+        return vec![root.to_path_buf()];
+    }
+
+    let mut files = Vec::new();
+    for entry in WalkDir::new(root)
+        .into_iter()
+        .filter_entry(|e| !should_ignore_entry(e.path()))
+        .filter_map(Result::ok)
+    {
+        let path = entry.path();
+        if path.is_file() && (is_supported_source_file(path) || is_routes_json_file(path)) {
+            files.push(path.to_path_buf());
+        }
+    }
+    files.sort();
+    files
+}
+
+pub fn should_ignore_entry(path: &Path) -> bool {
+    if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+        matches!(
+            name,
+            "node_modules"
+                | "dist"
+                | ".wrangler"
+                | ".astro"
+                | "build"
+                | "target"
+                | "coverage"
+                | ".git"
+                | ".turbo"
+                | ".next"
+        )
+    } else {
+        false
+    }
+}
+
+pub fn extract_scripts<'a>(path: &Path, content: &'a str) -> Vec<SourceScript<'a>> {
+    let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+    if ext == "astro" {
+        extract_astro_scripts(content)
+    } else {
+        let source_type = SourceType::from_path(path).unwrap_or_else(|_| {
+            SourceType::default()
+                .with_module(true)
+                .with_typescript(true)
+                .with_jsx(true)
+        });
+        vec![SourceScript {
+            content,
+            source_type,
+            byte_offset: 0,
+            is_astro_frontmatter: false,
+        }]
+    }
+}
+
+fn extract_astro_scripts(content: &str) -> Vec<SourceScript<'_>> {
+    let mut scripts = Vec::new();
+    let trimmed = content.trim_start();
+    let leading_whitespace_len = content.len() - trimmed.len();
+
+    if let Some(after_first) = trimmed.strip_prefix("---")
+        && let Some(end_idx) = after_first.find("---")
+    {
+        let frontmatter = &after_first[..end_idx];
+        let byte_offset = leading_whitespace_len + 3;
+        scripts.push(SourceScript {
+            content: frontmatter,
+            source_type: SourceType::default()
+                .with_module(true)
+                .with_typescript(true)
+                .with_jsx(true),
+            byte_offset,
+            is_astro_frontmatter: true,
+        });
+    }
+
+    let mut search_pos = 0;
+    while let Some(start_tag) = content[search_pos..].find("<script") {
+        let actual_start = search_pos + start_tag;
+        if let Some(tag_end) = content[actual_start..].find('>') {
+            let body_start = actual_start + tag_end + 1;
+            if let Some(close_tag) = content[body_start..].find("</script>") {
+                let script_body = &content[body_start..body_start + close_tag];
+                scripts.push(SourceScript {
+                    content: script_body,
+                    source_type: SourceType::default()
+                        .with_module(true)
+                        .with_typescript(true)
+                        .with_jsx(true),
+                    byte_offset: body_start,
+                    is_astro_frontmatter: false,
+                });
+                search_pos = body_start + close_tag + 9;
+            } else {
+                break;
+            }
+        } else {
+            break;
+        }
+    }
+
+    if scripts.is_empty() {
+        scripts.push(SourceScript {
+            content,
+            source_type: SourceType::default()
+                .with_module(true)
+                .with_typescript(true)
+                .with_jsx(true),
+            byte_offset: 0,
+            is_astro_frontmatter: false,
+        });
+    }
+
+    scripts
+}
+
+pub fn parse_ast<'a>(
+    allocator: &'a Allocator,
+    script: &SourceScript<'a>,
+) -> Result<AstUnit<'a>, String> {
+    let ret = Parser::new(allocator, script.content, script.source_type).parse();
+
+    if !ret.errors.is_empty() {
+        let first_err = &ret.errors[0];
+        return Err(format!("Parse error: {}", first_err));
+    }
+
+    Ok(AstUnit {
+        program: ret.program,
+        byte_offset: script.byte_offset,
+        script_source: script.content,
+    })
+}
+
+pub fn offset_to_location(
+    full_source: &str,
+    script_byte_offset: usize,
+    span_start: u32,
+    span_end: u32,
+) -> SourceLocation {
+    let absolute_start = script_byte_offset + span_start as usize;
+    let absolute_end = script_byte_offset + span_end as usize;
+    let length = absolute_end.saturating_sub(absolute_start);
+
+    let mut line = 1;
+    let mut col = 1;
+
+    let target_offset = absolute_start.min(full_source.len());
+    let sub = &full_source[..target_offset];
+
+    for c in sub.chars() {
+        if c == '\n' {
+            line += 1;
+            col = 1;
+        } else {
+            col += 1;
+        }
+    }
+
+    SourceLocation::new(line, col, target_offset, length)
+}
+
+pub fn read_file_string(path: &Path) -> Result<String, String> {
+    fs::read_to_string(path).map_err(|e| format!("Failed to read file {}: {}", path.display(), e))
+}

package/src/rules/do_storage.rs

@@ -0,0 +1,400 @@
+use oxc_ast::ast::*;
+use std::path::Path;
+
+use crate::diagnostics::Diagnostic;
+use crate::parser::{AstUnit, offset_to_location};
+
+pub struct DoStorageLinter<'a> {
+    pub file_path: &'a Path,
+    pub full_source: &'a str,
+    pub diagnostics: Vec<Diagnostic>,
+    in_transaction_depth: usize,
+}
+
+impl<'a> DoStorageLinter<'a> {
+    pub fn new(file_path: &'a Path, full_source: &'a str) -> Self {
+        Self {
+            file_path,
+            full_source,
+            diagnostics: Vec::new(),
+            in_transaction_depth: 0,
+        }
+    }
+
+    pub fn lint_ast(&mut self, ast: &AstUnit<'_>) {
+        for stmt in &ast.program.body {
+            self.visit_statement(stmt, ast);
+        }
+    }
+
+    fn extract_snippet(&self, target_line: usize) -> Option<String> {
+        let lines: Vec<&str> = self.full_source.lines().collect();
+        if target_line == 0 || target_line > lines.len() {
+            return None;
+        }
+        Some(lines[target_line - 1].trim().to_string())
+    }
+
+    fn is_storage_member_call<'b>(
+        &self,
+        call: &'b CallExpression<'_>,
+    ) -> Option<(&'b str, String)> {
+        if let Some(mem) = call.callee.as_member_expression()
+            && let Some(prop_name) = mem.static_property_name()
+            && matches!(
+                prop_name,
+                "put"
+                    | "get"
+                    | "delete"
+                    | "deleteAll"
+                    | "list"
+                    | "getAlarm"
+                    | "setAlarm"
+                    | "deleteAlarm"
+                    | "sync"
+                    | "transaction"
+                    | "sql"
+            )
+        {
+            let obj = mem.object();
+            if self.is_storage_object(obj) {
+                return Some((prop_name, self.format_member_expr(mem)));
+            }
+        }
+        None
+    }
+
+    fn format_member_expr(&self, mem: &MemberExpression<'_>) -> String {
+        let prop = mem.static_property_name().unwrap_or("method");
+        if let Some(sub_mem) = mem.object().as_member_expression() {
+            let sub_prop = sub_mem.static_property_name().unwrap_or("storage");
+            format!("{}.{}", sub_prop, prop)
+        } else {
+            match mem.object() {
+                Expression::Identifier(ident) => {
+                    format!("{}.{}", ident.name, prop)
+                }
+                Expression::ThisExpression(_) => {
+                    format!("this.{}", prop)
+                }
+                _ => format!("storage.{}", prop),
+            }
+        }
+    }
+
+    fn is_storage_object(&self, expr: &Expression<'_>) -> bool {
+        if let Some(mem) = expr.as_member_expression() {
+            if let Some(prop) = mem.static_property_name()
+                && prop == "storage"
+            {
+                return true;
+            }
+            if let Expression::ThisExpression(_) = mem.object() {
+                return mem.static_property_name() == Some("storage")
+                    || mem.static_property_name() == Some("ctx")
+                    || mem.static_property_name() == Some("state");
+            }
+            if let Some(inner) = mem.object().as_member_expression() {
+                return inner.static_property_name() == Some("storage");
+            }
+            return false;
+        }
+
+        match expr {
+            Expression::Identifier(ident) => {
+                ident.name == "storage" || ident.name == "state" || ident.name == "ctx"
+            }
+            _ => false,
+        }
+    }
+
+    fn visit_statement(&mut self, stmt: &Statement<'_>, ast: &AstUnit<'_>) {
+        match stmt {
+            Statement::ExportNamedDeclaration(export_named) => {
+                if let Some(decl) = &export_named.declaration {
+                    self.visit_declaration(decl, ast);
+                }
+            }
+            Statement::ExportDefaultDeclaration(export_default) => {
+                match &export_default.declaration {
+                    ExportDefaultDeclarationKind::ClassDeclaration(cls) => {
+                        self.visit_class(cls, ast);
+                    }
+                    ExportDefaultDeclarationKind::FunctionDeclaration(func) => {
+                        self.visit_function(func, ast);
+                    }
+                    decl => {
+                        if let Some(expr) = decl.as_expression() {
+                            self.visit_expression(expr, ast);
+                        }
+                    }
+                }
+            }
+            Statement::ExpressionStatement(expr_stmt) => {
+                if let Expression::CallExpression(call) = &expr_stmt.expression
+                    && let Some((method, display_name)) = self.is_storage_member_call(call)
+                {
+                    let loc = offset_to_location(
+                        self.full_source,
+                        ast.byte_offset,
+                        expr_stmt.span.start,
+                        expr_stmt.span.end,
+                    );
+
+                    let mut diag = Diagnostic::error(
+                        "do-storage/unawaited-storage-op",
+                        format!(
+                            "Durable Object storage operation '{display_name}()' must be awaited to guarantee persistence and avoid concurrency hazards."
+                        ),
+                        self.file_path,
+                    )
+                    .with_location(loc)
+                    .with_suggestion(
+                        format!("Add 'await' before '{display_name}(...)'."),
+                        Some(format!("await {display_name}(...)")),
+                    );
+                    diag.code_snippet = self.extract_snippet(loc.line);
+                    self.diagnostics.push(diag);
+
+                    if method == "transaction" {
+                        self.in_transaction_depth += 1;
+                        for arg in &call.arguments {
+                            if let Some(expr) = arg.as_expression() {
+                                self.visit_expression(expr, ast);
+                            }
+                        }
+                        self.in_transaction_depth -= 1;
+                        return;
+                    }
+                }
+                self.visit_expression(&expr_stmt.expression, ast);
+            }
+            Statement::BlockStatement(block) => {
+                for s in &block.body {
+                    self.visit_statement(s, ast);
+                }
+            }
+            Statement::IfStatement(if_stmt) => {
+                self.visit_expression(&if_stmt.test, ast);
+                self.visit_statement(&if_stmt.consequent, ast);
+                if let Some(alt) = &if_stmt.alternate {
+                    self.visit_statement(alt, ast);
+                }
+            }
+            Statement::VariableDeclaration(var_decl) => {
+                for decl in &var_decl.declarations {
+                    if let Some(init) = &decl.init {
+                        self.visit_expression(init, ast);
+                    }
+                }
+            }
+            Statement::FunctionDeclaration(func) => {
+                self.visit_function(func, ast);
+            }
+            Statement::ClassDeclaration(cls) => {
+                self.visit_class(cls, ast);
+            }
+            Statement::ReturnStatement(ret) => {
+                if let Some(arg) = &ret.argument {
+                    self.visit_expression(arg, ast);
+                }
+            }
+            Statement::TryStatement(try_stmt) => {
+                for s in &try_stmt.block.body {
+                    self.visit_statement(s, ast);
+                }
+                if let Some(h) = &try_stmt.handler {
+                    for s in &h.body.body {
+                        self.visit_statement(s, ast);
+                    }
+                }
+                if let Some(f) = &try_stmt.finalizer {
+                    for s in &f.body {
+                        self.visit_statement(s, ast);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_declaration(&mut self, decl: &Declaration<'_>, ast: &AstUnit<'_>) {
+        match decl {
+            Declaration::ClassDeclaration(cls) => self.visit_class(cls, ast),
+            Declaration::FunctionDeclaration(func) => self.visit_function(func, ast),
+            Declaration::VariableDeclaration(var_decl) => {
+                for d in &var_decl.declarations {
+                    if let Some(init) = &d.init {
+                        self.visit_expression(init, ast);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_function(&mut self, func: &Function<'_>, ast: &AstUnit<'_>) {
+        if let Some(body) = &func.body {
+            for s in &body.statements {
+                self.visit_statement(s, ast);
+            }
+        }
+    }
+
+    fn visit_class(&mut self, cls: &Class<'_>, ast: &AstUnit<'_>) {
+        for elem in &cls.body.body {
+            if let ClassElement::MethodDefinition(m) = elem
+                && let Some(body) = &m.value.body
+            {
+                for s in &body.statements {
+                    self.visit_statement(s, ast);
+                }
+            }
+        }
+    }
+
+    fn visit_expression(&mut self, expr: &Expression<'_>, ast: &AstUnit<'_>) {
+        match expr {
+            Expression::CallExpression(call) => {
+                if self.is_promise_all_hazard(call) {
+                    let loc = offset_to_location(
+                        self.full_source,
+                        ast.byte_offset,
+                        call.span.start,
+                        call.span.end,
+                    );
+
+                    let mut diag = Diagnostic::warning(
+                        "do-storage/concurrent-write-hazard",
+                        "Concurrent writes in Promise.all risk non-atomic state mutations and write collisions in Durable Objects.",
+                        self.file_path,
+                    )
+                    .with_location(loc)
+                    .with_suggestion(
+                        "Use 'storage.transaction(async (txn) => { ... })' for atomic batch writes.",
+                        None,
+                    );
+                    diag.code_snippet = self.extract_snippet(loc.line);
+                    self.diagnostics.push(diag);
+                }
+
+                if let Some((method, display_name)) = self.is_storage_member_call(call) {
+                    if method == "transaction" {
+                        if self.in_transaction_depth > 0 {
+                            let loc = offset_to_location(
+                                self.full_source,
+                                ast.byte_offset,
+                                call.span.start,
+                                call.span.end,
+                            );
+                            let mut diag = Diagnostic::error(
+                                "do-storage/nested-transaction",
+                                "Nested Durable Object transactions are not supported by the runtime.",
+                                self.file_path,
+                            )
+                            .with_location(loc);
+                            diag.code_snippet = self.extract_snippet(loc.line);
+                            self.diagnostics.push(diag);
+                        }
+
+                        self.in_transaction_depth += 1;
+                        for arg in &call.arguments {
+                            if let Some(arg_expr) = arg.as_expression() {
+                                self.visit_expression(arg_expr, ast);
+                            }
+                        }
+                        self.in_transaction_depth -= 1;
+                        return;
+                    }
+
+                    if self.in_transaction_depth > 0
+                        && (display_name.starts_with("this.") || display_name.starts_with("state."))
+                    {
+                        let loc = offset_to_location(
+                            self.full_source,
+                            ast.byte_offset,
+                            call.span.start,
+                            call.span.end,
+                        );
+                        let mut diag = Diagnostic::warning(
+                            "do-storage/transaction-escape",
+                            format!(
+                                "Calling '{display_name}()' inside a transaction bypasses the atomic transaction instance."
+                            ),
+                            self.file_path,
+                        )
+                        .with_location(loc)
+                        .with_suggestion(
+                            "Use the transaction handle (e.g. 'txn.put()') provided to the transaction callback.",
+                            None,
+                        );
+                        diag.code_snippet = self.extract_snippet(loc.line);
+                        self.diagnostics.push(diag);
+                    }
+                }
+
+                for arg in &call.arguments {
+                    if let Some(arg_expr) = arg.as_expression() {
+                        self.visit_expression(arg_expr, ast);
+                    }
+                }
+            }
+            Expression::AwaitExpression(aw) => {
+                self.visit_expression(&aw.argument, ast);
+            }
+            Expression::ArrowFunctionExpression(arrow) => {
+                for s in &arrow.body.statements {
+                    self.visit_statement(s, ast);
+                }
+            }
+            Expression::FunctionExpression(func) => {
+                if let Some(body) = &func.body {
+                    for s in &body.statements {
+                        self.visit_statement(s, ast);
+                    }
+                }
+            }
+            Expression::ArrayExpression(arr) => {
+                for el in &arr.elements {
+                    if let Some(e) = el.as_expression() {
+                        self.visit_expression(e, ast);
+                    }
+                }
+            }
+            Expression::ObjectExpression(obj) => {
+                for prop in &obj.properties {
+                    if let ObjectPropertyKind::ObjectProperty(p) = prop {
+                        self.visit_expression(&p.value, ast);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn is_promise_all_hazard(&self, call: &CallExpression<'_>) -> bool {
+        if let Some(mem) = call.callee.as_member_expression()
+            && let Expression::Identifier(ident) = mem.object()
+            && ident.name == "Promise"
+            && mem.static_property_name() == Some("all")
+            && let Some(first_arg) = call.arguments.first()
+            && let Some(Expression::ArrayExpression(arr)) = first_arg.as_expression()
+        {
+            let write_ops = arr
+                .elements
+                .iter()
+                .filter_map(|el| el.as_expression())
+                .filter(|e| {
+                    if let Expression::CallExpression(c) = e
+                        && let Some((method, _)) = self.is_storage_member_call(c)
+                    {
+                        return matches!(method, "put" | "delete" | "deleteAll");
+                    }
+                    false
+                })
+                .count();
+            return write_ops > 1;
+        }
+        false
+    }
+}