build(ngc): run integration test hermetically

This ensures we run in a clean directory, using our real distribution. It finds bugs like @internal
APIs needed to type-check in the offline compiler, as well as problems in package.json.

Also move tsc-wrapped under tools/@angular

tools/@angular/tsc-wrapped/src/schema.ts

@@ -0,0 +1,138 @@
+export interface ModuleMetadata {
+  __symbolic: 'module';
+  metadata: {[name: string]: (ClassMetadata | MetadataValue)};
+}
+export function isModuleMetadata(value: any): value is ModuleMetadata {
+  return value && value.__symbolic === 'module';
+}
+
+export interface ClassMetadata {
+  __symbolic: 'class';
+  decorators?: MetadataSymbolicExpression[];
+  members?: MetadataMap;
+}
+export function isClassMetadata(value: any): value is ClassMetadata {
+  return value && value.__symbolic === 'class';
+}
+
+export interface MetadataMap { [name: string]: MemberMetadata[]; }
+
+export interface MemberMetadata {
+  __symbolic: 'constructor'|'method'|'property';
+  decorators?: MetadataSymbolicExpression[];
+}
+export function isMemberMetadata(value: any): value is MemberMetadata {
+  if (value) {
+    switch (value.__symbolic) {
+      case 'constructor':
+      case 'method':
+      case 'property':
+        return true;
+    }
+  }
+  return false;
+}
+
+export interface MethodMetadata extends MemberMetadata {
+  __symbolic: 'constructor'|'method';
+  parameterDecorators?: MetadataSymbolicExpression[][];
+}
+export function isMethodMetadata(value: any): value is MemberMetadata {
+  return value && (value.__symbolic === 'constructor' || value.__symbolic === 'method');
+}
+
+export interface ConstructorMetadata extends MethodMetadata {
+  __symbolic: 'constructor';
+  parameters?: MetadataSymbolicExpression[];
+}
+export function isConstructorMetadata(value: any): value is ConstructorMetadata {
+  return value && value.__symbolic === 'constructor';
+}
+
+export type MetadataValue =
+    string | number | boolean | MetadataObject | MetadataArray | MetadataSymbolicExpression;
+
+export interface MetadataObject { [name: string]: MetadataValue; }
+
+export interface MetadataArray { [name: number]: MetadataValue; }
+
+export interface MetadataSymbolicExpression {
+  __symbolic: 'binary'|'call'|'index'|'new'|'pre'|'reference'|'select'
+}
+export function isMetadataSymbolicExpression(value: any): value is MetadataSymbolicExpression {
+  if (value) {
+    switch (value.__symbolic) {
+      case 'binary':
+      case 'call':
+      case 'index':
+      case 'new':
+      case 'pre':
+      case 'reference':
+      case 'select':
+        return true;
+    }
+  }
+  return false;
+}
+
+export interface MetadataSymbolicBinaryExpression extends MetadataSymbolicExpression {
+  __symbolic: 'binary';
+  operator: '&&'|'||'|'|'|'^'|'&'|'=='|'!='|'==='|'!=='|'<'|'>'|'<='|'>='|'instanceof'|'in'|'as'|
+      '<<'|'>>'|'>>>'|'+'|'-'|'*'|'/'|'%'|'**';
+  left: MetadataValue;
+  right: MetadataValue;
+}
+export function isMetadataSymbolicBinaryExpression(value: any):
+    value is MetadataSymbolicBinaryExpression {
+  return value && value.__symbolic === 'binary';
+}
+
+export interface MetadataSymbolicIndexExpression extends MetadataSymbolicExpression {
+  __symbolic: 'index';
+  expression: MetadataValue;
+  index: MetadataValue;
+}
+export function isMetadataSymbolicIndexExpression(value: any):
+    value is MetadataSymbolicIndexExpression {
+  return value && value.__symbolic === 'index';
+}
+
+export interface MetadataSymbolicCallExpression extends MetadataSymbolicExpression {
+  __symbolic: 'call'|'new';
+  expression: MetadataValue;
+  arguments?: MetadataValue[];
+}
+export function isMetadataSymbolicCallExpression(value: any):
+    value is MetadataSymbolicCallExpression {
+  return value && (value.__symbolic === 'call' || value.__symbolic === 'new');
+}
+
+export interface MetadataSymbolicPrefixExpression extends MetadataSymbolicExpression {
+  __symbolic: 'pre';
+  operator: '+'|'-'|'~'|'!';
+  operand: MetadataValue;
+}
+export function isMetadataSymbolicPrefixExpression(value: any):
+    value is MetadataSymbolicPrefixExpression {
+  return value && value.__symbolic === 'pre';
+}
+
+export interface MetadataSymbolicReferenceExpression extends MetadataSymbolicExpression {
+  __symbolic: 'reference';
+  name: string;
+  module: string;
+}
+export function isMetadataSymbolicReferenceExpression(value: any):
+    value is MetadataSymbolicReferenceExpression {
+  return value && value.__symbolic === 'reference';
+}
+
+export interface MetadataSymbolicSelectExpression extends MetadataSymbolicExpression {
+  __symbolic: 'select';
+  expression: MetadataValue;
+  name: string;
+}
+export function isMetadataSymbolicSelectExpression(value: any):
+    value is MetadataSymbolicSelectExpression {
+  return value && value.__symbolic === 'select';
+}