anchor.diff:  		fun doReleaseLock() {
   			// ...
   		}
  -
  -	}
  -----
  +	}
  +----
  +
  +[NOTE]
  +====
  +Note that `@After` advice in AspectJ is defined as "after finally advice", analogous
  +to a finally block in a try-catch statement. It will be invoked for any outcome,
  +normal return or exception thrown from the join point (user-declared target method),
  +in contrast to `@AfterReturning` which only applies to successful normal returns.
  +====
   
   
   [[aop-ataspectj-around-advice]]
   ==== Around Advice
   
  -The last kind of advice is around advice. Around advice runs "`around`" a matched method's
  -execution. It has the opportunity to do work both before and after the method runs
  -and to determine when, how, and even if the method actually gets to run at all.
  +The last kind of advice is around advice. Around advice runs "`around`" a matched
  +method's execution. It has the opportunity to do work both before and after the method
  +runs and to determine when, how, and even if the method actually gets to run at all.
   Around advice is often used if you need to share state before and after a method
  -execution in a thread-safe manner (starting and stopping a timer, for example). Always
  -use the least powerful form of advice that meets your requirements (that is, do not use
  -around advice if before advice would do).
  +execution in a thread-safe manner (starting and stopping a timer, for example).
  +Always use the least powerful form of advice that meets your requirements (that is,
  +do not use around advice if before advice would do).
   
   Around advice is declared by using the `@Around` annotation. The first parameter of the
   advice method must be of type `ProceedingJoinPoint`. Within the body of the advice,
  -calling `proceed()` on the `ProceedingJoinPoint` causes the underlying method to
  -run. The `proceed` method can also pass in an `Object[]`. The values
  -in the array are used as the arguments to the method execution when it proceeds.
  -
  -NOTE: The behavior of `proceed` when called with an `Object[]` is a little different than the
  -behavior of `proceed` for around advice compiled by the AspectJ compiler. For around
  +calling `proceed()` on the `ProceedingJoinPoint` causes the underlying method to run.
  +The `proceed` method can also pass in an `Object[]`. The values in the array are used
  +as the arguments to the method execution when it proceeds.
  +
  +NOTE: The behavior of `proceed` when called with an `Object[]` is a little different than
  +the behavior of `proceed` for around advice compiled by the AspectJ compiler. For around
   advice written using the traditional AspectJ language, the number of arguments passed to
   `proceed` must match the number of arguments passed to the around advice (not the number
   of arguments taken by the underlying join point), and the value passed to proceed in a
  
positive.code: 		public void doRecoveryActions() {
  			// ...
  		}
  
  	}
  ----
  [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
  
negative.code: 		fun doRecoveryActions() {
  			// ...
  		}
  	}
  ----
  
  Often, you want the advice to run only when exceptions of a given type are thrown,
  and you also often need access to the thrown exception in the advice body. You can
  use the `throwing` attribute to both restrict matching (if desired -- use `Throwable`
  as the exception type otherwise) and bind the thrown exception to an advice parameter.
  The following example shows how to do so:
  
  [source,java,indent=0,subs="verbatim,quotes",role="primary"]
  .Java
  