anchor.diff:                  if (typeMirror.isSubclassOf(Injectable.reflectType(Future))) {
                     if (typeMirror.typeArguments.length == 1) {
                       typeMirror = typeMirror.typeArguments[0];
  +
  +                    _logger
  +                        .finest("Injecting Future<${typeMirror.simpleName}>");
                     } else {
                       throw new ArgumentError();
                     }
  +                } else {
  +                  _logger.finest("Injecting ${typeMirror.simpleName}");
                   }
   
                   instanceMirror.invokeSetter(
  
positive.code:       classMirror.declarations.forEach((name, DeclarationMirror mirror) {
          if (mirror is VariableMirror) {
            if (mirror.metadata.contains(Inject)) {
              _logger.finest("Inject on variable ${mirror.simpleName}");
  
              var variableType = mirror.type;
              if (variableType is ClassMirror) {
  
negative.code:     }
    }
  
    static runInScope(Scope scope, ScopeRunnable runnable) => runZoned(
        () => Chain.capture(() async {
              await openScope(scope);
              await runnable();
              await closeScope(scope);
            }, onError: (error, Chain chain) {
              _logger.severe("Running in scope error", error, chain);
            }),
        zoneValues: {_SCOPE_CONTEXT_HOLDER: new _ScopeContextHolder()});
  
    static lookupObject(Type clazz) {
      ProviderFunction provider = lookupProviderFunction(clazz);
  