fix(core): don't build control flow graph inside bogus nodes (#4963)

crates/biome_cli/tests/commands/lint.rs

@@ -4047,3 +4047,30 @@ fn linter_doesnt_crash_on_malformed_code_from_issue_4623() {
         result,
     ));
 }
+
+#[test]
+fn linter_doesnt_crash_on_malformed_code_from_issue_4723() {
+    let mut console = BufferConsole::default();
+    let mut fs = MemoryFileSystem::default();
+
+    fs.insert(
+        Utf8PathBuf::from("issue4723.js"),
+        r#"   if ndpato{      (){   if asCmesnen{   }
+  if     '&
+  else"#
+            .as_bytes(),
+    );
+
+    let (fs, result) = run_cli_with_server_workspace(
+        fs,
+        &mut console,
+        Args::from(["lint", "issue4723.js"].as_slice()),
+    );
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "linter_doesnt_crash_on_malformed_code_from_issue_4723",
+        fs,
+        console,
+        result,
+    ));
+}

crates/biome_cli/tests/snapshots/main_commands_lint/linter_doesnt_crash_on_malformed_code_from_issue_4723.snap

@@ -0,0 +1,161 @@
+---
+source: crates/biome_cli/tests/snap_test.rs
+expression: redactor(content)
+---
+## `issue4723.js`
+
+```js
+   if ndpato{      (){   if asCmesnen{   }
+  if     '&
+  else
+```
+
+# Termination Message
+
+```block
+lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+
+
+
+```
+
+# Emitted Messages
+
+```block
+issue4723.js:1:7 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × expected `(` but instead found `ndpato`
+
+  > 1 │    if ndpato{      (){   if asCmesnen{   }
+      │       ^^^^^^
+    2 │   if     '&
+    3 │   else
+
+  i Remove ndpato
+
+
+```
+
+```block
+issue4723.js:1:13 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × expected `)` but instead found `{`
+
+  > 1 │    if ndpato{      (){   if asCmesnen{   }
+      │             ^
+    2 │   if     '&
+    3 │   else
+
+  i Remove {
+
+
+```
+
+```block
+issue4723.js:1:22 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × expected `=>` but instead found `{`
+
+  > 1 │    if ndpato{      (){   if asCmesnen{   }
+      │                      ^
+    2 │   if     '&
+    3 │   else
+
+  i Remove {
+
+
+```
+
+```block
+issue4723.js:1:29 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × expected `(` but instead found `asCmesnen`
+
+  > 1 │    if ndpato{      (){   if asCmesnen{   }
+      │                             ^^^^^^^^^
+    2 │   if     '&
+    3 │   else
+
+  i Remove asCmesnen
+
+
+```
+
+```block
+issue4723.js:1:38 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × expected `)` but instead found `{`
+
+  > 1 │    if ndpato{      (){   if asCmesnen{   }
+      │                                      ^
+    2 │   if     '&
+    3 │   else
+
+  i Remove {
+
+
+```
+
+```block
+issue4723.js:2:10 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × unterminated string literal
+
+    1 │    if ndpato{      (){   if asCmesnen{   }
+  > 2 │   if     '&
+      │          ^^
+    3 │   else
+
+  i 
+
+    1 │    if ndpato{      (){   if asCmesnen{   }
+  > 2 │   if     '&
+      │          ^^
+    3 │   else
+
+  i The closing quote must be on the same line.
+
+
+```
+
+```block
+issue4723.js:3:3 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × expected `)` but instead found `else`
+
+    1 │    if ndpato{      (){   if asCmesnen{   }
+    2 │   if     '&
+  > 3 │   else
+      │   ^^^^
+
+  i Remove else
+
+
+```
+
+```block
+issue4723.js:3:7 parse ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Expected a statement but instead found the end of the file.
+
+    1 │    if ndpato{      (){   if asCmesnen{   }
+    2 │   if     '&
+  > 3 │   else
+      │       
+
+  i Expected a statement here.
+
+    1 │    if ndpato{      (){   if asCmesnen{   }
+    2 │   if     '&
+  > 3 │   else
+      │       
+
+
+```
+
+```block
+Checked 1 file in <TIME>. No fixes applied.
+Found 8 errors.
+```

crates/biome_formatter/src/diagnostics.rs

@@ -55,9 +55,9 @@ impl From<SyntaxError> for FormatError {
 impl From<&SyntaxError> for FormatError {
     fn from(syntax_error: &SyntaxError) -> Self {
         match syntax_error {
-            SyntaxError::MissingRequiredChild | SyntaxError::UnexpectedMetavariable => {
-                FormatError::SyntaxError
-            }
+            SyntaxError::MissingRequiredChild
+            | SyntaxError::UnexpectedBogusNode
+            | SyntaxError::UnexpectedMetavariable => FormatError::SyntaxError,
         }
     }
 }

crates/biome_grit_patterns/src/errors.rs

@@ -12,15 +12,12 @@ pub enum CompileError {
     /// Indicates the (top-level) pattern could not be parsed.
     ParsePatternError(ParseDiagnostic),
 
-    /// Used for missing syntax nodes.
-    MissingSyntaxNode,
+    /// Used for syntax errors.
+    SyntaxError(SyntaxError),
 
     /// A built-in function call was discovered in an unexpected context.
     UnexpectedBuiltinCall(String),
 
-    /// A metavariables was discovered in an unexpected context.
-    UnexpectedMetavariable,
-
     /// If a function with the same name is defined multiple times.
     DuplicateFunctionDefinition(String),
 
@@ -95,15 +92,18 @@ impl Diagnostic for CompileError {
                 fmt.write_markup(markup! { "Error parsing pattern: " })?;
                 diagnostic.message(fmt)
             }
-            CompileError::MissingSyntaxNode => {
+            CompileError::SyntaxError(SyntaxError::MissingRequiredChild) => {
                 fmt.write_markup(markup! { "A syntax node was missing" })
             }
-            CompileError::UnexpectedBuiltinCall(name) => {
-                fmt.write_markup(markup! { "Unexpected call to built-in: "{{name}}"()" })
+            CompileError::SyntaxError(SyntaxError::UnexpectedBogusNode) => {
+                fmt.write_markup(markup! { "Unexpected bogus node" })
             }
-            CompileError::UnexpectedMetavariable => {
+            CompileError::SyntaxError(SyntaxError::UnexpectedMetavariable) => {
                 fmt.write_markup(markup! { "Unexpected metavariable" })
             }
+            CompileError::UnexpectedBuiltinCall(name) => {
+                fmt.write_markup(markup! { "Unexpected call to built-in: "{{name}}"()" })
+            }
             CompileError::DuplicateFunctionDefinition(name) => {
                 fmt.write_markup(markup! { "Duplicate function definition: "{{name}} })
             }
@@ -202,10 +202,7 @@ impl Diagnostic for CompileError {
 
 impl From<SyntaxError> for CompileError {
     fn from(error: SyntaxError) -> Self {
-        match error {
-            SyntaxError::MissingRequiredChild => Self::MissingSyntaxNode,
-            SyntaxError::UnexpectedMetavariable => Self::UnexpectedMetavariable,
-        }
+        Self::SyntaxError(error)
     }
 }
 

crates/biome_js_analyze/src/services/control_flow/nodes.rs

@@ -1,4 +1,5 @@
 mod block;
+mod bogus;
 mod break_stmt;
 mod continue_stmt;
 mod do_while;
@@ -15,6 +16,7 @@ mod variable;
 mod while_stmt;
 
 pub(super) use block::*;
+pub(super) use bogus::*;
 pub(super) use break_stmt::*;
 pub(super) use continue_stmt::*;
 pub(super) use do_while::*;

crates/biome_js_analyze/src/services/control_flow/nodes/bogus.rs

@@ -0,0 +1,22 @@
+use biome_js_syntax::AnyJsBogusNode;
+use biome_rowan::{SyntaxError, SyntaxResult};
+
+use crate::services::control_flow::{
+    visitor::{NodeVisitor, StatementStack},
+    FunctionBuilder,
+};
+
+/// Bogus visitor.
+///
+/// The bogus visitor merely acts to abort control flow analysis inside broken
+/// code, which could otherwise mess with assumptions made inside other
+/// visitors.
+pub(in crate::services::control_flow) struct BogusVisitor;
+
+impl NodeVisitor for BogusVisitor {
+    type Node = AnyJsBogusNode;
+
+    fn enter(_: Self::Node, _: &mut FunctionBuilder, _: StatementStack) -> SyntaxResult<Self> {
+        Err(SyntaxError::UnexpectedBogusNode)
+    }
+}

crates/biome_js_analyze/src/services/control_flow/visitor.rs

@@ -125,6 +125,7 @@ declare_visitor! {
         return_stmt: ReturnVisitor,
         throw: ThrowVisitor,
         variable: VariableVisitor,
+        bogus: BogusVisitor,
     }
 }
 

crates/biome_rowan/src/ast/mod.rs

@@ -747,6 +747,9 @@ pub enum SyntaxError {
     /// Error thrown when a mandatory node is not found
     MissingRequiredChild,
 
+    /// Error thrown when a bogus node is encountered in an unexpected position
+    UnexpectedBogusNode,
+
     /// Error thrown when a metavariable node is found in an unexpected context
     UnexpectedMetavariable,
 }
@@ -755,7 +758,8 @@ impl Display for SyntaxError {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         match self {
             SyntaxError::MissingRequiredChild => fmt.write_str("missing required child"),
-            SyntaxError::UnexpectedMetavariable => fmt.write_str("unexpectedd metavariable node"),
+            SyntaxError::UnexpectedBogusNode => fmt.write_str("unexpected bogus node"),
+            SyntaxError::UnexpectedMetavariable => fmt.write_str("unexpected metavariable node"),
         }
     }
 }
@@ -828,6 +832,7 @@ pub mod support {
             match &self.0 {
                 Ok(node) => std::fmt::Debug::fmt(node, f),
                 Err(SyntaxError::MissingRequiredChild) => f.write_str("missing (required)"),
+                Err(SyntaxError::UnexpectedBogusNode) => f.write_str("bogus node"),
                 Err(SyntaxError::UnexpectedMetavariable) => f.write_str("metavariable"),
             }
         }

xtask/codegen/src/generate_nodes.rs

@@ -727,6 +727,29 @@ pub fn generate_nodes(ast: &AstSrc, language_kind: LanguageKind) -> Result<Strin
         }
     });
 
+    let any_bogus = {
+        let kinds = ast.bogus.iter().enumerate().map(|(i, bogus_name)| {
+            let ident = format_ident!("{bogus_name}");
+            if i == 0 {
+                quote! { #ident }
+            } else {
+                quote! { | #ident }
+            }
+        });
+        let ident = format_ident!(
+            "Any{}BogusNode",
+            ast.bogus
+                .iter()
+                .find_map(|bogus_name| bogus_name.strip_suffix("Bogus"))
+                .expect("expected a plain *Bogus node")
+        );
+        quote! {
+            biome_rowan::declare_node_union! {
+                pub #ident = #(#kinds)*
+            }
+        }
+    };
+
     let lists = ast.lists().map(|(name, list)| {
         let list_name = format_ident!("{}", name);
         let list_kind = format_ident!("{}", Case::Constant.convert(name));
@@ -929,6 +952,7 @@ pub fn generate_nodes(ast: &AstSrc, language_kind: LanguageKind) -> Result<Strin
         #(#union_boilerplate_impls)*
         #(#display_impls)*
         #(#bogus)*
+        #any_bogus
         #(#lists)*
 
         #[derive(Clone)]