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);
  }

 xdescribe('Missing directive checks', () => {
   if (assertionsEnabled()) {
     function expectCompileError(inlineTpl, errMessage, done) {
       tplResolver.setTemplate(MyComp, new Template({inline: inlineTpl}));
       PromiseWrapper.then(compiler.compile(MyComp), (value) => {
         throw new BaseException("Test failure: should not have come here as an exception was expected");
       }, (err) => {
         expect(err.message).toEqual(errMessage);
         done();
       });
     }
     it('should raise an error if no directive is registered for a template with template bindings', inject([AsyncTestCompleter], (async) => {
       expectCompileError('<div><div template="if: foo"></div></div>', 'Missing directive to handle \'if\' in <div template="if: foo">', () => async.done());
     }));
     it('should raise an error for missing template directive (1)', inject([AsyncTestCompleter], (async) => {
       expectCompileError('<div><template foo></template></div>', 'Missing directive to handle: <template foo>', () => async.done());
     }));
     it('should raise an error for missing template directive (2)', inject([AsyncTestCompleter], (async) => {
       expectCompileError('<div><template *if="condition"></template></div>', 'Missing directive to handle: <template *if="condition">', () => async.done());
     }));
     it('should raise an error for missing template directive (3)', inject([AsyncTestCompleter], (async) => {
       expectCompileError('<div *if="condition"></div>', 'Missing directive to handle \'if\' in MyComp: <div *if="condition">', () => async.done());
     }));
   }
 });

 /** @internal */
 _genThrowOnChangeCheck(oldValue: string, newValue: string): string {
   if (assertionsEnabled()) {
     return `
       if(throwOnChange) {
         this.throwOnChangeError(${oldValue}, ${newValue});
       }
       `;
   } else {
     return '';
   }
 }

 /** @internal */
 _genThrowOnChangeCheck(oldValue: string, newValue: string): string {
   if (assertionsEnabled()) {
     return `
       if (throwOnChange && !${this.changeDetectionUtilVarName}.devModeEqual(${oldValue}, ${newValue})) {
         this.throwOnChangeError(${oldValue}, ${newValue});
       }
       `;
   } else {
     return '';
   }
 }

function _createVmZone(givenReporter) {
  var defaultErrorReporter = (exception, stackTrace) => {
    var longStackTrace = ListWrapper.join(stackTrace, "\n\n-----async gap-----\n");
    print(`${exception}\n\n${longStackTrace}`);
    throw exception;
  };
  var reporter = isPresent(givenReporter) ? givenReporter : defaultErrorReporter;
  var zone = new VmTurnZone({enableLongStackTrace: assertionsEnabled()});
  zone.initCallbacks({onErrorHandler: reporter});
  return zone;
}

 _processContentElement(current) {
   if (this._shadowDomStrategy.hasNativeContentElement()) {
     return ;
   }
   var attrs = current.attrs();
   var selector = MapWrapper.get(attrs, 'select');
   selector = isPresent(selector) ? selector : '';
   var contentStart = DOM.createScriptTag('type', 'ng/contentStart');
   if (assertionsEnabled()) {
     DOM.setAttribute(contentStart, 'select', selector);
   }
   var contentEnd = DOM.createScriptTag('type', 'ng/contentEnd');
   DOM.insertBefore(current.element, contentStart);
   DOM.insertBefore(current.element, contentEnd);
   DOM.remove(current.element);
   current.element = contentStart;
   current.bindElement().setContentTagSelector(selector);
 }

 constructor(element, compilationUnit = '') {
   this.element = element;
   this._attrs = null;
   this._classList = null;
   this.isViewRoot = false;
   this.inheritedProtoView = null;
   this.inheritedElementBinder = null;
   this.distanceToInheritedBinder = 0;
   this.compileChildren = true;
   this.ignoreBindings = false;
   var tplDesc = assertionsEnabled() ? getElementDescription(element) : null;
   if (compilationUnit !== '') {
     this.elementDescription = compilationUnit;
     if (isPresent(tplDesc))
       this.elementDescription += ": " + tplDesc;
   } else {
     this.elementDescription = tplDesc;
   }
 }

  _processContentElement(current: CompileElement) {
    if (this._shadowDomStrategy.hasNativeContentElement()) {
      return;
    }
    var attrs = current.attrs();
    var selector = attrs.get('select');
    selector = isPresent(selector) ? selector : '';

    // The content tag should be replaced by a pair of marker tags (start & end).
    // The end marker creation is delayed to keep the number of elements constant.
    // Creating the end marker here would invalidate the parent's textNodeIndices for the subsequent
    // text nodes
    var contentStart = DOM.createScriptTag('type', 'ng/contentStart');
    if (assertionsEnabled()) {
      DOM.setAttribute(contentStart, 'select', selector);
    }
    DOM.insertBefore(current.element, contentStart);
    DOM.remove(current.element);

    current.element = contentStart;
    current.bindElement().setContentTagSelector(selector);
  }

export function compilerProviders(): Array<Type | Provider | any[]> {
  return [
    Lexer,
    Parser,
    HtmlParser,
    TemplateParser,
    TemplateNormalizer,
    RuntimeMetadataResolver,
    StyleCompiler,
    CommandCompiler,
    ChangeDetectionCompiler,
    provide(ChangeDetectorGenConfig,
            {useValue: new ChangeDetectorGenConfig(assertionsEnabled(), false, true)}),
    TemplateCompiler,
    provide(RuntimeCompiler, {useClass: RuntimeCompiler_}),
    provide(Compiler, {useExisting: RuntimeCompiler}),
    DomElementSchemaRegistry,
    provide(ElementSchemaRegistry, {useExisting: DomElementSchemaRegistry}),
    AnchorBasedAppRootUrl,
    provide(AppRootUrl, {useExisting: AnchorBasedAppRootUrl}),
    UrlResolver
  ];
}

export function createNgZone(): NgZone {
  return new NgZone({enableLongStackTrace: assertionsEnabled()});
}