refactor(compiler): enable resolve phase for local compilation

This commit update the logic to enable `resolve` phase for local compilation. The `resolve` phase will be useful for local compilation in certain cases (will be used in followup PRs).

packages/compiler-cli/src/ngtsc/annotations/component/src/handler.ts

@@ -652,6 +652,10 @@ export class ComponentDecoratorHandler implements
   resolve(
       node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>,
       symbol: ComponentSymbol): ResolveResult<ComponentResolutionData> {
+    if (this.compilationMode === CompilationMode.LOCAL) {
+      return {};
+    }
+
     if (this.semanticDepGraphUpdater !== null && analysis.baseClass instanceof Reference) {
       symbol.baseClass = this.semanticDepGraphUpdater.getSymbol(analysis.baseClass.node);
     }
@@ -1100,7 +1104,7 @@ export class ComponentDecoratorHandler implements
 
   compileLocal(
       node: ClassDeclaration, analysis: Readonly<ComponentAnalysisData>,
-      pool: ConstantPool): CompileResult[] {
+      resolution: Readonly<Partial<ComponentResolutionData>>, pool: ConstantPool): CompileResult[] {
     if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
       return [];
     }

packages/compiler-cli/src/ngtsc/annotations/directive/src/handler.ts

@@ -246,7 +246,7 @@ export class DirectiveDecoratorHandler implements
 
   compileLocal(
       node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>,
-      pool: ConstantPool): CompileResult[] {
+      resolution: Readonly<unknown>, pool: ConstantPool): CompileResult[] {
     const fac = compileNgFactoryDefField(toFactoryMetadata(analysis.meta, FactoryTarget.Directive));
     const def = compileDirectiveFromMetadata(analysis.meta, pool, makeBindingParser());
     const inputTransformFields = compileInputTransformFields(analysis.inputs);

packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.ts

@@ -555,6 +555,10 @@ export class NgModuleDecoratorHandler implements
 
   resolve(node: ClassDeclaration, analysis: Readonly<NgModuleAnalysis>):
       ResolveResult<NgModuleResolution> {
+    if (this.compilationMode === CompilationMode.LOCAL) {
+      return {};
+    }
+
     const scope = this.scopeRegistry.getScopeOfModule(node);
     const diagnostics: ts.Diagnostic[] = [];
 

packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts

@@ -94,8 +94,12 @@ export class InjectableDecoratorHandler implements
     });
   }
 
-  resolve(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>, symbol: null):
+  resolve(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>):
       ResolveResult<unknown> {
+    if (this.compilationMode === CompilationMode.LOCAL) {
+      return {};
+    }
+
     if (requiresValidCtor(analysis.meta)) {
       const diagnostic = checkInheritanceOfInjectable(
           node, this.injectableRegistry, this.reflector, this.evaluator, this.strictCtorDeps,

packages/compiler-cli/src/ngtsc/annotations/src/pipe.ts

@@ -170,6 +170,10 @@ export class PipeDecoratorHandler implements
   }
 
   resolve(node: ClassDeclaration): ResolveResult<unknown> {
+    if (this.compilationMode === CompilationMode.LOCAL) {
+      return {};
+    }
+
     const duplicateDeclData = this.scopeRegistry.getDuplicateDeclarations(node);
     if (duplicateDeclData !== null) {
       // This pipe was declared twice (or more).

packages/compiler-cli/src/ngtsc/transform/src/api.ts

@@ -202,8 +202,9 @@ export interface DecoratorHandler<D, A, S extends SemanticSymbol|null, R> {
    * Generates code based on each individual source file without using its
    * dependencies (suitable for local dev edit/refresh workflow)
    */
-  compileLocal(node: ClassDeclaration, analysis: Readonly<A>, constantPool: ConstantPool):
-      CompileResult|CompileResult[];
+  compileLocal(
+      node: ClassDeclaration, analysis: Readonly<A>, resolution: Readonly<Partial<R>>,
+      constantPool: ConstantPool): CompileResult|CompileResult[];
 }
 
 /**

packages/compiler-cli/src/ngtsc/transform/src/compilation.ts

@@ -419,12 +419,6 @@ export class TraitCompiler implements ProgramTypeCheckAdapter {
   }
 
   resolve(): void {
-    // No resolving needed for local compilation (only analysis and compile will be done in this
-    // mode)
-    if (this.compilationMode === CompilationMode.LOCAL) {
-      return;
-    }
-
     const classes = this.classes.keys();
     for (const clazz of classes) {
       const record = this.classes.get(clazz)!;
@@ -465,6 +459,10 @@ export class TraitCompiler implements ProgramTypeCheckAdapter {
 
         trait = trait.toResolved(result.data ?? null, result.diagnostics ?? null);
 
+        if (this.compilationMode === CompilationMode.LOCAL) {
+          continue;
+        }
+
         if (result.reexports !== undefined) {
           const fileName = clazz.getSourceFile().fileName;
           if (!this.reexportMap.has(fileName)) {
@@ -484,7 +482,7 @@ export class TraitCompiler implements ProgramTypeCheckAdapter {
    * `ts.SourceFile`.
    */
   typeCheck(sf: ts.SourceFile, ctx: TypeCheckContext): void {
-    if (!this.fileToClasses.has(sf)) {
+    if (!this.fileToClasses.has(sf) || this.compilationMode === CompilationMode.LOCAL) {
       return;
     }
 
@@ -596,24 +594,20 @@ export class TraitCompiler implements ProgramTypeCheckAdapter {
 
     for (const trait of record.traits) {
       let compileRes: CompileResult|CompileResult[];
+
+      if (trait.state !== TraitState.Resolved || containsErrors(trait.analysisDiagnostics) ||
+          containsErrors(trait.resolveDiagnostics)) {
+        // Cannot compile a trait that is not resolved, or had any errors in its declaration.
+        continue;
+      }
+
       if (this.compilationMode === CompilationMode.LOCAL) {
-        if (trait.state !== TraitState.Analyzed || trait.analysis === null ||
-            containsErrors(trait.analysisDiagnostics)) {
-          // Cannot compile a trait in local mode that is not analyzed, or had any errors in its
-          // declaration.
-          continue;
-        }
         // `trait.analysis` is non-null asserted here because TypeScript does not recognize that
         // `Readonly<unknown>` is nullable (as `unknown` itself is nullable) due to the way that
         // `Readonly` works.
-        compileRes = trait.handler.compileLocal(clazz, trait.analysis!, constantPool);
+        compileRes =
+            trait.handler.compileLocal(clazz, trait.analysis!, trait.resolution!, constantPool);
       } else {
-        if (trait.state !== TraitState.Resolved || containsErrors(trait.analysisDiagnostics) ||
-            containsErrors(trait.resolveDiagnostics)) {
-          // Cannot compile a trait in global mode that is not resolved, or had any errors in its
-          // declaration.
-          continue;
-        }
         // `trait.resolution` is non-null asserted below because TypeScript does not recognize that
         // `Readonly<unknown>` is nullable (as `unknown` itself is nullable) due to the way that
         // `Readonly` works.

packages/compiler-cli/src/ngtsc/transform/test/compilation_spec.ts

@@ -340,20 +340,6 @@ runInEachFileSystem(() => {
         }
       }
 
-      it('should not run resolve phase', () => {
-        const contents = `
-          export class Test {}
-        `;
-        const handler = new TestDecoratorHandler();
-        spyOn(handler, 'resolve');
-        const {compiler, sourceFile} = setup(contents, [handler], CompilationMode.LOCAL);
-
-        compiler.analyzeSync(sourceFile);
-        compiler.resolve();
-
-        expect(handler.resolve).not.toHaveBeenCalled();
-      });
-
       it('should not register', () => {
         const contents = `
           export class Test {}