autoinstrument classes for cDebug::enter() and cDebug::leave()

[open768]

copilot suggests its possible to autoinstrument classes

<?php

class cDebug {
    private static $appClasses = [];

    public static function initialize() {
        // Get the list of declared classes before including application files
        $coreClasses = get_declared_classes();

        // Include your application files
        require_once "manifest.php";
        require_once "orm_manifest.php";

        // Get the list of declared classes after including application files
        $allClasses = get_declared_classes();

        // Determine the classes declared by the application
        self::$appClasses = array_diff($allClasses, $coreClasses);
    }

    public static function instrumentAll() {
        foreach (self::$appClasses as $className) {
            self::instrument($className);
        }
    }

    private static function instrument($className) {
        $reflectionClass = new ReflectionClass($className);
        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC);

        foreach ($methods as $method) {
            $methodName = $method->getName();
            if ($methodName !== '__construct') {
                self::wrapMethod($className, $methodName);
            }
        }
    }

    private static function wrapMethod($className, $methodName) {
        $originalMethod = new ReflectionMethod($className, $methodName);
        $originalMethod->setAccessible(true);

        $classInstance = new $className();
        $originalMethodClosure = $originalMethod->getClosure($classInstance);

        $newMethod = function () use ($originalMethodClosure, $methodName) {
            cDebug::enter($methodName);
            $result = call_user_func_array($originalMethodClosure, func_get_args());
            cDebug::leave($methodName);
            return $result;
        };

        $classInstance->$methodName = Closure::bind($newMethod, $classInstance, $className);
    }

    public static function enter($methodName) {
        echo "Entering method: $methodName\n";
    }

    public static function leave($methodName) {
        echo "Leaving method: $methodName\n";
    }
}

// Initialize and instrument all application classes
cDebug::initialize();
cDebug::instrumentAll();

// Example usage
$manifest = new cCuriosityORMManifest();
$manifest->updateIndex();

[open768]

had i looked at the code that copiot produced, i would have seen its creating an instance of the class and changing the instance methiod. thats as useful as a chocolate teapot

[open768]

but could it be done another way. the instrumenter could read the php code and write out a modified version, so that next time the code ran, everything would be autoinstrumented.

[open768]

https://github.com/nikic/PHP-Parser will be useful

[open768]

chat gpt suggests using attributes:

Solution: Abstract Superclass with Debug Decorator Logic
By placing the __call() method in a base class, we ensure that all child classes inherit the decorator behavior automatically.

Step 1: Create a Base Class with Debug Logic

abstract class Debuggable
{
    public function __call($name, $arguments)
    {
        $reflection = new ReflectionMethod($this, $name);

        // Check if the method has the #[DebugDecorator] attribute
        $attributes = $reflection->getAttributes(DebugDecorator::class);

        if (!empty($attributes)) {
            echo "function " . static::class . "::$name started\n";
        }

        // Call the actual function
        $result = $reflection->invoke($this, ...$arguments);

        if (!empty($attributes)) {
            echo "function " . static::class . "::$name ended\n";
        }

        return $result;
    }
}

Step 2: Define the Debug Decorator Attribute

#[Attribute]
class DebugDecorator
{
}

Step 3: Create a Subclass That Uses the Decorator

class MyClass extends Debuggable
{
    #[DebugDecorator]
    public function myfunc()
    {
        echo "hello\n";
    }
}

Step 4: Call Methods Normally
$instance = new MyClass();
$instance->myfunc();
function MyClass::myfunc started
hello
function MyClass::myfunc ended
How It Works