Drupal Rector Rules

Remove deprecated no-op InstallerTestBase::setUpProfile() calls

Sat, 12 Sep 2026 01:00:26 GMT

Source: #3520028
Timeline: Deprecated in Drupal 11.4.0, removed in Drupal 12.0.0

Drupal 11.4 removed the UI installer's profile-selection step, so InstallerTestBase::setUpProfile() is now a no-op that only triggers an E_USER_DEPRECATED notice with no replacement. Contrib and distribution functional tests that extend this base class and replicate the old step-by-step installer sequence (a common pattern in core's own installer tests) call $this->setUpProfile(); as a bare statement. This rule removes that statement, silencing the deprecation notice without changing test behavior, since the step no longer exists.

Before

class MyDistroInstallerTest extends \Drupal\FunctionalTests\Installer\InstallerTestBase {
  public function testInstaller(): void {
    $this->visitInstaller();
    $this->setUpLanguage();
    $this->setUpProfile();
    $this->setUpRequirementsProblem();
    $this->setUpSettings();
  }
}

After

class MyDistroInstallerTest extends \Drupal\FunctionalTests\Installer\InstallerTestBase {
  public function testInstaller(): void {
    $this->visitInstaller();
    $this->setUpLanguage();
    $this->setUpRequirementsProblem();
    $this->setUpSettings();
  }
}

Caveats

Only removes bare, no-argument $this->setUpProfile(); statement calls. It does not touch method overrides of setUpProfile() (e.g. a subclass that adds assertions and then calls parent::setUpProfile();), since those mix custom logic that needs human review; nor calls with arguments or on non-$this receivers, which never matched the deprecated API shape.

Code

<?php
declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Stmt\Expression;
use PhpParser\NodeVisitor;
use PHPStan\Type\ObjectType;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class RemoveDeprecatedInstallerTestSetUpProfileCallRector extends AbstractRector
{
    private const BASE_CLASS = 'Drupal\FunctionalTests\Installer\InstallerTestBase';

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Remove calls to the now-deprecated, no-op InstallerTestBase::setUpProfile().',
            [new CodeSample(
                <<<'CODE_SAMPLE'
$this->visitInstaller();
$this->setUpLanguage();
$this->setUpProfile();
$this->setUpRequirementsProblem();
CODE_SAMPLE
                ,
                <<<'CODE_SAMPLE'
$this->visitInstaller();
$this->setUpLanguage();
$this->setUpRequirementsProblem();
CODE_SAMPLE
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [Expression::class];
    }

    /** @param Expression $node */
    public function refactor(Node $node)
    {
        if (!$node instanceof Expression) {
            return null;
        }
        if (!$node->expr instanceof MethodCall) {
            return null;
        }
        $methodCall = $node->expr;
        if (!$this->isName($methodCall->name, 'setUpProfile')) {
            return null;
        }
        if (count($methodCall->args) !== 0) {
            return null;
        }
        if (!$methodCall->var instanceof Variable || !$this->isName($methodCall->var, 'this')) {
            return null;
        }
        if (!$this->isObjectType($methodCall->var, new ObjectType(self::BASE_CLASS))) {
            return null;
        }

        return NodeVisitor::REMOVE_NODE;
    }
}

return RectorConfig::configure()->withRules([RemoveDeprecatedInstallerTestSetUpProfileCallRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated update.inc global functions with the DatabaseUpdate service

Fri, 11 Sep 2026 20:20:54 GMT

Source: #3391683
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Rewrites calls to the deprecated global functions update_check_requirements(), update_system_schema_requirements(), and update_do_one() (defined in core/includes/update.inc) into calls on the new Drupal\Core\Update\DatabaseUpdate service, obtained via \Drupal::service(DatabaseUpdate::class). For update_do_one(), the $number argument is also cast to int to match the new method's strict type. This helps contrib code (custom update requirement checks, custom batch update runners) migrate ahead of the functions' removal.

Before

function mymodule_update_10001() {
  $requirements = update_check_requirements();
  return $requirements;
}

function mymodule_batch_wrapper($module, $number, $dependency_map, &$context) {
  update_do_one($module, $number, $dependency_map, $context);
}

After

function mymodule_update_10001() {
  $requirements = \Drupal::service(\Drupal\Core\Update\DatabaseUpdate::class)->getRequirements();
  return $requirements;
}

function mymodule_batch_wrapper($module, $number, $dependency_map, &$context) {
  \Drupal::service(\Drupal\Core\Update\DatabaseUpdate::class)->doOne($module, (int) $number, $dependency_map, $context);
}

Caveats

Does not rewrite _update_fix_missing_schema(): that function is documented as internal-use-only with no public replacement, so it is intentionally left out. Does not rewrite the string 'update_do_one' when passed as a batch operation callback name (e.g. $batch_builder->addOperation('update_do_one', [...])); that shape is a plain string literal, not a function call, and must be updated manually to DatabaseUpdate::class . ':doOne'. Calls using named arguments, argument unpacking (...$args), or a non-default arg count are left untouched to avoid mis-rewriting call shapes the rule cannot safely reason about.

Code

<?php
declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Cast\Int_;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceUpdateIncFunctionsWithDatabaseUpdateServiceRector extends AbstractRector
{
    /**
     * Maps deprecated global function name to the DatabaseUpdate method
     * name and the exact argument count each one requires.
     *
     * @var array<string, array{0: string, 1: int}>
     */
    private const FUNCTION_MAP = [
        'update_check_requirements' => ['getRequirements', 0],
        'update_system_schema_requirements' => ['systemSchemaRequirements', 0],
        'update_do_one' => ['doOne', 4],
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace calls to the deprecated update.inc functions update_check_requirements(), update_system_schema_requirements() and update_do_one() with calls to the Drupal\Core\Update\DatabaseUpdate service.',
            [new CodeSample(
                'update_do_one($module, $number, $dependency_map, $context);',
                '\\Drupal::service(\\Drupal\\Core\\Update\\DatabaseUpdate::class)->doOne($module, (int) $number, $dependency_map, $context);',
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }

        // Dynamic call target such as $fn(); the name is not a Name node.
        if (!$node->name instanceof Node\Name) {
            return null;
        }

        $functionName = $this->getName($node->name);
        if ($functionName === null || !isset(self::FUNCTION_MAP[$functionName])) {
            return null;
        }

        [$methodName, $expectedArgCount] = self::FUNCTION_MAP[$functionName];

        if (count($node->args) !== $expectedArgCount) {
            return null;
        }

        $args = $node->args;

        if ($functionName === 'update_do_one') {
            // Only rewrite when every argument is a plain positional Arg
            // (skip named args, spreads and unpacked args to stay safe).
            foreach ($args as $arg) {
                if (!$arg instanceof Arg || $arg->name !== null || $arg->unpack) {
                    return null;
                }
            }

            // update_do_one($module, $number, ...) took $number untyped;
            // doOne() requires an int, so cast it explicitly.
            $args[1] = new Arg(new Int_($args[1]->value));
        }

        $service = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg(new ClassConstFetch(new FullyQualified('Drupal\\Core\\Update\\DatabaseUpdate'), 'class'))],
        );

        return new MethodCall($service, $methodName, $args);
    }
}

return RectorConfig::configure()->withRules([ReplaceUpdateIncFunctionsWithDatabaseUpdateServiceRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace drupal_attach_tabledrag() with Table::attachTabledrag()

Fri, 11 Sep 2026 16:26:52 GMT

Source: #3035343
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Rewrites calls to the deprecated global function drupal_attach_tabledrag() into calls to the new \Drupal\Core\Render\Element\Table::attachTabledrag() static method, which now holds the logic. The function is deprecated in drupal:11.5.0 and will be removed in drupal:13.0.0. Only two-argument calls ($element, $options) are rewritten; the argument list is passed through unchanged, preserving named arguments and by-reference semantics.

Before

$element = [];
$options = [
  'table_id' => 'my-module-table',
  'action' => 'order',
  'relationship' => 'sibling',
  'group' => 'my-elements-weight',
];
drupal_attach_tabledrag($element, $options);

After

$element = [];
$options = [
  'table_id' => 'my-module-table',
  'action' => 'order',
  'relationship' => 'sibling',
  'group' => 'my-elements-weight',
];
\Drupal\Core\Render\Element\Table::attachTabledrag($element, $options);

Caveats

Only rewrites calls with exactly two arguments, matching the function's fixed (&$element, array $options) signature; calls with a different arity (which would already be fatal errors against the real function) are left untouched.

Code

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceDrupalAttachTabledragRector extends AbstractRector
{
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace drupal_attach_tabledrag() with \Drupal\Core\Render\Element\Table::attachTabledrag().',
            [new CodeSample(
                'drupal_attach_tabledrag($element, $options);',
                '\Drupal\Core\Render\Element\Table::attachTabledrag($element, $options);',
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }
        if (!$this->isName($node, 'drupal_attach_tabledrag')) {
            return null;
        }
        if (count($node->args) !== 2) {
            return null;
        }

        return new StaticCall(
            new FullyQualified('Drupal\\Core\\Render\\Element\\Table'),
            'attachTabledrag',
            $node->args,
        );
    }
}

return RectorConfig::configure()->withRules([ReplaceDrupalAttachTabledragRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace views_invalidate_cache() with Views::invalidateCache()

Thu, 10 Sep 2026 16:24:36 GMT

Source: #941970
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

The global function views_invalidate_cache() is deprecated in favor of \Drupal\views\Views::invalidateCache(). The new static method only invalidates the views_data cache tag and invokes hook_views_invalidate_cache(); it no longer forces a router rebuild, since that is now handled per-display via the PostSaveViewInterface machinery introduced in the same change. This rule rewrites simple call sites so modules keep working after the function is removed.

Before

views_invalidate_cache();

After

\Drupal\views\Views::invalidateCache();

Caveats

Only rewrites the cache-invalidation call itself. The old function also unconditionally called \Drupal::service('router.builder')->setRebuildNeeded(); callers that relied on views_invalidate_cache() to also trigger a router rebuild must add that call explicitly (\Drupal::service('router.builder')->setRebuildNeeded(); and, for Views' own route subscriber, \Drupal::service('views.route_subscriber')->reset();), since the replacement method no longer does this.

Code

<?php

declare(strict_types=1);

use Rector\Config\RectorConfig;
use Rector\Renaming\Rector\FuncCall\RenameFunctionRector;

return RectorConfig::configure()
    ->withConfiguredRule(RenameFunctionRector::class, [
        'views_invalidate_cache' => 'Drupal\\views\\Views::invalidateCache',
    ]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated user.module cancel functions with the AccountCancellation service

Wed, 09 Sep 2026 16:27:11 GMT

Source: #3620912
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates the global functions user_cancel(), _user_cancel(), _user_cancel_session_regenerate(), and user_cancel_methods() in favor of the new Drupal\user\AccountCancellation service, which exposes equivalent cancel(), cancelAccount(), regenerateSession(), and cancelMethods() methods. This rule rewrites direct calls to these global functions into calls on the service fetched via \Drupal::service(AccountCancellation::class), so contrib and custom code invoking user account cancellation continues to work once the functions are removed in Drupal 13.

Before

user_cancel($edit, $uid, $method);
_user_cancel($edit, $account, $method);
_user_cancel_session_regenerate();
$methods = user_cancel_methods();

After

\Drupal::service(\Drupal\user\AccountCancellation::class)->cancel($edit, $uid, $method);
\Drupal::service(\Drupal\user\AccountCancellation::class)->cancelAccount($edit, $account, $method);
\Drupal::service(\Drupal\user\AccountCancellation::class)->regenerateSession();
$methods = \Drupal::service(\Drupal\user\AccountCancellation::class)->cancelMethods();

Caveats

Only rewrites direct calls to these four global function names; dynamic calls ($fn(), call_user_func()) and same-named methods/static calls on unrelated classes are left untouched since they cannot be safely disambiguated at the AST level.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceUserCancelFunctionsWithAccountCancellationRector extends AbstractRector
{
    /**
     * @var array<string, string>
     */
    private const FUNCTION_TO_METHOD = [
        'user_cancel' => 'cancel',
        '_user_cancel' => 'cancelAccount',
        '_user_cancel_session_regenerate' => 'regenerateSession',
        'user_cancel_methods' => 'cancelMethods',
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated user.module account cancellation functions with the AccountCancellation service.',
            [new CodeSample(
                'user_cancel($edit, $uid, $method);',
                "\Drupal::service(\Drupal\user\AccountCancellation::class)->cancel(\$edit, \$uid, \$method);",
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }
        if ($node->name instanceof Node\Expr) {
            // Dynamic function calls (e.g. $fn()) are never a match.
            return null;
        }
        $functionName = $this->getName($node->name);
        if ($functionName === null || !isset(self::FUNCTION_TO_METHOD[$functionName])) {
            return null;
        }

        $service = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg($this->nodeFactory->createClassConstFetch('Drupal\\user\\AccountCancellation', 'class'))],
        );

        return new MethodCall($service, self::FUNCTION_TO_METHOD[$functionName], $node->args);
    }
}

return RectorConfig::configure()->withRules([ReplaceUserCancelFunctionsWithAccountCancellationRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Convert markFutureUpdateEquivalent() call to #[MarkFutureUpdateEquivalent] attribute

Mon, 07 Sep 2026 20:27:20 GMT

Source: #3561302
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Calling \Drupal::service('update.update_hook_registry')->markFutureUpdateEquivalent($number, $version) with only the legacy 2 arguments inside a hook_update_N() body is deprecated. The replacement is the #[MarkFutureUpdateEquivalent($number, $version)] attribute placed on the update function itself, which also lets the equivalent update register on module install (not just during database updates). This rule moves the two literal arguments from the removed statement onto the enclosing function as an attribute.

Before

function my_module_update_10400(): void {
  \Drupal::service('update.update_hook_registry')->markFutureUpdateEquivalent(11101, '11.1.1');
}

After

#[\Drupal\Core\Update\Attribute\MarkFutureUpdateEquivalent(11101, '11.1.1')]
function my_module_update_10400(): void {
}

Caveats

Only rewrites calls with exactly 2 positional literal arguments (int, string) on \Drupal::service('update.update_hook_registry')->markFutureUpdateEquivalent(...), and only when the call is a direct top-level statement in a function named like ..._update_<number>. Calls already passing the newer $module/$ran_update_number arguments, calls using named arguments, non-literal argument values, or calls inside non-update-hook-named functions are left untouched to avoid mis-rewrites. The attribute is emitted with its fully qualified class name rather than adding a use statement, since automatic import-cleanup in Rector's config also strips backslashes from unrelated \Drupal::... calls elsewhere in the same file.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Attribute;
use PhpParser\Node\AttributeGroup;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\Stmt\Expression;
use PhpParser\Node\Stmt\Function_;
use Rector\Config\RectorConfig;
use Rector\PhpParser\Node\Value\ValueResolver;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ConvertMarkFutureUpdateEquivalentCallToAttributeRector extends AbstractRector
{
    public function __construct(
        private readonly ValueResolver $valueResolver,
    ) {
    }

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Converts a 2-argument UpdateHookRegistry::markFutureUpdateEquivalent() call inside a hook_update_N() body into the #[MarkFutureUpdateEquivalent] attribute on the function.',
            [new CodeSample(
                <<<'CODE_SAMPLE'
function my_module_update_10400(): void {
  \Drupal::service('update.update_hook_registry')->markFutureUpdateEquivalent(11101, '11.1.1');
}
CODE_SAMPLE
                ,
                <<<'CODE_SAMPLE'
#[\Drupal\Core\Update\Attribute\MarkFutureUpdateEquivalent(11101, '11.1.1')]
function my_module_update_10400(): void {
}
CODE_SAMPLE
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [Function_::class];
    }

    /** @param Function_ $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof Function_) {
            return null;
        }
        // The attribute only takes effect on an actual hook_update_N()
        // function: module install reflects on "{module}_update_{schema}".
        if (!preg_match('/_update_\d+$/', $this->getName($node) ?? '')) {
            return null;
        }

        $hasChanged = false;
        foreach ($node->stmts as $key => $stmt) {
            $attribute = $this->matchMarkFutureUpdateEquivalentAttribute($stmt);
            if ($attribute === null) {
                continue;
            }

            $node->attrGroups[] = new AttributeGroup([$attribute]);
            unset($node->stmts[$key]);
            $hasChanged = true;
        }

        if (!$hasChanged) {
            return null;
        }

        $node->stmts = array_values($node->stmts);

        return $node;
    }

    private function matchMarkFutureUpdateEquivalentAttribute(Node $stmt): ?Attribute
    {
        if (!$stmt instanceof Expression) {
            return null;
        }
        $call = $stmt->expr;
        if (!$call instanceof MethodCall) {
            return null;
        }
        if (!$this->isName($call->name, 'markFutureUpdateEquivalent')) {
            return null;
        }
        // Only the deprecated 2-argument call is rewritten. A call already
        // passing $module and $ran_update_number is not the deprecated shape.
        if (count($call->args) !== 2) {
            return null;
        }
        [$numberArg, $versionArg] = $call->args;
        if (!$numberArg instanceof Arg || !$versionArg instanceof Arg) {
            return null;
        }
        // Named arguments could reorder the values; skip rather than risk
        // swapping the number and version when rebuilding as an attribute.
        if ($numberArg->name !== null || $versionArg->name !== null) {
            return null;
        }
        // Attribute arguments must be constant expressions: restrict to the
        // literal shapes actually used in core and contrib.
        if (!$numberArg->value instanceof Int_ || !$versionArg->value instanceof String_) {
            return null;
        }

        $caller = $call->var;
        if (!$caller instanceof StaticCall) {
            return null;
        }
        if (!$this->isName($caller->class, 'Drupal')) {
            return null;
        }
        if (!$this->isName($caller->name, 'service')) {
            return null;
        }
        if (count($caller->args) !== 1 || !$caller->args[0] instanceof Arg) {
            return null;
        }
        if (!$this->valueResolver->isValue($caller->args[0]->value, 'update.update_hook_registry')) {
            return null;
        }

        return new Attribute(
            new FullyQualified('Drupal\Core\Update\Attribute\MarkFutureUpdateEquivalent'),
            [new Arg($numberArg->value), new Arg($versionArg->value)],
        );
    }
}

return RectorConfig::configure()
    ->withRules([ConvertMarkFutureUpdateEquivalentCallToAttributeRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace user_role_*_permissions() functions with RoleInterface methods

Mon, 07 Sep 2026 12:33:21 GMT

Source: #2025089
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates the global functions user_role_grant_permissions(), user_role_revoke_permissions(), and user_role_change_permissions() in favor of the grantPermissions(), revokePermissions(), and changePermissions() methods on RoleInterface. This rule rewrites each FuncCall into \Drupal\user\Entity\Role::loadOverrideFree($rid)?->method($permissions)?->save(), using nullsafe chaining so behavior stays safe when the role does not exist, matching the pattern Drupal core itself uses in media.install and node.install.

Before

user_role_grant_permissions('anonymous', ['access content']);
user_role_revoke_permissions('anonymous', ['access content']);
user_role_change_permissions('anonymous', ['access content' => TRUE]);

After

\Drupal\user\Entity\Role::loadOverrideFree('anonymous')?->grantPermissions(['access content'])?->save();
\Drupal\user\Entity\Role::loadOverrideFree('anonymous')?->revokePermissions(['access content'])?->save();
\Drupal\user\Entity\Role::loadOverrideFree('anonymous')?->changePermissions(['access content' => TRUE])?->save();

Caveats

Skips calls using named arguments or argument unpacking (...$args), and calls with more than two positional arguments (the deprecated functions never had a third). user_role_revoke_permissions() did not null-check the loaded role internally (it would fatal on an unknown $rid), while the rewritten nullsafe chain silently no-ops instead; this is strictly safer and matches the pattern core itself adopted for the other two functions.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\Array_;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\NullsafeMethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceUserRolePermissionFunctionsRector extends AbstractRector
{
    /** @var array<string, string> */
    private const FUNCTION_TO_METHOD = [
        'user_role_grant_permissions' => 'grantPermissions',
        'user_role_revoke_permissions' => 'revokePermissions',
        'user_role_change_permissions' => 'changePermissions',
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace user_role_grant_permissions(), user_role_revoke_permissions() and user_role_change_permissions() with the corresponding RoleInterface method, loading the role with Role::loadOverrideFree() first.',
            [new CodeSample(
                "user_role_grant_permissions('anonymous', ['access content']);",
                "\\Drupal\\user\\Entity\\Role::loadOverrideFree('anonymous')?->grantPermissions(['access content'])?->save();",
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }

        $functionName = $this->getName($node->name);
        if ($functionName === null || !isset(self::FUNCTION_TO_METHOD[$functionName])) {
            return null;
        }

        if (count($node->args) < 1 || count($node->args) > 2) {
            return null;
        }

        // Skip named arguments and argument unpacking; too rare to be worth the complexity.
        foreach ($node->args as $arg) {
            if (!$arg instanceof Arg) {
                return null;
            }
            if ($arg->name !== null || $arg->unpack) {
                return null;
            }
        }

        $ridArg = $node->args[0];
        $permissionsArg = $node->args[1] ?? new Arg(new Array_([]));

        $methodName = self::FUNCTION_TO_METHOD[$functionName];

        $loadCall = new StaticCall(
            new FullyQualified('Drupal\\user\\Entity\\Role'),
            'loadOverrideFree',
            [$ridArg],
        );

        $permissionsCall = new NullsafeMethodCall($loadCall, $methodName, [$permissionsArg]);

        return new NullsafeMethodCall($permissionsCall, 'save');
    }
}

return RectorConfig::configure()->withRules([ReplaceUserRolePermissionFunctionsRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Rewrite deprecated update.compare.inc functions to UpdateCalculator/UpdateManager services

Fri, 04 Sep 2026 20:22:57 GMT

Source: #3580705
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal core deprecated three update.module global functions in favor of service methods: update_process_project_info() and update_calculate_project_update_status() moved to the internal Drupal\update\UpdateCalculator service, and update_calculate_project_data() moved to Drupal\update\UpdateManagerInterface::calculateProjectData(). This rule rewrites call sites to the equivalent service calls, including converting the by-reference update_calculate_project_update_status() call into an assignment that wraps arguments in the new UpdateProject/UpdateServerProjectInfo value objects and unwraps the result with toArray(), mirroring the deprecated function's own forwarding implementation.

Before

update_process_project_info($projects);
$data = update_calculate_project_data($available);
update_calculate_project_update_status($project_data, $available);

After

\Drupal::service(\Drupal\update\UpdateCalculator::class)->processProjectInfo($projects);
$data = \Drupal::service(\Drupal\update\UpdateManagerInterface::class)->calculateProjectData($available);
$project_data = \Drupal::service(\Drupal\update\UpdateCalculator::class)->updateProjectStatus(\Drupal\update\UpdateProject::createFromArray($project_data), \Drupal\update\UpdateServerProjectInfo::createFromArray($available))->toArray();

Caveats

Calls using named arguments or argument unpacking (...$args) are skipped since the replacement shape depends on positional argument order; these are rare for internal update.module functions. Calls with an unexpected argument count are left untouched rather than guessed at.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class UpdateCompareFunctionsToServiceRector extends AbstractRector
{
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated update.compare.inc global functions with calls to the update.update_calculator / update.manager services.',
            [new CodeSample(
                <<<'CODE_SAMPLE'
update_process_project_info($projects);
$data = update_calculate_project_data($available);
update_calculate_project_update_status($project_data, $available);
CODE_SAMPLE,
                <<<'CODE_SAMPLE'
\Drupal::service(\Drupal\update\UpdateCalculator::class)->processProjectInfo($projects);
$data = \Drupal::service(\Drupal\update\UpdateManagerInterface::class)->calculateProjectData($available);
$project_data = \Drupal::service(\Drupal\update\UpdateCalculator::class)->updateProjectStatus(\Drupal\update\UpdateProject::createFromArray($project_data), \Drupal\update\UpdateServerProjectInfo::createFromArray($available))->toArray();
CODE_SAMPLE,
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }
        if (!$this->isName($node->name, 'update_process_project_info')
            && !$this->isName($node->name, 'update_calculate_project_data')
            && !$this->isName($node->name, 'update_calculate_project_update_status')
        ) {
            return null;
        }

        // Skip named args / spread args: the replacement shape depends on
        // positional argument order.
        foreach ($node->args as $arg) {
            if (!$arg instanceof Arg || $arg->name !== null || $arg->unpack) {
                return null;
            }
        }

        if ($this->isName($node->name, 'update_process_project_info')) {
            if (count($node->args) !== 1) {
                return null;
            }
            return $this->createServiceMethodCall('Drupal\\update\\UpdateCalculator', 'processProjectInfo', $node->args);
        }

        if ($this->isName($node->name, 'update_calculate_project_data')) {
            if (count($node->args) !== 1) {
                return null;
            }
            return $this->createServiceMethodCall('Drupal\\update\\UpdateManagerInterface', 'calculateProjectData', $node->args);
        }

        // update_calculate_project_update_status(&$project_data, $available): void
        // mutates $project_data by reference. The replacement method takes
        // value objects and returns the new UpdateProject, so we rebuild the
        // call as an assignment back onto the original first-argument
        // expression, mirroring the deprecated function's own body.
        if (count($node->args) !== 2) {
            return null;
        }
        $projectDataArg = $node->args[0];
        $availableArg = $node->args[1];

        $updateProject = new StaticCall(
            new FullyQualified('Drupal\\update\\UpdateProject'),
            'createFromArray',
            [$projectDataArg],
        );
        $updateServerProjectInfo = new StaticCall(
            new FullyQualified('Drupal\\update\\UpdateServerProjectInfo'),
            'createFromArray',
            [$availableArg],
        );
        $serviceCall = $this->createServiceMethodCall(
            'Drupal\\update\\UpdateCalculator',
            'updateProjectStatus',
            [new Arg($updateProject), new Arg($updateServerProjectInfo)],
        );
        $toArrayCall = new MethodCall($serviceCall, 'toArray');

        return new Assign($projectDataArg->value, $toArrayCall);
    }

    /**
     * @param Arg[] $args
     */
    private function createServiceMethodCall(string $serviceClass, string $method, array $args): MethodCall
    {
        $serviceLookup = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg(new ClassConstFetch(new FullyQualified($serviceClass), 'class'))],
        );

        return new MethodCall($serviceLookup, $method, $args);
    }
}

return RectorConfig::configure()->withRules([UpdateCompareFunctionsToServiceRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Inline the deprecated FormBuilderInterface::HTMX_REQUEST constant

Thu, 03 Sep 2026 16:30:20 GMT

Source: #3555916
Timeline: Deprecated in Drupal 12.0.0, removed in Drupal 13.0.0

As part of the HTMX 4 upgrade, FormBuilderInterface::HTMX_REQUEST is deprecated in favor of HtmxRequestInfoTrait::isHtmxRequest() and will be removed in Drupal 13. Since the trait method needs the consuming class to use the trait and expose getRequest(), which isn't safely inferable in arbitrary contrib code, this rule instead inlines the constant's literal value ('HX-Request') at every use site. This keeps behavior identical while avoiding a fatal error once the constant is removed.

Before

use Drupal\Core\Form\FormBuilderInterface;

if ($request->headers->has(FormBuilderInterface::HTMX_REQUEST)) {
  // ...
}

After

if ($request->headers->has('HX-Request')) {
  // ...
}

Caveats

The deprecation message recommends adopting HtmxRequestInfoTrait::isHtmxRequest() instead, which is the more idiomatic fix when the calling class already uses that trait. This rule cannot safely detect that context, so it inlines the constant's literal string value instead, which is behaviorally identical and works regardless of the surrounding class.

Code

<?php
declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Scalar\String_;
use PHPStan\Type\ObjectType;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class InlineFormBuilderHtmxRequestConstantRector extends AbstractRector
{
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace the deprecated FormBuilderInterface::HTMX_REQUEST constant with its literal header name value.',
            [new CodeSample(
                '$request->headers->has(FormBuilderInterface::HTMX_REQUEST);',
                "\$request->headers->has('HX-Request');",
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [ClassConstFetch::class];
    }

    /** @param ClassConstFetch $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof ClassConstFetch) {
            return null;
        }
        if (!$this->isName($node->name, 'HTMX_REQUEST')) {
            return null;
        }
        if (!$this->isObjectType($node->class, new ObjectType('Drupal\\Core\\Form\\FormBuilderInterface'))) {
            return null;
        }
        return new String_('HX-Request');
    }
}

return RectorConfig::configure()->withRules([InlineFormBuilderHtmxRequestConstantRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated locale.module global constants with class constant/enum equivalents

Tue, 01 Sep 2026 16:52:46 GMT

Source: #2831617
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates ten global constants in locale.module (LOCALE_CUSTOMIZED, LOCALE_NOT_CUSTOMIZED, LOCALE_TRANSLATION_USE_SOURCE_*, LOCALE_TRANSLATION_OVERWRITE_*, LOCALE_TRANSLATION_REMOTE, LOCALE_TRANSLATION_LOCAL, LOCALE_TRANSLATION_CURRENT) in favor of LocaleDefaultOptions class constants and TranslationUpdateMode/Overwrite/SourceType backed-enum cases. This rule rewrites any ConstFetch reference to one of these ten global constants into the corresponding ClassConstFetch or EnumCase->value expression, so contrib and custom code using these constants keeps working after they are removed.

Before

$customized = LOCALE_CUSTOMIZED;
$use_source = LOCALE_TRANSLATION_USE_SOURCE_LOCAL;
if ($source->type == LOCALE_TRANSLATION_LOCAL || $source->type == LOCALE_TRANSLATION_REMOTE) {
  // ...
}

After

$customized = \Drupal\locale\LocaleDefaultOptions::CUSTOMIZED;
$use_source = \Drupal\locale\Model\TranslationUpdateMode::Local->value;
if ($source->type == \Drupal\locale\Model\SourceType::Local->value || $source->type == \Drupal\locale\Model\SourceType::Remote->value) {
  // ...
}

Caveats

Does not touch LOCALE_TRANSLATION_STATUS_TTL (inlined as a literal 600, no direct replacement) or LOCALE_JS_STRING/LOCALE_JS_OBJECT/LOCALE_JS_OBJECT_CONTEXT (moved to local variables inside LocaleJs::parseJsFile(), no public replacement); these have no equivalent expression to substitute, so call sites using them need manual review.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Identifier;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceLocaleDeprecatedConstantsRector extends AbstractRector
{
    /**
     * Old global constant name => [FQCN, member name, isEnumCase].
     *
     * @var array<string, array{0: string, 1: string, 2: bool}>
     */
    private const REPLACEMENTS = [
        'LOCALE_NOT_CUSTOMIZED' => ['Drupal\\locale\\LocaleDefaultOptions', 'NOT_CUSTOMIZED', false],
        'LOCALE_CUSTOMIZED' => ['Drupal\\locale\\LocaleDefaultOptions', 'CUSTOMIZED', false],
        'LOCALE_TRANSLATION_USE_SOURCE_LOCAL' => ['Drupal\\locale\\Model\\TranslationUpdateMode', 'Local', true],
        'LOCALE_TRANSLATION_USE_SOURCE_REMOTE_AND_LOCAL' => ['Drupal\\locale\\Model\\TranslationUpdateMode', 'RemoteAndLocal', true],
        'LOCALE_TRANSLATION_OVERWRITE_ALL' => ['Drupal\\locale\\Model\\Overwrite', 'All', true],
        'LOCALE_TRANSLATION_OVERWRITE_NON_CUSTOMIZED' => ['Drupal\\locale\\Model\\Overwrite', 'NonCustomized', true],
        'LOCALE_TRANSLATION_OVERWRITE_NONE' => ['Drupal\\locale\\Model\\Overwrite', 'None', true],
        'LOCALE_TRANSLATION_REMOTE' => ['Drupal\\locale\\Model\\SourceType', 'Remote', true],
        'LOCALE_TRANSLATION_LOCAL' => ['Drupal\\locale\\Model\\SourceType', 'Local', true],
        'LOCALE_TRANSLATION_CURRENT' => ['Drupal\\locale\\Model\\SourceType', 'Current', true],
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated locale.module global constants with their LocaleDefaultOptions class constant or Model enum case replacements.',
            [new CodeSample(
                '$customized = LOCALE_CUSTOMIZED;
$use_source = LOCALE_TRANSLATION_USE_SOURCE_LOCAL;',
                '$customized = \Drupal\locale\LocaleDefaultOptions::CUSTOMIZED;
$use_source = \Drupal\locale\Model\TranslationUpdateMode::Local->value;',
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [ConstFetch::class];
    }

    /** @param ConstFetch $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof ConstFetch) {
            return null;
        }

        foreach (self::REPLACEMENTS as $oldConstName => [$class, $member, $isEnumCase]) {
            if (!$this->isName($node, $oldConstName)) {
                continue;
            }

            $classConstFetch = $this->nodeFactory->createClassConstFetch($class, $member);

            if (!$isEnumCase) {
                return $classConstFetch;
            }

            return new PropertyFetch($classConstFetch, new Identifier('value'));
        }

        return null;
    }
}

return RectorConfig::configure()->withRules([ReplaceLocaleDeprecatedConstantsRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated file upload functions with service calls

Tue, 01 Sep 2026 16:49:03 GMT

Source: #3375423
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates the global functions file_save_upload(), file_managed_file_save_upload(), and _file_save_upload_from_form() in favor of the FormFileUploader and ManagedFileElementHelper services. This rule rewrites calls to the equivalent \Drupal::service(...)->method(...) form, preserving argument order. For file_save_upload(), a literal FALSE/NULL third argument (the old $destination default) is rewritten to the string 'temporary://' since the new method's parameter is strictly typed as string.

Before

$file = file_save_upload('upload', $validators, FALSE, 0);
$result = file_managed_file_save_upload($element, $form_state);
$result2 = _file_save_upload_from_form($element, $form_state, 0);

After

$file = \Drupal::service(\Drupal\file\Upload\FormFileUploader::class)->saveFormUploadedFiles('upload', $validators, 'temporary://', 0);
$result = \Drupal::service(\Drupal\file\Upload\ManagedFileElementHelper::class)->managedFileSaveUpload($element, $form_state);
$result2 = \Drupal::service(\Drupal\file\Upload\ManagedFileElementHelper::class)->saveFileUploads($element, $form_state, 0);

Caveats

If the $destination argument to file_save_upload() is a non-literal expression (a variable or function call) that may evaluate to FALSE or NULL at runtime, the rule leaves it unchanged; the rewritten service call requires a string, so such a call would need manual review. Calls using named arguments or argument unpacking (...$args) are skipped entirely rather than risk a wrong rewrite.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Scalar\String_;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceDeprecatedFileSaveUploadFunctionsRector extends AbstractRector
{
    /** @var array<string, array{class: string, method: string, minArgs: int, maxArgs: int}> */
    private const REPLACEMENTS = [
        'file_save_upload' => [
            'class' => 'Drupal\\file\\Upload\\FormFileUploader',
            'method' => 'saveFormUploadedFiles',
            'minArgs' => 1,
            'maxArgs' => 5,
        ],
        'file_managed_file_save_upload' => [
            'class' => 'Drupal\\file\\Upload\\ManagedFileElementHelper',
            'method' => 'managedFileSaveUpload',
            'minArgs' => 2,
            'maxArgs' => 2,
        ],
        '_file_save_upload_from_form' => [
            'class' => 'Drupal\\file\\Upload\\ManagedFileElementHelper',
            'method' => 'saveFileUploads',
            'minArgs' => 2,
            'maxArgs' => 4,
        ],
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace the deprecated file_save_upload(), file_managed_file_save_upload() and _file_save_upload_from_form() functions with calls to their replacement services.',
            [new CodeSample(
                '$file = file_save_upload("upload", $validators);',
                '$file = \Drupal::service(\Drupal\file\Upload\FormFileUploader::class)->saveFormUploadedFiles("upload", $validators);',
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }

        $functionName = null;
        foreach (self::REPLACEMENTS as $name => $replacement) {
            if ($this->isName($node->name, $name)) {
                $functionName = $name;
                break;
            }
        }
        if ($functionName === null) {
            return null;
        }
        $replacement = self::REPLACEMENTS[$functionName];

        $argCount = count($node->args);
        if ($argCount < $replacement['minArgs'] || $argCount > $replacement['maxArgs']) {
            return null;
        }

        // Named arguments and argument unpacking change the mapping between
        // position and parameter; skip rather than risk a wrong rewrite.
        foreach ($node->args as $arg) {
            if (!$arg instanceof Arg || $arg->name !== null || $arg->unpack) {
                return null;
            }
        }

        $args = $node->args;

        if ($functionName === 'file_save_upload') {
            // The old function normalizes a FALSE/NULL $destination to
            // 'temporary://' before delegating; the new method's parameter is
            // a plain string, so a literal FALSE/NULL third argument must be
            // rewritten to the string, or a TypeError results.
            if (isset($args[2]) && $args[2]->value instanceof ConstFetch) {
                $constName = $this->getName($args[2]->value->name);
                if ($constName !== null && in_array(strtolower($constName), ['false', 'null'], true)) {
                    $args[2] = new Arg(new String_('temporary://'));
                }
            }
        }

        $serviceCall = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg(new ClassConstFetch(new FullyQualified($replacement['class']), 'class'))],
        );

        return new MethodCall($serviceCall, $replacement['method'], $args);
    }
}

return RectorConfig::configure()->withRules([ReplaceDeprecatedFileSaveUploadFunctionsRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Update references to text_with_summary field plugins moved out of the text module

Tue, 01 Sep 2026 16:45:12 GMT

Source: #3549134
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 12.0.0

Drupal core moved the text_with_summary field type, its text_textarea_with_summary widget, and its text_summary_or_trimmed formatter out of the text module into a new dedicated text_with_summary module. The old classes in Drupal\text\Plugin\Field\... are deprecated in drupal:11.5.0 and removed in drupal:12.0.0. This rule rewrites use, extends, instanceof, new, and type-hint references from the old class locations to their new Drupal\text_with_summary\Plugin\Field\... equivalents so custom subclasses and type checks keep working after the module split.

Before

use Drupal\text\Plugin\Field\FieldType\TextWithSummaryItem;

class MyItem extends TextWithSummaryItem {
}

After

class MyItem extends \Drupal\text_with_summary\Plugin\Field\FieldType\TextWithSummaryItem {
}

Caveats

The rule rewrites the code reference itself but does not remove the now-unused use statement for the old class, and it does not add text_with_summary as a module dependency in the consuming module's .info.yml; both are cosmetic/config follow-ups a developer should make by hand.

Code

<?php
declare(strict_types=1);

use Rector\Config\RectorConfig;
use Rector\Renaming\Rector\Name\RenameClassRector;

return RectorConfig::configure()
    ->withConfiguredRule(RenameClassRector::class, [
        'Drupal\text\Plugin\Field\FieldType\TextWithSummaryItem' => 'Drupal\text_with_summary\Plugin\Field\FieldType\TextWithSummaryItem',
        'Drupal\text\Plugin\Field\FieldWidget\TextareaWithSummaryWidget' => 'Drupal\text_with_summary\Plugin\Field\FieldWidget\TextareaWithSummaryWidget',
        'Drupal\text\Plugin\Field\FieldFormatter\TextSummaryOrTrimmedFormatter' => 'Drupal\text_with_summary\Plugin\Field\FieldFormatter\TextSummaryOrTrimmedFormatter',
    ]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Inline user_picture_enabled() calls into a field-definition check

Mon, 31 Aug 2026 20:21:31 GMT

Source: #3151555
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

user_picture_enabled() is deprecated with no direct replacement; callers must inline the check it used to perform. This rule rewrites zero-argument calls to user_picture_enabled() into isset(\Drupal::service('entity_field.manager')->getFieldDefinitions('user', 'user')['user_picture']), matching exactly what core's own call sites were changed to. It preserves surrounding boolean context (negation, &&, etc.) since the replacement is a drop-in boolean expression.

Before

if (!user_picture_enabled()) {
  $disabled['toggle_node_user_picture'] = TRUE;
}

if (!empty($build['user_picture']) && user_picture_enabled()) {
  // ...
}

After

if (!isset(\Drupal::service('entity_field.manager')->getFieldDefinitions('user', 'user')['user_picture'])) {
  $disabled['toggle_node_user_picture'] = TRUE;
}

if (!empty($build['user_picture']) && isset(\Drupal::service('entity_field.manager')->getFieldDefinitions('user', 'user')['user_picture'])) {
  // ...
}

Caveats

Only matches calls with zero arguments (the function's real signature). A user-defined function or method that happens to share the name user_picture_enabled but takes arguments, or is called as $this->user_picture_enabled(...), is left untouched since the rule only targets global FuncCall nodes.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\ArrayDimFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\Isset_;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Scalar\String_;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceUserPictureEnabledRector extends AbstractRector
{
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated user_picture_enabled() with an inline check of the user_picture field definition.',
            [new CodeSample(
                'if (!user_picture_enabled()) { }',
                "if (!isset(\\Drupal::service('entity_field.manager')->getFieldDefinitions('user', 'user')['user_picture'])) { }",
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }
        if ($node->isFirstClassCallable()) {
            return null;
        }
        if (!$this->isName($node->name, 'user_picture_enabled')) {
            return null;
        }
        if (count($node->args) !== 0) {
            return null;
        }

        $service = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg(new String_('entity_field.manager'))],
        );
        $getFieldDefinitions = new MethodCall(
            $service,
            'getFieldDefinitions',
            [new Arg(new String_('user')), new Arg(new String_('user'))],
        );
        $arrayDimFetch = new ArrayDimFetch($getFieldDefinitions, new String_('user_picture'));

        return new Isset_([$arrayDimFetch]);
    }
}

return RectorConfig::configure()->withRules([ReplaceUserPictureEnabledRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated update.module global functions with service calls

Mon, 31 Aug 2026 12:35:19 GMT

Source: #3580703
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates five update.module procedural functions in favor of methods on the update.manager and update.processor services, removed in Drupal 13. This rule rewrites update_get_available(), update_refresh(), update_storage_clear(), update_create_fetch_task(), and update_fetch_data() calls to the equivalent \Drupal::service(...)->method(...) call, preserving all arguments. It skips dynamic calls ($fn()) where the function name is not statically known, and leaves unrelated functions of the same short name alone.

Before

$available = update_get_available(TRUE);
update_refresh();
update_storage_clear();
update_create_fetch_task($project);
update_fetch_data();

After

$available = \Drupal::service('update.manager')->getAvailable(TRUE);
\Drupal::service('update.manager')->refreshUpdateData();
\Drupal::service('update.manager')->reset();
\Drupal::service('update.processor')->createFetchTask($project);
\Drupal::service('update.processor')->fetchData();

Caveats

Does not cover update_fetch_data_finished() or _update_project_status_sort(), which core deprecates with no replacement, nor _update_no_data()/_update_message_text(), whose replacements are protected methods on \Drupal\update\UpdateMessageTrait that cannot be called without a class using that trait; those call sites need manual review.

Code

<?php
declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Scalar\String_;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceUpdateModuleFunctionsRector extends AbstractRector
{
    /**
     * Maps a deprecated update.module global function to the [service id,
     * method name] that replaces it. All of these functions were deprecated
     * in drupal:11.5.0 and are removed from drupal:13.0.0.
     *
     * @var array<string, array{0: string, 1: string}>
     */
    private const FUNCTION_MAP = [
        'update_get_available' => ['update.manager', 'getAvailable'],
        'update_refresh' => ['update.manager', 'refreshUpdateData'],
        'update_storage_clear' => ['update.manager', 'reset'],
        'update_create_fetch_task' => ['update.processor', 'createFetchTask'],
        'update_fetch_data' => ['update.processor', 'fetchData'],
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated update.module global functions with calls to the update.manager and update.processor services.',
            [new CodeSample(
                <<<'CODE_SAMPLE'
$available = update_get_available(TRUE);
update_storage_clear();
CODE_SAMPLE,
                <<<'CODE_SAMPLE'
$available = \Drupal::service('update.manager')->getAvailable(TRUE);
\Drupal::service('update.manager')->reset();
CODE_SAMPLE,
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }
        if (!$node->name instanceof Name) {
            // Dynamic call, e.g. $fn(); the function name isn't statically known.
            return null;
        }
        $functionName = $this->getName($node->name);
        if ($functionName === null || !isset(self::FUNCTION_MAP[$functionName])) {
            return null;
        }
        [$serviceId, $method] = self::FUNCTION_MAP[$functionName];

        $serviceCall = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg(new String_($serviceId))],
        );

        return new MethodCall($serviceCall, $method, $node->args);
    }
}

return RectorConfig::configure()->withRules([ReplaceUpdateModuleFunctionsRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace user_login_finalize() and user_logout() with services

Fri, 28 Aug 2026 22:06:29 GMT

Source: #2012976
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates the procedural user_login_finalize() and user_logout() functions in user.module in favor of \Drupal\user\LoginFinalizer::finalizeLogin() and \Drupal\user\LogoutFinalizer::finalizeLogout(), obtained via dependency injection or \Drupal::service(). This rule rewrites call sites of both global functions to the equivalent service call, letting contrib and custom code (including auth/session modules that call these directly) migrate ahead of removal in drupal:13.0.0.

Before

user_login_finalize($account);
user_logout();

After

\Drupal::service(\Drupal\user\LoginFinalizer::class)->finalizeLogin($account);
\Drupal::service(\Drupal\user\LogoutFinalizer::class)->finalizeLogout();

Caveats

Skips call sites that use named arguments (e.g. user_login_finalize(account: $account)) because the new service method's parameter is named $user, not $account; rewriting those would break under strict named-argument binding. Such (rare) call sites are left untouched for manual review. The rule targets \Drupal::service() call sites; it does not inject the service into a class constructor, since that requires editing the class's dependency list which is outside the scope of this rewrite.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceUserLoginLogoutFinalizeRector extends AbstractRector
{
    /**
     * Maps deprecated global function name to [service FQCN, method name].
     *
     * @var array<string, array{0: string, 1: string}>
     */
    private const REPLACEMENTS = [
        'user_login_finalize' => ['Drupal\\user\\LoginFinalizer', 'finalizeLogin'],
        'user_logout' => ['Drupal\\user\\LogoutFinalizer', 'finalizeLogout'],
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated user_login_finalize() and user_logout() global functions with the LoginFinalizer and LogoutFinalizer services.',
            [new CodeSample(
                'user_login_finalize($account);
user_logout();',
                '\Drupal::service(\Drupal\user\LoginFinalizer::class)->finalizeLogin($account);
\Drupal::service(\Drupal\user\LogoutFinalizer::class)->finalizeLogout();',
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }

        foreach (self::REPLACEMENTS as $functionName => [$serviceClass, $methodName]) {
            if (!$this->isName($node->name, $functionName)) {
                continue;
            }

            // The new service method's parameter name differs from the old
            // function's parameter name; a named argument would break.
            foreach ($node->args as $arg) {
                if ($arg instanceof Arg && $arg->name !== null) {
                    return null;
                }
            }

            $serviceCall = new StaticCall(
                new FullyQualified('Drupal'),
                'service',
                [new Arg(new ClassConstFetch(new FullyQualified($serviceClass), 'class'))],
            );

            return new MethodCall($serviceCall, $methodName, $node->args);
        }

        return null;
    }
}

return RectorConfig::configure()->withRules([ReplaceUserLoginLogoutFinalizeRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace _user_mail_notify() calls with NotificationHandler methods

Wed, 26 Aug 2026 21:05:20 GMT

Source: #3539178
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates the global function _user_mail_notify($op, $account) in favor of dedicated methods on the internal Drupal\user\NotificationHandler service, one method per notification type. This rule rewrites call sites where the $op argument is a literal string it recognizes (e.g. password_reset, cancel_confirm, status_blocked) into the equivalent \Drupal::service(NotificationHandler::class)->sendXxx($account) call, letting contrib modules migrate ahead of removal in Drupal 13.0.0.

Before

_user_mail_notify('password_reset', $account);
_user_mail_notify('cancel_confirm', $entity);

After

\Drupal::service(\Drupal\user\NotificationHandler::class)->sendPasswordReset($account);
\Drupal::service(\Drupal\user\NotificationHandler::class)->sendCancelConfirm($entity);

Caveats

Only rewrites calls whose $op argument is a plain string literal matching one of the eight known operations (register_admin_created, register_no_approval_required, register_pending_approval, password_reset, status_activated, status_blocked, cancel_confirm, status_canceled). Calls that compute $op dynamically (e.g. $op = $active ? 'status_activated' : 'status_blocked'; _user_mail_notify($op, $account);), use named arguments, pass a custom/unsupported $op value, or pass a different argument count are left untouched and must be migrated by hand. The old function could return NULL (suppressed) or FALSE (error) while the new methods always return bool; call sites that rely on distinguishing NULL from FALSE (rather than a simple truthy/falsy check) need manual review.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Scalar\String_;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceUserMailNotifyRector extends AbstractRector
{
    private const OP_TO_METHOD = [
        'register_admin_created' => 'sendRegisterAdminCreated',
        'register_no_approval_required' => 'sendRegisterNoApprovalRequired',
        'register_pending_approval' => 'sendRegisterPendingApproval',
        'password_reset' => 'sendPasswordReset',
        'status_activated' => 'sendStatusActivated',
        'status_blocked' => 'sendStatusBlocked',
        'cancel_confirm' => 'sendCancelConfirm',
        'status_canceled' => 'sendStatusCanceled',
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace _user_mail_notify() calls with the equivalent Drupal\user\NotificationHandler method.',
            [new CodeSample(
                "_user_mail_notify('password_reset', \$account);",
                "\\Drupal::service(\\Drupal\\user\\NotificationHandler::class)->sendPasswordReset(\$account);",
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }
        if (!$this->isName($node->name, '_user_mail_notify')) {
            return null;
        }
        if (count($node->args) !== 2) {
            return null;
        }
        if (!$node->args[0] instanceof Arg || !$node->args[1] instanceof Arg) {
            return null;
        }
        // Named arguments change the calling convention; skip for safety.
        if ($node->args[0]->name !== null || $node->args[1]->name !== null) {
            return null;
        }
        $opArg = $node->args[0]->value;
        if (!$opArg instanceof String_) {
            // The $op argument is not a plain string literal (e.g. a
            // variable); cannot determine which NotificationHandler method
            // to call without evaluating runtime data.
            return null;
        }
        if (!isset(self::OP_TO_METHOD[$opArg->value])) {
            // Unknown / custom $op value; no equivalent method exists on
            // NotificationHandler.
            return null;
        }
        $method = self::OP_TO_METHOD[$opArg->value];
        $service = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg(new ClassConstFetch(new FullyQualified('Drupal\\user\\NotificationHandler'), 'class'))],
        );
        return new MethodCall($service, $method, [$node->args[1]]);
    }
}

return RectorConfig::configure()->withRules([ReplaceUserMailNotifyRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated locale.module underscore functions with LocaleJs service calls

Wed, 26 Aug 2026 21:01:55 GMT

Source: #3618358
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates the remaining _locale_* underscore helper functions in locale.module in favor of methods on the Drupal\locale\LocaleJs service. This rule rewrites direct calls to _locale_refresh_translations(), _locale_invalidate_js(), _locale_parse_js_file(), and _locale_rebuild_js() into the equivalent \Drupal::service(\Drupal\locale\LocaleJs::class)->method() call, preserving arguments unchanged. Contrib code that rebuilds or invalidates JavaScript translation files keeps working after these globals are removed in Drupal 13.0.0.

Before

_locale_invalidate_js($langcode);
_locale_rebuild_js($langcode);
_locale_parse_js_file($filepath);
_locale_refresh_translations($langcodes, $lids);

After

\Drupal::service(\Drupal\locale\LocaleJs::class)->invalidate($langcode);
\Drupal::service(\Drupal\locale\LocaleJs::class)->rebuild($langcode);
\Drupal::service(\Drupal\locale\LocaleJs::class)->parseJsFile($filepath);
\Drupal::service(\Drupal\locale\LocaleJs::class)->refreshTranslations($langcodes, $lids);

Caveats

_locale_refresh_configuration() and _locale_strip_quotes() are also deprecated by this issue but have no replacement API, so calls to them are intentionally left untouched; callers must be manually inlined or removed. LocaleJs::parseJsFile() and LocaleJs::rebuild() are marked @internal in core (public only for test coverage), so rewritten call sites still depend on an internal API surface that core may change without a deprecation cycle.

Code

<?php
declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceLocaleJsUnderscoreFunctionsRector extends AbstractRector
{
    /**
     * @var array<string, string>
     */
    private const METHOD_MAP = [
        '_locale_refresh_translations' => 'refreshTranslations',
        '_locale_invalidate_js' => 'invalidate',
        '_locale_parse_js_file' => 'parseJsFile',
        '_locale_rebuild_js' => 'rebuild',
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated locale.module underscore functions with Drupal\locale\LocaleJs service calls.',
            [new CodeSample(
                '_locale_invalidate_js($langcode);',
                "\\Drupal::service(\\Drupal\\locale\\LocaleJs::class)->invalidate(\$langcode);",
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }
        if (!$node->name instanceof Name) {
            // Skip dynamic calls, e.g. $fn(...).
            return null;
        }
        $functionName = $this->getName($node->name);
        if ($functionName === null || !isset(self::METHOD_MAP[$functionName])) {
            return null;
        }

        $service = new StaticCall(
            new FullyQualified('Drupal'),
            'service',
            [new Arg(new ClassConstFetch(new FullyQualified('Drupal\\locale\\LocaleJs'), 'class'))],
        );

        return new MethodCall($service, self::METHOD_MAP[$functionName], $node->args);
    }
}

return RectorConfig::configure()->withRules([ReplaceLocaleJsUnderscoreFunctionsRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated locale.module global functions with class calls

Wed, 26 Aug 2026 00:27:21 GMT

Source: #3616277
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal 11.5 deprecates several locale.module global functions in favor of methods on new classes. locale_string_is_safe() becomes the static LocaleXss::stringIsSafe(); locale_is_translatable(), locale_translatable_language_list(), and locale_js_translate() become instance methods on the LocaleLanguages and LocaleJs services, obtained via \Drupal::service(). This rule rewrites direct calls to the old global functions so contrib and custom modules keep working after the functions are removed in Drupal 13.

Before

$safe = locale_string_is_safe($string);
$translatable = locale_is_translatable($langcode);
$languages = locale_translatable_language_list();
$translation_file = locale_js_translate($files, $language_interface);

After

$safe = \Drupal\locale\LocaleXss::stringIsSafe($string);
$translatable = \Drupal::service(\Drupal\locale\LocaleLanguages::class)->isTranslatable($langcode);
$languages = \Drupal::service(\Drupal\locale\LocaleLanguages::class)->getTranslatableLanguages();
$translation_file = \Drupal::service(\Drupal\locale\LocaleJs::class)->jsTranslate($files, $language_interface);

Caveats

Only covers the four functions with a direct 1:1 replacement (locale_string_is_safe, locale_is_translatable, locale_translatable_language_list, locale_js_translate). locale_translation_use_remote_source() and locale_translation_language_table() are also deprecated by this issue but have no direct replacement (inlined config check, or a class method meant to be referenced by name as a #after_build callback), so they are intentionally left untouched; callers of those two must be migrated by hand.

Code

<?php
declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Name\FullyQualified;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class ReplaceDeprecatedLocaleFunctionsRector extends AbstractRector
{
    /**
     * Functions replaced by a static method call.
     *
     * @var array<string, array{0: string, 1: string}>
     */
    private const STATIC_MAP = [
        'locale_string_is_safe' => ['Drupal\locale\LocaleXss', 'stringIsSafe'],
    ];

    /**
     * Functions replaced by a call on a service obtained via \Drupal::service().
     *
     * @var array<string, array{0: string, 1: string}>
     */
    private const SERVICE_MAP = [
        'locale_is_translatable' => ['Drupal\locale\LocaleLanguages', 'isTranslatable'],
        'locale_translatable_language_list' => ['Drupal\locale\LocaleLanguages', 'getTranslatableLanguages'],
        'locale_js_translate' => ['Drupal\locale\LocaleJs', 'jsTranslate'],
    ];

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Replace deprecated locale.module global functions with calls on their replacement classes.',
            [new CodeSample(
                <<<'CODE_SAMPLE'
$safe = locale_string_is_safe($string);
$translatable = locale_is_translatable($langcode);
$languages = locale_translatable_language_list();
CODE_SAMPLE
                ,
                <<<'CODE_SAMPLE'
$safe = \Drupal\locale\LocaleXss::stringIsSafe($string);
$translatable = \Drupal::service(\Drupal\locale\LocaleLanguages::class)->isTranslatable($langcode);
$languages = \Drupal::service(\Drupal\locale\LocaleLanguages::class)->getTranslatableLanguages();
CODE_SAMPLE
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [FuncCall::class];
    }

    /** @param FuncCall $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof FuncCall) {
            return null;
        }

        $functionName = $this->getName($node->name);
        if ($functionName === null) {
            return null;
        }

        if (isset(self::STATIC_MAP[$functionName])) {
            [$class, $method] = self::STATIC_MAP[$functionName];
            return new StaticCall(new FullyQualified($class), $method, $node->args);
        }

        if (isset(self::SERVICE_MAP[$functionName])) {
            [$class, $method] = self::SERVICE_MAP[$functionName];
            $service = new StaticCall(
                new FullyQualified('Drupal'),
                'service',
                [new Arg(new ClassConstFetch(new FullyQualified($class), 'class'))],
            );
            return new MethodCall($service, $method, $node->args);
        }

        return null;
    }
}

return RectorConfig::configure()->withRules([ReplaceDeprecatedLocaleFunctionsRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Add $memoryCache argument to UpdateRegistry instantiations

Tue, 25 Aug 2026 08:32:02 GMT

Source: #3303751
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 12.0.0

Drupal\Core\Update\UpdateRegistry::__construct() now takes an optional MemoryCacheInterface $memoryCache parameter inserted before the trailing $updateType parameter. Omitting it triggers an E_USER_DEPRECATED notice and will be a hard error in Drupal 12. This rule rewrites direct new UpdateRegistry(...) calls (positional or named) to pass \Drupal::service('cache.memory') in the new slot, correctly shifting an explicitly-passed $updateType.

Before

new UpdateRegistry($root, $sitePath, $module_list, $keyValue, $theme_handler, 'post_update');

After

new UpdateRegistry($root, $sitePath, $module_list, $keyValue, $theme_handler, \Drupal::service('cache.memory'), 'post_update');

Caveats

Only rewrites direct new UpdateRegistry(...) instantiations; code that obtains the service via \Drupal::service('update.post_update_registry') or dependency injection needs no change since core's service definition already passes the new argument. Calls using ...$args spread/unpacking are skipped because the argument position cannot be determined statically; these need manual review.

Code

<?php

declare(strict_types=1);

use PhpParser\Node;
use PhpParser\Node\Arg;
use PhpParser\Node\Expr\New_;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Scalar\String_;
use PhpParser\Node\VariadicPlaceholder;
use Rector\Config\RectorConfig;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

final class AddUpdateRegistryMemoryCacheArgumentRector extends AbstractRector
{
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Add the $memoryCache constructor argument to Drupal\Core\Update\UpdateRegistry instantiations.',
            [new CodeSample(
                'new UpdateRegistry($root, $sitePath, $module_list, $keyValue, $theme_handler, \'post_update\');',
                "new UpdateRegistry(\$root, \$sitePath, \$module_list, \$keyValue, \$theme_handler, \\Drupal::service('cache.memory'), 'post_update');",
            )],
        );
    }

    /** @return array<class-string<Node>> */
    public function getNodeTypes(): array
    {
        return [New_::class];
    }

    /** @param New_ $node */
    public function refactor(Node $node): ?Node
    {
        if (!$node instanceof New_) {
            return null;
        }
        if (!$this->isName($node->class, 'Drupal\\Core\\Update\\UpdateRegistry')) {
            return null;
        }

        $args = $node->args;

        // Bail on unpacked/spread args (`...$args`): position cannot be determined safely.
        foreach ($args as $arg) {
            if ($arg instanceof VariadicPlaceholder) {
                return null;
            }
        }

        $memoryCacheCall = new StaticCall(new FullyQualified('Drupal'), 'service', [new Arg(new String_('cache.memory'))]);

        $hasNamedArgs = false;
        foreach ($args as $arg) {
            if ($arg->name !== null) {
                $hasNamedArgs = true;
                if ($this->isName($arg->name, 'memoryCache')) {
                    // Already migrated.
                    return null;
                }
            }
        }

        if ($hasNamedArgs) {
            $node->args[] = new Arg($memoryCacheCall, false, false, [], new Identifier('memoryCache'));
            return $node;
        }

        $argCount = count($args);

        // Fewer than 5 positional args is not a valid call to this constructor
        // ($root, $sitePath, $module_list, $keyValue, $theme_handler are all required); skip.
        if ($argCount < 5) {
            return null;
        }

        // 7+ positional args already include $memoryCache; nothing to do.
        if ($argCount >= 7) {
            return null;
        }

        $memoryCacheArg = new Arg($memoryCacheCall);

        if ($argCount === 5) {
            // No $updateType passed: append $memoryCache as the 6th argument.
            $node->args[] = $memoryCacheArg;
            return $node;
        }

        // $argCount === 6: an explicit $updateType was passed positionally in the old
        // signature's 6th slot. Insert $memoryCache before it, shifting $updateType to 7th.
        array_splice($node->args, 5, 0, [$memoryCacheArg]);
        return $node;
    }
}

return RectorConfig::configure()->withRules([AddUpdateRegistryMemoryCacheArgumentRector::class]);

This content is AI-generated and may contain errors. See Drupal Digests for more.

Replace deprecated installer-specific extension list classes

Mon, 17 Aug 2026 00:26:14 GMT

Source: #2934063
Timeline: Deprecated in Drupal 11.5.0, removed in Drupal 13.0.0

Drupal\Core\Installer\InstallerModuleExtensionList and InstallerThemeExtensionList are now empty backward-compatibility shims around Drupal\Core\Extension\ModuleExtensionList and ThemeExtensionList; the installer no longer swaps them into the container. This rule rewrites type hints, property types, new calls, instanceof checks, and use imports from the deprecated installer classes to their base-class equivalents, which provide identical behavior.

Before

use Drupal\Core\Installer\InstallerModuleExtensionList;

class MyService {
  public function __construct(InstallerModuleExtensionList $module_list) {}
}

After

use Drupal\Core\Extension\ModuleExtensionList;

class MyService {
  public function __construct(ModuleExtensionList $module_list) {}
}

Caveats

Only rewrites the class references. It does not touch calls to the now-deprecated ExtensionList::setPathname() method that some contrib code may still call on the resulting object; that method has no direct replacement and is out of scope for this rule.

Code

<?php
declare(strict_types=1);

use Rector\Config\RectorConfig;
use Rector\Renaming\Rector\Name\RenameClassRector;

return RectorConfig::configure()
    ->withConfiguredRule(RenameClassRector::class, [
        'Drupal\\Core\\Installer\\InstallerModuleExtensionList' => 'Drupal\\Core\\Extension\\ModuleExtensionList',
        'Drupal\\Core\\Installer\\InstallerThemeExtensionList' => 'Drupal\\Core\\Extension\\ThemeExtensionList',
    ]);

This content is AI-generated and may contain errors. See Drupal Digests for more.