refactor: move angular source to /packages rather than modules/@angular

2017-03-02 10:48:42 -08:00
parent 5ad5301a3e
commit 3e51a19983
1051 changed files with 18 additions and 18 deletions
--- a/packages/compiler-cli/README.md
+++ b/packages/compiler-cli/README.md
@ -0,0 +1,141 @@
+# Angular Template Compiler
+
+Angular applications are built with templates, which may be `.html` or `.css` files,
+or may be inline `template` attributes on Decorators like `@Component`.
+
+These templates are compiled into executable JS at application runtime (except in `interpretation` mode).
+This compilation can occur on the client, but it results in slower bootstrap time, and also
+requires that the compiler be included in the code downloaded to the client.
+
+You can produce smaller, faster applications by running Angular's compiler as a build step,
+and then downloading only the executable JS to the client.
+
+## Install and use
+
+```
+# First install angular, see https://github.com/angular/angular/blob/master/CHANGELOG.md#200-rc0-2016-05-02
+$ npm install @angular/compiler-cli typescript@next @angular/platform-server @angular/compiler
+# Optional sanity check, make sure TypeScript can compile.
+$ ./node_modules/.bin/tsc -p path/to/project
+# ngc is a drop-in replacement for tsc.
+$ ./node_modules/.bin/ngc -p path/to/project
+```
+
+In order to write a `bootstrap` that imports the generated code, you should first write your
+top-level component, and run `ngc` once to produce a generated `.ngfactory.ts` file.
+Then you can add an import statement in the `bootstrap` allowing you to bootstrap off the
+generated code:
+
+```typescript
+main.module.ts
+-------------
+import {BrowserModule} from '@angular/platform-browser';
+import {Component, NgModule, ApplicationRef} from '@angular/core';
+
+@Component(...)
+export class MyComponent {}
+
+@NgModule({
+  imports: [BrowserModule],
+  declarations: [MyComponent],
+  entryComponents: [MyComponent]
+})
+export class MainModule {
+  constructor(appRef: ApplicationRef) {
+    appRef.bootstrap(MyComponent);
+  }
+}
+
+bootstrap.ts
+-------------
+
+import {MainModuleNgFactory} from './main.module.ngfactory';
+import {platformBrowser} from '@angular/platform-browser';
+
+platformBrowser().bootstrapModuleFactory(MainModuleNgFactory);
+```
+
+## Configuration
+
+The `tsconfig.json` file may contain an additional configuration block:
+```
+ "angularCompilerOptions": {
+   "genDir": ".",
+   "debug": true
+ }
+```
+
+### `genDir`
+
+the `genDir` option controls the path (relative to `tsconfig.json`) where the generated file tree
+will be written. If `genDir` is not set, then the code will be generated in the source tree, next
+to your original sources. More options may be added as we implement more features.
+
+We recommend you avoid checking generated files into version control. This permits a state where
+the generated files in the repository were created from sources that were never checked in,
+making it impossible to reproduce the current state. Also, your changes will effectively appear
+twice in code reviews, with the generated version inscrutible by the reviewer.
+
+In TypeScript 1.8, the generated sources will have to be written alongside your originals,
+so set `genDir` to the same location as your files (typicially the same as `rootDir`).
+Add `**/*.ngfactory.ts` to your `.gitignore` or other mechanism for your version control system.
+
+In TypeScript 1.9 and above, you can add a generated folder into your application,
+such as `codegen`. Using the `rootDirs` option, you can allow relative imports like
+`import {} from './foo.ngfactory'` even though the `src` and `codegen` trees are distinct.
+Add `**/codegen` to your `.gitignore` or similar.
+
+Note that in the second option, TypeScript will emit the code into two parallel directories
+as well. This is by design, see https://github.com/Microsoft/TypeScript/issues/8245.
+This makes the configuration of your runtime module loader more complex, so we don't recommend
+this option yet.
+
+### `debug`
+
+Set the `debug` option to true to generate debug information in the generate files.
+Default to `false`.
+
+See the example in the `test/` directory for a working example.
+
+## Compiler CLI
+
+This program mimics the TypeScript tsc command line. It accepts a `-p` flag which points to a
+`tsconfig.json` file, or a directory containing one.
+
+This CLI is intended for demos, prototyping, or for users with simple build systems
+that run bare `tsc`.
+
+Users with a build system should expect an Angular template plugin. Such a plugin would be
+based on the `public_api.ts` in this directory, but should share the TypeScript compiler instance
+with the one already used in the plugin for TypeScript typechecking and emit.
+
+## Design
+At a high level, this program
+- collects static metadata about the sources using the `tsc-wrapped` package
+- uses the `OfflineCompiler` from `@angular/compiler` to codegen additional `.ts` files
+- these `.ts` files are written to the `genDir` path, then compiled together with the application.
+
+## For developers
+```
+# Build Angular and the compiler
+./build.sh
+
+# Copy over the package so we can test the compiler tests
+$ cp tools/@angular/tsc-wrapped/package.json dist/tools/@angular/tsc-wrapped
+
+# Run the test once
+# (First edit the LINKABLE_PKGS to use npm link instead of npm install)
+$ ./scripts/ci/offline_compiler_test.sh
+
+# Keep a package fresh in watch mode
+./node_modules/.bin/tsc -p modules/@angular/compiler/tsconfig-es5.json -w
+
+# Recompile @angular/core module (needs to use tsc-ext to keep the metadata)
+$ export NODE_PATH=${NODE_PATH}:$(pwd)/dist/all:$(pwd)/dist/tools
+$ node dist/tools/@angular/tsc-wrapped/src/main -p modules/@angular/core/tsconfig-es5.json
+
+# Iterate on the test
+$ cd /tmp/wherever/e2e_test.1464388257/
+$ ./node_modules/.bin/ngc
+$ ./node_modules/.bin/jasmine test/*_spec.js
+```
--- a/packages/compiler-cli/esm5/tsconfig-build.json
+++ b/packages/compiler-cli/esm5/tsconfig-build.json
@ -0,0 +1,8 @@
+{
+    "extends": "./tsconfig-build",
+    "compilerOptions": {
+        "module": "es2015",
+        "moduleResolution": "node",
+        "outDir": "../../../dist/esm/compiler-cli"
+    }
+}
--- a/packages/compiler-cli/index.ts
+++ b/packages/compiler-cli/index.ts
@ -0,0 +1,17 @@
+/**
+ * @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
+ */
+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 {Extractor} from './src/extractor';
+export * from '@angular/tsc-wrapped';
+export {VERSION} from './src/version';
+
+
+// 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'
--- a/packages/compiler-cli/integrationtest/benchmarks/README.md
+++ b/packages/compiler-cli/integrationtest/benchmarks/README.md
@ -0,0 +1,6 @@
+# Overview
+
+This folder will be filled with the benchmark sources
+so that we can do offline compilation for them.
+
+
--- a/packages/compiler-cli/integrationtest/ngtools_src/app.component.css
+++ b/packages/compiler-cli/integrationtest/ngtools_src/app.component.css
@ -0,0 +1,3 @@
+:host {
+  background-color: blue;
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/app.component.html
+++ b/packages/compiler-cli/integrationtest/ngtools_src/app.component.html
@ -0,0 +1,5 @@
+<div>
+  <h1 i18n>hello world</h1>
+  <a [routerLink]="['lazy']">lazy</a>
+  <router-outlet></router-outlet>
+</div>
--- a/packages/compiler-cli/integrationtest/ngtools_src/app.component.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/app.component.ts
@ -0,0 +1,19 @@
+/**
+ * @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 {Component, ViewEncapsulation} from '@angular/core';
+
+
+@Component({
+  selector: 'app-root',
+  templateUrl: 'app.component.html',
+  styleUrls: ['app.component.css'],
+  encapsulation: ViewEncapsulation.None
+})
+export class AppComponent {
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/app.module.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/app.module.ts
@ -0,0 +1,32 @@
+/**
+ * @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 {Component, NgModule} from '@angular/core';
+import {BrowserModule} from '@angular/platform-browser';
+import {RouterModule} from '@angular/router';
+
+import {AppComponent} from './app.component';
+
+@Component({selector: 'home-view', template: 'home!'})
+export class HomeView {
+}
+
+
+@NgModule({
+  declarations: [AppComponent, HomeView],
+  imports: [
+    BrowserModule, RouterModule.forRoot([
+      {path: 'lazy', loadChildren: './lazy.module#LazyModule'},
+      {path: 'feature2', loadChildren: 'feature2/feature2.module#Feature2Module'},
+      {path: '', component: HomeView}
+    ])
+  ],
+  bootstrap: [AppComponent]
+})
+export class AppModule {
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/feature/feature.module.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/feature/feature.module.ts
@ -0,0 +1,21 @@
+/**
+ * @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 {Component, NgModule} from '@angular/core';
+import {RouterModule} from '@angular/router';
+
+@Component({selector: 'feature-component', template: 'foo.html'})
+export class FeatureComponent {
+}
+
+@NgModule({
+  declarations: [FeatureComponent],
+  imports: [RouterModule.forChild([{path: '', component: FeatureComponent}])]
+})
+export class FeatureModule {
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/feature/lazy-feature-nested.module.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/feature/lazy-feature-nested.module.ts
@ -0,0 +1,23 @@
+/**
+ * @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 {Component, NgModule} from '@angular/core';
+import {RouterModule} from '@angular/router';
+
+@Component({selector: 'lazy-feature-comp', template: 'lazy feature, nested!'})
+export class LazyFeatureNestedComponent {
+}
+
+@NgModule({
+  imports: [RouterModule.forChild([
+    {path: '', component: LazyFeatureNestedComponent, pathMatch: 'full'},
+  ])],
+  declarations: [LazyFeatureNestedComponent]
+})
+export class LazyFeatureNestedModule {
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/feature/lazy-feature.module.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/feature/lazy-feature.module.ts
@ -0,0 +1,27 @@
+/**
+ * @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 {Component, NgModule} from '@angular/core';
+import {RouterModule} from '@angular/router';
+
+@Component({selector: 'lazy-feature-comp', template: 'lazy feature!'})
+export class LazyFeatureComponent {
+}
+
+@NgModule({
+  imports: [RouterModule.forChild([
+    {path: '', component: LazyFeatureComponent, pathMatch: 'full'},
+    {path: 'feature', loadChildren: './feature.module#FeatureModule'}, {
+      path: 'nested-feature',
+      loadChildren: './lazy-feature-nested.module#LazyFeatureNestedModule'
+    }
+  ])],
+  declarations: [LazyFeatureComponent]
+})
+export class LazyFeatureModule {
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/feature2/default.module.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/feature2/default.module.ts
@ -0,0 +1,23 @@
+/**
+ * @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 {Component, NgModule} from '@angular/core';
+import {RouterModule} from '@angular/router';
+
+@Component({selector: 'feature-component', template: 'foo.html'})
+export class FeatureComponent {
+}
+
+@NgModule({
+  declarations: [FeatureComponent],
+  imports: [RouterModule.forChild([
+    {path: '', component: FeatureComponent},
+  ])]
+})
+export default class DefaultModule {
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/feature2/feature2.module.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/feature2/feature2.module.ts
@ -0,0 +1,26 @@
+/**
+ * @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 {Component, NgModule} from '@angular/core';
+import {RouterModule} from '@angular/router';
+
+@Component({selector: 'feature-component', template: 'foo.html'})
+export class FeatureComponent {
+}
+
+@NgModule({
+  declarations: [FeatureComponent],
+  imports: [RouterModule.forChild([
+    {path: '', component: FeatureComponent}, {path: 'd', loadChildren: './default.module'} {
+      path: 'e',
+      loadChildren: 'feature/feature.module#FeatureModule'
+    }
+  ])]
+})
+export class Feature2Module {
+}
--- a/packages/compiler-cli/integrationtest/ngtools_src/lazy.module.ts
+++ b/packages/compiler-cli/integrationtest/ngtools_src/lazy.module.ts
@ -0,0 +1,27 @@
+/**
+ * @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 {Component, NgModule} from '@angular/core';
+import {RouterModule} from '@angular/router';
+
+@Component({selector: 'lazy-comp', template: 'lazy!'})
+export class LazyComponent {
+}
+
+@NgModule({
+  imports: [RouterModule.forChild([
+    {path: '', component: LazyComponent, pathMatch: 'full'},
+    {path: 'feature', loadChildren: './feature/feature.module#FeatureModule'},
+    {path: 'lazy-feature', loadChildren: './feature/lazy-feature.module#LazyFeatureModule'}
+  ])],
+  declarations: [LazyComponent]
+})
+export class LazyModule {
+}
+
+export class SecondModule {}
--- a/packages/compiler-cli/integrationtest/ngtools_src/tsconfig-build.json
+++ b/packages/compiler-cli/integrationtest/ngtools_src/tsconfig-build.json
@ -0,0 +1,24 @@
+{
+  "angularCompilerOptions": {
+    // For TypeScript 1.8, we have to lay out generated files
+    // in the same source directory with your code.
+    "genDir": ".",
+    "debug": true
+  },
+
+  "compilerOptions": {
+    "target": "es5",
+    "experimentalDecorators": true,
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "rootDir": "",
+    "declaration": true,
+    "lib": [
+      "es6",
+      "dom"
+    ],
+    "baseUrl": ".",
+    // don't auto-discover @types/fs-extra
+    "types": []
+  }
+}
--- a/packages/compiler-cli/integrationtest/src/a/multiple_components.html
+++ b/packages/compiler-cli/integrationtest/src/a/multiple_components.html
@ -0,0 +1 @@
+<div></div>
--- a/packages/compiler-cli/integrationtest/src/a/multiple_components.ts
+++ b/packages/compiler-cli/integrationtest/src/a/multiple_components.ts
@ -0,0 +1,35 @@
+/**
+ * @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 {Component} from '@angular/core';
+
+@Component({selector: 'my-comp', template: '<div></div>'})
+export class MultipleComponentsMyComp {
+}
+
+@Component({
+  selector: 'next-comp',
+  templateUrl: './multiple_components.html',
+})
+export class NextComp {
+}
+
+// Verify that exceptions from DirectiveResolver don't propagate
+export function NotADirective(c: any): void {}
+@NotADirective
+export class HasCustomDecorator {
+}
+
+// Verify that custom decorators have metadata collected, eg Ionic
+export function Page(c: any): (f: Function) => void {
+  return NotADirective;
+}
+
+@Page({template: 'Ionic template'})
+export class AnIonicPage {
+}
--- a/packages/compiler-cli/integrationtest/src/animate.ts
+++ b/packages/compiler-cli/integrationtest/src/animate.ts
@ -0,0 +1,37 @@
+/**
+ * @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 {AUTO_STYLE, animate, state, style, transition, trigger} from '@angular/animations';
+import {Component} from '@angular/core';
+
+@Component({
+  selector: 'animate-cmp',
+  animations: [trigger(
+      'openClose',
+      [
+        state('*', style({height: AUTO_STYLE, color: 'black', borderColor: 'black'})),
+        state('closed, void', style({height: '0px', color: 'maroon', borderColor: 'maroon'})),
+        state('open', style({height: AUTO_STYLE, borderColor: 'green', color: 'green'})),
+        transition('* => *', animate('1s'))
+      ])],
+  template: `
+    <button (click)="setAsOpen()">Open</button>
+    <button (click)="setAsClosed()">Closed</button>
+    <button (click)="setAsSomethingElse()">Something Else</button>
+    <hr />
+    <div [@openClose]="stateExpression">
+      Look at this box
+    </div>
+  `
+})
+export class AnimateCmp {
+  stateExpression: string;
+  constructor() { this.setAsClosed(); }
+  setAsSomethingElse() { this.stateExpression = 'something'; }
+  setAsOpen() { this.stateExpression = 'open'; }
+  setAsClosed() { this.stateExpression = 'closed'; }
+}
--- a/packages/compiler-cli/integrationtest/src/basic.css
+++ b/packages/compiler-cli/integrationtest/src/basic.css
@ -0,0 +1,3 @@
+@import './shared.css';
+
+.green { color: green }
--- a/packages/compiler-cli/integrationtest/src/basic.html
+++ b/packages/compiler-cli/integrationtest/src/basic.html
@ -0,0 +1,5 @@
+<div [attr.array]="[0]" [attr.map]="{a:1}" title="translate me" i18n-title="meaning|desc">{{ctxProp}}</div>
+<form><input type="button" [(ngModel)]="ctxProp" name="first"/></form>
+<my-comp *ngIf="ctxBool"></my-comp>
+<div *ngFor="let x of ctxArr" [attr.value]="x"></div>
+<p id="welcomeMessage"><!--i18n-->Welcome<!--/i18n--></p>
--- a/packages/compiler-cli/integrationtest/src/basic.ts
+++ b/packages/compiler-cli/integrationtest/src/basic.ts
@ -0,0 +1,28 @@
+/**
+ * @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 {NgFor, NgIf} from '@angular/common';
+import {Component, Inject, LOCALE_ID, TRANSLATIONS_FORMAT} from '@angular/core';
+
+
+@Component({
+  selector: 'basic',
+  templateUrl: './basic.html',
+  styles: ['.red { color: red }'],
+  styleUrls: ['./basic.css'],
+})
+export class BasicComp {
+  ctxProp: string;
+  ctxBool: boolean;
+  ctxArr: any[] = [];
+  constructor(
+      @Inject(LOCALE_ID) public localeId: string,
+      @Inject(TRANSLATIONS_FORMAT) public translationsFormat: string) {
+    this.ctxProp = 'initialValue';
+  }
+}
--- a/packages/compiler-cli/integrationtest/src/bootstrap.ts
+++ b/packages/compiler-cli/integrationtest/src/bootstrap.ts
@ -0,0 +1,13 @@
+/**
+ * @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 {platformBrowser} from '@angular/platform-browser';
+import {BasicComp} from './basic';
+import {MainModuleNgFactory} from './module.ngfactory';
+
+MainModuleNgFactory.create(null).instance.appRef.bootstrap(BasicComp);
--- a/packages/compiler-cli/integrationtest/src/comp_using_3rdp.ts
+++ b/packages/compiler-cli/integrationtest/src/comp_using_3rdp.ts
@ -0,0 +1,18 @@
+/**
+ * @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 {Component} from '@angular/core';
+
+@Component({
+  selector: 'use-third-party',
+  template: '<third-party-comp [thirdParty]="title"></third-party-comp>' +
+      '<another-third-party-comp></another-third-party-comp>',
+})
+export class ComponentUsingThirdParty {
+  title: string = 'from 3rd party';
+}
--- a/packages/compiler-cli/integrationtest/src/dep.d.ts
+++ b/packages/compiler-cli/integrationtest/src/dep.d.ts
@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+
+// Verify we don't try to extract metadata for .d.ts files
+export declare var a: string;
--- a/packages/compiler-cli/integrationtest/src/entry_components.ts
+++ b/packages/compiler-cli/integrationtest/src/entry_components.ts
@ -0,0 +1,35 @@
+/**
+ * @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 {ANALYZE_FOR_ENTRY_COMPONENTS, Component, ComponentFactoryResolver, Inject, InjectionToken} from '@angular/core';
+
+import {BasicComp} from './basic';
+
+@Component({selector: 'cmp-entryComponents', template: '', entryComponents: [BasicComp]})
+export class CompWithEntryComponents {
+  constructor(public cfr: ComponentFactoryResolver) {}
+}
+
+export const SOME_TOKEN = new InjectionToken('someToken');
+
+export function provideValueWithEntryComponents(value: any) {
+  return [
+    {provide: SOME_TOKEN, useValue: value},
+    {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: value, multi: true},
+  ];
+}
+
+@Component({
+  selector: 'comp-entryComponents-provider',
+  template: '',
+  providers: [provideValueWithEntryComponents([{a: 'b', component: BasicComp}])]
+})
+export class CompWithAnalyzeEntryComponentsProvider {
+  constructor(public cfr: ComponentFactoryResolver, @Inject(SOME_TOKEN) public providedValue: any) {
+  }
+}
--- a/packages/compiler-cli/integrationtest/src/features.ts
+++ b/packages/compiler-cli/integrationtest/src/features.ts
@ -0,0 +1,79 @@
+/**
+ * @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 common from '@angular/common';
+import {CUSTOM_ELEMENTS_SCHEMA, Component, Directive, EventEmitter, Inject, InjectionToken, NgModule, Output} from '@angular/core';
+import {Observable} from 'rxjs/Observable';
+
+import {wrapInArray} from './funcs';
+
+export const SOME_INJECTON_TOKEN = new InjectionToken('injectionToken');
+
+@Component({
+  selector: 'comp-providers',
+  template: '',
+  providers: [
+    {provide: 'strToken', useValue: 'strValue'},
+    {provide: SOME_INJECTON_TOKEN, useValue: 10},
+    {provide: 'reference', useValue: common.NgIf},
+    {provide: 'complexToken', useValue: {a: 1, b: ['test', SOME_INJECTON_TOKEN]}},
+  ]
+})
+export class CompWithProviders {
+  constructor(@Inject('strToken') public ctxProp: string) {}
+}
+
+@Component({
+  selector: 'cmp-reference',
+  template: `
+    <input #a [(ngModel)]="foo" required>{{a.value}}
+    <div *ngIf="true">{{a.value}}</div>
+  `
+})
+export class CompWithReferences {
+  foo: string;
+}
+
+@Component({selector: 'cmp-pipes', template: `<div *ngIf>{{test | somePipe}}</div>`})
+export class CompUsingPipes {
+}
+
+@Component({
+  selector: 'cmp-custom-els',
+  template: `
+    <some-custom-element [someUnknownProp]="true"></some-custom-element>
+  `,
+})
+export class CompUsingCustomElements {
+}
+
+@Component({
+  selector: 'cmp-event',
+  template: `
+    <div (click)="handleDomEventVoid($event)"></div>
+    <div (click)="handleDomEventPreventDefault($event)"></div>
+    <div (dirEvent)="handleDirEvent($event)"></div>
+  `,
+})
+export class CompConsumingEvents {
+  handleDomEventVoid(e: any): void {}
+  handleDomEventPreventDefault(e: any): boolean { return false; }
+  handleDirEvent(e: any): void {}
+}
+
+@Directive({
+  selector: '[dirEvent]',
+})
+export class DirPublishingEvents {
+  @Output('dirEvent')
+  dirEvent: Observable<string> = new EventEmitter();
+}
+
+@NgModule({schemas: [CUSTOM_ELEMENTS_SCHEMA], declarations: wrapInArray(CompUsingCustomElements)})
+export class ModuleUsingCustomElements {
+}
--- a/packages/compiler-cli/integrationtest/src/funcs.ts
+++ b/packages/compiler-cli/integrationtest/src/funcs.ts
@ -0,0 +1,11 @@
+/**
+ * @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
+ */
+
+export function wrapInArray(value: any): any[] {
+  return [value];
+}
--- a/packages/compiler-cli/integrationtest/src/messages.fi.xlf
+++ b/packages/compiler-cli/integrationtest/src/messages.fi.xlf
@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" version="1.2">
+    <file source-language="en" datatype="plaintext" original="ng2.template">
+        <body>
+            <trans-unit id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4" datatype="html">
+                <source>translate me</source>
+                <target>käännä teksti</target>
+                <note priority="1" from="description">desc</note>
+                <note priority="1" from="meaning">meaning</note>
+            </trans-unit>
+            <trans-unit id="65cc4ab3b4c438e07c89be2b677d08369fb62da2" datatype="html">
+                <source>Welcome</source>
+                <target>tervetuloa</target>
+            </trans-unit>
+            <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
+                <source>other-3rdP-component</source>
+                <target>other-3rdP-component</target>
+            </trans-unit>
+        </body>
+    </file>
+</xliff>
--- a/packages/compiler-cli/integrationtest/src/module.ts
+++ b/packages/compiler-cli/integrationtest/src/module.ts
@ -0,0 +1,94 @@
+/**
+ * @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 {ApplicationRef, NgModule, NgZone, Provider, RendererFactory2} from '@angular/core';
+import {FormsModule} from '@angular/forms';
+import {NoopAnimationsModule, ɵAnimationEngine, ɵAnimationRendererFactory} from '@angular/platform-browser/animations';
+import {ServerModule, ɵServerRendererFactory2} from '@angular/platform-server';
+import {MdButtonModule} from '@angular2-material/button';
+// Note: don't refer to third_party_src as we want to test that
+// we can compile components from node_modules!
+import {ThirdpartyModule} from 'third_party/module';
+
+import {MultipleComponentsMyComp, NextComp} from './a/multiple_components';
+import {AnimateCmp} from './animate';
+import {BasicComp} from './basic';
+import {ComponentUsingThirdParty} from './comp_using_3rdp';
+import {CompWithAnalyzeEntryComponentsProvider, CompWithEntryComponents} from './entry_components';
+import {CompConsumingEvents, CompUsingPipes, CompWithProviders, CompWithReferences, DirPublishingEvents, ModuleUsingCustomElements} from './features';
+import {CompUsingRootModuleDirectiveAndPipe, SomeDirectiveInRootModule, SomeLibModule, SomePipeInRootModule, SomeService} from './module_fixtures';
+import {CompWithNgContent, ProjectingComp} from './projection';
+import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, DirectiveForQuery} from './queries';
+
+export function instantiateServerRendererFactory(
+    renderer: RendererFactory2, engine: ɵAnimationEngine, zone: NgZone) {
+  return new ɵAnimationRendererFactory(renderer, engine, zone);
+}
+
+// TODO(matsko): create a server module for animations and use
+// that instead of these manual providers here.
+export const SERVER_ANIMATIONS_PROVIDERS: Provider[] = [{
+  provide: RendererFactory2,
+  useFactory: instantiateServerRendererFactory,
+  deps: [ɵServerRendererFactory2, ɵAnimationEngine, NgZone]
+}];
+
+@NgModule({
+  declarations: [
+    AnimateCmp,
+    BasicComp,
+    CompConsumingEvents,
+    CompForChildQuery,
+    CompUsingPipes,
+    CompUsingRootModuleDirectiveAndPipe,
+    CompWithAnalyzeEntryComponentsProvider,
+    CompWithChildQuery,
+    CompWithDirectiveChild,
+    CompWithEntryComponents,
+    CompWithNgContent,
+    CompWithProviders,
+    CompWithReferences,
+    DirectiveForQuery,
+    DirPublishingEvents,
+    MultipleComponentsMyComp,
+    NextComp,
+    ProjectingComp,
+    SomeDirectiveInRootModule,
+    SomePipeInRootModule,
+    ComponentUsingThirdParty,
+  ],
+  imports: [
+    NoopAnimationsModule,
+    ServerModule,
+    FormsModule,
+    MdButtonModule,
+    ModuleUsingCustomElements,
+    SomeLibModule.withProviders(),
+    ThirdpartyModule,
+  ],
+  providers: [
+    SomeService,
+    SERVER_ANIMATIONS_PROVIDERS,
+  ],
+  entryComponents: [
+    AnimateCmp,
+    BasicComp,
+    CompUsingRootModuleDirectiveAndPipe,
+    CompWithAnalyzeEntryComponentsProvider,
+    CompWithChildQuery,
+    CompWithEntryComponents,
+    CompWithReferences,
+    ProjectingComp,
+    ComponentUsingThirdParty,
+  ]
+})
+export class MainModule {
+  constructor(public appRef: ApplicationRef) {}
+
+  ngDoBootstrap() {}
+}
--- a/packages/compiler-cli/integrationtest/src/module_fixtures.ts
+++ b/packages/compiler-cli/integrationtest/src/module_fixtures.ts
@ -0,0 +1,75 @@
+/**
+ * @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 {LowerCasePipe, NgIf} from '@angular/common';
+import {ANALYZE_FOR_ENTRY_COMPONENTS, Component, ComponentFactoryResolver, Directive, Inject, Injectable, InjectionToken, Input, ModuleWithProviders, NgModule, Pipe} from '@angular/core';
+
+@Injectable()
+export class SomeService {
+  public prop = 'someValue';
+}
+
+@Injectable()
+export class ServiceUsingLibModule {
+}
+
+@Directive({selector: '[someDir]', host: {'[title]': 'someDir'}})
+export class SomeDirectiveInRootModule {
+  @Input()
+  someDir: string;
+}
+
+@Directive({selector: '[someDir]', host: {'[title]': 'someDir'}})
+export class SomeDirectiveInLibModule {
+  @Input()
+  someDir: string;
+}
+
+@Pipe({name: 'somePipe'})
+export class SomePipeInRootModule {
+  transform(value: string): any { return `transformed ${value}`; }
+}
+
+@Pipe({name: 'somePipe'})
+export class SomePipeInLibModule {
+  transform(value: string): any { return `transformed ${value}`; }
+}
+
+@Component({selector: 'comp', template: `<div  [someDir]="'someValue' | somePipe"></div>`})
+export class CompUsingRootModuleDirectiveAndPipe {
+}
+
+@Component({selector: 'comp', template: `<div  [someDir]="'someValue' | somePipe"></div>`})
+export class CompUsingLibModuleDirectiveAndPipe {
+}
+
+export const SOME_TOKEN = new InjectionToken('someToken');
+
+export function provideValueWithEntryComponents(value: any) {
+  return [
+    {provide: SOME_TOKEN, useValue: value},
+    {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: value, multi: true},
+  ];
+}
+
+@NgModule({
+  declarations: [SomeDirectiveInLibModule, SomePipeInLibModule, CompUsingLibModuleDirectiveAndPipe],
+  exports: [CompUsingLibModuleDirectiveAndPipe],
+  entryComponents: [CompUsingLibModuleDirectiveAndPipe],
+})
+export class SomeLibModule {
+  static withProviders() {
+    return {
+      ngModule: SomeLibModule,
+      providers: [
+        ServiceUsingLibModule, provideValueWithEntryComponents(
+                                   [{a: 'b', component: CompUsingLibModuleDirectiveAndPipe}])
+      ]
+    };
+  }
+}
--- a/packages/compiler-cli/integrationtest/src/projection.ts
+++ b/packages/compiler-cli/integrationtest/src/projection.ts
@ -0,0 +1,20 @@
+/**
+ * @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 {Component} from '@angular/core';
+
+@Component({selector: 'comp-with-proj', template: '<ng-content></ng-content>'})
+export class CompWithNgContent {
+}
+
+@Component({
+  selector: 'main',
+  template: '<comp-with-proj><span greeting="Hello world!"></span></comp-with-proj>'
+})
+export class ProjectingComp {
+}
--- a/packages/compiler-cli/integrationtest/src/queries.ts
+++ b/packages/compiler-cli/integrationtest/src/queries.ts
@ -0,0 +1,37 @@
+/**
+ * @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 {NgFor} from '@angular/common';
+import {Component, Directive, QueryList, ViewChild, ViewChildren} from '@angular/core';
+
+@Component({selector: 'comp-for-child-query', template: 'child'})
+export class CompForChildQuery {
+}
+
+@Component(
+    {selector: 'comp-with-child-query', template: '<comp-for-child-query></comp-for-child-query>'})
+export class CompWithChildQuery {
+  @ViewChild(CompForChildQuery) child: CompForChildQuery;
+  @ViewChildren(CompForChildQuery) children: QueryList<CompForChildQuery>;
+}
+
+@Directive({selector: '[directive-for-query]'})
+export class DirectiveForQuery {
+}
+
+@Component({
+  selector: 'comp-with-directive-child',
+  template: `<div>
+     <div *ngFor="let data of divData" directive-for-query>{{data}}</div>
+  </div>`
+})
+export class CompWithDirectiveChild {
+  @ViewChildren(DirectiveForQuery) children: QueryList<DirectiveForQuery>;
+
+  divData: string[];
+}
--- a/packages/compiler-cli/integrationtest/src/shared.css
+++ b/packages/compiler-cli/integrationtest/src/shared.css
@ -0,0 +1 @@
+.blue { color: blue }
--- a/packages/compiler-cli/integrationtest/test/all_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/all_spec.ts
@ -0,0 +1,16 @@
+/**
+ * @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 './init';
+import './animate_spec';
+import './basic_spec';
+import './entry_components_spec';
+import './i18n_spec';
+import './ng_module_spec';
+import './projection_spec';
+import './query_spec';
--- a/packages/compiler-cli/integrationtest/test/animate_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/animate_spec.ts
@ -0,0 +1,72 @@
+/**
+ * @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 './init';
+import {DebugElement} from '@angular/core';
+import {AnimateCmp} from '../src/animate';
+import {createComponent} from './util';
+
+// TODO(matsko): make this green again...
+xdescribe('template codegen output', () => {
+  function findTargetElement(elm: DebugElement): DebugElement {
+    // the open-close-container is a child of the main container
+    // if the template changes then please update the location below
+    return elm.children[4];
+  }
+
+  it('should apply the animate states to the element', (done) => {
+    const compFixture = createComponent(AnimateCmp);
+    const debugElement = compFixture.debugElement;
+
+    const targetDebugElement = findTargetElement(<DebugElement>debugElement);
+
+    compFixture.componentInstance.setAsOpen();
+    compFixture.detectChanges();
+
+    setTimeout(() => {
+      expect(targetDebugElement.styles['height']).toEqual(null);
+      expect(targetDebugElement.styles['borderColor']).toEqual('green');
+      expect(targetDebugElement.styles['color']).toEqual('green');
+
+      compFixture.componentInstance.setAsClosed();
+      compFixture.detectChanges();
+
+      setTimeout(() => {
+        expect(targetDebugElement.styles['height']).toEqual('0px');
+        expect(targetDebugElement.styles['borderColor']).toEqual('maroon');
+        expect(targetDebugElement.styles['color']).toEqual('maroon');
+        done();
+      }, 0);
+    }, 0);
+  });
+
+  it('should apply the default animate state to the element', (done) => {
+    const compFixture = createComponent(AnimateCmp);
+    const debugElement = compFixture.debugElement;
+
+    const targetDebugElement = findTargetElement(<DebugElement>debugElement);
+
+    compFixture.componentInstance.setAsSomethingElse();
+    compFixture.detectChanges();
+
+    setTimeout(() => {
+      expect(targetDebugElement.styles['height']).toEqual(null);
+      expect(targetDebugElement.styles['borderColor']).toEqual('black');
+      expect(targetDebugElement.styles['color']).toEqual('black');
+
+      compFixture.componentInstance.setAsClosed();
+      compFixture.detectChanges();
+
+      setTimeout(() => {
+        expect(targetDebugElement.styles['height']).not.toEqual(null);
+        expect(targetDebugElement.styles['borderColor']).not.toEqual('grey');
+        expect(targetDebugElement.styles['color']).not.toEqual('grey');
+        done();
+      }, 0);
+    }, 0);
+  });
+});
--- a/packages/compiler-cli/integrationtest/test/basic_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/basic_spec.ts
@ -0,0 +1,92 @@
+/**
+ * @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 './init';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import {MultipleComponentsMyComp} from '../src/a/multiple_components';
+import {BasicComp} from '../src/basic';
+import {createComponent} from './util';
+
+describe('template codegen output', () => {
+  const outDir = 'src';
+
+  it('should lower Decorators without reflect-metadata', () => {
+    const jsOutput = path.join(outDir, 'basic.js');
+    expect(fs.existsSync(jsOutput)).toBeTruthy();
+    expect(fs.readFileSync(jsOutput, {encoding: 'utf-8'})).not.toContain('Reflect.decorate');
+  });
+
+  it('should produce metadata.json outputs', () => {
+    const metadataOutput = path.join(outDir, 'basic.metadata.json');
+    expect(fs.existsSync(metadataOutput)).toBeTruthy();
+    const output = fs.readFileSync(metadataOutput, {encoding: 'utf-8'});
+    expect(output).toContain('"decorators":');
+    expect(output).toContain('"module":"@angular/core","name":"Component"');
+  });
+
+  it('should write .d.ts files', () => {
+    const dtsOutput = path.join(outDir, 'basic.d.ts');
+    expect(fs.existsSync(dtsOutput)).toBeTruthy();
+    expect(fs.readFileSync(dtsOutput, {encoding: 'utf-8'})).toContain('Basic');
+  });
+
+  it('should write .ngfactory.ts for .d.ts inputs', () => {
+    const factoryOutput =
+        path.join('node_modules', '@angular2-material', 'button', 'button.ngfactory.ts');
+    expect(fs.existsSync(factoryOutput)).toBeTruthy();
+  });
+
+  it('should be able to create the basic component', () => {
+    const compFixture = createComponent(BasicComp);
+    expect(compFixture.componentInstance).toBeTruthy();
+  });
+
+  it('should support ngIf', () => {
+    const compFixture = createComponent(BasicComp);
+    const debugElement = compFixture.debugElement;
+    expect(debugElement.children.length).toBe(3);
+
+    compFixture.componentInstance.ctxBool = true;
+    compFixture.detectChanges();
+    expect(debugElement.children.length).toBe(4);
+    expect(debugElement.children[2].injector.get(MultipleComponentsMyComp)).toBeTruthy();
+  });
+
+  it('should support ngFor', () => {
+    const compFixture = createComponent(BasicComp);
+    const debugElement = compFixture.debugElement;
+    expect(debugElement.children.length).toBe(3);
+
+    // test NgFor
+    compFixture.componentInstance.ctxArr = [1, 2];
+    compFixture.detectChanges();
+    expect(debugElement.children.length).toBe(5);
+    expect(debugElement.children[2].attributes['value']).toBe('1');
+    expect(debugElement.children[3].attributes['value']).toBe('2');
+  });
+
+  describe('i18n', () => {
+    it('should inject the locale into the component', () => {
+      const compFixture = createComponent(BasicComp);
+      expect(compFixture.componentInstance.localeId).toEqual('fi');
+    });
+
+    it('should inject the translations format into the component', () => {
+      const compFixture = createComponent(BasicComp);
+      expect(compFixture.componentInstance.translationsFormat).toEqual('xlf');
+    });
+
+    it('should support i18n for content tags', () => {
+      const containerElement = createComponent(BasicComp).nativeElement;
+      const pElement = containerElement.children.find((c: any) => c.name == 'p');
+      const pText = pElement.children.map((c: any) => c.data).join('').trim();
+      expect(pText).toBe('tervetuloa');
+    });
+  });
+});
--- a/packages/compiler-cli/integrationtest/test/entry_components_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/entry_components_spec.ts
@ -0,0 +1,34 @@
+/**
+ * @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 './init';
+
+import {BasicComp} from '../src/basic';
+import {CompWithAnalyzeEntryComponentsProvider, CompWithEntryComponents} from '../src/entry_components';
+
+import {createComponent} from './util';
+
+describe('content projection', () => {
+  it('should support entryComponents in components', () => {
+    const compFixture = createComponent(CompWithEntryComponents);
+    const cf = compFixture.componentInstance.cfr.resolveComponentFactory(BasicComp);
+    expect(cf.componentType).toBe(BasicComp);
+  });
+
+  it('should support entryComponents via the ANALYZE_FOR_ENTRY_COMPONENTS provider and function providers in components',
+     () => {
+       const compFixture = createComponent(CompWithAnalyzeEntryComponentsProvider);
+       const cf = compFixture.componentInstance.cfr.resolveComponentFactory(BasicComp);
+       expect(cf.componentType).toBe(BasicComp);
+       // check that the function call that created the provider for ANALYZE_FOR_ENTRY_COMPONENTS
+       // worked.
+       expect(compFixture.componentInstance.providedValue).toEqual([
+         {a: 'b', component: BasicComp}
+       ]);
+     });
+});
--- a/packages/compiler-cli/integrationtest/test/i18n_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/i18n_spec.ts
@ -0,0 +1,88 @@
+/**
+ * @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 './init';
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+const EXPECTED_XMB = `<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE messagebundle [
+<!ELEMENT messagebundle (msg)*>
+<!ATTLIST messagebundle class CDATA #IMPLIED>
+
+<!ELEMENT msg (#PCDATA|ph|source)*>
+<!ATTLIST msg id CDATA #IMPLIED>
+<!ATTLIST msg seq CDATA #IMPLIED>
+<!ATTLIST msg name CDATA #IMPLIED>
+<!ATTLIST msg desc CDATA #IMPLIED>
+<!ATTLIST msg meaning CDATA #IMPLIED>
+<!ATTLIST msg obsolete (obsolete) #IMPLIED>
+<!ATTLIST msg xml:space (default|preserve) "default">
+<!ATTLIST msg is_hidden CDATA #IMPLIED>
+
+<!ELEMENT source (#PCDATA)>
+
+<!ELEMENT ph (#PCDATA|ex)*>
+<!ATTLIST ph name CDATA #REQUIRED>
+
+<!ELEMENT ex (#PCDATA)>
+]>
+<messagebundle>
+  <msg id="8136548302122759730" desc="desc" meaning="meaning">translate me</msg>
+  <msg id="3492007542396725315">Welcome</msg>
+  <msg id="3772663375917578720">other-3rdP-component</msg>
+</messagebundle>
+`;
+
+const EXPECTED_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
+<xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
+  <file source-language="fr" datatype="plaintext" original="ng2.template">
+    <body>
+      <trans-unit id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4" datatype="html">
+        <source>translate me</source>
+        <target/>
+        <note priority="1" from="description">desc</note>
+        <note priority="1" from="meaning">meaning</note>
+      </trans-unit>
+      <trans-unit id="65cc4ab3b4c438e07c89be2b677d08369fb62da2" datatype="html">
+        <source>Welcome</source>
+        <target/>
+      </trans-unit>
+      <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
+        <source>other-3rdP-component</source>
+        <target/>
+      </trans-unit>
+    </body>
+  </file>
+</xliff>
+`;
+
+describe('template i18n extraction output', () => {
+  const outDir = '';
+  const genDir = 'out';
+
+  it('should extract i18n messages as xmb', () => {
+    const xmbOutput = path.join(outDir, 'custom_file.xmb');
+    expect(fs.existsSync(xmbOutput)).toBeTruthy();
+    const xmb = fs.readFileSync(xmbOutput, {encoding: 'utf-8'});
+    expect(xmb).toEqual(EXPECTED_XMB);
+  });
+
+  it('should extract i18n messages as xliff', () => {
+    const xlfOutput = path.join(outDir, 'messages.xlf');
+    expect(fs.existsSync(xlfOutput)).toBeTruthy();
+    const xlf = fs.readFileSync(xlfOutput, {encoding: 'utf-8'});
+    expect(xlf).toEqual(EXPECTED_XLIFF);
+  });
+
+  it('should not emit js', () => {
+    const genOutput = path.join(genDir, '');
+    expect(fs.existsSync(genOutput)).toBeFalsy();
+  });
+});
--- a/packages/compiler-cli/integrationtest/test/init.ts
+++ b/packages/compiler-cli/integrationtest/test/init.ts
@ -0,0 +1,17 @@
+/**
+ * @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
+ */
+
+// Only needed to satisfy the check in core/src/util/decorators.ts
+// TODO(alexeagle): maybe remove that check?
+require('reflect-metadata');
+
+require('zone.js/dist/zone-node.js');
+require('zone.js/dist/long-stack-trace-zone.js');
+require('zone.js/dist/sync-test.js');
+require('zone.js/dist/proxy.js');
+require('zone.js/dist/jasmine-patch.js');
--- a/packages/compiler-cli/integrationtest/test/ng_module_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/ng_module_spec.ts
@ -0,0 +1,83 @@
+/**
+ * @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 './init';
+
+import {ComponentUsingThirdParty} from '../src/comp_using_3rdp';
+import {MainModule} from '../src/module';
+import {CompUsingLibModuleDirectiveAndPipe, CompUsingRootModuleDirectiveAndPipe, SOME_TOKEN, ServiceUsingLibModule, SomeLibModule, SomeService} from '../src/module_fixtures';
+
+import {createComponent, createModule} from './util';
+
+describe('NgModule', () => {
+  it('should support providers', () => {
+    const moduleRef = createModule();
+    expect(moduleRef.instance instanceof MainModule).toEqual(true);
+    expect(moduleRef.injector.get(MainModule) instanceof MainModule).toEqual(true);
+    expect(moduleRef.injector.get(SomeService) instanceof SomeService).toEqual(true);
+  });
+
+  it('should support entryComponents components', () => {
+    const moduleRef = createModule();
+    const cf = moduleRef.componentFactoryResolver.resolveComponentFactory(
+        CompUsingRootModuleDirectiveAndPipe);
+    expect(cf.componentType).toBe(CompUsingRootModuleDirectiveAndPipe);
+    const compRef = cf.create(moduleRef.injector);
+    expect(compRef.instance instanceof CompUsingRootModuleDirectiveAndPipe).toEqual(true);
+  });
+
+  it('should support entryComponents via the ANALYZE_FOR_ENTRY_COMPONENTS provider and function providers in components',
+     () => {
+       const moduleRef = createModule();
+       const cf = moduleRef.componentFactoryResolver.resolveComponentFactory(
+           CompUsingRootModuleDirectiveAndPipe);
+       expect(cf.componentType).toBe(CompUsingRootModuleDirectiveAndPipe);
+       // check that the function call that created the provider for ANALYZE_FOR_ENTRY_COMPONENTS
+       // worked.
+       expect(moduleRef.injector.get(SOME_TOKEN)).toEqual([
+         {a: 'b', component: CompUsingLibModuleDirectiveAndPipe}
+       ]);
+     });
+
+  describe('third-party modules', () => {
+    // https://github.com/angular/angular/issues/11889
+    it('should support third party entryComponents components', () => {
+      const fixture = createComponent(ComponentUsingThirdParty);
+      const thirdPComps = fixture.nativeElement.children;
+      expect(thirdPComps[0].children[0].children[0].data).toEqual('3rdP-component');
+      expect(thirdPComps[1].children[0].children[0].data).toEqual('other-3rdP-component');
+    });
+
+    // https://github.com/angular/angular/issues/12428
+    it('should support third party directives', () => {
+      const fixture = createComponent(ComponentUsingThirdParty);
+      const debugElement = fixture.debugElement;
+      fixture.detectChanges();
+      expect(debugElement.children[0].properties['title']).toEqual('from 3rd party');
+    });
+  });
+
+  it('should support module directives and pipes', () => {
+    const compFixture = createComponent(CompUsingRootModuleDirectiveAndPipe);
+    compFixture.detectChanges();
+
+    const debugElement = compFixture.debugElement;
+    expect(debugElement.children[0].properties['title']).toEqual('transformed someValue');
+  });
+
+  it('should support module directives and pipes on lib modules', () => {
+    const compFixture = createComponent(CompUsingLibModuleDirectiveAndPipe);
+    compFixture.detectChanges();
+
+    const debugElement = compFixture.debugElement;
+    expect(debugElement.children[0].properties['title']).toEqual('transformed someValue');
+
+    expect(debugElement.injector.get(SomeLibModule) instanceof SomeLibModule).toEqual(true);
+    expect(debugElement.injector.get(ServiceUsingLibModule) instanceof ServiceUsingLibModule)
+        .toEqual(true);
+  });
+});
--- a/packages/compiler-cli/integrationtest/test/projection_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/projection_spec.ts
@ -0,0 +1,23 @@
+/**
+ * @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 './init';
+import {By} from '@angular/platform-browser';
+import {CompWithNgContent, ProjectingComp} from '../src/projection';
+import {createComponent} from './util';
+
+describe('content projection', () => {
+  it('should support basic content projection', () => {
+    const mainCompFixture = createComponent(ProjectingComp);
+
+    const debugElement = mainCompFixture.debugElement;
+    const compWithProjection = debugElement.query(By.directive(CompWithNgContent));
+    expect(compWithProjection.children.length).toBe(1);
+    expect(compWithProjection.children[0].attributes['greeting']).toEqual('Hello world!');
+  });
+});
--- a/packages/compiler-cli/integrationtest/test/query_spec.ts
+++ b/packages/compiler-cli/integrationtest/test/query_spec.ts
@ -0,0 +1,35 @@
+/**
+ * @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 './init';
+import {DebugElement, QueryList} from '@angular/core';
+import {By} from '@angular/platform-browser';
+import {CompForChildQuery, CompWithChildQuery} from '../src/queries';
+import {createComponent} from './util';
+
+describe('child queries', () => {
+  it('should support compiling child queries', () => {
+    const childQueryCompFixture = createComponent(CompWithChildQuery);
+    const debugElement = childQueryCompFixture.debugElement;
+    const compWithChildren = debugElement.query(By.directive(CompWithChildQuery));
+    expect(childQueryCompFixture.componentInstance.child).toBeDefined();
+    expect(childQueryCompFixture.componentInstance.child instanceof CompForChildQuery).toBe(true);
+
+  });
+
+  it('should support compiling children queries', () => {
+    const childQueryCompFixture = createComponent(CompWithChildQuery);
+    const debugElement = childQueryCompFixture.debugElement;
+    const compWithChildren = debugElement.query(By.directive(CompWithChildQuery));
+
+    childQueryCompFixture.detectChanges();
+
+    expect(childQueryCompFixture.componentInstance.children).toBeDefined();
+    expect(childQueryCompFixture.componentInstance.children instanceof QueryList).toBe(true);
+  });
+});
--- a/packages/compiler-cli/integrationtest/test/test_ngtools_api.ts
+++ b/packages/compiler-cli/integrationtest/test/test_ngtools_api.ts
@ -0,0 +1,219 @@
+#!/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
+ */
+/* tslint:disable:no-console  */
+
+// Must be imported first, because angular2 decorators throws on load.
+import 'reflect-metadata';
+
+import * as path from 'path';
+import * as ts from 'typescript';
+import * as assert from 'assert';
+import {tsc} from '@angular/tsc-wrapped/src/tsc';
+import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompilerHostContext, __NGTOOLS_PRIVATE_API_2} from '@angular/compiler-cli';
+
+const glob = require('glob');
+
+/**
+ * Main method.
+ * Standalone program that executes codegen using the ngtools API and tests that files were
+ * properly read and wrote.
+ */
+function main() {
+  console.log(`testing ngtools API...`);
+
+  Promise.resolve()
+      .then(() => codeGenTest())
+      .then(() => i18nTest())
+      .then(() => lazyRoutesTest())
+      .then(() => {
+        console.log('All done!');
+        process.exit(0);
+      })
+      .catch((err) => {
+        console.error(err.stack);
+        console.error('Test failed');
+        process.exit(1);
+      });
+}
+
+function codeGenTest() {
+  const basePath = path.join(__dirname, '../ngtools_src');
+  const project = path.join(basePath, 'tsconfig-build.json');
+  const readResources: string[] = [];
+  const wroteFiles: string[] = [];
+
+  const config = tsc.readConfiguration(project, basePath);
+  const hostContext = new NodeCompilerHostContext();
+  const delegateHost = ts.createCompilerHost(config.parsed.options, true);
+  const host: ts.CompilerHost = Object.assign(
+      {}, delegateHost,
+      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
+  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
+
+  config.ngOptions.basePath = basePath;
+
+  console.log(`>>> running codegen for ${project}`);
+  return __NGTOOLS_PRIVATE_API_2
+      .codeGen({
+        basePath,
+        compilerOptions: config.parsed.options, program, host,
+
+        angularCompilerOptions: config.ngOptions,
+
+        // i18n options.
+        i18nFormat: null,
+        i18nFile: null,
+        locale: null,
+
+        readResource: (fileName: string) => {
+          readResources.push(fileName);
+          return hostContext.readResource(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: any) => {
+        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 = tsc.readConfiguration(project, basePath);
+  const hostContext = new NodeCompilerHostContext();
+  const delegateHost = ts.createCompilerHost(config.parsed.options, true);
+  const host: ts.CompilerHost = Object.assign(
+      {}, delegateHost,
+      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
+  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
+
+  config.ngOptions.basePath = basePath;
+
+  console.log(`>>> running i18n extraction for ${project}`);
+  return __NGTOOLS_PRIVATE_API_2
+      .extractI18n({
+        basePath,
+        compilerOptions: config.parsed.options, program, host,
+        angularCompilerOptions: config.ngOptions,
+        i18nFormat: 'xlf',
+        locale: null,
+        outFile: null,
+        readResource: (fileName: string) => {
+          readResources.push(fileName);
+          return hostContext.readResource(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: any) => {
+        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');
+
+  const config = tsc.readConfiguration(project, basePath);
+  const host = ts.createCompilerHost(config.parsed.options, true);
+  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
+
+  config.ngOptions.basePath = basePath;
+
+  const lazyRoutes = __NGTOOLS_PRIVATE_API_2.listLazyRoutes({
+    program,
+    host,
+    angularCompilerOptions: config.ngOptions,
+    entryModule: 'app.module#AppModule'
+  });
+
+  const expectations: {[route: string]: string} = {
+    './lazy.module#LazyModule': 'lazy.module.ts',
+    './feature/feature.module#FeatureModule': 'feature/feature.module.ts',
+    './feature/lazy-feature.module#LazyFeatureModule': 'feature/lazy-feature.module.ts',
+    './feature.module#FeatureModule': 'feature/feature.module.ts',
+    './lazy-feature-nested.module#LazyFeatureNestedModule': 'feature/lazy-feature-nested.module.ts',
+    'feature2/feature2.module#Feature2Module': 'feature2/feature2.module.ts',
+    './default.module': 'feature2/default.module.ts',
+    'feature/feature.module#FeatureModule': 'feature/feature.module.ts'
+  };
+
+  Object.keys(lazyRoutes).forEach((route: string) => {
+    assert(route in expectations, `Found a route that was not expected: "${route}".`);
+    assert(
+        lazyRoutes[route] == path.join(basePath, expectations[route]),
+        `Route "${route}" does not point to the expected absolute path ` +
+            `"${path.join(basePath, expectations[route])}". It points to "${lazyRoutes[route]}"`);
+  });
+
+  // Verify that all expectations were met.
+  assert.deepEqual(
+      Object.keys(lazyRoutes), Object.keys(expectations), `Expected routes listed to be: \n` +
+          `  ${JSON.stringify(Object.keys(expectations))}\n` +
+          `Actual:\n` +
+          `  ${JSON.stringify(Object.keys(lazyRoutes))}\n`);
+}
+
+main();
--- a/packages/compiler-cli/integrationtest/test/test_summaries.ts
+++ b/packages/compiler-cli/integrationtest/test/test_summaries.ts
@ -0,0 +1,126 @@
+#!/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
+ */
+/* tslint:disable:no-console  */
+
+// Must be imported first, because angular2 decorators throws on load.
+import 'reflect-metadata';
+
+import * as path from 'path';
+import * as ts from 'typescript';
+import * as assert from 'assert';
+import {tsc} from '@angular/tsc-wrapped/src/tsc';
+import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompilerHostContext} from '@angular/compiler-cli';
+
+/**
+ * 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
+        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 = tsc.readConfiguration(project, basePath);
+  config.ngOptions.basePath = basePath;
+  // This flag tells ngc do not recompile libraries.
+  config.ngOptions.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 tsc-wrapped main to just run codegen with a CompilerHostContext
+ */
+function codegen(
+    config: {parsed: ts.ParsedCommandLine, ngOptions: AngularCompilerOptions},
+    hostContextFactory: (host: ts.CompilerHost) => CompilerHostContext) {
+  const host = ts.createCompilerHost(config.parsed.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.parsed.fileNames, config.parsed.options, host);
+
+  return CodeGenerator.create(config.ngOptions, {
+                      } 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();
--- a/packages/compiler-cli/integrationtest/test/util.ts
+++ b/packages/compiler-cli/integrationtest/test/util.ts
@ -0,0 +1,33 @@
+/**
+ * @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 {NgModuleFactory, NgModuleRef} from '@angular/core';
+import {ComponentFixture} from '@angular/core/testing';
+import {platformServer} from '@angular/platform-server';
+
+import {MainModule} from '../src/module';
+import {MainModuleNgFactory} from '../src/module.ngfactory';
+
+let mainModuleRef: NgModuleRef<MainModule> = null;
+beforeEach((done) => {
+  platformServer().bootstrapModuleFactory(MainModuleNgFactory).then((moduleRef: any) => {
+    mainModuleRef = moduleRef;
+    done();
+  });
+});
+
+export function createModule(): NgModuleRef<MainModule> {
+  return mainModuleRef;
+}
+
+export function createComponent<C>(comp: {new (...args: any[]): C}): ComponentFixture<C> {
+  const moduleRef = createModule();
+  const compRef =
+      moduleRef.componentFactoryResolver.resolveComponentFactory(comp).create(moduleRef.injector);
+  return new ComponentFixture(compRef, null, null);
+}
--- a/packages/compiler-cli/integrationtest/third_party_src/README.md
+++ b/packages/compiler-cli/integrationtest/third_party_src/README.md
@ -0,0 +1,8 @@
+This folder emulates consuming precompiled modules and components.
+It is compiled separately from the other sources under `src`
+to only generate `*.js` / `*.d.ts` / `*.metadata.json` files,
+but no `*.ngfactory.ts` files.
+
+** WARNING **
+Do not import components/directives from here directly as we want to test that ngc still compiles 
+them when they are not imported.
--- a/packages/compiler-cli/integrationtest/third_party_src/comp.ts
+++ b/packages/compiler-cli/integrationtest/third_party_src/comp.ts
@ -0,0 +1,16 @@
+/**
+ * @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 {Component} from '@angular/core';
+
+@Component({
+  selector: 'third-party-comp',
+  template: '<div>3rdP-component</div>',
+})
+export class ThirdPartyComponent {
+}
--- a/packages/compiler-cli/integrationtest/third_party_src/directive.ts
+++ b/packages/compiler-cli/integrationtest/third_party_src/directive.ts
@ -0,0 +1,17 @@
+/**
+ * @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 {Directive, Input} from '@angular/core';
+
+@Directive({
+  selector: '[thirdParty]',
+  host: {'[title]': 'thirdParty'},
+})
+export class ThirdPartyDirective {
+  @Input() thirdParty: string;
+}
--- a/packages/compiler-cli/integrationtest/third_party_src/module.ts
+++ b/packages/compiler-cli/integrationtest/third_party_src/module.ts
@ -0,0 +1,28 @@
+/**
+ * @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 {NgModule} from '@angular/core';
+
+import {ThirdPartyComponent} from './comp';
+import {ThirdPartyDirective} from './directive';
+import {AnotherThirdPartyModule} from './other_module';
+
+@NgModule({
+  declarations: [
+    ThirdPartyComponent,
+    ThirdPartyDirective,
+  ],
+  exports: [
+    AnotherThirdPartyModule,
+    ThirdPartyComponent,
+    ThirdPartyDirective,
+  ],
+  imports: [AnotherThirdPartyModule]
+})
+export class ThirdpartyModule {
+}
--- a/packages/compiler-cli/integrationtest/third_party_src/other_comp.ts
+++ b/packages/compiler-cli/integrationtest/third_party_src/other_comp.ts
@ -0,0 +1,16 @@
+/**
+ * @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 {Component} from '@angular/core';
+
+@Component({
+  selector: 'another-third-party-comp',
+  template: '<div i18n>other-3rdP-component</div>',
+})
+export class AnotherThirdpartyComponent {
+}
--- a/packages/compiler-cli/integrationtest/third_party_src/other_module.ts
+++ b/packages/compiler-cli/integrationtest/third_party_src/other_module.ts
@ -0,0 +1,17 @@
+/**
+ * @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 {NgModule} from '@angular/core';
+import {AnotherThirdpartyComponent} from './other_comp';
+
+@NgModule({
+  declarations: [AnotherThirdpartyComponent],
+  exports: [AnotherThirdpartyComponent],
+})
+export class AnotherThirdPartyModule {
+}
--- a/packages/compiler-cli/integrationtest/third_party_src/tsconfig-build.json
+++ b/packages/compiler-cli/integrationtest/third_party_src/tsconfig-build.json
@ -0,0 +1,22 @@
+{
+  "angularCompilerOptions": {
+    // For TypeScript 1.8, we have to lay out generated files
+    // in the same source directory with your code.
+    "genDir": ".",
+    "debug": true
+  },
+
+  "compilerOptions": {
+    "target": "es5",
+    "experimentalDecorators": true,
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "rootDir": "",
+    "declaration": true,
+    "lib": ["es6", "dom"],
+    "baseUrl": ".",
+    "outDir": "../node_modules/third_party",
+     // Prevent scanning up the directory tree for types
+    "typeRoots": ["node_modules/@types"]
+ }
+}
--- a/packages/compiler-cli/integrationtest/tsconfig-build.json
+++ b/packages/compiler-cli/integrationtest/tsconfig-build.json
@ -0,0 +1,33 @@
+{
+  "angularCompilerOptions": {
+    // For TypeScript 1.8, we have to lay out generated files
+    // in the same source directory with your code.
+    "genDir": ".",
+    "debug": true
+  },
+
+  "compilerOptions": {
+    "target": "es5",
+    "experimentalDecorators": true,
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "rootDir": "",
+    "declaration": true,
+    "lib": ["es6", "dom"],
+    "baseUrl": ".",
+    // Prevent scanning up the directory tree for types
+    "typeRoots": ["node_modules/@types"]
+  },
+
+  "files": [
+    "src/module",
+    "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",
+    "benchmarks/src/largetable/ng2_switch/index_aot.ts"
+  ]
+}
--- a/packages/compiler-cli/integrationtest/tsconfig-xi18n.json
+++ b/packages/compiler-cli/integrationtest/tsconfig-xi18n.json
@ -0,0 +1,34 @@
+{
+  "angularCompilerOptions": {
+    // For TypeScript 1.8, we have to lay out generated files
+    // in the same source directory with your code.
+    "genDir": ".",
+    "debug": true
+  },
+
+  "compilerOptions": {
+    "target": "es5",
+    "experimentalDecorators": true,
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "outDir": "./out",
+    "rootDir": "",
+    "declaration": true,
+    "lib": ["es6", "dom"],
+    "baseUrl": ".",
+    // Prevent scanning up the directory tree for types
+    "typeRoots": ["node_modules/@types"]
+  },
+
+  "files": [
+    "src/module",
+    "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",
+    "benchmarks/src/largetable/ng2_switch/index_aot.ts"
+  ]
+}
--- a/packages/compiler-cli/integrationtest/webpack.config.js
+++ b/packages/compiler-cli/integrationtest/webpack.config.js
@ -0,0 +1,15 @@
+/**
+ * @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
+ */
+
+module.exports = {
+  target: 'node',
+  entry: './test/all_spec.js',
+  output: {filename: './all_spec.js'},
+  resolve: {extensions: ['.js']},
+
+};
--- a/packages/compiler-cli/package.json
+++ b/packages/compiler-cli/package.json
@ -0,0 +1,38 @@
+{
+  "name": "@angular/compiler-cli",
+  "version": "0.0.0-PLACEHOLDER",
+  "description": "Angular - the compiler CLI for Node.js",
+  "main": "index.js",
+  "typings": "./typings/index.d.ts",
+  "bin": {
+    "ngc": "./src/main.js",
+    "ng-xi18n": "./src/extract_i18n.js"
+  },
+  "dependencies": {
+    "@angular/tsc-wrapped": "4.0.0-rc.2",
+    "reflect-metadata": "^0.1.2",
+    "minimist": "^1.2.0"
+  },
+  "peerDependencies": {
+    "typescript": "^2.0.2",
+    "@angular/compiler": "0.0.0-PLACEHOLDER",
+    "@angular/core": "0.0.0-PLACEHOLDER"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/angular/angular.git"
+  },
+  "keywords": [
+    "angular",
+    "compiler"
+  ],
+  "contributors": [
+    "Tobias Bosch <tbosch@google.com> (https://angular.io/)",
+    "Alex Eagle <alexeagle@google.com> (https://angular.io/)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/angular/angular/issues"
+  },
+  "homepage": "https://github.com/angular/angular/tree/master/modules/@angular/compiler-cli"
+}
--- a/packages/compiler-cli/src/codegen.ts
+++ b/packages/compiler-cli/src/codegen.ts
@ -0,0 +1,82 @@
+/**
+ * @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 {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
+import {readFileSync} from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
+import {PathMappedCompilerHost} from './path_mapped_compiler_host';
+
+const GENERATED_META_FILES = /\.json$/;
+
+const PREAMBLE = `/**
+ * @fileoverview This file is generated by the Angular template compiler.
+ * Do not edit.
+ * @suppress {suspiciousCode,uselessCode,missingProperties}
+ */
+ /* tslint:disable */
+
+`;
+
+export class CodeGenerator {
+  constructor(
+      private options: AngularCompilerOptions, private program: ts.Program,
+      public host: ts.CompilerHost, private compiler: compiler.AotCompiler,
+      private ngCompilerHost: CompilerHost) {}
+
+  codegen(): Promise<any> {
+    return this.compiler
+        .compileAll(this.program.getSourceFiles().map(
+            sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)))
+        .then(generatedModules => {
+          generatedModules.forEach(generatedModule => {
+            const sourceFile = this.program.getSourceFile(generatedModule.srcFileUrl);
+            const emitPath = this.ngCompilerHost.calculateEmitPath(generatedModule.genFileUrl);
+            const source = GENERATED_META_FILES.test(emitPath) ? generatedModule.source :
+                                                                 PREAMBLE + generatedModule.source;
+            this.host.writeFile(emitPath, source, false, () => {}, [sourceFile]);
+          });
+        });
+  }
+
+  static create(
+      options: AngularCompilerOptions, cliOptions: NgcCliOptions, 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);
+    }
+    const transFile = cliOptions.i18nFile;
+    const locale = cliOptions.locale;
+    let transContent: string = '';
+    if (transFile) {
+      if (!locale) {
+        throw new Error(
+            `The translation file (${transFile}) locale must be provided. Use the --locale option.`);
+      }
+      transContent = readFileSync(transFile, 'utf8');
+    }
+    const {compiler: aotCompiler} = compiler.createAotCompiler(ngCompilerHost, {
+      translations: transContent,
+      i18nFormat: cliOptions.i18nFormat,
+      locale: cliOptions.locale,
+      enableLegacyTemplate: options.enableLegacyTemplate !== false,
+    });
+    return new CodeGenerator(options, program, tsCompilerHost, aotCompiler, ngCompilerHost);
+  }
+}
--- a/packages/compiler-cli/src/compiler_host.ts
+++ b/packages/compiler-cli/src/compiler_host.ts
@ -0,0 +1,411 @@
+/**
+ * @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} from '@angular/compiler';
+import {AngularCompilerOptions, CollectorOptions, MetadataCollector, ModuleMetadata} from '@angular/tsc-wrapped';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
+const DTS = /\.d\.ts$/;
+const NODE_MODULES = '/node_modules/';
+const IS_GENERATED = /\.(ngfactory|ngstyle)$/;
+const GENERATED_FILES = /\.ngfactory\.ts$|\.ngstyle\.ts$/;
+const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.ngstyle\.ts$/;
+const SHALLOW_IMPORT = /^((\w|-)+|(@(\w|-)+(\/(\w|-)+)+))$/;
+
+export interface CompilerHostContext extends ts.ModuleResolutionHost {
+  readResource(fileName: string): Promise<string>;
+  assumeFileExists(fileName: string): void;
+}
+
+export class CompilerHost implements AotCompilerHost {
+  protected metadataCollector = new MetadataCollector();
+  private isGenDirChildOfRootDir: boolean;
+  protected basePath: string;
+  private genDir: string;
+  private resolverCache = new Map<string, ModuleMetadata[]>();
+  private bundleIndexCache = new Map<string, boolean>();
+  private bundleIndexNames = new Set<string>();
+  protected resolveModuleNameHost: CompilerHostContext;
+
+  constructor(
+      protected program: ts.Program, protected options: AngularCompilerOptions,
+      protected context: CompilerHostContext, collectorOptions?: 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;
+    };
+  }
+
+  // We use absolute paths on disk as canonical.
+  getCanonicalFileName(fileName: string): string { 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'));
+    }
+    m = m.replace(EXT, '');
+    const resolved =
+        ts.resolveModuleName(
+              m, containingFile.replace(/\\/g, '/'), this.options, this.resolveModuleNameHost)
+            .resolvedModule;
+    return resolved ? this.getCanonicalFileName(resolved.resolvedFileName) : 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.
+   *
+   * 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 (!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);
+      }
+    }
+  }
+
+  private dotRelative(from: string, to: string): string {
+    const rPath: string = path.relative(from, to).replace(/\\/g, '/');
+    return rPath.startsWith('.') ? rPath : './' + rPath;
+  }
+
+  /**
+   * 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_modulse, 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);
+    }
+  }
+
+  protected getSourceFile(filePath: string): ts.SourceFile {
+    const sf = this.program.getSourceFile(filePath);
+    if (!sf) {
+      if (this.context.fileExists(filePath)) {
+        const sourceText = this.context.readFile(filePath);
+        return ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
+      }
+      throw new Error(`Source file ${filePath} not present in program.`);
+    }
+    return sf;
+  }
+
+  getMetadataFor(filePath: string): ModuleMetadata[] {
+    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 refernced a declared module for which no file
+      // exists for the module (i.e. jQuery or angularjs).
+      return;
+    }
+    if (DTS.test(filePath)) {
+      const metadataPath = filePath.replace(DTS, '.metadata.json');
+      if (this.context.fileExists(metadataPath)) {
+        return this.readMetadata(metadataPath, filePath);
+      } else {
+        // If there is a .d.ts file but no metadata file we need to produce a
+        // v3 metadata from the .d.ts file as v3 includes the exports we need
+        // to resolve symbols.
+        return [this.upgradeVersion1Metadata(
+            {'__symbolic': 'module', 'version': 1, 'metadata': {}}, filePath)];
+      }
+    } else {
+      const sf = this.getSourceFile(filePath);
+      const metadata = this.metadataCollector.getMetadata(sf);
+      return metadata ? [metadata] : [];
+    }
+  }
+
+  readMetadata(filePath: string, dtsFilePath: string): ModuleMetadata[] {
+    let metadatas = this.resolverCache.get(filePath);
+    if (metadatas) {
+      return metadatas;
+    }
+    try {
+      const metadataOrMetadatas = JSON.parse(this.context.readFile(filePath));
+      const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
+          (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
+          [];
+      const v1Metadata = metadatas.find(m => m.version === 1);
+      let v3Metadata = metadatas.find(m => m.version === 3);
+      if (!v3Metadata && v1Metadata) {
+        metadatas.push(this.upgradeVersion1Metadata(v1Metadata, dtsFilePath));
+      }
+      this.resolverCache.set(filePath, metadatas);
+      return metadatas;
+    } catch (e) {
+      console.error(`Failed to read JSON file ${filePath}`);
+      throw e;
+    }
+  }
+
+  private upgradeVersion1Metadata(v1Metadata: ModuleMetadata, dtsFilePath: string): ModuleMetadata {
+    // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
+    // as the only difference between the versions is whether all exports are contained in
+    // the metadata and the `extends` clause.
+    let v3Metadata: ModuleMetadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
+    if (v1Metadata.exports) {
+      v3Metadata.exports = v1Metadata.exports;
+    }
+    for (let prop in v1Metadata.metadata) {
+      v3Metadata.metadata[prop] = v1Metadata.metadata[prop];
+    }
+
+    const exports = this.metadataCollector.getMetadata(this.getSourceFile(dtsFilePath));
+    if (exports) {
+      for (let prop in exports.metadata) {
+        if (!v3Metadata.metadata[prop]) {
+          v3Metadata.metadata[prop] = exports.metadata[prop];
+        }
+      }
+      if (exports.exports) {
+        v3Metadata.exports = exports.exports;
+      }
+    }
+    return v3Metadata;
+  }
+
+  loadResource(filePath: string): Promise<string> { return this.context.readResource(filePath); }
+
+  loadSummary(filePath: string): string|null {
+    if (this.context.fileExists(filePath)) {
+      return this.context.readFile(filePath);
+    }
+  }
+
+  getOutputFileName(sourceFilePath: string): string {
+    return sourceFilePath.replace(EXT, '') + '.d.ts';
+  }
+
+  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.bundleIndexNames.has(normalFilePath);
+      }
+    }
+    return true;
+  }
+
+  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);
+  }
+
+  private hasBundleIndex(filePath: string): boolean {
+    const checkBundleIndex = (directory: string): boolean => {
+      let result = this.bundleIndexCache.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.importAs) {
+                      this.bundleIndexNames.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.bundleIndexCache.set(directory, result);
+      }
+      return result;
+    };
+
+    return checkBundleIndex(path.dirname(filePath));
+  }
+}
+
+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));
+  }
+}
--- a/packages/compiler-cli/src/extract_i18n.ts
+++ b/packages/compiler-cli/src/extract_i18n.ts
@ -0,0 +1,41 @@
+#!/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
+ */
+
+
+/**
+ * Extract i18n messages from source code
+ */
+// Must be imported first, because angular2 decorators throws on load.
+import 'reflect-metadata';
+
+import * as tsc from '@angular/tsc-wrapped';
+import * as ts from 'typescript';
+
+import {Extractor} from './extractor';
+
+function extract(
+    ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.I18nExtractionCliOptions,
+    program: ts.Program, host: ts.CompilerHost): Promise<void> {
+  return Extractor.create(ngOptions, program, host, cliOptions.locale)
+      .extract(cliOptions.i18nFormat, cliOptions.outFile);
+}
+
+// Entry point
+if (require.main === module) {
+  const args = require('minimist')(process.argv.slice(2));
+  const project = args.p || args.project || '.';
+  const cliOptions = new tsc.I18nExtractionCliOptions(args);
+  tsc.main(project, cliOptions, extract, {noEmit: true})
+      .then((exitCode: any) => process.exit(exitCode))
+      .catch((e: any) => {
+        console.error(e.stack);
+        console.error('Extraction failed');
+        process.exit(1);
+      });
+}
--- a/packages/compiler-cli/src/extractor.ts
+++ b/packages/compiler-cli/src/extractor.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
+ */
+
+
+/**
+ * Extract i18n messages from source code
+ */
+// Must be imported first, because angular2 decorators throws on load.
+import 'reflect-metadata';
+
+import * as compiler from '@angular/compiler';
+import * as tsc from '@angular/tsc-wrapped';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
+import {PathMappedCompilerHost} from './path_mapped_compiler_host';
+
+export class Extractor {
+  constructor(
+      private options: tsc.AngularCompilerOptions, private ngExtractor: compiler.Extractor,
+      public host: ts.CompilerHost, private ngCompilerHost: CompilerHost,
+      private program: ts.Program) {}
+
+  extract(formatName: string, outFile: string|null): Promise<void> {
+    // Checks the format and returns the extension
+    const ext = this.getExtension(formatName);
+
+    const promiseBundle = this.extractBundle();
+
+    return promiseBundle.then(bundle => {
+      const content = this.serialize(bundle, ext);
+      const dstFile = outFile || `messages.${ext}`;
+      const dstPath = path.join(this.options.genDir, dstFile);
+      this.host.writeFile(dstPath, content, false);
+    });
+  }
+
+  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, ext: string): string {
+    let serializer: compiler.Serializer;
+
+    switch (ext) {
+      case 'xmb':
+        serializer = new compiler.Xmb();
+        break;
+      case 'xlf':
+      default:
+        serializer = new compiler.Xliff();
+    }
+
+    return bundle.write(serializer);
+  }
+
+  getExtension(formatName: string): string {
+    const format = (formatName || 'xlf').toLowerCase();
+
+    if (format === 'xmb') return 'xmb';
+    if (format === 'xlf' || format === 'xlif') return 'xlf';
+
+    throw new Error('Unsupported format "${formatName}"');
+  }
+
+  static create(
+      options: tsc.AngularCompilerOptions, 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);
+  }
+}
--- a/packages/compiler-cli/src/main.ts
+++ b/packages/compiler-cli/src/main.ts
@ -0,0 +1,47 @@
+#!/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 angular2 decorators throws on load.
+import 'reflect-metadata';
+
+import * as ts from 'typescript';
+import * as tsc from '@angular/tsc-wrapped';
+import {isSyntaxError} from '@angular/compiler';
+
+import {CodeGenerator} from './codegen';
+
+function codegen(
+    ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.NgcCliOptions, program: ts.Program,
+    host: ts.CompilerHost) {
+  return CodeGenerator.create(ngOptions, cliOptions, program, host).codegen();
+}
+
+export function main(
+    args: any, consoleError: (s: string) => void = console.error): Promise<number> {
+  const project = args.p || args.project || '.';
+  const cliOptions = new tsc.NgcCliOptions(args);
+
+  return tsc.main(project, cliOptions, codegen).then(() => 0).catch(e => {
+    if (e instanceof tsc.UserError || isSyntaxError(e)) {
+      consoleError(e.message);
+      return Promise.resolve(1);
+    } else {
+      consoleError(e.stack);
+      consoleError('Compilation failed');
+      return Promise.resolve(1);
+    }
+  });
+}
+
+// CLI entry point
+if (require.main === module) {
+  const args = require('minimist')(process.argv.slice(2));
+  main(args).then((exitCode: number) => process.exit(exitCode));
+}
--- a/packages/compiler-cli/src/ngtools_api.ts
+++ b/packages/compiler-cli/src/ngtools_api.ts
@ -0,0 +1,153 @@
+/**
+ * @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, AotSummaryResolver, StaticReflector, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
+import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
+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';
+
+export interface NgTools_InternalApi_NG2_CodeGen_Options {
+  basePath: string;
+  compilerOptions: ts.CompilerOptions;
+  program: ts.Program;
+  host: ts.CompilerHost;
+
+  angularCompilerOptions: AngularCompilerOptions;
+
+  // i18n options.
+  i18nFormat: string;
+  i18nFile: string;
+  locale: string;
+
+  readResource: (fileName: string) => Promise<string>;
+
+  // Every new property under this line should be optional.
+}
+
+export interface NgTools_InternalApi_NG2_ListLazyRoutes_Options {
+  program: ts.Program;
+  host: ts.CompilerHost;
+  angularCompilerOptions: AngularCompilerOptions;
+  entryModule: string;
+
+  // Every new property under this line should be optional.
+}
+
+export interface NgTools_InternalApi_NG_2_LazyRouteMap { [route: string]: string; }
+
+export interface NgTools_InternalApi_NG2_ExtractI18n_Options {
+  basePath: string;
+  compilerOptions: ts.CompilerOptions;
+  program: ts.Program;
+  host: ts.CompilerHost;
+  angularCompilerOptions: AngularCompilerOptions;
+  i18nFormat: string;
+  readResource: (fileName: string) => Promise<string>;
+  // Every new property under this line should be optional.
+  locale?: string;
+  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
+ * @private
+ */
+export class NgTools_InternalApi_NG_2 {
+  /**
+   * @internal
+   * @private
+   */
+  static codeGen(options: NgTools_InternalApi_NG2_CodeGen_Options): Promise<void> {
+    const hostContext: CompilerHostContext =
+        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
+    const cliOptions: NgcCliOptions = {
+      i18nFormat: options.i18nFormat,
+      i18nFile: options.i18nFile,
+      locale: options.locale,
+      basePath: options.basePath
+    };
+
+    // Create the Code Generator.
+    const codeGenerator = CodeGenerator.create(
+        options.angularCompilerOptions, cliOptions, options.program, options.host, hostContext);
+
+    return codeGenerator.codegen();
+  }
+
+  /**
+   * @internal
+   * @private
+   */
+  static listLazyRoutes(options: NgTools_InternalApi_NG2_ListLazyRoutes_Options):
+      NgTools_InternalApi_NG_2_LazyRouteMap {
+    const angularCompilerOptions = options.angularCompilerOptions;
+    const program = options.program;
+
+    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);
+
+    const symbolCache = new StaticSymbolCache();
+    const summaryResolver = new AotSummaryResolver(ngCompilerHost, symbolCache);
+    const symbolResolver = new StaticSymbolResolver(ngCompilerHost, symbolCache, summaryResolver);
+    const staticReflector = new StaticReflector(symbolResolver);
+    const routeMap = listLazyRoutesOfModule(options.entryModule, ngCompilerHost, staticReflector);
+
+    return Object.keys(routeMap).reduce(
+        (acc: NgTools_InternalApi_NG_2_LazyRouteMap, route: string) => {
+          acc[route] = routeMap[route].absoluteFilePath;
+          return acc;
+        },
+        {});
+  }
+
+  /**
+   * @internal
+   * @private
+   */
+  static extractI18n(options: NgTools_InternalApi_NG2_ExtractI18n_Options): Promise<void> {
+    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);
+  }
+}
--- a/packages/compiler-cli/src/ngtools_impl.ts
+++ b/packages/compiler-cli/src/ngtools_impl.ts
@ -0,0 +1,211 @@
+/**
+ * @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} from '@angular/compiler';
+import {NgModule} from '@angular/core';
+
+// 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) {}
+
+  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);
+  }
+}
+
+
+/**
+ *
+ * @returns {LazyRouteMap}
+ * @private
+ */
+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.
+ * @private
+ */
+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.');
+  }
+}
+
+
+/**
+ * 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 allRoutes: any =
+      (moduleMetadata.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 = ((moduleMetadata.imports || []) as any[])
+                              .filter(i => i instanceof StaticSymbol) 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.
+ * @private
+ */
+function _getNgModuleMetadata(staticSymbol: StaticSymbol, reflector: StaticReflector): NgModule {
+  const ngModules = reflector.annotations(staticSymbol).filter((s: any) => s instanceof NgModule);
+  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.
+ * @private
+ */
+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;
+    }
+  }, []);
+}
--- a/packages/compiler-cli/src/path_mapped_compiler_host.ts
+++ b/packages/compiler-cli/src/path_mapped_compiler_host.ts
@ -0,0 +1,139 @@
+/**
+ * @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 {AngularCompilerOptions, ModuleMetadata} from '@angular/tsc-wrapped';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+import {CompilerHost, CompilerHostContext} from './compiler_host';
+
+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: AngularCompilerOptions, 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) {
+    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);
+      }
+    }
+  }
+
+  /**
+   * 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;
+    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 metadataPath = rootedPath.replace(DTS, '.metadata.json');
+        if (this.context.fileExists(metadataPath)) {
+          return this.readMetadata(metadataPath, rootedPath);
+        }
+      } else {
+        const sf = this.getSourceFile(rootedPath);
+        sf.fileName = sf.fileName;
+        const metadata = this.metadataCollector.getMetadata(sf);
+        return metadata ? [metadata] : [];
+      }
+    }
+  }
+}
--- a/packages/compiler-cli/src/version.ts
+++ b/packages/compiler-cli/src/version.ts
@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the common package.
+ */
+
+import {Version} from '@angular/core';
+/**
+ * @stable
+ */
+export const VERSION = new Version('0.0.0-PLACEHOLDER');
--- a/packages/compiler-cli/test/aot_host_spec.ts
+++ b/packages/compiler-cli/test/aot_host_spec.ts
@ -0,0 +1,272 @@
+/**
+ * @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 {ModuleMetadata} from '@angular/tsc-wrapped';
+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: 3, 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 v3 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: 3,
+        metadata: {
+          foo: {__symbolic: 'class'},
+          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 v3', () => {
+    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v1_empty.d.ts')).toEqual([
+      {__symbolic: 'module', version: 3, metadata: {}, exports: [{from: './lib/utils'}]}
+    ]);
+  });
+});
+
+const dummyModule = 'export let foo: any[];';
+const dummyMetadata: ModuleMetadata = {
+  __symbolic: 'module',
+  version: 3,
+  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": 3, "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 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';
+        `
+      }
+    }
+  }
+};
+
+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;
+  }
+}
--- a/packages/compiler-cli/test/main_spec.ts
+++ b/packages/compiler-cli/test/main_spec.ts
@ -0,0 +1,182 @@
+/**
+ * @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 {ɵReflectionCapabilities, ɵreflector} from '@angular/core';
+import {makeTempDir} from '@angular/tsc-wrapped/test/test_support';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import {main} from '../src/main';
+
+
+describe('compiler-cli', () => {
+  let basePath: string;
+  let write: (fileName: string, content: string) => void;
+
+  beforeEach(() => {
+    basePath = makeTempDir();
+    write = (fileName: string, content: string) => {
+      fs.writeFileSync(path.join(basePath, fileName), content, {encoding: 'utf-8'});
+    };
+    write('tsconfig.json', `{
+      "compilerOptions": {
+        "experimentalDecorators": true,
+        "types": [],
+        "outDir": "built",
+        "declaration": true,
+        "module": "es2015",
+        "moduleResolution": "node"
+      },
+      "angularCompilerOptions": {
+        "annotateForClosureCompiler": true
+      },
+      "files": ["test.ts"]
+    }`);
+    const nodeModulesPath = path.resolve(basePath, 'node_modules');
+    fs.mkdirSync(nodeModulesPath);
+    fs.symlinkSync(path.resolve(__dirname, '..', '..'), path.resolve(nodeModulesPath, '@angular'));
+  });
+
+  // Restore reflector since AoT compiler will update it with a new static reflector
+  afterEach(() => { ɵreflector.updateCapabilities(new ɵReflectionCapabilities()); });
+
+  it('should compile without errors', (done) => {
+    write('test.ts', 'export const A = 1;');
+
+    const mockConsole = {error: (s: string) => {}};
+
+    spyOn(mockConsole, 'error');
+
+    main({p: basePath}, mockConsole.error)
+        .then((exitCode) => {
+          expect(mockConsole.error).not.toHaveBeenCalled();
+          expect(exitCode).toEqual(0);
+          done();
+        })
+        .catch(e => done.fail(e));
+  });
+
+  it('should not print the stack trace if user input file does not exist', (done) => {
+    const mockConsole = {error: (s: string) => {}};
+
+    spyOn(mockConsole, 'error');
+
+    main({p: basePath}, mockConsole.error)
+        .then((exitCode) => {
+          expect(mockConsole.error)
+              .toHaveBeenCalledWith(
+                  `Error File '` + path.join(basePath, 'test.ts') + `' not found.`);
+          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
+          expect(exitCode).toEqual(1);
+          done();
+        })
+        .catch(e => done.fail(e));
+  });
+
+  it('should not print the stack trace if user input file is malformed', (done) => {
+    write('test.ts', 'foo;');
+
+    const mockConsole = {error: (s: string) => {}};
+
+    spyOn(mockConsole, 'error');
+
+    main({p: basePath}, mockConsole.error)
+        .then((exitCode) => {
+          expect(mockConsole.error)
+              .toHaveBeenCalledWith(
+                  'Error at ' + path.join(basePath, 'test.ts') + `:1:1: Cannot find name 'foo'.`);
+          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
+          expect(exitCode).toEqual(1);
+          done();
+        })
+        .catch(e => done.fail(e));
+  });
+
+  it('should not print the stack trace if cannot find the imported module', (done) => {
+    write('test.ts', `import {MyClass} from './not-exist-deps';`);
+
+    const mockConsole = {error: (s: string) => {}};
+
+    spyOn(mockConsole, 'error');
+
+    main({p: basePath}, mockConsole.error)
+        .then((exitCode) => {
+          expect(mockConsole.error)
+              .toHaveBeenCalledWith(
+                  'Error at ' + path.join(basePath, 'test.ts') +
+                  `:1:23: Cannot find module './not-exist-deps'.`);
+          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
+          expect(exitCode).toEqual(1);
+          done();
+        })
+        .catch(e => done.fail(e));
+  });
+
+  it('should not print the stack trace if cannot import', (done) => {
+    write('empty-deps.ts', 'export const A = 1;');
+    write('test.ts', `import {MyClass} from './empty-deps';`);
+
+    const mockConsole = {error: (s: string) => {}};
+
+    spyOn(mockConsole, 'error');
+
+    main({p: basePath}, mockConsole.error)
+        .then((exitCode) => {
+          expect(mockConsole.error)
+              .toHaveBeenCalledWith(
+                  'Error at ' + path.join(basePath, 'test.ts') + `:1:9: Module '"` +
+                  path.join(basePath, 'empty-deps') + `"' has no exported member 'MyClass'.`);
+          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
+          expect(exitCode).toEqual(1);
+          done();
+        })
+        .catch(e => done.fail(e));
+  });
+
+  it('should not print the stack trace if type mismatches', (done) => {
+    write('empty-deps.ts', 'export const A = "abc";');
+    write('test.ts', `
+      import {A} from './empty-deps';
+      A();
+    `);
+
+    const mockConsole = {error: (s: string) => {}};
+
+    spyOn(mockConsole, 'error');
+
+    main({p: basePath}, mockConsole.error)
+        .then((exitCode) => {
+          expect(mockConsole.error)
+              .toHaveBeenCalledWith(
+                  'Error at ' + path.join(basePath, 'test.ts') +
+                  ':3:7: Cannot invoke an expression whose type lacks a call signature. ' +
+                  'Type \'String\' has no compatible call signatures.');
+          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
+          expect(exitCode).toEqual(1);
+          done();
+        })
+        .catch(e => done.fail(e));
+  });
+
+  it('should print the stack trace on compiler internal errors', (done) => {
+    write('test.ts', 'export const A = 1;');
+
+    const mockConsole = {error: (s: string) => {}};
+
+    spyOn(mockConsole, 'error');
+
+    main({p: 'not-exist'}, mockConsole.error)
+        .then((exitCode) => {
+          expect(mockConsole.error).toHaveBeenCalled();
+          expect(mockConsole.error).toHaveBeenCalledWith('Compilation failed');
+          expect(exitCode).toEqual(1);
+          done();
+        })
+        .catch(e => done.fail(e));
+  });
+});
--- a/packages/compiler-cli/test/mocks.ts
+++ b/packages/compiler-cli/test/mocks.ts
@ -0,0 +1,136 @@
+/**
+ * @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 {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 {
+  constructor(public currentDirectory: string, private files: Entry) {}
+
+  fileExists(fileName: string): boolean { return typeof this.getEntry(fileName) === 'string'; }
+
+  directoryExists(path: string): boolean { return typeof this.getEntry(path) === 'object'; }
+
+  readFile(fileName: string): string|undefined {
+    const data = this.getEntry(fileName);
+    if (typeof data === 'string') {
+      return data;
+    }
+    return undefined;
+  }
+
+  readResource(fileName: string): Promise<string> {
+    const result = this.readFile(fileName);
+    if (result == null) {
+      return Promise.reject(new Error(`Resource not found: ${fileName}`));
+    }
+    return Promise.resolve(result);
+  }
+
+  writeFile(fileName: string, data: string): void {
+    const parts = fileName.split('/');
+    const name = parts.pop();
+    const entry = this.getEntry(parts);
+    if (entry && typeof entry !== 'string') {
+      entry[name] = data;
+    }
+  }
+
+  assumeFileExists(fileName: string): void { this.writeFile(fileName, ''); }
+
+  getEntry(fileName: string|string[]): Entry|undefined {
+    let parts = typeof fileName === 'string' ? fileName.split('/') : fileName;
+    if (parts[0]) {
+      parts = this.currentDirectory.split('/').concat(parts);
+    }
+    parts.shift();
+    parts = normalize(parts);
+    let current = this.files;
+    while (parts.length) {
+      const part = parts.shift();
+      if (typeof current === 'string') {
+        return undefined;
+      }
+      const next = (<Directory>current)[part];
+      if (next === undefined) {
+        return undefined;
+      }
+      current = next;
+    }
+    return current;
+  }
+
+  getDirectories(path: string): string[] {
+    const dir = this.getEntry(path);
+    if (typeof dir !== 'object') {
+      return [];
+    } else {
+      return Object.keys(dir).filter(key => typeof dir[key] === 'object');
+    }
+  }
+}
+
+function normalize(parts: string[]): string[] {
+  const result: string[] = [];
+  while (parts.length) {
+    const part = parts.shift();
+    switch (part) {
+      case '.':
+        break;
+      case '..':
+        result.pop();
+        break;
+      default:
+        result.push(part);
+    }
+  }
+  return result;
+}
+
+export class MockCompilerHost implements ts.CompilerHost {
+  constructor(private context: MockAotContext) {}
+
+  fileExists(fileName: string): boolean { return this.context.fileExists(fileName); }
+
+  readFile(fileName: string): string { return this.context.readFile(fileName); }
+
+  directoryExists(directoryName: string): boolean {
+    return this.context.directoryExists(directoryName);
+  }
+
+  getSourceFile(
+      fileName: string, languageVersion: ts.ScriptTarget,
+      onError?: (message: string) => void): ts.SourceFile {
+    const sourceText = this.context.readFile(fileName);
+    if (sourceText) {
+      return ts.createSourceFile(fileName, sourceText, languageVersion);
+    } else {
+      return undefined;
+    }
+  }
+
+  getDefaultLibFileName(options: ts.CompilerOptions): string {
+    return ts.getDefaultLibFileName(options);
+  }
+
+  writeFile: ts.WriteFileCallback = (fileName, text) => { this.context.writeFile(fileName, text); };
+
+  getCurrentDirectory(): string { return this.context.currentDirectory; }
+
+  getCanonicalFileName(fileName: string): string { return fileName; }
+
+  useCaseSensitiveFileNames(): boolean { return false; }
+
+  getNewLine(): string { return '\n'; }
+
+  getDirectories(path: string): string[] { return this.context.getDirectories(path); }
+}
--- a/packages/compiler-cli/tsconfig-build.json
+++ b/packages/compiler-cli/tsconfig-build.json
@ -0,0 +1,34 @@
+{
+    "compilerOptions": {
+        "baseUrl": ".",
+        "declaration": true,
+        "experimentalDecorators": true,
+        "noImplicitAny": true,
+        "module": "commonjs",
+        "outDir": "../../../dist/packages-dist/compiler-cli",
+        "paths": {
+          "@angular/core": ["../../../dist/packages-dist/core"],
+          "@angular/common": ["../../../dist/packages-dist/common"],
+          "@angular/compiler": ["../../../dist/packages-dist/compiler"],
+          "@angular/http": ["../../../dist/packages-dist/http"],
+          "@angular/platform-server": ["../../../dist/packages-dist/platform-server"],
+          "@angular/platform-browser": ["../../../dist/packages-dist/platform-browser"],
+          "@angular/tsc-wrapped": ["../../../dist/tools/@angular/tsc-wrapped"]
+        },
+        "rootDir": ".",
+        "sourceMap": true,
+        "inlineSources": true,
+        "target": "es5",
+        "lib": ["es6", "dom"],
+        "skipLibCheck": true
+    },
+    "exclude": ["integrationtest"],
+    "files": [
+        "index.ts",
+        "src/main.ts",
+        "src/extract_i18n.ts",
+        "../../../node_modules/@types/node/index.d.ts",
+        "../../../node_modules/@types/jasmine/index.d.ts",
+        "../../../node_modules/zone.js/dist/zone.js.d.ts"
+    ]
+}