refactor(@angular/build): use prefix tagging for object literal detection in StringAstFactory

Author: alan-agius4

packages/angular/build/src/tools/angular/linker/string-ast-factory.ts

@@ -21,28 +21,36 @@ import type {
   Parameter,
 } from '@angular/compiler-cli/src/ngtsc/translator/src/api/ast_factory';
 
+const OBJECT_LITERAL_PREFIX = '\0obj_';
+
 /**
  * An implementation of `AstFactory` that generates JavaScript code strings directly.
  */
 export class StringAstFactory implements AstFactory<string, unknown, string> {
   constructor(private readonly sourceCode: string = '') {}
 
   private render(expr: unknown): string {
+    let rendered: string;
     if (typeof expr === 'string') {
-      return expr;
-    }
-    if (
+      rendered = expr;
+    } else if (
       typeof expr === 'object' &&
       expr !== null &&
       typeof (expr as { start?: number; end?: number }).start === 'number' &&
       typeof (expr as { end?: number }).end === 'number'
     ) {
       const { start, end } = expr as { start: number; end: number };
 
-      return this.sourceCode.slice(start, end);
+      rendered = this.sourceCode.slice(start, end);
+    } else {
+      rendered = String(expr);
     }
 
-    return String(expr);
+    if (rendered.startsWith(OBJECT_LITERAL_PREFIX)) {
+      return rendered.slice(OBJECT_LITERAL_PREFIX.length);
+    }
+
+    return rendered;
   }
 
   /**
@@ -177,9 +185,8 @@ export class StringAstFactory implements AstFactory<string, unknown, string> {
 
   createArrowFunctionExpression(parameters: Parameter<string>[], body: unknown): string {
     const params = parameters.map((p) => p.name).join(', ');
+    const isObjectLiteral = typeof body === 'string' && body.startsWith(OBJECT_LITERAL_PREFIX);
     const renderedBody = this.render(body);
-    const isObjectLiteral =
-      renderedBody.startsWith('{') && renderedBody.endsWith('}') && !renderedBody.includes(';');
     const formattedBody = isObjectLiteral ? `(${renderedBody})` : renderedBody;
 
     return `(${params}) => ${formattedBody}`;
@@ -222,7 +229,7 @@ export class StringAstFactory implements AstFactory<string, unknown, string> {
       return `${key}: ${this.render(p.value)}`;
     });
 
-    return `{\n${props.join(',\n')}\n}`;
+    return `${OBJECT_LITERAL_PREFIX}{\n${props.join(',\n')}\n}`;
   }
 
   createParenthesizedExpression(expression: unknown): string {

packages/angular/build/src/tools/angular/linker/string-ast-factory_spec.ts

@@ -63,15 +63,15 @@ describe('StringAstFactory', () => {
         { kind: 'property' as const, propertyName: 'foo', value: '1', quoted: false },
         { kind: 'property' as const, propertyName: 'foo-bar', value: '2', quoted: true },
       ];
-      expect(factory.createObjectLiteral(props)).toBe('{\nfoo: 1,\n"foo-bar": 2\n}');
+      expect(factory.createObjectLiteral(props)).toContain('{\nfoo: 1,\n"foo-bar": 2\n}');
     });
 
     it('should correctly format object literals with spread properties', () => {
       const props = [
         { kind: 'property' as const, propertyName: 'foo', value: '1', quoted: false },
         { kind: 'spread' as const, expression: 'bar' },
       ];
-      expect(factory.createObjectLiteral(props)).toBe('{\nfoo: 1,\n...bar\n}');
+      expect(factory.createObjectLiteral(props)).toContain('{\nfoo: 1,\n...bar\n}');
     });
   });
 
@@ -165,6 +165,21 @@ describe('StringAstFactory', () => {
       expect(factory.createArrowFunctionExpression(params, 'a + b')).toBe('(a, b) => a + b');
     });
 
+    it('should parenthesize object literal expression bodies in arrow functions even when containing semicolons', () => {
+      const params = [{ name: 'a', type: null }];
+      const obj = factory.createObjectLiteral([
+        {
+          kind: 'property',
+          propertyName: 'factory',
+          value: '() => { return new Service(); }',
+          quoted: false,
+        },
+      ]);
+      expect(factory.createArrowFunctionExpression(params, obj)).toBe(
+        '(a) => ({\nfactory: () => { return new Service(); }\n})',
+      );
+    });
+
     it('should format statements', () => {
       expect(factory.createBlock(['foo();', 'bar();'])).toBe('{\nfoo();\nbar();\n}');
       expect(factory.createIfStatement('cond', 'foo();', 'bar();')).toBe(