refactor(compiler): remove unneeded fields from metadata

Removes `CompileIdentifierMetadata.name` / `.moduleUrl`,
as well as `CompileTypeMetadata.name / moduleUrl` and
`CompileFactoryMetadata.name / moduleUrl`.

modules/@angular/compiler/test/output/js_emitter_spec.ts

@@ -15,9 +15,9 @@ const someModuleUrl = 'somePackage/somePath';
 const anotherModuleUrl = 'somePackage/someOtherPath';
 
 const sameModuleIdentifier =
-    new CompileIdentifierMetadata({name: 'someLocalId', moduleUrl: someModuleUrl});
-const externalModuleIdentifier =
-    new CompileIdentifierMetadata({name: 'someExternalId', moduleUrl: anotherModuleUrl});
+    new CompileIdentifierMetadata({reference: {name: 'someLocalId', filePath: someModuleUrl}});
+const externalModuleIdentifier = new CompileIdentifierMetadata(
+    {reference: {name: 'someExternalId', filePath: anotherModuleUrl}});
 
 class SimpleJsImportGenerator implements ImportResolver {
   fileNameToModuleName(importedUrlStr: string, moduleUrlStr: string): string {

modules/@angular/compiler/test/output/output_emitter_util.ts

@@ -7,7 +7,7 @@
  */
 
 import {CompileIdentifierMetadata} from '@angular/compiler/src/compile_metadata';
-import {assetUrl} from '@angular/compiler/src/identifiers';
+import {assetUrl, createIdentifier} from '@angular/compiler/src/identifiers';
 import * as o from '@angular/compiler/src/output/output_ast';
 import {ImportResolver} from '@angular/compiler/src/output/path_util';
 import {EventEmitter} from '@angular/core';
@@ -20,23 +20,29 @@ export class ExternalClass {
   someMethod(a: any /** TODO #9100 */) { return {'param': a, 'data': this.data}; }
 }
 
-const testDataIdentifier = new CompileIdentifierMetadata({
+const testDataIdentifier = {
   name: 'ExternalClass',
   moduleUrl: `@angular/compiler/test/output/output_emitter_util`,
-  reference: ExternalClass
-});
+  runtime: ExternalClass
+};
 
-const eventEmitterIdentifier = new CompileIdentifierMetadata(
-    {name: 'EventEmitter', moduleUrl: assetUrl('core'), reference: EventEmitter});
+const eventEmitterIdentifier = {
+  name: 'EventEmitter',
+  moduleUrl: assetUrl('core'),
+  runtime: EventEmitter
+};
 
-const enumIdentifier = new CompileIdentifierMetadata({
+const enumIdentifier = {
   name: 'ViewType.HOST',
   moduleUrl: assetUrl('core', 'linker/view_type'),
-  reference: ViewType.HOST
-});
+  runtime: ViewType.HOST
+};
 
-const baseErrorIdentifier = new CompileIdentifierMetadata(
-    {name: 'BaseError', moduleUrl: assetUrl('core', 'facade/errors'), reference: BaseError});
+const baseErrorIdentifier = {
+  name: 'BaseError',
+  moduleUrl: assetUrl('core', 'facade/errors'),
+  runtime: BaseError
+};
 
 export var codegenExportsVars = [
   'getExpressions',
@@ -58,7 +64,7 @@ const _getExpressionsStmts: o.Statement[] = [
   o.variable('map').key(o.literal('changeable')).set(o.literal('changedValue')).toStmt(),
 
   o.variable('externalInstance')
-      .set(o.importExpr(testDataIdentifier).instantiate([o.literal('someValue')]))
+      .set(o.importExpr(createIdentifier(testDataIdentifier)).instantiate([o.literal('someValue')]))
       .toDeclStmt(),
   o.variable('externalInstance').prop('changeable').set(o.literal('changedValue')).toStmt(),
 
@@ -69,8 +75,8 @@ const _getExpressionsStmts: o.Statement[] = [
       .toDeclStmt(),
 
   o.variable('throwError')
-      .set(o.fn([], [new o.ThrowStmt(
-                        o.importExpr(baseErrorIdentifier).instantiate([o.literal('someError')]))]))
+      .set(o.fn([], [new o.ThrowStmt(o.importExpr(createIdentifier(baseErrorIdentifier))
+                                         .instantiate([o.literal('someError')]))]))
       .toDeclStmt(),
 
   o.variable('catchError')
@@ -152,9 +158,9 @@ const _getExpressionsStmts: o.Statement[] = [
 
     ['not', o.not(o.literal(false))],
 
-    ['externalTestIdentifier', o.importExpr(testDataIdentifier)],
-    ['externalSrcIdentifier', o.importExpr(eventEmitterIdentifier)],
-    ['externalEnumIdentifier', o.importExpr(enumIdentifier)],
+    ['externalTestIdentifier', o.importExpr(createIdentifier(testDataIdentifier))],
+    ['externalSrcIdentifier', o.importExpr(createIdentifier(eventEmitterIdentifier))],
+    ['externalEnumIdentifier', o.importExpr(createIdentifier(enumIdentifier))],
 
     ['externalInstance', o.variable('externalInstance')],
     ['dynamicInstance', o.variable('dynamicInstance')],
@@ -188,7 +194,7 @@ export var codegenStmts: o.Statement[] = [
   new o.CommentStmt('This is a comment'),
 
   new o.ClassStmt(
-      'DynamicClass', o.importExpr(testDataIdentifier),
+      'DynamicClass', o.importExpr(createIdentifier(testDataIdentifier)),
       [
         new o.ClassField('dynamicProp', o.DYNAMIC_TYPE),
         new o.ClassField('dynamicChangeable', o.DYNAMIC_TYPE),

modules/@angular/compiler/test/output/ts_emitter_spec.ts

@@ -10,16 +10,15 @@ import {CompileIdentifierMetadata} from '@angular/compiler/src/compile_metadata'
 import * as o from '@angular/compiler/src/output/output_ast';
 import {ImportResolver} from '@angular/compiler/src/output/path_util';
 import {TypeScriptEmitter} from '@angular/compiler/src/output/ts_emitter';
-import {beforeEach, describe, expect, it} from '@angular/core/testing/testing_internal';
 
 const someModuleUrl = 'somePackage/somePath';
 const anotherModuleUrl = 'somePackage/someOtherPath';
 
 const sameModuleIdentifier =
-    new CompileIdentifierMetadata({name: 'someLocalId', moduleUrl: someModuleUrl});
+    new CompileIdentifierMetadata({reference: {name: 'someLocalId', filePath: someModuleUrl}});
 
-const externalModuleIdentifier =
-    new CompileIdentifierMetadata({name: 'someExternalId', moduleUrl: anotherModuleUrl});
+const externalModuleIdentifier = new CompileIdentifierMetadata(
+    {reference: {name: 'someExternalId', filePath: anotherModuleUrl}});
 
 class SimpleJsImportGenerator implements ImportResolver {
   fileNameToModuleName(importedUrlStr: string, moduleUrlStr: string): string {
@@ -323,6 +322,14 @@ export function main() {
       ].join('\n'));
     });
 
+    it('should support expression types', () => {
+      expect(emitStmt(o.variable('a')
+                          .set(o.NULL_EXPR)
+                          .toDeclStmt(o.expressionType(
+                              o.variable('b'), [o.expressionType(o.variable('c'))]))))
+          .toEqual('var a:b<c> = (null as any);');
+    });
+
     it('should support combined types', () => {
       const writeVarExpr = o.variable('a').set(o.NULL_EXPR);
       expect(emitStmt(writeVarExpr.toDeclStmt(new o.ArrayType(null))))