Ionic serve files out of date

When running `ionic serve` it often happens that the transpiled files become out of date. After making a change to one of the TypeScript source files, ionic serve runs, but when looking at the built JavaScript files, the new code is not present. I found that the app-scripts build process kept two file caches. One in the app-script context and one in the so called InMemoryCompilerHost. The first was updated, but the latter wasn't. Since the HybridFileSystem already uses the app-scripts context fileCache, I think it is not necassary to also have an InMemoryCompilerHost to keep the same files in memory (and not update them when they were changed). So aside from fixing the out-of-date-files issue, this also will reduce memory usage.

src/aot/aot-compiler.ts

@@ -17,8 +17,8 @@ import {
 
 import { HybridFileSystem } from '../util/hybrid-file-system';
 import { getInstance as getHybridFileSystem } from '../util/hybrid-file-system-factory';
-import { getInMemoryCompilerHostInstance } from './compiler-host-factory';
-import { InMemoryCompilerHost } from './compiler-host';
+import { getFileSystemCompilerHostInstance } from './compiler-host-factory';
+import { FileSystemCompilerHost } from './compiler-host';
 import { getFallbackMainContent, replaceBootstrapImpl } from './utils';
 import { Logger } from '../logger/logger';
 import { printDiagnostics, clearDiagnostics, DiagnosticsType } from '../logger/logger-diagnostics';
@@ -40,7 +40,7 @@ export async function runAot(context: BuildContext, options: AotOptions) {
   const aggregateCompilerOption = Object.assign(tsConfig.options, angularCompilerOptions);
 
   const fileSystem = getHybridFileSystem(false);
-  const compilerHost = getInMemoryCompilerHostInstance(tsConfig.options);
+  const compilerHost = getFileSystemCompilerHostInstance(tsConfig.options);
   // todo, consider refactoring at some point
   const tsProgram = createProgram(tsConfig.fileNames, tsConfig.options, compilerHost);
 
@@ -77,7 +77,7 @@ export async function runAot(context: BuildContext, options: AotOptions) {
   }
 }
 
-function errorCheckProgram(context: BuildContext, tsConfig: TsConfig, compilerHost: InMemoryCompilerHost, cachedProgram: Program) {
+function errorCheckProgram(context: BuildContext, tsConfig: TsConfig, compilerHost: FileSystemCompilerHost, cachedProgram: Program) {
   // Create a new Program, based on the old one. This will trigger a resolution of all
   // transitive modules, which include files that might just have been generated.
   const program = createProgram(tsConfig.fileNames, tsConfig.options, compilerHost, cachedProgram);

src/aot/compiler-host-factory.ts

@@ -1,12 +1,12 @@
 import { CompilerOptions } from 'typescript';
-import { InMemoryCompilerHost } from './compiler-host';
+import { FileSystemCompilerHost } from './compiler-host';
 import { getInstance as getFileSystemInstance } from '../util/hybrid-file-system-factory';
 
-let instance: InMemoryCompilerHost = null;
+let instance: FileSystemCompilerHost = null;
 
-export function getInMemoryCompilerHostInstance(options: CompilerOptions) {
+export function getFileSystemCompilerHostInstance(options: CompilerOptions) {
   if (!instance) {
-    instance = new InMemoryCompilerHost(options, getFileSystemInstance(false));
+    instance = new FileSystemCompilerHost(options, getFileSystemInstance(false));
   }
   return instance;
 }

src/aot/compiler-host.ts

@@ -8,13 +8,11 @@ export interface OnErrorFn {
   (message: string): void;
 }
 
-export class InMemoryCompilerHost implements CompilerHost {
-  private sourceFileMap: Map<string, SourceFile>;
+export class FileSystemCompilerHost implements CompilerHost {
   private diskCompilerHost: CompilerHost;
 
   constructor(private options: CompilerOptions, private fileSystem: VirtualFileSystem, private setParentNodes = true) {
     this.diskCompilerHost = createCompilerHost(this.options, this.setParentNodes);
-    this.sourceFileMap = new Map<string, SourceFile>();
   }
 
   fileExists(filePath: string): boolean {
@@ -64,19 +62,13 @@ export class InMemoryCompilerHost implements CompilerHost {
 
   getSourceFile(filePath: string, languageVersion: ScriptTarget, onError?: OnErrorFn) {
     filePath = normalize(filePath);
-    const existingSourceFile = this.sourceFileMap.get(filePath);
-    if (existingSourceFile) {
-      return existingSourceFile;
-    }
     // we haven't created a source file for this yet, so try to use what's in memory
     const fileContentFromMemory = this.fileSystem.getFileContent(filePath);
     if (fileContentFromMemory) {
       const typescriptSourceFile = getTypescriptSourceFile(filePath, fileContentFromMemory, languageVersion, this.setParentNodes);
-      this.sourceFileMap.set(filePath, typescriptSourceFile);
       return typescriptSourceFile;
     }
     const diskSourceFile = this.diskCompilerHost.getSourceFile(filePath, languageVersion, onError);
-    this.sourceFileMap.set(filePath, diskSourceFile);
     return diskSourceFile;
   }
 

src/transpile.ts

@@ -5,7 +5,7 @@ import * as path from 'path';
 
 import * as ts from 'typescript';
 
-import { getInMemoryCompilerHostInstance } from './aot/compiler-host-factory';
+import { getFileSystemCompilerHostInstance } from './aot/compiler-host-factory';
 import { buildJsSourceMaps } from './bundle';
 import {
   getInjectDeepLinkConfigTypescriptTransform,
@@ -117,7 +117,7 @@ export function transpileWorker(context: BuildContext, workerConfig: TranspileWo
     tsConfig.options.declaration = undefined;
 
     // let's start a new tsFiles object to cache all the transpiled files in
-    const host = getInMemoryCompilerHostInstance(tsConfig.options);
+    const host = getFileSystemCompilerHostInstance(tsConfig.options);
 
     if (workerConfig.useTransforms && getBooleanPropertyValue(Constants.ENV_PARSE_DEEPLINKS)) {
       // beforeArray.push(purgeDeepLinkDecoratorTSTransform());