Created
August 12, 2020 20:47
-
-
Save pauloagrillo/d89c34ce87f72a348929c4cb1cde48ab to your computer and use it in GitHub Desktop.
Arquivo de Configuração do Phan - Curso Alura
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<?php | |
declare(strict_types=1); | |
use Phan\Issue; | |
/** | |
* This configuration will be read and overlaid on top of the | |
* default configuration. Command line arguments will be applied | |
* after this file is read. | |
* | |
* @see src/Phan/Config.php | |
* See Config for all configurable options. | |
* | |
* A Note About Paths | |
* ================== | |
* | |
* Files referenced from this file should be defined as | |
* | |
* ``` | |
* Config::projectPath('relative_path/to/file') | |
* ``` | |
* | |
* where the relative path is relative to the root of the | |
* project which is defined as either the working directory | |
* of the phan executable or a path passed in via the CLI | |
* '-d' flag. | |
*/ | |
return [ | |
// Supported values: `'5.6'`, `'7.0'`, `'7.1'`, `'7.2'`, `'7.3'`, `'7.4'`, `null`. | |
// If this is set to `null`, | |
// then Phan assumes the PHP version which is closest to the minor version | |
// of the php executable used to execute Phan. | |
// | |
// Note that the **only** effect of choosing `'5.6'` is to infer that functions removed in php 7.0 exist. | |
// (See `backward_compatibility_checks` for additional options) | |
'target_php_version' => '7.1', | |
// Default: true. If this is set to true, | |
// and target_php_version is newer than the version used to run Phan, | |
// Phan will act as though functions added in newer PHP versions exist. | |
// | |
// NOTE: Currently, this only affects Closure::fromCallable | |
'pretend_newer_core_functions_exist' => true, | |
// If true, missing properties will be created when | |
// they are first seen. If false, we'll report an | |
// error message. | |
'allow_missing_properties' => false, | |
// Allow null to be cast as any type and for any | |
// type to be cast to null. | |
'null_casts_as_any_type' => false, | |
// Allow null to be cast as any array-like type | |
// This is an incremental step in migrating away from null_casts_as_any_type. | |
// If null_casts_as_any_type is true, this has no effect. | |
'null_casts_as_array' => false, | |
// Allow any array-like type to be cast to null. | |
// This is an incremental step in migrating away from null_casts_as_any_type. | |
// If null_casts_as_any_type is true, this has no effect. | |
'array_casts_as_null' => false, | |
// If enabled, Phan will warn if **any** type in a method's object expression | |
// is definitely not an object, | |
// or if **any** type in an invoked expression is not a callable. | |
// Setting this to true will introduce numerous false positives | |
// (and reveal some bugs). | |
'strict_method_checking' => true, | |
// If enabled, Phan will warn if **any** type in the argument's type | |
// cannot be cast to a type in the parameter's expected type. | |
// Setting this to true will introduce a large number of false positives (and some bugs). | |
// (For self-analysis, Phan has a large number of suppressions and file-level suppressions, due to \ast\Node being difficult to type check) | |
'strict_param_checking' => true, | |
// If enabled, Phan will warn if **any** type in a property assignment's type | |
// cannot be cast to a type in the property's expected type. | |
// Setting this to true will introduce a large number of false positives (and some bugs). | |
// (For self-analysis, Phan has a large number of suppressions and file-level suppressions, due to \ast\Node being difficult to type check) | |
'strict_property_checking' => true, | |
// If enabled, Phan will warn if **any** type in the return statement's union type | |
// cannot be cast to a type in the method's declared return type. | |
// Setting this to true will introduce a large number of false positives (and some bugs). | |
// (For self-analysis, Phan has a large number of suppressions and file-level suppressions, due to \ast\Node being difficult to type check) | |
'strict_return_checking' => true, | |
// If enabled, Phan will warn if **any** type of the object expression for a property access | |
// does not contain that property. | |
'strict_object_checking' => true, | |
// If enabled, scalars (int, float, bool, string, null) | |
// are treated as if they can cast to each other. | |
// This does not affect checks of array keys. See scalar_array_key_cast. | |
'scalar_implicit_cast' => false, | |
// If enabled, any scalar array keys (int, string) | |
// are treated as if they can cast to each other. | |
// E.g. array<int,stdClass> can cast to array<string,stdClass> and vice versa. | |
// Normally, a scalar type such as int could only cast to/from int and mixed. | |
'scalar_array_key_cast' => false, | |
// If this has entries, scalars (int, float, bool, string, null) | |
// are allowed to perform the casts listed. | |
// E.g. ['int' => ['float', 'string'], 'float' => ['int'], 'string' => ['int'], 'null' => ['string']] | |
// allows casting null to a string, but not vice versa. | |
// (subset of scalar_implicit_cast) | |
'scalar_implicit_partial' => [], | |
// If true, Phan will convert the type of a possibly undefined array offset to the nullable, defined equivalent. | |
// If false, Phan will convert the type of a possibly undefined array offset to the defined equivalent (without converting to nullable). | |
'convert_possibly_undefined_offset_to_nullable' => false, | |
// If true, seemingly undeclared variables in the global | |
// scope will be ignored. This is useful for projects | |
// with complicated cross-file globals that you have no | |
// hope of fixing. | |
'ignore_undeclared_variables_in_global_scope' => false, | |
// Backwards Compatibility Checking (This is very slow) | |
'backward_compatibility_checks' => false, | |
// If true, check to make sure the return type declared | |
// in the doc-block (if any) matches the return type | |
// declared in the method signature. This process is | |
// slow. | |
'check_docblock_signature_return_type_match' => true, | |
// If true, check to make sure the param types declared | |
// in the doc-block (if any) matches the param types | |
// declared in the method signature. | |
'check_docblock_signature_param_type_match' => true, | |
// (*Requires check_docblock_signature_param_type_match to be true*) | |
// If true, make narrowed types from phpdoc params override | |
// the real types from the signature, when real types exist. | |
// (E.g. allows specifying desired lists of subclasses, | |
// or to indicate a preference for non-nullable types over nullable types) | |
// Affects analysis of the body of the method and the param types passed in by callers. | |
'prefer_narrowed_phpdoc_param_type' => true, | |
// (*Requires check_docblock_signature_return_type_match to be true*) | |
// If true, make narrowed types from phpdoc returns override | |
// the real types from the signature, when real types exist. | |
// (E.g. allows specifying desired lists of subclasses, | |
// or to indicate a preference for non-nullable types over nullable types) | |
// Affects analysis of return statements in the body of the method and the return types passed in by callers. | |
'prefer_narrowed_phpdoc_return_type' => true, | |
// If enabled, check all methods that override a | |
// parent method to make sure its signature is | |
// compatible with the parent's. This check | |
// can add quite a bit of time to the analysis. | |
// This will also check if final methods are overridden, etc. | |
'analyze_signature_compatibility' => true, | |
// Set this to true to allow contravariance in real parameter types of method overrides (Introduced in php 7.2) | |
// See https://secure.php.net/manual/en/migration72.new-features.php#migration72.new-features.param-type-widening | |
// (Users may enable this if analyzing projects that support only php 7.2+) | |
// This is false by default. (Will warn if real parameter types are omitted in an override) | |
'allow_method_param_type_widening' => false, | |
// Set this to true to make Phan guess that undocumented parameter types | |
// (for optional parameters) have the same type as default values | |
// (Instead of combining that type with `mixed`). | |
// E.g. `function($x = 'val')` would make Phan infer that $x had a type of `string`, not `string|mixed`. | |
// Phan will not assume it knows specific types if the default value is false or null. | |
'guess_unknown_parameter_type_using_default' => false, | |
// Allow adding types to vague return types such as @return object, @return ?mixed in function/method/closure union types. | |
// Normally, Phan only adds inferred returned types when there is no `@return` type or real return type signature.. | |
// This setting can be disabled on individual methods by adding `@phan-hardcode-return-type` to the doc comment. | |
// | |
// Disabled by default. This is more useful with `--analyze-twice`. | |
'allow_overriding_vague_return_types' => true, | |
// When enabled, infer that the types of the properties of `$this` are equal to their default values at the start of `__construct()`. | |
// This will have some false positives due to Phan not checking for setters and initializing helpers. | |
// This does not affect inherited properties. | |
'infer_default_properties_in_construct' => true, | |
// Set this to true to enable the plugins that Phan uses to infer more accurate return types of `implode`, `json_decode`, and many other functions. | |
// | |
// Phan is slightly faster when these are disabled. | |
'enable_extended_internal_return_type_plugins' => true, | |
// This setting maps case insensitive strings to union types. | |
// This is useful if a project uses phpdoc that differs from the phpdoc2 standard. | |
// If the corresponding value is the empty string, Phan will ignore that union type (E.g. can ignore 'the' in `@return the value`) | |
// If the corresponding value is not empty, Phan will act as though it saw the corresponding union type when the keys show up in a UnionType of @param, @return, @var, @property, etc. | |
// | |
// This matches the **entire string**, not parts of the string. | |
// (E.g. `@return the|null` will still look for a class with the name `the`, but `@return the` will be ignored with the below setting) | |
// | |
// (These are not aliases, this setting is ignored outside of doc comments). | |
// (Phan does not check if classes with these names exist) | |
// | |
// Example setting: ['unknown' => '', 'number' => 'int|float', 'char' => 'string', 'long' => 'int', 'the' => ''] | |
'phpdoc_type_mapping' => [ ], | |
// Set to true in order to attempt to detect dead | |
// (unreferenced) code. Keep in mind that the | |
// results will only be a guess given that classes, | |
// properties, constants and methods can be referenced | |
// as variables (like `$class->$property` or | |
// `$class->$method()`) in ways that we're unable | |
// to make sense of. | |
'dead_code_detection' => false, | |
// Set to true in order to attempt to detect unused variables. | |
// dead_code_detection will also enable unused variable detection. | |
'unused_variable_detection' => true, | |
// Set to true in order to force tracking references to elements | |
// (functions/methods/consts/protected). | |
// dead_code_detection is another option which also causes references | |
// to be tracked. | |
'force_tracking_references' => false, | |
// Set to true in order to attempt to detect redundant and impossible conditions. | |
// | |
// This has some false positives involving loops, | |
// variables set in branches of loops, and global variables. | |
'redundant_condition_detection' => true, | |
// Set to true in order to attempt to detect error-prone truthiness/falsiness checks. | |
// | |
// This is not suitable for all codebases. | |
'error_prone_truthy_condition_detection' => true, | |
// Enable this to warn about harmless redundant use for classes and namespaces such as `use Foo\bar` in namespace Foo. | |
// | |
// Note: This does not affect warnings about redundant uses in the global namespace. | |
'warn_about_redundant_use_namespaced_class' => true, | |
// If true, then run a quick version of checks that takes less time. | |
// False by default. | |
'quick_mode' => false, | |
// If true, then before analysis, try to simplify AST into a form | |
// which improves Phan's type inference in edge cases. | |
// | |
// This may conflict with 'dead_code_detection'. | |
// When this is true, this slows down analysis slightly. | |
// | |
// E.g. rewrites `if ($a = value() && $a > 0) {...}` | |
// into $a = value(); if ($a) { if ($a > 0) {...}}` | |
'simplify_ast' => true, | |
// If true, Phan will read `class_alias` calls in the global scope, | |
// then (1) create aliases from the *parsed* files if no class definition was found, | |
// and (2) emit issues in the global scope if the source or target class is invalid. | |
// (If there are multiple possible valid original classes for an aliased class name, | |
// the one which will be created is unspecified.) | |
// NOTE: THIS IS EXPERIMENTAL, and the implementation may change. | |
'enable_class_alias_support' => false, | |
// Enable or disable support for generic templated | |
// class types. | |
'generic_types_enabled' => true, | |
// If enabled, warn about throw statement where the exception types | |
// are not documented in the PHPDoc of functions, methods, and closures. | |
'warn_about_undocumented_throw_statements' => true, | |
// If enabled (and warn_about_undocumented_throw_statements is enabled), | |
// warn about function/closure/method calls that have (at)throws | |
// without the invoking method documenting that exception. | |
'warn_about_undocumented_exceptions_thrown_by_invoked_functions' => true, | |
// If this is a list, Phan will not warn about lack of documentation of (at)throws | |
// for any of the listed classes or their subclasses. | |
// This setting only matters when warn_about_undocumented_throw_statements is true. | |
// The default is the empty array (Warn about every kind of Throwable) | |
'exception_classes_with_optional_throws_phpdoc' => [ | |
'LogicException', | |
'RuntimeException', | |
'InvalidArgumentException', | |
'AssertionError', | |
'TypeError', | |
'Phan\Exception\IssueException', // TODO: Make Phan aware that some arguments suppress certain issues | |
'Phan\AST\TolerantASTConverter\InvalidNodeException', // This is used internally in TolerantASTConverter | |
// TODO: Undo the suppressions for the below categories of issues: | |
'Phan\Exception\CodeBaseException', | |
// phpunit | |
'PHPUnit\Framework\ExpectationFailedException', | |
'SebastianBergmann\RecursionContext\InvalidArgumentException', | |
], | |
// Increase this to properly analyze require_once statements | |
'max_literal_string_type_length' => 1000, | |
// Setting this to true makes the process assignment for file analysis | |
// as predictable as possible, using consistent hashing. | |
// Even if files are added or removed, or process counts change, | |
// relatively few files will move to a different group. | |
// (use when the number of files is much larger than the process count) | |
// NOTE: If you rely on Phan parsing files/directories in the order | |
// that they were provided in this config, don't use this) | |
// See https://github.com/phan/phan/wiki/Different-Issue-Sets-On-Different-Numbers-of-CPUs | |
'consistent_hashing_file_order' => false, | |
// If enabled, Phan will act as though it's certain of real return types of a subset of internal functions, | |
// even if those return types aren't available in reflection (real types were taken from php 7.3 or 8.0-dev, depending on target_php_version). | |
// | |
// Note that with php 7 and earlier, php would return null or false for many internal functions if the argument types or counts were incorrect. | |
// As a result, enabling this setting with target_php_version 8.0 may result in false positives for `--redundant-condition-detection` when codebases also support php 7.x. | |
'assume_real_types_for_internal_functions' => true, | |
// Override to hardcode existence and types of (non-builtin) globals. | |
// Class names should be prefixed with '\\'. | |
// (E.g. ['_FOO' => '\\FooClass', 'page' => '\\PageClass', 'userId' => 'int']) | |
'globals_type_map' => [], | |
// The minimum severity level to report on. This can be | |
// set to Issue::SEVERITY_LOW, Issue::SEVERITY_NORMAL or | |
// Issue::SEVERITY_CRITICAL. | |
'minimum_severity' => Issue::SEVERITY_LOW, | |
// Add any issue types (such as 'PhanUndeclaredMethod') | |
// here to inhibit them from being reported | |
'suppress_issue_types' => [ | |
'PhanUnreferencedClosure', // False positives seen with closures in arrays, TODO: move closure checks closer to what is done by unused variable plugin | |
'PhanPluginNoCommentOnProtectedMethod', | |
'PhanPluginDescriptionlessCommentOnProtectedMethod', | |
'PhanPluginNoCommentOnPrivateMethod', | |
'PhanPluginDescriptionlessCommentOnPrivateMethod', | |
'PhanPluginDescriptionlessCommentOnPrivateProperty', | |
// TODO: Fix edge cases in --automatic-fix for PhanPluginRedundantClosureComment | |
'PhanPluginRedundantClosureComment', | |
'PhanPluginPossiblyStaticPublicMethod', | |
'PhanPluginPossiblyStaticProtectedMethod', | |
// The types of ast\Node->children are all possibly unset. | |
'PhanTypePossiblyInvalidDimOffset', | |
], | |
// If empty, no filter against issues types will be applied. | |
// If non-empty, only issues within the list will be emitted | |
// by Phan. | |
// | |
// See https://github.com/phan/phan/wiki/Issue-Types-Caught-by-Phan | |
// for the full list of issues that Phan detects. | |
// | |
// Phan is capable of detecting hundreds of types of issues. | |
// Projects should almost always use `suppress_issue_types` instead. | |
'whitelist_issue_types' => [ | |
// 'PhanUndeclaredClass', | |
], | |
// A list of files to include in analysis | |
'file_list' => [ | |
'phan', | |
'phan_client', | |
'plugins/codeclimate/engine', | |
'tool/make_stubs', | |
'tool/pdep', | |
'tool/phantasm', | |
'tool/phoogle', | |
'internal/dump_fallback_ast.php', | |
'internal/dump_html_styles.php', | |
'internal/extract_arg_info.php', | |
'internal/internalsignatures.php', | |
'internal/line_deleter.php', | |
'internal/package.php', | |
'internal/reflection_completeness_check.php', | |
'internal/sanitycheck.php', | |
'internal/update_wiki_config_types.php', | |
'internal/update_wiki_issue_types.php', | |
'vendor/phpdocumentor/type-resolver/src/Types/ContextFactory.php', | |
'vendor/phpdocumentor/reflection-docblock/src/DocBlockFactory.php', | |
'vendor/phpdocumentor/reflection-docblock/src/DocBlock.php', | |
// 'vendor/phpunit/phpunit/src/Framework/TestCase.php', | |
], | |
// A regular expression to match files to be excluded | |
// from parsing and analysis and will not be read at all. | |
// | |
// This is useful for excluding groups of test or example | |
// directories/files, unanalyzable files, or files that | |
// can't be removed for whatever reason. | |
// (e.g. '@Test\.php$@', or '@vendor/.*/(tests|Tests)/@') | |
'exclude_file_regex' => '@^vendor/.*/(tests?|Tests?)/@', | |
// Enable this to enable checks of require/include statements referring to valid paths. | |
'enable_include_path_checks' => true, | |
// A list of include paths to check when checking if `require_once`, `include`, etc. are valid. | |
// | |
// To refer to the directory of the file being analyzed, use `'.'` | |
// To refer to the project root directory, you must use \Phan\Config::getProjectRootDirectory() | |
// | |
// (E.g. `['.', \Phan\Config::getProjectRootDirectory() . '/src/folder-added-to-include_path']`) | |
'include_paths' => ['.'], | |
// Enable this to warn about the use of relative paths in `require_once`, `include`, etc. | |
// Relative paths are harder to reason about, and opcache may have issues with relative paths in edge cases. | |
'warn_about_relative_include_statement' => true, | |
// A list of files that will be excluded from parsing and analysis | |
// and will not be read at all. | |
// | |
// This is useful for excluding hopelessly unanalyzable | |
// files that can't be removed for whatever reason. | |
'exclude_file_list' => [ | |
'internal/Sniffs/ValidUnderscoreVariableNameSniff.php', | |
], | |
// The number of processes to fork off during the analysis | |
// phase. | |
'processes' => 1, | |
// A list of directories that should be parsed for class and | |
// method information. After excluding the directories | |
// defined in exclude_analysis_directory_list, the remaining | |
// files will be statically analyzed for errors. | |
// | |
// Thus, both first-party and third-party code being used by | |
// your application should be included in this list. | |
'directory_list' => [ | |
'internal/lib', | |
'src', | |
'tests/Phan', | |
'vendor/composer/semver/src', | |
'vendor/composer/xdebug-handler/src', | |
'vendor/felixfbecker/advanced-json-rpc/lib', | |
'vendor/microsoft/tolerant-php-parser/src', | |
'vendor/netresearch/jsonmapper/src', | |
'vendor/phpunit/phpunit/src', | |
'vendor/psr/log/Psr', | |
'vendor/sabre/event/lib', | |
'vendor/symfony/console', | |
'.phan/plugins', | |
'.phan/stubs', | |
'vendor/psr/http-message', | |
'vendor/guzzlehttp/guzzle', | |
'vendor/synfony/dom-crawler' | |
], | |
// List of case-insensitive file extensions supported by Phan. | |
// (e.g. php, html, htm) | |
'analyzed_file_extensions' => ['php'], | |
// A directory list that defines files that will be excluded | |
// from static analysis, but whose class and method | |
// information should be included. | |
// | |
// Generally, you'll want to include the directories for | |
// third-party code (such as 'vendor/') in this list. | |
// | |
// n.b.: If you'd like to parse but not analyze 3rd | |
// party code, directories containing that code | |
// should be added to the `directory_list` as | |
// to `exclude_analysis_directory_list`. | |
'exclude_analysis_directory_list' => [ | |
'vendor/' | |
], | |
// By default, Phan will log error messages to stdout if PHP is using options that slow the analysis. | |
// (e.g. PHP is compiled with --enable-debug or when using Xdebug) | |
'skip_slow_php_options_warning' => false, | |
// You can put paths to internal stubs in this config option. | |
// Phan will continue using its detailed type annotations, but load the constants, classes, functions, and classes (and their Reflection types) from these stub files (doubling as valid php files). | |
// Use a different extension from php to avoid accidentally loading these. | |
// The 'mkstubs' script can be used to generate your own stubs (compatible with php 7.0+ right now) | |
'autoload_internal_extension_signatures' => [ | |
'ast' => '.phan/internal_stubs/ast.phan_php', | |
'ctype' => '.phan/internal_stubs/ctype.phan_php', | |
'igbinary' => '.phan/internal_stubs/igbinary.phan_php', | |
'mbstring' => '.phan/internal_stubs/mbstring.phan_php', | |
'pcntl' => '.phan/internal_stubs/pcntl.phan_php', | |
'posix' => '.phan/internal_stubs/posix.phan_php', | |
'readline' => '.phan/internal_stubs/readline.phan_php', | |
'sysvmsg' => '.phan/internal_stubs/sysvmsg.phan_php', | |
'sysvsem' => '.phan/internal_stubs/sysvsem.phan_php', | |
'sysvshm' => '.phan/internal_stubs/sysvshm.phan_php', | |
], | |
// Set this to false to emit `PhanUndeclaredFunction` issues for internal functions that Phan has signatures for, | |
// but aren't available in the codebase, or from Reflection. | |
// (may lead to false positives if an extension isn't loaded) | |
// | |
// If this is true(default), then Phan will not warn. | |
// | |
// Even when this is false, Phan will still infer return values and check parameters of internal functions | |
// if Phan has the signatures. | |
'ignore_undeclared_functions_with_known_signatures' => false, | |
'plugin_config' => [ | |
// A list of 1 or more PHP binaries (Absolute path or program name found in $PATH) | |
// to use to analyze your files with PHP's native `--syntax-check`. | |
// | |
// This can be used to simultaneously run PHP's syntax checks with multiple PHP versions. | |
// e.g. `'plugin_config' => ['php_native_syntax_check_binaries' => ['php72', 'php70', 'php56']]` | |
// if all of those programs can be found in $PATH | |
// 'php_native_syntax_check_binaries' => [PHP_BINARY], | |
// The maximum number of `php --syntax-check` processes to run at any point in time (Minimum: 1). | |
// This may be temporarily higher if php_native_syntax_check_binaries has more elements than this process count. | |
'php_native_syntax_check_max_processes' => 4, | |
// blacklist of methods to warn about for HasPHPDocPlugin | |
'has_phpdoc_method_ignore_regex' => '@^Phan\\\\Tests\\\\.*::(test.*|.*Provider)$@', | |
// Warn about duplicate descriptions for methods and property groups within classes. | |
// (This skips over deprecated methods) | |
// This may not apply to all code bases, | |
// but is useful in avoiding copied and pasted descriptions that may be inapplicable or too vague. | |
'has_phpdoc_check_duplicates' => true, | |
// If true, then never allow empty statement lists, even if there is a TODO/FIXME/"deliberately empty" comment. | |
'empty_statement_list_ignore_todos' => true, | |
// Automatically infer which methods are pure (i.e. should have no side effects) in UseReturnValuePlugin. | |
'infer_pure_methods' => true, | |
], | |
// A list of plugin files to execute | |
// NOTE: values can be the base name without the extension for plugins bundled with Phan (E.g. 'AlwaysReturnPlugin') | |
// or relative/absolute paths to the plugin (Relative to the project root). | |
'plugins' => [ | |
'AlwaysReturnPlugin', | |
'DollarDollarPlugin', | |
'UnreachableCodePlugin', | |
'DuplicateArrayKeyPlugin', | |
'PregRegexCheckerPlugin', | |
'PrintfCheckerPlugin', | |
'PHPUnitAssertionPlugin', // analyze assertSame/assertInstanceof/assertTrue/assertFalse | |
'UseReturnValuePlugin', | |
// UnknownElementTypePlugin warns about unknown types in element signatures. | |
'UnknownElementTypePlugin', | |
'DuplicateExpressionPlugin', | |
// warns about carriage returns("\r"), trailing whitespace, and tabs in PHP files. | |
'WhitespacePlugin', | |
// Warn about inline HTML anywhere in the files. | |
'InlineHTMLPlugin', | |
//////////////////////////////////////////////////////////////////////// | |
// Plugins for Phan's self-analysis | |
//////////////////////////////////////////////////////////////////////// | |
// Warns about the usage of assert() for Phan's self-analysis. See https://github.com/phan/phan/issues/288 | |
'NoAssertPlugin', | |
'PossiblyStaticMethodPlugin', | |
'HasPHPDocPlugin', | |
'PHPDocToRealTypesPlugin', // suggests replacing (at)return void with `: void` in the declaration, etc. | |
'PHPDocRedundantPlugin', | |
'PreferNamespaceUsePlugin', | |
'EmptyStatementListPlugin', | |
// Report empty (not overridden or overriding) methods and functions | |
// 'EmptyMethodAndFunctionPlugin', | |
// This should only be enabled if the code being analyzed contains Phan plugins. | |
'PhanSelfCheckPlugin', | |
// Warn about using the same loop variable name as a loop variable of an outer loop. | |
'LoopVariableReusePlugin', | |
// Warn about assigning the value the variable already had to that variable. | |
'RedundantAssignmentPlugin', | |
// These are specific to Phan's coding style | |
'StrictComparisonPlugin', | |
// Warn about `$var == SOME_INT_OR_STRING_CONST` due to unintuitive behavior such as `0 == 'a'` | |
'.phan/plugins/StrictLiteralComparisonPlugin.php', | |
// 'UnknownClassElementAccessPlugin' is more useful with batch analysis than in an editor. | |
// It's used in tests/run_test __FakeSelfFallbackTest | |
//////////////////////////////////////////////////////////////////////// | |
// End plugins for Phan's self-analysis | |
//////////////////////////////////////////////////////////////////////// | |
// 'SleepCheckerPlugin' is useful for projects which heavily use the __sleep() method. Phan doesn't use __sleep(). | |
// InvokePHPNativeSyntaxCheckPlugin invokes 'php --no-php-ini --syntax-check ${abs_path_to_analyzed_file}.php' and reports any error messages. | |
// Using this can cause phan's overall analysis time to more than double. | |
// 'InvokePHPNativeSyntaxCheckPlugin', | |
// 'PHPUnitNotDeadCodePlugin', // Marks PHPUnit test case subclasses and test cases as referenced code. This is only useful for runs when dead code detection is enabled. | |
// NOTE: This plugin only produces correct results when | |
// Phan is run on a single core (-j1). | |
// 'UnusedSuppressionPlugin', | |
], | |
]; |
Author
pauloagrillo
commented
Aug 12, 2020
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment