Inheritance diagram for ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule:

Collaboration diagram for ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule:

Public Member Functions
	__construct (ReflectionProvider $reflectionProvider, \PHPStan\Rules\Generics\GenericAncestorsCheck $genericAncestorsCheck)

	getNodeType ()

	processNode (Node $node, Scope $scope)

Protected Member Functions
	findInstanceCreation ()

	findMethodUsages ()

	getForbiddenClasses ()

	getHumanReadableRuleName ()

	getRelevantILIASVersion ()

Protected Attributes
ReflectionProvider	$reflectionProvider

PHPStan Rules Generics GenericAncestorsCheck	$genericAncestorsCheck

Private Member Functions
	getClassAncestors (string $class_name)

	cacheAncestors ($class_name, array $ancestor_classes)

	instantiatesForbiddenClasses (Node $node)

	usesMethodsOfForbiddenClass (Node $node, Scope $scope)

Private Attributes
array	$forbidden_classes = []

array	$ancestor_cache = []

Detailed Description

Definition at line 28 of file LegacyClassUsageRule.php.

Constructor & Destructor Documentation

◆ __construct()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::__construct	(	ReflectionProvider	$reflectionProvider,
		\PHPStan\Rules\Generics\GenericAncestorsCheck	$genericAncestorsCheck
	)

Definition at line 35 of file LegacyClassUsageRule.php.

      {
        $this->reflectionProvider = $reflectionProvider;
        $this->genericAncestorsCheck = $genericAncestorsCheck;
 
        // Determine possible class-names (parents and children) of the forbidden classes
        $forbidden_classes = [];
 
        foreach ($this->getForbiddenClasses() as $forbidden_class) {
            $ancestors = $this->getClassAncestors($forbidden_class);
            $this->cacheAncestors($forbidden_class, $ancestors);
            $forbidden_classes = array_merge(
                $forbidden_classes,
                $ancestors
            );
        }
 
        $this->forbidden_classes = array_unique($forbidden_classes);
    }

References ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\$forbidden_classes, ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\$genericAncestorsCheck, ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\$reflectionProvider, ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\cacheAncestors(), ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\getClassAncestors(), and ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\getForbiddenClasses().

Here is the call graph for this function:

Member Function Documentation

◆ cacheAncestors()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::cacheAncestors	(		$class_name,
		array	$ancestor_classes
	)

private

Definition at line 76 of file LegacyClassUsageRule.php.

                                                                         : void
    {
        $this->ancestor_cache[$class_name] = $ancestor_classes;
    }

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\__construct(), and ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\instantiatesForbiddenClasses().

Here is the caller graph for this function:

◆ findInstanceCreation()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::findInstanceCreation ( )

protected

Definition at line 86 of file LegacyClassUsageRule.php.

                                             : bool
    {
        return true;
    }

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\processNode().

Here is the caller graph for this function:

◆ findMethodUsages()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::findMethodUsages ( )

protected

Reimplemented in ILIAS\Scripts\PHPStan\Rules\NoLegacyTabsUsagesRule, and ILIAS\Scripts\PHPStan\Rules\NoLegacyToolbarUsagesRule.

Definition at line 91 of file LegacyClassUsageRule.php.

                                         : bool
    {
        return false;
    }

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\processNode().

Here is the caller graph for this function:

◆ getClassAncestors()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::getClassAncestors ( string $class_name )

private

Definition at line 57 of file LegacyClassUsageRule.php.

                                                          : array
    {
        if (isset($this->ancestor_cache[$class_name])) {
            return $this->ancestor_cache[$class_name];
        }
 
        $ancestors[] = $class_name;
 
        try {
            $reflection = $this->reflectionProvider->getClass($class_name);
            $ancestors = array_merge($ancestors, $reflection->getParentClassesNames());
        } catch (\PHPStan\Broker\ClassNotFoundException $e) {
            // Do nothing
        } finally {
            unset($reflection);
        }
        return array_unique($ancestors);
    }

References Vendor\Package\$e.

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\__construct(), and ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\instantiatesForbiddenClasses().

Here is the caller graph for this function:

◆ getForbiddenClasses()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::getForbiddenClasses ( )

abstractprotected

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\__construct(), and ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\usesMethodsOfForbiddenClass().

Here is the caller graph for this function:

◆ getHumanReadableRuleName()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::getHumanReadableRuleName ( )

abstractprotected

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\processNode().

Here is the caller graph for this function:

◆ getNodeType()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::getNodeType ( )

Definition at line 81 of file LegacyClassUsageRule.php.

                                 : string
    {
        return CallLike::class;
    }

◆ getRelevantILIASVersion()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::getRelevantILIASVersion ( )

abstractprotected

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\processNode().

Here is the caller graph for this function:

◆ instantiatesForbiddenClasses()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::instantiatesForbiddenClasses ( Node $node )

private

Definition at line 102 of file LegacyClassUsageRule.php.

                                                             : bool
    {
        if ($node->class instanceof Node\Name) {
            $class_name = $node->class->toString();
        } else {
            return false;
        }
        $class_names_to_test = $this->getClassAncestors($class_name);
 
        $array_intersect = array_intersect($class_names_to_test, $this->forbidden_classes);
        if ($array_intersect !== []) {
            $this->cacheAncestors($class_name, $class_names_to_test);
            return true;
        }
        return false;
    }

References ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\cacheAncestors(), and ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\getClassAncestors().

Referenced by ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\processNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processNode()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::processNode	(	Node	$node,
		Scope	$scope
	)

final

Definition at line 131 of file LegacyClassUsageRule.php.

                                                               : array
    {
        // Find new Instance Creation or Static Method Calls
        if ($this->findInstanceCreation()
            && ($node instanceof Node\Expr\StaticCall || $node instanceof Node\Expr\New_)
            && $this->instantiatesForbiddenClasses($node)
        ) {
            $class_name = $node->class->toString();
            return [
                RuleErrorBuilder::message("Usage of $class_name is forbidden.")
                                ->metadata([
                                    'rule' => $this->getHumanReadableRuleName(),
                                    'version' => $this->getRelevantILIASVersion(),
                                ])
                                ->build()
            ];
        }
 
        // Find Method Calls to forbidden classes
        if ($node instanceof Node\Expr\MethodCall
            && $this->findMethodUsages()
            && $this->usesMethodsOfForbiddenClass($node, $scope)
        ) {
            $method_name = $node->name->name;
            $class_name = $scope->getType($node->var)->getObjectClassNames()[0];
            return [
                RuleErrorBuilder::message("Usage of $class_name::$method_name is forbidden.")
                                ->metadata([
                                    'rule' => $this->getHumanReadableRuleName(),
                                    'version' => $this->getRelevantILIASVersion(),
                                ])
                                ->build()
            ];
        }
 
        return [];
    }

References $scope, ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\findInstanceCreation(), ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\findMethodUsages(), ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\getHumanReadableRuleName(), ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\getRelevantILIASVersion(), ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\instantiatesForbiddenClasses(), and ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule\usesMethodsOfForbiddenClass().

Here is the call graph for this function:

◆ usesMethodsOfForbiddenClass()

ILIAS\Scripts\PHPStan\Rules\LegacyClassUsageRule::usesMethodsOfForbiddenClass	(	Node	$node,
		Scope	$scope
	)

private

Definition at line 119 of file LegacyClassUsageRule.php.

                                                                          : bool
    {
        if (!$node->name instanceof Node\Identifier) {
            return false;
        }
        $method_name = $node->name->name;
        $called_classes = $scope->getType($node->var)->getObjectClassNames();
        $forbidden_classes = $this->getForbiddenClasses();
 
        return array_intersect($called_classes, $forbidden_classes) !== [];
    }