refactor(compiler): remove class related output AST types (#44411)

The Ivy compiler no longer generates classes so this commit removes
the supporting output nodes.

PR Close #44411

packages/compiler-cli/src/ngtsc/translator/src/translator.ts

@@ -92,10 +92,6 @@ export class ExpressionTranslatorVisitor<TStatement, TExpression> implements o.E
         stmt.leadingComments);
   }
 
-  visitDeclareClassStmt(_stmt: o.ClassStmt, _context: Context): never {
-    throw new Error('Method not implemented.');
-  }
-
   visitIfStmt(stmt: o.IfStmt, context: Context): TStatement {
     return this.attachComments(
         this.factory.createIfStatement(

packages/compiler/src/compiler.ts

@@ -53,7 +53,7 @@ export * from './ml_parser/tags';
 export {ParseTreeResult, TreeError} from './ml_parser/parser';
 export {LexerRange} from './ml_parser/lexer';
 export * from './ml_parser/xml_parser';
-export {ArrayType, DYNAMIC_TYPE, BinaryOperator, BinaryOperatorExpr, BuiltinType, BuiltinTypeName, ClassField, ClassMethod, ClassStmt, CommaExpr, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, Expression, ExpressionStatement, ExpressionType, ExpressionVisitor, ExternalExpr, ExternalReference, literalMap, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, MapType, NotExpr, NONE_TYPE, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, StatementVisitor, TaggedTemplateExpr, TemplateLiteral, TemplateLiteralElement, Type, TypeVisitor, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, StmtModifier, Statement, STRING_TYPE, TypeofExpr, collectExternalReferences, jsDocComment, leadingComment, LeadingComment, JSDocComment, UnaryOperator, UnaryOperatorExpr, LocalizedString} from './output/output_ast';
+export {ArrayType, DYNAMIC_TYPE, BinaryOperator, BinaryOperatorExpr, BuiltinType, BuiltinTypeName, CommaExpr, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, Expression, ExpressionStatement, ExpressionType, ExpressionVisitor, ExternalExpr, ExternalReference, literalMap, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, MapType, NotExpr, NONE_TYPE, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, StatementVisitor, TaggedTemplateExpr, TemplateLiteral, TemplateLiteralElement, Type, TypeVisitor, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, StmtModifier, Statement, STRING_TYPE, TypeofExpr, collectExternalReferences, jsDocComment, leadingComment, LeadingComment, JSDocComment, UnaryOperator, UnaryOperatorExpr, LocalizedString} from './output/output_ast';
 export {EmitterVisitorContext} from './output/abstract_emitter';
 export {JitEvaluator} from './output/output_jit';
 export * from './parse_util';

packages/compiler/src/output/abstract_emitter.ts

@@ -28,7 +28,6 @@ export class EmitterVisitorContext {
   }
 
   private _lines: _EmittedLine[];
-  private _classes: o.ClassStmt[] = [];
 
   constructor(private _indent: number) {
     this._lines = [new _EmittedLine(_indent)];
@@ -85,18 +84,6 @@ export class EmitterVisitorContext {
     }
   }
 
-  pushClass(clazz: o.ClassStmt) {
-    this._classes.push(clazz);
-  }
-
-  popClass(): o.ClassStmt {
-    return this._classes.pop()!;
-  }
-
-  get currentClass(): o.ClassStmt|null {
-    return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;
-  }
-
   toSource(): string {
     return this.sourceLines
         .map(l => l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : '')
@@ -226,8 +213,6 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
     return null;
   }
 
-  abstract visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any;
-
   visitIfStmt(stmt: o.IfStmt, ctx: EmitterVisitorContext): any {
     this.printLeadingComments(stmt, ctx);
     ctx.print(stmt, `if (`);

packages/compiler/src/output/abstract_js_emitter.ts

@@ -29,63 +29,6 @@ export abstract class AbstractJsEmitterVisitor extends AbstractEmitterVisitor {
   constructor() {
     super(false);
   }
-  override visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
-    ctx.pushClass(stmt);
-    this._visitClassConstructor(stmt, ctx);
-
-    if (stmt.parent != null) {
-      ctx.print(stmt, `${stmt.name}.prototype = Object.create(`);
-      stmt.parent.visitExpression(this, ctx);
-      ctx.println(stmt, `.prototype);`);
-    }
-    stmt.getters.forEach((getter) => this._visitClassGetter(stmt, getter, ctx));
-    stmt.methods.forEach((method) => this._visitClassMethod(stmt, method, ctx));
-    ctx.popClass();
-    return null;
-  }
-
-  private _visitClassConstructor(stmt: o.ClassStmt, ctx: EmitterVisitorContext) {
-    ctx.print(stmt, `function ${stmt.name}(`);
-    if (stmt.constructorMethod != null) {
-      this._visitParams(stmt.constructorMethod.params, ctx);
-    }
-    ctx.println(stmt, `) {`);
-    ctx.incIndent();
-    if (stmt.constructorMethod != null) {
-      if (stmt.constructorMethod.body.length > 0) {
-        ctx.println(stmt, `var self = this;`);
-        this.visitAllStatements(stmt.constructorMethod.body, ctx);
-      }
-    }
-    ctx.decIndent();
-    ctx.println(stmt, `}`);
-  }
-
-  private _visitClassGetter(stmt: o.ClassStmt, getter: o.ClassGetter, ctx: EmitterVisitorContext) {
-    ctx.println(
-        stmt,
-        `Object.defineProperty(${stmt.name}.prototype, '${getter.name}', { get: function() {`);
-    ctx.incIndent();
-    if (getter.body.length > 0) {
-      ctx.println(stmt, `var self = this;`);
-      this.visitAllStatements(getter.body, ctx);
-    }
-    ctx.decIndent();
-    ctx.println(stmt, `}});`);
-  }
-
-  private _visitClassMethod(stmt: o.ClassStmt, method: o.ClassMethod, ctx: EmitterVisitorContext) {
-    ctx.print(stmt, `${stmt.name}.prototype.${method.name} = function(`);
-    this._visitParams(method.params, ctx);
-    ctx.println(stmt, `) {`);
-    ctx.incIndent();
-    if (method.body.length > 0) {
-      ctx.println(stmt, `var self = this;`);
-      this.visitAllStatements(method.body, ctx);
-    }
-    ctx.decIndent();
-    ctx.println(stmt, `};`);
-  }
 
   override visitWrappedNodeExpr(ast: o.WrappedNodeExpr<any>, ctx: EmitterVisitorContext): any {
     throw new Error('Cannot emit a WrappedNodeExpr in Javascript.');

packages/compiler/src/output/output_ast.ts

@@ -1058,70 +1058,6 @@ export class ReturnStatement extends Statement {
   }
 }
 
-export class AbstractClassPart {
-  constructor(public type: Type|null = null, public modifiers: StmtModifier[] = []) {}
-  hasModifier(modifier: StmtModifier): boolean {
-    return this.modifiers.indexOf(modifier) !== -1;
-  }
-}
-
-export class ClassField extends AbstractClassPart {
-  constructor(
-      public name: string, type?: Type|null, modifiers?: StmtModifier[],
-      public initializer?: Expression) {
-    super(type, modifiers);
-  }
-  isEquivalent(f: ClassField) {
-    return this.name === f.name;
-  }
-}
-
-
-export class ClassMethod extends AbstractClassPart {
-  constructor(
-      public name: string|null, public params: FnParam[], public body: Statement[],
-      type?: Type|null, modifiers?: StmtModifier[]) {
-    super(type, modifiers);
-  }
-  isEquivalent(m: ClassMethod) {
-    return this.name === m.name && areAllEquivalent(this.body, m.body);
-  }
-}
-
-
-export class ClassGetter extends AbstractClassPart {
-  constructor(
-      public name: string, public body: Statement[], type?: Type|null, modifiers?: StmtModifier[]) {
-    super(type, modifiers);
-  }
-  isEquivalent(m: ClassGetter) {
-    return this.name === m.name && areAllEquivalent(this.body, m.body);
-  }
-}
-
-
-export class ClassStmt extends Statement {
-  constructor(
-      public name: string, public parent: Expression|null, public fields: ClassField[],
-      public getters: ClassGetter[], public constructorMethod: ClassMethod,
-      public methods: ClassMethod[], modifiers?: StmtModifier[], sourceSpan?: ParseSourceSpan|null,
-      leadingComments?: LeadingComment[]) {
-    super(modifiers, sourceSpan, leadingComments);
-  }
-  override isEquivalent(stmt: Statement): boolean {
-    return stmt instanceof ClassStmt && this.name === stmt.name &&
-        nullSafeIsEquivalent(this.parent, stmt.parent) &&
-        areAllEquivalent(this.fields, stmt.fields) &&
-        areAllEquivalent(this.getters, stmt.getters) &&
-        this.constructorMethod.isEquivalent(stmt.constructorMethod) &&
-        areAllEquivalent(this.methods, stmt.methods);
-  }
-  override visitStatement(visitor: StatementVisitor, context: any): any {
-    return visitor.visitDeclareClassStmt(this, context);
-  }
-}
-
-
 export class IfStmt extends Statement {
   constructor(
       public condition: Expression, public trueCase: Statement[],
@@ -1144,7 +1080,6 @@ export interface StatementVisitor {
   visitDeclareFunctionStmt(stmt: DeclareFunctionStmt, context: any): any;
   visitExpressionStmt(stmt: ExpressionStatement, context: any): any;
   visitReturnStmt(stmt: ReturnStatement, context: any): any;
-  visitDeclareClassStmt(stmt: ClassStmt, context: any): any;
   visitIfStmt(stmt: IfStmt, context: any): any;
 }
 
@@ -1339,27 +1274,6 @@ export class AstTransformer implements StatementVisitor, ExpressionVisitor {
         context);
   }
 
-  visitDeclareClassStmt(stmt: ClassStmt, context: any): any {
-    const parent = stmt.parent!.visitExpression(this, context);
-    const getters = stmt.getters.map(
-        getter => new ClassGetter(
-            getter.name, this.visitAllStatements(getter.body, context), getter.type,
-            getter.modifiers));
-    const ctorMethod = stmt.constructorMethod &&
-        new ClassMethod(stmt.constructorMethod.name, stmt.constructorMethod.params,
-                        this.visitAllStatements(stmt.constructorMethod.body, context),
-                        stmt.constructorMethod.type, stmt.constructorMethod.modifiers);
-    const methods = stmt.methods.map(
-        method => new ClassMethod(
-            method.name, method.params, this.visitAllStatements(method.body, context), method.type,
-            method.modifiers));
-    return this.transformStmt(
-        new ClassStmt(
-            stmt.name, parent, stmt.fields, getters, ctorMethod, methods, stmt.modifiers,
-            stmt.sourceSpan),
-        context);
-  }
-
   visitIfStmt(stmt: IfStmt, context: any): any {
     return this.transformStmt(
         new IfStmt(
@@ -1525,15 +1439,6 @@ export class RecursiveAstVisitor implements StatementVisitor, ExpressionVisitor
     stmt.value.visitExpression(this, context);
     return stmt;
   }
-  visitDeclareClassStmt(stmt: ClassStmt, context: any): any {
-    stmt.parent!.visitExpression(this, context);
-    stmt.getters.forEach(getter => this.visitAllStatements(getter.body, context));
-    if (stmt.constructorMethod) {
-      this.visitAllStatements(stmt.constructorMethod.body, context);
-    }
-    stmt.methods.forEach(method => this.visitAllStatements(method.body, context));
-    return stmt;
-  }
   visitIfStmt(stmt: IfStmt, context: any): any {
     stmt.condition.visitExpression(this, context);
     this.visitAllStatements(stmt.trueCase, context);
@@ -1557,10 +1462,6 @@ class _ReadVarVisitor extends RecursiveAstVisitor {
     // Don't descend into nested functions
     return stmt;
   }
-  override visitDeclareClassStmt(stmt: ClassStmt, context: any): any {
-    // Don't descend into nested classes
-    return stmt;
-  }
   override visitReadVarExpr(ast: ReadVarExpr, context: any): any {
     if (ast.name) {
       this.varNames.add(ast.name);

packages/compiler/src/output/output_jit.ts

@@ -146,13 +146,6 @@ export class JitEmitterVisitor extends AbstractJsEmitterVisitor {
     return super.visitDeclareFunctionStmt(stmt, ctx);
   }
 
-  override visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
-    if (stmt.hasModifier(o.StmtModifier.Exported)) {
-      this._evalExportedVars.push(stmt.name);
-    }
-    return super.visitDeclareClassStmt(stmt, ctx);
-  }
-
   private _emitReferenceToExternal(ast: o.Expression, value: any, ctx: EmitterVisitorContext):
       void {
     let id = this._evalArgValues.indexOf(value);