How to Reveal Static Call Relationships in Your Code

• 2 min
• Mon, Oct 5
• X comments
• Edit Post

"3 developers try to find one static method they can safely change."

Where is the end of it? Where to start?

Yay, we found one static method that seems independent on others. Let's send pull-requests for review.

Later that day, on code review...

• "Well, it depends on one more method. Let's refactor it too..."
• "Oh, now we need to change 2 methods in the template too... Hm, how do we get a service into that template?"
• "Hm, this template is created in a static method as well. Let's register it as a service..."
• "Ups, 3 more classes use this static service..."

Turmoil.

Stop & Relax

In a situation like this, let's take time to step back, breathe, and relax. There is a way to get out this, but brute force is not one of them.

"A journey of a thousand miles begins with a single step."

Recipe for Static Success

If we refactor 100+ static methods manually, we'll probably end up in the stress and frustration like in the story above.

The goal is to take one method at a time. But not just any static method. The easiest possible. How do we find it?

Take Low Hanging Fruit

The easiest static method is the one with the least coupling, or with a coupling that is easiest to remove, e.g.

• static method that is never used → remove it
• static method that is used only locally → remove static
• static method that is used only in local static method → make it private
• static method that is used only in template → refactor is to filter service

But you already know that, right? Anyone can remove method that is never used. What is the hard problem? How can we be sure the method is not really used?

Static Detector to the Rescue

To get these data, we use a handy tool migrify/static-detector.

Install it:

composer require migrify/static-detector --dev

Run it on your directory:

vendor/bin/static-detector detect src

We'll see the overview of all static methods, with all related static calls.

From the most spread one in the top, into the least coupled in the bottom.

For following file:

<?php

// src/SomeStatic.php
final class SomeStatic
{
    public static function neverCalled()
    {
    }

    public function run()
    {
        self::calledJustOnce();
    }

    public static function calledJustOnce()
    {
    }
}

We get this result:

Now even 700+ static methods do seem like such a big problem, right?

Happy coding!