refactor(compiler): remove unused code

BREAKING CHANGE:
- Removes `ChangeDetection`, use a binding for `ChangeDetectorGenConfig` instead
  to configure change detection.
- `RenderElementRef.renderBoundElementIndex` was renamed to `RenderElementRef.boundElementIndex`.
- Removes `ViewLoader`, use `XHRImpl` instead.

Author: tbosch

modules/angular2/src/compiler/change_definition_factory.ts

@@ -3,11 +3,9 @@ import {isPresent, isBlank} from 'angular2/src/core/facade/lang';
 import {reflector} from 'angular2/src/core/reflection/reflection';
 
 import {
-  ChangeDetection,
   DirectiveIndex,
   BindingRecord,
   DirectiveRecord,
-  ProtoChangeDetector,
   ChangeDetectionStrategy,
   ChangeDetectorDefinition,
   ChangeDetectorGenConfig,

modules/angular2/src/core/application_common.ts

@@ -12,8 +12,6 @@ import {
 import {BrowserDomAdapter} from 'angular2/src/core/dom/browser_adapter';
 import {BrowserGetTestability} from 'angular2/src/core/testability/browser_testability';
 import {DOM} from 'angular2/src/core/dom/dom_adapter';
-import {ViewLoader} from 'angular2/src/core/render/dom/compiler/view_loader';
-import {StyleInliner} from 'angular2/src/core/render/dom/compiler/style_inliner';
 import {Promise, PromiseWrapper, PromiseCompleter} from 'angular2/src/core/facade/async';
 import {XHR} from 'angular2/src/core/render/xhr';
 import {XHRImpl} from 'angular2/src/core/render/xhr_impl';
@@ -31,15 +29,8 @@ import {
   DynamicComponentLoader
 } from 'angular2/src/core/compiler/dynamic_component_loader';
 import {TestabilityRegistry, Testability} from 'angular2/src/core/testability/testability';
-import {Renderer, RenderCompiler} from 'angular2/src/core/render/api';
-import {
-  DomRenderer,
-  DOCUMENT,
-  DefaultDomCompiler,
-  APP_ID_RANDOM_BINDING,
-  MAX_IN_MEMORY_ELEMENTS_PER_TEMPLATE,
-  TemplateCloner
-} from 'angular2/src/core/render/render';
+import {Renderer} from 'angular2/src/core/render/api';
+import {DomRenderer, DOCUMENT, APP_ID_RANDOM_BINDING} from 'angular2/src/core/render/render';
 import {ElementSchemaRegistry} from 'angular2/src/core/render/dom/schema/element_schema_registry';
 import {
   DomElementSchemaRegistry
@@ -72,17 +63,11 @@ export function applicationDomBindings(): Array<Type | Binding | any[]> {
     DomRenderer,
     bind(Renderer).toAlias(DomRenderer),
     APP_ID_RANDOM_BINDING,
-    TemplateCloner,
-    bind(MAX_IN_MEMORY_ELEMENTS_PER_TEMPLATE).toValue(20),
-    DefaultDomCompiler,
     bind(ElementSchemaRegistry).toValue(new DomElementSchemaRegistry()),
-    bind(RenderCompiler).toAlias(DefaultDomCompiler),
     DomSharedStylesHost,
     bind(SharedStylesHost).toAlias(DomSharedStylesHost),
-    ViewLoader,
     EXCEPTION_BINDING,
     bind(XHR).toValue(new XHRImpl()),
-    StyleInliner,
     Testability,
     AnchorBasedAppRootUrl,
     bind(AppRootUrl).toAlias(AnchorBasedAppRootUrl),

modules/angular2/src/core/application_ref.ts

@@ -21,10 +21,6 @@ import {LifeCycle} from 'angular2/src/core/life_cycle/life_cycle';
 import {
   Parser,
   Lexer,
-  ChangeDetection,
-  DynamicChangeDetection,
-  JitChangeDetection,
-  PreGeneratedChangeDetection,
   IterableDiffers,
   defaultIterableDiffers,
   KeyValueDiffers,
@@ -39,9 +35,7 @@ import {DEFAULT_PIPES} from 'angular2/src/core/pipes';
 import {ViewResolver} from './compiler/view_resolver';
 import {DirectiveResolver} from './compiler/directive_resolver';
 import {PipeResolver} from './compiler/pipe_resolver';
-import {StyleUrlResolver} from 'angular2/src/core/render/dom/compiler/style_url_resolver';
 import {UrlResolver} from 'angular2/src/core/services/url_resolver';
-import {ComponentUrlMapper} from 'angular2/src/core/compiler/component_url_mapper';
 import {
   APP_ID_RANDOM_BINDING,
 } from 'angular2/src/core/render/render';
@@ -90,12 +84,6 @@ function _componentBindings(appComponentType: Type): Array<Type | Binding | any[
  * application, regardless of whether it runs on the UI thread or in a web worker.
  */
 export function applicationCommonBindings(): Array<Type | Binding | any[]> {
-  var bestChangeDetection = new DynamicChangeDetection();
-  if (PreGeneratedChangeDetection.isSupported()) {
-    bestChangeDetection = new PreGeneratedChangeDetection();
-  } else if (JitChangeDetection.isSupported()) {
-    bestChangeDetection = new JitChangeDetection();
-  }
   return [
     Compiler,
     APP_ID_RANDOM_BINDING,
@@ -109,12 +97,9 @@ export function applicationCommonBindings(): Array<Type | Binding | any[]> {
     DEFAULT_PIPES,
     bind(IterableDiffers).toValue(defaultIterableDiffers),
     bind(KeyValueDiffers).toValue(defaultKeyValueDiffers),
-    bind(ChangeDetection).toValue(bestChangeDetection),
     DirectiveResolver,
     UrlResolver,
-    StyleUrlResolver,
     PipeResolver,
-    ComponentUrlMapper,
     Parser,
     Lexer,
     DynamicComponentLoader,

modules/angular2/src/core/change_detection/change_detection.ts

@@ -1,19 +1,8 @@
-import {JitProtoChangeDetector} from './jit_proto_change_detector';
-import {PregenProtoChangeDetector} from './pregen_proto_change_detector';
-import {DynamicProtoChangeDetector} from './proto_change_detector';
 import {IterableDiffers, IterableDifferFactory} from './differs/iterable_differs';
 import {DefaultIterableDifferFactory} from './differs/default_iterable_differ';
 import {KeyValueDiffers, KeyValueDifferFactory} from './differs/keyvalue_differs';
 import {DefaultKeyValueDifferFactory} from './differs/default_keyvalue_differ';
-import {
-  ChangeDetection,
-  ProtoChangeDetector,
-  ChangeDetectorDefinition,
-  ChangeDetectorGenConfig
-} from './interfaces';
-import {Injector, Inject, Injectable, OpaqueToken, Optional, Binding} from 'angular2/src/core/di';
-import {StringMap, StringMapWrapper} from 'angular2/src/core/facade/collection';
-import {CONST, CONST_EXPR, isPresent, assertionsEnabled} from 'angular2/src/core/facade/lang';
+import {CONST, CONST_EXPR, isPresent} from 'angular2/src/core/facade/lang';
 
 export {
   ASTWithSource,
@@ -37,13 +26,13 @@ export {
   ProtoChangeDetector,
   ChangeDetector,
   ChangeDispatcher,
-  ChangeDetection,
   ChangeDetectorDefinition,
   DebugContext,
   ChangeDetectorGenConfig
 } from './interfaces';
 export {ChangeDetectionStrategy, CHANGE_DECTION_STRATEGY_VALUES} from './constants';
 export {DynamicProtoChangeDetector} from './proto_change_detector';
+export {JitProtoChangeDetector} from './jit_proto_change_detector';
 export {BindingRecord, BindingTarget} from './binding_record';
 export {DirectiveIndex, DirectiveRecord} from './directive_record';
 export {DynamicChangeDetector} from './dynamic_change_detector';
@@ -68,98 +57,3 @@ export const iterableDiff: IterableDifferFactory[] =
 export const defaultIterableDiffers = CONST_EXPR(new IterableDiffers(iterableDiff));
 
 export const defaultKeyValueDiffers = CONST_EXPR(new KeyValueDiffers(keyValDiff));
-
-/**
- * Map from {@link ChangeDetectorDefinition#id} to a factory method which takes a
- * {@link Pipes} and a {@link ChangeDetectorDefinition} and generates a
- * {@link ProtoChangeDetector} associated with the definition.
- */
-// TODO(kegluneq): Use PregenProtoChangeDetectorFactory rather than Function once possible in
-// dart2js. See https://github.com/dart-lang/sdk/issues/23630 for details.
-export var preGeneratedProtoDetectors: StringMap<string, Function> = {};
-
-/**
- * Implements change detection using a map of pregenerated proto detectors.
- */
-@Injectable()
-export class PreGeneratedChangeDetection extends ChangeDetection {
-  _dynamicChangeDetection: ChangeDetection;
-  _protoChangeDetectorFactories: StringMap<string, Function>;
-  _genConfig: ChangeDetectorGenConfig;
-
-  constructor(config?: ChangeDetectorGenConfig,
-              protoChangeDetectorsForTest?: StringMap<string, Function>) {
-    super();
-    this._dynamicChangeDetection = new DynamicChangeDetection();
-    this._protoChangeDetectorFactories = isPresent(protoChangeDetectorsForTest) ?
-                                             protoChangeDetectorsForTest :
-                                             preGeneratedProtoDetectors;
-
-    this._genConfig =
-        isPresent(config) ? config : new ChangeDetectorGenConfig(assertionsEnabled(),
-                                                                 assertionsEnabled(), false, false);
-  }
-
-  static isSupported(): boolean { return PregenProtoChangeDetector.isSupported(); }
-
-  getProtoChangeDetector(id: string, definition: ChangeDetectorDefinition): ProtoChangeDetector {
-    if (StringMapWrapper.contains(this._protoChangeDetectorFactories, id)) {
-      return StringMapWrapper.get(this._protoChangeDetectorFactories, id)(definition);
-    }
-    return this._dynamicChangeDetection.getProtoChangeDetector(id, definition);
-  }
-
-  get genConfig(): ChangeDetectorGenConfig { return this._genConfig; }
-  get generateDetectors(): boolean { return true; }
-}
-
-
-/**
- * Implements change detection that does not require `eval()`.
- *
- * This is slower than {@link JitChangeDetection}.
- */
-@Injectable()
-export class DynamicChangeDetection extends ChangeDetection {
-  _genConfig: ChangeDetectorGenConfig;
-
-  constructor(config?: ChangeDetectorGenConfig) {
-    super();
-    this._genConfig =
-        isPresent(config) ? config : new ChangeDetectorGenConfig(assertionsEnabled(),
-                                                                 assertionsEnabled(), false, false);
-  }
-
-  getProtoChangeDetector(id: string, definition: ChangeDetectorDefinition): ProtoChangeDetector {
-    return new DynamicProtoChangeDetector(definition);
-  }
-
-  get genConfig(): ChangeDetectorGenConfig { return this._genConfig; }
-  get generateDetectors(): boolean { return true; }
-}
-
-/**
- * Implements faster change detection by generating source code.
- *
- * This requires `eval()`. For change detection that does not require `eval()`, see
- * {@link DynamicChangeDetection} and {@link PreGeneratedChangeDetection}.
- */
-@Injectable()
-export class JitChangeDetection extends ChangeDetection {
-  _genConfig: ChangeDetectorGenConfig;
-  constructor(config?: ChangeDetectorGenConfig) {
-    super();
-    this._genConfig =
-        isPresent(config) ? config : new ChangeDetectorGenConfig(assertionsEnabled(),
-                                                                 assertionsEnabled(), false, true);
-  }
-
-  static isSupported(): boolean { return JitProtoChangeDetector.isSupported(); }
-
-  getProtoChangeDetector(id: string, definition: ChangeDetectorDefinition): ProtoChangeDetector {
-    return new JitProtoChangeDetector(definition);
-  }
-
-  get genConfig(): ChangeDetectorGenConfig { return this._genConfig; }
-  get generateDetectors(): boolean { return true; }
-}

modules/angular2/src/core/change_detection/interfaces.ts

@@ -1,46 +1,9 @@
-import {CONST} from 'angular2/src/core/facade/lang';
 import {Locals} from './parser/locals';
 import {BindingTarget, BindingRecord} from './binding_record';
 import {DirectiveIndex, DirectiveRecord} from './directive_record';
 import {ChangeDetectionStrategy} from './constants';
 import {ChangeDetectorRef} from './change_detector_ref';
 
-/**
- * Interface used by Angular to control the change detection strategy for an application.
- *
- * Angular implements the following change detection strategies by default:
- *
- * - {@link DynamicChangeDetection}: slower, but does not require `eval()`.
- * - {@link JitChangeDetection}: faster, but requires `eval()`.
- *
- * In JavaScript, you should always use `JitChangeDetection`, unless you are in an environment that
- *has
- * [CSP](https://developer.mozilla.org/en-US/docs/Web/Security/CSP), such as a Chrome Extension.
- *
- * In Dart, use `DynamicChangeDetection` during development. The Angular transformer generates an
- *analog to the
- * `JitChangeDetection` strategy at compile time.
- *
- *
- * See: {@link DynamicChangeDetection}, {@link JitChangeDetection},
- * {@link PreGeneratedChangeDetection}
- *
- * # Example
- * ```javascript
- * bootstrap(MyApp, [bind(ChangeDetection).toValue(new DynamicChangeDetection())]);
- * ```
- */
-@CONST()
-export class ChangeDetection {
-  getProtoChangeDetector(id: string, definition: ChangeDetectorDefinition): ProtoChangeDetector {
-    return null;
-  }
-
-  get generateDetectors(): boolean { return null; }
-
-  get genConfig(): ChangeDetectorGenConfig { return null; }
-}
-
 export class DebugContext {
   constructor(public element: any, public componentElement: any, public directive: any,
               public context: any, public locals: any, public injector: any) {}

modules/angular2/src/core/compiler.ts

@@ -9,7 +9,6 @@ export {
   OnInit,
   DoCheck
 } from './compiler/interfaces';
-export {ComponentUrlMapper} from './compiler/component_url_mapper';
 export {DirectiveResolver} from './compiler/directive_resolver';
 export {Compiler} from './compiler/compiler';
 export {AppViewManager} from './compiler/view_manager';

modules/angular2/src/core/compiler/element_injector.ts

@@ -48,7 +48,6 @@ import {
 import {QueryList} from './query_list';
 import {reflector} from 'angular2/src/core/reflection/reflection';
 import {SetterFn} from 'angular2/src/core/reflection/types';
-import {RenderDirectiveMetadata} from 'angular2/src/core/render/api';
 import {EventConfig} from 'angular2/src/core/render/event_config';
 import {PipeBinding} from '../pipes/pipe_binding';
 
@@ -128,17 +127,17 @@ export class DirectiveDependency extends Dependency {
 }
 
 export class DirectiveBinding extends ResolvedBinding {
-  constructor(key: Key, factory: Function, deps: Dependency[],
-              public metadata: RenderDirectiveMetadata,
+  public callOnDestroy: boolean;
+
+  constructor(key: Key, factory: Function, deps: Dependency[], public metadata: DirectiveMetadata,
               public bindings: Array<Type | Binding | any[]>,
               public viewBindings: Array<Type | Binding | any[]>) {
     super(key, [new ResolvedFactory(factory, deps)], false);
+    this.callOnDestroy = hasLifecycleHook(LifecycleHooks.OnDestroy, key.token);
   }
 
   get displayName(): string { return this.key.displayName; }
 
-  get callOnDestroy(): boolean { return this.metadata.callOnDestroy; }
-
   get queries(): QueryMetadataWithSetter[] {
     if (isBlank(this.metadata.queries)) return [];
 
@@ -163,47 +162,11 @@ export class DirectiveBinding extends ResolvedBinding {
     var rb = resolveBinding(binding);
     var rf = rb.resolvedFactories[0];
     var deps = rf.dependencies.map(DirectiveDependency.createFrom);
-    var token = binding.token;
-
-    var metadata = RenderDirectiveMetadata.create({
-      id: stringify(binding.token),
-      type: meta instanceof ComponentMetadata ? RenderDirectiveMetadata.COMPONENT_TYPE :
-                                                RenderDirectiveMetadata.DIRECTIVE_TYPE,
-      selector: meta.selector,
-      compileChildren: true,
-      outputs: meta.outputs,
-      host: isPresent(meta.host) ? MapWrapper.createFromStringMap(meta.host) : null,
-      inputs: meta.inputs,
-      readAttributes: DirectiveBinding._readAttributes(<any>deps),
-      queries: meta.queries,
-
-      callOnDestroy: hasLifecycleHook(LifecycleHooks.OnDestroy, token),
-      callOnChanges: hasLifecycleHook(LifecycleHooks.OnChanges, token),
-      callDoCheck: hasLifecycleHook(LifecycleHooks.DoCheck, token),
-      callOnInit: hasLifecycleHook(LifecycleHooks.OnInit, token),
-      callAfterContentInit: hasLifecycleHook(LifecycleHooks.AfterContentInit, token),
-      callAfterContentChecked: hasLifecycleHook(LifecycleHooks.AfterContentChecked, token),
-      callAfterViewInit: hasLifecycleHook(LifecycleHooks.AfterViewInit, token),
-      callAfterViewChecked: hasLifecycleHook(LifecycleHooks.AfterViewChecked, token),
-
-      changeDetection: meta instanceof ComponentMetadata ? meta.changeDetection : null,
-
-      exportAs: meta.exportAs
-    });
+
     var bindings = isPresent(meta.bindings) ? meta.bindings : [];
     var viewBindigs =
         meta instanceof ComponentMetadata && isPresent(meta.viewBindings) ? meta.viewBindings : [];
-    return new DirectiveBinding(rb.key, rf.factory, deps, metadata, bindings, viewBindigs);
-  }
-
-  static _readAttributes(deps: DirectiveDependency[]): string[] {
-    var readAttributes = [];
-    deps.forEach(dep => {
-      if (isPresent(dep.attributeName)) {
-        readAttributes.push(dep.attributeName);
-      }
-    });
-    return readAttributes;
+    return new DirectiveBinding(rb.key, rf.factory, deps, meta, bindings, viewBindigs);
   }
 
   static createFromType(type: Type, annotation: DirectiveMetadata): DirectiveBinding {
@@ -502,7 +465,7 @@ export class ElementInjector extends TreeNode<ElementInjector> implements Depend
       if (dirDep.key.id === StaticKeys.instance().changeDetectorRefId) {
         // We provide the component's view change detector to components and
         // the surrounding component's change detector to directives.
-        if (dirBin.metadata.type === RenderDirectiveMetadata.COMPONENT_TYPE) {
+        if (dirBin.metadata instanceof ComponentMetadata) {
           var componentView = this._preBuiltObjects.view.getNestedView(
               this._preBuiltObjects.elementRef.boundElementIndex);
           return componentView.changeDetector.ref;