docs: add changelog for 5.0.0-rc.6

PR Close #19931

.circleci/config.yml

@@ -29,7 +29,7 @@ jobs:
       - restore_cache:
           key: angular-{{ .Branch }}-{{ checksum "yarn.lock" }}
 
-      - run: yarn install --freeze-lockfile --non-interactive
+      - run: yarn install --frozen-lockfile --non-interactive
       - run: ./node_modules/.bin/gulp lint
 
   build:

.pullapprove.yml

@@ -7,9 +7,12 @@
 #
 # alexeagle - Alex Eagle
 # alxhub - Alex Rickabaugh
+# brocco - Mike Brocchi
 # chuckjaz - Chuck Jazdzewski
+# filipesilva - Filipe Silva
 # Foxandxss - Jesús Rodríguez
 # gkalpak - George Kalpakas
+# hansl - Hans Larsen
 # IgorMinar - Igor Minar
 # jasonaden - Jason Aden
 # juleskremer - Jules Kremer
@@ -144,11 +147,23 @@ groups:
       - mhevery
       - IgorMinar #fallback
 
+  compiler-cli/ngtools:
+    conditions:
+      files:
+        - "packages/compiler-cli/src/ngtools*"
+    users:
+      - hansl
+      - filipesilva #fallback
+      - brocco #fallback
+
   compiler-cli:
     conditions:
       files:
-        - "packages/compiler-cli/*"
-        - "packages/bazel/*"
+        include:
+          - "packages/compiler-cli/*"
+          - "packages/bazel/*"
+        exclude:
+          - "packages/compiler-cli/src/ngtools*"   
     users:
       - alexeagle
       - chuckjaz

.travis.yml

@@ -1,12 +1,10 @@
 language: node_js
 sudo: false
-# force trusty as Google Chrome addon is not supported on Precise
 dist: trusty
 node_js:
   - '6.9.5'
 
 addons:
-  chrome: stable
 #  firefox: "38.0"
   apt:
     sources:

CHANGELOG.md

@@ -1,3 +1,38 @@
+<a name="5.0.0-rc.6"></a>
+# [5.0.0-rc.6](https://github.com/angular/angular/compare/5.0.0-rc.5...5.0.0-rc.6) (2017-10-25)
+
+
+### Bug Fixes
+
+* **compiler:** automatically set `emitDecoratorMetadata` when `"annotationsAs": "static fields”` ([#19927](https://github.com/angular/angular/issues/19927)) ([ef08330](https://github.com/angular/angular/commit/ef08330)), closes [#19916](https://github.com/angular/angular/issues/19916)
+* **compiler:** don’t type check templates with `skipTemplateCodegen` ([#19909](https://github.com/angular/angular/issues/19909)) ([18bce59](https://github.com/angular/angular/commit/18bce59))
+* **compiler-cli:** only use error collector when needed. ([#19912](https://github.com/angular/angular/issues/19912)) ([9b26455](https://github.com/angular/angular/commit/9b26455))
+* **compiler-cli:** produce correct paths for windows output ([#19915](https://github.com/angular/angular/issues/19915)) ([6cc042e](https://github.com/angular/angular/commit/6cc042e))
+
+
+
+<a name="5.0.0-rc.5"></a>
+# [5.0.0-rc.5](https://github.com/angular/angular/compare/5.0.0-rc.4...5.0.0-rc.5) (2017-10-24)
+
+
+### Bug Fixes
+
+* **compiler-cli:** report all diagnostic error messages ([#19886](https://github.com/angular/angular/issues/19886)) ([a82f863](https://github.com/angular/angular/commit/a82f863))
+
+
+
+<a name="5.0.0-rc.4"></a>
+# [5.0.0-rc.4](https://github.com/angular/angular/compare/5.0.0-rc.3...5.0.0-rc.4) (2017-10-24)
+
+
+### Bug Fixes
+
+* **bazel:** don't console.error from the compile helper ([#19879](https://github.com/angular/angular/issues/19879)) ([5da96c7](https://github.com/angular/angular/commit/5da96c7))
+* **compiler:** correctly calculate the outDir if it repeats a parts of the `rootDir`. ([#19836](https://github.com/angular/angular/issues/19836)) ([fc0b1d5](https://github.com/angular/angular/commit/fc0b1d5)), closes [#19718](https://github.com/angular/angular/issues/19718)
+* **service-worker:** include versionedFiles in the manifest hashTable ([#19837](https://github.com/angular/angular/issues/19837)) ([90d1423](https://github.com/angular/angular/commit/90d1423))
+
+
+
 <a name="5.0.0-rc.3"></a>
 # [5.0.0-rc.3](https://github.com/angular/angular/compare/5.0.0-rc.2...5.0.0-rc.3) (2017-10-18)
 

CONTRIBUTING.md

@@ -220,6 +220,7 @@ The following is the list of supported scopes:
 * **platform-webworker**
 * **platform-webworker-dynamic**
 * **router**
+* **service-worker**
 * **upgrade**
 
 There are currently a few exceptions to the "use package name" rule:

aio/aio-builds-setup/dockerbuild/Dockerfile

@@ -156,7 +156,7 @@ RUN find $AIO_SCRIPTS_SH_DIR -maxdepth 1 -type f -printf "%P\n" \
 # Set up the Node.js scripts
 COPY scripts-js/ $AIO_SCRIPTS_JS_DIR/
 WORKDIR $AIO_SCRIPTS_JS_DIR/
-RUN yarn install --production --freeze-lockfile
+RUN yarn install --production --frozen-lockfile
 
 
 # Set up health check

aio/aio-builds-setup/scripts/create-image.sh

@@ -9,7 +9,7 @@ readonly defaultImageNameAndTag="aio-builds:latest"
 # (Necessary, because only `scripts-js/dist/` is copied to the docker image.)
 (
   cd "$SCRIPTS_JS_DIR"
-  yarn install --freeze-lockfile --non-interactive
+  yarn install --frozen-lockfile --non-interactive
   yarn build
 )
 

aio/aio-builds-setup/scripts/test.sh

@@ -7,6 +7,6 @@ source "`dirname $0`/_env.sh"
 # Test `scripts-js/`
 (
   cd "$SCRIPTS_JS_DIR"
-  yarn install --freeze-lockfile --non-interactive
+  yarn install --frozen-lockfile --non-interactive
   yarn test
 )

aio/e2e/app.e2e-spec.ts

@@ -68,30 +68,33 @@ describe('site App', function() {
 
   // TODO(https://github.com/angular/angular/issues/19785): Activate this again
   // once it is no more flaky.
-  xdescribe('google analytics', () => {
-    beforeEach(done => page.gaReady.then(done));
-
-    it('should call ga', done => {
-      page.ga()
-        .then(calls => {
-          expect(calls.length).toBeGreaterThan(2, 'ga calls');
-          done();
-        });
-    });
+  describe('google analytics', () => {
 
     it('should call ga with initial URL', done => {
       let path: string;
-
+      page.navigateTo('api');
       page.locationPath()
         .then(p => path = p)
         .then(() => page.ga().then(calls => {
-          expect(calls.length).toBeGreaterThan(2, 'ga calls');
-          expect(calls[1]).toEqual(['set', 'page', path]);
+          // The last call (length-1) will be the `send` command
+          // The second to last call (length-2) will be the command to `set` the page url
+          expect(calls[calls.length - 2]).toEqual(['set', 'page', path]);
           done();
         }));
     });
 
-    // Todo: add test to confirm tracking URL when navigate.
+    it('should call ga with new URL on navigation', done => {
+      let path: string;
+      page.getLink('features').click();
+      page.locationPath()
+        .then(p => path = p)
+        .then(() => page.ga().then(calls => {
+          // The last call (length-1) will be the `send` command
+          // The second to last call (length-2) will be the command to `set` the page url
+          expect(calls[calls.length - 2]).toEqual(['set', 'page', path]);
+          done();
+        }));
+    });
   });
 
   describe('search', () => {

aio/e2e/app.po.ts

@@ -12,7 +12,6 @@ export class SitePage {
     .all(by.css('a'))
     .filter((a: ElementFinder) => a.getAttribute('href').then(href => githubRegex.test(href)))
     .first();
-  gaReady: promise.Promise<any>;
 
   static setWindowWidth(newWidth: number) {
     const win = browser.driver.manage().window();
@@ -25,11 +24,14 @@ export class SitePage {
                   .first();
   }
   getLink(path) { return element(by.css(`a[href="${path}"]`)); }
-  ga() { return browser.executeScript('return window["gaCalls"]') as promise.Promise<any[][]>; }
+  ga() { return browser.executeScript('return window["ga"].q') as promise.Promise<any[][]>; }
   locationPath() { return browser.executeScript('return document.location.pathname') as promise.Promise<string>; }
 
   navigateTo(pageUrl = '') {
-    return browser.get('/' + pageUrl).then(_ => this.replaceGa(_));
+    return browser.get('/' + pageUrl)
+      // We need to tell the index.html not to load the real analytics library
+      // See the GA snippet in index.html
+      .then(() => browser.driver.executeScript('sessionStorage.setItem("__e2e__", true);'));
   }
 
   getDocViewerText() {
@@ -61,31 +63,4 @@ export class SitePage {
     browser.wait(ExpectedConditions.presenceOf(results.first()), 8000);
     return results;
   }
-
-  /**
-   * Replace the ambient Google Analytics tracker with homebrew spy
-   * don't send commands to GA during e2e testing!
-   * @param _ - forward's anything passed in
-   */
-  private replaceGa(_: any) {
-
-    this.gaReady = browser.driver.executeScript(() => {
-      // Give ga() a "ready" callback:
-      // https://developers.google.com/analytics/devguides/collection/analyticsjs/command-queue-reference
-      window['ga'](() => {
-        window['gaCalls'] = [];
-        window['ga'] = function() { window['gaCalls'].push(arguments); };
-      });
-
-    })
-    .then(() => {
-      // wait for GaService to start using window.ga after analytics lib loads.
-      const d =  promise.defer();
-      setTimeout(() => d.fulfill(), 1000); // GaService.initializeDelay
-      return d.promise;
-    });
-
-    return _;
-  }
 }
-

aio/firebase.json

@@ -44,6 +44,17 @@
         "source": "**/!(*.*)",
         "destination": "/index.html"
       }
+    ],
+    "headers": [
+      {
+        "source": "/",
+        "headers": [
+          {
+            "key": "Link",
+            "value": "</generated/navigation.json>;rel=preload;as=fetch,</generated/docs/index.json>;rel=preload;as=fetch"
+          }
+        ]
+      }
     ]
   }
 }

aio/package.json

@@ -7,7 +7,7 @@
   "license": "MIT",
   "scripts": {
     "aio-use-local": "node tools/ng-packages-installer overwrite . --debug --ignore-packages @angular/service-worker",
-    "aio-use-npm": "node tools/ng-packages-installer restore .",
+    "aio-use-npm": "node tools/ng-packages-installer restore . && yarn upgrade @angular/cli@1.3.0",
     "aio-check-local": "node tools/ng-packages-installer check .",
     "ng": "yarn check-env && ng",
     "start": "yarn check-env && ng serve",
@@ -19,11 +19,11 @@
     "test": "yarn check-env && ng test",
     "pree2e": "yarn check-env && yarn ~~update-webdriver",
     "e2e": "ng e2e --no-webdriver-update",
-    "presetup": "yarn install --freeze-lockfile && yarn ~~check-env && yarn boilerplate:remove",
+    "presetup": "yarn install --frozen-lockfile && yarn ~~check-env && yarn boilerplate:remove",
     "setup": "yarn aio-use-npm && yarn example-use-npm",
     "postsetup": "yarn boilerplate:add && yarn build-ie-polyfills && yarn generate-plunkers && yarn generate-zips && yarn docs",
     "presetup-local": "yarn presetup",
-    "setup-local": "yarn aio-use-local && yarn example-use-local",
+    "setup-local": "yarn aio-use-local && yarn upgrade @angular/cli@1.5.0-rc.2 && yarn example-use-local",
     "postsetup-local": "yarn postsetup",
     "pretest-pwa-score-localhost": "yarn build",
     "test-pwa-score-localhost": "concurrently --kill-others --success first \"http-server dist -p 4200 --silent\" \"yarn test-pwa-score http://localhost:4200 90\"",

aio/scripts/test-pwa-score.js

@@ -19,6 +19,11 @@ const config = require('lighthouse/lighthouse-core/config/default.js');
 // Constants
 const VIEWER_URL = 'https://googlechrome.github.io/lighthouse/viewer/';
 
+// Specify the path to Chrome on Travis
+if (process.env.TRAVIS) {
+  process.env.LIGHTHOUSE_CHROMIUM_PATH = process.env.CHROME_BIN;
+}
+
 // Run
 _main(process.argv.slice(2));
 

aio/src/app/app.module.ts

@@ -45,6 +45,7 @@ import { ScrollService } from 'app/shared/scroll.service';
 import { ScrollSpyService } from 'app/shared/scroll-spy.service';
 import { SearchBoxComponent } from './search/search-box/search-box.component';
 import { TocService } from 'app/shared/toc.service';
+import { WindowToken, windowProvider } from 'app/shared/window';
 
 import { SharedModule } from 'app/shared/shared.module';
 
@@ -113,7 +114,8 @@ export const svgIconProviders = [
     ScrollSpyService,
     SearchService,
     svgIconProviders,
-    TocService
+    TocService,
+    { provide: WindowToken, useFactory: windowProvider },
   ],
   bootstrap: [AppComponent]
 })

aio/src/app/shared/ga.service.spec.ts

@@ -1,130 +1,87 @@
 import { ReflectiveInjector } from '@angular/core';
-import { fakeAsync, tick } from '@angular/core/testing';
 
 import { GaService } from 'app/shared/ga.service';
-import { Logger } from 'app/shared/logger.service';
+import { WindowToken } from 'app/shared/window';
 
 describe('GaService', () => {
-  let gaSpy: jasmine.Spy;
+  let gaService: GaService;
   let injector: ReflectiveInjector;
-
-  // filter for 'send' which communicates with server
-  // returns the url of the 'send pageview'
-  function gaSpySendCalls() {
-    let lastUrl: string;
-    return gaSpy.calls.all()
-      .reduce((acc, c) =>  {
-        const args = c.args;
-        if (args[0] === 'set') {
-          lastUrl = args[2];
-        } else if (args[0] === 'send') {
-          acc.push(lastUrl);
-        }
-        return acc;
-      }, []);
-  }
+  let gaSpy: jasmine.Spy;
+  let mockWindow: any;
 
   beforeEach(() => {
-    injector = ReflectiveInjector.resolveAndCreate([
-        GaService,
-        { provide: Logger, useClass: TestLogger }
-    ]);
+    gaSpy = jasmine.createSpy('ga');
+    mockWindow = { ga: gaSpy };
+    injector = ReflectiveInjector.resolveAndCreate([GaService, { provide: WindowToken, useFactory: () => mockWindow }]);
+    gaService = injector.get(GaService);
   });
 
-  describe('with ambient GA', () => {
-    let gaService: GaService;
-
-    beforeEach(fakeAsync(() => {
-      this.winGa = window['ga']; // remember current GA tracker just in case
-
-      // Replace Google Analytics tracker with spy after calling "ga ready" callback
-      window['ga'] = (fn: Function) => {
-        window['ga'] = gaSpy = jasmine.createSpy('ga');
-        fn();
-        tick(GaService.initializeDelay); // see GaService#initializeGa
-      };
-      gaService = injector.get(GaService);
-    }));
-
-    afterEach(() => {
-      window['ga'] = this.winGa;
-    });
-
-    it('should initialize ga with "create" when constructed', () => {
-      const first = gaSpy.calls.first().args;
-      expect(first[0]).toBe('create');
-    });
-
-    describe('#locationChanged(url)', () => {
-      it('should send page to url w/ leading slash', () => {
-        gaService.locationChanged('testUrl');
-        let args = gaSpy.calls.all()[1].args;
-        expect(args).toEqual(['set', 'page', '/testUrl']);
-        args = gaSpy.calls.all()[2].args;
-        expect(args).toEqual(['send', 'pageview']);
-      });
-    });
-
-    describe('#sendPage(url)', () => {
-      it('should set page to url w/ leading slash', () => {
-        gaService.sendPage('testUrl');
-        const args = gaSpy.calls.all()[1].args;
-        expect(args).toEqual(['set', 'page', '/testUrl']);
-      });
-
-      it('should send "pageview" ', () => {
-        gaService.sendPage('testUrl');
-        const args = gaSpy.calls.all()[2].args;
-        expect(args).toEqual(['send', 'pageview']);
-      });
-
-      it('should not send twice with same URL, back-to-back', () => {
-        gaService.sendPage('testUrl');
-        gaService.sendPage('testUrl');
-        expect(gaSpySendCalls()).toEqual(['/testUrl']);
-      });
-
-      it('should send twice with same URL, back-to-back, even when the hash changes', () => {
-        // Therefore it is up to caller NOT to call it when hash changes if this is unwanted.
-        // See LocationService and its specs
-        gaService.sendPage('testUrl#one');
-        gaService.sendPage('testUrl#two');
-        expect(gaSpySendCalls()).toEqual([
-          '/testUrl#one',
-          '/testUrl#two'
-        ]);
-
-      });
-
-      it('should send same URL twice when other intervening URL', () => {
-        gaService.sendPage('testUrl');
-        gaService.sendPage('testUrl2');
-        gaService.sendPage('testUrl');
-        expect(gaSpySendCalls()).toEqual([
-          '/testUrl',
-          '/testUrl2',
-          '/testUrl'
-        ]);
-      });
-    });
-
+  it('should initialize ga with "create" when constructed', () => {
+    const first = gaSpy.calls.first().args;
+    expect(first[0]).toBe('create');
   });
 
-  describe('when no ambient GA', () => {
-    let gaService: GaService;
-    let logger: TestLogger;
-
-    it('should log with "create" when constructed', () => {
-      gaService = injector.get(GaService);
-      logger = injector.get(Logger);
-      expect(logger.log.calls.count()).toBe(1, 'logger.log should be called');
-      const first = logger.log.calls.first().args;
-      expect(first[0]).toBe('ga:');
-      expect(first[1][0]).toBe('create'); // first[1] is the array of args to ga()
+  describe('#locationChanged(url)', () => {
+    it('should send page to url w/ leading slash', () => {
+      gaService.locationChanged('testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('set', 'page', '/testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('send', 'pageview');
     });
   });
+
+  describe('#sendPage(url)', () => {
+    it('should set page to url w/ leading slash', () => {
+      gaService.sendPage('testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('set', 'page', '/testUrl');
+    });
+
+    it('should send "pageview" ', () => {
+      gaService.sendPage('testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('send', 'pageview');
+    });
+
+    it('should not send twice with same URL, back-to-back', () => {
+      gaService.sendPage('testUrl');
+      gaSpy.calls.reset();
+      gaService.sendPage('testUrl');
+      expect(gaSpy).not.toHaveBeenCalled();
+    });
+
+    it('should send again even if only the hash changes', () => {
+      // Therefore it is up to caller NOT to call it when hash changes if this is unwanted.
+      // See LocationService and its specs
+      gaService.sendPage('testUrl#one');
+      expect(gaSpy).toHaveBeenCalledWith('set', 'page', '/testUrl#one');
+      expect(gaSpy).toHaveBeenCalledWith('send', 'pageview');
+      gaSpy.calls.reset();
+      gaService.sendPage('testUrl#two');
+      expect(gaSpy).toHaveBeenCalledWith('set', 'page', '/testUrl#two');
+      expect(gaSpy).toHaveBeenCalledWith('send', 'pageview');
+    });
+
+    it('should send same URL twice when other intervening URL', () => {
+      gaService.sendPage('testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('set', 'page', '/testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('send', 'pageview');
+      gaSpy.calls.reset();
+      gaService.sendPage('testUrl2');
+      expect(gaSpy).toHaveBeenCalledWith('set', 'page', '/testUrl2');
+      expect(gaSpy).toHaveBeenCalledWith('send', 'pageview');
+      gaSpy.calls.reset();
+      gaService.sendPage('testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('set', 'page', '/testUrl');
+      expect(gaSpy).toHaveBeenCalledWith('send', 'pageview');
+    });
+  });
+
+  it('should support replacing the `window.ga` function', () => {
+    const gaSpy2 = jasmine.createSpy('new ga');
+    mockWindow.ga = gaSpy2;
+    gaSpy.calls.reset();
+
+    gaService.sendPage('testUrl');
+    expect(gaSpy).not.toHaveBeenCalled();
+    expect(gaSpy2).toHaveBeenCalledWith('set', 'page', '/testUrl');
+    expect(gaSpy2).toHaveBeenCalledWith('send', 'pageview');
+  });
 });
-
-class TestLogger {
-  log = jasmine.createSpy('log');
-}

aio/src/app/shared/ga.service.ts

@@ -1,7 +1,7 @@
-import { Injectable } from '@angular/core';
+import { Inject, Injectable } from '@angular/core';
 
 import { environment } from '../../environments/environment';
-import { Logger } from 'app/shared/logger.service';
+import { WindowToken } from 'app/shared/window';
 
 @Injectable()
 /**
@@ -10,15 +10,10 @@ import { Logger } from 'app/shared/logger.service';
  * Associates data with a GA "property" from the environment (`gaId`).
  */
 export class GaService {
-  // ms to wait before acquiring window.ga after analytics library loads
-  // empirically determined to allow time for e2e test setup
-  static initializeDelay = 1000;
 
   private previousUrl: string;
-  private ga: (...rest: any[]) => void;
 
-  constructor(private logger: Logger) {
-    this.initializeGa();
+  constructor(@Inject(WindowToken) private window: Window) {
     this.ga('create', environment['gaId'] , 'auto');
   }
 
@@ -34,27 +29,7 @@ export class GaService {
     this.ga('send', 'pageview');
   }
 
-  // These gyrations are necessary to make the service e2e testable
-  // and to disable ga tracking during e2e tests.
-  private initializeGa() {
-    const ga = window['ga'];
-    if (ga) {
-      // Queue commands until GA analytics script has loaded.
-      const gaQueue: any[][] = [];
-      this.ga = (...rest: any[]) => { gaQueue.push(rest); };
-
-      // Then send queued commands to either real or e2e test ga();
-      // after waiting to allow possible e2e test to replace global ga function
-      ga(() => setTimeout(() => {
-        // this.logger.log('GA fn:', window['ga'].toString());
-        this.ga = window['ga'];
-        gaQueue.forEach((command) => this.ga.apply(null, command));
-      }, GaService.initializeDelay));
-
-    } else {
-      // delegate `ga` calls to the logger if no ga installed
-      this.ga = (...rest: any[]) => { this.logger.log('ga:', rest); };
-    }
+  ga(...args) {
+    this.window['ga'](...args);
   }
-
 }

aio/src/app/shared/window.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+
+export const WindowToken = new InjectionToken('Window');
+export function windowProvider() { return window; }

aio/src/index.html

@@ -34,9 +34,13 @@
 
   <!-- Google Analytics -->
   <script>
-  window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
+  // Note this is a customised version of the GA tracking snippet to aid e2e testing
+  // See the bit between /**/.../**/
+  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;/**/i.sessionStorage.__e2e__||/**/m.parentNode.insertBefore(a,m)
+  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
   </script>
-  <script async src='https://www.google-analytics.com/analytics.js'></script>
   <!-- End Google Analytics -->
 
   <script>

aio/tools/examples/shared/protractor.config.js

@@ -20,7 +20,11 @@ exports.config = {
 
   // Capabilities to be passed to the webdriver instance.
   capabilities: {
-    'browserName': 'chrome'
+    'browserName': 'chrome',
+    // For Travis
+    chromeOptions: {
+      binary: process.env.CHROME_BIN
+    }
   },
 
   // Framework to use. Jasmine is recommended.

aio/tools/ng-packages-installer/index.js

@@ -129,7 +129,7 @@ class NgPackagesInstaller {
    * Yarn will also delete the local marker file for us.
    */
   restoreNpmDependencies() {
-    this._installDeps('--freeze-lockfile', '--check-files');
+    this._installDeps('--frozen-lockfile', '--check-files');
   }
 
   // Protected helpers

aio/tools/ng-packages-installer/index.spec.js

@@ -203,7 +203,7 @@ describe('NgPackagesInstaller', () => {
     it('should run `yarn install` in the specified directory, with the correct options', () => {
       spyOn(installer, '_installDeps');
       installer.restoreNpmDependencies();
-      expect(installer._installDeps).toHaveBeenCalledWith('--freeze-lockfile', '--check-files');
+      expect(installer._installDeps).toHaveBeenCalledWith('--frozen-lockfile', '--check-files');
     });
   });
 

aio/tools/transforms/angular-api-package/index.js

@@ -63,6 +63,7 @@ module.exports = new Package('angular-api', [basePackage, typeScriptPackage])
       'router/index.ts',
       'router/testing/index.ts',
       'router/upgrade/index.ts',
+      'service-worker/index.ts',
       'upgrade/index.ts',
       'upgrade/static/index.ts',
     ];

aio/tools/transforms/authors-package/api-package.js

@@ -21,6 +21,7 @@ const packageMap = {
   'platform-webworker': ['platform-webworker/index.ts'],
   'platform-webworker-dynamic': 'platform-webworker-dynamic/index.ts',
   router: ['router/index.ts', 'router/testing/index.ts', 'router/upgrade/index.ts'],
+  'service-worker': ['service-worker/index.ts'],
   upgrade: ['upgrade/index.ts', 'upgrade/static/index.ts']
 };
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-srcs",
-  "version": "5.0.0-rc.3",
+  "version": "5.0.0-rc.6",
   "private": true,
   "branchPattern": "2.0.*",
   "description": "Angular - a web framework for modern web apps",
@@ -24,7 +24,7 @@
   "dependencies": {
     "core-js": "^2.4.1",
     "reflect-metadata": "^0.1.3",
-    "rxjs": "^5.5.0",
+    "rxjs": "^5.5.2",
     "tslib": "^1.7.1",
     "zone.js": "^0.8.12"
   },

packages/bazel/src/ngc-wrapped/index.ts

@@ -60,6 +60,9 @@ export function runOneBuild(args: string[], inputs?: {[path: string]: string}):
     inputs,
     expectedOuts
   });
+  if (diagnostics.length) {
+    console.error(ng.formatDiagnostics(diagnostics));
+  }
   return diagnostics.every(d => d.category !== ts.DiagnosticCategory.Error);
 }
 
@@ -204,9 +207,7 @@ export function compile({allowNonHermeticReads, allDepsCompiledWithBazel = true,
       {rootNames: files, options: compilerOpts, host: ngHost, emitCallback, gatherDiagnostics});
   const tsickleEmitResult = emitResult as tsickle.EmitResult;
   let externs = '/** @externs */\n';
-  if (diagnostics.length) {
-    console.error(ng.formatDiagnostics(diagnostics));
-  } else {
+  if (!diagnostics.length) {
     if (bazelOpts.tsickleGenerateExterns) {
       externs += tsickle.getGeneratedExterns(tsickleEmitResult.externs);
     }

packages/compiler-cli/index.ts

@@ -6,13 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export {AotCompilerHost, AotCompilerHost as StaticReflectorHost, StaticReflector, StaticSymbol} from '@angular/compiler';
-export {CodeGenerator} from './src/codegen';
-export {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter, NodeCompilerHostContext} from './src/compiler_host';
 export {DiagnosticTemplateInfo, getExpressionScope, getTemplateExpressionDiagnostics} from './src/diagnostics/expression_diagnostics';
 export {AstType, ExpressionDiagnosticsContext} from './src/diagnostics/expression_type';
 export {BuiltinType, DeclarationKind, Definition, PipeInfo, Pipes, Signature, Span, Symbol, SymbolDeclaration, SymbolQuery, SymbolTable} from './src/diagnostics/symbols';
 export {getClassMembersFromDeclaration, getPipesTable, getSymbolQuery} from './src/diagnostics/typescript_symbols';
-export {Extractor} from './src/extractor';
 export {VERSION} from './src/version';
 
 export * from './src/metadata';
@@ -21,8 +18,7 @@ export * from './src/transformers/entry_points';
 
 export * from './src/perform_compile';
 
-// TODO(tbosch): remove this once everyone is on transformers
+// TODO(tbosch): remove this once cli 1.5 is fully released,
+// and usages in G3 are changed to `CompilerOptions`.
 export {CompilerOptions as AngularCompilerOptions} from './src/transformers/api';
-
-// TODO(hansl): moving to Angular 4 need to update this API.
 export {NgTools_InternalApi_NG_2 as __NGTOOLS_PRIVATE_API_2} from './src/ngtools_api';

packages/compiler-cli/integrationtest/test/test_ngtools_api.ts

@@ -15,8 +15,6 @@ import * as ts from 'typescript';
 import * as assert from 'assert';
 import {__NGTOOLS_PRIVATE_API_2, readConfiguration} from '@angular/compiler-cli';
 
-const glob = require('glob');
-
 /* tslint:disable:no-console  */
 /**
  * Main method.
@@ -27,9 +25,6 @@ function main() {
   console.log(`testing ngtools API...`);
 
   Promise.resolve()
-      .then(() => codeGenTest())
-      .then(() => codeGenTest(true))
-      .then(() => i18nTest())
       .then(() => lazyRoutesTest())
       .then(() => {
         console.log('All done!');
@@ -42,152 +37,6 @@ function main() {
       });
 }
 
-function codeGenTest(forceError = false) {
-  const basePath = path.join(__dirname, '../ngtools_src');
-  const srcPath = path.join(__dirname, '../src');
-  const project = path.join(basePath, 'tsconfig-build.json');
-  const readResources: string[] = [];
-  const wroteFiles: string[] = [];
-
-  const config = readConfiguration(project);
-  const delegateHost = ts.createCompilerHost(config.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
-  const program = ts.createProgram(config.rootNames, config.options, host);
-
-  config.options.basePath = basePath;
-
-  console.log(`>>> running codegen for ${project}`);
-  if (forceError) {
-    console.log(`>>> asserting that missingTranslation param with error value throws`);
-  }
-  return __NGTOOLS_PRIVATE_API_2
-      .codeGen({
-        basePath,
-        compilerOptions: config.options, program, host,
-
-        angularCompilerOptions: config.options,
-
-        // i18n options.
-        i18nFormat: 'xlf',
-        i18nFile: path.join(srcPath, 'messages.fi.xlf'),
-        locale: 'fi',
-        missingTranslation: forceError ? 'error' : 'ignore',
-
-        readResource: (fileName: string) => {
-          readResources.push(fileName);
-          if (!host.fileExists(fileName)) {
-            throw new Error(`Compilation failed. Resource file not found: ${fileName}`);
-          }
-          return Promise.resolve(host.readFile(fileName));
-        }
-      })
-      .then(() => {
-        console.log(`>>> codegen done, asserting read and wrote files`);
-
-        // Assert for each file that it has been read and each `ts` has a written file associated.
-        const allFiles = glob.sync(path.join(basePath, '**/*'), {nodir: true});
-
-        allFiles.forEach((fileName: string) => {
-          // Skip tsconfig.
-          if (fileName.match(/tsconfig-build.json$/)) {
-            return;
-          }
-
-          // Assert that file was read.
-          if (fileName.match(/\.module\.ts$/)) {
-            const factory = fileName.replace(/\.module\.ts$/, '.module.ngfactory.ts');
-            assert(wroteFiles.indexOf(factory) != -1, `Expected file "${factory}" to be written.`);
-          } else if (fileName.match(/\.css$/) || fileName.match(/\.html$/)) {
-            assert(
-                readResources.indexOf(fileName) != -1,
-                `Expected resource "${fileName}" to be read.`);
-          }
-        });
-
-        console.log(`done, no errors.`);
-      })
-      .catch((e: Error) => {
-        if (forceError) {
-          assert(
-              e.message.match(`Missing translation for message`),
-              `Expected error message for missing translations`);
-          console.log(`done, error catched`);
-        } else {
-          console.error(e.stack);
-          console.error('Compilation failed');
-          throw e;
-        }
-      });
-}
-
-function i18nTest() {
-  const basePath = path.join(__dirname, '../ngtools_src');
-  const project = path.join(basePath, 'tsconfig-build.json');
-  const readResources: string[] = [];
-  const wroteFiles: string[] = [];
-
-  const config = readConfiguration(project);
-  const delegateHost = ts.createCompilerHost(config.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
-  const program = ts.createProgram(config.rootNames, config.options, host);
-
-  config.options.basePath = basePath;
-
-  console.log(`>>> running i18n extraction for ${project}`);
-  return __NGTOOLS_PRIVATE_API_2
-      .extractI18n({
-        basePath,
-        compilerOptions: config.options, program, host,
-        angularCompilerOptions: config.options,
-        i18nFormat: 'xlf',
-        locale: undefined,
-        outFile: undefined,
-        readResource: (fileName: string) => {
-          readResources.push(fileName);
-          if (!host.fileExists(fileName)) {
-            throw new Error(`Compilation failed. Resource file not found: ${fileName}`);
-          }
-          return Promise.resolve(host.readFile(fileName));
-        },
-      })
-      .then(() => {
-        console.log(`>>> i18n extraction done, asserting read and wrote files`);
-
-        const allFiles = glob.sync(path.join(basePath, '**/*'), {nodir: true});
-
-        assert(wroteFiles.length == 1, `Expected a single message bundle file.`);
-
-        assert(
-            wroteFiles[0].endsWith('/ngtools_src/messages.xlf'),
-            `Expected the bundle file to be "message.xlf".`);
-
-        allFiles.forEach((fileName: string) => {
-          // Skip tsconfig.
-          if (fileName.match(/tsconfig-build.json$/)) {
-            return;
-          }
-
-          // Assert that file was read.
-          if (fileName.match(/\.css$/) || fileName.match(/\.html$/)) {
-            assert(
-                readResources.indexOf(fileName) != -1,
-                `Expected resource "${fileName}" to be read.`);
-          }
-        });
-
-        console.log(`done, no errors.`);
-      })
-      .catch((e: Error) => {
-        console.error(e.stack);
-        console.error('Extraction failed');
-        throw e;
-      });
-}
-
 function lazyRoutesTest() {
   const basePath = path.join(__dirname, '../ngtools_src');
   const project = path.join(basePath, 'tsconfig-build.json');

packages/compiler-cli/integrationtest/test/test_summaries.ts

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-// Must be imported first, because Angular decorators throw on load.
-import 'reflect-metadata';
-
-import * as path from 'path';
-import * as ts from 'typescript';
-import * as assert from 'assert';
-import {CompilerOptions, CodeGenerator, CompilerHostContext, NodeCompilerHostContext, readConfiguration} from '@angular/compiler-cli';
-
-/* tslint:disable:no-console  */
-/**
- * Main method.
- * Standalone program that executes the real codegen and tests that
- * ngsummary.json files are used for libraries.
- */
-function main() {
-  console.log(`testing usage of ngsummary.json files in libraries...`);
-  const basePath = path.resolve(__dirname, '..');
-  const project = path.resolve(basePath, 'tsconfig-build.json');
-  const readFiles: string[] = [];
-  const writtenFiles: {fileName: string, content: string}[] = [];
-
-  class AssertingHostContext extends NodeCompilerHostContext {
-    readFile(fileName: string): string {
-      if (/.*\/node_modules\/.*/.test(fileName) && !/.*ngsummary\.json$/.test(fileName) &&
-          !/package\.json$/.test(fileName)) {
-        // Only allow to read summaries and package.json files from node_modules
-        // TODO (mhevery): Fix this. TypeScript.d.ts does not allow returning null.
-        return null !;
-      }
-      readFiles.push(path.relative(basePath, fileName));
-      return super.readFile(fileName);
-    }
-    readResource(s: string): Promise<string> {
-      readFiles.push(path.relative(basePath, s));
-      return super.readResource(s);
-    }
-  }
-
-  const config = readConfiguration(project);
-  config.options.basePath = basePath;
-  // This flag tells ngc do not recompile libraries.
-  config.options.generateCodeForLibraries = false;
-
-  console.log(`>>> running codegen for ${project}`);
-  codegen(
-      config,
-      (host) => {
-        host.writeFile = (fileName: string, content: string) => {
-          fileName = path.relative(basePath, fileName);
-          writtenFiles.push({fileName, content});
-        };
-        return new AssertingHostContext();
-      })
-      .then((exitCode: any) => {
-        console.log(`>>> codegen done, asserting read files`);
-        assertSomeFileMatch(readFiles, /^node_modules\/.*\.ngsummary\.json$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.metadata.json$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.html$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.css$/);
-
-        assertNoFileMatch(readFiles, /^src\/.*\.ngsummary\.json$/);
-        assertSomeFileMatch(readFiles, /^src\/.*\.html$/);
-        assertSomeFileMatch(readFiles, /^src\/.*\.css$/);
-
-        console.log(`>>> asserting written files`);
-        assertWrittenFile(writtenFiles, /^src\/module\.ngfactory\.ts$/, /class MainModuleInjector/);
-
-        console.log(`done, no errors.`);
-        process.exit(exitCode);
-      })
-      .catch((e: any) => {
-        console.error(e.stack);
-        console.error('Compilation failed');
-        process.exit(1);
-      });
-}
-
-/**
- * Simple adaption of main to just run codegen with a CompilerHostContext
- */
-function codegen(
-    config: {options: CompilerOptions, rootNames: string[]},
-    hostContextFactory: (host: ts.CompilerHost) => CompilerHostContext) {
-  const host = ts.createCompilerHost(config.options, true);
-
-  // HACK: patch the realpath to solve symlink issue here:
-  // https://github.com/Microsoft/TypeScript/issues/9552
-  // todo(misko): remove once facade symlinks are removed
-  host.realpath = (path) => path;
-
-  const program = ts.createProgram(config.rootNames, config.options, host);
-
-  return CodeGenerator.create(config.options, {
-                      } as any, program, host, hostContextFactory(host)).codegen();
-}
-
-function assertSomeFileMatch(fileNames: string[], pattern: RegExp) {
-  assert(
-      fileNames.some(fileName => pattern.test(fileName)),
-      `Expected some read files match ${pattern}`);
-}
-
-function assertNoFileMatch(fileNames: string[], pattern: RegExp) {
-  const matches = fileNames.filter(fileName => pattern.test(fileName));
-  assert(
-      matches.length === 0,
-      `Expected no read files match ${pattern}, but found: \n${matches.join('\n')}`);
-}
-
-function assertWrittenFile(
-    files: {fileName: string, content: string}[], filePattern: RegExp, contentPattern: RegExp) {
-  assert(
-      files.some(file => filePattern.test(file.fileName) && contentPattern.test(file.content)),
-      `Expected some written files for ${filePattern} and content ${contentPattern}`);
-}
-
-main();

packages/compiler-cli/integrationtest/tsconfig-build.json

@@ -31,7 +31,6 @@
     "src/bootstrap",
     "test/all_spec",
     "test/test_ngtools_api",
-    "test/test_summaries",
     "benchmarks/src/tree/ng2/index_aot.ts",
     "benchmarks/src/tree/ng2_switch/index_aot.ts",
     "benchmarks/src/largetable/ng2/index_aot.ts",

packages/compiler-cli/integrationtest/tsconfig-xi18n.json

@@ -26,7 +26,6 @@
     "src/bootstrap",
     "test/all_spec",
     "test/test_ngtools_api",
-    "test/test_summaries",
     "benchmarks/src/tree/ng2/index_aot.ts",
     "benchmarks/src/tree/ng2_switch/index_aot.ts",
     "benchmarks/src/largetable/ng2/index_aot.ts",

packages/compiler-cli/src/codegen.ts

@@ -1,117 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * Transform template html and css into executable code.
- * Intended to be used in a build step.
- */
-import * as compiler from '@angular/compiler';
-import {readFileSync} from 'fs';
-import * as ts from 'typescript';
-
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
-import {CompilerOptions} from './transformers/api';
-
-const GENERATED_META_FILES = /\.json$/;
-
-const PREAMBLE = `/**
- * @fileoverview This file is generated by the Angular template compiler.
- * Do not edit.
- * @suppress {suspiciousCode,uselessCode,missingProperties,missingOverride}
- */
- /* tslint:disable */
-
-`;
-
-export interface CodeGeneratorI18nOptions {
-  i18nFormat: string|null;
-  i18nFile: string|null;
-  locale: string|null;
-  missingTranslation: string|null;
-}
-
-// TODO(tbosch): remove this once G3 uses the transformer compiler!
-export class CodeGenerator {
-  constructor(
-      private options: CompilerOptions, private program: ts.Program, public host: ts.CompilerHost,
-      private compiler: compiler.AotCompiler, private ngCompilerHost: CompilerHost) {}
-
-  codegen(): Promise<string[]> {
-    return this.compiler
-        .analyzeModulesAsync(this.program.getSourceFiles().map(
-            sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)))
-        .then(analyzedModules => this.emit(analyzedModules));
-  }
-
-  codegenSync(): string[] {
-    const analyzed = this.compiler.analyzeModulesSync(this.program.getSourceFiles().map(
-        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)));
-    return this.emit(analyzed);
-  }
-
-  private emit(analyzedModules: compiler.NgAnalyzedModules) {
-    const generatedModules = this.compiler.emitAllImpls(analyzedModules);
-    return generatedModules.map(generatedModule => {
-      const sourceFile = this.program.getSourceFile(generatedModule.srcFileUrl);
-      const emitPath = this.ngCompilerHost.calculateEmitPath(generatedModule.genFileUrl);
-      const source = generatedModule.source || compiler.toTypeScript(generatedModule, PREAMBLE);
-      this.host.writeFile(emitPath, source, false, () => {}, [sourceFile]);
-      return emitPath;
-    });
-  }
-
-  static create(
-      options: CompilerOptions, i18nOptions: CodeGeneratorI18nOptions, program: ts.Program,
-      tsCompilerHost: ts.CompilerHost, compilerHostContext?: CompilerHostContext,
-      ngCompilerHost?: CompilerHost): CodeGenerator {
-    if (!ngCompilerHost) {
-      const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
-      const context = compilerHostContext || new ModuleResolutionHostAdapter(tsCompilerHost);
-      ngCompilerHost = usePathMapping ? new PathMappedCompilerHost(program, options, context) :
-                                        new CompilerHost(program, options, context);
-    }
-    let transContent: string = '';
-    if (i18nOptions.i18nFile) {
-      if (!i18nOptions.locale) {
-        throw new Error(
-            `The translation file (${i18nOptions.i18nFile}) locale must be provided. Use the --locale option.`);
-      }
-      transContent = readFileSync(i18nOptions.i18nFile, 'utf8');
-    }
-    let missingTranslation = compiler.core.MissingTranslationStrategy.Warning;
-    if (i18nOptions.missingTranslation) {
-      switch (i18nOptions.missingTranslation) {
-        case 'error':
-          missingTranslation = compiler.core.MissingTranslationStrategy.Error;
-          break;
-        case 'warning':
-          missingTranslation = compiler.core.MissingTranslationStrategy.Warning;
-          break;
-        case 'ignore':
-          missingTranslation = compiler.core.MissingTranslationStrategy.Ignore;
-          break;
-        default:
-          throw new Error(
-              `Unknown option for missingTranslation (${i18nOptions.missingTranslation}). Use either error, warning or ignore.`);
-      }
-    }
-    if (!transContent) {
-      missingTranslation = compiler.core.MissingTranslationStrategy.Ignore;
-    }
-    const {compiler: aotCompiler} = compiler.createAotCompiler(ngCompilerHost, {
-      translations: transContent,
-      i18nFormat: i18nOptions.i18nFormat || undefined,
-      locale: i18nOptions.locale || undefined, missingTranslation,
-      enableLegacyTemplate: options.enableLegacyTemplate === true,
-      enableSummariesForJit: options.enableSummariesForJit !== false,
-      preserveWhitespaces: options.preserveWhitespaces,
-    });
-    return new CodeGenerator(options, program, tsCompilerHost, aotCompiler, ngCompilerHost);
-  }
-}

packages/compiler-cli/src/compiler_host.ts

@@ -1,494 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {AotCompilerHost, StaticSymbol, UrlResolver, createOfflineCompileUrlResolver, syntaxError} from '@angular/compiler';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ts from 'typescript';
-
-import {CollectorOptions, METADATA_VERSION, MetadataCollector, ModuleMetadata} from './metadata/index';
-import {CompilerOptions} from './transformers/api';
-
-const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-const DTS = /\.d\.ts$/;
-const NODE_MODULES = '/node_modules/';
-const IS_GENERATED = /\.(ngfactory|ngstyle|ngsummary)$/;
-const GENERATED_FILES = /\.ngfactory\.ts$|\.ngstyle\.ts$|\.ngsummary\.ts$/;
-const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.ngstyle\.ts$|\.ngsummary\.ts$/;
-const SHALLOW_IMPORT = /^((\w|-)+|(@(\w|-)+(\/(\w|-)+)+))$/;
-
-export interface BaseAotCompilerHostContext extends ts.ModuleResolutionHost {
-  readResource?(fileName: string): Promise<string>|string;
-}
-
-export abstract class BaseAotCompilerHost<C extends BaseAotCompilerHostContext> implements
-    AotCompilerHost {
-  private resolverCache = new Map<string, ModuleMetadata[]>();
-  private flatModuleIndexCache = new Map<string, boolean>();
-  private flatModuleIndexNames = new Set<string>();
-  private flatModuleIndexRedirectNames = new Set<string>();
-
-  constructor(protected options: CompilerOptions, protected context: C) {}
-
-  abstract moduleNameToFileName(m: string, containingFile: string): string|null;
-
-  abstract resourceNameToFileName(m: string, containingFile: string): string|null;
-
-  abstract fileNameToModuleName(importedFile: string, containingFile: string): string;
-
-  abstract toSummaryFileName(fileName: string, referringSrcFileName: string): string;
-
-  abstract fromSummaryFileName(fileName: string, referringLibFileName: string): string;
-
-  abstract getMetadataForSourceFile(filePath: string): ModuleMetadata|undefined;
-
-  getMetadataFor(filePath: string): ModuleMetadata[]|undefined {
-    if (!this.context.fileExists(filePath)) {
-      // If the file doesn't exists then we cannot return metadata for the file.
-      // This will occur if the user referenced a declared module for which no file
-      // exists for the module (i.e. jQuery or angularjs).
-      return;
-    }
-
-    if (DTS.test(filePath)) {
-      let metadatas = this.readMetadata(filePath);
-      if (!metadatas) {
-        // If there is a .d.ts file but no metadata file we need to produce a
-        // metadata from the .d.ts file as metadata files capture reexports
-        // (starting with v3).
-        metadatas = [this.upgradeMetadataWithDtsData(
-            {'__symbolic': 'module', 'version': 1, 'metadata': {}}, filePath)];
-      }
-      return metadatas;
-    }
-
-    // Attention: don't cache this, so that e.g. the LanguageService
-    // can read in changes from source files in the metadata!
-    const metadata = this.getMetadataForSourceFile(filePath);
-    return metadata ? [metadata] : [];
-  }
-
-  protected readMetadata(dtsFilePath: string): ModuleMetadata[]|undefined {
-    let metadatas = this.resolverCache.get(dtsFilePath);
-    if (metadatas) {
-      return metadatas;
-    }
-    const metadataPath = dtsFilePath.replace(DTS, '.metadata.json');
-    if (!this.context.fileExists(metadataPath)) {
-      return undefined;
-    }
-    try {
-      const metadataOrMetadatas = JSON.parse(this.context.readFile(metadataPath));
-      const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
-          (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
-          [];
-      if (metadatas.length) {
-        let maxMetadata = metadatas.reduce((p, c) => p.version > c.version ? p : c);
-        if (maxMetadata.version < METADATA_VERSION) {
-          metadatas.push(this.upgradeMetadataWithDtsData(maxMetadata, dtsFilePath));
-        }
-      }
-      this.resolverCache.set(dtsFilePath, metadatas);
-      return metadatas;
-    } catch (e) {
-      console.error(`Failed to read JSON file ${metadataPath}`);
-      throw e;
-    }
-  }
-
-  private upgradeMetadataWithDtsData(oldMetadata: ModuleMetadata, dtsFilePath: string):
-      ModuleMetadata {
-    // patch v1 to v3 by adding exports and the `extends` clause.
-    // patch v3 to v4 by adding `interface` symbols for TypeAlias
-    let newMetadata: ModuleMetadata = {
-      '__symbolic': 'module',
-      'version': METADATA_VERSION,
-      'metadata': {...oldMetadata.metadata},
-    };
-    if (oldMetadata.exports) {
-      newMetadata.exports = oldMetadata.exports;
-    }
-    if (oldMetadata.importAs) {
-      newMetadata.importAs = oldMetadata.importAs;
-    }
-    if (oldMetadata.origins) {
-      newMetadata.origins = oldMetadata.origins;
-    }
-    const dtsMetadata = this.getMetadataForSourceFile(dtsFilePath);
-    if (dtsMetadata) {
-      for (let prop in dtsMetadata.metadata) {
-        if (!newMetadata.metadata[prop]) {
-          newMetadata.metadata[prop] = dtsMetadata.metadata[prop];
-        }
-      }
-
-      // Only copy exports from exports from metadata prior to version 3.
-      // Starting with version 3 the collector began collecting exports and
-      // this should be redundant. Also, with bundler will rewrite the exports
-      // which will hoist the exports from modules referenced indirectly causing
-      // the imports to be different than the .d.ts files and using the .d.ts file
-      // exports would cause the StaticSymbolResolver to redirect symbols to the
-      // incorrect location.
-      if ((!oldMetadata.version || oldMetadata.version < 3) && dtsMetadata.exports) {
-        newMetadata.exports = dtsMetadata.exports;
-      }
-    }
-    return newMetadata;
-  }
-
-  loadResource(filePath: string): Promise<string>|string {
-    if (this.context.readResource) return this.context.readResource(filePath);
-    if (!this.context.fileExists(filePath)) {
-      throw syntaxError(`Error: Resource file not found: ${filePath}`);
-    }
-    return this.context.readFile(filePath);
-  }
-
-  loadSummary(filePath: string): string|null {
-    if (this.context.fileExists(filePath)) {
-      return this.context.readFile(filePath);
-    }
-    return null;
-  }
-
-  isSourceFile(filePath: string): boolean {
-    const excludeRegex =
-        this.options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
-    if (excludeRegex.test(filePath)) {
-      return false;
-    }
-    if (DTS.test(filePath)) {
-      // Check for a bundle index.
-      if (this.hasBundleIndex(filePath)) {
-        const normalFilePath = path.normalize(filePath);
-        return this.flatModuleIndexNames.has(normalFilePath) ||
-            this.flatModuleIndexRedirectNames.has(normalFilePath);
-      }
-    }
-    return true;
-  }
-
-  private hasBundleIndex(filePath: string): boolean {
-    const checkBundleIndex = (directory: string): boolean => {
-      let result = this.flatModuleIndexCache.get(directory);
-      if (result == null) {
-        if (path.basename(directory) == 'node_module') {
-          // Don't look outside the node_modules this package is installed in.
-          result = false;
-        } else {
-          // A bundle index exists if the typings .d.ts file has a metadata.json that has an
-          // importAs.
-          try {
-            const packageFile = path.join(directory, 'package.json');
-            if (this.context.fileExists(packageFile)) {
-              // Once we see a package.json file, assume false until it we find the bundle index.
-              result = false;
-              const packageContent: any = JSON.parse(this.context.readFile(packageFile));
-              if (packageContent.typings) {
-                const typings = path.normalize(path.join(directory, packageContent.typings));
-                if (DTS.test(typings)) {
-                  const metadataFile = typings.replace(DTS, '.metadata.json');
-                  if (this.context.fileExists(metadataFile)) {
-                    const metadata = JSON.parse(this.context.readFile(metadataFile));
-                    if (metadata.flatModuleIndexRedirect) {
-                      this.flatModuleIndexRedirectNames.add(typings);
-                      // Note: don't set result = true,
-                      // as this would mark this folder
-                      // as having a bundleIndex too early without
-                      // filling the bundleIndexNames.
-                    } else if (metadata.importAs) {
-                      this.flatModuleIndexNames.add(typings);
-                      result = true;
-                    }
-                  }
-                }
-              }
-            } else {
-              const parent = path.dirname(directory);
-              if (parent != directory) {
-                // Try the parent directory.
-                result = checkBundleIndex(parent);
-              } else {
-                result = false;
-              }
-            }
-          } catch (e) {
-            // If we encounter any errors assume we this isn't a bundle index.
-            result = false;
-          }
-        }
-        this.flatModuleIndexCache.set(directory, result);
-      }
-      return result;
-    };
-
-    return checkBundleIndex(path.dirname(filePath));
-  }
-}
-
-export interface CompilerHostContext extends ts.ModuleResolutionHost {
-  readResource?(fileName: string): Promise<string>|string;
-  assumeFileExists(fileName: string): void;
-}
-
-// TODO(tbosch): remove this once G3 uses the transformer compiler!
-export class CompilerHost extends BaseAotCompilerHost<CompilerHostContext> {
-  protected metadataProvider: MetadataCollector;
-  protected basePath: string;
-  private moduleFileNames = new Map<string, string|null>();
-  private isGenDirChildOfRootDir: boolean;
-  private genDir: string;
-  protected resolveModuleNameHost: CompilerHostContext;
-  private urlResolver: UrlResolver;
-
-  constructor(
-      protected program: ts.Program, options: CompilerOptions, context: CompilerHostContext,
-      collectorOptions?: CollectorOptions) {
-    super(options, context);
-    this.metadataProvider = new MetadataCollector(collectorOptions);
-    // normalize the path so that it never ends with '/'.
-    this.basePath = path.normalize(path.join(this.options.basePath !, '.')).replace(/\\/g, '/');
-    this.genDir = path.normalize(path.join(this.options.genDir !, '.')).replace(/\\/g, '/');
-
-    const genPath: string = path.relative(this.basePath, this.genDir);
-    this.isGenDirChildOfRootDir = genPath === '' || !genPath.startsWith('..');
-
-    this.resolveModuleNameHost = Object.create(this.context);
-
-    // When calling ts.resolveModuleName,
-    // additional allow checks for .d.ts files to be done based on
-    // checks for .ngsummary.json files,
-    // so that our codegen depends on fewer inputs and requires to be called
-    // less often.
-    // This is needed as we use ts.resolveModuleName in reflector_host
-    // and it should be able to resolve summary file names.
-    this.resolveModuleNameHost.fileExists = (fileName: string): boolean => {
-      if (this.context.fileExists(fileName)) {
-        return true;
-      }
-      if (DTS.test(fileName)) {
-        const base = fileName.substring(0, fileName.length - 5);
-        return this.context.fileExists(base + '.ngsummary.json');
-      }
-      return false;
-    };
-    this.urlResolver = createOfflineCompileUrlResolver();
-  }
-
-  protected getSourceFile(filePath: string): ts.SourceFile {
-    let sf = this.program.getSourceFile(filePath);
-    if (!sf) {
-      if (this.context.fileExists(filePath)) {
-        const sourceText = this.context.readFile(filePath);
-        sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
-      } else {
-        throw new Error(`Source file ${filePath} not present in program.`);
-      }
-    }
-    return sf;
-  }
-
-  getMetadataForSourceFile(filePath: string): ModuleMetadata|undefined {
-    return this.metadataProvider.getMetadata(this.getSourceFile(filePath));
-  }
-
-  toSummaryFileName(fileName: string, referringSrcFileName: string): string {
-    return fileName.replace(EXT, '') + '.d.ts';
-  }
-
-  fromSummaryFileName(fileName: string, referringLibFileName: string): string { return fileName; }
-
-  calculateEmitPath(filePath: string): string {
-    // Write codegen in a directory structure matching the sources.
-    let root = this.options.basePath !;
-    for (const eachRootDir of this.options.rootDirs || []) {
-      if (this.options.trace) {
-        console.error(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
-      }
-      if (path.relative(eachRootDir, filePath).indexOf('.') !== 0) {
-        root = eachRootDir;
-      }
-    }
-
-    // transplant the codegen path to be inside the `genDir`
-    let relativePath: string = path.relative(root, filePath);
-    while (relativePath.startsWith('..' + path.sep)) {
-      // Strip out any `..` path such as: `../node_modules/@foo` as we want to put everything
-      // into `genDir`.
-      relativePath = relativePath.substr(3);
-    }
-
-    return path.join(this.options.genDir !, relativePath);
-  }
-
-  // We use absolute paths on disk as canonical.
-  getCanonicalFileName(fileName: string): string { return fileName; }
-
-  moduleNameToFileName(m: string, containingFile: string): string|null {
-    const key = m + ':' + (containingFile || '');
-    let result: string|null = this.moduleFileNames.get(key) || null;
-    if (!result) {
-      if (!containingFile || !containingFile.length) {
-        if (m.indexOf('.') === 0) {
-          throw new Error('Resolution of relative paths requires a containing file.');
-        }
-        // Any containing file gives the same result for absolute imports
-        containingFile = this.getCanonicalFileName(path.join(this.basePath, 'index.ts'));
-      }
-      m = m.replace(EXT, '');
-      const resolved =
-          ts.resolveModuleName(
-                m, containingFile.replace(/\\/g, '/'), this.options, this.resolveModuleNameHost)
-              .resolvedModule;
-      result = resolved ? this.getCanonicalFileName(resolved.resolvedFileName) : null;
-      this.moduleFileNames.set(key, result);
-    }
-    return result;
-  }
-
-  /**
-   * We want a moduleId that will appear in import statements in the generated code.
-   * These need to be in a form that system.js can load, so absolute file paths don't work.
-   *
-   * The `containingFile` is always in the `genDir`, where as the `importedFile` can be in
-   * `genDir`, `node_module` or `basePath`.  The `importedFile` is either a generated file or
-   * existing file.
-   *
-   *               | genDir   | node_module |  rootDir
-   * --------------+----------+-------------+----------
-   * generated     | relative |   relative  |   n/a
-   * existing file |   n/a    |   absolute  |  relative(*)
-   *
-   * NOTE: (*) the relative path is computed depending on `isGenDirChildOfRootDir`.
-   */
-  fileNameToModuleName(importedFile: string, containingFile: string): string {
-    // If a file does not yet exist (because we compile it later), we still need to
-    // assume it exists it so that the `resolve` method works!
-    if (importedFile !== containingFile && !this.context.fileExists(importedFile)) {
-      this.context.assumeFileExists(importedFile);
-    }
-
-    containingFile = this.rewriteGenDirPath(containingFile);
-    const containingDir = path.dirname(containingFile);
-    // drop extension
-    importedFile = importedFile.replace(EXT, '');
-
-    const nodeModulesIndex = importedFile.indexOf(NODE_MODULES);
-    const importModule = nodeModulesIndex === -1 ?
-        null :
-        importedFile.substring(nodeModulesIndex + NODE_MODULES.length);
-    const isGeneratedFile = IS_GENERATED.test(importedFile);
-
-    if (isGeneratedFile) {
-      // rewrite to genDir path
-      if (importModule) {
-        // it is generated, therefore we do a relative path to the factory
-        return this.dotRelative(containingDir, this.genDir + NODE_MODULES + importModule);
-      } else {
-        // assume that import is also in `genDir`
-        importedFile = this.rewriteGenDirPath(importedFile);
-        return this.dotRelative(containingDir, importedFile);
-      }
-    } else {
-      // user code import
-      if (importModule) {
-        return importModule;
-      } else {
-        if (!this.isGenDirChildOfRootDir) {
-          // assume that they are on top of each other.
-          importedFile = importedFile.replace(this.basePath, this.genDir);
-        }
-        if (SHALLOW_IMPORT.test(importedFile)) {
-          return importedFile;
-        }
-        return this.dotRelative(containingDir, importedFile);
-      }
-    }
-  }
-
-  resourceNameToFileName(m: string, containingFile: string): string {
-    return this.urlResolver.resolve(containingFile, m);
-  }
-
-  /**
-   * Moves the path into `genDir` folder while preserving the `node_modules` directory.
-   */
-  private rewriteGenDirPath(filepath: string) {
-    const nodeModulesIndex = filepath.indexOf(NODE_MODULES);
-    if (nodeModulesIndex !== -1) {
-      // If we are in node_modules, transplant them into `genDir`.
-      return path.join(this.genDir, filepath.substring(nodeModulesIndex));
-    } else {
-      // pretend that containing file is on top of the `genDir` to normalize the paths.
-      // we apply the `genDir` => `rootDir` delta through `rootDirPrefix` later.
-      return filepath.replace(this.basePath, this.genDir);
-    }
-  }
-
-  private dotRelative(from: string, to: string): string {
-    const rPath: string = path.relative(from, to).replace(/\\/g, '/');
-    return rPath.startsWith('.') ? rPath : './' + rPath;
-  }
-}
-
-export class CompilerHostContextAdapter {
-  protected assumedExists: {[fileName: string]: boolean} = {};
-
-  assumeFileExists(fileName: string): void { this.assumedExists[fileName] = true; }
-}
-
-export class ModuleResolutionHostAdapter extends CompilerHostContextAdapter implements
-    CompilerHostContext {
-  public directoryExists: ((directoryName: string) => boolean)|undefined;
-
-  constructor(private host: ts.ModuleResolutionHost) {
-    super();
-    if (host.directoryExists) {
-      this.directoryExists = (directoryName: string) => host.directoryExists !(directoryName);
-    }
-  }
-
-  fileExists(fileName: string): boolean {
-    return this.assumedExists[fileName] || this.host.fileExists(fileName);
-  }
-
-  readFile(fileName: string): string { return this.host.readFile(fileName); }
-
-  readResource(s: string) {
-    if (!this.host.fileExists(s)) {
-      // TODO: We should really have a test for error cases like this!
-      throw new Error(`Compilation failed. Resource file not found: ${s}`);
-    }
-    return Promise.resolve(this.host.readFile(s));
-  }
-}
-
-export class NodeCompilerHostContext extends CompilerHostContextAdapter implements
-    CompilerHostContext {
-  fileExists(fileName: string): boolean {
-    return this.assumedExists[fileName] || fs.existsSync(fileName);
-  }
-
-  directoryExists(directoryName: string): boolean {
-    try {
-      return fs.statSync(directoryName).isDirectory();
-    } catch (e) {
-      return false;
-    }
-  }
-
-  readFile(fileName: string): string { return fs.readFileSync(fileName, 'utf8'); }
-
-  readResource(s: string) {
-    if (!this.fileExists(s)) {
-      // TODO: We should really have a test for error cases like this!
-      throw new Error(`Compilation failed. Resource file not found: ${s}`);
-    }
-    return Promise.resolve(this.readFile(s));
-  }
-}

packages/compiler-cli/src/extractor.ts

@@ -1,64 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-
-/**
- * Extract i18n messages from source code
- */
-// Must be imported first, because Angular decorators throw on load.
-import 'reflect-metadata';
-
-import * as compiler from '@angular/compiler';
-import * as path from 'path';
-import * as ts from 'typescript';
-
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
-import {CompilerOptions} from './transformers/api';
-import {i18nExtract, i18nGetExtension, i18nSerialize} from './transformers/program';
-
-export class Extractor {
-  constructor(
-      private options: CompilerOptions, private ngExtractor: compiler.Extractor,
-      public host: ts.CompilerHost, private ngCompilerHost: CompilerHost,
-      private program: ts.Program) {}
-
-  extract(formatName: string, outFile: string|null): Promise<string[]> {
-    return this.extractBundle().then(
-        bundle => i18nExtract(formatName, outFile, this.host, this.options, bundle));
-  }
-
-  extractBundle(): Promise<compiler.MessageBundle> {
-    const files = this.program.getSourceFiles().map(
-        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName));
-
-    return this.ngExtractor.extract(files);
-  }
-
-  serialize(bundle: compiler.MessageBundle, formatName: string): string {
-    return i18nSerialize(bundle, formatName, this.options);
-  }
-
-  getExtension(formatName: string): string { return i18nGetExtension(formatName); }
-
-  static create(
-      options: CompilerOptions, program: ts.Program, tsCompilerHost: ts.CompilerHost,
-      locale?: string|null, compilerHostContext?: CompilerHostContext,
-      ngCompilerHost?: CompilerHost): Extractor {
-    if (!ngCompilerHost) {
-      const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
-      const context = compilerHostContext || new ModuleResolutionHostAdapter(tsCompilerHost);
-      ngCompilerHost = usePathMapping ? new PathMappedCompilerHost(program, options, context) :
-                                        new CompilerHost(program, options, context);
-    }
-
-    const {extractor: ngExtractor} = compiler.Extractor.create(ngCompilerHost, locale || null);
-
-    return new Extractor(options, ngExtractor, tsCompilerHost, ngCompilerHost, program);
-  }
-}

packages/compiler-cli/src/language_services.ts

@@ -14,9 +14,10 @@ Angular modules and Typescript as this will indirectly add a dependency
 to the language service.
 
 */
-export {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter, NodeCompilerHostContext} from './compiler_host';
 export {DiagnosticTemplateInfo, ExpressionDiagnostic, getExpressionDiagnostics, getExpressionScope, getTemplateExpressionDiagnostics} from './diagnostics/expression_diagnostics';
 export {AstType, DiagnosticKind, ExpressionDiagnosticsContext, TypeDiagnostic} from './diagnostics/expression_type';
 export {BuiltinType, DeclarationKind, Definition, Location, PipeInfo, Pipes, Signature, Span, Symbol, SymbolDeclaration, SymbolQuery, SymbolTable} from './diagnostics/symbols';
 export {getClassFromStaticSymbol, getClassMembers, getClassMembersFromDeclaration, getPipesTable, getSymbolQuery} from './diagnostics/typescript_symbols';
+export {MetadataCollector, ModuleMetadata} from './metadata';
 export {CompilerOptions} from './transformers/api';
+export {MetadataReaderCache, MetadataReaderHost, createMetadataReaderCache, readMetadata} from './transformers/metadata_reader';

packages/compiler-cli/src/main.ts

@@ -28,15 +28,15 @@ export function main(
   let {project, rootNames, options, errors: configErrors, watch, emitFlags} =
       config || readNgcCommandLineAndConfiguration(args);
   if (configErrors.length) {
-    return reportErrorsAndExit(configErrors, consoleError);
+    return reportErrorsAndExit(configErrors, /*options*/ undefined, consoleError);
   }
   if (watch) {
     const result = watchMode(project, options, consoleError);
-    return reportErrorsAndExit(result.firstCompileResult, consoleError);
+    return reportErrorsAndExit(result.firstCompileResult, options, consoleError);
   }
   const {diagnostics: compileDiags} = performCompilation(
       {rootNames, options, emitFlags, emitCallback: createEmitCallback(options)});
-  return reportErrorsAndExit(compileDiags, consoleError);
+  return reportErrorsAndExit(compileDiags, options, consoleError);
 }
 
 function createEmitCallback(options: api.CompilerOptions): api.TsEmitCallback|undefined {
@@ -45,6 +45,12 @@ function createEmitCallback(options: api.CompilerOptions): api.TsEmitCallback|un
   if (!transformDecorators && !transformTypesToClosure) {
     return undefined;
   }
+  if (transformDecorators) {
+    // This is needed as a workaround for https://github.com/angular/tsickle/issues/635
+    // Otherwise tsickle might emit references to non imported values
+    // as TypeScript elided the import.
+    options.emitDecoratorMetadata = true;
+  }
   const tsickleHost: tsickle.TsickleHost = {
     shouldSkipTsickleProcessing: (fileName) =>
                                      /\.d\.ts$/.test(fileName) || GENERATED_FILES.test(fileName),
@@ -128,10 +134,17 @@ export function readCommandLineAndConfiguration(
 }
 
 function reportErrorsAndExit(
-    allDiagnostics: Diagnostics, consoleError: (s: string) => void = console.error): number {
+    allDiagnostics: Diagnostics, options?: api.CompilerOptions,
+    consoleError: (s: string) => void = console.error): number {
   const errorsAndWarnings = filterErrorsAndWarnings(allDiagnostics);
   if (errorsAndWarnings.length) {
-    consoleError(formatDiagnostics(errorsAndWarnings));
+    let currentDir = options ? options.basePath : undefined;
+    const formatHost: ts.FormatDiagnosticsHost = {
+      getCurrentDirectory: () => currentDir || ts.sys.getCurrentDirectory(),
+      getCanonicalFileName: fileName => fileName,
+      getNewLine: () => ts.sys.newLine
+    };
+    consoleError(formatDiagnostics(errorsAndWarnings, formatHost));
   }
   return exitCodeFromResult(allDiagnostics);
 }

packages/compiler-cli/src/ngtools_api.ts

@@ -13,15 +13,17 @@
  * something else.
  */
 
-import {AotCompilerHost, AotSummaryResolver, StaticReflector, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
+/**
+ *********************************************************************
+ * Changes to this file need to be approved by the Angular CLI team. *
+ *********************************************************************
+ */
+
 import * as ts from 'typescript';
 
-import {CodeGenerator} from './codegen';
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {Extractor} from './extractor';
-import {listLazyRoutesOfModule} from './ngtools_impl';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
-import {CompilerOptions} from './transformers/api';
+import {CompilerHost, CompilerOptions, LazyRoute} from './transformers/api';
+import {getOriginalReferences} from './transformers/compiler_host';
+import {createProgram} from './transformers/entry_points';
 
 export interface NgTools_InternalApi_NG2_CodeGen_Options {
   basePath: string;
@@ -66,47 +68,16 @@ export interface NgTools_InternalApi_NG2_ExtractI18n_Options {
   outFile?: string;
 }
 
-/**
- * A ModuleResolutionHostAdapter that overrides the readResource() method with the one
- * passed in the interface.
- */
-class CustomLoaderModuleResolutionHostAdapter extends ModuleResolutionHostAdapter {
-  constructor(
-      private _readResource: (path: string) => Promise<string>, host: ts.ModuleResolutionHost) {
-    super(host);
-  }
-
-  readResource(path: string) { return this._readResource(path); }
-}
-
 /**
  * @internal
+ * @deprecatd Use ngtools_api2 instead!
  */
 export class NgTools_InternalApi_NG_2 {
   /**
    * @internal
    */
   static codeGen(options: NgTools_InternalApi_NG2_CodeGen_Options): Promise<any> {
-    const hostContext: CompilerHostContext =
-        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
-
-    const i18nOptions = {
-      i18nFormat: options.i18nFormat !,
-      i18nFile: options.i18nFile !,
-      locale: options.locale !,
-      missingTranslation: options.missingTranslation !,
-    };
-    const ngOptions = options.angularCompilerOptions;
-    if (ngOptions.enableSummariesForJit === undefined) {
-      // default to false
-      ngOptions.enableSummariesForJit = false;
-    }
-
-    // Create the Code Generator.
-    const codeGenerator =
-        CodeGenerator.create(ngOptions, i18nOptions, options.program, options.host, hostContext);
-
-    return codeGenerator.codegen();
+    throw throwNotSupportedError();
   }
 
   /**
@@ -114,42 +85,49 @@ export class NgTools_InternalApi_NG_2 {
    */
   static listLazyRoutes(options: NgTools_InternalApi_NG2_ListLazyRoutes_Options):
       NgTools_InternalApi_NG_2_LazyRouteMap {
-    const angularCompilerOptions = options.angularCompilerOptions;
-    const program = options.program;
+    // TODO(tbosch): Also throwNotSupportedError once Angular CLI 1.5.1 ships,
+    // as we only needed this to support Angular CLI 1.5.0 rc.*
+    const ngProgram = createProgram({
+      rootNames: options.program.getRootFileNames(),
+      options: {...options.angularCompilerOptions, collectAllErrors: true},
+      host: options.host
+    });
+    const lazyRoutes = ngProgram.listLazyRoutes(options.entryModule);
 
-    const moduleResolutionHost = new ModuleResolutionHostAdapter(options.host);
-    const usePathMapping =
-        !!angularCompilerOptions.rootDirs && angularCompilerOptions.rootDirs.length > 0;
-    const ngCompilerHost: AotCompilerHost = usePathMapping ?
-        new PathMappedCompilerHost(program, angularCompilerOptions, moduleResolutionHost) :
-        new CompilerHost(program, angularCompilerOptions, moduleResolutionHost);
+    // reset the referencedFiles that the ng.Program added to the SourceFiles
+    // as the host might be caching the source files!
+    for (const sourceFile of options.program.getSourceFiles()) {
+      const originalReferences = getOriginalReferences(sourceFile);
+      if (originalReferences) {
+        sourceFile.referencedFiles = originalReferences;
+      }
+    }
 
-    const symbolCache = new StaticSymbolCache();
-    const summaryResolver = new AotSummaryResolver(ngCompilerHost, symbolCache);
-    const symbolResolver = new StaticSymbolResolver(ngCompilerHost, symbolCache, summaryResolver);
-    const staticReflector = new StaticReflector(summaryResolver, symbolResolver);
-    const routeMap = listLazyRoutesOfModule(options.entryModule, ngCompilerHost, staticReflector);
+    const result: NgTools_InternalApi_NG_2_LazyRouteMap = {};
+    lazyRoutes.forEach(lazyRoute => {
+      const route = lazyRoute.route;
+      const referencedFilePath = lazyRoute.referencedModule.filePath;
+      if (result[route] && result[route] != referencedFilePath) {
+        throw new Error(
+            `Duplicated path in loadChildren detected: "${route}" is used in 2 loadChildren, ` +
+            `but they point to different modules "(${result[route]} and ` +
+            `"${referencedFilePath}"). Webpack cannot distinguish on context and would fail to ` +
+            'load the proper one.');
+      }
+      result[route] = referencedFilePath;
+    });
 
-    return Object.keys(routeMap).reduce(
-        (acc: NgTools_InternalApi_NG_2_LazyRouteMap, route: string) => {
-          acc[route] = routeMap[route].absoluteFilePath;
-          return acc;
-        },
-        {});
+    return result;
   }
 
   /**
    * @internal
    */
   static extractI18n(options: NgTools_InternalApi_NG2_ExtractI18n_Options): Promise<any> {
-    const hostContext: CompilerHostContext =
-        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
-
-    // Create the i18n extractor.
-    const locale = options.locale || null;
-    const extractor = Extractor.create(
-        options.angularCompilerOptions, options.program, options.host, locale, hostContext);
-
-    return extractor.extract(options.i18nFormat !, options.outFile || null);
+    throw throwNotSupportedError();
   }
 }
+
+function throwNotSupportedError() {
+  throw new Error(`Please update @angular/cli. Angular 5+ requires at least Angular CLI 1.5+`);
+}

packages/compiler-cli/src/ngtools_api2.ts

@@ -15,6 +15,12 @@
  * Once the ngc api is public and stable, this can be removed.
  */
 
+/**
+ *********************************************************************
+ * Changes to this file need to be approved by the Angular CLI team. *
+ *********************************************************************
+ */
+
 import {ParseSourceSpan} from '@angular/compiler';
 import * as ts from 'typescript';
 
@@ -94,6 +100,12 @@ export interface TsEmitArguments {
 
 export interface TsEmitCallback { (args: TsEmitArguments): ts.EmitResult; }
 
+export interface LazyRoute {
+  module: {name: string, filePath: string};
+  route: string;
+  referencedModule: {name: string, filePath: string};
+}
+
 export interface Program {
   getTsProgram(): ts.Program;
   getTsOptionDiagnostics(cancellationToken?: ts.CancellationToken): ts.Diagnostic[];
@@ -106,6 +118,7 @@ export interface Program {
   getNgSemanticDiagnostics(fileName?: string, cancellationToken?: ts.CancellationToken):
       Diagnostic[];
   loadNgStructureAsync(): Promise<void>;
+  listLazyRoutes(entryRoute?: string): LazyRoute[];
   emit({emitFlags, cancellationToken, customTransformers, emitCallback}: {
     emitFlags?: EmitFlags,
     cancellationToken?: ts.CancellationToken,

packages/compiler-cli/src/ngtools_impl.ts

@@ -1,215 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * This is a private API for the ngtools toolkit.
- *
- * This API should be stable for NG 2. It can be removed in NG 4..., but should be replaced by
- * something else.
- */
-import {AotCompilerHost, StaticReflector, StaticSymbol, core} from '@angular/compiler';
-
-
-// We cannot depend directly to @angular/router.
-type Route = any;
-const ROUTER_MODULE_PATH = '@angular/router';
-const ROUTER_ROUTES_SYMBOL_NAME = 'ROUTES';
-
-
-// LazyRoute information between the extractors.
-export interface LazyRoute {
-  routeDef: RouteDef;
-  absoluteFilePath: string;
-}
-export type LazyRouteMap = {
-  [route: string]: LazyRoute
-};
-
-// A route definition. Normally the short form 'path/to/module#ModuleClassName' is used by
-// the user, and this is a helper class to extract information from it.
-export class RouteDef {
-  private constructor(public readonly path: string, public readonly className: string|null = null) {
-  }
-
-  toString() {
-    return (this.className === null || this.className == 'default') ?
-        this.path :
-        `${this.path}#${this.className}`;
-  }
-
-  static fromString(entry: string): RouteDef {
-    const split = entry.split('#');
-    return new RouteDef(split[0], split[1] || null);
-  }
-}
-
-
-export function listLazyRoutesOfModule(
-    entryModule: string, host: AotCompilerHost, reflector: StaticReflector): LazyRouteMap {
-  const entryRouteDef = RouteDef.fromString(entryModule);
-  const containingFile = _resolveModule(entryRouteDef.path, entryRouteDef.path, host);
-  const modulePath = `./${containingFile.replace(/^(.*)\//, '')}`;
-  const className = entryRouteDef.className !;
-
-  // List loadChildren of this single module.
-  const appStaticSymbol = reflector.findDeclaration(modulePath, className, containingFile);
-  const ROUTES = reflector.findDeclaration(ROUTER_MODULE_PATH, ROUTER_ROUTES_SYMBOL_NAME);
-  const lazyRoutes: LazyRoute[] =
-      _extractLazyRoutesFromStaticModule(appStaticSymbol, reflector, host, ROUTES);
-
-  const allLazyRoutes = lazyRoutes.reduce(
-      function includeLazyRouteAndSubRoutes(allRoutes: LazyRouteMap, lazyRoute: LazyRoute):
-          LazyRouteMap {
-            const route: string = lazyRoute.routeDef.toString();
-            _assertRoute(allRoutes, lazyRoute);
-            allRoutes[route] = lazyRoute;
-
-            // StaticReflector does not support discovering annotations like `NgModule` on default
-            // exports
-            // Which means: if a default export NgModule was lazy-loaded, we can discover it, but,
-            //  we cannot parse its routes to see if they have loadChildren or not.
-            if (!lazyRoute.routeDef.className) {
-              return allRoutes;
-            }
-
-            const lazyModuleSymbol = reflector.findDeclaration(
-                lazyRoute.absoluteFilePath, lazyRoute.routeDef.className || 'default');
-
-            const subRoutes =
-                _extractLazyRoutesFromStaticModule(lazyModuleSymbol, reflector, host, ROUTES);
-
-            return subRoutes.reduce(includeLazyRouteAndSubRoutes, allRoutes);
-          },
-      {});
-
-  return allLazyRoutes;
-}
-
-
-/**
- * Try to resolve a module, and returns its absolute path.
- * @private
- */
-function _resolveModule(modulePath: string, containingFile: string, host: AotCompilerHost) {
-  const result = host.moduleNameToFileName(modulePath, containingFile);
-  if (!result) {
-    throw new Error(`Could not resolve "${modulePath}" from "${containingFile}".`);
-  }
-  return result;
-}
-
-
-/**
- * Throw an exception if a route is in a route map, but does not point to the same module.
- */
-function _assertRoute(map: LazyRouteMap, route: LazyRoute) {
-  const r = route.routeDef.toString();
-  if (map[r] && map[r].absoluteFilePath != route.absoluteFilePath) {
-    throw new Error(
-        `Duplicated path in loadChildren detected: "${r}" is used in 2 loadChildren, ` +
-        `but they point to different modules "(${map[r].absoluteFilePath} and ` +
-        `"${route.absoluteFilePath}"). Webpack cannot distinguish on context and would fail to ` +
-        'load the proper one.');
-  }
-}
-
-export function flatten<T>(list: Array<T|T[]>): T[] {
-  return list.reduce((flat: any[], item: T | T[]): T[] => {
-    const flatItem = Array.isArray(item) ? flatten(item) : item;
-    return (<T[]>flat).concat(flatItem);
-  }, []);
-}
-
-/**
- * Extract all the LazyRoutes from a module. This extracts all `loadChildren` keys from this
- * module and all statically referred modules.
- * @private
- */
-function _extractLazyRoutesFromStaticModule(
-    staticSymbol: StaticSymbol, reflector: StaticReflector, host: AotCompilerHost,
-    ROUTES: StaticSymbol): LazyRoute[] {
-  const moduleMetadata = _getNgModuleMetadata(staticSymbol, reflector);
-  const imports = flatten(moduleMetadata.imports || []);
-  const allRoutes: any = imports.filter(i => 'providers' in i).reduce((mem: Route[], m: any) => {
-    return mem.concat(_collectRoutes(m.providers || [], reflector, ROUTES));
-  }, _collectRoutes(moduleMetadata.providers || [], reflector, ROUTES));
-
-  const lazyRoutes: LazyRoute[] =
-      _collectLoadChildren(allRoutes).reduce((acc: LazyRoute[], route: string) => {
-        const routeDef = RouteDef.fromString(route);
-        const absoluteFilePath = _resolveModule(routeDef.path, staticSymbol.filePath, host);
-        acc.push({routeDef, absoluteFilePath});
-        return acc;
-      }, []);
-
-  const importedSymbols =
-      (imports as any[])
-          .filter(i => i instanceof StaticSymbol || i.ngModule instanceof StaticSymbol)
-          .map(i => {
-            if (i instanceof StaticSymbol) return i;
-            return i.ngModule;
-          }) as StaticSymbol[];
-
-  return importedSymbols
-      .reduce(
-          (acc: LazyRoute[], i: StaticSymbol) => {
-            return acc.concat(_extractLazyRoutesFromStaticModule(i, reflector, host, ROUTES));
-          },
-          [])
-      .concat(lazyRoutes);
-}
-
-
-/**
- * Get the NgModule Metadata of a symbol.
- */
-function _getNgModuleMetadata(
-    staticSymbol: StaticSymbol, reflector: StaticReflector): core.NgModule {
-  const ngModules =
-      reflector.annotations(staticSymbol).filter((s: any) => core.createNgModule.isTypeOf(s));
-  if (ngModules.length === 0) {
-    throw new Error(`${staticSymbol.name} is not an NgModule`);
-  }
-  return ngModules[0];
-}
-
-
-/**
- * Return the routes from the provider list.
- * @private
- */
-function _collectRoutes(
-    providers: any[], reflector: StaticReflector, ROUTES: StaticSymbol): Route[] {
-  return providers.reduce((routeList: Route[], p: any) => {
-    if (p.provide === ROUTES) {
-      return routeList.concat(p.useValue);
-    } else if (Array.isArray(p)) {
-      return routeList.concat(_collectRoutes(p, reflector, ROUTES));
-    } else {
-      return routeList;
-    }
-  }, []);
-}
-
-
-/**
- * Return the loadChildren values of a list of Route.
- */
-function _collectLoadChildren(routes: Route[]): string[] {
-  return routes.reduce((m, r) => {
-    if (r.loadChildren && typeof r.loadChildren === 'string') {
-      return m.concat(r.loadChildren);
-    } else if (Array.isArray(r)) {
-      return m.concat(_collectLoadChildren(r));
-    } else if (r.children) {
-      return m.concat(_collectLoadChildren(r.children));
-    } else {
-      return m;
-    }
-  }, []);
-}

packages/compiler-cli/src/path_mapped_compiler_host.ts

@@ -1,142 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {StaticSymbol} from '@angular/compiler';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ts from 'typescript';
-
-import {CompilerHost, CompilerHostContext} from './compiler_host';
-import {ModuleMetadata} from './metadata/index';
-import {CompilerOptions} from './transformers/api';
-
-const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-const DTS = /\.d\.ts$/;
-
-/**
- * This version of the AotCompilerHost expects that the program will be compiled
- * and executed with a "path mapped" directory structure, where generated files
- * are in a parallel tree with the sources, and imported using a `./` relative
- * import. This requires using TS `rootDirs` option and also teaching the module
- * loader what to do.
- */
-export class PathMappedCompilerHost extends CompilerHost {
-  constructor(program: ts.Program, options: CompilerOptions, context: CompilerHostContext) {
-    super(program, options, context);
-  }
-
-  getCanonicalFileName(fileName: string): string {
-    if (!fileName) return fileName;
-    // NB: the rootDirs should have been sorted longest-first
-    for (const dir of this.options.rootDirs || []) {
-      if (fileName.indexOf(dir) === 0) {
-        fileName = fileName.substring(dir.length);
-      }
-    }
-    return fileName;
-  }
-
-  moduleNameToFileName(m: string, containingFile: string): string|null {
-    if (!containingFile || !containingFile.length) {
-      if (m.indexOf('.') === 0) {
-        throw new Error('Resolution of relative paths requires a containing file.');
-      }
-      // Any containing file gives the same result for absolute imports
-      containingFile = this.getCanonicalFileName(path.join(this.basePath, 'index.ts'));
-    }
-    for (const root of this.options.rootDirs || ['']) {
-      const rootedContainingFile = path.join(root, containingFile);
-      const resolved =
-          ts.resolveModuleName(m, rootedContainingFile, this.options, this.context).resolvedModule;
-      if (resolved) {
-        if (this.options.traceResolution) {
-          console.error('resolve', m, containingFile, '=>', resolved.resolvedFileName);
-        }
-        return this.getCanonicalFileName(resolved.resolvedFileName);
-      }
-    }
-    return null;
-  }
-
-  /**
-   * We want a moduleId that will appear in import statements in the generated code.
-   * These need to be in a form that system.js can load, so absolute file paths don't work.
-   * Relativize the paths by checking candidate prefixes of the absolute path, to see if
-   * they are resolvable by the moduleResolution strategy from the CompilerHost.
-   */
-  fileNameToModuleName(importedFile: string, containingFile: string): string {
-    if (this.options.traceResolution) {
-      console.error(
-          'getImportPath from containingFile', containingFile, 'to importedFile', importedFile);
-    }
-
-    // If a file does not yet exist (because we compile it later), we still need to
-    // assume it exists so that the `resolve` method works!
-    if (!this.context.fileExists(importedFile)) {
-      if (this.options.rootDirs && this.options.rootDirs.length > 0) {
-        this.context.assumeFileExists(path.join(this.options.rootDirs[0], importedFile));
-      } else {
-        this.context.assumeFileExists(importedFile);
-      }
-    }
-
-    const resolvable = (candidate: string) => {
-      const resolved = this.moduleNameToFileName(candidate, importedFile);
-      return resolved && resolved.replace(EXT, '') === importedFile.replace(EXT, '');
-    };
-
-    const importModuleName = importedFile.replace(EXT, '');
-    const parts = importModuleName.split(path.sep).filter(p => !!p);
-    let foundRelativeImport: string = undefined !;
-    for (let index = parts.length - 1; index >= 0; index--) {
-      let candidate = parts.slice(index, parts.length).join(path.sep);
-      if (resolvable(candidate)) {
-        return candidate;
-      }
-      candidate = '.' + path.sep + candidate;
-      if (resolvable(candidate)) {
-        foundRelativeImport = candidate;
-      }
-    }
-
-    if (foundRelativeImport) return foundRelativeImport;
-
-    // Try a relative import
-    const candidate = path.relative(path.dirname(containingFile), importModuleName);
-    if (resolvable(candidate)) {
-      return candidate;
-    }
-
-    throw new Error(
-        `Unable to find any resolvable import for ${importedFile} relative to ${containingFile}`);
-  }
-
-  getMetadataFor(filePath: string): ModuleMetadata[] {
-    for (const root of this.options.rootDirs || []) {
-      const rootedPath = path.join(root, filePath);
-      if (!this.context.fileExists(rootedPath)) {
-        // If the file doesn't exists then we cannot return metadata for the file.
-        // This will occur if the user refernced a declared module for which no file
-        // exists for the module (i.e. jQuery or angularjs).
-        continue;
-      }
-      if (DTS.test(rootedPath)) {
-        const metadatas = this.readMetadata(rootedPath);
-        if (metadatas) {
-          return metadatas;
-        }
-      } else {
-        // Attention: don't cache this, so that e.g. the LanguageService
-        // can read in changes from source files in the metadata!
-        const metadata = this.getMetadataForSourceFile(rootedPath);
-        return metadata ? [metadata] : [];
-      }
-    }
-    return null !;
-  }
-}

packages/compiler-cli/src/transformers/api.ts

@@ -150,6 +150,9 @@ export interface CompilerOptions extends ts.CompilerOptions {
    * in JIT mode. This is off by default.
    */
   enableSummariesForJit?: boolean;
+
+  /** @internal */
+  collectAllErrors?: boolean;
 }
 
 export interface CompilerHost extends ts.CompilerHost {
@@ -229,6 +232,12 @@ export interface LibrarySummary {
   sourceFile?: ts.SourceFile;
 }
 
+export interface LazyRoute {
+  route: string;
+  module: {name: string, filePath: string};
+  referencedModule: {name: string, filePath: string};
+}
+
 export interface Program {
   /**
    * Retrieve the TypeScript program used to produce semantic diagnostics and emit the sources.
@@ -293,6 +302,14 @@ export interface Program {
    */
   loadNgStructureAsync(): Promise<void>;
 
+  /**
+   * Returns the lazy routes in the program.
+   * @param entryRoute A reference to an NgModule like `someModule#name`. If given,
+   *              will recursively analyze routes starting from this symbol only.
+   *              Otherwise will list all routes for all NgModules in the program/
+   */
+  listLazyRoutes(entryRoute?: string): LazyRoute[];
+
   /**
    * Emit the files requested by emitFlags implied by the program.
    *

packages/compiler-cli/src/transformers/compiler_host.ts

@@ -6,19 +6,18 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {EmitterVisitorContext, ExternalReference, GeneratedFile, ParseSourceSpan, TypeScriptEmitter, collectExternalReferences, syntaxError} from '@angular/compiler';
+import {AotCompilerHost, EmitterVisitorContext, ExternalReference, GeneratedFile, ParseSourceSpan, TypeScriptEmitter, collectExternalReferences, syntaxError} from '@angular/compiler';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-import {BaseAotCompilerHost} from '../compiler_host';
 import {TypeCheckHost} from '../diagnostics/translate_diagnostics';
-import {ModuleMetadata} from '../metadata/index';
+import {METADATA_VERSION, ModuleMetadata} from '../metadata/index';
 
 import {CompilerHost, CompilerOptions, LibrarySummary} from './api';
-import {GENERATED_FILES} from './util';
+import {MetadataReaderHost, createMetadataReaderCache, readMetadata} from './metadata_reader';
+import {DTS, GENERATED_FILES, isInRootDir, relativeToRootDirs} from './util';
 
 const NODE_MODULES_PACKAGE_NAME = /node_modules\/((\w|-)+|(@(\w|-)+\/(\w|-)+))/;
-const DTS = /\.d\.ts$/;
 const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 
 export function createCompilerHost(
@@ -48,9 +47,12 @@ export interface CodeGenerator {
  * - AotCompilerHost for @angular/compiler
  * - TypeCheckHost for mapping ts errors to ng errors (via translateDiagnostics)
  */
-export class TsCompilerAotCompilerTypeCheckHostAdapter extends
-    BaseAotCompilerHost<CompilerHost> implements ts.CompilerHost,
+export class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHost, AotCompilerHost,
     TypeCheckHost {
+  private metadataReaderCache = createMetadataReaderCache();
+  private flatModuleIndexCache = new Map<string, boolean>();
+  private flatModuleIndexNames = new Set<string>();
+  private flatModuleIndexRedirectNames = new Set<string>();
   private rootDirs: string[];
   private moduleResolutionCache: ts.ModuleResolutionCache;
   private originalSourceFiles = new Map<string, ts.SourceFile|undefined>();
@@ -58,6 +60,8 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
   private generatedSourceFiles = new Map<string, GenSourceFile>();
   private generatedCodeFor = new Map<string, string[]>();
   private emitter = new TypeScriptEmitter();
+  private metadataReaderHost: MetadataReaderHost;
+
   getCancellationToken: () => ts.CancellationToken;
   getDefaultLibLocation: () => string;
   trace: (s: string) => void;
@@ -65,10 +69,9 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
   directoryExists?: (directoryName: string) => boolean;
 
   constructor(
-      private rootFiles: string[], options: CompilerOptions, context: CompilerHost,
+      private rootFiles: string[], private options: CompilerOptions, private context: CompilerHost,
       private metadataProvider: MetadataProvider, private codeGenerator: CodeGenerator,
       private librarySummaries = new Map<string, LibrarySummary>()) {
-    super(options, context);
     this.moduleResolutionCache = ts.createModuleResolutionCache(
         this.context.getCurrentDirectory !(), this.context.getCanonicalFileName.bind(this.context));
     const basePath = this.options.basePath !;
@@ -103,6 +106,15 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
     if (context.fromSummaryFileName) {
       this.fromSummaryFileName = context.fromSummaryFileName.bind(context);
     }
+    this.metadataReaderHost = {
+      cacheMetadata: () => true,
+      getSourceFileMetadata: (filePath) => {
+        const sf = this.getOriginalSourceFile(filePath);
+        return sf ? this.metadataProvider.getMetadata(sf) : undefined;
+      },
+      fileExists: (filePath) => this.originalFileExists(filePath),
+      readFile: (filePath) => this.context.readFile(filePath),
+    };
   }
 
   private resolveModuleName(moduleName: string, containingFile: string): ts.ResolvedModule
@@ -251,14 +263,6 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
     return sf;
   }
 
-  getMetadataForSourceFile(filePath: string): ModuleMetadata|undefined {
-    const sf = this.getOriginalSourceFile(filePath);
-    if (!sf) {
-      return undefined;
-    }
-    return this.metadataProvider.getMetadata(sf);
-  }
-
   updateGeneratedFile(genFile: GeneratedFile): ts.SourceFile {
     if (!genFile.stmts) {
       throw new Error(
@@ -301,7 +305,7 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
   shouldGenerateFile(fileName: string): {generate: boolean, baseFileName?: string} {
     // TODO(tbosch): allow generating files that are not in the rootDir
     // See https://github.com/angular/angular/issues/19337
-    if (this.options.rootDir && !pathStartsWithPrefix(this.options.rootDir, fileName)) {
+    if (!isInRootDir(fileName, this.options)) {
       return {generate: false};
     }
     const genMatch = GENERATED_FILES.exec(fileName);
@@ -335,7 +339,7 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
     // TODO(tbosch): allow generating files that are not in the rootDir
     // See https://github.com/angular/angular/issues/19337
     return !GENERATED_FILES.test(fileName) && this.isSourceFile(fileName) &&
-        (!this.options.rootDir || pathStartsWithPrefix(this.options.rootDir, fileName));
+        isInRootDir(fileName, this.options);
   }
 
   getSourceFile(
@@ -415,16 +419,39 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
     if (summary) {
       return summary.text;
     }
-    return super.loadSummary(filePath);
+    if (this.originalFileExists(filePath)) {
+      return this.context.readFile(filePath);
+    }
+    return null;
   }
 
   isSourceFile(filePath: string): boolean {
+    // Don't generate any files nor typecheck them
+    // if skipTemplateCodegen is set and fullTemplateTypeCheck is not yet set,
+    // for backwards compatibility.
+    if (this.options.skipTemplateCodegen && !this.options.fullTemplateTypeCheck) {
+      return false;
+    }
     // If we have a summary from a previous compilation,
     // treat the file never as a source file.
     if (this.librarySummaries.has(filePath)) {
       return false;
     }
-    return super.isSourceFile(filePath);
+    if (GENERATED_FILES.test(filePath)) {
+      return false;
+    }
+    if (this.options.generateCodeForLibraries === false && DTS.test(filePath)) {
+      return false;
+    }
+    if (DTS.test(filePath)) {
+      // Check for a bundle index.
+      if (this.hasBundleIndex(filePath)) {
+        const normalFilePath = path.normalize(filePath);
+        return this.flatModuleIndexNames.has(normalFilePath) ||
+            this.flatModuleIndexRedirectNames.has(normalFilePath);
+      }
+    }
+    return true;
   }
 
   readFile(fileName: string) {
@@ -434,6 +461,76 @@ export class TsCompilerAotCompilerTypeCheckHostAdapter extends
     }
     return this.context.readFile(fileName);
   }
+
+  getMetadataFor(filePath: string): ModuleMetadata[]|undefined {
+    return readMetadata(filePath, this.metadataReaderHost, this.metadataReaderCache);
+  }
+
+  loadResource(filePath: string): Promise<string>|string {
+    if (this.context.readResource) return this.context.readResource(filePath);
+    if (!this.originalFileExists(filePath)) {
+      throw syntaxError(`Error: Resource file not found: ${filePath}`);
+    }
+    return this.context.readFile(filePath);
+  }
+
+  private hasBundleIndex(filePath: string): boolean {
+    const checkBundleIndex = (directory: string): boolean => {
+      let result = this.flatModuleIndexCache.get(directory);
+      if (result == null) {
+        if (path.basename(directory) == 'node_module') {
+          // Don't look outside the node_modules this package is installed in.
+          result = false;
+        } else {
+          // A bundle index exists if the typings .d.ts file has a metadata.json that has an
+          // importAs.
+          try {
+            const packageFile = path.join(directory, 'package.json');
+            if (this.originalFileExists(packageFile)) {
+              // Once we see a package.json file, assume false until it we find the bundle index.
+              result = false;
+              const packageContent: any = JSON.parse(this.context.readFile(packageFile));
+              if (packageContent.typings) {
+                const typings = path.normalize(path.join(directory, packageContent.typings));
+                if (DTS.test(typings)) {
+                  const metadataFile = typings.replace(DTS, '.metadata.json');
+                  if (this.originalFileExists(metadataFile)) {
+                    const metadata = JSON.parse(this.context.readFile(metadataFile));
+                    if (metadata.flatModuleIndexRedirect) {
+                      this.flatModuleIndexRedirectNames.add(typings);
+                      // Note: don't set result = true,
+                      // as this would mark this folder
+                      // as having a bundleIndex too early without
+                      // filling the bundleIndexNames.
+                    } else if (metadata.importAs) {
+                      this.flatModuleIndexNames.add(typings);
+                      result = true;
+                    }
+                  }
+                }
+              }
+            } else {
+              const parent = path.dirname(directory);
+              if (parent != directory) {
+                // Try the parent directory.
+                result = checkBundleIndex(parent);
+              } else {
+                result = false;
+              }
+            }
+          } catch (e) {
+            // If we encounter any errors assume we this isn't a bundle index.
+            result = false;
+          }
+        }
+        this.flatModuleIndexCache.set(directory, result);
+      }
+      return result;
+    };
+
+    return checkBundleIndex(path.dirname(filePath));
+  }
+
   getDefaultLibFileName = (options: ts.CompilerOptions) =>
       this.context.getDefaultLibFileName(options)
   getCurrentDirectory = () => this.context.getCurrentDirectory();
@@ -482,22 +579,6 @@ function getPackageName(filePath: string): string|null {
   return match ? match[1] : null;
 }
 
-export function relativeToRootDirs(filePath: string, rootDirs: string[]): string {
-  if (!filePath) return filePath;
-  for (const dir of rootDirs || []) {
-    const rel = pathStartsWithPrefix(dir, filePath);
-    if (rel) {
-      return rel;
-    }
-  }
-  return filePath;
-}
-
-function pathStartsWithPrefix(prefix: string, fullPath: string): string|null {
-  const rel = path.relative(prefix, fullPath);
-  return rel.startsWith('..') ? null : rel;
-}
-
 function stripNodeModulesPrefix(filePath: string): string {
   return filePath.replace(/.*node_modules\//, '');
 }

packages/compiler-cli/src/transformers/lower_expressions.ts

@@ -181,11 +181,13 @@ function createVariableStatementForDeclarations(declarations: Declaration[]): ts
       /* modifiers */ undefined, ts.createVariableDeclarationList(varDecls, ts.NodeFlags.Const));
 }
 
-export function getExpressionLoweringTransformFactory(requestsMap: RequestsMap):
-    (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile {
+export function getExpressionLoweringTransformFactory(
+    requestsMap: RequestsMap, program: ts.Program): (context: ts.TransformationContext) =>
+    (sourceFile: ts.SourceFile) => ts.SourceFile {
   // Return the factory
   return (context: ts.TransformationContext) => (sourceFile: ts.SourceFile): ts.SourceFile => {
-    const requests = requestsMap.getRequests(sourceFile);
+    // We need to use the original SourceFile for reading metadata, and not the transformed one.
+    const requests = requestsMap.getRequests(program.getSourceFile(sourceFile.fileName));
     if (requests && requests.size) {
       return transformSourceFile(sourceFile, requests, context);
     }

packages/compiler-cli/src/transformers/metadata_reader.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ts from 'typescript';
+
+import {METADATA_VERSION, ModuleMetadata} from '../metadata';
+
+import {DTS} from './util';
+
+export interface MetadataReaderHost {
+  getSourceFileMetadata(filePath: string): ModuleMetadata|undefined;
+  cacheMetadata?(fileName: string): boolean;
+  fileExists(filePath: string): boolean;
+  readFile(filePath: string): string;
+}
+
+export interface MetadataReaderCache {
+  /**
+   * @internal
+   */
+  data: Map<string, ModuleMetadata[]|undefined>;
+}
+
+export function createMetadataReaderCache(): MetadataReaderCache {
+  const data = new Map<string, ModuleMetadata[]|undefined>();
+  return {data};
+}
+
+export function readMetadata(
+    filePath: string, host: MetadataReaderHost, cache?: MetadataReaderCache): ModuleMetadata[]|
+    undefined {
+  let metadatas = cache && cache.data.get(filePath);
+  if (metadatas) {
+    return metadatas;
+  }
+  if (host.fileExists(filePath)) {
+    // If the file doesn't exists then we cannot return metadata for the file.
+    // This will occur if the user referenced a declared module for which no file
+    // exists for the module (i.e. jQuery or angularjs).
+    if (DTS.test(filePath)) {
+      metadatas = readMetadataFile(host, filePath);
+      if (!metadatas) {
+        // If there is a .d.ts file but no metadata file we need to produce a
+        // metadata from the .d.ts file as metadata files capture reexports
+        // (starting with v3).
+        metadatas = [upgradeMetadataWithDtsData(
+            host, {'__symbolic': 'module', 'version': 1, 'metadata': {}}, filePath)];
+      }
+    } else {
+      const metadata = host.getSourceFileMetadata(filePath);
+      metadatas = metadata ? [metadata] : [];
+    }
+  }
+  if (cache && (!host.cacheMetadata || host.cacheMetadata(filePath))) {
+    cache.data.set(filePath, metadatas);
+  }
+  return metadatas;
+}
+
+
+function readMetadataFile(host: MetadataReaderHost, dtsFilePath: string): ModuleMetadata[]|
+    undefined {
+  const metadataPath = dtsFilePath.replace(DTS, '.metadata.json');
+  if (!host.fileExists(metadataPath)) {
+    return undefined;
+  }
+  try {
+    const metadataOrMetadatas = JSON.parse(host.readFile(metadataPath));
+    const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
+        (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
+        [];
+    if (metadatas.length) {
+      let maxMetadata = metadatas.reduce((p, c) => p.version > c.version ? p : c);
+      if (maxMetadata.version < METADATA_VERSION) {
+        metadatas.push(upgradeMetadataWithDtsData(host, maxMetadata, dtsFilePath));
+      }
+    }
+    return metadatas;
+  } catch (e) {
+    console.error(`Failed to read JSON file ${metadataPath}`);
+    throw e;
+  }
+}
+
+function upgradeMetadataWithDtsData(
+    host: MetadataReaderHost, oldMetadata: ModuleMetadata, dtsFilePath: string): ModuleMetadata {
+  // patch v1 to v3 by adding exports and the `extends` clause.
+  // patch v3 to v4 by adding `interface` symbols for TypeAlias
+  let newMetadata: ModuleMetadata = {
+    '__symbolic': 'module',
+    'version': METADATA_VERSION,
+    'metadata': {...oldMetadata.metadata},
+  };
+  if (oldMetadata.exports) {
+    newMetadata.exports = oldMetadata.exports;
+  }
+  if (oldMetadata.importAs) {
+    newMetadata.importAs = oldMetadata.importAs;
+  }
+  if (oldMetadata.origins) {
+    newMetadata.origins = oldMetadata.origins;
+  }
+  const dtsMetadata = host.getSourceFileMetadata(dtsFilePath);
+  if (dtsMetadata) {
+    for (let prop in dtsMetadata.metadata) {
+      if (!newMetadata.metadata[prop]) {
+        newMetadata.metadata[prop] = dtsMetadata.metadata[prop];
+      }
+    }
+
+    // Only copy exports from exports from metadata prior to version 3.
+    // Starting with version 3 the collector began collecting exports and
+    // this should be redundant. Also, with bundler will rewrite the exports
+    // which will hoist the exports from modules referenced indirectly causing
+    // the imports to be different than the .d.ts files and using the .d.ts file
+    // exports would cause the StaticSymbolResolver to redirect symbols to the
+    // incorrect location.
+    if ((!oldMetadata.version || oldMetadata.version < 3) && dtsMetadata.exports) {
+      newMetadata.exports = dtsMetadata.exports;
+    }
+  }
+  return newMetadata;
+}

packages/compiler-cli/src/transformers/program.ts

@@ -14,11 +14,13 @@ import * as ts from 'typescript';
 import {TypeCheckHost, translateDiagnostics} from '../diagnostics/translate_diagnostics';
 import {ModuleMetadata, createBundleIndexHost} from '../metadata/index';
 
-import {CompilerHost, CompilerOptions, CustomTransformers, DEFAULT_ERROR_CODE, Diagnostic, EmitFlags, LibrarySummary, Program, SOURCE, TsEmitArguments, TsEmitCallback} from './api';
+import {CompilerHost, CompilerOptions, CustomTransformers, DEFAULT_ERROR_CODE, Diagnostic, EmitFlags, LazyRoute, LibrarySummary, Program, SOURCE, TsEmitArguments, TsEmitCallback} from './api';
 import {CodeGenerator, TsCompilerAotCompilerTypeCheckHostAdapter, getOriginalReferences} from './compiler_host';
 import {LowerMetadataCache, getExpressionLoweringTransformFactory} from './lower_expressions';
 import {getAngularEmitterTransformFactory} from './node_emitter_transform';
-import {GENERATED_FILES, StructureIsReused, createMessageDiagnostic, tsStructureIsReused} from './util';
+import {GENERATED_FILES, StructureIsReused, createMessageDiagnostic, isInRootDir, tsStructureIsReused} from './util';
+
+
 
 /**
  * Maximum number of files that are emitable via calling ts.Program.emit
@@ -50,8 +52,8 @@ class AngularCompilerProgram implements Program {
   private emittedSourceFiles: ts.SourceFile[]|undefined;
 
   // Lazily initialized fields
-  private _typeCheckHost: TypeCheckHost;
   private _compiler: AotCompiler;
+  private _hostAdapter: TsCompilerAotCompilerTypeCheckHostAdapter;
   private _tsProgram: ts.Program;
   private _analyzedModules: NgAnalyzedModules|undefined;
   private _structuralDiagnostics: Diagnostic[]|undefined;
@@ -167,7 +169,7 @@ class AngularCompilerProgram implements Program {
         diags.push(...this.tsProgram.getSemanticDiagnostics(sf, cancellationToken));
       }
     });
-    const {ng} = translateDiagnostics(this.typeCheckHost, diags);
+    const {ng} = translateDiagnostics(this.hostAdapter, diags);
     return ng;
   }
 
@@ -175,18 +177,23 @@ class AngularCompilerProgram implements Program {
     if (this._analyzedModules) {
       throw new Error('Angular structure already loaded');
     }
-    const {tmpProgram, sourceFiles, hostAdapter, rootNames} = this._createProgramWithBasicStubs();
-    return this._compiler.loadFilesAsync(sourceFiles)
+    const {tmpProgram, sourceFiles, rootNames} = this._createProgramWithBasicStubs();
+    return this.compiler.loadFilesAsync(sourceFiles)
         .catch(this.catchAnalysisError.bind(this))
         .then(analyzedModules => {
           if (this._analyzedModules) {
             throw new Error('Angular structure loaded both synchronously and asynchronsly');
           }
-          this._updateProgramWithTypeCheckStubs(
-              tmpProgram, analyzedModules, hostAdapter, rootNames);
+          this._updateProgramWithTypeCheckStubs(tmpProgram, analyzedModules, rootNames);
         });
   }
 
+  listLazyRoutes(route?: string): LazyRoute[] {
+    // Note: Don't analyzedModules if a route is given
+    // to be fast enough.
+    return this.compiler.listLazyRoutes(route, route ? undefined : this.analyzedModules);
+  }
+
   emit(
       {emitFlags = EmitFlags.Default, cancellationToken, customTransformers,
        emitCallback = defaultEmitCallback}: {
@@ -341,11 +348,18 @@ class AngularCompilerProgram implements Program {
   // Private members
   private get compiler(): AotCompiler {
     if (!this._compiler) {
-      this.initSync();
+      this._createCompiler();
     }
     return this._compiler !;
   }
 
+  private get hostAdapter(): TsCompilerAotCompilerTypeCheckHostAdapter {
+    if (!this._hostAdapter) {
+      this._createCompiler();
+    }
+    return this._hostAdapter !;
+  }
+
   private get analyzedModules(): NgAnalyzedModules {
     if (!this._analyzedModules) {
       this.initSync();
@@ -367,19 +381,12 @@ class AngularCompilerProgram implements Program {
     return this._tsProgram !;
   }
 
-  private get typeCheckHost(): TypeCheckHost {
-    if (!this._typeCheckHost) {
-      this.initSync();
-    }
-    return this._typeCheckHost !;
-  }
-
   private calculateTransforms(
       genFiles: Map<string, GeneratedFile>,
       customTransformers?: CustomTransformers): ts.CustomTransformers {
     const beforeTs: ts.TransformerFactory<ts.SourceFile>[] = [];
     if (!this.options.disableExpressionLowering) {
-      beforeTs.push(getExpressionLoweringTransformFactory(this.metadataCache));
+      beforeTs.push(getExpressionLoweringTransformFactory(this.metadataCache, this.tsProgram));
     }
     beforeTs.push(getAngularEmitterTransformFactory(genFiles));
     if (customTransformers && customTransformers.beforeTs) {
@@ -393,19 +400,42 @@ class AngularCompilerProgram implements Program {
     if (this._analyzedModules) {
       return;
     }
-    const {tmpProgram, sourceFiles, hostAdapter, rootNames} = this._createProgramWithBasicStubs();
+    const {tmpProgram, sourceFiles, rootNames} = this._createProgramWithBasicStubs();
     let analyzedModules: NgAnalyzedModules|null;
     try {
-      analyzedModules = this._compiler.loadFilesSync(sourceFiles);
+      analyzedModules = this.compiler.loadFilesSync(sourceFiles);
     } catch (e) {
       analyzedModules = this.catchAnalysisError(e);
     }
-    this._updateProgramWithTypeCheckStubs(tmpProgram, analyzedModules, hostAdapter, rootNames);
+    this._updateProgramWithTypeCheckStubs(tmpProgram, analyzedModules, rootNames);
+  }
+
+  private _createCompiler() {
+    const codegen: CodeGenerator = {
+      generateFile: (genFileName, baseFileName) =>
+                        this._compiler.emitBasicStub(genFileName, baseFileName),
+      findGeneratedFileNames: (fileName) => this._compiler.findGeneratedFileNames(fileName),
+    };
+
+    this._hostAdapter = new TsCompilerAotCompilerTypeCheckHostAdapter(
+        this.rootNames, this.options, this.host, this.metadataCache, codegen,
+        this.oldProgramLibrarySummaries);
+    const aotOptions = getAotCompilerOptions(this.options);
+    this._structuralDiagnostics = [];
+    const errorCollector =
+        (this.options.collectAllErrors || this.options.fullTemplateTypeCheck) ? (err: any) => {
+          this._structuralDiagnostics !.push({
+            messageText: err.toString(),
+            category: ts.DiagnosticCategory.Error,
+            source: SOURCE,
+            code: DEFAULT_ERROR_CODE
+          });
+        } : undefined;
+    this._compiler = createAotCompiler(this._hostAdapter, aotOptions, errorCollector).compiler;
   }
 
   private _createProgramWithBasicStubs(): {
     tmpProgram: ts.Program,
-    hostAdapter: TsCompilerAotCompilerTypeCheckHostAdapter,
     rootNames: string[],
     sourceFiles: string[],
   } {
@@ -418,58 +448,56 @@ class AngularCompilerProgram implements Program {
 
     const codegen: CodeGenerator = {
       generateFile: (genFileName, baseFileName) =>
-                        this._compiler.emitBasicStub(genFileName, baseFileName),
-      findGeneratedFileNames: (fileName) => this._compiler.findGeneratedFileNames(fileName),
+                        this.compiler.emitBasicStub(genFileName, baseFileName),
+      findGeneratedFileNames: (fileName) => this.compiler.findGeneratedFileNames(fileName),
     };
 
-    const hostAdapter = new TsCompilerAotCompilerTypeCheckHostAdapter(
-        this.rootNames, this.options, this.host, this.metadataCache, codegen,
-        this.oldProgramLibrarySummaries);
-    const aotOptions = getAotCompilerOptions(this.options);
-    this._compiler = createAotCompiler(hostAdapter, aotOptions).compiler;
-    this._typeCheckHost = hostAdapter;
-    this._structuralDiagnostics = [];
 
-    let rootNames =
-        this.rootNames.filter(fn => !GENERATED_FILES.test(fn) || !hostAdapter.isSourceFile(fn));
+    let rootNames = this.rootNames;
+    if (this.options.generateCodeForLibraries !== false) {
+      // if we should generateCodeForLibraries, enver include
+      // generated files in the program as otherwise we will
+      // ovewrite them and typescript will report the error
+      // TS5055: Cannot write file ... because it would overwrite input file.
+      rootNames = this.rootNames.filter(fn => !GENERATED_FILES.test(fn));
+    }
     if (this.options.noResolve) {
       this.rootNames.forEach(rootName => {
-        if (hostAdapter.shouldGenerateFilesFor(rootName)) {
-          rootNames.push(...this._compiler.findGeneratedFileNames(rootName));
+        if (this.hostAdapter.shouldGenerateFilesFor(rootName)) {
+          rootNames.push(...this.compiler.findGeneratedFileNames(rootName));
         }
       });
     }
 
-    const tmpProgram = ts.createProgram(rootNames, this.options, hostAdapter, oldTsProgram);
+    const tmpProgram = ts.createProgram(rootNames, this.options, this.hostAdapter, oldTsProgram);
     const sourceFiles: string[] = [];
     tmpProgram.getSourceFiles().forEach(sf => {
-      if (hostAdapter.isSourceFile(sf.fileName)) {
+      if (this.hostAdapter.isSourceFile(sf.fileName)) {
         sourceFiles.push(sf.fileName);
       }
     });
-    return {tmpProgram, sourceFiles, hostAdapter, rootNames};
+    return {tmpProgram, sourceFiles, rootNames};
   }
 
   private _updateProgramWithTypeCheckStubs(
-      tmpProgram: ts.Program, analyzedModules: NgAnalyzedModules|null,
-      hostAdapter: TsCompilerAotCompilerTypeCheckHostAdapter, rootNames: string[]) {
+      tmpProgram: ts.Program, analyzedModules: NgAnalyzedModules|null, rootNames: string[]) {
     this._analyzedModules = analyzedModules || emptyModules;
     if (analyzedModules) {
       tmpProgram.getSourceFiles().forEach(sf => {
         if (sf.fileName.endsWith('.ngfactory.ts')) {
-          const {generate, baseFileName} = hostAdapter.shouldGenerateFile(sf.fileName);
+          const {generate, baseFileName} = this.hostAdapter.shouldGenerateFile(sf.fileName);
           if (generate) {
             // Note: ! is ok as hostAdapter.shouldGenerateFile will always return a basefileName
             // for .ngfactory.ts files.
-            const genFile = this._compiler.emitTypeCheckStub(sf.fileName, baseFileName !);
+            const genFile = this.compiler.emitTypeCheckStub(sf.fileName, baseFileName !);
             if (genFile) {
-              hostAdapter.updateGeneratedFile(genFile);
+              this.hostAdapter.updateGeneratedFile(genFile);
             }
           }
         }
       });
     }
-    this._tsProgram = ts.createProgram(rootNames, this.options, hostAdapter, tmpProgram);
+    this._tsProgram = ts.createProgram(rootNames, this.options, this.hostAdapter, tmpProgram);
     // Note: the new ts program should be completely reusable by TypeScript as:
     // - we cache all the files in the hostAdapter
     // - new new stubs use the exactly same imports/exports as the old once (we assert that in
@@ -483,21 +511,25 @@ class AngularCompilerProgram implements Program {
     if (isSyntaxError(e)) {
       const parserErrors = getParseErrors(e);
       if (parserErrors && parserErrors.length) {
-        this._structuralDiagnostics =
-            parserErrors.map<Diagnostic>(e => ({
-                                           messageText: e.contextualMessage(),
-                                           category: ts.DiagnosticCategory.Error,
-                                           span: e.span,
-                                           source: SOURCE,
-                                           code: DEFAULT_ERROR_CODE
-                                         }));
+        this._structuralDiagnostics = [
+          ...(this._structuralDiagnostics || []),
+          ...parserErrors.map<Diagnostic>(e => ({
+                                            messageText: e.contextualMessage(),
+                                            category: ts.DiagnosticCategory.Error,
+                                            span: e.span,
+                                            source: SOURCE,
+                                            code: DEFAULT_ERROR_CODE
+                                          }))
+        ];
       } else {
-        this._structuralDiagnostics = [{
-          messageText: e.message,
-          category: ts.DiagnosticCategory.Error,
-          source: SOURCE,
-          code: DEFAULT_ERROR_CODE
-        }];
+        this._structuralDiagnostics = [
+          ...(this._structuralDiagnostics || []), {
+            messageText: e.message,
+            category: ts.DiagnosticCategory.Error,
+            source: SOURCE,
+            code: DEFAULT_ERROR_CODE
+          }
+        ];
       }
       return null;
     }
@@ -512,7 +544,10 @@ class AngularCompilerProgram implements Program {
       if (!(emitFlags & EmitFlags.Codegen)) {
         return {genFiles: [], genDiags: []};
       }
-      let genFiles = this.compiler.emitAllImpls(this.analyzedModules);
+      // TODO(tbosch): allow generating files that are not in the rootDir
+      // See https://github.com/angular/angular/issues/19337
+      let genFiles = this.compiler.emitAllImpls(this.analyzedModules)
+                         .filter(genFile => isInRootDir(genFile.genFileUrl, this.options));
       if (this.oldProgramEmittedGeneratedFiles) {
         const oldProgramEmittedGeneratedFiles = this.oldProgramEmittedGeneratedFiles;
         genFiles = genFiles.filter(genFile => {
@@ -672,6 +707,10 @@ function getNgOptionDiagnostics(options: CompilerOptions): Diagnostic[] {
   return [];
 }
 
+function normalizeSeparators(path: string): string {
+  return path.replace(/\\/g, '/');
+}
+
 /**
  * Returns a function that can adjust a path from source path to out path,
  * based on an existing mapping from source to out path.
@@ -693,17 +732,19 @@ export function createSrcToOutPathMapper(
     } = path): (srcFileName: string) => string {
   let srcToOutPath: (srcFileName: string) => string;
   if (outDir) {
+    let path: {} = {};  // Ensure we error if we use `path` instead of `host`.
     if (sampleSrcFileName == null || sampleOutFileName == null) {
       throw new Error(`Can't calculate the rootDir without a sample srcFileName / outFileName. `);
     }
-    const srcFileDir = host.dirname(sampleSrcFileName).replace(/\\/g, '/');
-    const outFileDir = host.dirname(sampleOutFileName).replace(/\\/g, '/');
+    const srcFileDir = normalizeSeparators(host.dirname(sampleSrcFileName));
+    const outFileDir = normalizeSeparators(host.dirname(sampleOutFileName));
     if (srcFileDir === outFileDir) {
       return (srcFileName) => srcFileName;
     }
+    // calculate the common suffix, stopping
+    // at `outDir`.
     const srcDirParts = srcFileDir.split('/');
-    const outDirParts = outFileDir.split('/');
-    // calculate the common suffix
+    const outDirParts = normalizeSeparators(host.relative(outDir, outFileDir)).split('/');
     let i = 0;
     while (i < Math.min(srcDirParts.length, outDirParts.length) &&
            srcDirParts[srcDirParts.length - 1 - i] === outDirParts[outDirParts.length - 1 - i])
@@ -719,7 +760,7 @@ export function createSrcToOutPathMapper(
 export function i18nExtract(
     formatName: string | null, outFile: string | null, host: ts.CompilerHost,
     options: CompilerOptions, bundle: MessageBundle): string[] {
-  formatName = formatName || 'null';
+  formatName = formatName || 'xlf';
   // Checks the format and returns the extension
   const ext = i18nGetExtension(formatName);
   const content = i18nSerialize(bundle, formatName, options);
@@ -753,7 +794,7 @@ export function i18nSerialize(
 }
 
 export function i18nGetExtension(formatName: string): string {
-  const format = (formatName || 'xlf').toLowerCase();
+  const format = formatName.toLowerCase();
 
   switch (format) {
     case 'xmb':

packages/compiler-cli/src/transformers/util.ts

@@ -6,11 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import * as path from 'path';
 import * as ts from 'typescript';
 
-import {DEFAULT_ERROR_CODE, Diagnostic, SOURCE} from './api';
+import {CompilerOptions, DEFAULT_ERROR_CODE, Diagnostic, SOURCE} from './api';
 
 export const GENERATED_FILES = /(.*?)\.(ngfactory|shim\.ngstyle|ngstyle|ngsummary)\.(js|d\.ts|ts)$/;
+export const DTS = /\.d\.ts$/;
 
 export const enum StructureIsReused {Not = 0, SafeModules = 1, Completely = 2}
 
@@ -29,3 +31,23 @@ export function createMessageDiagnostic(messageText: string): ts.Diagnostic&Diag
     source: SOURCE,
   };
 }
+
+export function isInRootDir(fileName: string, options: CompilerOptions) {
+  return !options.rootDir || pathStartsWithPrefix(options.rootDir, fileName);
+}
+
+export function relativeToRootDirs(filePath: string, rootDirs: string[]): string {
+  if (!filePath) return filePath;
+  for (const dir of rootDirs || []) {
+    const rel = pathStartsWithPrefix(dir, filePath);
+    if (rel) {
+      return rel;
+    }
+  }
+  return filePath;
+}
+
+function pathStartsWithPrefix(prefix: string, fullPath: string): string|null {
+  const rel = path.relative(prefix, fullPath);
+  return rel.startsWith('..') ? null : rel;
+}

packages/compiler-cli/test/aot_host_spec.ts

@@ -1,310 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {METADATA_VERSION, ModuleMetadata} from '@angular/compiler-cli';
-import * as ts from 'typescript';
-
-import {CompilerHost} from '../src/compiler_host';
-
-import {Directory, Entry, MockAotContext, MockCompilerHost} from './mocks';
-
-describe('CompilerHost', () => {
-  let context: MockAotContext;
-  let program: ts.Program;
-  let hostNestedGenDir: CompilerHost;
-  let hostSiblingGenDir: CompilerHost;
-
-  beforeEach(() => {
-    context = new MockAotContext('/tmp/src', clone(FILES));
-    const host = new MockCompilerHost(context);
-    program = ts.createProgram(
-        ['main.ts'], {
-          module: ts.ModuleKind.CommonJS,
-        },
-        host);
-    // Force a typecheck
-    const errors = program.getSemanticDiagnostics();
-    if (errors && errors.length) {
-      throw new Error('Expected no errors');
-    }
-    hostNestedGenDir = new CompilerHost(
-        program, {
-          genDir: '/tmp/project/src/gen/',
-          basePath: '/tmp/project/src',
-          skipMetadataEmit: false,
-          strictMetadataEmit: false,
-          skipTemplateCodegen: false,
-          trace: false
-        },
-        context);
-    hostSiblingGenDir = new CompilerHost(
-        program, {
-          genDir: '/tmp/project/gen',
-          basePath: '/tmp/project/src/',
-          skipMetadataEmit: false,
-          strictMetadataEmit: false,
-          skipTemplateCodegen: false,
-          trace: false
-        },
-        context);
-  });
-
-  describe('nestedGenDir', () => {
-    it('should import node_module from factory', () => {
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/node_modules/@angular/core.d.ts',
-                 '/tmp/project/src/gen/my.ngfactory.ts', ))
-          .toEqual('@angular/core');
-    });
-
-    it('should import factory from factory', () => {
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ngfactory.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./my.other.ngfactory');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.css.ngstyle.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.css.ngstyle');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.shim.ngstyle.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other.shim.ngstyle');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.sass.ngstyle.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.sass.ngstyle');
-    });
-
-    it('should import application from factory', () => {
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('../my.other');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../../my.other');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('../a/my.other');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.css.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('../a/my.other.css');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.css.shim.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('../a/my.other.css.shim');
-    });
-  });
-
-  describe('siblingGenDir', () => {
-    it('should import node_module from factory', () => {
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/node_modules/@angular/core.d.ts',
-                 '/tmp/project/src/gen/my.ngfactory.ts'))
-          .toEqual('@angular/core');
-    });
-
-    it('should import factory from factory', () => {
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ngfactory.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./my.other.ngfactory');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.css.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.css');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.css.shim.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other.css.shim');
-    });
-
-    it('should import application from factory', () => {
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./my.other');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other');
-    });
-  });
-
-  it('should be able to produce an import from main @angular/core', () => {
-    expect(hostNestedGenDir.fileNameToModuleName(
-               '/tmp/project/node_modules/@angular/core.d.ts', '/tmp/project/src/main.ts'))
-        .toEqual('@angular/core');
-  });
-
-  it('should be able to produce an import to a shallow import', () => {
-    expect(hostNestedGenDir.fileNameToModuleName('@angular/core', '/tmp/project/src/main.ts'))
-        .toEqual('@angular/core');
-    expect(hostNestedGenDir.fileNameToModuleName(
-               '@angular/upgrade/static', '/tmp/project/src/main.ts'))
-        .toEqual('@angular/upgrade/static');
-    expect(hostNestedGenDir.fileNameToModuleName('myLibrary', '/tmp/project/src/main.ts'))
-        .toEqual('myLibrary');
-    expect(hostNestedGenDir.fileNameToModuleName('lib23-43', '/tmp/project/src/main.ts'))
-        .toEqual('lib23-43');
-  });
-
-  it('should be able to produce an import from main to a sub-directory', () => {
-    expect(hostNestedGenDir.fileNameToModuleName('lib/utils.ts', 'main.ts')).toEqual('./lib/utils');
-  });
-
-  it('should be able to produce an import from to a peer file', () => {
-    expect(hostNestedGenDir.fileNameToModuleName('lib/collections.ts', 'lib/utils.ts'))
-        .toEqual('./collections');
-  });
-
-  it('should be able to produce an import from to a sibling directory', () => {
-    expect(hostNestedGenDir.fileNameToModuleName('lib/utils.ts', 'lib2/utils2.ts'))
-        .toEqual('../lib/utils');
-  });
-
-  it('should be able to read a metadata file', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/core.d.ts')).toEqual([
-      {__symbolic: 'module', version: METADATA_VERSION, metadata: {foo: {__symbolic: 'class'}}}
-    ]);
-  });
-
-  it('should be able to read metadata from an otherwise unused .d.ts file ', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts')).toEqual([
-      dummyMetadata
-    ]);
-  });
-
-  it('should be able to read empty metadata ', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/empty.d.ts')).toEqual([]);
-  });
-
-  it('should return undefined for missing modules', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/missing.d.ts')).toBeUndefined();
-  });
-
-  it(`should add missing v${METADATA_VERSION} metadata from v1 metadata and .d.ts files`, () => {
-    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v1.d.ts')).toEqual([
-      {__symbolic: 'module', version: 1, metadata: {foo: {__symbolic: 'class'}}}, {
-        __symbolic: 'module',
-        version: METADATA_VERSION,
-        metadata: {
-          foo: {__symbolic: 'class'},
-          aType: {__symbolic: 'interface'},
-          Bar: {__symbolic: 'class', members: {ngOnInit: [{__symbolic: 'method'}]}},
-          BarChild: {__symbolic: 'class', extends: {__symbolic: 'reference', name: 'Bar'}},
-          ReExport: {__symbolic: 'reference', module: './lib/utils2', name: 'ReExport'},
-        },
-        exports: [{from: './lib/utils2', export: ['Export']}],
-      }
-    ]);
-  });
-
-  it(`should upgrade a missing metadata file into v${METADATA_VERSION}`, () => {
-    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v1_empty.d.ts')).toEqual([{
-      __symbolic: 'module',
-      version: METADATA_VERSION,
-      metadata: {},
-      exports: [{from: './lib/utils'}]
-    }]);
-  });
-
-  it(`should upgrade v3 metadata into v${METADATA_VERSION}`, () => {
-    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v3.d.ts')).toEqual([
-      {__symbolic: 'module', version: 3, metadata: {foo: {__symbolic: 'class'}}}, {
-        __symbolic: 'module',
-        version: METADATA_VERSION,
-        metadata: {
-          foo: {__symbolic: 'class'},
-          aType: {__symbolic: 'interface'},
-          Bar: {__symbolic: 'class', members: {ngOnInit: [{__symbolic: 'method'}]}},
-          BarChild: {__symbolic: 'class', extends: {__symbolic: 'reference', name: 'Bar'}},
-          ReExport: {__symbolic: 'reference', module: './lib/utils2', name: 'ReExport'},
-        }
-        // Note: exports is missing because it was elided in the original.
-      }
-    ]);
-  });
-});
-
-const dummyModule = 'export let foo: any[];';
-const dummyMetadata: ModuleMetadata = {
-  __symbolic: 'module',
-  version: METADATA_VERSION,
-  metadata:
-      {foo: {__symbolic: 'error', message: 'Variable not initialized', line: 0, character: 11}}
-};
-const FILES: Entry = {
-  'tmp': {
-    'src': {
-      'main.ts': `
-        import * as c from '@angular/core';
-        import * as r from '@angular/router';
-        import * as u from './lib/utils';
-        import * as cs from './lib/collections';
-        import * as u2 from './lib2/utils2';
-      `,
-      'lib': {
-        'utils.ts': dummyModule,
-        'collections.ts': dummyModule,
-      },
-      'lib2': {'utils2.ts': dummyModule},
-      'node_modules': {
-        '@angular': {
-          'core.d.ts': dummyModule,
-          'core.metadata.json':
-              `{"__symbolic":"module", "version": ${METADATA_VERSION}, "metadata": {"foo": {"__symbolic": "class"}}}`,
-          'router': {'index.d.ts': dummyModule, 'src': {'providers.d.ts': dummyModule}},
-          'unused.d.ts': dummyModule,
-          'empty.d.ts': 'export declare var a: string;',
-          'empty.metadata.json': '[]',
-        }
-      },
-      'metadata_versions': {
-        'v1.d.ts': `
-          import {ReExport} from './lib/utils2';
-          export {ReExport};
-
-          export {Export} from './lib/utils2';
-
-          export type aType = number;
-
-          export declare class Bar {
-            ngOnInit() {}
-          }
-          export declare class BarChild extends Bar {}
-        `,
-        'v1.metadata.json':
-            `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
-        'v1_empty.d.ts': `
-          export * from './lib/utils';
-        `,
-        'v3.d.ts': `
-          import {ReExport} from './lib/utils2';
-          export {ReExport};
-
-          export {Export} from './lib/utils2';
-
-          export type aType = number;
-
-          export declare class Bar {
-            ngOnInit() {}
-          }
-          export declare class BarChild extends Bar {}
-        `,
-        'v3.metadata.json':
-            `{"__symbolic":"module", "version": 3, "metadata": {"foo": {"__symbolic": "class"}}}`,
-      }
-    }
-  }
-};
-
-function clone(entry: Entry): Entry {
-  if (typeof entry === 'string') {
-    return entry;
-  } else {
-    const result: Directory = {};
-    for (const name in entry) {
-      result[name] = clone(entry[name]);
-    }
-    return result;
-  }
-}

packages/compiler-cli/test/diagnostics/expression_diagnostics_spec.ts

@@ -8,6 +8,7 @@
 
 import {StaticSymbol} from '@angular/compiler';
 import {CompilerHost} from '@angular/compiler-cli';
+import {ReflectorHost} from '@angular/language-service/src/reflector_host';
 import * as ts from 'typescript';
 
 import {getExpressionDiagnostics, getTemplateExpressionDiagnostics} from '../../src/diagnostics/expression_diagnostics';
@@ -21,7 +22,6 @@ describe('expression diagnostics', () => {
   let host: MockLanguageServiceHost;
   let service: ts.LanguageService;
   let context: DiagnosticContext;
-  let aotHost: CompilerHost;
   let type: StaticSymbol;
 
   beforeAll(() => {
@@ -33,8 +33,8 @@ describe('expression diagnostics', () => {
     const options: CompilerOptions = Object.create(host.getCompilationSettings());
     options.genDir = '/dist';
     options.basePath = '/src';
-    aotHost = new CompilerHost(program, options, host, {verboseInvalidExpression: true});
-    context = new DiagnosticContext(service, program, checker, aotHost);
+    const symbolResolverHost = new ReflectorHost(() => program, host, options);
+    context = new DiagnosticContext(service, program, checker, symbolResolverHost);
     type = context.getStaticSymbol('app/app.component.ts', 'AppComponent');
   });
 

packages/compiler-cli/test/diagnostics/mocks.ts

@@ -6,9 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {AotCompilerHost, AotSummaryResolver, CompileMetadataResolver, CompilerConfig, DEFAULT_INTERPOLATION_CONFIG, DirectiveNormalizer, DirectiveResolver, DomElementSchemaRegistry, HtmlParser, I18NHtmlParser, InterpolationConfig, JitSummaryResolver, Lexer, NgAnalyzedModules, NgModuleResolver, ParseTreeResult, Parser, PipeResolver, ResourceLoader, StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, SummaryResolver, TemplateParser, analyzeNgModules, createOfflineCompileUrlResolver} from '@angular/compiler';
+import {AotCompilerHost, AotSummaryResolver, CompileMetadataResolver, CompilerConfig, DEFAULT_INTERPOLATION_CONFIG, DirectiveNormalizer, DirectiveResolver, DomElementSchemaRegistry, HtmlParser, I18NHtmlParser, InterpolationConfig, JitSummaryResolver, Lexer, NgAnalyzedModules, NgModuleResolver, ParseTreeResult, Parser, PipeResolver, ResourceLoader, StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost, SummaryResolver, TemplateParser, analyzeNgModules, createOfflineCompileUrlResolver} from '@angular/compiler';
 import {ViewEncapsulation, ɵConsole as Console} from '@angular/core';
-import {CompilerHostContext} from 'compiler-cli';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
@@ -25,7 +24,7 @@ function calcRootPath() {
 
 const realFiles = new Map<string, string>();
 
-export class MockLanguageServiceHost implements ts.LanguageServiceHost, CompilerHostContext {
+export class MockLanguageServiceHost implements ts.LanguageServiceHost {
   private options: ts.CompilerOptions;
   private context: MockAotContext;
   private assumedExist = new Set<string>();
@@ -122,7 +121,7 @@ export class DiagnosticContext {
 
   constructor(
       public service: ts.LanguageService, public program: ts.Program,
-      public checker: ts.TypeChecker, public host: AotCompilerHost) {}
+      public checker: ts.TypeChecker, public host: StaticSymbolResolverHost) {}
 
   private collectError(e: any, path?: string) { this._errors.push({e, path}); }
 

packages/compiler-cli/test/diagnostics/symbol_query_spec.ts

@@ -9,6 +9,7 @@
 import {StaticSymbol} from '@angular/compiler';
 import {CompilerHost} from '@angular/compiler-cli';
 import {EmittingCompilerHost, MockAotCompilerHost, MockCompilerHost, MockData, MockDirectory, MockMetadataBundlerHost, arrayToMockDir, arrayToMockMap, isSource, settings, setup, toMockFileArray} from '@angular/compiler/test/aot/test_util';
+import {ReflectorHost} from '@angular/language-service/src/reflector_host';
 import * as ts from 'typescript';
 
 import {Symbol, SymbolQuery, SymbolTable} from '../../src/diagnostics/symbols';
@@ -44,8 +45,8 @@ describe('symbol query', () => {
     const options: CompilerOptions = Object.create(host.getCompilationSettings());
     options.genDir = '/dist';
     options.basePath = '/quickstart';
-    const aotHost = new CompilerHost(program, options, host, {verboseInvalidExpression: true});
-    context = new DiagnosticContext(service, program, checker, aotHost);
+    const symbolResolverHost = new ReflectorHost(() => program, host, options);
+    context = new DiagnosticContext(service, program, checker, symbolResolverHost);
     query = getSymbolQuery(program, checker, sourceFile, emptyPipes);
   });
 

packages/compiler-cli/test/mocks.ts

@@ -6,14 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompilerHostContext} from '@angular/compiler-cli/src/compiler_host';
 import * as ts from 'typescript';
 
 export type Entry = string | Directory;
 
 export interface Directory { [name: string]: Entry; }
 
-export class MockAotContext implements CompilerHostContext {
+export class MockAotContext {
   constructor(public currentDirectory: string, private files: Entry) {}
 
   fileExists(fileName: string): boolean { return typeof this.getEntry(fileName) === 'string'; }

packages/compiler-cli/test/ngc_spec.ts

@@ -502,29 +502,69 @@ describe('ngc transformer command-line', () => {
       it('should add metadata as decorators', () => {
         writeConfig(`{
           "extends": "./tsconfig-base.json",
+          "compilerOptions": {
+            "emitDecoratorMetadata": true
+          },
           "angularCompilerOptions": {
             "annotationsAs": "decorators"
           },
           "files": ["mymodule.ts"]
         }`);
+        write('aclass.ts', `export class AClass {}`);
         write('mymodule.ts', `
-        import {NgModule, Component} from '@angular/core';
+          import {NgModule} from '@angular/core';
+          import {AClass} from './aclass';
 
-        @Component({template: ''})
-        export class MyComp {
-          fn(p: any) {}
-        }
-
-        @NgModule({declarations: [MyComp]})
-        export class MyModule {}
-      `);
+          @NgModule({declarations: []})
+          export class MyModule {
+            constructor(importedClass: AClass) {}
+          }
+        `);
 
         const exitCode = main(['-p', basePath], errorSpy);
         expect(exitCode).toEqual(0);
 
         const mymodulejs = path.resolve(outDir, 'mymodule.js');
         const mymoduleSource = fs.readFileSync(mymodulejs, 'utf8');
-        expect(mymoduleSource).toContain('MyComp = __decorate([');
+        expect(mymoduleSource).toContain('MyModule = __decorate([');
+        expect(mymoduleSource).toContain(`import { AClass } from './aclass';`);
+        expect(mymoduleSource).toContain(`__metadata("design:paramtypes", [AClass])`);
+      });
+
+      it('should add metadata as static fields', () => {
+        // Note: Don't specify emitDecoratorMetadata here on purpose,
+        // as regression test for https://github.com/angular/angular/issues/19916.
+        writeConfig(`{
+          "extends": "./tsconfig-base.json",
+          "compilerOptions": {
+            "emitDecoratorMetadata": false
+          },
+          "angularCompilerOptions": {
+            "annotationsAs": "static fields"
+          },
+          "files": ["mymodule.ts"]
+        }`);
+        write('aclass.ts', `export class AClass {}`);
+        write('mymodule.ts', `
+          import {NgModule} from '@angular/core';
+          import {AClass} from './aclass';
+
+          @NgModule({declarations: []})
+          export class MyModule {
+            constructor(importedClass: AClass) {}
+          }
+        `);
+
+        const exitCode = main(['-p', basePath], errorSpy);
+        expect(exitCode).toEqual(0);
+
+        const mymodulejs = path.resolve(outDir, 'mymodule.js');
+        const mymoduleSource = fs.readFileSync(mymodulejs, 'utf8');
+        expect(mymoduleSource).not.toContain('__decorate');
+        expect(mymoduleSource).toContain('args: [{ declarations: [] },] }');
+        expect(mymoduleSource).not.toContain(`__metadata`);
+        expect(mymoduleSource).toContain(`import { AClass } from './aclass';`);
+        expect(mymoduleSource).toContain(`{ type: AClass, }`);
       });
     });
 
@@ -1391,5 +1431,41 @@ describe('ngc transformer command-line', () => {
           main(['-p', path.join(basePath, 'src/tsconfig.json')], message => messages.push(message));
       expect(exitCode).toBe(0, 'Compile failed unexpectedly.\n  ' + messages.join('\n  '));
     });
+
+    it('should emit all structural errors', () => {
+      write('src/tsconfig.json', `{
+        "extends": "../tsconfig-base.json",
+        "files": ["test-module.ts"]
+      }`);
+      write('src/lib/indirect2.ts', `
+        declare var f: any;
+        export const t2 = f\`<p>hello</p>\`;
+      `);
+      write('src/lib/indirect1.ts', `
+        import {t2} from './indirect2';
+        export const t1 = t2 + ' ';
+      `);
+      write('src/lib/test.component.ts', `
+        import {Component} from '@angular/core';
+        import {t1} from './indirect1';
+
+        @Component({
+          template: t1
+        })
+        export class TestComponent {}
+      `);
+      write('src/test-module.ts', `
+        import {NgModule} from '@angular/core';
+        import {TestComponent} from './lib/test.component';
+
+        @NgModule({declarations: [TestComponent]})
+        export class TestModule {}
+      `);
+      const messages: string[] = [];
+      const exitCode =
+          main(['-p', path.join(basePath, 'src/tsconfig.json')], message => messages.push(message));
+      expect(exitCode).toBe(2, 'Compile was expected to fail');
+      expect(messages[0]).toContain(['Tagged template expressions are not supported in metadata']);
+    });
   });
 });

packages/compiler-cli/test/ngtools_api_spec.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as path from 'path';
+import * as ts from 'typescript';
+
+import {NgTools_InternalApi_NG_2} from '../src/ngtools_api';
+
+import {TestSupport, setup} from './test_support';
+
+describe('ngtools_api (deprecated)', () => {
+  let testSupport: TestSupport;
+
+  beforeEach(() => { testSupport = setup(); });
+
+  function createProgram(rootNames: string[]) {
+    const options = testSupport.createCompilerOptions();
+    const host = ts.createCompilerHost(options, true);
+    const program =
+        ts.createProgram(rootNames.map(p => path.resolve(testSupport.basePath, p)), options, host);
+    return {program, host, options};
+  }
+
+  function writeSomeRoutes() {
+    testSupport.writeFiles({
+      'src/main.ts': `
+        import {NgModule, Component} from '@angular/core';
+        import {RouterModule} from '@angular/router';
+
+        // Component with metadata errors.
+        @Component(() => {if (1==1) return null as any;})
+        export class ErrorComp2 {}
+
+        @NgModule({
+          declarations: [ErrorComp2, NonExistentComp],
+          imports: [RouterModule.forRoot([{loadChildren: './child#ChildModule'}])]
+        })
+        export class MainModule {}
+      `,
+      'src/child.ts': `
+        import {NgModule} from '@angular/core';
+        import {RouterModule} from '@angular/router';
+
+        @NgModule({
+          imports: [RouterModule.forChild([{loadChildren: './child2#ChildModule2'}])]
+        })
+        export class ChildModule {}
+      `,
+      'src/child2.ts': `
+        import {NgModule} from '@angular/core';
+
+        @NgModule()
+        export class ChildModule2 {}
+      `,
+    });
+  }
+
+  it('should list lazy routes recursively', () => {
+    writeSomeRoutes();
+    const {program, host, options} = createProgram(['src/main.ts']);
+    const routes = NgTools_InternalApi_NG_2.listLazyRoutes({
+      program,
+      host,
+      angularCompilerOptions: options,
+      entryModule: 'src/main#MainModule',
+    });
+    expect(routes).toEqual({
+      './child#ChildModule': path.resolve(testSupport.basePath, 'src/child.ts'),
+      './child2#ChildModule2': path.resolve(testSupport.basePath, 'src/child2.ts'),
+    });
+  });
+
+  it('should allow to emit the program after analyzing routes', () => {
+    writeSomeRoutes();
+    const {program, host, options} = createProgram(['src/main.ts']);
+    NgTools_InternalApi_NG_2.listLazyRoutes({
+      program,
+      host,
+      angularCompilerOptions: options,
+      entryModule: 'src/main#MainModule',
+    });
+    program.emit();
+    testSupport.shouldExist('built/src/main.js');
+  });
+});

packages/compiler-cli/test/transformers/lower_expressions_spec.ts

@@ -181,13 +181,15 @@ function convert(annotatedSource: string) {
       [fileName], {module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2017}, host);
   const moduleSourceFile = program.getSourceFile(fileName);
   const transformers: ts.CustomTransformers = {
-    before: [getExpressionLoweringTransformFactory({
-      getRequests(sourceFile: ts.SourceFile): RequestLocationMap{
-        if (sourceFile.fileName == moduleSourceFile.fileName) {
-          return requests;
-        } else {return new Map();}
-      }
-    })]
+    before: [getExpressionLoweringTransformFactory(
+        {
+          getRequests(sourceFile: ts.SourceFile): RequestLocationMap{
+            if (sourceFile.fileName == moduleSourceFile.fileName) {
+              return requests;
+            } else {return new Map();}
+          }
+        },
+        program)]
   };
   let result: string = '';
   const emitResult = program.emit(

packages/compiler-cli/test/transformers/metadata_reader_spec.ts

@@ -0,0 +1,177 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ts from 'typescript';
+
+import {METADATA_VERSION, MetadataCollector, ModuleMetadata} from '../../src/metadata';
+import {MetadataReaderHost, readMetadata} from '../../src/transformers/metadata_reader';
+import {Directory, Entry, MockAotContext} from '../mocks';
+
+describe('metadata reader', () => {
+  let host: MetadataReaderHost;
+
+  beforeEach(() => {
+    const context = new MockAotContext('/tmp/src', clone(FILES));
+    const metadataCollector = new MetadataCollector();
+    host = {
+      fileExists: (fileName) => context.fileExists(fileName),
+      readFile: (fileName) => context.readFile(fileName),
+      getSourceFileMetadata: (fileName) => {
+        const sourceText = context.readFile(fileName);
+        return sourceText != null ?
+            metadataCollector.getMetadata(
+                ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest)) :
+            undefined;
+      },
+    };
+  });
+
+
+  it('should be able to read a metadata file', () => {
+    expect(readMetadata('node_modules/@angular/core.d.ts', host)).toEqual([
+      {__symbolic: 'module', version: METADATA_VERSION, metadata: {foo: {__symbolic: 'class'}}}
+    ]);
+  });
+
+  it('should be able to read metadata from an otherwise unused .d.ts file ', () => {
+    expect(readMetadata('node_modules/@angular/unused.d.ts', host)).toEqual([dummyMetadata]);
+  });
+
+  it('should be able to read empty metadata ',
+     () => { expect(readMetadata('node_modules/@angular/empty.d.ts', host)).toEqual([]); });
+
+  it('should return undefined for missing modules',
+     () => { expect(readMetadata('node_modules/@angular/missing.d.ts', host)).toBeUndefined(); });
+
+  it(`should add missing v${METADATA_VERSION} metadata from v1 metadata and .d.ts files`, () => {
+    expect(readMetadata('metadata_versions/v1.d.ts', host)).toEqual([
+      {__symbolic: 'module', version: 1, metadata: {foo: {__symbolic: 'class'}}}, {
+        __symbolic: 'module',
+        version: METADATA_VERSION,
+        metadata: {
+          foo: {__symbolic: 'class'},
+          aType: {__symbolic: 'interface'},
+          Bar: {__symbolic: 'class', members: {ngOnInit: [{__symbolic: 'method'}]}},
+          BarChild: {__symbolic: 'class', extends: {__symbolic: 'reference', name: 'Bar'}},
+          ReExport: {__symbolic: 'reference', module: './lib/utils2', name: 'ReExport'},
+        },
+        exports: [{from: './lib/utils2', export: ['Export']}],
+      }
+    ]);
+  });
+
+  it(`should upgrade a missing metadata file into v${METADATA_VERSION}`, () => {
+    expect(readMetadata('metadata_versions/v1_empty.d.ts', host)).toEqual([{
+      __symbolic: 'module',
+      version: METADATA_VERSION,
+      metadata: {},
+      exports: [{from: './lib/utils'}]
+    }]);
+  });
+
+  it(`should upgrade v3 metadata into v${METADATA_VERSION}`, () => {
+    expect(readMetadata('metadata_versions/v3.d.ts', host)).toEqual([
+      {__symbolic: 'module', version: 3, metadata: {foo: {__symbolic: 'class'}}}, {
+        __symbolic: 'module',
+        version: METADATA_VERSION,
+        metadata: {
+          foo: {__symbolic: 'class'},
+          aType: {__symbolic: 'interface'},
+          Bar: {__symbolic: 'class', members: {ngOnInit: [{__symbolic: 'method'}]}},
+          BarChild: {__symbolic: 'class', extends: {__symbolic: 'reference', name: 'Bar'}},
+          ReExport: {__symbolic: 'reference', module: './lib/utils2', name: 'ReExport'},
+        }
+        // Note: exports is missing because it was elided in the original.
+      }
+    ]);
+  });
+});
+
+const dummyModule = 'export let foo: any[];';
+const dummyMetadata: ModuleMetadata = {
+  __symbolic: 'module',
+  version: METADATA_VERSION,
+  metadata:
+      {foo: {__symbolic: 'error', message: 'Variable not initialized', line: 0, character: 11}}
+};
+const FILES: Entry = {
+  'tmp': {
+    'src': {
+      'main.ts': `
+        import * as c from '@angular/core';
+        import * as r from '@angular/router';
+        import * as u from './lib/utils';
+        import * as cs from './lib/collections';
+        import * as u2 from './lib2/utils2';
+      `,
+      'lib': {
+        'utils.ts': dummyModule,
+        'collections.ts': dummyModule,
+      },
+      'lib2': {'utils2.ts': dummyModule},
+      'node_modules': {
+        '@angular': {
+          'core.d.ts': dummyModule,
+          'core.metadata.json':
+              `{"__symbolic":"module", "version": ${METADATA_VERSION}, "metadata": {"foo": {"__symbolic": "class"}}}`,
+          'router': {'index.d.ts': dummyModule, 'src': {'providers.d.ts': dummyModule}},
+          'unused.d.ts': dummyModule,
+          'empty.d.ts': 'export declare var a: string;',
+          'empty.metadata.json': '[]',
+        }
+      },
+      'metadata_versions': {
+        'v1.d.ts': `
+          import {ReExport} from './lib/utils2';
+          export {ReExport};
+
+          export {Export} from './lib/utils2';
+
+          export type aType = number;
+
+          export declare class Bar {
+            ngOnInit() {}
+          }
+          export declare class BarChild extends Bar {}
+        `,
+        'v1.metadata.json':
+            `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
+        'v1_empty.d.ts': `
+          export * from './lib/utils';
+        `,
+        'v3.d.ts': `
+          import {ReExport} from './lib/utils2';
+          export {ReExport};
+
+          export {Export} from './lib/utils2';
+
+          export type aType = number;
+
+          export declare class Bar {
+            ngOnInit() {}
+          }
+          export declare class BarChild extends Bar {}
+        `,
+        'v3.metadata.json':
+            `{"__symbolic":"module", "version": 3, "metadata": {"foo": {"__symbolic": "class"}}}`,
+      }
+    }
+  }
+};
+
+function clone(entry: Entry): Entry {
+  if (typeof entry === 'string') {
+    return entry;
+  } else {
+    const result: Directory = {};
+    for (const name in entry) {
+      result[name] = clone(entry[name]);
+    }
+    return result;
+  }
+}

packages/compiler-cli/test/transformers/program_spec.ts

@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-import {CompilerHost} from '../../src/transformers/api';
+import {CompilerHost, EmitFlags, LazyRoute} from '../../src/transformers/api';
 import {createSrcToOutPathMapper} from '../../src/transformers/program';
 import {GENERATED_FILES, StructureIsReused, tsStructureIsReused} from '../../src/transformers/util';
 import {TestSupport, expectNoDiagnosticsInProgram, setup} from '../test_support';
@@ -309,11 +309,35 @@ describe('ng program', () => {
     });
   });
 
-  it('should typecheck templates even if skipTemplateCodegen is set', () => {
+  it('should not typecheck templates if skipTemplateCodegen is set but fullTemplateTypeCheck is not',
+     () => {
+       testSupport.writeFiles({
+         'src/main.ts': `
+        import {NgModule} from '@angular/core';
+
+        @NgModule(() => {if (1==1) return null as any;})
+        export class SomeClassWithInvalidMetadata {}
+      `,
+       });
+       const options = testSupport.createCompilerOptions({skipTemplateCodegen: true});
+       const host = ng.createCompilerHost({options});
+       const program = ng.createProgram(
+           {rootNames: [path.resolve(testSupport.basePath, 'src/main.ts')], options, host});
+       expectNoDiagnosticsInProgram(options, program);
+       const emitResult = program.emit({emitFlags: EmitFlags.All});
+       expect(emitResult.diagnostics.length).toBe(0);
+
+       testSupport.shouldExist('built/src/main.metadata.json');
+     });
+
+  it('should typecheck templates if skipTemplateCodegen and fullTemplateTypeCheck is set', () => {
     testSupport.writeFiles({
       'src/main.ts': createModuleAndCompSource('main', `{{nonExistent}}`),
     });
-    const options = testSupport.createCompilerOptions({skipTemplateCodegen: true});
+    const options = testSupport.createCompilerOptions({
+      skipTemplateCodegen: true,
+      fullTemplateTypeCheck: true,
+    });
     const host = ng.createCompilerHost({options});
     const program = ng.createProgram(
         {rootNames: [path.resolve(testSupport.basePath, 'src/main.ts')], options, host});
@@ -454,25 +478,33 @@ describe('ng program', () => {
   });
 
   it('should not emit generated files whose sources are outside of the rootDir', () => {
-    compileLib('lib');
     testSupport.writeFiles({
       'src/main.ts': createModuleAndCompSource('main'),
       'src/index.ts': `
           export * from './main';
-          export * from 'lib/index';
         `
     });
-    compile(undefined, {rootDir: path.resolve(testSupport.basePath, 'src')});
+    const options =
+        testSupport.createCompilerOptions({rootDir: path.resolve(testSupport.basePath, 'src')});
+    const host = ng.createCompilerHost({options});
+    const writtenFileNames: string[] = [];
+    const oldWriteFile = host.writeFile;
+    host.writeFile = (fileName, data, writeByteOrderMark) => {
+      writtenFileNames.push(fileName);
+      oldWriteFile(fileName, data, writeByteOrderMark);
+    };
+
+    compile(/*oldProgram*/ undefined, options, /*rootNames*/ undefined, host);
+
+    // no emit for files from node_modules as they are outside of rootDir
+    expect(writtenFileNames.some(f => /node_modules/.test(f))).toBe(false);
+
+    // emit all gen files for files under src/
     testSupport.shouldExist('built/main.js');
     testSupport.shouldExist('built/main.d.ts');
     testSupport.shouldExist('built/main.ngfactory.js');
     testSupport.shouldExist('built/main.ngfactory.d.ts');
     testSupport.shouldExist('built/main.ngsummary.json');
-    testSupport.shouldNotExist('built/node_modules/lib/index.js');
-    testSupport.shouldNotExist('built/node_modules/lib/index.d.ts');
-    testSupport.shouldNotExist('built/node_modules/lib/index.ngfactory.js');
-    testSupport.shouldNotExist('built/node_modules/lib/index.ngfactory.d.ts');
-    testSupport.shouldNotExist('built/node_modules/lib/index.ngsummary.json');
   });
 
   describe('createSrcToOutPathMapper', () => {
@@ -492,10 +524,17 @@ describe('ng program', () => {
     });
 
     it('should adjust the filename if the outDir is outside of the rootDir', () => {
-      const mapper = createSrcToOutPathMapper('/out', '/tmp/a/x.ts', '/a/x.js');
+      const mapper = createSrcToOutPathMapper('/out', '/tmp/a/x.ts', '/out/a/x.js');
       expect(mapper('/tmp/b/y.js')).toBe('/out/b/y.js');
     });
 
+    it('should adjust the filename if the common prefix of sampleSrc and sampleOut is outside of outDir',
+       () => {
+         const mapper =
+             createSrcToOutPathMapper('/dist/common', '/src/common/x.ts', '/dist/common/x.js');
+         expect(mapper('/src/common/y.js')).toBe('/dist/common/y.js');
+       });
+
     it('should work on windows with normalized paths', () => {
       const mapper =
           createSrcToOutPathMapper('c:/tmp/out', 'c:/tmp/a/x.ts', 'c:/tmp/out/a/x.js', path.win32);
@@ -508,4 +547,287 @@ describe('ng program', () => {
       expect(mapper('c:\\tmp\\b\\y.js')).toBe('c:\\tmp\\out\\b\\y.js');
     });
   });
+
+  describe('listLazyRoutes', () => {
+    function writeSomeRoutes() {
+      testSupport.writeFiles({
+        'src/main.ts': `
+          import {NgModule} from '@angular/core';
+          import {RouterModule} from '@angular/router';
+
+          @NgModule({
+            imports: [RouterModule.forRoot([{loadChildren: './child#ChildModule'}])]
+          })
+          export class MainModule {}
+        `,
+        'src/child.ts': `
+          import {NgModule} from '@angular/core';
+          import {RouterModule} from '@angular/router';
+
+          @NgModule({
+            imports: [RouterModule.forChild([{loadChildren: './child2#ChildModule2'}])]
+          })
+          export class ChildModule {}
+        `,
+        'src/child2.ts': `
+          import {NgModule} from '@angular/core';
+
+          @NgModule()
+          export class ChildModule2 {}
+        `,
+      });
+    }
+
+    function createProgram(rootNames: string[], overrideOptions: ng.CompilerOptions = {}) {
+      const options = testSupport.createCompilerOptions(overrideOptions);
+      const host = ng.createCompilerHost({options});
+      const program = ng.createProgram(
+          {rootNames: rootNames.map(p => path.resolve(testSupport.basePath, p)), options, host});
+      return {program, options};
+    }
+
+    function normalizeRoutes(lazyRoutes: LazyRoute[]) {
+      return lazyRoutes.map(
+          r => ({
+            route: r.route,
+            module: {name: r.module.name, filePath: r.module.filePath},
+            referencedModule:
+                {name: r.referencedModule.name, filePath: r.referencedModule.filePath},
+          }));
+    }
+
+    it('should list all lazyRoutes', () => {
+      writeSomeRoutes();
+      const {program, options} = createProgram(['src/main.ts', 'src/child.ts', 'src/child2.ts']);
+      expectNoDiagnosticsInProgram(options, program);
+      expect(normalizeRoutes(program.listLazyRoutes())).toEqual([
+        {
+          module: {name: 'MainModule', filePath: path.resolve(testSupport.basePath, 'src/main.ts')},
+          referencedModule:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          route: './child#ChildModule'
+        },
+        {
+          module:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          referencedModule:
+              {name: 'ChildModule2', filePath: path.resolve(testSupport.basePath, 'src/child2.ts')},
+          route: './child2#ChildModule2'
+        },
+      ]);
+    });
+
+    it('should list lazyRoutes given an entryRoute recursively', () => {
+      writeSomeRoutes();
+      const {program, options} = createProgram(['src/main.ts']);
+      expectNoDiagnosticsInProgram(options, program);
+      expect(normalizeRoutes(program.listLazyRoutes('src/main#MainModule'))).toEqual([
+        {
+          module: {name: 'MainModule', filePath: path.resolve(testSupport.basePath, 'src/main.ts')},
+          referencedModule:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          route: './child#ChildModule'
+        },
+        {
+          module:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          referencedModule:
+              {name: 'ChildModule2', filePath: path.resolve(testSupport.basePath, 'src/child2.ts')},
+          route: './child2#ChildModule2'
+        },
+      ]);
+
+      expect(normalizeRoutes(program.listLazyRoutes('src/child#ChildModule'))).toEqual([
+        {
+          module:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          referencedModule:
+              {name: 'ChildModule2', filePath: path.resolve(testSupport.basePath, 'src/child2.ts')},
+          route: './child2#ChildModule2'
+        },
+      ]);
+    });
+
+    it('should list lazyRoutes pointing to a default export', () => {
+      testSupport.writeFiles({
+        'src/main.ts': `
+          import {NgModule} from '@angular/core';
+          import {RouterModule} from '@angular/router';
+
+          @NgModule({
+            imports: [RouterModule.forRoot([{loadChildren: './child'}])]
+          })
+          export class MainModule {}
+        `,
+        'src/child.ts': `
+          import {NgModule} from '@angular/core';
+
+          @NgModule()
+          export default class ChildModule {}
+        `,
+      });
+      const {program, options} = createProgram(['src/main.ts']);
+      expect(normalizeRoutes(program.listLazyRoutes('src/main#MainModule'))).toEqual([
+        {
+          module: {name: 'MainModule', filePath: path.resolve(testSupport.basePath, 'src/main.ts')},
+          referencedModule:
+              {name: undefined, filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          route: './child'
+        },
+      ]);
+    });
+
+    it('should list lazyRoutes from imported modules', () => {
+      testSupport.writeFiles({
+        'src/main.ts': `
+          import {NgModule} from '@angular/core';
+          import {RouterModule} from '@angular/router';
+          import {NestedMainModule} from './nested/main';
+
+          @NgModule({
+            imports: [
+              RouterModule.forRoot([{loadChildren: './child#ChildModule'}]),
+              NestedMainModule,
+            ]
+          })
+          export class MainModule {}
+        `,
+        'src/child.ts': `
+          import {NgModule} from '@angular/core';
+
+          @NgModule()
+          export class ChildModule {}
+        `,
+        'src/nested/main.ts': `
+          import {NgModule} from '@angular/core';
+          import {RouterModule} from '@angular/router';
+
+          @NgModule({
+            imports: [RouterModule.forChild([{loadChildren: './child#NestedChildModule'}])]
+          })
+          export class NestedMainModule {}
+        `,
+        'src/nested/child.ts': `
+          import {NgModule} from '@angular/core';
+
+          @NgModule()
+          export class NestedChildModule {}
+        `,
+      });
+      const {program, options} = createProgram(['src/main.ts']);
+      expect(normalizeRoutes(program.listLazyRoutes('src/main#MainModule'))).toEqual([
+        {
+          module: {
+            name: 'NestedMainModule',
+            filePath: path.resolve(testSupport.basePath, 'src/nested/main.ts')
+          },
+          referencedModule: {
+            name: 'NestedChildModule',
+            filePath: path.resolve(testSupport.basePath, 'src/nested/child.ts')
+          },
+          route: './child#NestedChildModule'
+        },
+        {
+          module: {name: 'MainModule', filePath: path.resolve(testSupport.basePath, 'src/main.ts')},
+          referencedModule:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          route: './child#ChildModule'
+        },
+      ]);
+    });
+
+    it('should dedupe lazyRoutes given an entryRoute', () => {
+      writeSomeRoutes();
+      testSupport.writeFiles({
+        'src/index.ts': `
+          import {NgModule} from '@angular/core';
+          import {RouterModule} from '@angular/router';
+
+          @NgModule({
+            imports: [
+              RouterModule.forRoot([{loadChildren: './main#MainModule'}]),
+              RouterModule.forRoot([{loadChildren: './child#ChildModule'}]),
+            ]
+          })
+          export class MainModule {}
+        `,
+      });
+      const {program, options} = createProgram(['src/index.ts']);
+      expectNoDiagnosticsInProgram(options, program);
+      expect(normalizeRoutes(program.listLazyRoutes('src/main#MainModule'))).toEqual([
+        {
+          module: {name: 'MainModule', filePath: path.resolve(testSupport.basePath, 'src/main.ts')},
+          referencedModule:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          route: './child#ChildModule'
+        },
+        {
+          module:
+              {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+          referencedModule:
+              {name: 'ChildModule2', filePath: path.resolve(testSupport.basePath, 'src/child2.ts')},
+          route: './child2#ChildModule2'
+        },
+      ]);
+    });
+
+    it('should list lazyRoutes given an entryRoute even with static errors', () => {
+      testSupport.writeFiles({
+        'src/main.ts': `
+          import {NgModule, Component} from '@angular/core';
+          import {RouterModule} from '@angular/router';
+
+          @Component({
+            selector: 'url-comp',
+            // Non existent external template
+            templateUrl: 'non-existent.html',
+          })
+          export class ErrorComp {}
+
+          @Component({
+            selector: 'err-comp',
+            // Error in template
+            template: '<input/>{{',
+          })
+          export class ErrorComp2 {}
+
+          // Component with metadata errors.
+          @Component(() => {if (1==1) return null as any;})
+          export class ErrorComp3 {}
+
+          // Unused component
+          @Component({
+            selector: 'unused-comp',
+            template: ''
+          })
+          export class UnusedComp {}
+
+          @NgModule({
+            declarations: [ErrorComp, ErrorComp2, ErrorComp3, NonExistentComp],
+            imports: [RouterModule.forRoot([{loadChildren: './child#ChildModule'}])]
+          })
+          export class MainModule {}
+
+          @NgModule({
+            // Component used in 2 NgModules
+            declarations: [ErrorComp],
+          })
+          export class Mod2 {}
+        `,
+        'src/child.ts': `
+          import {NgModule} from '@angular/core';
+
+          @NgModule()
+          export class ChildModule {}
+        `,
+      });
+      const program = createProgram(['src/main.ts'], {collectAllErrors: true}).program;
+      expect(normalizeRoutes(program.listLazyRoutes('src/main#MainModule'))).toEqual([{
+        module: {name: 'MainModule', filePath: path.resolve(testSupport.basePath, 'src/main.ts')},
+        referencedModule:
+            {name: 'ChildModule', filePath: path.resolve(testSupport.basePath, 'src/child.ts')},
+        route: './child#ChildModule'
+      }]);
+    });
+  });
 });

packages/compiler/src/aot/compiler.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileNgModuleSummary, CompilePipeMetadata, CompilePipeSummary, CompileProviderMetadata, CompileStylesheetMetadata, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, componentFactoryName, flatten, identifierName, templateSourceUrl} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileNgModuleSummary, CompilePipeMetadata, CompilePipeSummary, CompileProviderMetadata, CompileStylesheetMetadata, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, componentFactoryName, flatten, identifierName, templateSourceUrl, tokenReference} from '../compile_metadata';
 import {CompilerConfig} from '../config';
 import {ViewEncapsulation} from '../core';
 import {MessageBundle} from '../i18n/message_bundle';
@@ -29,6 +29,7 @@ import {ViewCompileResult, ViewCompiler} from '../view_compiler/view_compiler';
 import {AotCompilerHost} from './compiler_host';
 import {AotCompilerOptions} from './compiler_options';
 import {GeneratedFile} from './generated_file';
+import {LazyRoute, listLazyRoutes, parseLazyRoute} from './lazy_routes';
 import {StaticReflector} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
 import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
@@ -500,13 +501,13 @@ export class AotCompiler {
       }
       const arity = this._symbolResolver.getTypeArity(symbol) || 0;
       const {filePath, name, members} = this._symbolResolver.getImportAs(symbol) || symbol;
-      const importModule = this._symbolResolver.fileNameToModuleName(filePath, genFilePath);
+      const importModule = this._fileNameToModuleName(filePath, genFilePath);
 
       // It should be good enough to compare filePath to genFilePath and if they are equal
       // there is a self reference. However, ngfactory files generate to .ts but their
       // symbols have .d.ts so a simple compare is insufficient. They should be canonical
       // and is tracked by #17705.
-      const selfReference = this._symbolResolver.fileNameToModuleName(genFilePath, genFilePath);
+      const selfReference = this._fileNameToModuleName(genFilePath, genFilePath);
       const moduleName = importModule === selfReference ? null : importModule;
 
       // If we are in a type expression that refers to a generic type then supply
@@ -527,6 +528,12 @@ export class AotCompiler {
     return {statements: [], genFilePath, importExpr};
   }
 
+  private _fileNameToModuleName(importedFilePath: string, containingFilePath: string): string {
+    return this._summaryResolver.getKnownModuleName(importedFilePath) ||
+        this._symbolResolver.getKnownModuleName(importedFilePath) ||
+        this._host.fileNameToModuleName(importedFilePath, containingFilePath);
+  }
+
   private _codegenStyles(
       srcFileUrl: string, compMeta: CompileDirectiveMetadata,
       stylesheetMetadata: CompileStylesheetMetadata, isShimmed: boolean,
@@ -542,6 +549,43 @@ export class AotCompiler {
   private _codegenSourceModule(srcFileUrl: string, ctx: OutputContext): GeneratedFile {
     return new GeneratedFile(srcFileUrl, ctx.genFilePath, ctx.statements);
   }
+
+  listLazyRoutes(entryRoute?: string, analyzedModules?: NgAnalyzedModules): LazyRoute[] {
+    const self = this;
+    if (entryRoute) {
+      const symbol = parseLazyRoute(entryRoute, this._reflector).referencedModule;
+      return visitLazyRoute(symbol);
+    } else if (analyzedModules) {
+      const allLazyRoutes: LazyRoute[] = [];
+      for (const ngModule of analyzedModules.ngModules) {
+        const lazyRoutes = listLazyRoutes(ngModule, this._reflector);
+        for (const lazyRoute of lazyRoutes) {
+          allLazyRoutes.push(lazyRoute);
+        }
+      }
+      return allLazyRoutes;
+    } else {
+      throw new Error(`Either route or analyzedModules has to be specified!`);
+    }
+
+    function visitLazyRoute(
+        symbol: StaticSymbol, seenRoutes = new Set<StaticSymbol>(),
+        allLazyRoutes: LazyRoute[] = []): LazyRoute[] {
+      // Support pointing to default exports, but stop recursing there,
+      // as the StaticReflector does not yet support default exports.
+      if (seenRoutes.has(symbol) || !symbol.name) {
+        return allLazyRoutes;
+      }
+      seenRoutes.add(symbol);
+      const lazyRoutes = listLazyRoutes(
+          self._metadataResolver.getNgModuleMetadata(symbol, true) !, self._reflector);
+      for (const lazyRoute of lazyRoutes) {
+        allLazyRoutes.push(lazyRoute);
+        visitLazyRoute(lazyRoute.referencedModule, seenRoutes, allLazyRoutes);
+      }
+      return allLazyRoutes;
+    }
+  }
 }
 
 function _createEmptyStub(outputCtx: OutputContext) {

packages/compiler/src/aot/compiler_factory.ts

@@ -52,15 +52,18 @@ export function createAotUrlResolver(host: {
 /**
  * Creates a new AotCompiler based on options and a host.
  */
-export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCompilerOptions):
-    {compiler: AotCompiler, reflector: StaticReflector} {
+export function createAotCompiler(
+    compilerHost: AotCompilerHost, options: AotCompilerOptions,
+    errorCollector?: (error: any, type?: any) =>
+        void): {compiler: AotCompiler, reflector: StaticReflector} {
   let translations: string = options.translations || '';
 
   const urlResolver = createAotUrlResolver(compilerHost);
   const symbolCache = new StaticSymbolCache();
   const summaryResolver = new AotSummaryResolver(compilerHost, symbolCache);
   const symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver);
-  const staticReflector = new StaticReflector(summaryResolver, symbolResolver);
+  const staticReflector =
+      new StaticReflector(summaryResolver, symbolResolver, [], [], errorCollector);
   const htmlParser = new I18NHtmlParser(
       new HtmlParser(), translations, options.i18nFormat, options.missingTranslation, console);
   const config = new CompilerConfig({
@@ -80,7 +83,7 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
   const resolver = new CompileMetadataResolver(
       config, htmlParser, new NgModuleResolver(staticReflector),
       new DirectiveResolver(staticReflector), new PipeResolver(staticReflector), summaryResolver,
-      elementSchemaRegistry, normalizer, console, symbolCache, staticReflector);
+      elementSchemaRegistry, normalizer, console, symbolCache, staticReflector, errorCollector);
   // TODO(vicb): do not pass options.i18nFormat here
   const viewCompiler = new ViewCompiler(staticReflector);
   const typeCheckCompiler = new TypeCheckCompiler(options, staticReflector);

packages/compiler/src/aot/compiler_host.ts

@@ -14,6 +14,13 @@ import {AotSummaryResolverHost} from './summary_resolver';
  * services and from underlying file systems.
  */
 export interface AotCompilerHost extends StaticSymbolResolverHost, AotSummaryResolverHost {
+  /**
+   * Converts a file path to a module name that can be used as an `import.
+   * I.e. `path/to/importedFile.ts` should be imported by `path/to/containingFile.ts`.
+   *
+   * See ImportResolver.
+   */
+  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;
   /**
    * Converts a path that refers to a resource into an absolute filePath
    * that can be later on used for loading the resource via `loadResource.

packages/compiler/src/aot/lazy_routes.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileNgModuleMetadata, tokenReference} from '../compile_metadata';
+import {Route} from '../core';
+import {CompileMetadataResolver} from '../metadata_resolver';
+
+import {AotCompilerHost} from './compiler_host';
+import {StaticReflector} from './static_reflector';
+import {StaticSymbol} from './static_symbol';
+
+export interface LazyRoute {
+  module: StaticSymbol;
+  route: string;
+  referencedModule: StaticSymbol;
+}
+
+export function listLazyRoutes(
+    moduleMeta: CompileNgModuleMetadata, reflector: StaticReflector): LazyRoute[] {
+  const allLazyRoutes: LazyRoute[] = [];
+  for (const {provider, module} of moduleMeta.transitiveModule.providers) {
+    if (tokenReference(provider.token) === reflector.ROUTES) {
+      const loadChildren = _collectLoadChildren(provider.useValue);
+      for (const route of loadChildren) {
+        allLazyRoutes.push(parseLazyRoute(route, reflector, module.reference));
+      }
+    }
+  }
+  return allLazyRoutes;
+}
+
+function _collectLoadChildren(routes: string | Route | Route[], target: string[] = []): string[] {
+  if (typeof routes === 'string') {
+    target.push(routes);
+  } else if (Array.isArray(routes)) {
+    for (const route of routes) {
+      _collectLoadChildren(route, target);
+    }
+  } else if (routes.loadChildren) {
+    _collectLoadChildren(routes.loadChildren, target);
+  } else if (routes.children) {
+    _collectLoadChildren(routes.children, target);
+  }
+  return target;
+}
+
+export function parseLazyRoute(
+    route: string, reflector: StaticReflector, module?: StaticSymbol): LazyRoute {
+  const [routePath, routeName] = route.split('#');
+  const referencedModule = reflector.resolveExternalReference(
+      {
+        moduleName: routePath,
+        name: routeName,
+      },
+      module ? module.filePath : undefined);
+  return {route: route, module: module || referencedModule, referencedModule};
+}

packages/compiler/src/aot/static_reflector.ts

@@ -45,7 +45,7 @@ export class StaticReflector implements CompileReflector {
   private conversionMap = new Map<StaticSymbol, (context: StaticSymbol, args: any[]) => any>();
   private injectionToken: StaticSymbol;
   private opaqueToken: StaticSymbol;
-  private ROUTES: StaticSymbol;
+  ROUTES: StaticSymbol;
   private ANALYZE_FOR_ENTRY_COMPONENTS: StaticSymbol;
   private annotationForParentClassWithSummaryKind =
       new Map<CompileSummaryKind, MetadataFactory<any>[]>();
@@ -76,8 +76,9 @@ export class StaticReflector implements CompileReflector {
     return this.symbolResolver.getResourcePath(staticSymbol);
   }
 
-  resolveExternalReference(ref: o.ExternalReference): StaticSymbol {
-    const refSymbol = this.symbolResolver.getSymbolByModule(ref.moduleName !, ref.name !);
+  resolveExternalReference(ref: o.ExternalReference, containingFile?: string): StaticSymbol {
+    const refSymbol =
+        this.symbolResolver.getSymbolByModule(ref.moduleName !, ref.name !, containingFile);
     const declarationSymbol = this.findSymbolDeclaration(refSymbol);
     this.symbolResolver.recordModuleNameForFileName(refSymbol.filePath, ref.moduleName !);
     this.symbolResolver.recordImportAs(declarationSymbol, refSymbol);

packages/compiler/src/aot/static_symbol_resolver.ts

@@ -39,13 +39,6 @@ export interface StaticSymbolResolverHost {
    * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.
    */
   moduleNameToFileName(moduleName: string, containingFile?: string): string|null;
-  /**
-   * Converts a file path to a module name that can be used as an `import.
-   * I.e. `path/to/importedFile.ts` should be imported by `path/to/containingFile.ts`.
-   *
-   * See ImportResolver.
-   */
-  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;
 }
 
 const SUPPORTED_SCHEMA_VERSION = 4;
@@ -160,15 +153,6 @@ export class StaticSymbolResolver {
     return (resolvedSymbol && resolvedSymbol.metadata && resolvedSymbol.metadata.arity) || null;
   }
 
-  /**
-   * Converts a file path to a module name that can be used as an `import`.
-   */
-  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string {
-    return this.summaryResolver.getKnownModuleName(importedFilePath) ||
-        this.knownFileNameToModuleNames.get(importedFilePath) ||
-        this.host.fileNameToModuleName(importedFilePath, containingFilePath);
-  }
-
   getKnownModuleName(filePath: string): string|null {
     return this.knownFileNameToModuleNames.get(filePath) || null;
   }
@@ -498,9 +482,8 @@ export class StaticSymbolResolver {
     const filePath = this.resolveModule(module, containingFile);
     if (!filePath) {
       this.reportError(
-          new Error(`Could not resolve module ${module}${containingFile ? ` relative to $ {
-            containingFile
-          } `: ''}`));
+          new Error(`Could not resolve module ${module}${containingFile ? ' relative to ' +
+            containingFile : ''}`));
       return this.getStaticSymbol(`ERROR:${module}`, symbolName);
     }
     return this.getStaticSymbol(filePath, symbolName);

packages/compiler/src/compiler.ts

@@ -39,6 +39,7 @@ export * from './aot/static_reflector';
 export * from './aot/static_symbol';
 export * from './aot/static_symbol_resolver';
 export * from './aot/summary_resolver';
+export {LazyRoute} from './aot/lazy_routes';
 export * from './ast_path';
 export * from './summary_resolver';
 export {Identifiers} from './identifiers';

packages/compiler/src/core.ts

@@ -260,3 +260,8 @@ function makeMetadataFactory<T>(name: string, props?: (...args: any[]) => T): Me
   factory.ngMetadataName = name;
   return factory;
 }
+
+export interface Route {
+  children?: Route[];
+  loadChildren?: string|Type|any;
+}

packages/compiler/test/aot/static_symbol_resolver_spec.ts

@@ -465,10 +465,6 @@ export class MockStaticSymbolResolverHost implements StaticSymbolResolverHost {
     return '/tmp/' + modulePath + '.d.ts';
   }
 
-  fileNameToModuleName(filePath: string, containingFile: string) {
-    return filePath.replace(/(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/, '');
-  }
-
   getMetadataFor(moduleId: string): any { return this._getMetadataFor(moduleId); }
 
   private _getMetadataFor(filePath: string): any {

packages/compiler/test/aot/test_util.ts

@@ -652,7 +652,7 @@ export function compile(
   const tsSettings = {...settings, ...tsOptions};
   const program = ts.createProgram(host.scriptNames.slice(0), tsSettings, host);
   preCompile(program);
-  const {compiler, reflector} = createAotCompiler(aotHost, options);
+  const {compiler, reflector} = createAotCompiler(aotHost, options, (err) => { throw err; });
   const analyzedModules =
       compiler.analyzeModulesSync(program.getSourceFiles().map(sf => sf.fileName));
   const genFiles = compiler.emitAllImpls(analyzedModules);

packages/language-service/src/reflector_host.ts

@@ -6,12 +6,17 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {AotCompilerHost} from '@angular/compiler';
-import {CompilerHost, CompilerOptions, ModuleResolutionHostAdapter} from '@angular/compiler-cli/src/language_services';
+import {StaticSymbolResolverHost} from '@angular/compiler';
+import {CompilerOptions, MetadataCollector, MetadataReaderCache, MetadataReaderHost, createMetadataReaderCache, readMetadata} from '@angular/compiler-cli/src/language_services';
+import * as path from 'path';
 import * as ts from 'typescript';
 
-class ReflectorModuleModuleResolutionHost implements ts.ModuleResolutionHost {
-  constructor(private host: ts.LanguageServiceHost) {
+class ReflectorModuleModuleResolutionHost implements ts.ModuleResolutionHost, MetadataReaderHost {
+  // Note: verboseInvalidExpressions is important so that
+  // the collector will collect errors instead of throwing
+  private metadataCollector = new MetadataCollector({verboseInvalidExpression: true});
+
+  constructor(private host: ts.LanguageServiceHost, private getProgram: () => ts.Program) {
     if (host.directoryExists)
       this.directoryExists = directoryName => this.host.directoryExists !(directoryName);
   }
@@ -29,24 +34,46 @@ class ReflectorModuleModuleResolutionHost implements ts.ModuleResolutionHost {
   }
 
   directoryExists: (directoryName: string) => boolean;
+
+  getSourceFileMetadata(fileName: string) {
+    const sf = this.getProgram().getSourceFile(fileName);
+    return sf ? this.metadataCollector.getMetadata(sf) : undefined;
+  }
+
+  cacheMetadata(fileName: string) {
+    // Don't cache the metadata for .ts files as they might change in the editor!
+    return fileName.endsWith('.d.ts');
+  }
 }
 
-// This reflector host's purpose is to first set verboseInvalidExpressions to true so the
-// reflector will collect errors instead of throwing, and second to all deferring the creation
-// of the program until it is actually needed.
-export class ReflectorHost extends CompilerHost {
+export class ReflectorHost implements StaticSymbolResolverHost {
+  private moduleResolutionCache: ts.ModuleResolutionCache;
+  private hostAdapter: ReflectorModuleModuleResolutionHost;
+  private metadataReaderCache = createMetadataReaderCache();
+
   constructor(
-      private getProgram: () => ts.Program, serviceHost: ts.LanguageServiceHost,
-      options: CompilerOptions) {
-    super(
-        // The ancestor value for program is overridden below so passing null here is safe.
-        /* program */ null !, options,
-        new ModuleResolutionHostAdapter(new ReflectorModuleModuleResolutionHost(serviceHost)),
-        {verboseInvalidExpression: true});
+      getProgram: () => ts.Program, serviceHost: ts.LanguageServiceHost,
+      private options: CompilerOptions) {
+    this.hostAdapter = new ReflectorModuleModuleResolutionHost(serviceHost, getProgram);
+    this.moduleResolutionCache =
+        ts.createModuleResolutionCache(serviceHost.getCurrentDirectory(), (s) => s);
   }
 
-  protected get program() { return this.getProgram(); }
-  protected set program(value: ts.Program) {
-    // Discard the result set by ancestor constructor
+  getMetadataFor(modulePath: string): {[key: string]: any}[]|undefined {
+    return readMetadata(modulePath, this.hostAdapter, this.metadataReaderCache);
+  }
+
+  moduleNameToFileName(moduleName: string, containingFile?: string): string|null {
+    if (!containingFile) {
+      if (moduleName.indexOf('.') === 0) {
+        throw new Error('Resolution of relative paths requires a containing file.');
+      }
+      // Any containing file gives the same result for absolute imports
+      containingFile = path.join(this.options.basePath !, 'index.ts');
+    }
+    const resolved =
+        ts.resolveModuleName(moduleName, containingFile, this.options, this.hostAdapter)
+            .resolvedModule;
+    return resolved ? resolved.resolvedFileName : null;
   }
 }

packages/service-worker/config/src/generator.ts

@@ -46,7 +46,7 @@ export class Generator {
       plainFiles.forEach(file => seenMap.add(file));
 
       // Add the hashes.
-      await plainFiles.reduce(async(previous, file) => {
+      await[...versionedFiles, ...plainFiles].reduce(async(previous, file) => {
         await previous;
         const hash = await this.fs.hash(file);
         hashTable[joinUrls(this.baseHref, file)] = hash;

packages/service-worker/config/test/generator_spec.ts

@@ -14,6 +14,7 @@ export function main() {
     it('generates a correct config', (done: DoneFn) => {
       const fs = new MockFilesystem({
         '/index.html': 'This is a test',
+        '/test.txt': 'Another test',
         '/foo/test.html': 'Another test',
         '/ignored/x.html': 'should be ignored',
       });
@@ -30,7 +31,9 @@ export function main() {
               '/**/*.html', '!/ignored/**',
               //                '/*.html',
             ],
-            versionedFiles: [],
+            versionedFiles: [
+              '/**/*.txt',
+            ],
             urls: [
               '/absolute/**',
               '/some/url?with+escaped+chars',
@@ -62,7 +65,11 @@ export function main() {
                'name': 'test',
                'installMode': 'prefetch',
                'updateMode': 'prefetch',
-               'urls': ['/test/index.html', '/test/foo/test.html'],
+               'urls': [
+                 '/test/index.html',
+                 '/test/foo/test.html',
+                 '/test/test.txt',
+               ],
                'patterns': [
                  '\\/absolute\\/.*',
                  '\\/some\\/url\\?with\\+escaped\\+chars',
@@ -79,6 +86,7 @@ export function main() {
                'version': 1,
              }],
              'hashTable': {
+               '/test/test.txt': '18f6f8eb7b1c23d2bb61bff028b83d867a9e4643',
                '/test/index.html': 'a54d88e06612d820bc3be72877c74f257b561b19',
                '/test/foo/test.html': '18f6f8eb7b1c23d2bb61bff028b83d867a9e4643'
              }

packages/service-worker/config/tsconfig-build.json

@@ -18,6 +18,7 @@
     "annotateForClosureCompiler": true,
     "strictMetadataEmit": false,
     "flatModuleOutFile": "config.js",
-    "flatModuleId": "@angular/service-worker/config"
+    "flatModuleId": "@angular/service-worker/config",
+    "skipTemplateCodegen": true
   }
 }

packages/service-worker/index.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+// This file is not used to build this module. It is only used during editing
+// by the TypeScript language service and during build for verification. `ngc`
+// replaces this file with production index.ts when it rewrites private symbol
+// names.
+
+export * from './public_api';

packages/service-worker/tsconfig-build.json

@@ -19,6 +19,7 @@
     "annotateForClosureCompiler": true,
     "strictMetadataEmit": false,
     "flatModuleOutFile": "service-worker.js",
-    "flatModuleId": "@angular/service-worker"
+    "flatModuleId": "@angular/service-worker",
+    "skipTemplateCodegen": true
   }
 }

scripts/ci/env.sh

@@ -36,9 +36,10 @@ fi
 
 setEnvVar NODE_VERSION 6.9.5
 setEnvVar YARN_VERSION 1.0.2
+setEnvVar CHROMIUM_VERSION 499098 # Chrome 62 linux stable, see https://www.chromium.org/developers/calendar
 setEnvVar BAZEL_VERSION 0.5.4
 setEnvVar SAUCE_CONNECT_VERSION 4.4.9
-setEnvVar ANGULAR_CLI_VERSION 1.4.0-rc.2
+setEnvVar ANGULAR_CLI_VERSION 1.5.0-rc.2
 setEnvVar PROJECT_ROOT $(cd ${thisDir}/../..; pwd)
 
 if [[ ${TRAVIS:-} ]]; then
@@ -103,6 +104,7 @@ if [[ ${TRAVIS:-} ]]; then
   setEnvVar BROWSER_STACK_USERNAME angularteam1
   # not using use setEnvVar so that we don't print the key
   export BROWSER_STACK_ACCESS_KEY=BWCd4SynLzdDcv8xtzsB
+  setEnvVar CHROME_BIN ${HOME}/.chrome/chromium/chrome-linux/chrome
   setEnvVar BROWSER_PROVIDER_READY_FILE /tmp/angular-build/browser-provider-tunnel-init.lock
 fi
 

scripts/ci/install-chromium.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+set -u -e -o pipefail
+
+# Setup environment
+readonly thisDir=$(cd $(dirname $0); pwd)
+source ${thisDir}/_travis-fold.sh
+
+
+# This script basically follows the instructions to download an old version of Chromium: https://www.chromium.org/getting-involved/download-chromium
+# 1) It retrieves the current stable version number from https://www.chromium.org/developers/calendar (via the https://omahaproxy.appspot.com/all file), e.g. 359700 for Chromium 48.
+# 2) It checks the Travis cache for this specific version
+# 3) If not available, it downloads and caches it, using the "decrement commit number" trick.
+
+#Build version read from the OmahaProxy CSV Viewer at https://www.chromium.org/developers/calendar
+#Let's use the following version of Chromium, and inform about availability of newer build from https://omahaproxy.appspot.com/all
+#
+# CHROMIUM_VERSION <<< this variable is now set via env.sh
+
+PLATFORM="$(uname -s)"
+case "$PLATFORM" in
+  (Darwin)
+    ARCHITECTURE=Mac
+    DIST_FILE=chrome-mac.zip
+    ;;
+  (Linux)
+    ARCHITECTURE=Linux_x64
+    DIST_FILE=chrome-linux.zip
+    ;;
+  (*)
+    echo Unsupported platform $PLATFORM.  Exiting ... >&2
+    exit 3
+    ;;
+esac
+
+TMP=$(curl -s "https://omahaproxy.appspot.com/all") || true
+oldIFS="$IFS"
+IFS='
+'
+IFS=${IFS:0:1}
+lines=( $TMP )
+IFS=','
+for line in "${lines[@]}"
+  do
+    lineArray=($line);
+    if [ "${lineArray[0]}" = "linux" ] && [ "${lineArray[1]}" = "stable" ] ; then
+      LATEST_CHROMIUM_VERSION="${lineArray[7]}"
+    fi
+done
+IFS="$oldIFS"
+
+CHROMIUM_DIR=$HOME/.chrome/chromium
+CHROMIUM_BIN=$CHROMIUM_DIR/chrome-linux/chrome
+CHROMIUM_VERSION_FILE=$CHROMIUM_DIR/VERSION
+
+EXISTING_VERSION=""
+if [[ -f $CHROMIUM_VERSION_FILE && -x $CHROMIUM_BIN ]]; then
+  EXISTING_VERSION=`cat $CHROMIUM_VERSION_FILE`
+  echo Found cached Chromium version: ${EXISTING_VERSION}
+fi
+
+if [[ "$EXISTING_VERSION" != "$CHROMIUM_VERSION" ]]; then
+  echo Downloading Chromium version: ${CHROMIUM_VERSION}
+  rm -fR $CHROMIUM_DIR
+  mkdir -p $CHROMIUM_DIR
+
+  NEXT=$CHROMIUM_VERSION
+  FILE="chrome-linux.zip"
+  STATUS=404
+  while [[ $STATUS == 404 && $NEXT -ge 0 ]]
+  do
+    echo Fetch Chromium version: ${NEXT}
+    STATUS=$(curl "https://storage.googleapis.com/chromium-browser-snapshots/${ARCHITECTURE}/${NEXT}/${DIST_FILE}" -s -w %{http_code} --create-dirs -o $FILE) || true
+    NEXT=$[$NEXT-1]
+  done
+
+  unzip $FILE -d $CHROMIUM_DIR
+  rm $FILE
+  echo $CHROMIUM_VERSION > $CHROMIUM_VERSION_FILE
+fi
+
+if [[ "$CHROMIUM_VERSION" != "$LATEST_CHROMIUM_VERSION" ]]; then
+  echo "New version of Chromium available. Update install-chromium.sh with build number: ${LATEST_CHROMIUM_VERSION}"
+fi

scripts/ci/install.sh

@@ -37,7 +37,7 @@ travisFoldEnd "install-yarn"
 
 # Install all npm dependencies according to yarn.lock
 travisFoldStart "yarn-install"
-  node tools/npm/check-node-modules --purge || yarn install --freeze-lockfile --non-interactive
+  node tools/npm/check-node-modules --purge || yarn install --frozen-lockfile --non-interactive
 travisFoldEnd "yarn-install"
 
 
@@ -72,11 +72,21 @@ if [[ ${TRAVIS} && (${CI_MODE} == "bazel" || ${CI_MODE} == "e2e_2") ]]; then
   travisFoldEnd "bazel-install"
 fi
 
-# Start xvfb for local Chrome testing
-if [[ ${TRAVIS} && (${CI_MODE} == "js" || ${CI_MODE} == "e2e" || ${CI_MODE} == "e2e_2" || ${CI_MODE} == "aio" || ${CI_MODE} == "aio_e2e") ]]; then
-  travisFoldStart "xvfb-start"
-    sh -e /etc/init.d/xvfb start
-  travisFoldEnd "xvfb-start"
+
+# Install Chromium
+if [[ ${TRAVIS} && ${CI_MODE} == "js" || ${CI_MODE} == "e2e" || ${CI_MODE} == "e2e_2" || ${CI_MODE} == "aio" || ${CI_MODE} == "aio_e2e" ]]; then
+  travisFoldStart "install-chromium"
+    (
+      ${thisDir}/install-chromium.sh
+
+      # Start xvfb for local Chrome used for testing
+      if [[ ${TRAVIS} ]]; then
+        travisFoldStart "install-chromium.xvfb-start"
+          sh -e /etc/init.d/xvfb start
+        travisFoldEnd "install-chromium.xvfb-start"
+      fi
+    )
+  travisFoldEnd "install-chromium"
 fi
 
 

scripts/ci/offline_compiler_test.sh

@@ -60,8 +60,6 @@ cp -v package.json $TMP
   ./node_modules/.bin/ng-xi18n -p tsconfig-xi18n.json --i18nFormat=xlf2 --outFile=messages.xliff2.xlf
   ./node_modules/.bin/ng-xi18n -p tsconfig-xi18n.json --i18nFormat=xmb --outFile=custom_file.xmb
 
-  # Removed until #15219 is fixed
-  # node test/test_summaries.js
   node test/test_ngtools_api.js
 
   ./node_modules/.bin/jasmine init

scripts/ci/test-e2e.sh

@@ -26,7 +26,6 @@ travisFoldEnd "test.e2e.check-cycle"
 
 # Serve files for e2e tests
 (
-  cd dist/
   $(npm bin)/gulp serve &
   $(npm bin)/gulp serve-examples &
 )

yarn.lock

@@ -6194,9 +6194,9 @@ rx-lite@^3.1.2:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/rx-lite/-/rx-lite-3.1.2.tgz#19ce502ca572665f3b647b10939f97fd1615f102"
 
-rxjs@5.5.x:
-  version "5.5.0"
-  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-5.5.0.tgz#26d8f3866eb700e247e0728a147c3d628993d812"
+rxjs@^5.5.2:
+  version "5.5.2"
+  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-5.5.2.tgz#28d403f0071121967f18ad665563255d54236ac3"
   dependencies:
     symbol-observable "^1.0.1"