refactor(semantic,linter): assert that Program is always the first node (#12123)

Follow on to #12087

> We might be able to improve perf of AstNodes::ancestor_ids a little by
using a custom iterator, instead of std::iter::successors.
> Also, node_id == NodeId::DUMMY would be a cheaper check than parent_id
== node_id. The NodeId of Program in practice is always NodeId::DUMMY
(0), but we don't have a static guarantee of that at present. But we
could get that guarantee by adding assert!(self.parent_ids.is_empty())
to the top of AstNodes::add_program_node (or maybe just debug_assert!).
> @overlookmotel in
#12087 (comment)

My changes:
- added constant NodeId::ROOT (same value as NodeId::DUMMY, but leads to
more intuitive code)
- added asserts in `add_program_node` that nodes are empty and node kind
that's being added is Program
- ancestor_kinds and ancestors now build upon ancestor_ids, making
std::iter::successors implementation obsolete
- make AstNodeParentIter simpler by iterating over node ids and by
making use of previous assertions of `add_program_node`
- remove root, root_node and root_node_mut functions and replace their
use with either new program function or NodeId::ROOT

Results in general much less code, especially less boilerplate code in
the linter around getting the program node. Also might hopefully yield
some small benchmark improvements.

Edit:
Only very minor if not zero improvements on the linter benchmarks :(

I also noticed while working on this that the ancestor iterator methods
where documented as "The first node produced by this iterator is the
first parent of the node pointed to by node_id". That statement was
incorrect because all the iterators didn't yield the parent of node_id,
but node_id itself as first item. I updated the documentation of these
methods to correctly reflect their implementation.

Author: ulrichstark

crates/oxc_linter/src/rules/eslint/no_eval.rs

@@ -214,11 +214,8 @@ impl Rule for NoEval {
                         return;
                     }
 
-                    let root = ctx.nodes().get_node(ctx.nodes().root().unwrap());
-                    let program = root.kind().as_program().unwrap();
-
                     let is_valid = if scope_flags.is_top() {
-                        program.source_type.is_script()
+                        ctx.nodes().program().unwrap().source_type.is_script()
                     } else {
                         let node = ctx.nodes().get_node(ctx.scoping().get_node_id(scope_id));
                         ast_util::is_default_this_binding(ctx, node, true)

crates/oxc_linter/src/rules/eslint/no_unreachable.rs

@@ -8,6 +8,7 @@ use oxc_cfg::{
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
+use oxc_semantic::NodeId;
 use oxc_span::{GetSpan, Span};
 
 use crate::{context::LintContext, rule::Rule};
@@ -54,7 +55,7 @@ declare_oxc_lint!(
 impl Rule for NoUnreachable {
     fn run_once(&self, ctx: &LintContext) {
         let nodes = ctx.nodes();
-        let Some(root) = nodes.root_node() else { return };
+        let root = nodes.get_node(NodeId::ROOT);
         let cfg = ctx.cfg();
         let graph = cfg.graph();
 

crates/oxc_linter/src/rules/eslint/sort_imports.rs

@@ -6,10 +6,7 @@ use std::{
 
 use cow_utils::CowUtils;
 use itertools::Itertools;
-use oxc_ast::{
-    AstKind,
-    ast::{ImportDeclaration, ImportDeclarationSpecifier, Statement},
-};
+use oxc_ast::ast::{ImportDeclaration, ImportDeclarationSpecifier, Statement};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
@@ -137,10 +134,7 @@ impl Rule for SortImports {
     }
 
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root) = ctx.nodes().root_node() else {
-            return;
-        };
-        let AstKind::Program(program) = root.kind() else { unreachable!() };
+        let program = ctx.nodes().program().unwrap();
 
         let mut import_declarations = vec![];
 

crates/oxc_linter/src/rules/import/exports_last.rs

@@ -1,8 +1,5 @@
 use itertools::Itertools;
-use oxc_ast::{
-    AstKind,
-    ast::{ModuleDeclaration, Statement},
-};
+use oxc_ast::ast::{ModuleDeclaration, Statement};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
@@ -54,19 +51,15 @@ declare_oxc_lint!(
 impl Rule for ExportsLast {
     fn run_once(&self, ctx: &LintContext<'_>) {
         // find last non export declaration index
-        let Some(root) = ctx.nodes().root_node() else {
-            return;
-        };
-        if let AstKind::Program(program) = root.kind() {
-            let body = &program.body;
-            let find_res =
-                body.iter().rev().find_position(|statement| !is_exports_declaration(statement));
-            if let Some((index, _)) = find_res {
-                let end = body.len() - index;
-                for statement in &body[0..end] {
-                    if is_exports_declaration(statement) {
-                        ctx.diagnostic(exports_last_diagnostic(statement.span()));
-                    }
+        let program = ctx.nodes().program().unwrap();
+        let body = &program.body;
+        let find_res =
+            body.iter().rev().find_position(|statement| !is_exports_declaration(statement));
+        if let Some((index, _)) = find_res {
+            let end = body.len() - index;
+            for statement in &body[0..end] {
+                if is_exports_declaration(statement) {
+                    ctx.diagnostic(exports_last_diagnostic(statement.span()));
                 }
             }
         }

crates/oxc_linter/src/rules/import/first.rs

@@ -1,9 +1,6 @@
 use std::convert::From;
 
-use oxc_ast::{
-    AstKind,
-    ast::{Statement, TSModuleReference},
-};
+use oxc_ast::ast::{Statement, TSModuleReference};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
@@ -113,10 +110,7 @@ impl Rule for First {
         let mut non_import_count = 0;
         let mut any_relative = false;
 
-        let Some(root) = ctx.nodes().root_node() else {
-            return;
-        };
-        let AstKind::Program(program) = root.kind() else { unreachable!() };
+        let program = ctx.nodes().program().unwrap();
 
         for statement in &program.body {
             match statement {

crates/oxc_linter/src/rules/jest/no_duplicate_hooks.rs

@@ -104,18 +104,15 @@ declare_oxc_lint!(
 
 impl Rule for NoDuplicateHooks {
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root_node) = ctx.nodes().root_node() else {
-            return;
-        };
         let mut hook_contexts: FxHashMap<NodeId, Vec<FxHashMap<String, i32>>> =
             FxHashMap::default();
-        hook_contexts.insert(root_node.id(), Vec::new());
+        hook_contexts.insert(NodeId::ROOT, Vec::new());
 
         let mut possibles_jest_nodes = collect_possible_jest_call_node(ctx);
         possibles_jest_nodes.sort_by_key(|n| n.node.id());
 
         for possible_jest_node in possibles_jest_nodes {
-            Self::run(&possible_jest_node, root_node.id(), &mut hook_contexts, ctx);
+            Self::run(&possible_jest_node, NodeId::ROOT, &mut hook_contexts, ctx);
         }
     }
 }

crates/oxc_linter/src/rules/nextjs/no_async_client_component.rs

@@ -90,10 +90,7 @@ declare_oxc_lint!(
 
 impl Rule for NoAsyncClientComponent {
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root) = ctx.nodes().root_node() else {
-            return;
-        };
-        let AstKind::Program(program) = root.kind() else { unreachable!() };
+        let program = ctx.nodes().program().unwrap();
 
         if program.directives.iter().any(|directive| directive.directive.as_str() == "use client") {
             for node in &program.body {

crates/oxc_linter/src/rules/typescript/consistent_type_imports.rs

@@ -576,8 +576,7 @@ fn get_type_only_named_import<'a>(
     ctx: &LintContext<'a>,
     source: &str,
 ) -> Option<&'a ImportDeclaration<'a>> {
-    let root = ctx.nodes().root_node()?;
-    let program = root.kind().as_program()?;
+    let program = ctx.nodes().program().unwrap();
 
     for stmt in &program.body {
         let Statement::ImportDeclaration(import_decl) = stmt else {

crates/oxc_linter/src/rules/typescript/triple_slash_reference.rs

@@ -1,7 +1,4 @@
-use oxc_ast::{
-    AstKind,
-    ast::{Statement, TSModuleReference},
-};
+use oxc_ast::ast::{Statement, TSModuleReference};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
@@ -109,10 +106,7 @@ impl Rule for TripleSlashReference {
     }
 
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root) = ctx.nodes().root_node() else {
-            return;
-        };
-        let AstKind::Program(program) = root.kind() else { unreachable!() };
+        let program = ctx.nodes().program().unwrap();
 
         // We don't need to iterate over all comments since Triple-slash directives are only valid at the top of their containing file.
         // We are trying to get the first statement start potioin, falling back to the program end if statement does not exist

crates/oxc_linter/src/rules/unicorn/no_empty_file.rs

@@ -1,4 +1,3 @@
-use oxc_ast::AstKind;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
@@ -44,11 +43,7 @@ declare_oxc_lint!(
 
 impl Rule for NoEmptyFile {
     fn run_once(&self, ctx: &LintContext) {
-        let Some(root) = ctx.nodes().root_node() else {
-            return;
-        };
-
-        let AstKind::Program(program) = root.kind() else { unreachable!() };
+        let program = ctx.nodes().program().unwrap();
         if program.body.iter().any(|node| !is_empty_stmt(node)) {
             return;
         }