How to find all classes that are getting dynamic properties assigned?

[sneakyimp]

I'm working on a site implemented in CodeIgniter 3. We are trying to upgrade the server because it's running Ubuntu 16 / PHP 7 which are both now EOL. The website code works pretty great with PHP 8.1 but the latest release is PHP 8.2.1 and we'd like to get as up-to-date as possible if we are going through the trouble of upgrading. Unfortunately, PHP 8.2 deprecates dynamic properties for a class object, and CI3 rampantly assigns such dynamic properties.

I know we can address this problem by A) creating magic __set and __get methods or by B) adding this new attribute before each class that endures this abuse:

#[\AllowDynamicProperties]
class FooClass {
    // blah blah blah
}
$foo = new FooClass();
$foo->some_new_property = 42;

Question 1: Which solution do you guys prefer for this sort of problem?
The magic methods approach, A, might let you include some logic to respond to possibly abusive behaviors, Whereas the attribute approach, B, is briefer.

Question 2: Is there some efficient way to identify all the classes that undergo this abuse?
I wonder if there is some IDE tool that might detect this problem? Or can anyone suggest an approach to identifying all the poor classes that are subject to this abominable mistreatment?

EDIT: Note that there's a discussion of this very question on github. If anyone is interested in chiming in over there, it would probably draw more attention to the issue, which would be nice.

[NogDog]

Had some time on my hands this afternoon, so I threw this together, and it seems promising...but not rigorously tested. 🙂 (Probably need to add something for self::$something = ..., too.)

#!/usr/bin/env php
<?php
/**
 * Look for undeclared property assignments
 * 
 * USAGE:
 *   deprecated.php ( file | directory )
 */

if(empty($argv[1])) {
  die("USAGE: deprecated.php ( file | directory )\n");
}

$files = [];
$input = rtrim($argv[1], '/');
if (is_dir($input)) {
  $files = glob("$input/*.php");
  if (!$files) {
    die("No PHP files found in $input\n");
  }
} elseif (is_file($input)) {
  $files[] = $input;
} else {
  die("Nothing found for $input\n");
}

$assignment_regex = '/\$this->(\w+)\s*=/';
$find_regex = '/(private|protected|public)(\s+\w+)?\s+\$%s\b/';

foreach ($files as $file) {
  echo "$file\n";
  $text = file_get_contents($file);
  if (trim($text) === '') {
    die("File not found/loaded\n");
  }

  preg_match_all($assignment_regex, $text, $matches);
  foreach ($matches[1] as $name) {
    $regex = sprintf($find_regex, $name);
    if (!preg_match($regex, $text)) {
      echo "  * No declaration found for \$this->$name\n";
    }
  }
}

[benanamen]

Answer 1: The decision between the two solutions depends on your specific use case and your team's preferences. The magic methods approach, A, may be more flexible as it allows for more complex logic to be executed when the dynamic properties are set or accessed. However, the attribute approach, B, is simpler and less prone to errors, and it would work just as well for most use cases.

Answer 2: One way to identify all the classes that undergo this abuse would be to search the codebase for instances of dynamic property assignments, such as $foo->some_new_property = 42;. This can be done using a text editor with a "find in files" feature or using a command line tool such as grep. Additionally, some IDEs, such as PhpStorm, have built-in features to search for specific patterns in the codebase, which could be used to identify the dynamic property assignments.

Another approach is to use a code analysis tool that can identify instances of deprecated or problematic code. Some popular examples include Psalm, PHPStan, and Phan. These tools can often be integrated with your development environment, such as with a plugin for your text editor or IDE, and can help you identify potential issues with the codebase, including instances of dynamic property assignments.

Overall, it's important to keep in mind that upgrading to PHP 8.2 may involve changes to your codebase, so it's essential to thoroughly test your application before deploying it to a production environment.