Angular compiler alignment: 98.4% material-angular match rate (615/625)

Fixes applied:
- Track function detection for implicit `this` calls in @for loops
- Variable ordering / context inlining prevention (don't inline nextContext when intervening ViewContextRead fences exist)
- Constant pool function ordering (function declarations before arrow functions)
- Formatting improvements (double quotes, comma spacing, blank lines between declarations)

Results:
- material-angular: 610/625 (97.6%) → 615/625 (98.4%)
- bitwarden-clients: 651/651 (100%) maintained

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/output/emitter.rs

@@ -388,9 +388,7 @@ impl JsEmitter {
     /// Emit multiple statements to a string.
     pub fn emit_statements<'a>(&self, stmts: &[OutputStatement<'a>]) -> String {
         let mut ctx = EmitterContext::new();
-        for stmt in stmts {
-            self.visit_statement(stmt, &mut ctx);
-        }
+        self.visit_all_statements(stmts, &mut ctx);
         ctx.to_source()
     }
 
@@ -420,9 +418,7 @@ impl JsEmitter {
         generated_file: Option<&str>,
     ) -> (String, Option<oxc_sourcemap::SourceMap>) {
         let mut ctx = EmitterContext::with_source_file(source_file);
-        for stmt in stmts {
-            self.visit_statement(stmt, &mut ctx);
-        }
+        self.visit_all_statements(stmts, &mut ctx);
         ctx.to_source_with_map(generated_file)
     }
 
@@ -440,6 +436,32 @@ impl JsEmitter {
         }
     }
 
+    /// Visit all statements, adding blank lines between top-level const/function declarations.
+    ///
+    /// This matches Angular's output formatting which adds a blank line between:
+    /// - Consecutive const declarations
+    /// - Consecutive function declarations
+    /// - Between const and function declarations
+    fn visit_all_statements<'a>(&self, stmts: &[OutputStatement<'a>], ctx: &mut EmitterContext) {
+        for (i, stmt) in stmts.iter().enumerate() {
+            // Add blank line between top-level declarations (const/function)
+            if i > 0 {
+                let prev_stmt = &stmts[i - 1];
+                let needs_blank_line = matches!(
+                    (prev_stmt, stmt),
+                    (OutputStatement::DeclareVar(_), OutputStatement::DeclareVar(_))
+                        | (OutputStatement::DeclareVar(_), OutputStatement::DeclareFunction(_))
+                        | (OutputStatement::DeclareFunction(_), OutputStatement::DeclareFunction(_))
+                        | (OutputStatement::DeclareFunction(_), OutputStatement::DeclareVar(_))
+                );
+                if needs_blank_line {
+                    ctx.newline();
+                }
+            }
+            self.visit_statement(stmt, ctx);
+        }
+    }
+
     fn visit_declare_var_stmt(&self, stmt: &DeclareVarStmt<'_>, ctx: &mut EmitterContext) {
         // Print leading comment if present
         // See: packages/compiler/src/output/abstract_emitter.ts:218-235
@@ -657,7 +679,7 @@ impl JsEmitter {
             }
             OutputExpression::Comma(e) => {
                 ctx.print("(");
-                self.visit_all_expressions(&e.parts, ctx, ",");
+                self.visit_all_expressions(&e.parts, ctx, ", ");
                 ctx.print(")");
             }
             OutputExpression::Function(e) => {
@@ -679,7 +701,7 @@ impl JsEmitter {
             OutputExpression::ArrowFunction(e) => {
                 ctx.print_with_span("(", source_span);
                 self.visit_params(&e.params, ctx);
-                ctx.print(") =>");
+                ctx.print(") => ");
                 match &e.body {
                     ArrowFunctionBody::Expression(body_expr) => {
                         // Check if the body is an object literal (needs parens)
@@ -717,14 +739,14 @@ impl JsEmitter {
                 }
                 // Map the function call to its source location
                 ctx.print_with_span("(", source_span);
-                self.visit_all_expressions(&e.args, ctx, ",");
+                self.visit_all_expressions(&e.args, ctx, ", ");
                 ctx.print(")");
             }
             OutputExpression::Instantiate(e) => {
                 ctx.print_with_span("new ", source_span);
                 self.visit_expression(&e.class_expr, ctx);
                 ctx.print("(");
-                self.visit_all_expressions(&e.args, ctx, ",");
+                self.visit_all_expressions(&e.args, ctx, ", ");
                 ctx.print(")");
             }
             OutputExpression::DynamicImport(e) => {
@@ -802,7 +824,7 @@ impl JsEmitter {
 
     fn visit_literal_array<'a>(&self, entries: &[OutputExpression<'a>], ctx: &mut EmitterContext) {
         ctx.print("[");
-        self.visit_all_expressions(entries, ctx, ",");
+        self.visit_all_expressions(entries, ctx, ", ");
         ctx.print("]");
     }
 
@@ -818,33 +840,37 @@ impl JsEmitter {
         entries: &[super::ast::LiteralMapEntry<'a>],
         ctx: &mut EmitterContext,
     ) {
-        ctx.print("{");
+        if entries.is_empty() {
+            ctx.print("{}");
+            return;
+        }
+        ctx.print("{ ");
         let mut incremented_indent = false;
         for (i, entry) in entries.iter().enumerate() {
             if i > 0 {
                 // Check line length and break if needed
                 if ctx.line_length() > LINE_LENGTH_LIMIT {
-                    ctx.println(",");
+                    ctx.println(", ");
                     if !incremented_indent {
                         // Continuation lines are marked with double indent
                         ctx.inc_indent();
                         ctx.inc_indent();
                         incremented_indent = true;
                     }
                 } else {
-                    ctx.print(",");
+                    ctx.print(", ");
                 }
             }
             let key = escape_identifier(&entry.key, self.escape_dollar_in_strings, entry.quoted);
             ctx.print(&key);
-            ctx.print(":");
+            ctx.print(": ");
             self.visit_expression(&entry.value, ctx);
         }
         if incremented_indent {
             ctx.dec_indent();
             ctx.dec_indent();
         }
-        ctx.print("}");
+        ctx.print(" }");
     }
 
     fn visit_template_literal(
@@ -950,7 +976,7 @@ impl JsEmitter {
     fn visit_params(&self, params: &[FnParam<'_>], ctx: &mut EmitterContext) {
         for (i, param) in params.iter().enumerate() {
             if i > 0 {
-                ctx.print(",");
+                ctx.print(", ");
             }
             ctx.print(&param.name);
         }
@@ -1047,18 +1073,18 @@ fn unary_operator_to_str(op: UnaryOperator) -> &'static str {
 /// Escape a string for JavaScript output.
 fn escape_string(input: &str, escape_dollar: bool) -> String {
     let mut result = String::with_capacity(input.len() + 2);
-    result.push('\'');
+    result.push('"');
     for c in input.chars() {
         match c {
-            '\'' => result.push_str("\\'"),
+            '"' => result.push_str("\\\""),
             '\\' => result.push_str("\\\\"),
             '\n' => result.push_str("\\n"),
             '\r' => result.push_str("\\r"),
             '$' if escape_dollar => result.push_str("\\$"),
             _ => result.push(c),
         }
     }
-    result.push('\'');
+    result.push('"');
     result
 }
 
@@ -1136,7 +1162,7 @@ mod tests {
             LiteralExpr { value: LiteralValue::String(Atom::from("hello")), source_span: None },
             &alloc,
         ));
-        assert_eq!(emitter.emit_expression(&expr), "'hello'");
+        assert_eq!(emitter.emit_expression(&expr), "\"hello\"");
     }
 
     #[test]
@@ -1152,11 +1178,12 @@ mod tests {
 
     #[test]
     fn test_escape_string() {
-        assert_eq!(escape_string("hello", false), "'hello'");
-        assert_eq!(escape_string("it's", false), "'it\\'s'");
-        assert_eq!(escape_string("line\nbreak", false), "'line\\nbreak'");
-        assert_eq!(escape_string("$var", true), "'\\$var'");
-        assert_eq!(escape_string("$var", false), "'$var'");
+        assert_eq!(escape_string("hello", false), "\"hello\"");
+        assert_eq!(escape_string("it's", false), "\"it's\"");
+        assert_eq!(escape_string("say \"hi\"", false), "\"say \\\"hi\\\"\"");
+        assert_eq!(escape_string("line\nbreak", false), "\"line\\nbreak\"");
+        assert_eq!(escape_string("$var", true), "\"\\$var\"");
+        assert_eq!(escape_string("$var", false), "\"$var\"");
     }
 
     // ========================================================================