feat: allow for forward references in injection

It is possible for a class defined first to be referencing a class defined later, and as a result at the time of the definition it is not possible to access the later's class reference. This allows to refer to the later defined class through a closure.Closes angular#1891

Author: mhevery

modules/angular2/angular2.js

@@ -3,6 +3,7 @@ export * from './core';
 export * from './annotations';
 export * from './directives';
 export * from './forms';
+export * from './di';
 export {Observable, EventEmitter} from 'angular2/src/facade/async';
 export * from 'angular2/src/render/api';
 export {DomRenderer, DOCUMENT_TOKEN} from 'angular2/src/render/dom/dom_renderer';

modules/angular2/di.ts

@@ -7,6 +7,7 @@
 
 export * from './src/di/annotations';
 export * from './src/di/decorators';
+export * from './src/di/forward_ref';
 export {Injector} from './src/di/injector';
 export {Binding, ResolvedBinding, Dependency, bind} from './src/di/binding';
 export {Key, KeyRegistry, TypeLiteral} from './src/di/key';

modules/angular2/src/core/compiler/compiler.js

@@ -1,4 +1,4 @@
-import {Binding} from 'angular2/di';
+import {Binding, resolveForwardRef} from 'angular2/di';
 import {Injectable} from 'angular2/src/di/annotations_impl';
 import {Type, isBlank, isPresent, BaseException, normalizeBlank, stringify} from 'angular2/src/facade/lang';
 import {Promise, PromiseWrapper} from 'angular2/src/facade/async';
@@ -237,7 +237,7 @@ export class Compiler {
 
  _flattenList(tree:List<any>, out:List<any> /*<Type|Binding>*/):void {
  for (var i = 0; i < tree.length; i++) {
- var item = tree[i];
+ var item = resolveForwardRef(tree[i]);
  if (ListWrapper.isList(item)) {
  this._flattenList(item, out);
  } else {

modules/angular2/src/core/compiler/directive_resolver.js

@@ -1,12 +1,13 @@
 import {Injectable} from 'angular2/src/di/annotations_impl';
+import {resolveForwardRef} from 'angular2/di';
 import {Type, isPresent, BaseException, stringify} from 'angular2/src/facade/lang';
 import {Directive} from '../annotations_impl/annotations';
 import {reflector} from 'angular2/src/reflection/reflection';
 
 @Injectable()
 export class DirectiveResolver {
  resolve(type:Type):Directive {
- var annotations = reflector.annotations(type);
+ var annotations = reflector.annotations(resolveForwardRef(type));
  if (isPresent(annotations)) {
  for (var i=0; i<annotations.length; i++) {
  var annotation = annotations[i];

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

@@ -3,7 +3,7 @@ import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 import {Math} from 'angular2/src/facade/math';
 import {List, ListWrapper, MapWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
 import {Injector, Key, Dependency, bind, Binding, ResolvedBinding, NoBindingError,
- AbstractBindingError, CyclicDependencyError} from 'angular2/di';
+ AbstractBindingError, CyclicDependencyError, resolveForwardRef} from 'angular2/di';
 import {Parent, Ancestor} from 'angular2/src/core/annotations_impl/visibility';
 import {Attribute, Query} from 'angular2/src/core/annotations_impl/di';
 import * as viewModule from './view';
@@ -220,7 +220,7 @@ export class DirectiveDependency extends Dependency {
 
  static _query(properties) {
  var p = ListWrapper.find(properties, (p) => p instanceof Query);
- return isPresent(p) ? p.directive : null;
+ return isPresent(p) ? resolveForwardRef(p.directive) : null;
  }
 }
 

modules/angular2/src/di/binding.ts

@@ -10,6 +10,7 @@ import {
  DependencyAnnotation
 } from './annotations_impl';
 import {NoAnnotationError} from './exceptions';
+import {resolveForwardRef} from './forward_ref';
 
 /**
  * @private
@@ -217,8 +218,9 @@ export class Binding {
  var resolvedDeps;
  var isAsync = false;
  if (isPresent(this.toClass)) {
- factoryFn = reflector.factory(this.toClass);
- resolvedDeps = _dependenciesFor(this.toClass);
+ var toClass = resolveForwardRef(this.toClass);
+ factoryFn = reflector.factory(toClass);
+ resolvedDeps = _dependenciesFor(toClass);
  } else if (isPresent(this.toAlias)) {
  factoryFn = (aliasInstance) => aliasInstance;
  resolvedDeps = [Dependency.fromKey(Key.get(this.toAlias))];
@@ -234,7 +236,8 @@ export class Binding {
  resolvedDeps = _EMPTY_LIST;
  }
 
- return new ResolvedBinding(Key.get(this.token), factoryFn, resolvedDeps, isAsync);
+ return new ResolvedBinding(Key.get(resolveForwardRef(this.token)), factoryFn, resolvedDeps,
+ isAsync);
  }
 }
 
@@ -428,7 +431,8 @@ export class BindingBuilder {
 function _constructDependencies(factoryFunction: Function, dependencies: List<any>) {
  return isBlank(dependencies) ?
  _dependenciesFor(factoryFunction) :
- ListWrapper.map(dependencies, (t) => Dependency.fromKey(Key.get(t)));
+ ListWrapper.map(dependencies,
+ (t) => Dependency.fromKey(Key.get(resolveForwardRef(t))));
 }
 
 function _dependenciesFor(typeOrFunc): List<any> {
@@ -475,6 +479,8 @@ function _extractToken(typeOrFunc, annotations) {
  }
  }
 
+ token = resolveForwardRef(token);
+
  if (isPresent(token)) {
  return _createDependency(token, asPromise, lazy, optional, depProps);
  } else {

modules/angular2/src/di/forward_ref.dart

@@ -0,0 +1,17 @@
+library angular2.di.forward_ref;
+
+typedef Type ForwardRefFn();
+
+/**
+ * Dart does not have the forward ref problem, so this function is a noop.
+ */
+forwardRef(ForwardRefFn forwardRefFn) => forwardRefFn();
+
+/**
+ * Lazily retrieve the reference value.
+ *
+ * See: {@link forwardRef}
+ *
+ * @exportedAs angular2/di
+ */
+resolveForwardRef(type) => type;

modules/angular2/src/di/forward_ref.ts

@@ -0,0 +1,50 @@
+import {Type} from 'angular2/src/facade/lang';
+
+export interface ForwardRefFn { (): Type; }
+
+/**
+ * Allows to refer to references which are not yet defined.
+ *
+ * This situation arises when the key which we need te refer to for the purposes of DI is declared,
+ * but not yet defined.
+ *
+ * ## Example:
+ *
+ * ```
+ * class Door {
+ * // Incorrect way to refer to a reference which is defined later.
+ * // This fails because `Lock` is undefined at this point.
+ * constructor(lock:Lock) { }
+ *
+ * // Correct way to refer to a reference which is defined later.
+ * // The reference needs to be captured in a closure.
+ * constructor(@Inject(forwardRef(() => Lock)) lock:Lock) { }
+ * }
+ *
+ * // Only at this point the lock is defined.
+ * class Lock {
+ * }
+ * ```
+ *
+ * @exportedAs angular2/di
+ */
+export function forwardRef(forwardRefFn: ForwardRefFn): Type {
+ (<any>forwardRefFn).__forward_ref__ = forwardRef;
+ return (<Type><any>forwardRefFn);
+}
+
+/**
+ * Lazily retrieve the reference value.
+ *
+ * See: {@link forwardRef}
+ *
+ * @exportedAs angular2/di
+ */
+export function resolveForwardRef(type: any): any {
+ if (typeof type == 'function' && type.hasOwnProperty('__forward_ref__') &&
+ type.__forward_ref__ === forwardRef) {
+ return (<ForwardRefFn>type)();
+ } else {
+ return type;
+ }
+}

modules/angular2/src/di/injector.ts

@@ -13,6 +13,7 @@ import {
 import {FunctionWrapper, Type, isPresent, isBlank} from 'angular2/src/facade/lang';
 import {PromiseWrapper, Promise} from 'angular2/src/facade/async';
 import {Key} from './key';
+import {resolveForwardRef} from './forward_ref';
 
 var _constructing = new Object();
 var _notFound = new Object();
@@ -370,7 +371,7 @@ class _AsyncInjectorStrategy {
 function _resolveBindings(bindings: List<any>): List<ResolvedBinding> {
  var resolvedList = ListWrapper.createFixedSize(bindings.length);
  for (var i = 0; i < bindings.length; i++) {
- var unresolved = bindings[i];
+ var unresolved = resolveForwardRef(bindings[i]);
  var resolved;
  if (unresolved instanceof ResolvedBinding) {
  resolved = unresolved; // ha-ha! I'm easily amused

modules/angular2/src/di/key.ts

@@ -1,5 +1,5 @@
 import {MapWrapper} from 'angular2/src/facade/collection';
-import {stringify, CONST, Type} from 'angular2/src/facade/lang';
+import {stringify, CONST, Type, isBlank, BaseException} from 'angular2/src/facade/lang';
 import {TypeLiteral} from './type_literal';
 
 export {TypeLiteral} from './type_literal';
@@ -26,6 +26,9 @@ export class Key {
  * @private
  */
  constructor(token: Object, id: number) {
+ if (isBlank(token)) {
+ throw new BaseException('Token must be defined!');
+ }
  this.token = token;
  this.id = id;
  }