StringMapWrapper.forEach(stringMap, (_, key) => { ListWrapper.push(res, key); });

  /**
   * Return descendant TestElememts matching the given predicate
   * and scope.
   *
   * @param {Function: boolean} predicate
   * @param {Scope} scope
   *
   * @return {List<DebugElement>}
   */
  queryAll(predicate: Predicate<DebugElement>, scope: Function = Scope.all): List<DebugElement> {
    var elementsInScope = scope(this);

    return ListWrapper.filter(elementsInScope, predicate);
  }

 (child) => { scope = ListWrapper.concat(scope, Scope.all(child)); });

 _createInstances(): List<any> { return ListWrapper.createFixedSize(Key.numberOfKeys + 1); }

 _setInstance(key: Key, obj): void { ListWrapper.set(this._instances, key.id, obj); }

 addChild(cd: ChangeDetector) {
   ListWrapper.push(this.lightDomChildren, cd);
   cd.parent = this;
 }

 addShadowDomChild(cd: ChangeDetector) {
   ListWrapper.push(this.shadowDomChildren, cd);
   cd.parent = this;
 }

 _splitBindConfig(bindConfig: string) {
   return ListWrapper.map(bindConfig.split('|'), (s) => s.trim());
 }

  process(parent: CompileElement, current: CompileElement, control: CompileControl) {
    var attrs = current.attrs();
    var classList = current.classList();

    var cssSelector = new CssSelector();
    var nodeName = DOM.nodeName(current.element);
    cssSelector.setElement(nodeName);
    for (var i = 0; i < classList.length; i++) {
      cssSelector.addClassName(classList[i]);
    }

    MapWrapper.forEach(attrs,
                       (attrValue, attrName) => { cssSelector.addAttribute(attrName, attrValue); });

    var componentDirective;
    var foundDirectiveIndices = [];
    var elementBinder = null;
    this._selectorMatcher.match(cssSelector, (selector, directiveIndex) => {
      elementBinder = current.bindElement();
      var directive = this._directives[directiveIndex];
      if (directive.type === DirectiveMetadata.COMPONENT_TYPE) {
        // components need to go first, so it is easier to locate them in the result.
        ListWrapper.insert(foundDirectiveIndices, 0, directiveIndex);
        if (isPresent(componentDirective)) {
          throw new BaseException(
              `Only one component directive is allowed per element - check ${current.elementDescription}`);
        }
        componentDirective = directive;
        elementBinder.setComponentId(directive.id);
      } else {
        ListWrapper.push(foundDirectiveIndices, directiveIndex);
      }
    });
    ListWrapper.forEach(foundDirectiveIndices, (directiveIndex) => {
      var directive = this._directives[directiveIndex];
      var directiveBinderBuilder = elementBinder.bindDirective(directiveIndex);
      current.compileChildren = current.compileChildren && directive.compileChildren;
      if (isPresent(directive.properties)) {
        MapWrapper.forEach(directive.properties, (bindConfig, dirProperty) => {
          this._bindDirectiveProperty(dirProperty, bindConfig, current, directiveBinderBuilder);
        });
      }
      if (isPresent(directive.hostListeners)) {
        MapWrapper.forEach(directive.hostListeners, (action, eventName) => {
          this._bindDirectiveEvent(eventName, action, current, directiveBinderBuilder);
        });
      }
      if (isPresent(directive.hostActions)) {
        MapWrapper.forEach(directive.hostActions, (action, actionName) => {
          this._bindHostAction(actionName, action, current, directiveBinderBuilder);
        });
      }
      if (isPresent(directive.hostProperties)) {
        MapWrapper.forEach(directive.hostProperties, (hostPropertyName, directivePropertyName) => {
          this._bindHostProperty(hostPropertyName, directivePropertyName, current,
                                 directiveBinderBuilder);
        });
      }
      if (isPresent(directive.hostAttributes)) {
        MapWrapper.forEach(directive.hostAttributes, (hostAttrValue, hostAttrName) => {
          this._addHostAttribute(hostAttrName, hostAttrValue, current);
        });
      }
      if (isPresent(directive.readAttributes)) {
        ListWrapper.forEach(directive.readAttributes,
                            (attrName) => { elementBinder.readAttribute(attrName); });
      }
    });
  }

 _createRecords(definition: ChangeDetectorDefinition) {
   var recordBuilder = new ProtoRecordBuilder();
   ListWrapper.forEach(definition.bindingRecords,
                       (b) => { recordBuilder.add(b, definition.variableNames); });
   return coalesce(recordBuilder.records);
 }