anchor.diff:  part of drails_di;
   
  +/// Class that must be extended in order to make the methods of an object interceptable
  +/// 
  +///     Class MyService {
  +///       myMethod() => "inside myMethod";
  +///     }
  +///     
  +///     Class MyServiceImpl extends MyService {
  +///       myMethod() => super.myMethod() + "Impl";
  +///       
  +///       myMethodThrow() => throw new Exception("some message");
  +///     }
  +///     
  +///     Class MyServiceProxy extends AopProxy implements MyService {}
  +///     
  +/// then in other file or in the same file you can create top level functions that are
  +/// going to act as aspects/interceptors:
  +/// 
  +///     //Create the pointcut
  +///     bool myService_myMethod(instance, Invocation invo) =>
  +///       instance is MyService && invo.memberName == #myMethod;
  +/// 
  +///     //add the pointcut before
  +///     @Before(myService_myMethod)
  +///     printBeforeMyServiceMyMethod(Invocation invo) {
  +///       print("before MyService.myMethod");
  +///       //modify invo as needed
  +///       return invo;
  +///     }
  +///     
  +///     myService_myMethod_retVal(instance, Invocation invo, retVal) =>
  +///       retVal == "myMethodImpl" && myService_myMethod();
  +///     
  +///     //add pointcut after
  +///     @After(myService_myMethod_retVal)
  +///     printAfterMyServiceMyMethod(retVal) {
  +///       print(after MyService.myMethod");
  +///       //modify retVal as needed
  +///       return retVal;
  +///     }
  +///  
   class AopProxy {
     noSuchMethod(Invocation invocation) {
       var component = ApplicationContext._componentOfProxy[reflect(this).type.reflectedType];
  
positive.code:       //Invoque method end
        
        //After aspect begin
        ApplicationContext._aspectsAfter.keys.where((aspect) {
          var afterAnn = new GetValueOfAnnotation<After>().fromDeclaration(aspect);
          
          if(!afterAnn.retValNull && afterAnn.retVal == retVal
              || afterAnn.retValNull == (retVal == null))
            return afterAnn.isAfter(im, invocation);
          
          return false;
        }).forEach((mm) {
          retVal = ApplicationContext._aspectsAfter[mm].invoke(mm.simpleName, [retVal]).reflectee;
        });
        //After aspect end
  
negative.code:     
      //Befor aspect begin
      ApplicationContext._aspectsBefore.keys.where((aspect) =>
          new GetValueOfAnnotation<Before>().fromDeclaration(aspect).isBefore(component, invocation)
      ).forEach((mm) {
        ApplicationContext._aspectsBefore[mm].invoke(mm.simpleName, []);
      });
  