Macros can eliminate using $method/dynamic dispatch here altogether.

Macros for method names which compile into AmethodName or methodName depending on global var set for compilation then.

Dynamic dispatch is a hit on speed anyway.

Always call

do a.AmethodName()

And inside dynamic dispatch check global variable %debug (or global, or some IsDebug method etc.). If it exists call both annotation methods and target method, If it does not exist only call target method.

Another approach would be using dynamic dispatch:

Let's say you have this method:

/// @NiceTest1
ClassMethod Test()
{
    Write 1
}

Using Class Generators you generate 2 additional methods:

/// @NiceTest1
ClassMethod OnBeforeTest()
{
    Write "Before NiceTest1"
}

/// @NiceTest1
ClassMethod OnAfterTest()
{
    Write "After NiceTest1"
}

and you add dynamic dispatch method (and dynamic dispatch classmethod) to the class:

/// Is used to implement an unknown method call.  It is also used
/// to resolve an unknown multidimensional property reference (to get the value
/// of a property) because that syntax is identical to a method call.
Method %DispatchMethod(Method As %String, Args...) [ ServerOnly = 1 ]
{
    // Amethod -> method
    set Method = $e(Method, 2, *)
    do $method(, "OnBefore" _ Method, Args...)
    do $method(, Method, Args...)
    do $method(,"OnAfter" _ Method,Args...)
}

So, as a whole it can look like this:

Class Utils.Annotations1 Extends %RegisteredObject
{

Method OnBeforeTest()
{
    Write "Init NiceTest1",!
}

/// @NiceTest1
Method Test()
{
    Write 1,!
}

Method OnAfterTest()
{
    Write "End NiceTest1",!
}

/// Is used to implement an unknown method call. 
Method %DispatchMethod(Method As %String, Args...) [ ServerOnly = 1 ]
{
    set Method = ..getMethodName(Method)
    do $method(, "OnBefore" _ Method, Args...)
    do $method(, Method, Args...)
    do $method(,"OnAfter" _ Method,Args...)
}

/// Is used to implement an unknown class method call
ClassMethod %DispatchClassMethod(Class As %String, Method As %String, Args...) [ ServerOnly = 1 ]
{
    set Method = ..getMethodName(Method)
    do $classmethod(, "OnBefore" _ Method, Args...)
    do $classmethod(, Method, Args...)
    do $classmethod(,"OnAfter" _ Method,Args...)
}

ClassMethod getMethodName(method As %String) As %String
{
    // Amethod -> method
    set method = $e(method, 2, *)
    return method
}

}

Works like this:

USER>do a.ATest()
Init NiceTest1
1
End NiceTest1
 
USER>do a.Test()
1

You can modify method code during compilation (obviously dangerous) using generators. Here's the sample that annotates all methods, containing @ in description:

Class Utils.Annotations
{

/// @NiceTest1
ClassMethod Test()
{
    Write 1
}

ClassMethod OnCompile() As %Status [ CodeMode = objectgenerator ]
{
    #dim sc As %Status = $$$OK
    for i=1:1:%class.Methods.Count() {
        #dim method As %Dictionary.MethodDefinition = %class.Methods.GetAt(i)
        if method.Description [ "@" {
            set sc = ..annotate(method)
            quit:$$$ISERR(sc)
        }
    }
    quit:$$$ISERR(sc) sc
    set sc = %class.%Save()
    quit sc
}

ClassMethod annotate(method As %Dictionary.MethodDefinition) As %Status
{
    #dim sc As %Status = $$$OK
    set code = method.Implementation.Read($$$MaxCacheInt)
    set code = ..cleadOldAnnotation(code)
    set code = ..addNewAnnotation(code, $e(method.Description, 2,*))
    
    do method.Implementation.Clear()
    do method.Implementation.Write(code)
    
    quit sc
}

ClassMethod cleadOldAnnotation(code As %String) As %String
{
    if $find(code, "//init annotation end") {
        set code = $e(code, $find(code, "//init annotation end") + 2, $find(code, "//complete annotation start") - $l("//complete annotation start") - 2)
    }
    return code
}

ClassMethod addNewAnnotation(code As %String, annotation As %String) As %String
{
    #define Tab $c(9)
    set code =  $$$Tab _ "Write ""Init " _ annotation _ """" _ $$$NL _
                $$$Tab _ "//init annotation end" _ $$$NL _
                code _
                $$$Tab _ "//complete annotation start"_ $$$NL _
                $$$Tab _ "Write ""End " _ annotation _ """"
    return code
}

}

Compiles into:

/// @NiceTest1
ClassMethod Test()
{
    Write "Init NiceTest1"
    //init annotation end
    Write 1
    //complete annotation start
    Write "End NiceTest1"
}

GitHub

You need:

• NodeJS
• Python 2
• npm, gyp
• C++ compiler

Kit.zip can be found here.

%DB_CACHESYS may also be required, because data for this table is stored in CACHESYS database.

Atelier accesses web port, which can be open.

• Are there any hardware differences?
• Are there differences in memory allocation?

You can ran them from a terminal.

Yes, same as with studio, Caché supports Unit Tests. Documentation.

write ##class(Config.CPF).Activate()

Would read and activate current configuration file without system restart.