feat(aot): creating files in a virtual fs.

hansl · hansl · commit ed4e34ec0612 · 2016-10-02T09:02:17.000-07:00
In addition, reading and using AST on main.ts to figure out the entry module, if not specified.
diff --git a/packages/angular-cli/models/webpack-build-typescript.ts b/packages/angular-cli/models/webpack-build-typescript.ts
@@ -55,7 +55,7 @@ export const getWebpackAotConfigPartial = function(projectRoot: string, appConfi
       new NgcWebpackPlugin({
         project: path.resolve(projectRoot, appConfig.root, appConfig.tsconfig),
         baseDir: path.resolve(projectRoot, ''),
-        entryModule: path.join(projectRoot, appConfig.root, 'app/app.module#AppModule'),
+        main: path.join(projectRoot, appConfig.root, appConfig.main),
         genDir: path.join(projectRoot, appConfig.outDir, 'ngfactory')
       }),
     ]
diff --git a/packages/webpack/src/compiler_host.ts b/packages/webpack/src/compiler_host.ts
@@ -0,0 +1,181 @@
+import * as ts from 'typescript';
+import {basename, dirname} from 'path';
+import * as fs from 'fs';
+
+
+export interface OnErrorFn {
+  (message: string): void;
+}
+
+
+const dev = Math.floor(Math.random() * 10000);
+
+
+export class VirtualStats implements fs.Stats {
+  protected _ctime = new Date();
+  protected _mtime = new Date();
+  protected _atime = new Date();
+  protected _btime = new Date();
+  protected _dev = dev;
+  protected _ino = Math.floor(Math.random() * 100000);
+  protected _mode = parseInt('777', 8);  // RWX for everyone.
+  protected _uid = process.env['UID'] || 0;
+  protected _gid = process.env['GID'] || 0;
+
+  constructor(protected _path: string) {}
+
+  isFile() { return false; }
+  isDirectory() { return false; }
+  isBlockDevice() { return false; }
+  isCharacterDevice() { return false; }
+  isSymbolicLink() { return false; }
+  isFIFO() { return false; }
+  isSocket() { return false; }
+
+  get dev() { return this._dev; }
+  get ino() { return this._ino; }
+  get mode() { return this._mode; }
+  get nlink() { return 1; }  // Default to 1 hard link.
+  get uid() { return this._uid; }
+  get gid() { return this._gid; }
+  get rdev() { return 0; }
+  get size() { return 0; }
+  get blksize() { return 512; }
+  get blocks() { return Math.ceil(this.size / this.blksize); }
+  get atime() { return this._atime; }
+  get mtime() { return this._mtime; }
+  get ctime() { return this._ctime; }
+  get birthtime() { return this._btime; }
+}
+
+export class VirtualDirStats extends VirtualStats {
+  constructor(_fileName: string) {
+    super(_fileName);
+  }
+
+  isDirectory() { return true; }
+
+  get size() { return 1024; }
+}
+
+export class VirtualFileStats extends VirtualStats {
+  private _sourceFile: ts.SourceFile;
+  constructor(_fileName: string, private _content: string) {
+    super(_fileName);
+  }
+
+  get content() { return this._content; }
+  set content(v: string) {
+    this._content = v;
+    this._mtime = new Date();
+  }
+  getSourceFile(languageVersion: ts.ScriptTarget, setParentNodes: boolean) {
+    if (!this._sourceFile) {
+      this._sourceFile = ts.createSourceFile(
+        this._path,
+        this._content,
+        languageVersion,
+        setParentNodes);
+    }
+
+    return this._sourceFile;
+  }
+
+  isFile() { return true; }
+
+  get size() { return this._content.length; }
+}
+
+
+export class WebpackCompilerHost implements ts.CompilerHost {
+  private _delegate: ts.CompilerHost;
+  private _cachedFiles: {[path: string]: VirtualFileStats} = Object.create(null);
+  private _directories: {[path: string]: VirtualDirStats} = Object.create(null);
+
+  constructor(private _options: ts.CompilerOptions, private _setParentNodes = true) {
+    this._delegate = ts.createCompilerHost(this._options, this._setParentNodes);
+  }
+
+  private _setFileContent(fileName: string, content: string) {
+    this._cachedFiles[fileName] = new VirtualFileStats(fileName, content);
+
+    let p = dirname(fileName);
+    while (p && !this._directories[p]) {
+      this._directories[p] = new VirtualDirStats(p);
+      p = dirname(p);
+    }
+  }
+
+  populateWebpackResolver(resolver: any) {
+    const fs = resolver.fileSystem;
+
+    for (const fileName of Object.keys(this._cachedFiles)) {
+      const stats = this._cachedFiles[fileName];
+      fs._statStorage.data[fileName] = [null, stats];
+      fs._readFileStorage.data[fileName] = [null, stats.content];
+    }
+    for (const path of Object.keys(this._directories)) {
+      const stats = this._directories[path];
+      const files = Object.keys(this._directories)
+        .filter(fileName => dirname(fileName) == path)
+        .map(path => basename(path));
+
+      fs._statStorage.data[path] = [null, stats];
+      fs._readdirStorage.data[path] = [null, files];
+    }
+  }
+
+  fileExists(fileName: string): boolean {
+    return fileName in this._cachedFiles || this._delegate.fileExists(fileName);
+  }
+
+  readFile(fileName: string): string {
+    return (fileName in this._cachedFiles)
+         ? this._cachedFiles[fileName].content
+         : this._delegate.readFile(fileName);
+  }
+
+  directoryExists(directoryName: string): boolean {
+    return (directoryName in this._directories) || this._delegate.directoryExists(directoryName);
+  }
+
+  getDirectories(path: string): string[] {
+    return this._delegate.getDirectories(path);
+  }
+
+  getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: OnErrorFn) {
+    if (!(fileName in this._cachedFiles)) {
+      return this._delegate.getSourceFile(fileName, languageVersion, onError);
+    }
+
+    return this._cachedFiles[fileName].getSourceFile(languageVersion, this._setParentNodes);
+  }
+
+  getCancellationToken() {
+    return this._delegate.getCancellationToken();
+  }
+
+  getDefaultLibFileName(options: ts.CompilerOptions) {
+    return this._delegate.getDefaultLibFileName(options);
+  }
+
+  writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: OnErrorFn) {
+    this._setFileContent(fileName, data);
+  }
+
+  getCurrentDirectory(): string {
+    return this._delegate.getCurrentDirectory();
+  }
+
+  getCanonicalFileName(fileName: string): string {
+    return this._delegate.getCanonicalFileName(fileName);
+  }
+
+  useCaseSensitiveFileNames(): boolean {
+    return this._delegate.useCaseSensitiveFileNames();
+  }
+
+  getNewLine(): string {
+    return this._delegate.getNewLine();
+  }
+}
diff --git a/packages/webpack/src/plugin.ts b/packages/webpack/src/plugin.ts
@@ -1,3 +1,4 @@
+import * as fs from 'fs';
 import * as ts from 'typescript';
 import * as path from 'path';
 
@@ -9,6 +10,19 @@ import {patchReflectorHost} from './reflector_host';
 import {WebpackResourceLoader} from './resource_loader';
 import {createResolveDependenciesFromContextMap} from './utils';
 import { AngularCompilerOptions } from '@angular/tsc-wrapped';
+import {WebpackCompilerHost} from './compiler_host';
+
+
+function _findNodes(sourceFile: ts.SourceFile, node: ts.Node, kind: ts.SyntaxKind,
+                    keepGoing = false): ts.Node[] {
+  if (node.kind == kind && !keepGoing) {
+    return [node];
+  }
+
+  return node.getChildren(sourceFile).reduce((result, n) => {
+    return result.concat(_findNodes(sourceFile, n, kind, keepGoing));
+  }, node.kind == kind ? [node] : []);
+}
 
 
 /**
@@ -22,6 +36,7 @@ export interface AngularWebpackPluginOptions {
   baseDir: string;
   basePath?: string;
   genDir?: string;
+  main?: string;
 }
 
 
@@ -32,7 +47,7 @@ export class NgcWebpackPlugin {
   reflector: ngCompiler.StaticReflector;
   reflectorHost: ngCompiler.ReflectorHost;
   program: ts.Program;
-  compilerHost: ts.CompilerHost;
+  compilerHost: WebpackCompilerHost;
   compilerOptions: ts.CompilerOptions;
   angularCompilerOptions: AngularCompilerOptions;
   files: any[];
@@ -58,19 +73,81 @@ export class NgcWebpackPlugin {
     this.genDir = this.options.genDir
                || path.resolve(process.cwd(), this.angularCompilerOptions.genDir + '/app');
     this.entryModule = options.entryModule || (this.angularCompilerOptions as any).entryModule;
+    if (!options.entryModule && options.main) {
+      this.entryModule = this.figureOutEntryFromMain(options.main);
+    }
 
     const entryModule = this.entryModule;
     const [rootModule, rootNgModule] = entryModule.split('#');
     this.projectPath = options.project;
     this.rootModule = rootModule;
     this.rootModuleName = rootNgModule;
-    this.compilerHost = ts.createCompilerHost(this.compilerOptions, true);
+    this.compilerHost = new WebpackCompilerHost(this.compilerOptions);
     this.program = ts.createProgram(this.files, this.compilerOptions, this.compilerHost);
     this.reflectorHost = new ngCompiler.ReflectorHost(
       this.program, this.compilerHost, this.angularCompilerOptions);
     this.reflector = new ngCompiler.StaticReflector(this.reflectorHost);
   }
 
+  figureOutEntryFromMain(mainPath: string): string {
+    const source = ts.createSourceFile(
+      mainPath, fs.readFileSync(mainPath, 'utf-8'), ts.ScriptTarget.Latest);
+
+    const bootstrap = _findNodes(source, source, ts.SyntaxKind.CallExpression, false)
+      .map(node => node as ts.CallExpression)
+      .filter(call => {
+        const access = call.expression as ts.PropertyAccessExpression;
+        return access.kind == ts.SyntaxKind.PropertyAccessExpression
+            && access.name.kind == ts.SyntaxKind.Identifier
+            && (access.name.text == 'bootstrapModule'
+             || access.name.text == 'bootstrapModuleFactory');
+      });
+
+    if (bootstrap.length != 1
+        || bootstrap[0].arguments[0].kind !== ts.SyntaxKind.Identifier) {
+      throw new Error('Tried to find bootstrap code, but could not. Specify either '
+                    + 'statically analyzable bootstrap code or pass in an entryModule '
+                    + 'to the plugins options.');
+    }
+
+    const bootstrapSymbolName = (bootstrap[0].arguments[0] as ts.Identifier).text;
+
+    // We found the bootstrap variable, now we just need to get where it's imported.
+    const imports = _findNodes(source, source, ts.SyntaxKind.ImportDeclaration, false)
+      .map(node => node as ts.ImportDeclaration);
+
+    for (const decl of imports) {
+      if (!decl.importClause || !decl.moduleSpecifier) {
+        continue;
+      }
+      if (decl.moduleSpecifier.kind !== ts.SyntaxKind.StringLiteral) {
+        continue;
+      }
+
+      const module = (decl.moduleSpecifier as ts.StringLiteral).text;
+
+      if (decl.importClause.namedBindings.kind == ts.SyntaxKind.NamespaceImport) {
+        const binding = decl.importClause.namedBindings as ts.NamespaceImport;
+        if (binding.name.text == bootstrapSymbolName) {
+          // This is a default export.
+          return module;
+        }
+      } else if (decl.importClause.namedBindings.kind == ts.SyntaxKind.NamedImports) {
+        const binding = decl.importClause.namedBindings as ts.NamedImports;
+        for (const specifier of binding.elements) {
+          if (specifier.name.text == bootstrapSymbolName) {
+            return `${path.resolve(path.dirname(mainPath), module)}#${bootstrapSymbolName}`;
+          }
+        }
+      }
+    }
+
+    // shrug... something bad happened and we couldn't find the import statement.
+    throw new Error('Tried to find bootstrap code, but could not. Specify either '
+                  + 'statically analyzable bootstrap code or pass in an entryModule '
+                  + 'to the plugins options.');
+  }
+
   // registration hook for webpack plugin
   apply(compiler: any) {
     this.compiler = compiler;
@@ -110,6 +187,15 @@ export class NgcWebpackPlugin {
       compilation._ngToolsWebpackPluginInstance = null;
       cb();
     });
+
+    // Virtual file system.
+    compiler.resolvers.normal.plugin('resolve', (request: any, cb?: () => void) => {
+      // populate the file system cache with the virtual module
+      this.compilerHost.populateWebpackResolver(compiler.resolvers.normal);
+      if (cb) {
+        cb();
+      }
+    });
   }
 
   private _make(compilation: any, cb: (err?: any, request?: any) => void) {
diff --git a/packages/webpack/src/resource_loader.ts b/packages/webpack/src/resource_loader.ts

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ export const getWebpackAotConfigPartial = function(projectRoot: string, appConfi`
`55`	`55`	`new NgcWebpackPlugin({`
`56`	`56`	`project: path.resolve(projectRoot, appConfig.root, appConfig.tsconfig),`
`57`	`57`	`baseDir: path.resolve(projectRoot, ''),`
`58`		`- entryModule: path.join(projectRoot, appConfig.root, 'app/app.module#AppModule'),`
	`58`	`+ main: path.join(projectRoot, appConfig.root, appConfig.main),`
`59`	`59`	`genDir: path.join(projectRoot, appConfig.outDir, 'ngfactory')`
`60`	`60`	`}),`
`61`	`61`	`]`