function _dependenciesFor(typeOrFunc: any): ReflectiveDependency[] {
  var params = reflector.parameters(typeOrFunc);
  if (isBlank(params)) return [];
  if (params.some(isBlank)) {
    throw new NoAnnotationError(typeOrFunc, params);
  }
  return params.map((p: any[]) => _extractToken(typeOrFunc, p, params));
}

function _readMetadata(componentType: Type) {
  let metadata = reflector.annotations(componentType).filter(f => f instanceof RoutesMetadata);
  if (metadata.length === 0) {
    throw new BaseException(
        `Component '${stringify(componentType)}' does not have route configuration`);
  }
  return metadata[0];
}

  resolveComponent(componentType: Type): Promise<ComponentFactory> {
    var metadatas = reflector.annotations(componentType);
    var componentFactory = metadatas.find(_isComponentFactory);

    if (isBlank(componentFactory)) {
      throw new BaseException(`No precompiled component ${stringify(componentType)} found`);
    }
    return PromiseWrapper.resolve(componentFactory);
  }

  compileInHost(componentType: Type): Promise<HostViewFactoryRef_> {
    var metadatas = reflector.annotations(componentType);
    var hostViewFactory = metadatas.find(isHostViewFactory);

    if (isBlank(hostViewFactory)) {
      throw new BaseException(`No precompiled component ${stringify(componentType)} found`);
    }
    return PromiseWrapper.resolve(new HostViewFactoryRef_(hostViewFactory));
  }

 /**
  * Return {@link PipeMetadata} for a given `Type`.
  */
 resolve(type: Type): PipeMetadata {
   var metas = reflector.annotations(resolveForwardRef(type));
   if (isPresent(metas)) {
     var annotation = metas.find(_isPipeMetadata);
     if (isPresent(annotation)) {
       return annotation;
     }
   }
   throw new BaseException(`No Pipe decorator found on ${stringify(type)}`);
 }

 /**
  * Return {@link PipeMetadata} for a given `Type`.
  */
 resolve(type: Type): PipeMetadata {
   var metas = reflector.annotations(resolveForwardRef(type));
   if (isPresent(metas)) {
     for (var i = 0; i < metas.length; i++) {
       var annotation = metas[i];
       if (annotation instanceof PipeMetadata) {
         return annotation;
       }
     }
   }
   throw new BaseException(`No Pipe decorator found on ${stringify(type)}`);
 }

export function resolveReflectiveFactory(provider: Provider): ResolvedReflectiveFactory {
  var factoryFn: Function;
  var resolvedDeps;
  if (isPresent(provider.useClass)) {
    var useClass = resolveForwardRef(provider.useClass);
    factoryFn = reflector.factory(useClass);
    resolvedDeps = _dependenciesFor(useClass);
  } else if (isPresent(provider.useExisting)) {
    factoryFn = (aliasInstance) => aliasInstance;
    resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
  } else if (isPresent(provider.useFactory)) {
    factoryFn = provider.useFactory;
    resolvedDeps = constructDependencies(provider.useFactory, provider.dependencies);
  } else {
    factoryFn = () => provider.useValue;
    resolvedDeps = _EMPTY_LIST;
  }
  return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
}

 beforeEach(inject([Compiler], (_compiler) => {
   someHostViewFactory = new HostViewFactory(null, null);
   reflector.registerType(SomeComponent, new ReflectionInfo([someHostViewFactory]));
 }));

 beforeEach(inject([Compiler], (_compiler) => {
   compiler = _compiler;
   cht = new CompiledHostTemplate(new CompiledComponentTemplate('aCompId', null, null, null));
   reflector.registerType(SomeComponent, new ReflectionInfo([cht]));
 }));