fix: update code for oxc 0.123 API changes (Atom -> Ident)

Agent-Logs-Url: https://github.com/voidzero-dev/oxc-angular-compiler/sessions/e30e0210-0bc0-4fde-89cf-53e615179571

Co-authored-by: Brooooooklyn <3468483+Brooooooklyn@users.noreply.github.com>

Author: Claude

crates/angular_conformance/src/extractor/util.rs

@@ -54,7 +54,7 @@ impl SpecExtractor {
                     let parts: Vec<&str> = lit
                         .quasis
                         .iter()
-                        .filter_map(|q| q.value.cooked.as_ref().map(oxc_span::Atom::as_str))
+                        .filter_map(|q| q.value.cooked.as_ref().map(oxc_span::Str::as_str))
                         .collect();
                     Some(parts.join(""))
                 }
@@ -138,10 +138,10 @@ impl SpecExtractor {
                 Some(serde_json::Value::String(lit.value.to_string()))
             }
             Expression::NumericLiteral(lit) => {
-                serde_json::Number::from_f64(lit.value).map(serde_json::Value::Number)
+                serde_json::Number::from_f64(lit.value.into()).map(serde_json::Value::Number)
             }
             Expression::NullLiteral(_) => Some(serde_json::Value::Null),
-            Expression::BooleanLiteral(lit) => Some(serde_json::Value::Bool(lit.value)),
+            Expression::BooleanLiteral(lit) => Some(serde_json::Value::Bool(lit.value.into())),
             Expression::ArrayExpression(arr) => {
                 let mut values = Vec::new();
                 for element in &arr.elements {

crates/angular_conformance/src/subsystems/html_whitespace.rs

@@ -384,7 +384,7 @@ impl WhitespaceRemovingHumanizer {
         for token in tokens {
             match token.token_type {
                 InterpolatedTokenType::Text => {
-                    let text = token.parts.first().map_or("", oxc_span::Atom::as_str);
+                    let text = token.parts.first().map_or("", oxc_span::Ident::as_str);
                     let processed = process_whitespace(text);
                     result.push(vec![processed]);
                 }

crates/oxc_angular_compiler/src/ast/expression.rs

@@ -11,7 +11,7 @@
 //! - No bitwise operators
 
 use oxc_allocator::{Allocator, Box, Vec};
-use oxc_span::{Atom, Span};
+use oxc_span::{Ident, Span};
 
 /// A span within the expression source.
 #[derive(Debug, Clone, Copy)]
@@ -594,7 +594,7 @@ pub struct PropertyRead<'a> {
     /// The receiver expression.
     pub receiver: AngularExpression<'a>,
     /// The property name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
 }
 
 /// A safe property read expression: `receiver?.property`.
@@ -609,7 +609,7 @@ pub struct SafePropertyRead<'a> {
     /// The receiver expression.
     pub receiver: AngularExpression<'a>,
     /// The property name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
 }
 
 /// A keyed read expression: `receiver[key]`.
@@ -659,7 +659,7 @@ pub struct BindingPipe<'a> {
     /// The expression being piped.
     pub exp: AngularExpression<'a>,
     /// The pipe name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The pipe arguments.
     pub args: Vec<'a, AngularExpression<'a>>,
     /// The type of pipe reference.
@@ -670,7 +670,7 @@ pub struct BindingPipe<'a> {
 #[derive(Debug, Clone)]
 pub enum LiteralValue<'a> {
     /// A string literal.
-    String(Atom<'a>),
+    String(Ident<'a>),
     /// A number literal.
     Number(f64),
     /// A boolean literal.
@@ -718,7 +718,7 @@ pub struct SpreadElement<'a> {
 #[derive(Debug)]
 pub struct ArrowFunctionParameter<'a> {
     /// The parameter name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The span of this parameter.
     pub span: ParseSpan,
     /// The absolute source span.
@@ -751,7 +751,7 @@ pub enum LiteralMapKey<'a> {
 #[derive(Debug)]
 pub struct LiteralMapPropertyKey<'a> {
     /// The key string.
-    pub key: Atom<'a>,
+    pub key: Ident<'a>,
     /// Whether the key is quoted.
     pub quoted: bool,
     /// Whether this is a shorthand initialization.
@@ -788,7 +788,7 @@ pub struct Interpolation<'a> {
     /// The absolute source span.
     pub source_span: AbsoluteSourceSpan,
     /// The static string parts.
-    pub strings: Vec<'a, Atom<'a>>,
+    pub strings: Vec<'a, Ident<'a>>,
     /// The dynamic expression parts.
     pub expressions: Vec<'a, AngularExpression<'a>>,
 }
@@ -1062,7 +1062,7 @@ pub struct TemplateLiteralElement<'a> {
     /// The absolute source span.
     pub source_span: AbsoluteSourceSpan,
     /// The text content.
-    pub text: Atom<'a>,
+    pub text: Ident<'a>,
 }
 
 /// A parenthesized expression.
@@ -1084,9 +1084,9 @@ pub struct RegularExpressionLiteral<'a> {
     /// The absolute source span.
     pub source_span: AbsoluteSourceSpan,
     /// The regex pattern.
-    pub body: Atom<'a>,
+    pub body: Ident<'a>,
     /// The regex flags.
-    pub flags: Option<Atom<'a>>,
+    pub flags: Option<Ident<'a>>,
 }
 
 // ============================================================================
@@ -1128,7 +1128,7 @@ pub struct ExpressionBinding<'a> {
 #[derive(Debug, Clone)]
 pub struct TemplateBindingIdentifier<'a> {
     /// The source text.
-    pub source: Atom<'a>,
+    pub source: Ident<'a>,
     /// The span.
     pub span: AbsoluteSourceSpan,
 }
@@ -1139,9 +1139,9 @@ pub struct ASTWithSource<'a> {
     /// The AST.
     pub ast: AngularExpression<'a>,
     /// The original source.
-    pub source: Option<Atom<'a>>,
+    pub source: Option<Ident<'a>>,
     /// The source location.
-    pub location: Atom<'a>,
+    pub location: Ident<'a>,
     /// The absolute offset in the template.
     pub absolute_offset: u32,
     // Note: Errors are collected separately in the parser/transformer context
@@ -1210,7 +1210,7 @@ pub enum BindingType {
 #[derive(Debug)]
 pub struct ParsedProperty<'a> {
     /// The property name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The binding expression.
     pub expression: ASTWithSource<'a>,
     /// The type of property binding.
@@ -1247,11 +1247,11 @@ impl<'a> ParsedProperty<'a> {
 #[derive(Debug)]
 pub struct ParsedEvent<'a> {
     /// The event name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The event target or animation phase.
     /// For regular events: "window", "document", "body", or None.
     /// For legacy animation events: the animation phase.
-    pub target_or_phase: Option<Atom<'a>>,
+    pub target_or_phase: Option<Ident<'a>>,
     /// The type of event binding.
     pub event_type: ParsedEventType,
     /// The handler expression.

crates/oxc_angular_compiler/src/ast/html.rs

@@ -4,7 +4,7 @@
 //! ported from Angular's `ml_parser/ast.ts`.
 
 use oxc_allocator::{Box, Vec};
-use oxc_span::{Atom, Span};
+use oxc_span::{Ident, Span};
 
 use super::expression::AngularExpression;
 
@@ -31,7 +31,7 @@ pub struct InterpolatedToken<'a> {
     /// The token type.
     pub token_type: InterpolatedTokenType,
     /// The token parts (structure depends on token type).
-    pub parts: Vec<'a, Atom<'a>>,
+    pub parts: Vec<'a, Ident<'a>>,
     /// The source span.
     pub span: Span,
 }
@@ -83,7 +83,7 @@ impl<'a> HtmlNode<'a> {
 #[derive(Debug)]
 pub struct HtmlText<'a> {
     /// The decoded text value (entities resolved, interpolations joined).
-    pub value: Atom<'a>,
+    pub value: Ident<'a>,
     /// The source span (after stripping leading trivia).
     pub span: Span,
     /// The full start offset before stripping leading trivia (for source maps).
@@ -100,13 +100,13 @@ pub struct HtmlElement<'a> {
     /// The element tag name.
     /// For regular elements: the tag name (e.g., "div", ":svg:rect").
     /// For selectorless components: the component name (e.g., "MyComp").
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// For selectorless components: the namespace prefix (e.g., "svg" in `<ng-component:MyComp:svg:rect>`).
     /// None for regular elements or selectorless components without namespace.
-    pub component_prefix: Option<Atom<'a>>,
+    pub component_prefix: Option<Ident<'a>>,
     /// For selectorless components: the HTML tag name (e.g., "rect" in `<ng-component:MyComp:svg:rect>`).
     /// None for regular elements or selectorless components without tag name.
-    pub component_tag_name: Option<Atom<'a>>,
+    pub component_tag_name: Option<Ident<'a>>,
     /// The element attributes.
     pub attrs: Vec<'a, HtmlAttribute<'a>>,
     /// Selectorless directives (e.g., @Dir, @Dir(attr="value")).
@@ -133,12 +133,12 @@ pub struct HtmlElement<'a> {
 #[derive(Debug)]
 pub struct HtmlComponent<'a> {
     /// The component class name (e.g., "MyComp").
-    pub component_name: Atom<'a>,
+    pub component_name: Ident<'a>,
     /// The HTML tag name (e.g., "button" in `<MyComp:button>`).
     /// None for component-only syntax like `<MyComp>`.
-    pub tag_name: Option<Atom<'a>>,
+    pub tag_name: Option<Ident<'a>>,
     /// The full qualified name (e.g., "MyComp:svg:rect").
-    pub full_name: Atom<'a>,
+    pub full_name: Ident<'a>,
     /// The element attributes.
     pub attrs: Vec<'a, HtmlAttribute<'a>>,
     /// Selectorless directives (e.g., @Dir).
@@ -159,7 +159,7 @@ pub struct HtmlComponent<'a> {
 #[derive(Debug)]
 pub struct HtmlDirective<'a> {
     /// The directive name (without the @ prefix).
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The directive attributes (inside parentheses, if any).
     pub attrs: Vec<'a, HtmlAttribute<'a>>,
     /// The source span for the entire directive.
@@ -176,9 +176,9 @@ pub struct HtmlDirective<'a> {
 #[derive(Debug)]
 pub struct HtmlAttribute<'a> {
     /// The attribute name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The decoded attribute value (entities resolved, interpolations joined).
-    pub value: Atom<'a>,
+    pub value: Ident<'a>,
     /// The source span.
     pub span: Span,
     /// The name span.
@@ -194,7 +194,7 @@ pub struct HtmlAttribute<'a> {
 #[derive(Debug)]
 pub struct HtmlComment<'a> {
     /// The comment value.
-    pub value: Atom<'a>,
+    pub value: Ident<'a>,
     /// The source span.
     pub span: Span,
 }
@@ -203,9 +203,9 @@ pub struct HtmlComment<'a> {
 #[derive(Debug)]
 pub struct HtmlExpansion<'a> {
     /// The switch value.
-    pub switch_value: Atom<'a>,
+    pub switch_value: Ident<'a>,
     /// The expansion type (e.g., "plural", "select").
-    pub expansion_type: Atom<'a>,
+    pub expansion_type: Ident<'a>,
     /// The expansion cases.
     pub cases: Vec<'a, HtmlExpansionCase<'a>>,
     /// The source span.
@@ -222,7 +222,7 @@ pub struct HtmlExpansion<'a> {
 #[derive(Debug)]
 pub struct HtmlExpansionCase<'a> {
     /// The case value (e.g., "one", "other").
-    pub value: Atom<'a>,
+    pub value: Ident<'a>,
     /// The expansion nodes.
     pub expansion: Vec<'a, HtmlNode<'a>>,
     /// The source span.
@@ -268,7 +268,7 @@ pub struct HtmlBlock<'a> {
     /// The block type.
     pub block_type: BlockType,
     /// The block name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The block parameters.
     pub parameters: Vec<'a, HtmlBlockParameter<'a>>,
     /// The child nodes.
@@ -291,7 +291,7 @@ pub struct HtmlBlock<'a> {
 #[derive(Debug)]
 pub struct HtmlBlockParameter<'a> {
     /// The raw expression text (e.g., "minimum 500ms", "track item.id").
-    pub expression: Atom<'a>,
+    pub expression: Ident<'a>,
     /// The source span.
     pub span: Span,
 }
@@ -300,7 +300,7 @@ pub struct HtmlBlockParameter<'a> {
 #[derive(Debug)]
 pub struct HtmlLetDeclaration<'a> {
     /// The variable name.
-    pub name: Atom<'a>,
+    pub name: Ident<'a>,
     /// The value expression.
     pub value: AngularExpression<'a>,
     /// The source span.
@@ -506,7 +506,7 @@ mod tests {
 
         // Create a simple tree: root element with two child elements
         let child1 = HtmlElement {
-            name: Atom::from("span"),
+            name: Ident::from("span"),
             component_prefix: None,
             component_tag_name: None,
             attrs: Vec::new_in(&allocator),
@@ -520,7 +520,7 @@ mod tests {
         };
 
         let child2 = HtmlElement {
-            name: Atom::from("p"),
+            name: Ident::from("p"),
             component_prefix: None,
             component_tag_name: None,
             attrs: Vec::new_in(&allocator),
@@ -538,7 +538,7 @@ mod tests {
         children.push(HtmlNode::Element(Box::new_in(child2, &allocator)));
 
         let root = HtmlElement {
-            name: Atom::from("div"),
+            name: Ident::from("div"),
             component_prefix: None,
             component_tag_name: None,
             attrs: Vec::new_in(&allocator),
@@ -565,7 +565,7 @@ mod tests {
         let allocator = Allocator::default();
 
         let text = HtmlText {
-            value: Atom::from("Hello"),
+            value: Ident::from("Hello"),
             span: Span::default(),
             full_start: None,
             tokens: Vec::new_in(&allocator),