├── .gitignore
├── tests
    ├── Sniffs
    │   └── Imports
    │   │   ├── Fixtures
    │   │       ├── FileKeywordFixture.php
    │   │       ├── MultipleFilesFixtures
    │   │       │   ├── MultipleFilesFixtures2.php
    │   │       │   └── MultipleFilesFixtures1.php
    │   │       ├── ClassUsedAsNamespaceFixture.php
    │   │       ├── ConstantsFixure.php
    │   │       ├── RequireImportsMethodNameFixture.php
    │   │       ├── UsedTraitFixture.php
    │   │       ├── ClassFixtures.php
    │   │       ├── GlobalNamespaceFixture.php
    │   │       ├── RequireImportsAllowedPatternFixture.php
    │   │       ├── InterfaceFixture.php
    │   │       ├── TraitFixture.php
    │   │       ├── NestedFunctionsFixture.php
    │   │       ├── WordPressFixture.php
    │   │       └── RequireImportsFixture.php
    │   │   └── RequireImportsSniffTest.php
    ├── bootstrap.php
    └── SniffTestHelper.php
├── ImportDetection
    ├── ruleset.xml
    ├── FileSymbolRecord.php
    ├── Symbol.php
    ├── SniffHelpers.php
    ├── Sniffs
    │   └── Imports
    │   │   └── RequireImportsSniff.php
    └── WordPressSymbols.php
├── phpunit.xml
├── .circleci
    └── config.yml
├── composer-php7.json
├── composer.json
├── phpcs.xml
├── LICENSE
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor
2 | composer.lock
3 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/FileKeywordFixture.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | use Foo\Bar\File;
4 | 
5 | function doSomething(File $myFile) {
6 |   echo $myFile;
7 | }
8 | 


--------------------------------------------------------------------------------
/ImportDetection/ruleset.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0"?>
2 | <ruleset name="ImportDetection">
3 |  <description>A set of phpcs sniffs to look for unused or unimported symbols.</description>
4 | </ruleset>
5 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/MultipleFilesFixtures/MultipleFilesFixtures2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | class Foo {
 6 | }
 7 | 
 8 | function doAThing() {
 9 | 	executeCommand();
10 | }
11 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <phpunit
 2 | 	bootstrap="tests/bootstrap.php"
 3 | 	>
 4 | 	<testsuites>
 5 | 		<testsuite name="ImportDetection">
 6 | 			<directory>tests</directory>
 7 | 		</testsuite>
 8 | 	</testsuites>
 9 | </phpunit>
10 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/MultipleFilesFixtures/MultipleFilesFixtures1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyNamespace;
 4 | 
 5 | use MyNamespace\Sub\Bar;
 6 | 
 7 | class Foo {
 8 | }
 9 | 
10 | function doAThing() {
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | declare(strict_types=1);
3 | 
4 | namespace ImportDetectionTest;
5 | 
6 | require_once(__DIR__ . '/../vendor/squizlabs/php_codesniffer/tests/bootstrap.php');
7 | require_once(__DIR__ . '/SniffTestHelper.php');
8 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/ClassUsedAsNamespaceFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Movies;
 4 | 
 5 | class Totoro {
 6 |   public function playMovie() {
 7 |     Totoro\startMoviePlayer(); // this should be a warning that `Totoro` is not imported
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/ConstantsFixure.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use const NamespaceName\{B, C};
 3 | use const NamespaceName\{D, E};
 4 | use const NamespaceName\{
 5 | 	K,
 6 | 	P,
 7 | };
 8 | 
 9 | echo C;
10 | echo B;
11 | echo E;
12 | echo F;
13 | echo K;
14 | echo P;
15 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/RequireImportsMethodNameFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace CAR_APP\Vehicles\Greatness;
 5 | 
 6 | class GreatClass {
 7 | 	private function activate() {
 8 | 	}
 9 | 
10 | 	public function run() {
11 | 		activate(); // should report unimported function
12 | 	}
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/UsedTraitFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace Services\Kitchen;
 5 | 
 6 | use Services\Appliance;
 7 | 
 8 | class Toaster {
 9 | 	use Appliance;
10 | 	use UnimportedSymbol; // this should be a warning
11 | 	public function makeToast() {
12 | 		$this->energize();
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/ClassFixtures.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use NamespaceName\{
 3 | 	A, // used line 13
 4 | 	C\D, // not used
 5 | 	X\Y as Z, // used line 14
 6 | };
 7 | use NamespaceName\{
 8 | 	B, // not used
 9 | 	E\F, // used line 15
10 | 	I\J as H, // not used
11 | };
12 | use Some\NS\ {
13 | 	ClassName,
14 | 	function SubLevel\functionName,
15 | 	const Constants\CONSTANT_NAME as SOME_CONSTANT,
16 | 	function SubLevel\AnotherName,
17 | };
18 | use Some\NS\/* test comment with a backslash \ */{
19 | 	AnotherLevel,
20 | };
21 | 
22 | A::class;
23 | Z::class;
24 | F::class;
25 | 
26 | echo ClassName::class;
27 | echo functionName();
28 | echo SOME_CONSTANT;
29 | echo AnotherName();
30 | echo AnotherLevel::class;
31 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/GlobalNamespaceFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | use MagicCode\Snacks;
 5 | use function CAR_APP\Functions\whitelisted_function;
 6 | use function CAR_APP\Functions\unused_function; // unused
 7 | use function CAR_APP\Functions\{ three_function, four_function }; // unused
 8 | use function Other_App\{ one_function, two_function };
 9 | 
10 | class GreatClass {
11 | 	private function activate() {
12 | 		whitelisted_function();
13 | 		another_whitelisted_function(); // unimported
14 | 		non_whitelisted_function(); // unimported
15 | 		one_function();
16 | 		two_function();
17 | 		three_function();
18 | 		Snacks\do_that_magic();
19 | 		Cookies\eat_them(); // unimported
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/RequireImportsAllowedPatternFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace CAR_APP\Vehicles\Greatness;
 5 | 
 6 | use MagicCode\Snacks;
 7 | use function CAR_APP\Functions\whitelisted_function;
 8 | use function CAR_APP\Functions\unused_function; // unused
 9 | use function CAR_APP\Functions\{ three_function, four_function }; // unused
10 | use function Other_App\{ one_function, two_function };
11 | 
12 | class GreatClass {
13 | 	private function activate() {
14 | 		whitelisted_function();
15 | 		another_whitelisted_function(); // unimported
16 | 		non_whitelisted_function(); // unimported
17 | 		one_function();
18 | 		two_function();
19 | 		three_function();
20 | 		Snacks\do_that_magic();
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/InterfaceFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // Declare the interface 'iTemplate'
 4 | interface iTemplate
 5 | {
 6 |     public function setVariable($name, $var);
 7 |     public function getHtml($template);
 8 | }
 9 | 
10 | // Implement the interface
11 | // This will work
12 | class Template implements iTemplate
13 | {
14 |     private $vars = array();
15 |   
16 |     public function setVariable($name, $var)
17 |     {
18 |         $this->vars[$name] = $var;
19 |     }
20 |   
21 |     public function getHtml($template)
22 |     {
23 |         foreach($this->vars as $name => $value) {
24 |             $template = str_replace('{' . $name . '}', $value, $template);
25 |         }
26 |  
27 |         return $template;
28 |     }
29 | }
30 | 
31 | class BadClass implements BadTemplate {
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/TraitFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // Declare the interface 'GoodTrait'
 4 | trait GoodTrait
 5 | {
 6 |     private $traitVar = "trait";
 7 | 
 8 |     public function getTraitVar()
 9 |     {
10 |         return $this->traitVar;
11 |     }
12 | }
13 | 
14 | // Use the trait
15 | // This will work
16 | class UseTrait
17 | {
18 |     use GoodTrait;
19 |     private $vars = array();
20 |   
21 |     public function setVariable($name, $var)
22 |     {
23 |         $this->vars[$name] = $var;
24 |     }
25 |   
26 |     public function getHtml($template)
27 |     {
28 |         foreach($this->vars as $name => $value) {
29 |             $template = str_replace('{' . $name . '}', $value, $template);
30 |         }
31 |  
32 |         return $template;
33 |     }
34 | }
35 | 
36 | class BadClass {
37 |     use BadTrait;
38 | }
39 | 


--------------------------------------------------------------------------------
/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | jobs:
 3 |   build_php7.0:
 4 |     docker:
 5 |       - image: circleci/php:7.0-apache-stretch-browsers
 6 |     steps:
 7 |       - checkout
 8 |       - run: COMPOSER=composer-php7.json composer install
 9 |       - run: COMPOSER=composer-php7.json composer test
10 |   build_php8.0:
11 |     docker:
12 |       - image: circleci/php:8.0
13 |     steps:
14 |       - checkout
15 |       - run: COMPOSER=composer.json composer install
16 |       - run: COMPOSER=composer.json composer test
17 |   build_php7.4:
18 |     docker:
19 |       - image: circleci/php:7.4.6
20 |     steps:
21 |       - checkout
22 |       - run: COMPOSER=composer.json composer install
23 |       - run: COMPOSER=composer.json composer test
24 | workflows:
25 |   version: 2
26 |   build_php_versions:
27 |     jobs:
28 |       - build_php7.0
29 |       - build_php7.4
30 |       - build_php8.0
31 | 


--------------------------------------------------------------------------------
/ImportDetection/FileSymbolRecord.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ImportDetection;
 4 | 
 5 | class FileSymbolRecord {
 6 | 	public $importedFunctions = [];
 7 | 	public $importedConsts = [];
 8 | 	public $importedClasses = [];
 9 | 	public $importedSymbolRecords = [];
10 | 	public $seenSymbols = [];
11 | 	public $activeNamespace = null;
12 | 
13 | 	public function addImportedFunctions($names) {
14 | 		$this->importedFunctions = array_merge($this->importedFunctions, $names);
15 | 	}
16 | 
17 | 	public function addImportedClasses($names) {
18 | 		$this->importedClasses = array_merge($this->importedClasses, $names);
19 | 	}
20 | 
21 | 	public function addImportedConsts($names) {
22 | 		$this->importedConsts = array_merge($this->importedConsts, $names);
23 | 	}
24 | 
25 | 	public function addImportedSymbolRecords($names) {
26 | 		$this->importedSymbolRecords = array_merge($this->importedSymbolRecords, $names);
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/composer-php7.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "sirbrillig/phpcs-import-detection",
 3 |     "description": "A set of phpcs sniffs to look for unused or unimported symbols.",
 4 |     "type": "phpcodesniffer-standard",
 5 |     "keywords" : [ "phpcs", "static analysis" ],
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Payton Swick",
10 |             "email": "payton@foolord.com"
11 |         }
12 |     ],
13 |     "autoload": {
14 |         "psr-4": {
15 |             "ImportDetection\\": "ImportDetection/"
16 |         }
17 |     },
18 |     "minimum-stability": "dev",
19 |     "prefer-stable": true,
20 |     "scripts": {
21 |         "test": "./vendor/bin/phpunit"
22 |     },
23 |     "require" : {
24 |         "php": "^7.0",
25 |         "squizlabs/php_codesniffer": "^3.5.8"
26 |     },
27 |     "require-dev": {
28 |         "sirbrillig/phpcs-variable-analysis": "^2.0.1",
29 |         "dealerdirect/phpcodesniffer-composer-installer": "^0.7.1",
30 |         "phpunit/phpunit": "^6.4"
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "sirbrillig/phpcs-import-detection",
 3 |     "description": "A set of phpcs sniffs to look for unused or unimported symbols.",
 4 |     "type": "phpcodesniffer-standard",
 5 |     "keywords" : [ "phpcs", "static analysis" ],
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Payton Swick",
10 |             "email": "payton@foolord.com"
11 |         }
12 |     ],
13 |     "autoload": {
14 |         "psr-4": {
15 |             "ImportDetection\\": "ImportDetection/"
16 |         }
17 |     },
18 |     "minimum-stability": "dev",
19 |     "prefer-stable": true,
20 |     "scripts": {
21 |         "test": "./vendor/bin/phpunit"
22 |     },
23 |     "require" : {
24 |         "php": "^7.0 || ^8.0",
25 |         "squizlabs/php_codesniffer": "^3.5.8"
26 |     },
27 |     "require-dev": {
28 |         "sirbrillig/phpcs-variable-analysis": "^2.0.1",
29 |         "dealerdirect/phpcodesniffer-composer-installer": "^0.7.1",
30 |         "phpunit/phpunit": "^9.0"
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/NestedFunctionsFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | function doThing() {
 3 | 
 4 | 	function nestedFuncA( $arg ) {
 5 | 		echo $arg . ' world';
 6 | 	}
 7 | 
 8 | 	nestedFuncA( 'here' );
 9 | 	nestedFuncB( 'hello' ); // warning: undefined
10 | 	doAThing( 'dothingfunc' ); // warning: undefined
11 | }
12 | 
13 | class MyThing {
14 | 	public function doAThing() {
15 | 		function nestedFuncB( $arg ) {
16 | 			echo $arg . ' world';
17 | 		}
18 | 
19 | 		nestedFuncB( 'hello' );
20 | 		nestedFuncA( 'live' ); // warning: undefined
21 | 		$this->nestedFuncA( 'hello' );
22 | 
23 | 		if (true) {
24 | 			nestedFuncB( 'boo' );
25 | 		}
26 | 
27 | 		if (true) {
28 | 			function nestedFuncC() {
29 | 				echo 'we are deep now';
30 | 			}
31 | 
32 | 			nestedFuncC();
33 | 		}
34 | 	}
35 | 
36 | 	public function doANestedThing() {
37 | 		function nestedFuncA() {
38 | 			echo 'nope';
39 | 		}
40 | 
41 | 		\registerThing(new class {
42 | 			public function subClassFunc() {
43 | 				function nestedFuncC( $arg ) {
44 | 					echo $arg . ' world';
45 | 				}
46 | 
47 | 				nestedFuncC( 'hello' );
48 | 				nestedFuncA( 'blarg' ); // warning: undefined
49 | 			}
50 | 		});
51 | 
52 | 		doANestedThing('thisfunc'); // warning: undefined
53 | 	}
54 | }
55 | 
56 | nestedFuncA( 'hi' ); // warning: undefined
57 | 


--------------------------------------------------------------------------------
/phpcs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <ruleset name="MyStandard">
 3 |     <description>
 4 |         From https://gist.github.com/Ovsyanka/e2ab2ff76e7c0d7e75a1e4213a03ff95
 5 |         PSR2 with changes:
 6 |             * tabs instead of spaces (https://gist.github.com/gsherwood/9d22f634c57f990a7c64)
 7 |             * bracers on end of line instead new line
 8 |     </description>
 9 | 
10 |     <!-- tabs -->
11 |     <arg name="tab-width" value="4"/>
12 |     <rule ref="PSR2">
13 |         <!-- bracers -->
14 |         <exclude name="Squiz.Functions.MultiLineFunctionDeclaration.BraceOnSameLine" />
15 |         <exclude name="PSR2.Classes.ClassDeclaration.OpenBraceNewLine" />
16 | 
17 |         <!-- tabs -->
18 |         <exclude name="Generic.WhiteSpace.DisallowTabIndent"/>
19 |     </rule>
20 | 
21 |     <!-- tabs -->
22 |     <rule ref="Generic.WhiteSpace.DisallowSpaceIndent"/>
23 |     <rule ref="Generic.WhiteSpace.ScopeIndent">
24 |         <properties>
25 |             <property name="indent" value="4"/>
26 |             <property name="tabIndent" value="true"/>
27 |         </properties>
28 |     </rule>
29 | 
30 |     <!-- bracers -->
31 |     <rule ref="Generic.Functions.OpeningFunctionBraceKernighanRitchie" />
32 |     <rule ref="Generic.Classes.OpeningBraceSameLine"/>
33 | 
34 |     <!-- variables: https://github.com/sirbrillig/VariableAnalysis/ -->
35 |     <rule ref="VariableAnalysis"/>
36 |     <rule ref="VariableAnalysis.CodeAnalysis.VariableAnalysis">
37 |         <properties>
38 |             <property name="allowUnusedCaughtExceptions" value="true"/>
39 |         </properties>
40 |     </rule>
41 |     <rule ref="VariableAnalysis.CodeAnalysis.VariableAnalysis.UndefinedVariable">
42 |         <type>error</type>
43 |     </rule>
44 |     <rule ref="Generic.Files.LineLength.TooLong">
45 |         <severity>0</severity>
46 |     </rule>
47 | </ruleset>
48 | 


--------------------------------------------------------------------------------
/ImportDetection/Symbol.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace ImportDetection;
 5 | 
 6 | class Symbol {
 7 | 	private $tokens;
 8 | 	private $isUsed;
 9 | 	private $alias;
10 | 
11 | 	public function __construct(array $tokens, self $alias = null) {
12 | 		if (empty($tokens)) {
13 | 			throw new \Exception('Cannot construct Symbol with no tokens');
14 | 		}
15 | 		foreach ($tokens as $token) {
16 | 			if (empty($token) || ! is_array($token)) {
17 | 				throw new \Exception('Cannot construct Symbol with invalid token: ' . var_export($token, true));
18 | 			}
19 | 		}
20 | 		$this->tokens = $tokens;
21 | 		$this->isUsed = false;
22 | 		$this->alias = $alias;
23 | 	}
24 | 
25 | 	public static function getTokenWithPosition(array $token, int $stackPtr): array {
26 | 		$token['tokenPosition'] = $stackPtr;
27 | 		return $token;
28 | 	}
29 | 
30 | 	public function getTokens(): array {
31 | 		return $this->tokens;
32 | 	}
33 | 
34 | 	public function getName(): string {
35 | 		return $this->joinSymbolParts($this->tokens);
36 | 	}
37 | 
38 | 	public function getAlias(): string {
39 | 		if ($this->alias) {
40 | 			return $this->alias->getName();
41 | 		}
42 | 
43 | 		return $this->tokens[count($this->tokens) - 1]['content'];
44 | 	}
45 | 
46 | 	public function isAbsoluteNamespace(): bool {
47 | 		$type = $this->tokens[0]['type'] ?? '';
48 | 		return $type === 'T_NS_SEPARATOR';
49 | 	}
50 | 
51 | 	public function isNamespaced(): bool {
52 | 		return count($this->tokens) > 1;
53 | 	}
54 | 
55 | 	/**
56 | 	 * @return string|null
57 | 	 */
58 | 	public function getTopLevelNamespace() {
59 | 		if (! $this->isNamespaced()) {
60 | 			return null;
61 | 		}
62 | 		return $this->tokens[0]['content'] ?? null;
63 | 	}
64 | 
65 | 	public function getSymbolPosition(): int {
66 | 		return $this->tokens[0]['tokenPosition'] ?? 1;
67 | 	}
68 | 
69 | 	public function getSymbolConditions(): array {
70 | 		return $this->tokens[0]['conditions'] ?? [];
71 | 	}
72 | 
73 | 	public function markUsed() {
74 | 		$this->isUsed = true;
75 | 	}
76 | 
77 | 	public function isUsed(): bool {
78 | 		return $this->isUsed;
79 | 	}
80 | 
81 | 	private function joinSymbolParts(array $tokens): string {
82 | 		$symbolStrings = array_map(function (array $token): string {
83 | 			return $token['content'] ?? '';
84 | 		}, $tokens);
85 | 		return implode('', $symbolStrings);
86 | 	}
87 | }
88 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/WordPressFixture.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MyPlugin;
 4 | 
 5 | /*
 6 | Plugin Name: MyPlugin
 7 | Plugin URI:   http://automattic.com/
 8 | Description:  This is a test of a WordPress plugin file
 9 | Version:      1.0.0
10 | Author:       Whoever
11 | License:      GPL2
12 | License URI:  https://www.gnu.org/licenses/gpl-2.0.html
13 | Text Domain:  wporg
14 | Domain Path:  /languages
15 | */
16 | class CoolPlugin {
17 | 	/**
18 | 	 * Plugin class constructor.
19 | 	 *
20 | 	 * @access public
21 | 	 */
22 | 	public function __construct() {
23 | 		add_action( 'init', array( $this, 'init' ) ); // WordPressSymbol
24 | 	}
25 | 
26 | 	/**
27 | 	 * Hook actions and filters, set options.
28 | 	 *
29 | 	 * @access public
30 | 	 */
31 | 	public function init() {
32 | 		$current_user = wp_get_current_user(); // WordPressSymbol
33 | 		load_plugin_textdomain( 'myplugin', false, basename( dirname( __FILE__ ) ) . '/languages' ); // WordPressSymbol
34 | 		add_action( 'admin_menu', array( $this, 'add_admin_pages' ) ); // WordPressSymbol
35 | 		add_filter( 'the_posts', array( $this, 'the_posts_intercept' ) ); // WordPressSymbol
36 | 		do_action( 'some_filter' ); // WordPressSymbol
37 | 		apply_filters( 'some_filter', 'hello' ); // WordPressSymbol
38 | 		some_unimported_function(); // unimported
39 | 	}
40 | 
41 | 	public function test_constants() {
42 | 		if (DOING_AJAX) { // WordPressSymbol
43 | 			return 1;
44 | 		}
45 | 		if (XMLRPC_REQUEST) { // WordPressSymbol
46 | 			return 2;
47 | 		}
48 | 		if (file_exists(WP_PLUGIN_URL . '/foo/bar')) { // WordPressSymbol
49 | 			return 3;
50 | 		}
51 | 		$output = $this->test_classes();
52 | 		if (is_wp_error($output)) { // WordPressSymbol
53 | 			return 4;
54 | 		}
55 | 		$count = HOUR_IN_SECONDS + 10; // WordPressSymbol
56 | 		return $count;
57 | 	}
58 | 
59 | 	public function test_classes() {
60 | 		if (WP_USE_THEMES) { // WordPressSymbol
61 | 			return new WP_Error(); // unimported
62 | 		}
63 | 		return new WP_Post(); // unimported
64 | 	}
65 | 
66 | 	public function test_additional_constants() {
67 | 		global $wpdb;
68 | 		return $wpdb->get_results(
69 | 			"SELECT data.*
70 | 			FROM {$wpdb->data} bar
71 | 			LEFT JOIN {$wpdb->data_meta} foo
72 | 			ON foo.id = bar.id
73 | 			LIMIT 1",
74 | 			OBJECT_K // WordPressSymbol
75 | 		);
76 | 	}
77 | }
78 | 
79 | function foo() {}
80 | add_action('init', foo);
81 | foo();
82 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD Licence Agreement
 2 | -----------------------------------------------------------------------
 3 | 
 4 | This software is available to you under the BSD license,
 5 | available in the LICENSE file accompanying this software.
 6 | You may obtain a copy of the License at
 7 | 
 8 | http://www.opensource.org/licenses/bsd-license.php
 9 | 
10 | -----------------------------------------------------------------------
11 | 
12 | Copyright (c) 2011, Sam Graham <php-codesniffer-variableanalysis BLAHBLAH illusori.co.uk>
13 | All rights reserved.
14 | 
15 | Redistribution and use in source and binary forms, with or without
16 | modification, are permitted provided that the following conditions are
17 | met:
18 | 
19 |  * Redistributions of source code must retain the above copyright
20 |    notice, this list of conditions and the following disclaimer.
21 |  * Redistributions in binary form must reproduce the above copyright
22 |    notice, this list of conditions and the following disclaimer in the
23 |    documentation and/or other materials provided with the
24 |    distribution.
25 | 
26 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 | 
38 | -----------------------------------------------------------------------
39 | 
40 | Portions of this sofware derived from work Copyright (c) 2010, Monotek d.o.o,
41 | released under a BSD License available at:
42 | 
43 | http://www.opensource.org/licenses/bsd-license.php
44 | 
45 | -----------------------------------------------------------------------
46 | 
47 | Portions of this software derived from work Copyright (c), 2006 Squiz
48 | Pty Ltd (ABN 77 084 670 600), available under the following license:
49 | 
50 | BSD Licence Agreement
51 | -----------------------------------------------------------------------
52 | 
53 | This software is available to you under the BSD license,
54 | available in the LICENSE file accompanying this software.
55 | You may obtain a copy of the License at
56 | 
57 | http://matrix.squiz.net/developer/tools/php_cs/licence
58 | 
59 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
60 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
61 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
62 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
63 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
64 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
65 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
66 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
67 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
68 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
69 | 
70 | Copyright (c), 2006 Squiz Pty Ltd (ABN 77 084 670 600).
71 | All rights reserved.
72 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/Fixtures/RequireImportsFixture.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare( strict_types=1 );
  3 | 
  4 | namespace CAR_APP\Vehicles;
  5 | 
  6 | use Physics\MovementType;
  7 | use VehicleWithEmissions as PollutionProducer;
  8 | use function Roads\getSpeedLimit;
  9 | use function monitor_begin;
 10 | use function Physics\{ // this line has an unused import
 11 | 	setMoving,
 12 | 	setMovable as makeItMove,
 13 | 	setStopped
 14 | };
 15 | use CAR_APP_GLOBALS; // this line has an unused import
 16 | use WeatherStore;
 17 | use WeatherModels\Storm;
 18 | use const Weather\SNOW;
 19 | use const Weather\{RAIN, SLEET, CAR_IN_WEATHER}; // this line has an unused import
 20 | use Notifications\Alerts;
 21 | 
 22 | const TYPE = 'Car';
 23 | 
 24 | class Car {
 25 | 	public function drive(string $whereTo, Car $previousCar = null) {
 26 | 		// next line has unimported function
 27 | 		$currentWeather = getWeather();
 28 | 		if ($currentWeather === SNOW) {
 29 | 			// next line has unimported class
 30 | 			return new DrivingProblem('weather is too harsh');
 31 | 		}
 32 | 		if ($currentWeather === RAIN) {
 33 | 			// next line has unimported class
 34 | 			return new DrivingProblem('weather is too harsh');
 35 | 		}
 36 | 		// next line has unimported const
 37 | 		if ($currentWeather === SUN) {
 38 | 			// next line has unimported class
 39 | 			if (DataStore::readyToMark()) {
 40 | 				WeatherStore::markGoodDay();
 41 | 			}
 42 | 		}
 43 | 		if ($currentWeather instanceof Storm) {
 44 | 			return new \Exception('stormy');
 45 | 		}
 46 | 		// next line has unimported class
 47 | 		if ($currentWeather instanceof Drizzle) {
 48 | 			throw new \Exception();
 49 | 		}
 50 | 		if (getSpeedLimit() < 1) {
 51 | 			// next line has unimported class
 52 | 			return new DrivingProblem('no speed limit');
 53 | 		}
 54 | 		setMoving(TYPE, true);
 55 | 		\Physics\setMoving(TYPE, 'drive');
 56 | 		// next line has an unimported function
 57 | 		setMovable(CAR_IN_WEATHER);
 58 | 		makeItMove(CAR_IN_WEATHER);
 59 | 		startMonitor();
 60 | 		$this->polluter = new PollutionProducer();
 61 | 		// next line has an unimported class
 62 | 		$data = new stdClass(PHP_VERSION);
 63 | 		$store = new WeatherStore($data);
 64 | 		try {
 65 | 			$store->trackWeather($store->key);
 66 | 		} catch (\MyException $err) {
 67 | 			Alerts\makeAnAlert($err);
 68 | 			// next line has an unimported function
 69 | 			OldAlerts\makeAlert($err);
 70 | 			// next line has an unimported class
 71 | 			$oldAlert = new OldAlerts\OldAlert();
 72 | 			// next line has an unimported class
 73 | 			$oldAlert = OldAlerts\OldAlert::makeRed($oldAlert);
 74 | 			$oldAlert->warn();
 75 | 			$alert = new Alerts\MyAlert();
 76 | 			$alert = Alerts\MyAlert::markAlertImportant($alert);
 77 | 			$alert->notifyUser();
 78 | 			// next line has an unimported class
 79 | 			return new Exception('buggy');
 80 | 		}
 81 | 		$name = $store->current_name_as_string;
 82 | 		$data = new \stdClass(PHP_VERSION);
 83 | 		return new MovementType('driving in ' . $name);
 84 | 	}
 85 | 
 86 | 	// next line has an unimported class
 87 | 	public function convertToRobot(Car $car): Robot {
 88 | 		// next line has an unimported class
 89 | 		return new Robot($car);
 90 | 	}
 91 | }
 92 | 
 93 | function startMonitor() {
 94 | 	// next line has an unimported function
 95 | 	OldAlerts\makeAlert();
 96 | 	new Car();
 97 | 	echo str_replace('Foo', 'Bar', 'Foobar...');
 98 | 	$rows = whitelisted_function();
 99 | 	$data = allowed_funcs_function_one();
100 | 	array_map(function (array $row) use ($data) {
101 | 		$data && monitor_begin($row);
102 | 	}, $rows);
103 | }
104 | 
105 | define(WHATEVER, 'some words');
106 | 
107 | function engageMagic(object $foobar) {
108 | 	echo $foobar;
109 | }
110 | 
111 | function engageMoreMagic(mixed $foobar) {
112 | 	echo $foobar;
113 | }
114 | 


--------------------------------------------------------------------------------
/tests/SniffTestHelper.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | // phpcs:disable PSR1.Classes.ClassDeclaration.MultipleClasses
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ImportDetectionTest;
  6 | 
  7 | use PHP_CodeSniffer\Files\LocalFile;
  8 | use PHP_CodeSniffer\Files\FileList;
  9 | use PHP_CodeSniffer\Ruleset;
 10 | use PHP_CodeSniffer\Config;
 11 | 
 12 | class MessageRecord {
 13 | 	public $rowNumber;
 14 | 	public $columnNumber;
 15 | 	public $message;
 16 | 	public $source;
 17 | }
 18 | 
 19 | class SniffTestHelper {
 20 | 	public function prepareLocalFileForSniffs($sniffFiles, string $fixtureFile): LocalFile {
 21 | 		$config = new Config();
 22 | 		$ruleset = new Ruleset($config);
 23 | 		if (! is_array($sniffFiles)) {
 24 | 			$sniffFiles = [$sniffFiles];
 25 | 		}
 26 | 		$ruleset->registerSniffs($sniffFiles, [], []);
 27 | 		$ruleset->populateTokenListeners();
 28 | 		if (! file_exists($fixtureFile)) {
 29 | 			throw new \Exception('Fixture file does not exist! ' . $fixtureFile);
 30 | 		}
 31 | 		return new LocalFile($fixtureFile, $ruleset, $config);
 32 | 	}
 33 | 
 34 | 	public function prepareLocalFilesForSniffs($sniffFiles, $fixtureFiles): FileList {
 35 | 		$config = new Config();
 36 | 		if (! is_array($fixtureFiles)) {
 37 | 			$fixtureFiles = [$fixtureFiles];
 38 | 		}
 39 | 		$config->files = $fixtureFiles;
 40 | 		$ruleset = new Ruleset($config);
 41 | 		if (! is_array($sniffFiles)) {
 42 | 			$sniffFiles = [$sniffFiles];
 43 | 		}
 44 | 		$ruleset->registerSniffs($sniffFiles, [], []);
 45 | 		$ruleset->populateTokenListeners();
 46 | 		return new FileList($config, $ruleset);
 47 | 	}
 48 | 
 49 | 	public function processFiles($sniffFiles) {
 50 | 		foreach ($sniffFiles as $phpcsFile) {
 51 | 			if (! file_exists($phpcsFile->path)) {
 52 | 				throw new \Exception('Fixture file does not exist! ' . $phpcsFile->path);
 53 | 			}
 54 | 			$phpcsFile->process();
 55 | 		}
 56 | 	}
 57 | 
 58 | 	public function getWarningMessageRecords(array $messages) {
 59 | 		$messageRecords = [];
 60 | 		foreach ($messages as $rowNumber => $messageRow) {
 61 | 			foreach ($messageRow as $columnNumber => $messageArrays) {
 62 | 				foreach ($messageArrays as $messageArray) {
 63 | 					$messageRecord = new MessageRecord();
 64 | 					$messageRecord->rowNumber = $rowNumber;
 65 | 					$messageRecord->columnNumber = $columnNumber;
 66 | 					$messageRecord->message = $messageArray['message'];
 67 | 					$messageRecord->source = $messageArray['source'];
 68 | 					$messageRecords[] = $messageRecord;
 69 | 				}
 70 | 			}
 71 | 		}
 72 | 		return $messageRecords;
 73 | 	}
 74 | 
 75 | 	public function getLineNumbersFromMessages(array $messages): array {
 76 | 		$lines = array_keys($messages);
 77 | 		sort($lines);
 78 | 		return $lines;
 79 | 	}
 80 | 
 81 | 	public function getNoticesFromFiles($phpcsFiles, string $noticeType): array {
 82 | 		$noticesByFile = [];
 83 | 		foreach ($phpcsFiles as $phpcsFile) {
 84 | 			switch ($noticeType) {
 85 | 				case 'warning':
 86 | 					$noticesByFile[$phpcsFile->path] = $this->getLineNumbersFromMessages($phpcsFile->getWarnings());
 87 | 					break;
 88 | 				case 'error':
 89 | 					$noticesByFile[$phpcsFile->path] = $this->getLineNumbersFromMessages($phpcsFile->getErrors());
 90 | 					break;
 91 | 				default:
 92 | 					throw new \Exception("Invalid notice type '{$noticeType}'");
 93 | 			}
 94 | 		}
 95 | 		return $noticesByFile;
 96 | 	}
 97 | 
 98 | 	public function getWarningLineNumbersFromFile(LocalFile $phpcsFile): array {
 99 | 		return $this->getLineNumbersFromMessages($phpcsFile->getWarnings());
100 | 	}
101 | 
102 | 	public function getErrorLineNumbersFromFile(LocalFile $phpcsFile): array {
103 | 		return $this->getLineNumbersFromMessages($phpcsFile->getErrors());
104 | 	}
105 | 
106 | 	public function getFixedFileContents(LocalFile $phpcsFile) {
107 | 		$phpcsFile->fixer->startFile($phpcsFile);
108 | 		$phpcsFile->fixer->fixFile();
109 | 		return $phpcsFile->fixer->getContents();
110 | 	}
111 | }
112 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # ImportDetection
  2 | 
  3 | A set of [phpcs](https://github.com/squizlabs/PHP_CodeSniffer) sniffs to look for unused or unimported symbols.
  4 | 
  5 | This adds a sniff which shows warnings if a symbol (function, constant, class) is used and is not defined directly, imported explicitly, nor has its namespace imported.
  6 | 
  7 | > [!WARNING]
  8 | > PHP 8 changed how `use` statements are tokenized, leading to [this bug](https://github.com/sirbrillig/phpcs-import-detection/issues/52) which basically breaks this sniff. This sniff also has fairly poor performance. I don't have time with my current work to continue to refactor this sniff at the moment and I wouldn't recommend it until at least that issue is fixed. If anyone wants to work on improvements, feel free to open a PR!
  9 | 
 10 | When code is moved around, it can be problematic if classes which are used in a relative or global context get moved to a different namespace. In those cases it's better if the classes use their fully-qualified namespace, or if they are imported explicitly using `use` (in which case they can be detected by a linter like this one). These warnings should help when refactoring code to avoid bugs.
 11 | 
 12 | It also detects imports which are _not_ being used.
 13 | 
 14 | For example:
 15 | 
 16 | ```php
 17 | namespace Vehicles;
 18 | use Registry;
 19 | use function Vehicles\startCar;
 20 | use Chocolate; // this will be a warning because `Chocolate` is never used
 21 | class Car {
 22 |   public function drive() {
 23 |     startCar(); // this is fine because `startCar` is imported
 24 |     Registry\registerCar($this); // this is fine because `Registry` is imported
 25 |     \DrivingTracker\registerDrive($this); // this is fine because it's fully-qualified
 26 |     goFaster(); // this will be a warning because `goFaster` was not imported
 27 |   }
 28 | }
 29 | ```
 30 | 
 31 | **Note:** This sniff is a lightweight syntax checker providing a scan of the current file and it doesn't know what other files might have defined. Therefore it will warn you about implicitly imported symbols even if they're in the same namespace. It's safe to import something from the same namespace and can even improve readability, but if you'd prefer to scan multiple files, I suggest using static analysis tools like [psalm](https://psalm.dev/) or [phpstan](https://github.com/phpstan/phpstan).
 32 | 
 33 | ## Installation
 34 | 
 35 | To use these rules in a project which is set up using [composer](https://href.li/?https://getcomposer.org/), we recommend using the [phpcodesniffer-composer-installer library](https://href.li/?https://github.com/DealerDirect/phpcodesniffer-composer-installer) which will automatically use all installed standards in the current project with the composer type `phpcodesniffer-standard` when you run phpcs.
 36 | 
 37 | ```
 38 | composer require --dev sirbrillig/phpcs-import-detection dealerdirect/phpcodesniffer-composer-installer
 39 | ```
 40 | 
 41 | ## Configuration
 42 | 
 43 | When installing sniff standards in a project, you edit a `phpcs.xml` file with the `rule` tag inside the `ruleset` tag. The `ref` attribute of that tag should specify a standard, category, sniff, or error code to enable. It’s also possible to use these tags to disable or modify certain rules. The [official annotated file](https://href.li/?https://github.com/squizlabs/PHP_CodeSniffer/wiki/Annotated-ruleset.xml) explains how to do this.
 44 | 
 45 | ```xml
 46 | <?xml version="1.0"?>
 47 | <ruleset name="MyStandard">
 48 |  <description>My library.</description>
 49 |  <rule ref="ImportDetection"/>
 50 | </ruleset>
 51 | ```
 52 | 
 53 | ## Sniff Codes
 54 | 
 55 | There are two sniff codes that are reported by this sniff. Both are warnings.
 56 | 
 57 | - `ImportDetection.Imports.RequireImports.Symbol`: A symbol has been used but not imported
 58 | - `ImportDetection.Imports.RequireImports.Import`: A symbol has been imported and not used
 59 | 
 60 | In any given file, you can use phpcs comments to disable these sniffs. For example, if you have a global class called `MyGlobalClass` which you don't want to import, you could use it like this:
 61 | 
 62 | ```php
 63 | <?php
 64 | 
 65 | $instance = new MyGlobalClass(); // phpcs:ignore ImportDetection.Imports.RequireImports.Symbol -- this class is global
 66 | $instance->doSomething();
 67 | ```
 68 | 
 69 | For a whole file, you can ignore a sniff like this:
 70 | 
 71 | ```php
 72 | <?php
 73 | // phpcs:disable ImportDetection.Imports.RequireImports.Symbol
 74 | 
 75 | $instance = new MyGlobalClass();
 76 | $instance->doSomething();
 77 | ```
 78 | 
 79 | For a whole project, you can use the `phpcs.xml` file to disable these sniffs or modify their priority. For example, to disable checks for unused imports, you could use a configuration like this:
 80 | 
 81 | ```xml
 82 | <?xml version="1.0"?>
 83 | <ruleset name="MyStandard">
 84 |  <description>My library.</description>
 85 |  <rule ref="ImportDetection"/>
 86 |  <rule ref="ImportDetection.Imports.RequireImports.Import">
 87 |    <severity>0</severity>
 88 |  </rule>
 89 | </ruleset>
 90 | ```
 91 | 
 92 | ## Ignoring Symbol Patterns
 93 | 
 94 | Oftentimes there might be global symbols that you want to use without importing or using a fully-qualified path.
 95 | 
 96 | (Remember that function call resolution first searches the current namespace, then the global namespace, but constant and class resolution only searches the current namespace! You still have to import things like `Exception` or use the fully-qualified `\Exception`.)
 97 | 
 98 | You can ignore certain patterns by using the `ignoreUnimportedSymbols` config option. It is a regular expression. Here is an example for some common WordPress symbols:
 99 | 
100 | ```xml
101 | <?xml version="1.0"?>
102 | <ruleset name="MyStandard">
103 |  <description>My library.</description>
104 |  <rule ref="ImportDetection"/>
105 |  <rule ref="ImportDetection.Imports.RequireImports">
106 |    <properties>
107 |     <property name="ignoreUnimportedSymbols" value="/^(wp_parse_args|OBJECT\S*|ARRAY_\S+|is_wp_error|__|esc_html__|get_blog_\S+)$/"/>
108 |   </properties>
109 |  </rule>
110 | </ruleset>
111 | ```
112 | 
113 | Despite the name, you can also use the `ignoreUnimportedSymbols` pattern to ignore specific unused imports.
114 | 
115 | ## Ignoring Global Symbols in Global Namespace
116 | 
117 | If a file is in the global namespace, then sometimes it may be unnecessary to import functions that are also global. If you'd like to ignore global symbol use in the global namespace, you can enable the `ignoreGlobalsWhenInGlobalScope` option, like this:
118 | 
119 | ```xml
120 | <?xml version="1.0"?>
121 | <ruleset name="MyStandard">
122 |  <description>My library.</description>
123 |  <rule ref="ImportDetection"/>
124 |  <rule ref="ImportDetection.Imports.RequireImports">
125 |    <properties>
126 |     <property name="ignoreGlobalsWhenInGlobalScope" value="true"/>
127 |   </properties>
128 |  </rule>
129 | </ruleset>
130 | ```
131 | 
132 | ## Ignoring WordPress Patterns
133 | 
134 | A common use-case is to ignore all the globally available WordPress symbols. Rather than trying to come up with a pattern to ignore them all yourself, you can set the config option `ignoreWordPressSymbols` which will ignore as many of them as it knows about. For example:
135 | 
136 | ```xml
137 | <?xml version="1.0"?>
138 | <ruleset name="MyStandard">
139 |  <description>My library.</description>
140 |  <rule ref="ImportDetection"/>
141 |  <rule ref="ImportDetection.Imports.RequireImports">
142 |    <properties>
143 |     <property name="ignoreWordPressSymbols" value="true"/>
144 |   </properties>
145 |  </rule>
146 | </ruleset>
147 | ```
148 | 
149 | ## Usage
150 | 
151 | Most editors have a phpcs plugin available, but you can also run phpcs manually. To run phpcs on a file in your project, just use the command-line as follows (the `-s` causes the sniff code to be shown, which is very important for learning about an error).
152 | 
153 | ```
154 | vendor/bin/phpcs -s src/MyProject/MyClass.php
155 | ```
156 | 
157 | ## See Also
158 | 
159 | - [VariableAnalysis](https://github.com/sirbrillig/phpcs-variable-analysis): Find undefined and unused variables.
160 | 


--------------------------------------------------------------------------------
/ImportDetection/SniffHelpers.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace ImportDetection;
  5 | 
  6 | use ImportDetection\Symbol;
  7 | use PHP_CodeSniffer\Files\File;
  8 | 
  9 | class SniffHelpers {
 10 | 	public function isObjectReference(File $phpcsFile, $stackPtr) {
 11 | 		$tokens = $phpcsFile->getTokens();
 12 | 		$prevPtr = $phpcsFile->findPrevious([T_OBJECT_OPERATOR], $stackPtr - 1, $stackPtr - 2);
 13 | 		return ($prevPtr && isset($tokens[$prevPtr]));
 14 | 	}
 15 | 
 16 | 	public function isStaticReference(File $phpcsFile, $stackPtr) {
 17 | 		$tokens = $phpcsFile->getTokens();
 18 | 		$prevPtr = $phpcsFile->findPrevious([T_DOUBLE_COLON], $stackPtr - 1, $stackPtr - 2);
 19 | 		return ($prevPtr && isset($tokens[$prevPtr]));
 20 | 	}
 21 | 
 22 | 	// Borrowed this idea from
 23 | 	// https://pear.php.net/reference/PHP_CodeSniffer-3.1.1/apidoc/PHP_CodeSniffer/LowercasePHPFunctionsSniff.html
 24 | 	public function isBuiltInFunction(File $phpcsFile, $stackPtr) {
 25 | 		$allFunctions = get_defined_functions();
 26 | 		$builtInFunctions = array_flip($allFunctions['internal']);
 27 | 		$tokens = $phpcsFile->getTokens();
 28 | 		$functionName = $tokens[$stackPtr]['content'];
 29 | 		return isset($builtInFunctions[strtolower($functionName)]);
 30 | 	}
 31 | 
 32 | 	public function isPredefinedTypehint(File $phpcsFile, $stackPtr) {
 33 | 		$allTypehints = [
 34 | 			'bool',
 35 | 			'string',
 36 | 			'mixed',
 37 | 			'object',
 38 | 			'int',
 39 | 			'float',
 40 | 			'void',
 41 | 			'self',
 42 | 			'array',
 43 | 			'callable',
 44 | 			'iterable',
 45 | 		];
 46 | 		$tokens = $phpcsFile->getTokens();
 47 | 		$tokenContent = $tokens[$stackPtr]['content'];
 48 | 		return in_array($tokenContent, $allTypehints, true);
 49 | 	}
 50 | 
 51 | 	public function isPredefinedConstant(File $phpcsFile, $stackPtr) {
 52 | 		$allConstants = get_defined_constants();
 53 | 		$tokens = $phpcsFile->getTokens();
 54 | 		$constantName = $tokens[$stackPtr]['content'];
 55 | 		return isset($allConstants[$constantName]);
 56 | 	}
 57 | 
 58 | 	public function isPredefinedClass(File $phpcsFile, $stackPtr) {
 59 | 		$allClasses = get_declared_classes();
 60 | 		$tokens = $phpcsFile->getTokens();
 61 | 		$className = $tokens[$stackPtr]['content'];
 62 | 		return in_array($className, $allClasses);
 63 | 	}
 64 | 
 65 | 	public function getImportType(File $phpcsFile, $stackPtr): string {
 66 | 		$tokens = $phpcsFile->getTokens();
 67 | 		if (! empty($tokens[$stackPtr]['conditions'])) {
 68 | 			return 'trait-application';
 69 | 		}
 70 | 		$nextStringPtr = $phpcsFile->findNext([T_STRING], $stackPtr + 1);
 71 | 		if (! $nextStringPtr) {
 72 | 			return 'unknown';
 73 | 		}
 74 | 		$isClosureImport = $phpcsFile->findNext([T_OPEN_PARENTHESIS], $stackPtr + 1, $nextStringPtr);
 75 | 		if ($isClosureImport) {
 76 | 			return 'closure';
 77 | 		}
 78 | 		$nextString = $tokens[$nextStringPtr];
 79 | 		if ($nextString['content'] === 'function') {
 80 | 			return 'function';
 81 | 		}
 82 | 		if ($nextString['content'] === 'const') {
 83 | 			return 'const';
 84 | 		}
 85 | 		return 'class';
 86 | 	}
 87 | 
 88 | 	private function getImportedSymbolsFromGroupStatement(File $phpcsFile, int $stackPtr): array {
 89 | 		$tokens = $phpcsFile->getTokens();
 90 | 		$endBracketPtr = $phpcsFile->findNext([T_CLOSE_USE_GROUP], $stackPtr + 1);
 91 | 		$startBracketPtr = $phpcsFile->findNext([T_OPEN_USE_GROUP], $stackPtr + 1);
 92 | 		if (! $endBracketPtr || ! $startBracketPtr) {
 93 | 			throw new \Exception('Invalid group import statement starting at token ' . $stackPtr . ': ' . $tokens[$stackPtr]['content']);
 94 | 		}
 95 | 
 96 | 		// Get the namespace for the import first, so we can attach it to each Symbol
 97 | 		$endOfImportNamespace = $phpcsFile->findPrevious([T_NS_SEPARATOR], $startBracketPtr - 1);
 98 | 		if (! $endOfImportNamespace) {
 99 | 			throw new \Exception('Unable to parse namespace for group import statement starting at token ' . $stackPtr . ': ' . $tokens[$stackPtr]['content']);
100 | 		}
101 | 		$importPrefixSymbol = $this->getFullSymbol($phpcsFile, $endOfImportNamespace);
102 | 
103 | 		$collectedSymbols = [];
104 | 		$lastStringPtr = $startBracketPtr;
105 | 
106 | 		while ($lastStringPtr < $endBracketPtr) {
107 | 			$commaPtr = $phpcsFile->findNext([T_COMMA], $lastStringPtr + 1, $endBracketPtr) ?: $endBracketPtr;
108 | 			$aliasPtr = $phpcsFile->findNext([T_AS], $lastStringPtr + 1, $commaPtr);
109 | 			$aliasSymbol = null;
110 | 
111 | 			if ($aliasPtr) {
112 | 				$aliasStringPtr = $phpcsFile->findNext([T_STRING], $aliasPtr + 1, $commaPtr);
113 | 				$aliasSymbol = new Symbol([Symbol::getTokenWithPosition($tokens[$aliasStringPtr], $aliasStringPtr)]);
114 | 			}
115 | 
116 | 			$endOfStringsPtr = $aliasPtr ?: $commaPtr;
117 | 			$importSuffixSymbols = [];
118 | 
119 | 			do {
120 | 				$lastStringPtr = $phpcsFile->findNext([T_STRING, T_NS_SEPARATOR], $lastStringPtr + 1, $endOfStringsPtr);
121 | 
122 | 				if ($lastStringPtr) {
123 | 					$importSuffixSymbols[] = Symbol::getTokenWithPosition($tokens[$lastStringPtr], $lastStringPtr);
124 | 				}
125 | 			} while ($lastStringPtr);
126 | 
127 | 			$lastStringPtr = $commaPtr;
128 | 
129 | 			if (! empty($importSuffixSymbols)) {
130 | 				$importCompleteSymbol = array_merge($importPrefixSymbol->getTokens(), $importSuffixSymbols);
131 | 				$collectedSymbols[] = new Symbol($importCompleteSymbol, $aliasSymbol);
132 | 			}
133 | 		}
134 | 
135 | 		return $collectedSymbols;
136 | 	}
137 | 
138 | 	public function getImportNames(File $phpcsFile, $stackPtr): array {
139 | 		$symbols = $this->getImportedSymbolsFromImportStatement($phpcsFile, $stackPtr);
140 | 		return array_map(function ($symbol) {
141 | 			return $symbol->getAlias();
142 | 		}, $symbols);
143 | 	}
144 | 
145 | 	public function getImportedSymbolsFromImportStatement(File $phpcsFile, $stackPtr): array {
146 | 		$tokens = $phpcsFile->getTokens();
147 | 
148 | 		$endOfStatementPtr = $phpcsFile->findNext([T_SEMICOLON], $stackPtr + 1);
149 | 		if (! $endOfStatementPtr) {
150 | 			return [];
151 | 		}
152 | 
153 | 		// Process grouped imports differently
154 | 		$nextBracketPtr = $phpcsFile->findNext([T_OPEN_USE_GROUP], $stackPtr + 1, $endOfStatementPtr);
155 | 		if ($nextBracketPtr) {
156 | 			return $this->getImportedSymbolsFromGroupStatement($phpcsFile, $stackPtr);
157 | 		}
158 | 
159 | 		// Get the last string before the last semicolon, comma, or closing curly bracket
160 | 		$endOfImportPtr = $phpcsFile->findPrevious(
161 | 			[T_COMMA, T_CLOSE_USE_GROUP],
162 | 			$stackPtr + 1,
163 | 			$endOfStatementPtr
164 | 		);
165 | 		if (! $endOfImportPtr) {
166 | 			$endOfImportPtr = $endOfStatementPtr;
167 | 		}
168 | 		$lastStringPtr = $phpcsFile->findPrevious([T_STRING], $endOfImportPtr - 1, $stackPtr);
169 | 		if (! $lastStringPtr || ! isset($tokens[$lastStringPtr])) {
170 | 			return [];
171 | 		}
172 | 		return [$this->getFullSymbol($phpcsFile, $lastStringPtr)];
173 | 	}
174 | 
175 | 	public function getPreviousStatementPtr(File $phpcsFile, int $stackPtr): int {
176 | 		return $phpcsFile->findPrevious([T_SEMICOLON, T_CLOSE_CURLY_BRACKET], $stackPtr - 1) ?: 1;
177 | 	}
178 | 
179 | 	public function isWithinDeclareCall(File $phpcsFile, $stackPtr): bool {
180 | 		$previousStatementPtr = $this->getPreviousStatementPtr($phpcsFile, $stackPtr);
181 | 		return !! $phpcsFile->findPrevious([T_DECLARE], $stackPtr - 1, $previousStatementPtr);
182 | 	}
183 | 
184 | 	public function isWithinDefineCall(File $phpcsFile, $stackPtr): bool {
185 | 		$previousStatementPtr = $this->getPreviousStatementPtr($phpcsFile, $stackPtr);
186 | 		return !! $phpcsFile->findPrevious([T_STRING], $stackPtr - 1, $previousStatementPtr, false, 'define');
187 | 	}
188 | 
189 | 	public function isWithinNamespaceStatement(File $phpcsFile, $stackPtr): bool {
190 | 		$previousStatementPtr = $this->getPreviousStatementPtr($phpcsFile, $stackPtr);
191 | 		return !! $phpcsFile->findPrevious([T_NAMESPACE], $stackPtr - 1, $previousStatementPtr);
192 | 	}
193 | 
194 | 	public function isWithinImportStatement(File $phpcsFile, $stackPtr): bool {
195 | 		$tokens = $phpcsFile->getTokens();
196 | 		if (! empty($tokens[$stackPtr]['conditions'])) {
197 | 			return false;
198 | 		}
199 | 		$isClosureImport = $phpcsFile->findNext([T_OPEN_PARENTHESIS], $stackPtr + 1, $stackPtr + 5);
200 | 		if ($isClosureImport) {
201 | 			return false;
202 | 		}
203 | 		$previousStatementPtr = $this->getPreviousStatementPtr($phpcsFile, $stackPtr);
204 | 		return !! $phpcsFile->findPrevious([T_USE], $stackPtr - 1, $previousStatementPtr);
205 | 	}
206 | 
207 | 	/**
208 | 	 * @return array|null
209 | 	 */
210 | 	public function getPreviousNonWhitespaceToken(File $phpcsFile, int $stackPtr) {
211 | 		$tokens = $phpcsFile->getTokens();
212 | 		$prevNonWhitespacePtr = $phpcsFile->findPrevious(T_WHITESPACE, $stackPtr - 1, $stackPtr - 3, true, null, false);
213 | 		if (! $prevNonWhitespacePtr || ! isset($tokens[$prevNonWhitespacePtr])) {
214 | 			return null;
215 | 		}
216 | 		return $tokens[$prevNonWhitespacePtr];
217 | 	}
218 | 
219 | 	public function getConstantName(File $phpcsFile, $stackPtr) {
220 | 		$tokens = $phpcsFile->getTokens();
221 | 		$nextStringPtr = $phpcsFile->findNext([T_STRING], $stackPtr + 1, $stackPtr + 3);
222 | 		if (! $nextStringPtr || ! isset($tokens[$nextStringPtr])) {
223 | 			return null;
224 | 		}
225 | 		return $tokens[$nextStringPtr]['content'];
226 | 	}
227 | 
228 | 	public function isSymbolADefinition(File $phpcsFile, Symbol $symbol): bool {
229 | 		// if the previous non-whitespace token is const, function, class, or trait, it is a definition
230 | 		// Note: this does not handle use statements, for that use isWithinImportStatement
231 | 		$stackPtr = $symbol->getSymbolPosition();
232 | 		$prevToken = $this->getPreviousNonWhitespaceToken($phpcsFile, $stackPtr) ?? [];
233 | 		return $this->isTokenADefinition($prevToken) || $this->isWithinDefineCall($phpcsFile, $stackPtr) || $this->isWithinDeclareCall($phpcsFile, $stackPtr);
234 | 	}
235 | 
236 | 	public function isTokenADefinition(array $token): bool {
237 | 		// Note: this does not handle use or define
238 | 		$type = $token['type'] ?? '';
239 | 		$definitionTypes = ['T_CLASS', 'T_FUNCTION', 'T_CONST', 'T_INTERFACE', 'T_TRAIT'];
240 | 		return in_array($type, $definitionTypes, true);
241 | 	}
242 | 
243 | 	public function getFullSymbol($phpcsFile, $stackPtr): Symbol {
244 | 		$originalPtr = $stackPtr;
245 | 		$tokens = $phpcsFile->getTokens();
246 | 		// go backwards and forward and collect all the tokens until we encounter
247 | 		// anything other than a backslash or a string
248 | 		$currentToken = Symbol::getTokenWithPosition($tokens[$stackPtr], $stackPtr);
249 | 		$fullSymbolParts = [];
250 | 		while ($this->isTokenASymbolPart($currentToken)) {
251 | 			$fullSymbolParts[] = $currentToken;
252 | 			$stackPtr--;
253 | 			$currentToken = Symbol::getTokenWithPosition($tokens[$stackPtr] ?? [], $stackPtr);
254 | 		}
255 | 		$fullSymbolParts = array_reverse($fullSymbolParts);
256 | 		$stackPtr = $originalPtr + 1;
257 | 		$currentToken = Symbol::getTokenWithPosition($tokens[$stackPtr] ?? [], $stackPtr);
258 | 		while ($this->isTokenASymbolPart($currentToken)) {
259 | 			$fullSymbolParts[] = $currentToken;
260 | 			$stackPtr++;
261 | 			$currentToken = Symbol::getTokenWithPosition($tokens[$stackPtr] ?? [], $stackPtr);
262 | 		}
263 | 		return new Symbol($fullSymbolParts);
264 | 	}
265 | 
266 | 	public function isTokenASymbolPart(array $token): bool {
267 | 		$type = $token['type'] ?? '';
268 | 		$symbolParts = ['T_NS_SEPARATOR', 'T_STRING', 'T_RETURN_TYPE'];
269 | 		return in_array($type, $symbolParts, true);
270 | 	}
271 | }
272 | 


--------------------------------------------------------------------------------
/tests/Sniffs/Imports/RequireImportsSniffTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace ImportDetectionTest;
  5 | 
  6 | use PHPUnit\Framework\TestCase;
  7 | 
  8 | class RequireImportsSniffTest extends TestCase {
  9 | 	public function testRequireImportsSniff() {
 10 | 		$fixtureFile = __DIR__ . '/Fixtures/RequireImportsFixture.php';
 11 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
 12 | 		$helper = new SniffTestHelper();
 13 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
 14 | 		$phpcsFile->ruleset->setSniffProperty(
 15 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
 16 | 			'ignoreUnimportedSymbols',
 17 | 			'/^(something_to_ignore|whitelisted_function|allowed_funcs_\w+)$/'
 18 | 		);
 19 | 		$phpcsFile->process();
 20 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
 21 | 		$expectedLines = [
 22 | 			10,
 23 | 			15,
 24 | 			19,
 25 | 			27,
 26 | 			30,
 27 | 			34,
 28 | 			37,
 29 | 			39,
 30 | 			47,
 31 | 			52,
 32 | 			57,
 33 | 			62,
 34 | 			69,
 35 | 			71,
 36 | 			73,
 37 | 			79,
 38 | 			87,
 39 | 			89,
 40 | 			95,
 41 | 		];
 42 | 		$this->assertEquals($expectedLines, $lines);
 43 | 		$this->assertSame(count($expectedLines), $phpcsFile->getWarningCount());
 44 | 	}
 45 | 
 46 | 	public function testRequireImportsSniffFindsUnimportedFunctionsWithNoConfig() {
 47 | 		$fixtureFile = __DIR__ . '/Fixtures/RequireImportsAllowedPatternFixture.php';
 48 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
 49 | 		$helper = new SniffTestHelper();
 50 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
 51 | 		$phpcsFile->ruleset->setSniffProperty(
 52 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
 53 | 			'ignoreUnimportedSymbols',
 54 | 			''
 55 | 		);
 56 | 		$phpcsFile->process();
 57 | 		$messages = $helper->getWarningMessageRecords($phpcsFile->getWarnings());
 58 | 		$messages = array_values(array_filter($messages, function ($message) {
 59 | 			return $message->source === 'ImportDetection.Imports.RequireImports.Symbol';
 60 | 		}));
 61 | 		$lines = array_map(function ($message) {
 62 | 			return $message->rowNumber;
 63 | 		}, $messages);
 64 | 		$expectedLines = [
 65 | 			15,
 66 | 			16,
 67 | 		];
 68 | 		$this->assertEquals($expectedLines, $lines);
 69 | 	}
 70 | 
 71 | 	public function testRequireImportsSniffFindsUnusedImportsWithNoConfig() {
 72 | 		$fixtureFile = __DIR__ . '/Fixtures/RequireImportsAllowedPatternFixture.php';
 73 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
 74 | 		$helper = new SniffTestHelper();
 75 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
 76 | 		$phpcsFile->ruleset->setSniffProperty(
 77 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
 78 | 			'ignoreUnimportedSymbols',
 79 | 			''
 80 | 		);
 81 | 		$phpcsFile->process();
 82 | 		$messages = $helper->getWarningMessageRecords($phpcsFile->getWarnings());
 83 | 		$messages = array_values(array_filter($messages, function ($message) {
 84 | 			return $message->source === 'ImportDetection.Imports.RequireImports.Import';
 85 | 		}));
 86 | 		$lines = array_map(function ($message) {
 87 | 			return $message->rowNumber;
 88 | 		}, $messages);
 89 | 		$expectedLines = [
 90 | 			8,
 91 | 			9,
 92 | 		];
 93 | 		$this->assertEquals($expectedLines, $lines);
 94 | 	}
 95 | 
 96 | 	public function testRequireImportsSniffIgnoresWhitelistedUnimportedSymbols() {
 97 | 		$fixtureFile = __DIR__ . '/Fixtures/RequireImportsAllowedPatternFixture.php';
 98 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
 99 | 		$helper = new SniffTestHelper();
100 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
101 | 		$phpcsFile->ruleset->setSniffProperty(
102 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
103 | 			'ignoreUnimportedSymbols',
104 | 			'/^(something_to_ignore|whitelisted_function|allowed_funcs_\w+|another_[a-z_]+)$/'
105 | 		);
106 | 		$phpcsFile->process();
107 | 		$messages = $helper->getWarningMessageRecords($phpcsFile->getWarnings());
108 | 		$messages = array_values(array_filter($messages, function ($message) {
109 | 			return $message->source === 'ImportDetection.Imports.RequireImports.Symbol';
110 | 		}));
111 | 		$lines = array_map(function ($message) {
112 | 			return $message->rowNumber;
113 | 		}, $messages);
114 | 		$expectedLines = [
115 | 			16,
116 | 		];
117 | 		$this->assertEquals($expectedLines, $lines);
118 | 	}
119 | 
120 | 	public function testRequireImportsSniffIgnoresWhitelistedUnusedImports() {
121 | 		$fixtureFile = __DIR__ . '/Fixtures/RequireImportsAllowedPatternFixture.php';
122 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
123 | 		$helper = new SniffTestHelper();
124 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
125 | 		$phpcsFile->ruleset->setSniffProperty(
126 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
127 | 			'ignoreUnimportedSymbols',
128 | 			'/\\\unused_function|\\\four_function/'
129 | 		);
130 | 		$phpcsFile->process();
131 | 		$messages = $helper->getWarningMessageRecords($phpcsFile->getWarnings());
132 | 		$messages = array_values(array_filter($messages, function ($message) {
133 | 			return $message->source === 'ImportDetection.Imports.RequireImports.Import';
134 | 		}));
135 | 		$lines = array_map(function ($message) {
136 | 			return $message->rowNumber;
137 | 		}, $messages);
138 | 		$expectedLines = [];
139 | 		$this->assertEquals($expectedLines, $lines);
140 | 	}
141 | 
142 | 	public function testRequireImportsSniffFindsWordPressPatternsIfNotSet() {
143 | 		$fixtureFile = __DIR__ . '/Fixtures/WordPressFixture.php';
144 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
145 | 		$helper = new SniffTestHelper();
146 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
147 | 		$phpcsFile->ruleset->setSniffProperty(
148 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
149 | 			'ignoreWordPressSymbols',
150 | 			'false'
151 | 		);
152 | 		$phpcsFile->process();
153 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
154 | 		$expectedLines = [
155 | 			23,
156 | 			32,
157 | 			33,
158 | 			34,
159 | 			35,
160 | 			36,
161 | 			37,
162 | 			38,
163 | 			42,
164 | 			45,
165 | 			48,
166 | 			52,
167 | 			55,
168 | 			60,
169 | 			61,
170 | 			63,
171 | 			74,
172 | 			80,
173 | 		];
174 | 		$this->assertEquals($expectedLines, $lines);
175 | 	}
176 | 
177 | 	public function testRequireImportsSniffIgnoresWordPressPatternsIfSet() {
178 | 		$fixtureFile = __DIR__ . '/Fixtures/WordPressFixture.php';
179 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
180 | 		$helper = new SniffTestHelper();
181 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
182 | 		$phpcsFile->ruleset->setSniffProperty(
183 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
184 | 			'ignoreWordPressSymbols',
185 | 			'true'
186 | 		);
187 | 		$phpcsFile->process();
188 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
189 | 		$expectedLines = [ 38, 61, 63, 80 ];
190 | 		$this->assertEquals($expectedLines, $lines);
191 | 	}
192 | 
193 | 	public function testRequireImportsSniffDoesNotCountMethodNames() {
194 | 		$fixtureFile = __DIR__ . '/Fixtures/RequireImportsMethodNameFixture.php';
195 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
196 | 		$helper = new SniffTestHelper();
197 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
198 | 		$phpcsFile->process();
199 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
200 | 		$expectedLines = [ 11 ];
201 | 		$this->assertEquals($expectedLines, $lines);
202 | 	}
203 | 
204 | 	public function testRequireImportsSniffCountsTraitUseAsUsage() {
205 | 		$fixtureFile = __DIR__ . '/Fixtures/UsedTraitFixture.php';
206 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
207 | 		$helper = new SniffTestHelper();
208 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
209 | 		$phpcsFile->process();
210 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
211 | 		$expectedLines = [10];
212 | 		$this->assertEquals($expectedLines, $lines);
213 | 	}
214 | 
215 | 	public function testRequireImportsSniffWorksWithInterfaces() {
216 | 		$fixtureFile = __DIR__ . '/Fixtures/InterfaceFixture.php';
217 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
218 | 		$helper = new SniffTestHelper();
219 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
220 | 		$phpcsFile->process();
221 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
222 | 		$expectedLines = [31];
223 | 		$this->assertEquals($expectedLines, $lines);
224 | 	}
225 | 
226 | 	public function testRequireImportsSniffWorksWithTraits() {
227 | 		$fixtureFile = __DIR__ . '/Fixtures/TraitFixture.php';
228 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
229 | 		$helper = new SniffTestHelper();
230 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
231 | 		$phpcsFile->process();
232 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
233 | 		$expectedLines = [37];
234 | 		$this->assertEquals($expectedLines, $lines);
235 | 	}
236 | 
237 | 	public function testRequireImportsSniffFindsGlobalSymbolsIfNoConfig() {
238 | 		$fixtureFile = __DIR__ . '/Fixtures/GlobalNamespaceFixture.php';
239 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
240 | 		$helper = new SniffTestHelper();
241 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
242 | 		$phpcsFile->process();
243 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
244 | 		$expectedLines = [
245 | 			6,
246 | 			7,
247 | 			13,
248 | 			14,
249 | 			19,
250 | 		];
251 | 		$this->assertEquals($expectedLines, $lines);
252 | 	}
253 | 
254 | 	public function testRequireImportsSniffIgnoresGlobalSymbolsIfConfigured() {
255 | 		$fixtureFile = __DIR__ . '/Fixtures/GlobalNamespaceFixture.php';
256 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
257 | 		$helper = new SniffTestHelper();
258 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
259 | 		$phpcsFile->ruleset->setSniffProperty(
260 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
261 | 			'ignoreGlobalsWhenInGlobalScope',
262 | 			'true'
263 | 		);
264 | 		$phpcsFile->process();
265 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
266 | 		$expectedLines = [
267 | 			6,
268 | 			7,
269 | 			19,
270 | 		];
271 | 		$this->assertEquals($expectedLines, $lines);
272 | 	}
273 | 
274 | 	public function testRequireImportsSniffFindsGlobalSymbolsInNamespaceIfConfigured() {
275 | 		$fixtureFile = __DIR__ . '/Fixtures/RequireImportsAllowedPatternFixture.php';
276 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
277 | 		$helper = new SniffTestHelper();
278 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
279 | 		$phpcsFile->ruleset->setSniffProperty(
280 | 			'ImportDetection\Sniffs\Imports\RequireImportsSniff',
281 | 			'ignoreGlobalsWhenInGlobalScope',
282 | 			'true'
283 | 		);
284 | 		$phpcsFile->process();
285 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
286 | 		$expectedLines = [
287 | 			8,
288 | 			9,
289 | 			15,
290 | 			16,
291 | 		];
292 | 		$this->assertEquals($expectedLines, $lines);
293 | 	}
294 | 
295 | 	public function testRequireImportsDoesNotBleedToMultipleFiles() {
296 | 		$fixtureFile = __DIR__ . '/Fixtures/MultipleFilesFixtures';
297 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
298 | 		$helper = new SniffTestHelper();
299 | 		$phpcsFiles = $helper->prepareLocalFilesForSniffs($sniffFile, $fixtureFile);
300 | 		// Unclear why this works, but if I run this twice the first fixture file
301 | 		// gets all its warnings cleared (and the other fixture file has the same
302 | 		// warning twice).
303 | 		$helper->processFiles($phpcsFiles);
304 | 		$helper->processFiles($phpcsFiles);
305 | 		$linesByFile = $helper->getNoticesFromFiles($phpcsFiles, 'warning');
306 | 		$expectedLines = [
307 | 			// The runner runs 'MultipleFilesFixtures2' first.
308 | 			__DIR__ . '/Fixtures/MultipleFilesFixtures/MultipleFilesFixtures2.php' => [],
309 | 			__DIR__ . '/Fixtures/MultipleFilesFixtures/MultipleFilesFixtures1.php' => [5],
310 | 		];
311 | 		$this->assertEquals($expectedLines, $linesByFile);
312 | 	}
313 | 
314 | 	public function testRequireImportsFindsUnimportedNamespaceIdenticalToClass() {
315 | 		$fixtureFile = __DIR__ . '/Fixtures/ClassUsedAsNamespaceFixture.php';
316 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
317 | 		$helper = new SniffTestHelper();
318 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
319 | 		$phpcsFile->process();
320 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
321 | 		$expectedLines = [
322 | 			7,
323 | 		];
324 | 		$this->assertEquals($expectedLines, $lines);
325 | 	}
326 | 
327 | 	public function testRequireImportsNoticesUnusedClasses() {
328 | 		$fixtureFile = __DIR__ . '/Fixtures/ClassFixtures.php';
329 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
330 | 		$helper = new SniffTestHelper();
331 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
332 | 		$phpcsFile->process();
333 | 
334 | 		$warnings = $phpcsFile->getWarnings();
335 | 		$messages = $helper->getWarningMessageRecords($warnings);
336 | 		$messages = array_values(array_filter($messages, function ($message) {
337 | 			return $message->source === 'ImportDetection.Imports.RequireImports.Import';
338 | 		}));
339 | 		$lines = array_map(function ($message) {
340 | 			return $message->rowNumber;
341 | 		}, $messages);
342 | 		$expectedLines = [
343 | 			2,
344 | 			7,
345 | 			7,
346 | 		];
347 | 		$this->assertEquals($expectedLines, $lines);
348 | 		$this->assertCount(3, $messages);
349 | 		$this->assertEquals('Found unused symbol \'NamespaceName\C\D\'.', $messages[0]->message);
350 | 		$this->assertEquals('Found unused symbol \'NamespaceName\B\'.', $messages[1]->message);
351 | 		$this->assertEquals('Found unused symbol \'NamespaceName\I\J\'.', $messages[2]->message);
352 | 	}
353 | 
354 | 	public function testRequireImportsNoticesUnusedConstants() {
355 | 		$fixtureFile = __DIR__ . '/Fixtures/ConstantsFixure.php';
356 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
357 | 		$helper = new SniffTestHelper();
358 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
359 | 		$phpcsFile->process();
360 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
361 | 		$expectedLines = [
362 | 			3,
363 | 			12,
364 | 		];
365 | 		$this->assertEquals($expectedLines, $lines);
366 | 	}
367 | 
368 | 	public function testRequireImportsSniffTreatsFileImportAsUsedWhenUsed() {
369 | 		$fixtureFile = __DIR__ . '/Fixtures/FileKeywordFixture.php';
370 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
371 | 		$helper = new SniffTestHelper();
372 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
373 | 		$phpcsFile->process();
374 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
375 | 		$expectedLines = [];
376 | 		$this->assertEquals($expectedLines, $lines);
377 | 	}
378 | 
379 | 	public function testRequireImportsNoticesNestedFunctions() {
380 | 		$fixtureFile = __DIR__ . '/Fixtures/NestedFunctionsFixture.php';
381 | 		$sniffFile = __DIR__ . '/../../../ImportDetection/Sniffs/Imports/RequireImportsSniff.php';
382 | 		$helper = new SniffTestHelper();
383 | 		$phpcsFile = $helper->prepareLocalFileForSniffs($sniffFile, $fixtureFile);
384 | 		$phpcsFile->process();
385 | 		$lines = $helper->getWarningLineNumbersFromFile($phpcsFile);
386 | 		$expectedLines = [
387 | 			9,
388 | 			10,
389 | 			20,
390 | 			48,
391 | 			52,
392 | 			56,
393 | 		];
394 | 		$this->assertEquals($expectedLines, $lines);
395 | 	}
396 | }
397 | 


--------------------------------------------------------------------------------
/ImportDetection/Sniffs/Imports/RequireImportsSniff.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ImportDetection\Sniffs\Imports;
  4 | 
  5 | use ImportDetection\Symbol;
  6 | use ImportDetection\SniffHelpers;
  7 | use ImportDetection\FileSymbolRecord;
  8 | use ImportDetection\WordPressSymbols;
  9 | use PHP_CodeSniffer\Sniffs\Sniff;
 10 | use PHP_CodeSniffer\Files\File;
 11 | 
 12 | class RequireImportsSniff implements Sniff {
 13 | 	public $ignoreUnimportedSymbols = null;
 14 | 	public $ignoreGlobalsWhenInGlobalScope = false;
 15 | 	public $ignoreWordPressSymbols = null;
 16 | 
 17 | 	private $symbolRecordsByFile = [];
 18 | 
 19 | 	public function register() {
 20 | 		return [T_USE, T_STRING, T_RETURN_TYPE, T_WHITESPACE, T_NAMESPACE];
 21 | 	}
 22 | 
 23 | 	public function process(File $phpcsFile, $stackPtr) {
 24 | 		$helper = new SniffHelpers();
 25 | 		$tokens = $phpcsFile->getTokens();
 26 | 		$token = $tokens[$stackPtr];
 27 | 		// Keep one set of symbol records per file
 28 | 		$this->symbolRecordsByFile[$phpcsFile->path] = $this->symbolRecordsByFile[$phpcsFile->path] ?? new FileSymbolRecord;
 29 | 		if ($token['type'] === 'T_NAMESPACE') {
 30 | 			return $this->processNamespace($phpcsFile, $stackPtr);
 31 | 		}
 32 | 		if ($token['type'] === 'T_WHITESPACE') {
 33 | 			$this->debug('found whitespace');
 34 | 			return $this->processEndOfFile($phpcsFile, $stackPtr);
 35 | 		}
 36 | 		if ($token['type'] === 'T_USE') {
 37 | 			$this->debug('found import');
 38 | 			if (in_array($helper->getImportType($phpcsFile, $stackPtr), ['function', 'const', 'class'])) {
 39 | 				$this->recordImportedSymbols($phpcsFile, $stackPtr);
 40 | 			}
 41 | 			return $this->processUse($phpcsFile, $stackPtr);
 42 | 		}
 43 | 		$symbol = $helper->getFullSymbol($phpcsFile, $stackPtr);
 44 | 		// If the symbol has been seen before (if this is a duplicate), ignore it
 45 | 		if (in_array($symbol, $this->symbolRecordsByFile[$phpcsFile->path]->seenSymbols)) {
 46 | 			$this->debug('found duplicate symbol: ' . $symbol->getName());
 47 | 			return;
 48 | 		}
 49 | 		$this->symbolRecordsByFile[$phpcsFile->path]->seenSymbols[] = $symbol;
 50 | 		// If the symbol is in the ignore list, ignore it
 51 | 		if ($this->isSymbolIgnored($symbol)) {
 52 | 			$this->debug('found ignored symbol: ' . $symbol->getName());
 53 | 			$this->markSymbolUsed($phpcsFile, $symbol);
 54 | 			return;
 55 | 		}
 56 | 		// If the symbol is a fully-qualified namespace, ignore it
 57 | 		if ($symbol->isAbsoluteNamespace()) {
 58 | 			$this->debug('found absolute namespaced symbol: ' . $symbol->getName());
 59 | 			return;
 60 | 		}
 61 | 		// If this symbol is a definition, ignore it
 62 | 		if ($helper->isSymbolADefinition($phpcsFile, $symbol)) {
 63 | 			$this->debug('found definition symbol: ' . $symbol->getName());
 64 | 			return;
 65 | 		}
 66 | 		// If this symbol is a static reference or an object reference, ignore it
 67 | 		if ($helper->isStaticReference($phpcsFile, $stackPtr) || $helper->isObjectReference($phpcsFile, $stackPtr)) {
 68 | 			$this->debug('found static symbol: ' . $symbol->getName());
 69 | 			return;
 70 | 		}
 71 | 		// If this symbol is a namespace definition, ignore it
 72 | 		if ($helper->isWithinNamespaceStatement($phpcsFile, $symbol->getSymbolPosition())) {
 73 | 			$this->debug('found namespace definition symbol: ' . $symbol->getName());
 74 | 			return;
 75 | 		}
 76 | 		// If this symbol is an import, ignore it
 77 | 		if ($helper->isWithinImportStatement($phpcsFile, $symbol->getSymbolPosition())) {
 78 | 			$this->debug('found symbol inside an import: ' . $symbol->getName());
 79 | 			return;
 80 | 		}
 81 | 		// If the symbol's namespace is imported or defined, ignore it
 82 | 		// If the symbol has no namespace and is itself is imported or defined, ignore it
 83 | 		if ($this->isSymbolDefined($phpcsFile, $symbol)) {
 84 | 			$this->debug('found defined symbol: ' . $symbol->getName());
 85 | 			$this->markSymbolUsed($phpcsFile, $symbol);
 86 | 			return;
 87 | 		}
 88 | 		// If the symbol is predefined, ignore it
 89 | 		if ($helper->isPredefinedConstant($phpcsFile, $stackPtr) || $helper->isBuiltInFunction($phpcsFile, $stackPtr)) {
 90 | 			$this->debug('found predefined symbol: ' . $symbol->getName());
 91 | 			return;
 92 | 		}
 93 | 		// If this symbol is a predefined typehint, ignore it
 94 | 		if ($helper->isPredefinedTypehint($phpcsFile, $stackPtr)) {
 95 | 			$this->debug('found typehint symbol: ' . $symbol->getName());
 96 | 			return;
 97 | 		}
 98 | 		// If the symbol is global, we are in the global namespace, and
 99 | 		// configured to ignore global symbols in the global namespace,
100 | 		// ignore it
101 | 		if ($this->ignoreGlobalsWhenInGlobalScope && ! $symbol->isNamespaced() && ! $this->symbolRecordsByFile[$phpcsFile->path]->activeNamespace) {
102 | 			$this->debug('found global symbol in global namespace: ' . $symbol->getName());
103 | 			return;
104 | 		}
105 | 		$this->debug('found unimported symbol: ' . $symbol->getName());
106 | 		$error = "Found unimported symbol '{$symbol->getName()}'.";
107 | 		$phpcsFile->addWarning($error, $stackPtr, 'Symbol');
108 | 	}
109 | 
110 | 	private function debug(string $message) {
111 | 		if (! defined('PHP_CODESNIFFER_VERBOSITY')) {
112 | 			return;
113 | 		}
114 | 		if (PHP_CODESNIFFER_VERBOSITY > 3) {
115 | 			echo PHP_EOL . "RequireImportsSniff: DEBUG: $message" . PHP_EOL;
116 | 		}
117 | 	}
118 | 
119 | 	private function isSymbolIgnored(Symbol $symbol): bool {
120 | 		$ignorePattern = $this->getIgnoredSymbolPattern();
121 | 		$doesSymbolMatchIgnorePattern = $this->doesSymbolMatchPattern($symbol, $ignorePattern);
122 | 		if ($doesSymbolMatchIgnorePattern) {
123 | 			return true;
124 | 		}
125 | 
126 | 		$wordPressPatterns = $this->getIgnoredWordPressSymbolPatterns();
127 | 		$matchingWordPressPatterns = array_values(array_filter($wordPressPatterns, function (string $pattern) use ($symbol): bool {
128 | 			return $this->doesSymbolMatchPattern($symbol, "/{$pattern}/");
129 | 		}));
130 | 		return count($matchingWordPressPatterns) > 0;
131 | 	}
132 | 
133 | 	private function doesSymbolMatchPattern(Symbol $symbol, string $pattern): bool {
134 | 		$symbolName = $symbol->getName();
135 | 		if (empty($pattern)) {
136 | 			return false;
137 | 		}
138 | 		try {
139 | 			return (1 === preg_match($pattern, $symbolName));
140 | 		} catch (\Exception $err) {
141 | 			throw new \Exception("Invalid ignore pattern found: '{$pattern}'");
142 | 		}
143 | 	}
144 | 
145 | 	private function getIgnoredWordPressSymbolPatterns() {
146 | 		return empty($this->ignoreWordPressSymbols) ? [] : WordPressSymbols::getWordPressSymbolPatterns();
147 | 	}
148 | 
149 | 	private function getIgnoredSymbolPattern() {
150 | 		return $this->ignoreUnimportedSymbols ?? '';
151 | 	}
152 | 
153 | 	private function isSymbolDefined(File $phpcsFile, Symbol $symbol): bool {
154 | 		$namespace = $symbol->getTopLevelNamespace();
155 | 		// If the symbol's namespace is imported, ignore it
156 | 		if ($namespace) {
157 | 			return $this->isNamespaceImported($phpcsFile, $namespace);
158 | 		}
159 | 		// If the symbol has no namespace and is itself is imported or defined, ignore it
160 | 		return $this->isNamespaceImportedOrDefined($phpcsFile, $symbol);
161 | 	}
162 | 
163 | 	private function isNamespaceImported(File $phpcsFile, string $namespace): bool {
164 | 		return (
165 | 			$this->isClassImported($phpcsFile, $namespace)
166 | 			|| $this->isFunctionImported($phpcsFile, $namespace)
167 | 			|| $this->isConstImported($phpcsFile, $namespace)
168 | 		);
169 | 	}
170 | 
171 | 	private function isSymbolAFunctionCall(File $phpcsFile, Symbol $symbol): bool {
172 | 		$tokens = $phpcsFile->getTokens();
173 | 		$stackPtr = $symbol->getSymbolPosition();
174 | 		if (isset($tokens[$stackPtr + 1]) && $tokens[$stackPtr + 1]['type'] === 'T_OPEN_PARENTHESIS') {
175 | 			return true;
176 | 		}
177 | 		return false;
178 | 	}
179 | 
180 | 	private function isNamespaceImportedOrDefined(File $phpcsFile, Symbol $symbol): bool {
181 | 		$namespace = $symbol->getName();
182 | 		$conditions = $symbol->getSymbolConditions();
183 | 		return (
184 | 			$this->isClassImported($phpcsFile, $namespace)
185 | 			|| $this->isClassDefined($phpcsFile, $namespace)
186 | 			|| $this->isFunctionImported($phpcsFile, $namespace)
187 | 			|| $this->isFunctionDefined($phpcsFile, $symbol, $namespace, $conditions)
188 | 			|| $this->isConstImported($phpcsFile, $namespace)
189 | 			|| $this->isConstDefined($phpcsFile, $namespace)
190 | 		);
191 | 	}
192 | 
193 | 	private function processUse(File $phpcsFile, $stackPtr) {
194 | 		$helper = new SniffHelpers();
195 | 		$importType = $helper->getImportType($phpcsFile, $stackPtr);
196 | 		switch ($importType) {
197 | 			case 'function':
198 | 				return $this->saveFunctionImport($phpcsFile, $stackPtr);
199 | 			case 'const':
200 | 				return $this->saveConstImport($phpcsFile, $stackPtr);
201 | 			case 'class':
202 | 				return $this->saveClassImport($phpcsFile, $stackPtr);
203 | 		}
204 | 	}
205 | 
206 | 	private function recordImportedSymbols(File $phpcsFile, int $stackPtr) {
207 | 		$helper = new SniffHelpers();
208 | 		$symbols = $helper->getImportedSymbolsFromImportStatement($phpcsFile, $stackPtr);
209 | 		$this->debug('recording imported symbols: ' . implode(', ', array_map(function (Symbol $symbol): string {
210 | 			return $symbol->getName();
211 | 		}, $symbols)));
212 | 		$symbols = array_map(function ($symbol) {
213 | 			if ($this->isSymbolIgnored($symbol)) {
214 | 				$this->debug('found ignored imported symbol: ' . $symbol->getName());
215 | 				$symbol->markUsed();
216 | 			}
217 | 			return $symbol;
218 | 		}, $symbols);
219 | 		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedSymbolRecords($symbols);
220 | 	}
221 | 
222 | 	private function saveFunctionImport(File $phpcsFile, $stackPtr) {
223 | 		$helper = new SniffHelpers();
224 | 		$importNames = $helper->getImportNames($phpcsFile, $stackPtr);
225 | 		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedFunctions($importNames);
226 | 	}
227 | 
228 | 	private function saveConstImport(File $phpcsFile, $stackPtr) {
229 | 		$helper = new SniffHelpers();
230 | 		$importNames = $helper->getImportNames($phpcsFile, $stackPtr);
231 | 		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedConsts($importNames);
232 | 	}
233 | 
234 | 	private function saveClassImport(File $phpcsFile, $stackPtr) {
235 | 		$helper = new SniffHelpers();
236 | 		$importNames = $helper->getImportNames($phpcsFile, $stackPtr);
237 | 		$this->symbolRecordsByFile[$phpcsFile->path]->addImportedClasses($importNames);
238 | 	}
239 | 
240 | 	private function isFunctionImported(File $phpcsFile, string $functionName): bool {
241 | 		return in_array($functionName, $this->symbolRecordsByFile[$phpcsFile->path]->importedFunctions);
242 | 	}
243 | 
244 | 	private function isConstImported(File $phpcsFile, string $constName): bool {
245 | 		return in_array($constName, $this->symbolRecordsByFile[$phpcsFile->path]->importedConsts);
246 | 	}
247 | 
248 | 	private function isClassImported(File $phpcsFile, string $name): bool {
249 | 		return in_array($name, $this->symbolRecordsByFile[$phpcsFile->path]->importedClasses);
250 | 	}
251 | 
252 | 	private function isClassDefined(File $phpcsFile, string $className): bool {
253 | 		$classPtr = $phpcsFile->findNext([T_CLASS, T_INTERFACE, T_TRAIT], 0);
254 | 		while ($classPtr) {
255 | 			$thisClassName = $phpcsFile->getDeclarationName($classPtr);
256 | 			if ($className === $thisClassName) {
257 | 				return true;
258 | 			}
259 | 			$classPtr = $phpcsFile->findNext([T_CLASS, T_INTERFACE, T_TRAIT], $classPtr + 1);
260 | 		}
261 | 		return false;
262 | 	}
263 | 
264 | 	private function isFunctionDefined(File $phpcsFile, Symbol $symbol, string $functionName, array $conditions): bool {
265 | 		$tokens = $phpcsFile->getTokens();
266 | 
267 | 		if (! $this->isSymbolAFunctionCall($phpcsFile, $symbol)) {
268 | 			return false;
269 | 		}
270 | 
271 | 		$scopesToEnter = array_filter(array_keys($conditions), function ($conditionPtr) use ($conditions) {
272 | 			return $conditions[$conditionPtr] === T_FUNCTION;
273 | 		});
274 | 		$this->debug("looking for definition for function {$functionName}");
275 | 		$this->debug("my conditions are " . json_encode($conditions));
276 | 		$this->debug("scopes to enter " . implode(',', $scopesToEnter));
277 | 
278 | 		// Only look at the inner-most scope and global scope
279 | 		$scopesToEnter = [end($scopesToEnter), 0];
280 | 
281 | 		foreach ($scopesToEnter as $scopeStart) {
282 | 			$functionToken = $tokens[$scopeStart];
283 | 			$scopeEnd = $functionToken['scope_closer'] ?? null;
284 | 
285 | 			// Within each function scope, find all the function definitions and
286 | 			// compare their names to the name we are looking for.
287 | 			$functionDefinitionsInScope = $this->findAllFunctionDefinitionsInScope($phpcsFile, $scopeStart, $scopeEnd);
288 | 
289 | 			foreach ($functionDefinitionsInScope as $thisFunctionName) {
290 | 				$this->debug("is this function the one we want? " . $thisFunctionName);
291 | 				if ($functionName === $thisFunctionName) {
292 | 					$this->debug("yes indeed");
293 | 					return true;
294 | 				}
295 | 			}
296 | 		}
297 | 		return false;
298 | 	}
299 | 
300 | 	/**
301 | 	 * Return an array of function names defined in a scope
302 | 	 */
303 | 	private function findAllFunctionDefinitionsInScope(File $phpcsFile, int $scopeStart, int $scopeEnd = null): array {
304 | 		$this->debug("looking for functions defined between {$scopeStart} and {$scopeEnd}");
305 | 		$tokens = $phpcsFile->getTokens();
306 | 		$functionNames = [];
307 | 
308 | 		$tokensToInvestigate = [T_FUNCTION, T_CLASS, T_TRAIT, T_INTERFACE];
309 | 
310 | 		// Skip the function we are in, but not the global scope
311 | 		$functionToken = $tokens[$scopeStart];
312 | 		$scopeOffset = $functionToken['type'] === 'T_FUNCTION' ? 2 : 0;
313 | 		$functionPtr = $phpcsFile->findNext($tokensToInvestigate, $scopeStart + $scopeOffset, $scopeEnd);
314 | 
315 | 		while ($functionPtr) {
316 | 			$functionName = $phpcsFile->getDeclarationName($functionPtr);
317 | 			$functionToken = $tokens[$functionPtr];
318 | 			$thisFunctionScopeEnd = $functionToken['scope_closer'] ?? 0;
319 | 
320 | 			// Skip things other than IF that have their own scope
321 | 			if ($functionToken['type'] !== 'T_FUNCTION') {
322 | 				if (! $thisFunctionScopeEnd) {
323 | 					$this->debug("function at {$functionPtr} has no end:" . $functionName);
324 | 					break;
325 | 				}
326 | 				$functionPtr = $phpcsFile->findNext($tokensToInvestigate, $thisFunctionScopeEnd, $scopeEnd);
327 | 				continue;
328 | 			}
329 | 
330 | 			$this->debug("found function at {$functionPtr}:" . $functionName);
331 | 			$functionNames[] = $functionName;
332 | 			$functionPtr = $phpcsFile->findNext($tokensToInvestigate, $thisFunctionScopeEnd, $scopeEnd);
333 | 		}
334 | 		return $functionNames;
335 | 	}
336 | 
337 | 	private function isConstDefined(File $phpcsFile, string $functionName): bool {
338 | 		$helper = new SniffHelpers();
339 | 		$functionPtr = $phpcsFile->findNext([T_CONST], 0);
340 | 		while ($functionPtr) {
341 | 			$thisFunctionName = $helper->getConstantName($phpcsFile, $functionPtr);
342 | 			if ($functionName === $thisFunctionName) {
343 | 				return true;
344 | 			}
345 | 			$functionPtr = $phpcsFile->findNext([T_CONST], $functionPtr + 1);
346 | 		}
347 | 		return false;
348 | 	}
349 | 
350 | 	private function markSymbolUsed(File $phpcsFile, Symbol $symbol) {
351 | 		$record = $this->getRecordedImportedSymbolMatchingSymbol($phpcsFile, $symbol);
352 | 		if (! $record) {
353 | 			// Symbol records only exist for imported symbols, so if a used symbol
354 | 			// has not been imported we don't need to mark anything.
355 | 			$this->debug("ignoring marking symbol used since it was never imported: {$symbol->getName()}");
356 | 			return;
357 | 		}
358 | 		$record->markUsed();
359 | 	}
360 | 
361 | 	private function getRecordedImportedSymbolMatchingSymbol(File $phpcsFile, Symbol $symbol) {
362 | 		foreach ($this->symbolRecordsByFile[$phpcsFile->path]->importedSymbolRecords as $record) {
363 | 			$namespaceOrAlias = $symbol->getTopLevelNamespace() ?? $symbol->getAlias();
364 | 			$this->debug("comparing symbol {$namespaceOrAlias} to alias {$record->getAlias()}");
365 | 			if ($record->getAlias() === $namespaceOrAlias) {
366 | 				return $record;
367 | 			}
368 | 		}
369 | 		return null;
370 | 	}
371 | 
372 | 	private function processEndOfFile(File $phpcsFile, int $stackPtr) {
373 | 		$tokens = $phpcsFile->getTokens();
374 | 		// If this is not the end of the file, ignore it
375 | 		if (isset($tokens[$stackPtr + 1])) {
376 | 			return;
377 | 		}
378 | 		// For each import, if the Symbol was not used, mark a warning
379 | 		foreach ($this->symbolRecordsByFile[$phpcsFile->path]->importedSymbolRecords as $record) {
380 | 			if (! $record->isUsed()) {
381 | 				$this->debug("found unused symbol: {$record->getName()}");
382 | 				$error = "Found unused symbol '{$record->getName()}'.";
383 | 				$phpcsFile->addWarning($error, $record->getSymbolPosition(), 'Import');
384 | 			}
385 | 		}
386 | 	}
387 | 
388 | 	private function processNamespace(File $phpcsFile, int $stackPtr) {
389 | 		$helper = new SniffHelpers();
390 | 		$symbols = $helper->getImportedSymbolsFromImportStatement($phpcsFile, $stackPtr);
391 | 		if (count($symbols) < 1) {
392 | 			return;
393 | 		}
394 | 		if (count($symbols) > 1) {
395 | 			throw new \Exception('Found more than one namespace: ' . var_export($symbols, true));
396 | 		}
397 | 		$this->debug('we are in the namespace: ' . $symbols[0]->getName());
398 | 		$this->symbolRecordsByFile[$phpcsFile->path]->activeNamespace = $symbols[0];
399 | 	}
400 | }
401 | 


--------------------------------------------------------------------------------
/ImportDetection/WordPressSymbols.php:
--------------------------------------------------------------------------------
   1 | <?php
   2 | declare(strict_types=1);
   3 | 
   4 | namespace ImportDetection;
   5 | 
   6 | class WordPressSymbols {
   7 | 	public static function getWordPressSymbolPatterns(): array {
   8 | 		$strings = array_merge(
   9 | 			[],
  10 | 			self::getWordPressFunctions(),
  11 | 			self::getWordPressConstants()
  12 | 		);
  13 | 		return array_map(function (string $functionName): string {
  14 | 			return "^{$functionName}$";
  15 | 		}, $strings);
  16 | 	}
  17 | 
  18 | 	private static function getWordPressFunctions(): array {
  19 | 		// From: http://api.wpseek.com/?method=wordpress.getfunctions&output=plain
  20 | 		$allFunctions = <<< ENDPATTERNS
  21 | _
  22 | __
  23 | __autoload
  24 | __checked_selected_helper
  25 | __clear_multi_author_cache
  26 | __get_option
  27 | __ngettext
  28 | __ngettext_noop
  29 | __return_empty_array
  30 | __return_empty_string
  31 | __return_false
  32 | __return_null
  33 | __return_true
  34 | __return_zero
  35 | _access_denied_splash
  36 | _add_post_type_submenus
  37 | _add_themes_utility_last
  38 | _admin_bar_bump_cb
  39 | _admin_notice_post_locked
  40 | _admin_search_query
  41 | _ajax_wp_die_handler
  42 | _autop_newline_preservation_helper
  43 | _c
  44 | _canonical_charset
  45 | _cleanup_header_comment
  46 | _cleanup_image_add_caption
  47 | _clear_modified_cache_on_transition_comment_status
  48 | _close_comments_for_old_post
  49 | _close_comments_for_old_posts
  50 | _config_wp_home
  51 | _config_wp_siteurl
  52 | _convert_urlencoded_to_entities
  53 | _copy_dir
  54 | _copy_image_file
  55 | _count_posts_cache_key
  56 | _crop_image_resource
  57 | _custom_background_cb
  58 | _custom_header_background_just_in_time
  59 | _custom_logo_header_styles
  60 | _deep_replace
  61 | _default_wp_die_handler
  62 | _delete_attachment_theme_mod
  63 | _delete_option_fresh_site
  64 | _deprecated_argument
  65 | _deprecated_constructor
  66 | _deprecated_file
  67 | _deprecated_function
  68 | _deprecated_hook
  69 | _device_can_upload
  70 | _doing_it_wrong
  71 | _draft_or_post_title
  72 | _e
  73 | _ex
  74 | _fetch_remote_file
  75 | _filter_query_attachment_filenames
  76 | _find_post_by_old_date
  77 | _find_post_by_old_slug
  78 | _fix_attachment_links
  79 | _flip_image_resource
  80 | _future_post_hook
  81 | _get_additional_user_keys
  82 | _get_admin_bar_pref
  83 | _get_component_from_parsed_url_array
  84 | _get_cron_array
  85 | _get_cron_lock
  86 | _get_custom_object_labels
  87 | _get_dropins
  88 | _get_last_post_time
  89 | _get_list_table
  90 | _get_meta_table
  91 | _get_non_cached_ids
  92 | _get_page_link
  93 | _get_path_to_translation
  94 | _get_path_to_translation_from_lang_dir
  95 | _get_plugin_data_markup_translate
  96 | _get_post_ancestors
  97 | _get_random_header_data
  98 | _get_template_edit_filename
  99 | _get_term_children
 100 | _get_term_hierarchy
 101 | _get_widget_id_base
 102 | _get_wptexturize_shortcode_regex
 103 | _get_wptexturize_split_regex
 104 | _hash_hmac
 105 | _http_build_query
 106 | _image_get_preview_ratio
 107 | _insert_into_post_button
 108 | _ipad_meta
 109 | _is_valid_nav_menu_item
 110 | _json_decode_object_helper
 111 | _links_add_base
 112 | _links_add_target
 113 | _list_meta_row
 114 | _load_image_to_edit_path
 115 | _load_textdomain_just_in_time
 116 | _local_storage_notice
 117 | _make_cat_compat
 118 | _make_email_clickable_cb
 119 | _make_url_clickable_cb
 120 | _make_web_ftp_clickable_cb
 121 | _maybe_update_core
 122 | _maybe_update_plugins
 123 | _maybe_update_themes
 124 | _mb_strlen
 125 | _mb_substr
 126 | _mce_set_direction
 127 | _media_button
 128 | _media_states
 129 | _n
 130 | _n_noop
 131 | _nav_menu_item_id_use_once
 132 | _navigation_markup
 133 | _nc
 134 | _nx
 135 | _nx_noop
 136 | _oembed_create_xml
 137 | _oembed_filter_feed_content
 138 | _oembed_rest_pre_serve_request
 139 | _pad_term_counts
 140 | _page_traverse_name
 141 | _post_format_get_term
 142 | _post_format_get_terms
 143 | _post_format_link
 144 | _post_format_request
 145 | _post_format_wp_get_object_terms
 146 | _post_states
 147 | _post_type_meta_capabilities
 148 | _preview_theme_stylesheet_filter
 149 | _preview_theme_template_filter
 150 | _prime_comment_caches
 151 | _prime_network_caches
 152 | _prime_post_caches
 153 | _prime_site_caches
 154 | _prime_term_caches
 155 | _print_emoji_detection_script
 156 | _print_scripts
 157 | _print_styles
 158 | _publish_post_hook
 159 | _redirect_to_about_wordpress
 160 | _register_widget_form_callback
 161 | _register_widget_update_callback
 162 | _relocate_children
 163 | _remove_qs_args_if_not_in_url
 164 | _remove_theme_support
 165 | _reset_front_page_settings_for_post
 166 | _response_to_rss
 167 | _rotate_image_resource
 168 | _sanitize_text_fields
 169 | _save_post_hook
 170 | _scalar_wp_die_handler
 171 | _search_terms_tidy
 172 | _set_cron_array
 173 | _set_preview
 174 | _show_post_preview
 175 | _sort_name_callback
 176 | _sort_nav_menu_items
 177 | _sort_uname_callback
 178 | _split_shared_term
 179 | _split_str_by_whitespace
 180 | _thickbox_path_admin_subfolder
 181 | _transition_post_status
 182 | _truncate_post_slug
 183 | _unzip_file_pclzip
 184 | _unzip_file_ziparchive
 185 | _update_blog_date_on_post_delete
 186 | _update_blog_date_on_post_publish
 187 | _update_generic_term_count
 188 | _update_post_term_count
 189 | _update_posts_count_on_delete
 190 | _update_posts_count_on_transition_post_status
 191 | _update_term_count_on_transition_post_status
 192 | _usort_by_first_member
 193 | _usort_terms_by_id
 194 | _usort_terms_by_name
 195 | _walk_bookmarks
 196 | _wp_add_global_attributes
 197 | _wp_admin_bar_init
 198 | _wp_admin_html_begin
 199 | _wp_ajax_add_hierarchical_term
 200 | _wp_ajax_delete_comment_response
 201 | _wp_ajax_menu_quick_search
 202 | _wp_auto_add_pages_to_menu
 203 | _wp_batch_split_terms
 204 | _wp_call_all_hook
 205 | _wp_can_use_pcre_u
 206 | _wp_check_for_scheduled_split_terms
 207 | _wp_check_split_default_terms
 208 | _wp_check_split_nav_menu_terms
 209 | _wp_check_split_terms_in_menus
 210 | _wp_credits_add_profile_link
 211 | _wp_credits_build_object_link
 212 | _wp_customize_changeset_filter_insert_post_data
 213 | _wp_customize_include
 214 | _wp_customize_loader_settings
 215 | _wp_customize_publish_changeset
 216 | _wp_dashboard_control_callback
 217 | _wp_dashboard_recent_comments_row
 218 | _wp_delete_customize_changeset_dependent_auto_drafts
 219 | _wp_delete_orphaned_draft_menu_items
 220 | _wp_delete_post_menu_item
 221 | _wp_delete_tax_menu_item
 222 | _wp_emoji_list
 223 | _wp_expand_nav_menu_post_data
 224 | _wp_filter_build_unique_id
 225 | _wp_filter_taxonomy_base
 226 | _wp_footer_scripts
 227 | _wp_get_attachment_relative_path
 228 | _wp_get_current_user
 229 | _wp_get_image_size_from_meta
 230 | _wp_get_post_revision_version
 231 | _wp_get_user_contactmethods
 232 | _wp_handle_upload
 233 | _wp_http_get_object
 234 | _wp_image_editor_choose
 235 | _wp_iso_convert
 236 | _wp_json_convert_string
 237 | _wp_json_prepare_data
 238 | _wp_json_sanity_check
 239 | _wp_keep_alive_customize_changeset_dependent_auto_drafts
 240 | _wp_kses_decode_entities_chr
 241 | _wp_kses_decode_entities_chr_hexdec
 242 | _wp_kses_split_callback
 243 | _wp_link_page
 244 | _wp_menu_item_classes_by_context
 245 | _wp_menu_output
 246 | _wp_menus_changed
 247 | _wp_mysql_week
 248 | _wp_nav_menu_meta_box_object
 249 | _wp_object_count_sort_cb
 250 | _wp_object_name_sort_cb
 251 | _wp_oembed_get_object
 252 | _wp_personal_data_cleanup_requests
 253 | _wp_personal_data_export_page
 254 | _wp_personal_data_handle_actions
 255 | _wp_personal_data_removal_page
 256 | _wp_post_revision_data
 257 | _wp_post_revision_fields
 258 | _wp_post_thumbnail_class_filter
 259 | _wp_post_thumbnail_class_filter_add
 260 | _wp_post_thumbnail_class_filter_remove
 261 | _wp_post_thumbnail_html
 262 | _wp_posts_page_notice
 263 | _wp_preview_post_thumbnail_filter
 264 | _wp_preview_terms_filter
 265 | _wp_privacy_account_request_confirmed
 266 | _wp_privacy_account_request_confirmed_message
 267 | _wp_privacy_action_request_types
 268 | _wp_privacy_completed_request
 269 | _wp_privacy_hook_requests_page
 270 | _wp_privacy_requests_screen_options
 271 | _wp_privacy_resend_request
 272 | _wp_privacy_send_erasure_fulfillment_notification
 273 | _wp_privacy_send_request_confirmation_notification
 274 | _wp_privacy_settings_filter_draft_page_titles
 275 | _wp_privacy_statuses
 276 | _wp_put_post_revision
 277 | _wp_register_meta_args_whitelist
 278 | _wp_relative_upload_path
 279 | _wp_remove_unregistered_widgets
 280 | _wp_render_title_tag
 281 | _wp_sanitize_utf8_in_redirect
 282 | _wp_scripts_maybe_doing_it_wrong
 283 | _wp_sidebars_changed
 284 | _wp_specialchars
 285 | _wp_timezone_choice_usort_callback
 286 | _wp_translate_php_url_constant_to_key
 287 | _wp_translate_postdata
 288 | _wp_upgrade_revisions_of_post
 289 | _wp_upload_dir
 290 | _wptexturize_pushpop_element
 291 | _x
 292 | _xmlrpc_wp_die_handler
 293 | absint
 294 | activate_plugin
 295 | activate_plugins
 296 | activate_sitewide_plugin
 297 | add_action
 298 | add_blog_option
 299 | add_clean_index
 300 | add_comment_meta
 301 | add_comments_page
 302 | add_contextual_help
 303 | add_cssclass
 304 | add_custom_background
 305 | add_custom_image_header
 306 | add_dashboard_page
 307 | add_editor_style
 308 | add_existing_user_to_blog
 309 | add_feed
 310 | add_filter
 311 | add_image_size
 312 | add_link
 313 | add_links_page
 314 | add_magic_quotes
 315 | add_management_page
 316 | add_media_page
 317 | add_menu_classes
 318 | add_menu_page
 319 | add_meta
 320 | add_meta_box
 321 | add_metadata
 322 | add_network_option
 323 | add_new_user_to_blog
 324 | add_object_page
 325 | add_option
 326 | add_option_update_handler
 327 | add_option_whitelist
 328 | add_options_page
 329 | add_pages_page
 330 | add_permastruct
 331 | add_ping
 332 | add_plugins_page
 333 | add_post_meta
 334 | add_post_type_support
 335 | add_posts_page
 336 | add_query_arg
 337 | add_rewrite_endpoint
 338 | add_rewrite_rule
 339 | add_rewrite_tag
 340 | add_role
 341 | add_screen_option
 342 | add_settings_error
 343 | add_settings_field
 344 | add_settings_section
 345 | add_shortcode
 346 | add_site_meta
 347 | add_site_option
 348 | add_submenu_page
 349 | add_term_meta
 350 | add_theme_page
 351 | add_theme_support
 352 | add_thickbox
 353 | add_user
 354 | add_user_meta
 355 | add_user_to_blog
 356 | add_users_page
 357 | add_utility_page
 358 | addslashes_gpc
 359 | adjacent_image_link
 360 | adjacent_post_link
 361 | adjacent_posts_rel_link
 362 | adjacent_posts_rel_link_wp_head
 363 | admin_color_scheme_picker
 364 | admin_created_user_email
 365 | admin_url
 366 | allow_subdirectory_install
 367 | allow_subdomain_install
 368 | allowed_http_request_hosts
 369 | allowed_tags
 370 | antispambot
 371 | apache_mod_loaded
 372 | apply_filters
 373 | apply_filters_deprecated
 374 | apply_filters_ref_array
 375 | array_replace_recursive
 376 | atom_enclosure
 377 | atom_site_icon
 378 | attachment_id3_data_meta_box
 379 | attachment_submit_meta_box
 380 | attachment_submitbox_metadata
 381 | attachment_url_to_postid
 382 | attribute_escape
 383 | auth_redirect
 384 | author_can
 385 | automatic_feed_links
 386 | avoid_blog_page_permalink_collision
 387 | background_color
 388 | background_image
 389 | backslashit
 390 | balancetags
 391 | before_last_bar
 392 | bloginfo
 393 | bloginfo_rss
 394 | body_class
 395 | bool_from_yn
 396 | build_query
 397 | bulk_edit_posts
 398 | cache_javascript_headers
 399 | cache_users
 400 | calendar_week_mod
 401 | can_edit_network
 402 | cancel_comment_reply_link
 403 | capital_p_dangit
 404 | cat_is_ancestor_of
 405 | category_description
 406 | category_exists
 407 | check_admin_referer
 408 | check_ajax_referer
 409 | check_and_publish_future_post
 410 | check_column
 411 | check_comment
 412 | check_comment_flood_db
 413 | check_import_new_users
 414 | check_password_reset_key
 415 | check_theme_switched
 416 | check_upload_mimes
 417 | check_upload_size
 418 | checked
 419 | choose_primary_blog
 420 | clean_attachment_cache
 421 | clean_blog_cache
 422 | clean_bookmark_cache
 423 | clean_category_cache
 424 | clean_comment_cache
 425 | clean_network_cache
 426 | clean_object_term_cache
 427 | clean_page_cache
 428 | clean_post_cache
 429 | clean_pre
 430 | clean_site_details_cache
 431 | clean_taxonomy_cache
 432 | clean_term_cache
 433 | clean_url
 434 | clean_user_cache
 435 | clear_global_post_cache
 436 | codepress_footer_js
 437 | codepress_get_lang
 438 | comment_author
 439 | comment_author_email
 440 | comment_author_email_link
 441 | comment_author_ip
 442 | comment_author_link
 443 | comment_author_rss
 444 | comment_author_url
 445 | comment_author_url_link
 446 | comment_class
 447 | comment_date
 448 | comment_excerpt
 449 | comment_exists
 450 | comment_footer_die
 451 | comment_form
 452 | comment_form_title
 453 | comment_guid
 454 | comment_id
 455 | comment_id_fields
 456 | comment_link
 457 | comment_reply_link
 458 | comment_text
 459 | comment_text_rss
 460 | comment_time
 461 | comment_type
 462 | comments_link
 463 | comments_link_feed
 464 | comments_number
 465 | comments_open
 466 | comments_popup_link
 467 | comments_popup_script
 468 | comments_rss
 469 | comments_rss_link
 470 | comments_template
 471 | compression_test
 472 | confirm_another_blog_signup
 473 | confirm_blog_signup
 474 | confirm_delete_users
 475 | confirm_user_signup
 476 | content_url
 477 | convert_chars
 478 | convert_invalid_entities
 479 | convert_smilies
 480 | convert_to_screen
 481 | copy_dir
 482 | core_update_footer
 483 | core_upgrade_preamble
 484 | count_many_users_posts
 485 | count_user_posts
 486 | count_users
 487 | create_empty_blog
 488 | create_initial_post_types
 489 | create_initial_rest_routes
 490 | create_initial_taxonomies
 491 | create_user
 492 | current_action
 493 | current_filter
 494 | current_theme_info
 495 | current_theme_supports
 496 | current_time
 497 | current_user_can
 498 | current_user_can_for_blog
 499 | customize_themes_print_templates
 500 | dashboard_browser_nag_class
 501 | dashboard_php_nag_class
 502 | date_i18n
 503 | dbdelta
 504 | deactivate_plugins
 505 | deactivate_sitewide_plugin
 506 | dead_db
 507 | debug_fclose
 508 | debug_fopen
 509 | debug_fwrite
 510 | default_password_nag
 511 | default_password_nag_edit_user
 512 | default_password_nag_handler
 513 | default_topic_count_scale
 514 | default_topic_count_text
 515 | delete_all_user_settings
 516 | delete_blog_option
 517 | delete_comment_meta
 518 | delete_expired_transients
 519 | delete_get_calendar_cache
 520 | delete_meta
 521 | delete_metadata
 522 | delete_metadata_by_mid
 523 | delete_network_option
 524 | delete_option
 525 | delete_plugins
 526 | delete_post_meta
 527 | delete_post_meta_by_key
 528 | delete_post_thumbnail
 529 | delete_site_meta
 530 | delete_site_meta_by_key
 531 | delete_site_option
 532 | delete_site_transient
 533 | delete_term_meta
 534 | delete_theme
 535 | delete_transient
 536 | delete_user_meta
 537 | delete_user_option
 538 | delete_user_setting
 539 | delete_usermeta
 540 | delete_users_add_js
 541 | deslash
 542 | did_action
 543 | disabled
 544 | discover_pingback_server_uri
 545 | dismiss_core_update
 546 | dismissed_updates
 547 | display_header
 548 | display_header_text
 549 | display_plugins_table
 550 | display_setup_form
 551 | display_space_usage
 552 | display_theme
 553 | display_themes
 554 | do_accordion_sections
 555 | do_action
 556 | do_action_deprecated
 557 | do_action_ref_array
 558 | do_activate_header
 559 | do_all_pings
 560 | do_core_upgrade
 561 | do_dismiss_core_update
 562 | do_enclose
 563 | do_feed
 564 | do_feed_atom
 565 | do_feed_rdf
 566 | do_feed_rss
 567 | do_feed_rss2
 568 | do_meta_boxes
 569 | do_robots
 570 | do_settings_fields
 571 | do_settings_sections
 572 | do_shortcode
 573 | do_shortcode_tag
 574 | do_shortcodes_in_html_tags
 575 | do_signup_header
 576 | do_trackbacks
 577 | do_undismiss_core_update
 578 | documentation_link
 579 | doing_action
 580 | doing_filter
 581 | domain_exists
 582 | download_url
 583 | drop_index
 584 | dropdown_categories
 585 | dropdown_cats
 586 | dropdown_link_categories
 587 | dynamic_sidebar
 588 | edit_bookmark_link
 589 | edit_comment
 590 | edit_comment_link
 591 | edit_form_image_editor
 592 | edit_link
 593 | edit_post
 594 | edit_post_link
 595 | edit_tag_link
 596 | edit_term_link
 597 | edit_user
 598 | email_exists
 599 | endelement
 600 | enqueue_comment_hotkeys_js
 601 | enqueue_embed_scripts
 602 | ent2ncr
 603 | esc_attr
 604 | esc_attr__
 605 | esc_attr_e
 606 | esc_attr_x
 607 | esc_html
 608 | esc_html__
 609 | esc_html_e
 610 | esc_html_x
 611 | esc_js
 612 | esc_sql
 613 | esc_textarea
 614 | esc_url
 615 | esc_url_raw
 616 | export_add_js
 617 | export_date_options
 618 | export_wp
 619 | extract_from_markers
 620 | favorite_actions
 621 | feed_content_type
 622 | feed_links
 623 | feed_links_extra
 624 | fetch_feed
 625 | fetch_rss
 626 | file_is_displayable_image
 627 | file_is_valid_image
 628 | filter_default_option
 629 | filter_ssl
 630 | find_core_auto_update
 631 | find_core_update
 632 | find_posts_div
 633 | fix_import_form_size
 634 | fix_phpmailer_messageid
 635 | floated_admin_avatar
 636 | flush_rewrite_rules
 637 | force_balance_tags
 638 | force_ssl_admin
 639 | force_ssl_content
 640 | force_ssl_login
 641 | form_option
 642 | format_code_lang
 643 | format_for_editor
 644 | format_to_edit
 645 | format_to_post
 646 | funky_javascript_callback
 647 | funky_javascript_fix
 648 | gallery_shortcode
 649 | gd_edit_image_support
 650 | generate_random_password
 651 | generic_ping
 652 | get_404_template
 653 | get_active_blog_for_user
 654 | get_adjacent_post
 655 | get_adjacent_post_link
 656 | get_adjacent_post_rel_link
 657 | get_admin_page_parent
 658 | get_admin_page_title
 659 | get_admin_url
 660 | get_admin_users_for_domain
 661 | get_all_category_ids
 662 | get_all_page_ids
 663 | get_all_post_type_supports
 664 | get_all_user_settings
 665 | get_alloptions
 666 | get_alloptions_110
 667 | get_allowed_http_origins
 668 | get_allowed_mime_types
 669 | get_allowed_themes
 670 | get_ancestors
 671 | get_approved_comments
 672 | get_archive_template
 673 | get_archives
 674 | get_archives_link
 675 | get_attached_file
 676 | get_attached_media
 677 | get_attachment_fields_to_edit
 678 | get_attachment_icon
 679 | get_attachment_icon_src
 680 | get_attachment_innerhtml
 681 | get_attachment_link
 682 | get_attachment_taxonomies
 683 | get_attachment_template
 684 | get_author_feed_link
 685 | get_author_link
 686 | get_author_name
 687 | get_author_posts_url
 688 | get_author_rss_link
 689 | get_author_template
 690 | get_author_user_ids
 691 | get_autotoggle
 692 | get_available_languages
 693 | get_available_post_mime_types
 694 | get_available_post_statuses
 695 | get_avatar
 696 | get_avatar_data
 697 | get_avatar_url
 698 | get_background_color
 699 | get_background_image
 700 | get_blog_count
 701 | get_blog_details
 702 | get_blog_id_from_url
 703 | get_blog_list
 704 | get_blog_option
 705 | get_blog_permalink
 706 | get_blog_post
 707 | get_blog_status
 708 | get_blogaddress_by_domain
 709 | get_blogaddress_by_id
 710 | get_blogaddress_by_name
 711 | get_bloginfo
 712 | get_bloginfo_rss
 713 | get_blogs_of_user
 714 | get_body_class
 715 | get_bookmark
 716 | get_bookmark_field
 717 | get_bookmarks
 718 | get_boundary_post
 719 | get_boundary_post_rel_link
 720 | get_broken_themes
 721 | get_calendar
 722 | get_cancel_comment_reply_link
 723 | get_cat_id
 724 | get_cat_name
 725 | get_categories
 726 | get_category
 727 | get_category_by_path
 728 | get_category_by_slug
 729 | get_category_children
 730 | get_category_feed_link
 731 | get_category_link
 732 | get_category_parents
 733 | get_category_rss_link
 734 | get_category_template
 735 | get_category_to_edit
 736 | get_catname
 737 | get_children
 738 | get_clean_basedomain
 739 | get_cli_args
 740 | get_column_headers
 741 | get_comment
 742 | get_comment_author
 743 | get_comment_author_email
 744 | get_comment_author_email_link
 745 | get_comment_author_ip
 746 | get_comment_author_link
 747 | get_comment_author_rss
 748 | get_comment_author_url
 749 | get_comment_author_url_link
 750 | get_comment_class
 751 | get_comment_count
 752 | get_comment_date
 753 | get_comment_excerpt
 754 | get_comment_guid
 755 | get_comment_id
 756 | get_comment_id_fields
 757 | get_comment_link
 758 | get_comment_meta
 759 | get_comment_pages_count
 760 | get_comment_reply_link
 761 | get_comment_statuses
 762 | get_comment_text
 763 | get_comment_time
 764 | get_comment_to_edit
 765 | get_comment_type
 766 | get_commentdata
 767 | get_comments
 768 | get_comments_link
 769 | get_comments_number
 770 | get_comments_number_text
 771 | get_comments_pagenum_link
 772 | get_comments_popup_template
 773 | get_compat_media_markup
 774 | get_core_checksums
 775 | get_core_updates
 776 | get_current_blog_id
 777 | get_current_network_id
 778 | get_current_screen
 779 | get_current_site
 780 | get_current_site_name
 781 | get_current_theme
 782 | get_current_user_id
 783 | get_currentuserinfo
 784 | get_custom_header
 785 | get_custom_header_markup
 786 | get_custom_logo
 787 | get_dashboard_blog
 788 | get_dashboard_url
 789 | get_date_from_gmt
 790 | get_date_template
 791 | get_day_link
 792 | get_default_comment_status
 793 | get_default_feed
 794 | get_default_link_to_edit
 795 | get_default_page_to_edit
 796 | get_default_post_to_edit
 797 | get_delete_post_link
 798 | get_dirsize
 799 | get_dropins
 800 | get_edit_bookmark_link
 801 | get_edit_comment_link
 802 | get_edit_post_link
 803 | get_edit_profile_url
 804 | get_edit_tag_link
 805 | get_edit_term_link
 806 | get_edit_user_link
 807 | get_editable_authors
 808 | get_editable_roles
 809 | get_editable_user_ids
 810 | get_editor_stylesheets
 811 | get_embed_template
 812 | get_enclosed
 813 | get_extended
 814 | get_feed_link
 815 | get_file_data
 816 | get_file_description
 817 | get_filesystem_method
 818 | get_footer
 819 | get_front_page_template
 820 | get_gmt_from_date
 821 | get_header
 822 | get_header_image
 823 | get_header_image_tag
 824 | get_header_textcolor
 825 | get_header_video_settings
 826 | get_header_video_url
 827 | get_hidden_columns
 828 | get_hidden_meta_boxes
 829 | get_home_path
 830 | get_home_template
 831 | get_home_url
 832 | get_html_split_regex
 833 | get_http_origin
 834 | get_id_from_blogname
 835 | get_image_send_to_editor
 836 | get_image_tag
 837 | get_importers
 838 | get_index_rel_link
 839 | get_index_template
 840 | get_inline_data
 841 | get_intermediate_image_sizes
 842 | get_language_attributes
 843 | get_last_updated
 844 | get_lastcommentmodified
 845 | get_lastpostdate
 846 | get_lastpostmodified
 847 | get_link
 848 | get_link_to_edit
 849 | get_linkcatname
 850 | get_linkobjects
 851 | get_linkobjectsbyname
 852 | get_linkrating
 853 | get_links
 854 | get_links_list
 855 | get_links_withrating
 856 | get_linksbyname
 857 | get_linksbyname_withrating
 858 | get_locale
 859 | get_locale_stylesheet_uri
 860 | get_main_network_id
 861 | get_main_site_id
 862 | get_media_embedded_in_content
 863 | get_media_item
 864 | get_media_items
 865 | get_meta_keys
 866 | get_meta_sql
 867 | get_metadata
 868 | get_metadata_by_mid
 869 | get_month_link
 870 | get_most_active_blogs
 871 | get_most_recent_post_of_user
 872 | get_mu_plugins
 873 | get_nav_menu_locations
 874 | get_network
 875 | get_network_by_path
 876 | get_network_option
 877 | get_networks
 878 | get_next_comments_link
 879 | get_next_post
 880 | get_next_post_link
 881 | get_next_posts_link
 882 | get_next_posts_page_link
 883 | get_nonauthor_user_ids
 884 | get_num_queries
 885 | get_object_subtype
 886 | get_object_taxonomies
 887 | get_object_term_cache
 888 | get_objects_in_term
 889 | get_oembed_endpoint_url
 890 | get_oembed_response_data
 891 | get_oembed_response_data_rich
 892 | get_option
 893 | get_others_drafts
 894 | get_others_pending
 895 | get_others_unpublished_posts
 896 | get_page
 897 | get_page_by_path
 898 | get_page_by_title
 899 | get_page_children
 900 | get_page_hierarchy
 901 | get_page_link
 902 | get_page_of_comment
 903 | get_page_statuses
 904 | get_page_template
 905 | get_page_template_slug
 906 | get_page_templates
 907 | get_page_uri
 908 | get_paged_template
 909 | get_pagenum_link
 910 | get_pages
 911 | get_parent_post_rel_link
 912 | get_parent_theme_file_path
 913 | get_parent_theme_file_uri
 914 | get_password_reset_key
 915 | get_pending_comments_num
 916 | get_permalink
 917 | get_plugin_data
 918 | get_plugin_files
 919 | get_plugin_page_hook
 920 | get_plugin_page_hookname
 921 | get_plugin_updates
 922 | get_plugins
 923 | get_post
 924 | get_post_ancestors
 925 | get_post_class
 926 | get_post_comments_feed_link
 927 | get_post_custom
 928 | get_post_custom_keys
 929 | get_post_custom_values
 930 | get_post_embed_html
 931 | get_post_embed_url
 932 | get_post_field
 933 | get_post_format
 934 | get_post_format_link
 935 | get_post_format_slugs
 936 | get_post_format_string
 937 | get_post_format_strings
 938 | get_post_galleries
 939 | get_post_galleries_images
 940 | get_post_gallery
 941 | get_post_gallery_images
 942 | get_post_meta
 943 | get_post_meta_by_id
 944 | get_post_mime_type
 945 | get_post_mime_types
 946 | get_post_modified_time
 947 | get_post_permalink
 948 | get_post_reply_link
 949 | get_post_stati
 950 | get_post_status
 951 | get_post_status_object
 952 | get_post_statuses
 953 | get_post_taxonomies
 954 | get_post_thumbnail_id
 955 | get_post_time
 956 | get_post_to_edit
 957 | get_post_type
 958 | get_post_type_archive_feed_link
 959 | get_post_type_archive_link
 960 | get_post_type_archive_template
 961 | get_post_type_capabilities
 962 | get_post_type_labels
 963 | get_post_type_object
 964 | get_post_types
 965 | get_post_types_by_support
 966 | get_postdata
 967 | get_posts
 968 | get_posts_by_author_sql
 969 | get_posts_nav_link
 970 | get_preferred_from_update_core
 971 | get_preview_post_link
 972 | get_previous_comments_link
 973 | get_previous_post
 974 | get_previous_post_link
 975 | get_previous_posts_link
 976 | get_previous_posts_page_link
 977 | get_privacy_policy_url
 978 | get_private_posts_cap_sql
 979 | get_profile
 980 | get_pung
 981 | get_queried_object
 982 | get_queried_object_id
 983 | get_query_template
 984 | get_query_var
 985 | get_random_header_image
 986 | get_raw_theme_root
 987 | get_real_file_to_edit
 988 | get_registered_meta_keys
 989 | get_registered_metadata
 990 | get_registered_nav_menus
 991 | get_registered_settings
 992 | get_rest_url
 993 | get_role
 994 | get_rss
 995 | get_sample_permalink
 996 | get_sample_permalink_html
 997 | get_screen_icon
 998 | get_search_comments_feed_link
 999 | get_search_feed_link
1000 | get_search_form
1001 | get_search_link
1002 | get_search_query
1003 | get_search_template
1004 | get_settings
1005 | get_settings_errors
1006 | get_shortcode_atts_regex
1007 | get_shortcode_regex
1008 | get_shortcut_link
1009 | get_sidebar
1010 | get_single_template
1011 | get_singular_template
1012 | get_site
1013 | get_site_allowed_themes
1014 | get_site_by_path
1015 | get_site_icon_url
1016 | get_site_meta
1017 | get_site_option
1018 | get_site_screen_help_sidebar_content
1019 | get_site_screen_help_tab_args
1020 | get_site_transient
1021 | get_site_url
1022 | get_sites
1023 | get_sitestats
1024 | get_space_allowed
1025 | get_space_used
1026 | get_status_header_desc
1027 | get_stylesheet
1028 | get_stylesheet_directory
1029 | get_stylesheet_directory_uri
1030 | get_stylesheet_uri
1031 | get_subdirectory_reserved_names
1032 | get_submit_button
1033 | get_super_admins
1034 | get_tag
1035 | get_tag_feed_link
1036 | get_tag_link
1037 | get_tag_regex
1038 | get_tag_template
1039 | get_tags
1040 | get_tags_to_edit
1041 | get_tax_sql
1042 | get_taxonomies
1043 | get_taxonomies_for_attachments
1044 | get_taxonomy
1045 | get_taxonomy_labels
1046 | get_taxonomy_template
1047 | get_temp_dir
1048 | get_template
1049 | get_template_directory
1050 | get_template_directory_uri
1051 | get_template_part
1052 | get_term
1053 | get_term_by
1054 | get_term_children
1055 | get_term_feed_link
1056 | get_term_field
1057 | get_term_link
1058 | get_term_meta
1059 | get_term_parents_list
1060 | get_term_to_edit
1061 | get_terms
1062 | get_terms_to_edit
1063 | get_the_archive_description
1064 | get_the_archive_title
1065 | get_the_attachment_link
1066 | get_the_author
1067 | get_the_author_aim
1068 | get_the_author_description
1069 | get_the_author_email
1070 | get_the_author_firstname
1071 | get_the_author_icq
1072 | get_the_author_id
1073 | get_the_author_lastname
1074 | get_the_author_link
1075 | get_the_author_login
1076 | get_the_author_meta
1077 | get_the_author_msn
1078 | get_the_author_nickname
1079 | get_the_author_posts
1080 | get_the_author_posts_link
1081 | get_the_author_url
1082 | get_the_author_yim
1083 | get_the_category
1084 | get_the_category_by_id
1085 | get_the_category_list
1086 | get_the_category_rss
1087 | get_the_comments_navigation
1088 | get_the_comments_pagination
1089 | get_the_content
1090 | get_the_content_feed
1091 | get_the_date
1092 | get_the_excerpt
1093 | get_the_generator
1094 | get_the_guid
1095 | get_the_id
1096 | get_the_modified_author
1097 | get_the_modified_date
1098 | get_the_modified_time
1099 | get_the_password_form
1100 | get_the_permalink
1101 | get_the_post_navigation
1102 | get_the_post_thumbnail
1103 | get_the_post_thumbnail_caption
1104 | get_the_post_thumbnail_url
1105 | get_the_post_type_description
1106 | get_the_posts_navigation
1107 | get_the_posts_pagination
1108 | get_the_privacy_policy_link
1109 | get_the_tag_list
1110 | get_the_tags
1111 | get_the_taxonomies
1112 | get_the_term_list
1113 | get_the_terms
1114 | get_the_time
1115 | get_the_title
1116 | get_the_title_rss
1117 | get_theme
1118 | get_theme_data
1119 | get_theme_feature_list
1120 | get_theme_file_path
1121 | get_theme_file_uri
1122 | get_theme_mod
1123 | get_theme_mods
1124 | get_theme_root
1125 | get_theme_root_uri
1126 | get_theme_roots
1127 | get_theme_starter_content
1128 | get_theme_support
1129 | get_theme_update_available
1130 | get_theme_updates
1131 | get_themes
1132 | get_to_ping
1133 | get_trackback_url
1134 | get_transient
1135 | get_translations_for_domain
1136 | get_udims
1137 | get_upload_iframe_src
1138 | get_upload_space_available
1139 | get_uploaded_header_images
1140 | get_url_in_content
1141 | get_user_by
1142 | get_user_by_email
1143 | get_user_count
1144 | get_user_details
1145 | get_user_id_from_string
1146 | get_user_locale
1147 | get_user_meta
1148 | get_user_metavalues
1149 | get_user_option
1150 | get_user_setting
1151 | get_user_to_edit
1152 | get_userdata
1153 | get_userdatabylogin
1154 | get_usermeta
1155 | get_usernumposts
1156 | get_users
1157 | get_users_drafts
1158 | get_users_of_blog
1159 | get_weekstartend
1160 | get_wp_title_rss
1161 | get_year_link
1162 | global_terms
1163 | global_terms_enabled
1164 | got_mod_rewrite
1165 | got_url_rewrite
1166 | graceful_fail
1167 | grant_super_admin
1168 | gzip_compression
1169 | has_action
1170 | has_category
1171 | has_custom_header
1172 | has_custom_logo
1173 | has_excerpt
1174 | has_filter
1175 | has_header_image
1176 | has_header_video
1177 | has_image_size
1178 | has_meta
1179 | has_nav_menu
1180 | has_post_format
1181 | has_post_thumbnail
1182 | has_shortcode
1183 | has_site_icon
1184 | has_tag
1185 | has_term
1186 | has_term_meta
1187 | hash_equals
1188 | have_comments
1189 | have_posts
1190 | header_image
1191 | header_textcolor
1192 | heartbeat_autosave
1193 | home_url
1194 | html_type_rss
1195 | htmlentities2
1196 | human_time_diff
1197 | iframe_footer
1198 | iframe_header
1199 | iis7_add_rewrite_rule
1200 | iis7_delete_rewrite_rule
1201 | iis7_rewrite_rule_exists
1202 | iis7_save_url_rewrite_rules
1203 | iis7_supports_permalinks
1204 | image_add_caption
1205 | image_align_input_fields
1206 | image_attachment_fields_to_edit
1207 | image_attachment_fields_to_save
1208 | image_constrain_size_for_editor
1209 | image_downsize
1210 | image_edit_apply_changes
1211 | image_get_intermediate_size
1212 | image_hwstring
1213 | image_link_input_fields
1214 | image_make_intermediate_size
1215 | image_media_send_to_editor
1216 | image_resize
1217 | image_resize_dimensions
1218 | image_size_input_fields
1219 | img_caption_shortcode
1220 | in_category
1221 | in_the_loop
1222 | includes_url
1223 | index_rel_link
1224 | insert_blog
1225 | insert_with_markers
1226 | install_blog
1227 | install_blog_defaults
1228 | install_dashboard
1229 | install_global_terms
1230 | install_network
1231 | install_plugin_information
1232 | install_plugin_install_status
1233 | install_plugins_favorites_form
1234 | install_plugins_upload
1235 | install_popular_tags
1236 | install_search_form
1237 | install_theme_information
1238 | install_theme_search_form
1239 | install_themes_dashboard
1240 | install_themes_feature_list
1241 | install_themes_upload
1242 | is_404
1243 | is_active_sidebar
1244 | is_active_widget
1245 | is_admin
1246 | is_admin_bar_showing
1247 | is_allowed_http_origin
1248 | is_archive
1249 | is_archived
1250 | is_attachment
1251 | is_author
1252 | is_blog_admin
1253 | is_blog_installed
1254 | is_blog_user
1255 | is_category
1256 | is_child_theme
1257 | is_client_error
1258 | is_comment_feed
1259 | is_comments_popup
1260 | is_countable
1261 | is_customize_preview
1262 | is_date
1263 | is_day
1264 | is_dynamic_sidebar
1265 | is_email
1266 | is_email_address_unsafe
1267 | is_embed
1268 | is_error
1269 | is_feed
1270 | is_front_page
1271 | is_header_video_active
1272 | is_home
1273 | is_info
1274 | is_iterable
1275 | is_lighttpd_before_150
1276 | is_local_attachment
1277 | is_locale_switched
1278 | is_main_blog
1279 | is_main_network
1280 | is_main_query
1281 | is_main_site
1282 | is_month
1283 | is_multi_author
1284 | is_multisite
1285 | is_nav_menu
1286 | is_nav_menu_item
1287 | is_network_admin
1288 | is_network_only_plugin
1289 | is_new_day
1290 | is_object_in_taxonomy
1291 | is_object_in_term
1292 | is_page
1293 | is_page_template
1294 | is_paged
1295 | is_plugin_active
1296 | is_plugin_active_for_network
1297 | is_plugin_inactive
1298 | is_plugin_page
1299 | is_post_type_archive
1300 | is_post_type_hierarchical
1301 | is_post_type_viewable
1302 | is_preview
1303 | is_protected_meta
1304 | is_random_header_image
1305 | is_redirect
1306 | is_registered_sidebar
1307 | is_robots
1308 | is_rtl
1309 | is_search
1310 | is_serialized
1311 | is_serialized_string
1312 | is_server_error
1313 | is_single
1314 | is_singular
1315 | is_site_admin
1316 | is_site_meta_supported
1317 | is_ssl
1318 | is_sticky
1319 | is_subdomain_install
1320 | is_success
1321 | is_super_admin
1322 | is_tag
1323 | is_tax
1324 | is_taxonomy
1325 | is_taxonomy_hierarchical
1326 | is_taxonomy_viewable
1327 | is_term
1328 | is_textdomain_loaded
1329 | is_time
1330 | is_trackback
1331 | is_uninstallable_plugin
1332 | is_upload_space_available
1333 | is_user_admin
1334 | is_user_logged_in
1335 | is_user_member_of_blog
1336 | is_user_option_local
1337 | is_user_spammy
1338 | is_wp_error
1339 | is_wpmu_sitewide_plugin
1340 | is_year
1341 | iso8601_timezone_to_offset
1342 | iso8601_to_datetime
1343 | js_escape
1344 | json_last_error_msg
1345 | kses_init
1346 | kses_init_filters
1347 | kses_remove_filters
1348 | language_attributes
1349 | like_escape
1350 | link_advanced_meta_box
1351 | link_categories_meta_box
1352 | link_pages
1353 | link_submit_meta_box
1354 | link_target_meta_box
1355 | link_xfn_meta_box
1356 | links_add_base_url
1357 | links_add_target
1358 | links_popup_script
1359 | list_authors
1360 | list_cats
1361 | list_core_update
1362 | list_files
1363 | list_meta
1364 | list_plugin_updates
1365 | list_theme_updates
1366 | list_translation_updates
1367 | load_child_theme_textdomain
1368 | load_default_textdomain
1369 | load_image_to_edit
1370 | load_muplugin_textdomain
1371 | load_plugin_textdomain
1372 | load_template
1373 | load_textdomain
1374 | load_theme_textdomain
1375 | locale_stylesheet
1376 | locate_template
1377 | login_footer
1378 | login_header
1379 | logio
1380 | maintenance_nag
1381 | make_clickable
1382 | make_db_current
1383 | make_db_current_silent
1384 | make_site_theme
1385 | make_site_theme_from_default
1386 | make_site_theme_from_oldschool
1387 | make_url_footnote
1388 | map_deep
1389 | map_meta_cap
1390 | maybe_add_column
1391 | maybe_add_existing_user_to_blog
1392 | maybe_convert_table_to_utf8mb4
1393 | maybe_create_table
1394 | maybe_disable_automattic_widgets
1395 | maybe_disable_link_manager
1396 | maybe_drop_column
1397 | maybe_hash_hex_color
1398 | maybe_redirect_404
1399 | maybe_serialize
1400 | maybe_unserialize
1401 | mb_strlen
1402 | mbstring_binary_safe_encoding
1403 | media_buttons
1404 | media_handle_sideload
1405 | media_handle_upload
1406 | media_post_single_attachment_fields_to_edit
1407 | media_send_to_editor
1408 | media_sideload_image
1409 | media_single_attachment_fields_to_edit
1410 | media_upload_audio
1411 | media_upload_file
1412 | media_upload_flash_bypass
1413 | media_upload_form
1414 | media_upload_form_handler
1415 | media_upload_gallery
1416 | media_upload_gallery_form
1417 | media_upload_header
1418 | media_upload_html_bypass
1419 | media_upload_image
1420 | media_upload_library
1421 | media_upload_library_form
1422 | media_upload_max_image_resize
1423 | media_upload_tabs
1424 | media_upload_text_after
1425 | media_upload_type_form
1426 | media_upload_type_url_form
1427 | media_upload_video
1428 | menu_page_url
1429 | meta_box_prefs
1430 | meta_form
1431 | metadata_exists
1432 | ms_allowed_http_request_hosts
1433 | ms_cookie_constants
1434 | ms_deprecated_blogs_file
1435 | ms_file_constants
1436 | ms_is_switched
1437 | ms_load_current_site_and_network
1438 | ms_not_installed
1439 | ms_site_check
1440 | ms_subdomain_constants
1441 | ms_upload_constants
1442 | mu_dropdown_languages
1443 | mu_options
1444 | multisite_over_quota_message
1445 | mysql2date
1446 | mysql_to_rfc3339
1447 | network_admin_url
1448 | network_domain_check
1449 | network_edit_site_nav
1450 | network_home_url
1451 | network_settings_add_js
1452 | network_site_url
1453 | network_step1
1454 | network_step2
1455 | new_user_email_admin_notice
1456 | newblog_notify_siteadmin
1457 | newuser_notify_siteadmin
1458 | next_comments_link
1459 | next_image_link
1460 | next_post
1461 | next_post_link
1462 | next_post_rel_link
1463 | next_posts
1464 | next_posts_link
1465 | next_widget_id_number
1466 | nocache_headers
1467 | noindex
1468 | normalize_whitespace
1469 | number_format_i18n
1470 | option_update_filter
1471 | options_discussion_add_js
1472 | options_general_add_js
1473 | options_permalink_add_js
1474 | options_reading_add_js
1475 | options_reading_blog_charset
1476 | page_attributes_meta_box
1477 | page_template_dropdown
1478 | paginate_comments_links
1479 | paginate_links
1480 | parent_dropdown
1481 | parent_post_rel_link
1482 | parse_w3cdtf
1483 | path_is_absolute
1484 | path_join
1485 | pclziputilcopyblock
1486 | pclziputiloptiontext
1487 | pclziputilpathinclusion
1488 | pclziputilpathreduction
1489 | pclziputilrename
1490 | pclziputiltranslatewinpath
1491 | permalink_anchor
1492 | permalink_link
1493 | permalink_single_rss
1494 | pingback
1495 | pingback_ping_source_uri
1496 | pings_open
1497 | plugin_basename
1498 | plugin_dir_path
1499 | plugin_dir_url
1500 | plugin_sandbox_scrape
1501 | plugins_api
1502 | plugins_url
1503 | populate_network
1504 | populate_options
1505 | populate_roles
1506 | populate_roles_160
1507 | populate_roles_210
1508 | populate_roles_230
1509 | populate_roles_250
1510 | populate_roles_260
1511 | populate_roles_270
1512 | populate_roles_280
1513 | populate_roles_300
1514 | popuplinks
1515 | post_author_meta_box
1516 | post_categories_meta_box
1517 | post_class
1518 | post_comment_meta_box
1519 | post_comment_meta_box_thead
1520 | post_comment_status_meta_box
1521 | post_comments_feed_link
1522 | post_custom
1523 | post_custom_meta_box
1524 | post_excerpt_meta_box
1525 | post_exists
1526 | post_form_autocomplete_off
1527 | post_format_meta_box
1528 | post_password_required
1529 | post_permalink
1530 | post_preview
1531 | post_reply_link
1532 | post_revisions_meta_box
1533 | post_slug_meta_box
1534 | post_submit_meta_box
1535 | post_tags_meta_box
1536 | post_thumbnail_meta_box
1537 | post_trackback_meta_box
1538 | post_type_archive_title
1539 | post_type_exists
1540 | post_type_supports
1541 | postbox_classes
1542 | posts_nav_link
1543 | pre_schema_upgrade
1544 | prep_atom_text_construct
1545 | prepend_attachment
1546 | prev_post_rel_link
1547 | preview_theme
1548 | preview_theme_ob_filter
1549 | preview_theme_ob_filter_callback
1550 | previous_comments_link
1551 | previous_image_link
1552 | previous_post
1553 | previous_post_link
1554 | previous_posts
1555 | previous_posts_link
1556 | print_admin_styles
1557 | print_column_headers
1558 | print_embed_comments_button
1559 | print_embed_scripts
1560 | print_embed_sharing_button
1561 | print_embed_sharing_dialog
1562 | print_embed_styles
1563 | print_emoji_detection_script
1564 | print_emoji_styles
1565 | print_footer_scripts
1566 | print_head_scripts
1567 | print_late_styles
1568 | privacy_ping_filter
1569 | query_posts
1570 | random_bytes
1571 | random_int
1572 | randomcompat_intval
1573 | randomcompat_strlen
1574 | randomcompat_substr
1575 | rawurlencode_deep
1576 | readonly
1577 | recurse_dirsize
1578 | redirect_canonical
1579 | redirect_guess_404_permalink
1580 | redirect_post
1581 | redirect_this_site
1582 | refresh_blog_details
1583 | refresh_user_details
1584 | register_activation_hook
1585 | register_admin_color_schemes
1586 | register_column_headers
1587 | register_deactivation_hook
1588 | register_default_headers
1589 | register_importer
1590 | register_initial_settings
1591 | register_meta
1592 | register_nav_menu
1593 | register_nav_menus
1594 | register_new_user
1595 | register_post_meta
1596 | register_post_status
1597 | register_post_type
1598 | register_rest_field
1599 | register_rest_route
1600 | register_setting
1601 | register_sidebar
1602 | register_sidebar_widget
1603 | register_sidebars
1604 | register_taxonomy
1605 | register_taxonomy_for_object_type
1606 | register_term_meta
1607 | register_theme_directory
1608 | register_uninstall_hook
1609 | register_widget
1610 | register_widget_control
1611 | registered_meta_key_exists
1612 | rel_canonical
1613 | remove_accents
1614 | remove_action
1615 | remove_all_actions
1616 | remove_all_filters
1617 | remove_all_shortcodes
1618 | remove_custom_background
1619 | remove_custom_image_header
1620 | remove_editor_styles
1621 | remove_filter
1622 | remove_image_size
1623 | remove_menu_page
1624 | remove_meta_box
1625 | remove_option_update_handler
1626 | remove_option_whitelist
1627 | remove_permastruct
1628 | remove_post_type_support
1629 | remove_query_arg
1630 | remove_rewrite_tag
1631 | remove_role
1632 | remove_shortcode
1633 | remove_submenu_page
1634 | remove_theme_mod
1635 | remove_theme_mods
1636 | remove_theme_support
1637 | remove_user_from_blog
1638 | request_filesystem_credentials
1639 | require_if_theme_supports
1640 | require_wp_db
1641 | reset_mbstring_encoding
1642 | reset_password
1643 | rest_api_default_filters
1644 | rest_api_init
1645 | rest_api_loaded
1646 | rest_api_register_rewrites
1647 | rest_authorization_required_code
1648 | rest_cookie_check_errors
1649 | rest_cookie_collect_status
1650 | rest_do_request
1651 | rest_ensure_request
1652 | rest_ensure_response
1653 | rest_filter_response_fields
1654 | rest_get_avatar_sizes
1655 | rest_get_avatar_urls
1656 | rest_get_date_with_gmt
1657 | rest_get_server
1658 | rest_get_url_prefix
1659 | rest_handle_deprecated_argument
1660 | rest_handle_deprecated_function
1661 | rest_handle_options_request
1662 | rest_is_boolean
1663 | rest_is_ip_address
1664 | rest_output_link_header
1665 | rest_output_link_wp_head
1666 | rest_output_rsd
1667 | rest_parse_date
1668 | rest_parse_request_arg
1669 | rest_sanitize_boolean
1670 | rest_sanitize_request_arg
1671 | rest_sanitize_value_from_schema
1672 | rest_send_allow_header
1673 | rest_send_cors_headers
1674 | rest_url
1675 | rest_validate_request_arg
1676 | rest_validate_value_from_schema
1677 | restore_current_blog
1678 | restore_current_locale
1679 | restore_previous_locale
1680 | retrieve_password
1681 | retrieve_widgets
1682 | revoke_super_admin
1683 | rewind_posts
1684 | rich_edit_exists
1685 | rsd_link
1686 | rss2_site_icon
1687 | rss_enclosure
1688 | safecss_filter_attr
1689 | sanitize_bookmark
1690 | sanitize_bookmark_field
1691 | sanitize_category
1692 | sanitize_category_field
1693 | sanitize_comment_cookies
1694 | sanitize_email
1695 | sanitize_file_name
1696 | sanitize_hex_color
1697 | sanitize_hex_color_no_hash
1698 | sanitize_html_class
1699 | sanitize_key
1700 | sanitize_meta
1701 | sanitize_mime_type
1702 | sanitize_option
1703 | sanitize_post
1704 | sanitize_post_field
1705 | sanitize_sql_orderby
1706 | sanitize_term
1707 | sanitize_term_field
1708 | sanitize_text_field
1709 | sanitize_textarea_field
1710 | sanitize_title
1711 | sanitize_title_for_query
1712 | sanitize_title_with_dashes
1713 | sanitize_trackback_urls
1714 | sanitize_url
1715 | sanitize_user
1716 | sanitize_user_field
1717 | sanitize_user_object
1718 | save_mod_rewrite_rules
1719 | savedomdocument
1720 | screen_icon
1721 | screen_layout
1722 | screen_meta
1723 | screen_options
1724 | script_concat_settings
1725 | search_theme_directories
1726 | seems_utf8
1727 | selected
1728 | self_admin_url
1729 | self_link
1730 | send_confirmation_on_profile_email
1731 | send_frame_options_header
1732 | send_nosniff_header
1733 | send_origin_headers
1734 | separate_comments
1735 | set_current_screen
1736 | set_current_user
1737 | set_post_format
1738 | set_post_thumbnail
1739 | set_post_thumbnail_size
1740 | set_post_type
1741 | set_query_var
1742 | set_screen_options
1743 | set_site_transient
1744 | set_theme_mod
1745 | set_transient
1746 | set_url_scheme
1747 | set_user_setting
1748 | settings_errors
1749 | settings_fields
1750 | setup_config_display_header
1751 | setup_postdata
1752 | setup_userdata
1753 | shortcode_atts
1754 | shortcode_exists
1755 | shortcode_parse_atts
1756 | shortcode_unautop
1757 | show_admin_bar
1758 | show_blog_form
1759 | show_message
1760 | show_user_form
1761 | shutdown_action_hook
1762 | signup_another_blog
1763 | signup_blog
1764 | signup_get_available_languages
1765 | signup_nonce_check
1766 | signup_nonce_fields
1767 | signup_user
1768 | single_cat_title
1769 | single_month_title
1770 | single_post_title
1771 | single_tag_title
1772 | single_term_title
1773 | site_admin_notice
1774 | site_icon_url
1775 | site_url
1776 | size_format
1777 | smilies_init
1778 | sort_menu
1779 | spawn_cron
1780 | spl_autoload_functions
1781 | spl_autoload_register
1782 | spl_autoload_unregister
1783 | start_post_rel_link
1784 | start_wp
1785 | startelement
1786 | status_header
1787 | stick_post
1788 | sticky_class
1789 | stream_preview_image
1790 | strip_fragment_from_url
1791 | strip_shortcode_tag
1792 | strip_shortcodes
1793 | stripslashes_deep
1794 | stripslashes_from_strings_only
1795 | submit_button
1796 | switch_theme
1797 | switch_to_blog
1798 | switch_to_locale
1799 | sync_category_tag_slugs
1800 | tag_description
1801 | tag_escape
1802 | tag_exists
1803 | taxonomy_exists
1804 | taxonomy_meta_box_sanitize_cb_checkboxes
1805 | taxonomy_meta_box_sanitize_cb_input
1806 | term_description
1807 | term_exists
1808 | term_is_ancestor_of
1809 | the_archive_description
1810 | the_archive_title
1811 | the_attachment_link
1812 | the_attachment_links
1813 | the_author
1814 | the_author_aim
1815 | the_author_description
1816 | the_author_email
1817 | the_author_firstname
1818 | the_author_icq
1819 | the_author_id
1820 | the_author_lastname
1821 | the_author_link
1822 | the_author_login
1823 | the_author_meta
1824 | the_author_msn
1825 | the_author_nickname
1826 | the_author_posts
1827 | the_author_posts_link
1828 | the_author_url
1829 | the_author_yim
1830 | the_category
1831 | the_category_head
1832 | the_category_id
1833 | the_category_rss
1834 | the_comment
1835 | the_comments_navigation
1836 | the_comments_pagination
1837 | the_content
1838 | the_content_feed
1839 | the_content_rss
1840 | the_custom_header_markup
1841 | the_custom_logo
1842 | the_date
1843 | the_date_xml
1844 | the_editor
1845 | the_embed_site_title
1846 | the_excerpt
1847 | the_excerpt_embed
1848 | the_excerpt_rss
1849 | the_feed_link
1850 | the_generator
1851 | the_guid
1852 | the_header_image_tag
1853 | the_header_video_url
1854 | the_id
1855 | the_media_upload_tabs
1856 | the_meta
1857 | the_modified_author
1858 | the_modified_date
1859 | the_modified_time
1860 | the_permalink
1861 | the_permalink_rss
1862 | the_post
1863 | the_post_navigation
1864 | the_post_password
1865 | the_post_thumbnail
1866 | the_post_thumbnail_caption
1867 | the_post_thumbnail_url
1868 | the_posts_navigation
1869 | the_posts_pagination
1870 | the_privacy_policy_link
1871 | the_search_query
1872 | the_shortlink
1873 | the_tags
1874 | the_taxonomies
1875 | the_terms
1876 | the_time
1877 | the_title
1878 | the_title_attribute
1879 | the_title_rss
1880 | the_weekday
1881 | the_weekday_date
1882 | the_widget
1883 | theme_update_available
1884 | themes_api
1885 | timer_start
1886 | timer_stop
1887 | tinymce_include
1888 | touch_time
1889 | trackback
1890 | trackback_rdf
1891 | trackback_response
1892 | trackback_url
1893 | trackback_url_list
1894 | trailingslashit
1895 | translate
1896 | translate_level_to_role
1897 | translate_nooped_plural
1898 | translate_smiley
1899 | translate_user_role
1900 | translate_with_context
1901 | translate_with_gettext_context
1902 | translations_api
1903 | type_url_form_audio
1904 | type_url_form_file
1905 | type_url_form_image
1906 | type_url_form_video
1907 | undismiss_core_update
1908 | unescape_invalid_shortcodes
1909 | uninstall_plugin
1910 | unload_textdomain
1911 | unregister_default_headers
1912 | unregister_meta_key
1913 | unregister_nav_menu
1914 | unregister_post_meta
1915 | unregister_post_type
1916 | unregister_setting
1917 | unregister_sidebar
1918 | unregister_sidebar_widget
1919 | unregister_taxonomy
1920 | unregister_taxonomy_for_object_type
1921 | unregister_term_meta
1922 | unregister_widget
1923 | unregister_widget_control
1924 | unstick_post
1925 | untrailingslashit
1926 | unzip_file
1927 | update_archived
1928 | update_attached_file
1929 | update_blog_details
1930 | update_blog_option
1931 | update_blog_public
1932 | update_blog_status
1933 | update_category_cache
1934 | update_comment_cache
1935 | update_comment_meta
1936 | update_core
1937 | update_gallery_tab
1938 | update_home_siteurl
1939 | update_meta
1940 | update_meta_cache
1941 | update_metadata
1942 | update_metadata_by_mid
1943 | update_nag
1944 | update_network_cache
1945 | update_network_option
1946 | update_network_option_new_admin_email
1947 | update_object_term_cache
1948 | update_option
1949 | update_option_new_admin_email
1950 | update_page_cache
1951 | update_post_cache
1952 | update_post_caches
1953 | update_post_meta
1954 | update_post_thumbnail_cache
1955 | update_postmeta_cache
1956 | update_posts_count
1957 | update_recently_edited
1958 | update_right_now_message
1959 | update_site_cache
1960 | update_site_meta
1961 | update_site_option
1962 | update_sitemeta_cache
1963 | update_term_cache
1964 | update_term_meta
1965 | update_termmeta_cache
1966 | update_user_caches
1967 | update_user_meta
1968 | update_user_option
1969 | update_user_status
1970 | update_usermeta
1971 | upgrade_all
1972 | upgrade_network
1973 | upgrade_old_slugs
1974 | upload_is_file_too_big
1975 | upload_is_user_over_quota
1976 | upload_size_limit_filter
1977 | upload_space_setting
1978 | url_is_accessable_via_ssl
1979 | url_shorten
1980 | url_to_postid
1981 | urldecode_deep
1982 | urlencode_deep
1983 | use_codepress
1984 | use_ssl_preference
1985 | user_admin_url
1986 | user_can
1987 | user_can_access_admin_page
1988 | user_can_create_draft
1989 | user_can_create_post
1990 | user_can_delete_post
1991 | user_can_delete_post_comments
1992 | user_can_edit_post
1993 | user_can_edit_post_comments
1994 | user_can_edit_post_date
1995 | user_can_edit_user
1996 | user_can_richedit
1997 | user_can_set_post_date
1998 | user_pass_ok
1999 | user_trailingslashit
2000 | username_exists
2001 | users_can_register_signup_filter
2002 | utf8_uri_encode
2003 | valid_unicode
2004 | validate_active_plugins
2005 | validate_another_blog_signup
2006 | validate_blog_form
2007 | validate_blog_signup
2008 | validate_current_theme
2009 | validate_email
2010 | validate_file
2011 | validate_file_to_edit
2012 | validate_plugin
2013 | validate_user_form
2014 | validate_user_signup
2015 | validate_username
2016 | verify_file_md5
2017 | walk_category_dropdown_tree
2018 | walk_category_tree
2019 | walk_nav_menu_tree
2020 | walk_page_dropdown_tree
2021 | walk_page_tree
2022 | weblog_ping
2023 | welcome_user_msg_filter
2024 | win_is_writable
2025 | wlwmanifest_link
2026 | wp
2027 | wp_add_dashboard_widget
2028 | wp_add_id3_tag_data
2029 | wp_add_inline_script
2030 | wp_add_inline_style
2031 | wp_add_object_terms
2032 | wp_add_post_tags
2033 | wp_add_privacy_policy_content
2034 | wp_add_trashed_suffix_to_post_name_for_post
2035 | wp_add_trashed_suffix_to_post_name_for_trashed_posts
2036 | wp_admin_bar_add_secondary_groups
2037 | wp_admin_bar_appearance_menu
2038 | wp_admin_bar_comments_menu
2039 | wp_admin_bar_customize_menu
2040 | wp_admin_bar_dashboard_view_site_menu
2041 | wp_admin_bar_edit_menu
2042 | wp_admin_bar_header
2043 | wp_admin_bar_my_account_item
2044 | wp_admin_bar_my_account_menu
2045 | wp_admin_bar_my_sites_menu
2046 | wp_admin_bar_new_content_menu
2047 | wp_admin_bar_render
2048 | wp_admin_bar_search_menu
2049 | wp_admin_bar_shortlink_menu
2050 | wp_admin_bar_sidebar_toggle
2051 | wp_admin_bar_site_menu
2052 | wp_admin_bar_updates_menu
2053 | wp_admin_bar_wp_menu
2054 | wp_admin_canonical_url
2055 | wp_admin_css
2056 | wp_admin_css_color
2057 | wp_admin_css_uri
2058 | wp_admin_headers
2059 | wp_ajax_add_link_category
2060 | wp_ajax_add_menu_item
2061 | wp_ajax_add_meta
2062 | wp_ajax_add_tag
2063 | wp_ajax_add_user
2064 | wp_ajax_ajax_tag_search
2065 | wp_ajax_autocomplete_user
2066 | wp_ajax_closed_postboxes
2067 | wp_ajax_crop_image
2068 | wp_ajax_dashboard_widgets
2069 | wp_ajax_date_format
2070 | wp_ajax_delete_comment
2071 | wp_ajax_delete_inactive_widgets
2072 | wp_ajax_delete_link
2073 | wp_ajax_delete_meta
2074 | wp_ajax_delete_page
2075 | wp_ajax_delete_plugin
2076 | wp_ajax_delete_post
2077 | wp_ajax_delete_tag
2078 | wp_ajax_delete_theme
2079 | wp_ajax_destroy_sessions
2080 | wp_ajax_dim_comment
2081 | wp_ajax_dismiss_wp_pointer
2082 | wp_ajax_edit_comment
2083 | wp_ajax_edit_theme_plugin_file
2084 | wp_ajax_fetch_list
2085 | wp_ajax_find_posts
2086 | wp_ajax_generate_password
2087 | wp_ajax_get_attachment
2088 | wp_ajax_get_comments
2089 | wp_ajax_get_community_events
2090 | wp_ajax_get_permalink
2091 | wp_ajax_get_post_thumbnail_html
2092 | wp_ajax_get_revision_diffs
2093 | wp_ajax_get_tagcloud
2094 | wp_ajax_heartbeat
2095 | wp_ajax_hidden_columns
2096 | wp_ajax_image_editor
2097 | wp_ajax_imgedit_preview
2098 | wp_ajax_inline_save
2099 | wp_ajax_inline_save_tax
2100 | wp_ajax_install_plugin
2101 | wp_ajax_install_theme
2102 | wp_ajax_logged_in
2103 | wp_ajax_menu_get_metabox
2104 | wp_ajax_menu_locations_save
2105 | wp_ajax_menu_quick_search
2106 | wp_ajax_meta_box_order
2107 | wp_ajax_nopriv_heartbeat
2108 | wp_ajax_oembed_cache
2109 | wp_ajax_parse_embed
2110 | wp_ajax_parse_media_shortcode
2111 | wp_ajax_press_this_add_category
2112 | wp_ajax_press_this_save_post
2113 | wp_ajax_query_attachments
2114 | wp_ajax_query_themes
2115 | wp_ajax_replyto_comment
2116 | wp_ajax_sample_permalink
2117 | wp_ajax_save_attachment
2118 | wp_ajax_save_attachment_compat
2119 | wp_ajax_save_attachment_order
2120 | wp_ajax_save_user_color_scheme
2121 | wp_ajax_save_widget
2122 | wp_ajax_save_wporg_username
2123 | wp_ajax_search_install_plugins
2124 | wp_ajax_search_plugins
2125 | wp_ajax_send_attachment_to_editor
2126 | wp_ajax_send_link_to_editor
2127 | wp_ajax_set_attachment_thumbnail
2128 | wp_ajax_set_post_thumbnail
2129 | wp_ajax_time_format
2130 | wp_ajax_trash_post
2131 | wp_ajax_untrash_post
2132 | wp_ajax_update_plugin
2133 | wp_ajax_update_theme
2134 | wp_ajax_update_welcome_panel
2135 | wp_ajax_update_widget
2136 | wp_ajax_upload_attachment
2137 | wp_ajax_widgets_order
2138 | wp_ajax_wp_compression_test
2139 | wp_ajax_wp_fullscreen_save_post
2140 | wp_ajax_wp_link_ajax
2141 | wp_ajax_wp_privacy_erase_personal_data
2142 | wp_ajax_wp_privacy_export_personal_data
2143 | wp_ajax_wp_remove_post_lock
2144 | wp_allow_comment
2145 | wp_allowed_protocols
2146 | wp_array_slice_assoc
2147 | wp_attachment_is
2148 | wp_attachment_is_image
2149 | wp_audio_shortcode
2150 | wp_auth_check
2151 | wp_auth_check_html
2152 | wp_auth_check_load
2153 | wp_authenticate
2154 | wp_authenticate_cookie
2155 | wp_authenticate_email_password
2156 | wp_authenticate_spam_check
2157 | wp_authenticate_username_password
2158 | wp_autosave
2159 | wp_basename
2160 | wp_blacklist_check
2161 | wp_cache_add
2162 | wp_cache_add_global_groups
2163 | wp_cache_add_non_persistent_groups
2164 | wp_cache_close
2165 | wp_cache_decr
2166 | wp_cache_delete
2167 | wp_cache_flush
2168 | wp_cache_get
2169 | wp_cache_get_last_changed
2170 | wp_cache_incr
2171 | wp_cache_init
2172 | wp_cache_replace
2173 | wp_cache_reset
2174 | wp_cache_set
2175 | wp_cache_switch_to_blog
2176 | wp_calculate_image_sizes
2177 | wp_calculate_image_srcset
2178 | wp_can_install_language_pack
2179 | wp_caption_input_textarea
2180 | wp_category_checklist
2181 | wp_check_browser_version
2182 | wp_check_comment_data_max_lengths
2183 | wp_check_comment_flood
2184 | wp_check_filetype
2185 | wp_check_filetype_and_ext
2186 | wp_check_for_changed_dates
2187 | wp_check_for_changed_slugs
2188 | wp_check_invalid_utf8
2189 | wp_check_jsonp_callback
2190 | wp_check_locked_posts
2191 | wp_check_mysql_version
2192 | wp_check_password
2193 | wp_check_php_mysql_versions
2194 | wp_check_php_version
2195 | wp_check_post_hierarchy_for_loops
2196 | wp_check_post_lock
2197 | wp_check_term_hierarchy_for_loops
2198 | wp_checkdate
2199 | wp_clean_plugins_cache
2200 | wp_clean_themes_cache
2201 | wp_clean_update_cache
2202 | wp_clear_auth_cookie
2203 | wp_clear_scheduled_hook
2204 | wp_clearcookie
2205 | wp_clone
2206 | wp_color_scheme_settings
2207 | wp_comment_form_unfiltered_html_nonce
2208 | wp_comment_reply
2209 | wp_comment_trashnotice
2210 | wp_comments_personal_data_eraser
2211 | wp_comments_personal_data_exporter
2212 | wp_constrain_dimensions
2213 | wp_convert_bytes_to_hr
2214 | wp_convert_hr_to_bytes
2215 | wp_convert_widget_settings
2216 | wp_cookie_constants
2217 | wp_count_attachments
2218 | wp_count_comments
2219 | wp_count_posts
2220 | wp_count_terms
2221 | wp_create_categories
2222 | wp_create_category
2223 | wp_create_nav_menu
2224 | wp_create_nonce
2225 | wp_create_post_autosave
2226 | wp_create_tag
2227 | wp_create_term
2228 | wp_create_thumbnail
2229 | wp_create_user
2230 | wp_create_user_request
2231 | wp_credits
2232 | wp_cron
2233 | wp_crop_image
2234 | wp_custom_css_cb
2235 | wp_customize_support_script
2236 | wp_customize_url
2237 | wp_dashboard
2238 | wp_dashboard_browser_nag
2239 | wp_dashboard_cached_rss_widget
2240 | wp_dashboard_empty
2241 | wp_dashboard_events_news
2242 | wp_dashboard_incoming_links
2243 | wp_dashboard_incoming_links_control
2244 | wp_dashboard_incoming_links_output
2245 | wp_dashboard_php_nag
2246 | wp_dashboard_plugins
2247 | wp_dashboard_plugins_output
2248 | wp_dashboard_primary
2249 | wp_dashboard_primary_control
2250 | wp_dashboard_primary_output
2251 | wp_dashboard_quick_press
2252 | wp_dashboard_quick_press_output
2253 | wp_dashboard_quota
2254 | wp_dashboard_recent_comments
2255 | wp_dashboard_recent_comments_control
2256 | wp_dashboard_recent_drafts
2257 | wp_dashboard_recent_posts
2258 | wp_dashboard_right_now
2259 | wp_dashboard_rss_control
2260 | wp_dashboard_rss_output
2261 | wp_dashboard_secondary
2262 | wp_dashboard_secondary_control
2263 | wp_dashboard_secondary_output
2264 | wp_dashboard_setup
2265 | wp_dashboard_site_activity
2266 | wp_dashboard_trigger_widget_control
2267 | wp_debug_backtrace_summary
2268 | wp_debug_mode
2269 | wp_default_editor
2270 | wp_default_scripts
2271 | wp_default_styles
2272 | wp_defer_comment_counting
2273 | wp_defer_term_counting
2274 | wp_delete_attachment
2275 | wp_delete_attachment_files
2276 | wp_delete_auto_drafts
2277 | wp_delete_category
2278 | wp_delete_comment
2279 | wp_delete_file
2280 | wp_delete_file_from_directory
2281 | wp_delete_link
2282 | wp_delete_nav_menu
2283 | wp_delete_object_term_relationships
2284 | wp_delete_post
2285 | wp_delete_post_revision
2286 | wp_delete_site
2287 | wp_delete_term
2288 | wp_delete_user
2289 | wp_dependencies_unique_hosts
2290 | wp_dequeue_script
2291 | wp_dequeue_style
2292 | wp_deregister_script
2293 | wp_deregister_style
2294 | wp_destroy_all_sessions
2295 | wp_destroy_current_session
2296 | wp_destroy_other_sessions
2297 | wp_die
2298 | wp_doc_link_parse
2299 | wp_doing_ajax
2300 | wp_doing_cron
2301 | wp_download_language_pack
2302 | wp_dropdown_categories
2303 | wp_dropdown_cats
2304 | wp_dropdown_languages
2305 | wp_dropdown_pages
2306 | wp_dropdown_roles
2307 | wp_dropdown_users
2308 | wp_edit_attachments_query
2309 | wp_edit_attachments_query_vars
2310 | wp_edit_posts_query
2311 | wp_edit_theme_plugin_file
2312 | wp_editor
2313 | wp_embed_defaults
2314 | wp_embed_excerpt_attachment
2315 | wp_embed_excerpt_more
2316 | wp_embed_handler_audio
2317 | wp_embed_handler_googlevideo
2318 | wp_embed_handler_video
2319 | wp_embed_handler_youtube
2320 | wp_embed_register_handler
2321 | wp_embed_unregister_handler
2322 | wp_encode_emoji
2323 | wp_enqueue_code_editor
2324 | wp_enqueue_editor
2325 | wp_enqueue_media
2326 | wp_enqueue_script
2327 | wp_enqueue_scripts
2328 | wp_enqueue_style
2329 | wp_exif_date2ts
2330 | wp_exif_frac2dec
2331 | wp_expand_dimensions
2332 | wp_explain_nonce
2333 | wp_ext2type
2334 | wp_extract_urls
2335 | wp_favicon_request
2336 | wp_filesystem
2337 | wp_filter_comment
2338 | wp_filter_kses
2339 | wp_filter_nohtml_kses
2340 | wp_filter_object_list
2341 | wp_filter_oembed_result
2342 | wp_filter_post_kses
2343 | wp_filter_pre_oembed_result
2344 | wp_finalize_scraping_edited_file_errors
2345 | wp_find_hierarchy_loop
2346 | wp_find_hierarchy_loop_tortoise_hare
2347 | wp_fix_server_vars
2348 | wp_footer
2349 | wp_functionality_constants
2350 | wp_generate_attachment_metadata
2351 | wp_generate_auth_cookie
2352 | wp_generate_password
2353 | wp_generate_tag_cloud
2354 | wp_generate_user_request_key
2355 | wp_generate_uuid4
2356 | wp_generator
2357 | wp_get_active_and_valid_plugins
2358 | wp_get_active_network_plugins
2359 | wp_get_additional_image_sizes
2360 | wp_get_all_sessions
2361 | wp_get_archives
2362 | wp_get_associated_nav_menu_items
2363 | wp_get_attachment_caption
2364 | wp_get_attachment_id3_keys
2365 | wp_get_attachment_image
2366 | wp_get_attachment_image_sizes
2367 | wp_get_attachment_image_src
2368 | wp_get_attachment_image_srcset
2369 | wp_get_attachment_image_url
2370 | wp_get_attachment_link
2371 | wp_get_attachment_metadata
2372 | wp_get_attachment_thumb_file
2373 | wp_get_attachment_thumb_url
2374 | wp_get_attachment_url
2375 | wp_get_audio_extensions
2376 | wp_get_available_translations
2377 | wp_get_canonical_url
2378 | wp_get_comment_fields_max_lengths
2379 | wp_get_comment_status
2380 | wp_get_cookie_login
2381 | wp_get_current_commenter
2382 | wp_get_current_user
2383 | wp_get_custom_css
2384 | wp_get_custom_css_post
2385 | wp_get_db_schema
2386 | wp_get_document_title
2387 | wp_get_ext_types
2388 | wp_get_http
2389 | wp_get_http_headers
2390 | wp_get_image_editor
2391 | wp_get_image_mime
2392 | wp_get_installed_translations
2393 | wp_get_link_cats
2394 | wp_get_links
2395 | wp_get_linksbyname
2396 | wp_get_media_creation_timestamp
2397 | wp_get_mime_types
2398 | wp_get_mu_plugins
2399 | wp_get_nav_menu_items
2400 | wp_get_nav_menu_name
2401 | wp_get_nav_menu_object
2402 | wp_get_nav_menu_to_edit
2403 | wp_get_nav_menus
2404 | wp_get_network
2405 | wp_get_nocache_headers
2406 | wp_get_object_terms
2407 | wp_get_original_referer
2408 | wp_get_password_hint
2409 | wp_get_plugin_file_editable_extensions
2410 | wp_get_pomo_file_data
2411 | wp_get_popular_importers
2412 | wp_get_post_autosave
2413 | wp_get_post_categories
2414 | wp_get_post_cats
2415 | wp_get_post_parent_id
2416 | wp_get_post_revision
2417 | wp_get_post_revisions
2418 | wp_get_post_tags
2419 | wp_get_post_terms
2420 | wp_get_raw_referer
2421 | wp_get_recent_posts
2422 | wp_get_referer
2423 | wp_get_revision_ui_diff
2424 | wp_get_schedule
2425 | wp_get_scheduled_event
2426 | wp_get_schedules
2427 | wp_get_server_protocol
2428 | wp_get_session_token
2429 | wp_get_shortlink
2430 | wp_get_sidebars_widgets
2431 | wp_get_single_post
2432 | wp_get_sites
2433 | wp_get_split_term
2434 | wp_get_split_terms
2435 | wp_get_term_taxonomy_parent_id
2436 | wp_get_theme
2437 | wp_get_theme_file_editable_extensions
2438 | wp_get_themes
2439 | wp_get_translation_updates
2440 | wp_get_update_data
2441 | wp_get_upload_dir
2442 | wp_get_user_contact_methods
2443 | wp_get_user_request_data
2444 | wp_get_users_with_no_role
2445 | wp_get_video_extensions
2446 | wp_get_widget_defaults
2447 | wp_guess_url
2448 | wp_handle_comment_submission
2449 | wp_handle_sideload
2450 | wp_handle_upload
2451 | wp_hash
2452 | wp_hash_password
2453 | wp_head
2454 | wp_heartbeat_set_suspension
2455 | wp_heartbeat_settings
2456 | wp_html_excerpt
2457 | wp_html_split
2458 | wp_htmledit_pre
2459 | wp_http_supports
2460 | wp_http_validate_url
2461 | wp_iframe
2462 | wp_image_add_srcset_and_sizes
2463 | wp_image_editor
2464 | wp_image_editor_supports
2465 | wp_image_matches_ratio
2466 | wp_imagecreatetruecolor
2467 | wp_import_cleanup
2468 | wp_import_handle_upload
2469 | wp_import_upload_form
2470 | wp_initial_constants
2471 | wp_initial_nav_menu_meta_boxes
2472 | wp_insert_attachment
2473 | wp_insert_category
2474 | wp_insert_comment
2475 | wp_insert_link
2476 | wp_insert_post
2477 | wp_insert_site
2478 | wp_insert_term
2479 | wp_insert_user
2480 | wp_install
2481 | wp_install_defaults
2482 | wp_install_language_form
2483 | wp_install_maybe_enable_pretty_permalinks
2484 | wp_installing
2485 | wp_is_file_mod_allowed
2486 | wp_is_ini_value_changeable
2487 | wp_is_large_network
2488 | wp_is_mobile
2489 | wp_is_numeric_array
2490 | wp_is_post_autosave
2491 | wp_is_post_revision
2492 | wp_is_stream
2493 | wp_is_uuid
2494 | wp_is_writable
2495 | wp_iso_descrambler
2496 | wp_json_encode
2497 | wp_just_in_time_script_localization
2498 | wp_kses
2499 | wp_kses_allowed_html
2500 | wp_kses_array_lc
2501 | wp_kses_attr
2502 | wp_kses_attr_check
2503 | wp_kses_attr_parse
2504 | wp_kses_bad_protocol
2505 | wp_kses_bad_protocol_once
2506 | wp_kses_bad_protocol_once2
2507 | wp_kses_check_attr_val
2508 | wp_kses_data
2509 | wp_kses_decode_entities
2510 | wp_kses_hair
2511 | wp_kses_hair_parse
2512 | wp_kses_hook
2513 | wp_kses_html_error
2514 | wp_kses_js_entities
2515 | wp_kses_named_entities
2516 | wp_kses_no_null
2517 | wp_kses_normalize_entities
2518 | wp_kses_normalize_entities2
2519 | wp_kses_normalize_entities3
2520 | wp_kses_one_attr
2521 | wp_kses_post
2522 | wp_kses_post_deep
2523 | wp_kses_split
2524 | wp_kses_split2
2525 | wp_kses_stripslashes
2526 | wp_kses_version
2527 | wp_link_category_checklist
2528 | wp_link_manager_disabled_message
2529 | wp_link_pages
2530 | wp_list_authors
2531 | wp_list_bookmarks
2532 | wp_list_categories
2533 | wp_list_cats
2534 | wp_list_comments
2535 | wp_list_filter
2536 | wp_list_pages
2537 | wp_list_pluck
2538 | wp_list_post_revisions
2539 | wp_list_sort
2540 | wp_list_widget_controls
2541 | wp_list_widget_controls_dynamic_sidebar
2542 | wp_list_widgets
2543 | wp_load_alloptions
2544 | wp_load_core_site_options
2545 | wp_load_image
2546 | wp_load_press_this
2547 | wp_load_translations_early
2548 | wp_localize_community_events
2549 | wp_localize_jquery_ui_datepicker
2550 | wp_localize_script
2551 | wp_login
2552 | wp_login_form
2553 | wp_login_url
2554 | wp_login_viewport_meta
2555 | wp_loginout
2556 | wp_logout
2557 | wp_logout_url
2558 | wp_lostpassword_url
2559 | wp_magic_quotes
2560 | wp_mail
2561 | wp_maintenance
2562 | wp_make_content_images_responsive
2563 | wp_make_link_relative
2564 | wp_make_plugin_file_tree
2565 | wp_make_theme_file_tree
2566 | wp_map_nav_menu_locations
2567 | wp_map_sidebars_widgets
2568 | wp_match_mime_types
2569 | wp_max_upload_size
2570 | wp_maybe_auto_update
2571 | wp_maybe_clean_new_site_cache_on_update
2572 | wp_maybe_decline_date
2573 | wp_maybe_generate_attachment_metadata
2574 | wp_maybe_grant_install_languages_cap
2575 | wp_maybe_load_embeds
2576 | wp_maybe_load_widgets
2577 | wp_maybe_transition_site_statuses_on_update
2578 | wp_maybe_update_network_site_counts
2579 | wp_maybe_update_network_site_counts_on_update
2580 | wp_maybe_update_network_user_counts
2581 | wp_media_attach_action
2582 | wp_media_insert_url_form
2583 | wp_media_personal_data_exporter
2584 | wp_media_upload_handler
2585 | wp_mediaelement_fallback
2586 | wp_meta
2587 | wp_metadata_lazyloader
2588 | wp_mime_type_icon
2589 | wp_mkdir_p
2590 | wp_nav_menu
2591 | wp_nav_menu_disabled_check
2592 | wp_nav_menu_item_link_meta_box
2593 | wp_nav_menu_item_post_type_meta_box
2594 | wp_nav_menu_item_taxonomy_meta_box
2595 | wp_nav_menu_locations_meta_box
2596 | wp_nav_menu_manage_columns
2597 | wp_nav_menu_max_depth
2598 | wp_nav_menu_post_type_meta_boxes
2599 | wp_nav_menu_setup
2600 | wp_nav_menu_taxonomy_meta_boxes
2601 | wp_nav_menu_update_menu_items
2602 | wp_network_admin_email_change_notification
2603 | wp_network_dashboard_right_now
2604 | wp_new_blog_notification
2605 | wp_new_comment
2606 | wp_new_comment_notify_moderator
2607 | wp_new_comment_notify_postauthor
2608 | wp_new_user_notification
2609 | wp_next_scheduled
2610 | wp_no_robots
2611 | wp_nonce_ays
2612 | wp_nonce_field
2613 | wp_nonce_tick
2614 | wp_nonce_url
2615 | wp_normalize_path
2616 | wp_normalize_site_data
2617 | wp_not_installed
2618 | wp_notify_moderator
2619 | wp_notify_postauthor
2620 | wp_ob_end_flush_all
2621 | wp_oembed_add_discovery_links
2622 | wp_oembed_add_host_js
2623 | wp_oembed_add_provider
2624 | wp_oembed_ensure_format
2625 | wp_oembed_get
2626 | wp_oembed_register_route
2627 | wp_oembed_remove_provider
2628 | wp_old_slug_redirect
2629 | wp_original_referer_field
2630 | wp_page_menu
2631 | wp_page_reload_on_back_button_js
2632 | wp_parse_args
2633 | wp_parse_auth_cookie
2634 | wp_parse_id_list
2635 | wp_parse_slug_list
2636 | wp_parse_str
2637 | wp_parse_url
2638 | wp_password_change_notification
2639 | wp_playlist_scripts
2640 | wp_playlist_shortcode
2641 | wp_plugin_directory_constants
2642 | wp_plugin_update_row
2643 | wp_plugin_update_rows
2644 | wp_plupload_default_settings
2645 | wp_popular_terms_checklist
2646 | wp_post_mime_type_where
2647 | wp_post_preview_js
2648 | wp_post_revision_title
2649 | wp_post_revision_title_expanded
2650 | wp_pre_kses_less_than
2651 | wp_pre_kses_less_than_callback
2652 | wp_preload_dialogs
2653 | wp_prepare_attachment_for_js
2654 | wp_prepare_revisions_for_js
2655 | wp_prepare_site_data
2656 | wp_prepare_themes_for_js
2657 | wp_print_admin_notice_templates
2658 | wp_print_community_events_markup
2659 | wp_print_community_events_templates
2660 | wp_print_editor_js
2661 | wp_print_file_editor_templates
2662 | wp_print_footer_scripts
2663 | wp_print_head_scripts
2664 | wp_print_media_templates
2665 | wp_print_plugin_file_tree
2666 | wp_print_request_filesystem_credentials_modal
2667 | wp_print_revision_templates
2668 | wp_print_scripts
2669 | wp_print_styles
2670 | wp_print_theme_file_tree
2671 | wp_print_update_row_templates
2672 | wp_privacy_anonymize_data
2673 | wp_privacy_anonymize_ip
2674 | wp_privacy_delete_old_export_files
2675 | wp_privacy_exports_dir
2676 | wp_privacy_exports_url
2677 | wp_privacy_generate_personal_data_export_file
2678 | wp_privacy_generate_personal_data_export_group_html
2679 | wp_privacy_process_personal_data_erasure_page
2680 | wp_privacy_process_personal_data_export_page
2681 | wp_privacy_send_personal_data_export_email
2682 | wp_protect_special_option
2683 | wp_prototype_before_jquery
2684 | wp_publish_post
2685 | wp_queue_comments_for_comment_meta_lazyload
2686 | wp_queue_posts_for_term_meta_lazyload
2687 | wp_quicktags
2688 | wp_raise_memory_limit
2689 | wp_rand
2690 | wp_read_audio_metadata
2691 | wp_read_image_metadata
2692 | wp_read_video_metadata
2693 | wp_redirect
2694 | wp_redirect_admin_locations
2695 | wp_referer_field
2696 | wp_refresh_post_lock
2697 | wp_refresh_post_nonces
2698 | wp_register
2699 | wp_register_comment_personal_data_eraser
2700 | wp_register_comment_personal_data_exporter
2701 | wp_register_media_personal_data_exporter
2702 | wp_register_plugin_realpath
2703 | wp_register_script
2704 | wp_register_sidebar_widget
2705 | wp_register_style
2706 | wp_register_user_personal_data_exporter
2707 | wp_register_widget_control
2708 | wp_registration_url
2709 | wp_rel_nofollow
2710 | wp_rel_nofollow_callback
2711 | wp_remote_fopen
2712 | wp_remote_get
2713 | wp_remote_head
2714 | wp_remote_post
2715 | wp_remote_request
2716 | wp_remote_retrieve_body
2717 | wp_remote_retrieve_cookie
2718 | wp_remote_retrieve_cookie_value
2719 | wp_remote_retrieve_cookies
2720 | wp_remote_retrieve_header
2721 | wp_remote_retrieve_headers
2722 | wp_remote_retrieve_response_code
2723 | wp_remote_retrieve_response_message
2724 | wp_removable_query_args
2725 | wp_remove_object_terms
2726 | wp_replace_in_html_tags
2727 | wp_reschedule_event
2728 | wp_reset_postdata
2729 | wp_reset_query
2730 | wp_reset_vars
2731 | wp_resolve_numeric_slug_conflicts
2732 | wp_resource_hints
2733 | wp_restore_image
2734 | wp_restore_post_revision
2735 | wp_revisions_enabled
2736 | wp_revisions_to_keep
2737 | wp_revoke_user
2738 | wp_richedit_pre
2739 | wp_roles
2740 | wp_rss
2741 | wp_safe_redirect
2742 | wp_safe_remote_get
2743 | wp_safe_remote_head
2744 | wp_safe_remote_post
2745 | wp_safe_remote_request
2746 | wp_salt
2747 | wp_sanitize_redirect
2748 | wp_save_image
2749 | wp_save_image_file
2750 | wp_save_nav_menu_items
2751 | wp_save_post_revision
2752 | wp_schedule_delete_old_privacy_export_files
2753 | wp_schedule_event
2754 | wp_schedule_single_event
2755 | wp_schedule_update_checks
2756 | wp_schedule_update_network_counts
2757 | wp_scheduled_delete
2758 | wp_script_add_data
2759 | wp_script_is
2760 | wp_scripts
2761 | wp_send_json
2762 | wp_send_json_error
2763 | wp_send_json_success
2764 | wp_send_new_user_notifications
2765 | wp_send_user_request
2766 | wp_set_all_user_settings
2767 | wp_set_auth_cookie
2768 | wp_set_comment_cookies
2769 | wp_set_comment_status
2770 | wp_set_current_user
2771 | wp_set_internal_encoding
2772 | wp_set_lang_dir
2773 | wp_set_link_cats
2774 | wp_set_object_terms
2775 | wp_set_password
2776 | wp_set_post_categories
2777 | wp_set_post_cats
2778 | wp_set_post_lock
2779 | wp_set_post_tags
2780 | wp_set_post_terms
2781 | wp_set_sidebars_widgets
2782 | wp_set_wpdb_vars
2783 | wp_setcookie
2784 | wp_setup_nav_menu_item
2785 | wp_shake_js
2786 | wp_shortlink_header
2787 | wp_shortlink_wp_head
2788 | wp_should_upgrade_global_tables
2789 | wp_shrink_dimensions
2790 | wp_sidebar_description
2791 | wp_signon
2792 | wp_simplepie_autoload
2793 | wp_site_admin_email_change_notification
2794 | wp_site_icon
2795 | wp_slash
2796 | wp_spaces_regexp
2797 | wp_spam_comment
2798 | wp_specialchars
2799 | wp_specialchars_decode
2800 | wp_sprintf
2801 | wp_sprintf_l
2802 | wp_ssl_constants
2803 | wp_star_rating
2804 | wp_start_object_cache
2805 | wp_start_scraping_edited_file_errors
2806 | wp_staticize_emoji
2807 | wp_staticize_emoji_for_email
2808 | wp_stream_image
2809 | wp_strip_all_tags
2810 | wp_style_add_data
2811 | wp_style_is
2812 | wp_style_loader_src
2813 | wp_styles
2814 | wp_suspend_cache_addition
2815 | wp_suspend_cache_invalidation
2816 | wp_switch_roles_and_user
2817 | wp_tag_cloud
2818 | wp_targeted_link_rel
2819 | wp_targeted_link_rel_callback
2820 | wp_templating_constants
2821 | wp_tempnam
2822 | wp_term_is_shared
2823 | wp_terms_checklist
2824 | wp_text_diff
2825 | wp_theme_update_row
2826 | wp_theme_update_rows
2827 | wp_throttle_comment_flood
2828 | wp_timezone_choice
2829 | wp_timezone_override_offset
2830 | wp_timezone_supported
2831 | wp_tiny_mce
2832 | wp_title
2833 | wp_title_rss
2834 | wp_transition_comment_status
2835 | wp_transition_post_status
2836 | wp_trash_comment
2837 | wp_trash_post
2838 | wp_trash_post_comments
2839 | wp_trim_excerpt
2840 | wp_trim_words
2841 | wp_underscore_audio_template
2842 | wp_underscore_playlist_templates
2843 | wp_underscore_video_template
2844 | wp_unique_filename
2845 | wp_unique_post_slug
2846 | wp_unique_term_slug
2847 | wp_unregister_globals
2848 | wp_unregister_sidebar_widget
2849 | wp_unregister_widget_control
2850 | wp_unschedule_event
2851 | wp_unschedule_hook
2852 | wp_unslash
2853 | wp_unspam_comment
2854 | wp_untrash_comment
2855 | wp_untrash_post
2856 | wp_untrash_post_comments
2857 | wp_update_attachment_metadata
2858 | wp_update_blog_public_option_on_site_update
2859 | wp_update_category
2860 | wp_update_comment
2861 | wp_update_comment_count
2862 | wp_update_comment_count_now
2863 | wp_update_core
2864 | wp_update_custom_css_post
2865 | wp_update_link
2866 | wp_update_nav_menu_item
2867 | wp_update_nav_menu_object
2868 | wp_update_network_counts
2869 | wp_update_network_site_counts
2870 | wp_update_network_user_counts
2871 | wp_update_plugin
2872 | wp_update_plugins
2873 | wp_update_post
2874 | wp_update_site
2875 | wp_update_term
2876 | wp_update_term_count
2877 | wp_update_term_count_now
2878 | wp_update_theme
2879 | wp_update_themes
2880 | wp_update_user
2881 | wp_upgrade
2882 | wp_upload_bits
2883 | wp_upload_dir
2884 | wp_user_personal_data_exporter
2885 | wp_user_request_action_description
2886 | wp_user_settings
2887 | wp_using_ext_object_cache
2888 | wp_validate_auth_cookie
2889 | wp_validate_boolean
2890 | wp_validate_logged_in_cookie
2891 | wp_validate_redirect
2892 | wp_validate_site_data
2893 | wp_validate_user_request_key
2894 | wp_verify_nonce
2895 | wp_version_check
2896 | wp_video_shortcode
2897 | wp_welcome_panel
2898 | wp_widget_control
2899 | wp_widget_description
2900 | wp_widget_rss_form
2901 | wp_widget_rss_output
2902 | wp_widget_rss_process
2903 | wp_widgets_access_body_class
2904 | wp_widgets_add_menu
2905 | wp_widgets_init
2906 | wp_write_post
2907 | wpautop
2908 | wpmu_activate_signup
2909 | wpmu_activate_stylesheet
2910 | wpmu_admin_do_redirect
2911 | wpmu_admin_redirect_add_updated_param
2912 | wpmu_checkavailablespace
2913 | wpmu_create_blog
2914 | wpmu_create_user
2915 | wpmu_current_site
2916 | wpmu_delete_blog
2917 | wpmu_delete_user
2918 | wpmu_get_blog_allowedthemes
2919 | wpmu_log_new_registrations
2920 | wpmu_menu
2921 | wpmu_signup_blog
2922 | wpmu_signup_blog_notification
2923 | wpmu_signup_stylesheet
2924 | wpmu_signup_user
2925 | wpmu_signup_user_notification
2926 | wpmu_update_blogs_date
2927 | wpmu_validate_blog_signup
2928 | wpmu_validate_user_signup
2929 | wpmu_welcome_notification
2930 | wpmu_welcome_user_notification
2931 | wptexturize
2932 | wptexturize_primes
2933 | wpview_media_sandbox_styles
2934 | write_post
2935 | xfn_check
2936 | xmlrpc_getpostcategory
2937 | xmlrpc_getposttitle
2938 | xmlrpc_pingback_error
2939 | xmlrpc_removepostdata
2940 | zeroise
2941 | ENDPATTERNS;
2942 | 		return explode("\n", $allFunctions);
2943 | 	}
2944 | 
2945 | 	private static function getWordPressConstants(): array {
2946 | 		// from https://api.wpseek.com/1.1/wordpress/constants.json
2947 | 		$allConstants = <<< ENDPATTERNS
2948 | ABSPATH
2949 | ADMIN_COOKIE_PATH
2950 | AKISMET_DELETE_LIMIT
2951 | AKISMET_VERSION
2952 | AKISMET__MINIMUM_WP_VERSION
2953 | AKISMET__PLUGIN_DIR
2954 | ARRAY_A
2955 | ARRAY_N
2956 | ATOM
2957 | AUTH_COOKIE
2958 | AUTH_KEY
2959 | AUTH_SALT
2960 | AUTOSAVE_INTERVAL
2961 | BACKGROUND_COLOR
2962 | BACKGROUND_IMAGE
2963 | BLOGUPLOADDIR
2964 | COMMENTS_TEMPLATE
2965 | COOKIEHASH
2966 | COOKIEPATH
2967 | COOKIE_DOMAIN
2968 | CRLF
2969 | CUSTOM_TAGS
2970 | DAY_IN_SECONDS
2971 | DB_CHARSET
2972 | DB_COLLATE
2973 | DB_HOST
2974 | DB_NAME
2975 | DB_PASSWORD
2976 | DB_USER
2977 | DOING_AJAX
2978 | DOING_AUTOSAVE
2979 | DOING_CRON
2980 | EBML_ID_ASPECTRATIOTYPE
2981 | EBML_ID_ATTACHEDFILE
2982 | EBML_ID_ATTACHMENTLINK
2983 | EBML_ID_ATTACHMENTS
2984 | EBML_ID_AUDIO
2985 | EBML_ID_BITDEPTH
2986 | EBML_ID_CHANNELPOSITIONS
2987 | EBML_ID_CHANNELS
2988 | EBML_ID_CHAPCOUNTRY
2989 | EBML_ID_CHAPLANGUAGE
2990 | EBML_ID_CHAPPROCESS
2991 | EBML_ID_CHAPPROCESSCODECID
2992 | EBML_ID_CHAPPROCESSCOMMAND
2993 | EBML_ID_CHAPPROCESSDATA
2994 | EBML_ID_CHAPPROCESSPRIVATE
2995 | EBML_ID_CHAPPROCESSTIME
2996 | EBML_ID_CHAPSTRING
2997 | EBML_ID_CHAPTERATOM
2998 | EBML_ID_CHAPTERDISPLAY
2999 | EBML_ID_CHAPTERFLAGENABLED
3000 | EBML_ID_CHAPTERFLAGHIDDEN
3001 | EBML_ID_CHAPTERPHYSICALEQUIV
3002 | EBML_ID_CHAPTERS
3003 | EBML_ID_CHAPTERSEGMENTEDITIONUID
3004 | EBML_ID_CHAPTERSEGMENTUID
3005 | EBML_ID_CHAPTERTIMEEND
3006 | EBML_ID_CHAPTERTIMESTART
3007 | EBML_ID_CHAPTERTRACK
3008 | EBML_ID_CHAPTERTRACKNUMBER
3009 | EBML_ID_CHAPTERTRANSLATE
3010 | EBML_ID_CHAPTERTRANSLATECODEC
3011 | EBML_ID_CHAPTERTRANSLATEEDITIONUID
3012 | EBML_ID_CHAPTERTRANSLATEID
3013 | EBML_ID_CHAPTERUID
3014 | EBML_ID_CLUSTER
3015 | EBML_ID_CLUSTERBLOCK
3016 | EBML_ID_CLUSTERBLOCKADDID
3017 | EBML_ID_CLUSTERBLOCKADDITIONAL
3018 | EBML_ID_CLUSTERBLOCKADDITIONID
3019 | EBML_ID_CLUSTERBLOCKADDITIONS
3020 | EBML_ID_CLUSTERBLOCKDURATION
3021 | EBML_ID_CLUSTERBLOCKGROUP
3022 | EBML_ID_CLUSTERBLOCKMORE
3023 | EBML_ID_CLUSTERBLOCKVIRTUAL
3024 | EBML_ID_CLUSTERCODECSTATE
3025 | EBML_ID_CLUSTERDELAY
3026 | EBML_ID_CLUSTERDURATION
3027 | EBML_ID_CLUSTERENCRYPTEDBLOCK
3028 | EBML_ID_CLUSTERFRAMENUMBER
3029 | EBML_ID_CLUSTERLACENUMBER
3030 | EBML_ID_CLUSTERPOSITION
3031 | EBML_ID_CLUSTERPREVSIZE
3032 | EBML_ID_CLUSTERREFERENCEBLOCK
3033 | EBML_ID_CLUSTERREFERENCEPRIORITY
3034 | EBML_ID_CLUSTERREFERENCEVIRTUAL
3035 | EBML_ID_CLUSTERSILENTTRACKNUMBER
3036 | EBML_ID_CLUSTERSILENTTRACKS
3037 | EBML_ID_CLUSTERSIMPLEBLOCK
3038 | EBML_ID_CLUSTERSLICES
3039 | EBML_ID_CLUSTERTIMECODE
3040 | EBML_ID_CLUSTERTIMESLICE
3041 | EBML_ID_CODECDECODEALL
3042 | EBML_ID_CODECDOWNLOADURL
3043 | EBML_ID_CODECID
3044 | EBML_ID_CODECINFOURL
3045 | EBML_ID_CODECNAME
3046 | EBML_ID_CODECPRIVATE
3047 | EBML_ID_CODECSETTINGS
3048 | EBML_ID_COLOURSPACE
3049 | EBML_ID_CONTENTCOMPALGO
3050 | EBML_ID_CONTENTCOMPRESSION
3051 | EBML_ID_CONTENTCOMPSETTINGS
3052 | EBML_ID_CONTENTENCALGO
3053 | EBML_ID_CONTENTENCKEYID
3054 | EBML_ID_CONTENTENCODING
3055 | EBML_ID_CONTENTENCODINGORDER
3056 | EBML_ID_CONTENTENCODINGS
3057 | EBML_ID_CONTENTENCODINGSCOPE
3058 | EBML_ID_CONTENTENCODINGTYPE
3059 | EBML_ID_CONTENTENCRYPTION
3060 | EBML_ID_CONTENTSIGALGO
3061 | EBML_ID_CONTENTSIGHASHALGO
3062 | EBML_ID_CONTENTSIGKEYID
3063 | EBML_ID_CONTENTSIGNATURE
3064 | EBML_ID_CRC32
3065 | EBML_ID_CUEBLOCKNUMBER
3066 | EBML_ID_CUECLUSTERPOSITION
3067 | EBML_ID_CUECODECSTATE
3068 | EBML_ID_CUEPOINT
3069 | EBML_ID_CUEREFCLUSTER
3070 | EBML_ID_CUEREFCODECSTATE
3071 | EBML_ID_CUEREFERENCE
3072 | EBML_ID_CUEREFNUMBER
3073 | EBML_ID_CUEREFTIME
3074 | EBML_ID_CUES
3075 | EBML_ID_CUETIME
3076 | EBML_ID_CUETRACK
3077 | EBML_ID_CUETRACKPOSITIONS
3078 | EBML_ID_DATEUTC
3079 | EBML_ID_DEFAULTDURATION
3080 | EBML_ID_DISPLAYHEIGHT
3081 | EBML_ID_DISPLAYUNIT
3082 | EBML_ID_DISPLAYWIDTH
3083 | EBML_ID_DOCTYPE
3084 | EBML_ID_DOCTYPEREADVERSION
3085 | EBML_ID_DOCTYPEVERSION
3086 | EBML_ID_DURATION
3087 | EBML_ID_EBML
3088 | EBML_ID_EBMLMAXIDLENGTH
3089 | EBML_ID_EBMLMAXSIZELENGTH
3090 | EBML_ID_EBMLREADVERSION
3091 | EBML_ID_EBMLVERSION
3092 | EBML_ID_EDITIONENTRY
3093 | EBML_ID_EDITIONFLAGDEFAULT
3094 | EBML_ID_EDITIONFLAGHIDDEN
3095 | EBML_ID_EDITIONFLAGORDERED
3096 | EBML_ID_EDITIONUID
3097 | EBML_ID_FILEDATA
3098 | EBML_ID_FILEDESCRIPTION
3099 | EBML_ID_FILEMIMETYPE
3100 | EBML_ID_FILENAME
3101 | EBML_ID_FILEREFERRAL
3102 | EBML_ID_FILEUID
3103 | EBML_ID_FLAGDEFAULT
3104 | EBML_ID_FLAGENABLED
3105 | EBML_ID_FLAGFORCED
3106 | EBML_ID_FLAGINTERLACED
3107 | EBML_ID_FLAGLACING
3108 | EBML_ID_GAMMAVALUE
3109 | EBML_ID_INFO
3110 | EBML_ID_LANGUAGE
3111 | EBML_ID_MAXBLOCKADDITIONID
3112 | EBML_ID_MAXCACHE
3113 | EBML_ID_MINCACHE
3114 | EBML_ID_MUXINGAPP
3115 | EBML_ID_NAME
3116 | EBML_ID_NEXTFILENAME
3117 | EBML_ID_NEXTUID
3118 | EBML_ID_OLDSTEREOMODE
3119 | EBML_ID_OUTPUTSAMPLINGFREQUENCY
3120 | EBML_ID_PIXELCROPBOTTOM
3121 | EBML_ID_PIXELCROPLEFT
3122 | EBML_ID_PIXELCROPRIGHT
3123 | EBML_ID_PIXELCROPTOP
3124 | EBML_ID_PIXELHEIGHT
3125 | EBML_ID_PIXELWIDTH
3126 | EBML_ID_PREVFILENAME
3127 | EBML_ID_PREVUID
3128 | EBML_ID_SAMPLINGFREQUENCY
3129 | EBML_ID_SEEK
3130 | EBML_ID_SEEKHEAD
3131 | EBML_ID_SEEKID
3132 | EBML_ID_SEEKPOSITION
3133 | EBML_ID_SEGMENT
3134 | EBML_ID_SEGMENTFAMILY
3135 | EBML_ID_SEGMENTFILENAME
3136 | EBML_ID_SEGMENTUID
3137 | EBML_ID_SIMPLETAG
3138 | EBML_ID_STEREOMODE
3139 | EBML_ID_TAG
3140 | EBML_ID_TAGATTACHMENTUID
3141 | EBML_ID_TAGBINARY
3142 | EBML_ID_TAGCHAPTERUID
3143 | EBML_ID_TAGDEFAULT
3144 | EBML_ID_TAGEDITIONUID
3145 | EBML_ID_TAGLANGUAGE
3146 | EBML_ID_TAGNAME
3147 | EBML_ID_TAGS
3148 | EBML_ID_TAGSTRING
3149 | EBML_ID_TAGTRACKUID
3150 | EBML_ID_TARGETS
3151 | EBML_ID_TARGETTYPE
3152 | EBML_ID_TARGETTYPEVALUE
3153 | EBML_ID_TIMECODESCALE
3154 | EBML_ID_TITLE
3155 | EBML_ID_TRACKENTRY
3156 | EBML_ID_TRACKNUMBER
3157 | EBML_ID_TRACKOFFSET
3158 | EBML_ID_TRACKOVERLAY
3159 | EBML_ID_TRACKS
3160 | EBML_ID_TRACKTIMECODESCALE
3161 | EBML_ID_TRACKTRANSLATE
3162 | EBML_ID_TRACKTRANSLATECODEC
3163 | EBML_ID_TRACKTRANSLATEEDITIONUID
3164 | EBML_ID_TRACKTRANSLATETRACKID
3165 | EBML_ID_TRACKTYPE
3166 | EBML_ID_TRACKUID
3167 | EBML_ID_VIDEO
3168 | EBML_ID_VOID
3169 | EBML_ID_WRITINGAPP
3170 | EMPTY_TRASH_DAYS
3171 | ENT_SUBSTITUTE
3172 | EP_ALL
3173 | EP_ALL_ARCHIVES
3174 | EP_ATTACHMENT
3175 | EP_AUTHORS
3176 | EP_CATEGORIES
3177 | EP_COMMENTS
3178 | EP_DATE
3179 | EP_DAY
3180 | EP_MONTH
3181 | EP_NONE
3182 | EP_PAGES
3183 | EP_PERMALINK
3184 | EP_ROOT
3185 | EP_SEARCH
3186 | EP_TAGS
3187 | EP_YEAR
3188 | EZSQL_VERSION
3189 | FORCE_SSL_ADMIN
3190 | FS_CHMOD_DIR
3191 | FS_CHMOD_FILE
3192 | FS_CONNECT_TIMEOUT
3193 | FS_TIMEOUT
3194 | FTP_ASCII
3195 | FTP_AUTOASCII
3196 | FTP_BINARY
3197 | FTP_FORCE
3198 | FTP_OS_MAC
3199 | FTP_OS_UNIX
3200 | FTP_OS_WINDOWS
3201 | GB_IN_BYTES
3202 | GETID3_FLV_TAG_AUDIO
3203 | GETID3_FLV_TAG_META
3204 | GETID3_FLV_TAG_VIDEO
3205 | GETID3_FLV_VIDEO_H263
3206 | GETID3_FLV_VIDEO_H264
3207 | GETID3_FLV_VIDEO_SCREEN
3208 | GETID3_FLV_VIDEO_SCREENV2
3209 | GETID3_FLV_VIDEO_VP6FLV
3210 | GETID3_FLV_VIDEO_VP6FLV_ALPHA
3211 | GETID3_HELPERAPPSDIR
3212 | GETID3_INCLUDEPATH
3213 | GETID3_MP3_VALID_CHECK_FRAMES
3214 | GETID3_OS_ISWINDOWS
3215 | GETID3_TEMP_DIR
3216 | H264_AVC_SEQUENCE_HEADER
3217 | H264_PROFILE_BASELINE
3218 | H264_PROFILE_EXTENDED
3219 | H264_PROFILE_HIGH
3220 | H264_PROFILE_HIGH10
3221 | H264_PROFILE_HIGH422
3222 | H264_PROFILE_HIGH444
3223 | H264_PROFILE_HIGH444_PREDICTIVE
3224 | H264_PROFILE_MAIN
3225 | HEADER_IMAGE
3226 | HEADER_IMAGE_HEIGHT
3227 | HEADER_IMAGE_WIDTH
3228 | HEADER_TEXTCOLOR
3229 | HOUR_IN_SECONDS
3230 | IFRAME_REQUEST
3231 | IMG_JPG
3232 | IS_PROFILE_PAGE
3233 | JSON_PRETTY_PRINT
3234 | KB_IN_BYTES
3235 | LANGDIR
3236 | LOGGED_IN_COOKIE
3237 | LOGGED_IN_KEY
3238 | LOGGED_IN_SALT
3239 | MAGPIE_CACHE_AGE
3240 | MAGPIE_CACHE_DIR
3241 | MAGPIE_CACHE_FRESH_ONLY
3242 | MAGPIE_CACHE_ON
3243 | MAGPIE_DEBUG
3244 | MAGPIE_FETCH_TIME_OUT
3245 | MAGPIE_INITALIZED
3246 | MAGPIE_USER_AGENT
3247 | MAGPIE_USE_GZIP
3248 | MB_IN_BYTES
3249 | MEDIA_TRASH
3250 | MINUTE_IN_SECONDS
3251 | MONTH_IN_SECONDS
3252 | MULTISITE
3253 | MUPLUGINDIR
3254 | NONCE_KEY
3255 | NONCE_SALT
3256 | NO_HEADER_TEXT
3257 | OBJECT
3258 | OBJECT_K
3259 | PASS_COOKIE
3260 | PCLZIP_ATT_FILE_COMMENT
3261 | PCLZIP_ATT_FILE_CONTENT
3262 | PCLZIP_ATT_FILE_MTIME
3263 | PCLZIP_ATT_FILE_NAME
3264 | PCLZIP_ATT_FILE_NEW_FULL_NAME
3265 | PCLZIP_ATT_FILE_NEW_SHORT_NAME
3266 | PCLZIP_CB_POST_ADD
3267 | PCLZIP_CB_POST_EXTRACT
3268 | PCLZIP_CB_PRE_ADD
3269 | PCLZIP_CB_PRE_EXTRACT
3270 | PCLZIP_ERROR_EXTERNAL
3271 | PCLZIP_ERR_ALREADY_A_DIRECTORY
3272 | PCLZIP_ERR_BAD_CHECKSUM
3273 | PCLZIP_ERR_BAD_EXTENSION
3274 | PCLZIP_ERR_BAD_EXTRACTED_FILE
3275 | PCLZIP_ERR_BAD_FORMAT
3276 | PCLZIP_ERR_DELETE_FILE_FAIL
3277 | PCLZIP_ERR_DIRECTORY_RESTRICTION
3278 | PCLZIP_ERR_DIR_CREATE_FAIL
3279 | PCLZIP_ERR_FILENAME_TOO_LONG
3280 | PCLZIP_ERR_INVALID_ARCHIVE_ZIP
3281 | PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE
3282 | PCLZIP_ERR_INVALID_OPTION_VALUE
3283 | PCLZIP_ERR_INVALID_PARAMETER
3284 | PCLZIP_ERR_INVALID_ZIP
3285 | PCLZIP_ERR_MISSING_FILE
3286 | PCLZIP_ERR_MISSING_OPTION_VALUE
3287 | PCLZIP_ERR_NO_ERROR
3288 | PCLZIP_ERR_READ_OPEN_FAIL
3289 | PCLZIP_ERR_RENAME_FILE_FAIL
3290 | PCLZIP_ERR_UNSUPPORTED_COMPRESSION
3291 | PCLZIP_ERR_UNSUPPORTED_ENCRYPTION
3292 | PCLZIP_ERR_USER_ABORTED
3293 | PCLZIP_ERR_WRITE_OPEN_FAIL
3294 | PCLZIP_OPT_ADD_COMMENT
3295 | PCLZIP_OPT_ADD_PATH
3296 | PCLZIP_OPT_ADD_TEMP_FILE_OFF
3297 | PCLZIP_OPT_ADD_TEMP_FILE_ON
3298 | PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD
3299 | PCLZIP_OPT_BY_EREG
3300 | PCLZIP_OPT_BY_INDEX
3301 | PCLZIP_OPT_BY_NAME
3302 | PCLZIP_OPT_BY_PREG
3303 | PCLZIP_OPT_COMMENT
3304 | PCLZIP_OPT_EXTRACT_AS_STRING
3305 | PCLZIP_OPT_EXTRACT_DIR_RESTRICTION
3306 | PCLZIP_OPT_EXTRACT_IN_OUTPUT
3307 | PCLZIP_OPT_NO_COMPRESSION
3308 | PCLZIP_OPT_PATH
3309 | PCLZIP_OPT_PREPEND_COMMENT
3310 | PCLZIP_OPT_REMOVE_ALL_PATH
3311 | PCLZIP_OPT_REMOVE_PATH
3312 | PCLZIP_OPT_REPLACE_NEWER
3313 | PCLZIP_OPT_SET_CHMOD
3314 | PCLZIP_OPT_STOP_ON_ERROR
3315 | PCLZIP_OPT_TEMP_FILE_OFF
3316 | PCLZIP_OPT_TEMP_FILE_ON
3317 | PCLZIP_OPT_TEMP_FILE_THRESHOLD
3318 | PCLZIP_READ_BLOCK_SIZE
3319 | PCLZIP_SEPARATOR
3320 | PCLZIP_TEMPORARY_DIR
3321 | PCLZIP_TEMPORARY_FILE_RATIO
3322 | PHP_INT_MIN
3323 | PHP_VERSION_ID
3324 | PLUGINDIR
3325 | PLUGINS_COOKIE_PATH
3326 | PO_MAX_LINE_LEN
3327 | RANDOM_COMPAT_READ_BUFFER
3328 | REST_API_VERSION
3329 | REST_REQUEST
3330 | RSS
3331 | SCRIPT_DEBUG
3332 | SECURE_AUTH_COOKIE
3333 | SECURE_AUTH_KEY
3334 | SECURE_AUTH_SALT
3335 | SERVICES_JSON_IN_ARR
3336 | SERVICES_JSON_IN_CMT
3337 | SERVICES_JSON_IN_OBJ
3338 | SERVICES_JSON_IN_STR
3339 | SERVICES_JSON_LOOSE_TYPE
3340 | SERVICES_JSON_SLICE
3341 | SERVICES_JSON_SUPPRESS_ERRORS
3342 | SERVICES_JSON_USE_TO_JSON
3343 | SHORTINIT
3344 | SIMPLEPIE_BUILD
3345 | SIMPLEPIE_CONSTRUCT_ALL
3346 | SIMPLEPIE_CONSTRUCT_BASE64
3347 | SIMPLEPIE_CONSTRUCT_HTML
3348 | SIMPLEPIE_CONSTRUCT_IRI
3349 | SIMPLEPIE_CONSTRUCT_MAYBE_HTML
3350 | SIMPLEPIE_CONSTRUCT_NONE
3351 | SIMPLEPIE_CONSTRUCT_TEXT
3352 | SIMPLEPIE_CONSTRUCT_XHTML
3353 | SIMPLEPIE_FILE_SOURCE_CURL
3354 | SIMPLEPIE_FILE_SOURCE_FILE_GET_CONTENTS
3355 | SIMPLEPIE_FILE_SOURCE_FSOCKOPEN
3356 | SIMPLEPIE_FILE_SOURCE_LOCAL
3357 | SIMPLEPIE_FILE_SOURCE_NONE
3358 | SIMPLEPIE_FILE_SOURCE_REMOTE
3359 | SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY
3360 | SIMPLEPIE_LINKBACK
3361 | SIMPLEPIE_LOCATOR_ALL
3362 | SIMPLEPIE_LOCATOR_AUTODISCOVERY
3363 | SIMPLEPIE_LOCATOR_LOCAL_BODY
3364 | SIMPLEPIE_LOCATOR_LOCAL_EXTENSION
3365 | SIMPLEPIE_LOCATOR_NONE
3366 | SIMPLEPIE_LOCATOR_REMOTE_BODY
3367 | SIMPLEPIE_LOCATOR_REMOTE_EXTENSION
3368 | SIMPLEPIE_LOWERCASE
3369 | SIMPLEPIE_NAME
3370 | SIMPLEPIE_NAMESPACE_ATOM_03
3371 | SIMPLEPIE_NAMESPACE_ATOM_10
3372 | SIMPLEPIE_NAMESPACE_DC_10
3373 | SIMPLEPIE_NAMESPACE_DC_11
3374 | SIMPLEPIE_NAMESPACE_GEORSS
3375 | SIMPLEPIE_NAMESPACE_ITUNES
3376 | SIMPLEPIE_NAMESPACE_MEDIARSS
3377 | SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG
3378 | SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG2
3379 | SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG3
3380 | SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG4
3381 | SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG5
3382 | SIMPLEPIE_NAMESPACE_RDF
3383 | SIMPLEPIE_NAMESPACE_RSS_090
3384 | SIMPLEPIE_NAMESPACE_RSS_10
3385 | SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT
3386 | SIMPLEPIE_NAMESPACE_RSS_20
3387 | SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO
3388 | SIMPLEPIE_NAMESPACE_XHTML
3389 | SIMPLEPIE_NAMESPACE_XML
3390 | SIMPLEPIE_PCRE_HTML_ATTRIBUTE
3391 | SIMPLEPIE_PCRE_XML_ATTRIBUTE
3392 | SIMPLEPIE_SAME_CASE
3393 | SIMPLEPIE_TYPE_ALL
3394 | SIMPLEPIE_TYPE_ATOM_03
3395 | SIMPLEPIE_TYPE_ATOM_10
3396 | SIMPLEPIE_TYPE_ATOM_ALL
3397 | SIMPLEPIE_TYPE_NONE
3398 | SIMPLEPIE_TYPE_RSS_090
3399 | SIMPLEPIE_TYPE_RSS_091
3400 | SIMPLEPIE_TYPE_RSS_091_NETSCAPE
3401 | SIMPLEPIE_TYPE_RSS_091_USERLAND
3402 | SIMPLEPIE_TYPE_RSS_092
3403 | SIMPLEPIE_TYPE_RSS_093
3404 | SIMPLEPIE_TYPE_RSS_094
3405 | SIMPLEPIE_TYPE_RSS_10
3406 | SIMPLEPIE_TYPE_RSS_20
3407 | SIMPLEPIE_TYPE_RSS_ALL
3408 | SIMPLEPIE_TYPE_RSS_RDF
3409 | SIMPLEPIE_TYPE_RSS_SYNDICATION
3410 | SIMPLEPIE_UPPERCASE
3411 | SIMPLEPIE_URL
3412 | SIMPLEPIE_USERAGENT
3413 | SIMPLEPIE_VERSION
3414 | SITECOOKIEPATH
3415 | STYLESHEETPATH
3416 | SUBDOMAIN_INSTALL
3417 | TB_IN_BYTES
3418 | TEMPLATEPATH
3419 | TEST_COOKIE
3420 | UPLOADBLOGSDIR
3421 | UPLOADS
3422 | USER_COOKIE
3423 | VHOST
3424 | WEEK_IN_SECONDS
3425 | WPINC
3426 | WPMU_ACCEL_REDIRECT
3427 | WPMU_PLUGIN_DIR
3428 | WPMU_PLUGIN_URL
3429 | WPMU_SENDFILE
3430 | WP_ADMIN
3431 | WP_BLOG_ADMIN
3432 | WP_CACHE
3433 | WP_CONTENT_DIR
3434 | WP_CONTENT_URL
3435 | WP_CRON_LOCK_TIMEOUT
3436 | WP_DEBUG
3437 | WP_DEBUG_DISPLAY
3438 | WP_DEBUG_LOG
3439 | WP_DEFAULT_THEME
3440 | WP_FEATURE_BETTER_PASSWORDS
3441 | WP_IMPORTING
3442 | WP_INSTALLING
3443 | WP_INSTALLING_NETWORK
3444 | WP_JSON_SERIALIZE_COMPATIBLE
3445 | WP_LANG_DIR
3446 | WP_LOAD_IMPORTERS
3447 | WP_MAIL_INTERVAL
3448 | WP_MAX_MEMORY_LIMIT
3449 | WP_MEMORY_LIMIT
3450 | WP_NETWORK_ADMIN
3451 | WP_PLUGIN_DIR
3452 | WP_PLUGIN_URL
3453 | WP_POST_REVISIONS
3454 | WP_REPAIRING
3455 | WP_SETUP_CONFIG
3456 | WP_UNINSTALL_PLUGIN
3457 | WP_USER_ADMIN
3458 | WP_USE_THEMES
3459 | WXR_VERSION
3460 | XMLRPC_REQUEST
3461 | YEAR_IN_SECONDS
3462 | ENDPATTERNS;
3463 | 		return explode("\n", $allConstants);
3464 | 	}
3465 | }
3466 | 


--------------------------------------------------------------------------------