19. Annex

  • Supported Rulesets
  • Supported Reports
  • Supported PHP Extensions
  • Supported Frameworks
  • Applications
  • Recognized Libraries
  • New analyzers
  • External services
  • PHP Error messages

19.1. Supported Rulesets

Exakat groups analysis by rulesets. This way, analyzing ‘Security’ runs all possible analysis related to security. One analysis may belong to multiple rulesets.

  • All
  • Analyze
  • Appcontent
  • Appinfo
  • Calisthenics
  • ClassReview
  • ClearPHP
  • Coding Conventions
  • CompatibilityPHP53
  • CompatibilityPHP54
  • CompatibilityPHP55
  • CompatibilityPHP56
  • CompatibilityPHP70
  • CompatibilityPHP71
  • CompatibilityPHP72
  • CompatibilityPHP73
  • CompatibilityPHP74
  • CompatibilityPHP80
  • Complete
  • Custom
  • Dead code
  • DefensiveProgrammingTM
  • Dismell
  • Dump
  • First
  • Internal
  • Inventory
  • Level 1
  • Level 2
  • Level 3
  • Level 4
  • Level 5
  • LintButWontExec
  • Newfeatures
  • OneFile
  • PHP recommendations
  • Performances
  • Portability
  • Preferences
  • RadwellCodes
  • Rector
  • SOLID
  • Security
  • Semantics
  • Simple
  • Stats
  • Suggestions
  • Top10
  • Typechecks
  • Unassigned
  • Under Work
  • php-cs-fixable

19.2. Supported Reports

Exakat produces various reports. Some are general, covering various aspects in a reference way; others focus on one aspect.

  • Ambassador
  • Ambassadornomenu
  • Drillinstructor
  • Top10
  • Text
  • Xml
  • Uml
  • Yaml
  • Plantuml
  • None
  • Simplehtml
  • Owasp
  • Perfile
  • Phpconfiguration
  • Phpcompilation
  • Favorites
  • Manual
  • Stubs
  • Inventories
  • Clustergrammer
  • Filedependencies
  • Filedependencieshtml
  • Classdependencies
  • Stubs
  • Radwellcode
  • Grade
  • Weekly
  • Scrutinizer
  • Codesniffer
  • Phpcsfixer
  • Facetedjson
  • Json
  • Onepagejson
  • Marmelab
  • Simpletable
  • Exakatyaml
  • Codeflower
  • Dependencywheel
  • Phpcity
  • Sarb
  • Exakatvendors
  • Topology

19.3. Supported PHP Extensions

PHP extensions are used to check for structures usage (classes, interfaces, etc.), to identify dependencies and directives.

PHP extensions are described with the list of structures they define : functions, classes, constants, traits, variables, interfaces, namespaces, and directives.

19.4. Supported Frameworks

Frameworks, components and libraries are supported via Exakat extensions.

List of extensions : there are 10 extensions

19.6. Recognized Libraries

Libraries that are popular, large and often included in repositories are identified early in the analysis process, and ignored. This prevents Exakat to analysis some code foreign to the current repository : it prevents false positives from this code, and make the analysis much lighter. The whole process is entirely automatic.

Those libraries, or even some of the, may be included again in the analysis by commenting the ignored_dir[] line, in the projects/<project>/config.ini file.

19.7. New analyzers

List of analyzers, by version of introduction, newest to oldest. In parenthesis, the first element is the analyzer name, used with ‘analyze -P’ command, and the seconds, if any, are the ruleset, used with the -T option. Rulesets are separated by commas, as the same analysis may be used in several rulesets.

  • 2.0.3
    • Collect Class Children Count (Dump/CollectClassChildren)
    • Collect Class Depth (Dump/CollectClassDepth ; Dump)
    • Collect Class Interface Counts (Dump/CollectClassInterfaceCounts ; Dump)
    • Exceeding Typehint (Functions/ExceedingTypehint ; ClassReview)
    • Interfaces/PossibleInterfaces (Interfaces/PossibleInterfaces ; )
  • 2.0.2
    • Dump/Inclusions (Dump/Inclusions ; Dump)
    • Dump/NewOrder (Dump/NewOrder ; Unassigned)
    • Dump/ParameterArgumentsLinks (Dump/ParameterArgumentsLinks ; Unassigned)
    • Insufficient Property Typehint (Classes/InsufficientPropertyTypehint)
    • Nullable Without Check (Functions/NullableWithoutCheck ; ClassReview)
    • Typehint Order (Dump/TypehintOrder ; Unassigned)
    • Wrong Typehinted Name (Functions/WrongTypehintedName ; Coding Conventions, Semantics)
  • 1.9.9
    • Complete/CreateForeachDefault (Complete/CreateForeachDefault ; Complete)
    • Concrete usage (Vendors/Concrete5 ; Appinfo)
    • Could Type With Array (Functions/CouldTypeWithArray ; Typechecks)
    • Could Type With Boolean (Functions/CouldTypeWithBool ; Typechecks)
    • Could Type With Int (Functions/CouldTypeWithInt ; Typechecks)
    • Could Type With String (Functions/CouldTypeWithString ; Typechecks)
    • Dump/CollectMbstringEncodings (Dump/CollectMbstringEncodings ; Dump)
    • Filter To add_slashes() (Php/FilterToAddSlashes ; CompatibilityPHP74)
    • Functions/CouldTypeWithIterable (Functions/CouldTypeWithIterable ; Typechecks)
    • Immutable Signature (Classes/ImmutableSignature ; Appinfo)
    • Is_A() With String (Php/IsAWithString ; Analyze, Simple, Rector)
    • Mbstring Third Arg (Structures/MbstringThirdArg ; Analyze)
    • Mbstring Unknown Encoding (Structures/MbstringUnknownEncoding ; Analyze)
    • Merge If Then (Structures/MergeIfThen ; Analyze)
    • Shell commands (Type/Shellcommands ; Appinfo)
    • Typehinting Stats (Dump/TypehintingStats ; Dump)
    • Typo 3 usage (Vendors/Typo3 ; Appinfo)
    • Weird Array Index (Arrays/WeirdIndex)
    • Wrong Case Namespaces (Namespaces/WrongCase ; Coding Conventions)
    • Wrong Type With Call (Functions/WrongTypeWithCall ; Analyze, Typechecks)
  • 1.9.8
    • Cant Implement Traversable (Interfaces/CantImplementTraversable ; Analyze, LintButWontExec)
    • Complete/PropagateCalls (Complete/PropagateCalls)
    • Parameter Hiding (Functions/ParameterHiding ; Semantics)
  • 1.9.7
    • Dump/CollectForeachFavorite (Dump/CollectForeachFavorite ; Dump)
    • Make Functioncall With Reference (Complete/MakeFunctioncallWithReference ; Complete)
    • Too Many Dereferencing (Classes/TooManyDereferencing)
    • Use Url Query Functions (Structures/UseUrlQueryFunctions ; Suggestions)
  • 1.9.6
    • Create Magic Method (Complete/CreateMagicMethod ; )
    • Custom/NotInThisList (Custom/NotInThisList ; Unassigned)
    • Dump/CollectLocalVariableCounts (Dump/CollectLocalVariableCounts ; Dump)
    • Dump/CollectParameterCounts (Dump/CollectParameterCounts ; Dump)
    • Dump/DereferencingLevels (Dump/DereferencingLevels ; Dump)
    • Duplicate Literal (Type/DuplicateLiteral ; Semantics)
    • Internet Domains (Type/UdpDomains ; Inventory)
    • No Weak SSL Crypto (Security/NoWeakSSLCrypto ; Security)
    • No mb_substr In Loop (Performances/MbStringInLoop ; Performances)
    • Non Nullable Getters (Classes/NonNullableSetters)
    • Use Case Value (Structures/UseCaseValue ; Suggestions)
  • 1.9.5
    • Dump/CollectLiterals (Dump/CollectLiterals ; Dump)
    • Interfaces Is Not Implemented (Interfaces/IsNotImplemented ; Analyze, ClassReview)
    • Magic Properties (Classes/MagicProperties)
    • No Garantee For Property Constant (Interfaces/NoGaranteeForPropertyConstant ; Analyze, ClassReview)
    • No Literal For Reference (Functions/NoLiteralForReference ; Analyze)
    • Use array_slice() (Performances/UseArraySlice ; Analyze)
  • 1.9.4
    • Coalesce And Concat (Structures/CoalesceAndConcat ; Analyze)
    • Constant Comparison (Structures/AlwaysFalse ; Analyze)
    • Cyclomatic Complexity (Dump/CyclomaticComplexity ; Dump)
    • Nested Ternary Without Parenthesis (Php/NestedTernaryWithoutParenthesis ; Appinfo, CompatibilityPHP74)
    • PHP 74 New Directives (Php/Php74NewDirective ; CompatibilityPHP73)
    • Should Use Explode Args (Structures/ShouldUseExplodeArgs ; Analyze)
    • Spread Operator For Array (Php/SpreadOperatorForArray ; Appinfo)
    • Too Many Array Dimensions (Arrays/TooManyDimensions)
    • Use Arrow Functions (Functions/UseArrowFunctions ; Appinfo)
  • 1.9.3
    • Complete/SetClassRemoteDefinitionWithParenthesis (Complete/SetClassRemoteDefinitionWithParenthesis ; Complete)
    • Complete/SetClassRemoteDefinitionWithTypehint (Complete/SetClassRemoteDefinitionWithTypehint ; Complete)
    • Environment Variables (Dump/EnvironmentVariables ; )
    • Indentation Levels (Dump/IndentationLevels ; Unassigned, Dump)
    • Max Level Of Nesting (Structures/MaxLevelOfIdentation ; Analyze)
    • No Spread For Hash (Arrays/NoSpreadForHash)
    • PHP 7.4 Constant Deprecation (Php/Php74Deprecation ; CompatibilityPHP74)
    • PHP 7.4 Removed Directives (Php/Php74RemovedDirective ; CompatibilityPHP74)
    • Set Class Method Remote Definition (Complete/SetClassMethodRemoteDefinition ; Complete)
    • Set Class Property Definition With Typehint (Complete/SetClassPropertyDefinitionWithTypehint ; Complete)
    • Set Class Remote Definition With Global (Complete/SetClassRemoteDefinitionWithGlobal ; Complete)
    • Set Class Remote Definition With Local New (Complete/SetClassRemoteDefinitionWithLocalNew ; Complete)
    • Set Class Remote Definition With Return Typehint (Complete/SetClassRemoteDefinitionWithReturnTypehint ; Complete)
    • Set String Method Definition (Complete/SetStringMethodDefinition ; Complete)
    • SetA rray Class Definition (Complete/SetArrayClassDefinition ; Complete)
    • Use Contravariance (Php/UseContravariance ; Appinfo)
    • Use Covariance (Php/UseCovariance ; Appinfo)
    • openssl_random_pseudo_byte() Second Argument (Structures/OpensslRandomPseudoByteSecondArg ; CompatibilityPHP74)
    • strip_tags Skips Closed Tag (Structures/StripTagsSkipsClosedTag ; Analyze)
  • 1.9.2
    • Complete/SetClassRemoteDefinitionWithInjection (Complete/SetClassRemoteDefinitionWithInjection ; Complete)
    • Create Compact Variables (Complete/CreateCompactVariables)
    • Create Default Values (Complete/CreateDefaultValues ; Complete)
    • Create Magic Property (Complete/CreateMagicProperty ; Complete)
    • Follow Closure Definition (Complete/FollowClosureDefinition ; Complete)
    • Make Class Constant Definition (Complete/MakeClassConstantDefinition ; Complete)
    • Make Class Method Definition (Complete/MakeClassMethodDefinition ; Complete)
    • No ENT_IGNORE (Security/NoEntIgnore ; Security)
    • No More Curly Arrays (Php/NoMoreCurlyArrays ; CompatibilityPHP74)
    • Overwritten Constant (Complete/OverwrittenConstants ; Complete)
    • Overwritten Methods (Complete/OverwrittenMethods ; Complete)
    • Overwritten Properties (Complete/OverwrittenProperties ; Complete)
    • PHP 7.4 Reserved Keyword (Php/Php74ReservedKeyword ; CompatibilityPHP74)
    • Propagate Constants (Complete/PropagateConstants ; Complete)
    • Set Class_Alias Definition (Complete/SetClassAliasDefinition ; Complete)
    • Set Clone Link (Complete/SetCloneLink ; Complete)
    • Set Parent Definition (Complete/SetParentDefinition ; Complete)
    • Solve Trait Methods (Complete/SolveTraitMethods ; Complete)
    • Structures/ImplodeArgsOrder (Structures/ImplodeArgsOrder ; Analyze)
    • array_merge() And Variadic (Structures/ArrayMergeAndVariadic ; Analyze)
  • 1.9.1
    • Complete/PhpNativeReference (Complete/PhpNativeReference)
  • 1.9.0
    • Class Without Parent (Classes/NoParent)
    • Numeric Literal Separator (Php/IntegerSeparatorUsage ; Appinfo, CompatibilityPHP73)
    • PHP 7.4 Removed Functions (Php/Php74RemovedFunctions ; CompatibilityPHP74)
    • Reflection Export() Is Deprecated (Php/ReflectionExportIsDeprecated ; CompatibilityPHP74)
    • Scalar Are Not Arrays (Php/ScalarAreNotArrays ; Analyze, CompatibilityPHP74)
    • Serialize Magic Method (Php/SerializeMagic ; Internal)
    • Similar Integers (Type/SimilarIntegers ; Coding Conventions, Semantics)
    • Unbinding Closures (Functions/UnbindingClosures ; CompatibilityPHP74)
    • array_key_exists() Works On Arrays (Php/ArrayKeyExistsWithObjects ; Analyze, CompatibilityPHP74)
  • 1.8.9
    • Avoid mb_dectect_encoding() (Php/AvoidMbDectectEncoding ; Analyze)
    • Disconnected Classes (Classes/DisconnectedClasses)
    • Not Or Tilde (Structures/NotOrNot ; Preferences)
    • Overwritten Source And Value (Structures/ForeachSourceValue ; Analyze, OneFile)
    • Php/Php74mbstrrpos3rdArg (Php/Php74mbstrrpos3rdArg ; CompatibilityPHP74)
    • Useless Type Check (Functions/UselessTypeCheck ; Dead code, OneFile)
  • 1.8.8
    • Set Aside Code (Structures/SetAside)
    • Use Array Functions (Structures/UseArrayFunctions ; Suggestions)
  • 1.8.7
    • Cant Use Function (Functions/CantUse)
    • Generator Cannot Return (Functions/GeneratorCannotReturn ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Use DateTimeImmutable Class (Php/UseDateTimeImmutable ; Suggestions)
    • Wrong Returned Type (Functions/WrongReturnedType ; Analyze, ClassReview)
  • 1.8.6
    • Dependant Abstract Classes (Classes/DependantAbstractClass ; Analyze, ClassReview)
    • Infinite Recursion (Structures/InfiniteRecursion ; Analyze)
    • Modules/IncomingData (Modules/IncomingData ; Internal)
    • Modules/NativeReplacement (Modules/NativeReplacement ; Internal)
    • Null Or Boolean Arrays (Arrays/NullBoolean)
  • 1.8.5
    • Could Use Trait (Traits/CouldUseTrait)
  • 1.8.4
    • Always Use Function With array_key_exists() (Performances/Php74ArrayKeyExists ; Performances)
    • Complex Dynamic Names (Variables/ComplexDynamicNames ; Suggestions)
    • Could Be Constant (Constants/CouldBeConstant ; Suggestions)
    • New Constants In PHP 7.4 (Php/Php74NewConstants ; CompatibilityPHP74)
    • Regex On Arrays (Performances/RegexOnArrays ; Performances)
    • Unused Class Constant (Classes/UnusedConstant)
    • curl_version() Has No Argument (Structures/CurlVersionNow ; CompatibilityPHP74)
  • 1.8.3
    • Autoappend (Performances/Autoappend ; Performances)
    • Make Magic Concrete (Classes/MakeMagicConcrete)
    • Memoize MagicCall (Performances/MemoizeMagicCall ; Analyze, ClassReview)
    • Substr To Trim (Structures/SubstrToTrim ; Suggestions)
  • 1.8.2
    • Identical Methods (Classes/IdenticalMethods)
    • No Append On Source (Structures/NoAppendOnSource ; Analyze)
  • 1.8.1
    • No Need For get_class() (Structures/NoNeedGetClass)
  • 1.8.0
    • Already Parents Trait (Traits/AlreadyParentsTrait ; Analyze)
    • Casting Ternary (Structures/CastingTernary ; Analyze, OneFile)
    • Concat And Addition (Php/ConcatAndAddition ; Analyze, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72, CompatibilityPHP73, CompatibilityPHP74, Top10, CompatibilityPHP80)
    • Concat Empty String (Structures/ConcatEmpty ; Analyze, OneFile)
    • Minus One On Error (Security/MinusOneOnError ; Security)
    • New Functions In PHP 7.4 (Php/Php74NewFunctions ; CompatibilityPHP74)
    • Unpacking Inside Arrays (Php/UnpackingInsideArrays ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72, CompatibilityPHP73)
    • Useless Argument (Functions/UselessArgument)
  • 1.7.9
    • Avoid option arrays in constructors (Classes/AvoidOptionArrays)
    • Trait Not Found (Traits/TraitNotFound ; Analyze, LintButWontExec)
    • Useless Default Argument (Functions/UselessDefault ; Suggestions)
    • ext/ffi (Extensions/Extffi ; Appinfo, Appcontent)
    • ext/uuid (Extensions/Extuuid ; Appinfo)
    • ext/zend_monitor (Extensions/Extzendmonitor ; Appinfo)
  • 1.7.8
    • ext/svm (Extensions/Extsvm)
  • 1.7.7
    • Implode One Arg (Php/ImplodeOneArg)
    • Incoming Values (Php/IncomingValues ; Internal)
    • Integer Conversion (Security/IntegerConversion ; Security)
  • 1.7.6
    • Caught Variable (Exceptions/CatchE)
    • Multiple Unset() (Structures/MultipleUnset ; Suggestions, php-cs-fixable)
    • PHP Overridden Function (Php/OveriddenFunction ; Appinfo)
    • array_merge With Ellipsis (Structures/ArrayMergeWithEllipsis ; )
  • 1.7.2
    • Check On __Call Usage (Classes/CheckOnCallUsage)
    • Unsupported Operand Types (Structures/UnsupportedOperandTypes ; )
  • 1.7.0
    • Clone With Non-Object (Classes/CloneWithNonObject)
    • Self-Transforming Variables (Variables/SelfTransform ; Internal)
    • Should Deep Clone (Classes/ShouldDeepClone ; Suggestions)
    • Windows Only Constants (Portability/WindowsOnlyConstants ; )
  • 1.6.9
    • Inconsistent Variable Usage (Variables/InconsistentUsage ; Under Work)
    • Typehint Must Be Returned (Functions/TypehintMustBeReturned)
  • 1.6.8
    • PHP 8.0 Removed Constants (Php/Php80RemovedConstant)
    • PHP 8.0 Removed Functions (Php/Php80RemovedFunctions ; CompatibilityPHP80)
  • 1.6.7
    • An OOP Factory (Patterns/Factory ; Appinfo)
    • Constant Dynamic Creation (Constants/DynamicCreation ; Appinfo)
    • Law of Demeter (Classes/DemeterLaw)
  • 1.6.6
    • Functions/BadTypehintRelay (Functions/BadTypehintRelay)
    • Insufficient Typehint (Functions/InsufficientTypehint ; Analyze, Typechecks)
  • 1.6.5
    • String Initialization (Arrays/StringInitialization)
    • Variable Is Not A Condition (Structures/NoVariableIsACondition ; Analyze)
    • ext/pcov (Extensions/Extpcov ; Appinfo)
    • ext/weakref (Extensions/Extweakref ; Appinfo)
  • 1.6.4
    • Defined Classes (Modules/DefinedClasses)
    • Don’t Be Too Manual (Structures/DontBeTooManual ; Coding Conventions)
    • Use Coalesce Equal (Structures/UseCoalesceEqual ; )
  • 1.6.3
    • Assign And Compare (Structures/AssigneAndCompare)
  • 1.6.2
    • Typed Property Usage (Php/TypedPropertyUsage)
  • 1.6.1
    • Possible Missing Subpattern (Php/MissingSubpattern ; Analyze, Top10)
    • array_key_exists() Speedup (Performances/ArrayKeyExistsSpeedup)
  • 1.5.8
    • Multiple Identical Closure (Functions/MultipleIdenticalClosure)
    • Path lists (Type/Path ; Appinfo)
  • 1.5.7
    • Method Could Be Static (Classes/CouldBeStatic)
    • Multiple Usage Of Same Trait (Traits/MultipleUsage ; Suggestions)
    • Self Using Trait (Traits/SelfUsingTrait ; Dead code, ClassReview)
    • ext/wasm (Extensions/Extwasm ; Appinfo)
  • 1.5.6
    • Isset() On The Whole Array (Performances/IssetWholeArray ; Performances, Suggestions)
    • Useless Alias (Traits/UselessAlias ; Analyze, LintButWontExec)
    • ext/async (Extensions/Extasync)
    • ext/sdl (Extensions/Extsdl ; Appinfo)
  • 1.5.5
    • Directly Use File (Structures/DirectlyUseFile ; Suggestions)
    • Safe HTTP Headers (Security/SafeHttpHeaders ; Security)
    • fputcsv() In Loops (Performances/CsvInLoops)
  • 1.5.4
    • Avoid Self In Interface (Interfaces/AvoidSelfInInterface ; ClassReview)
    • Should Have Destructor (Classes/ShouldHaveDestructor)
    • Unreachable Class Constant (Classes/UnreachableConstant ; ClassReview)
  • 1.5.3
    • Don’t Loop On Yield (Structures/DontLoopOnYield)
    • Variable May Be Non-Global (Structures/VariableMayBeNonGlobal ; Internal)
  • 1.5.2
    • PHP Exception (Exceptions/IsPhpException)
    • Should Yield With Key (Functions/ShouldYieldWithKey ; Analyze, Top10)
    • ext/decimal (Extensions/Extdecimal ; Appinfo)
    • ext/psr (Extensions/Extpsr ; Appinfo)
  • 1.5.1
    • Use Basename Suffix (Structures/BasenameSuffix)
  • 1.5.0
    • Could Use Try (Exceptions/CouldUseTry)
    • Pack Format Inventory (Type/Pack ; Inventory, Appinfo)
    • Printf Format Inventory (Type/Printf ; Inventory, Appinfo)
    • idn_to_ascii() New Default (Php/IdnUts46 ; CompatibilityPHP74)
  • 1.4.9
    • Don’t Read And Write In One Expression (Structures/DontReadAndWriteInOneExpression ; Analyze, CompatibilityPHP73, CompatibilityPHP74)
    • Invalid Pack Format (Structures/InvalidPackFormat ; Analyze)
    • Named Regex (Structures/NamedRegex ; Suggestions)
    • No Reference For Static Property (Php/NoReferenceForStaticProperty ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • No Return For Generator (Php/NoReturnForGenerator ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Repeated Interface (Interfaces/RepeatedInterface ; Analyze, LintButWontExec)
    • Wrong Access Style to Property (Classes/UndeclaredStaticProperty)
  • 1.4.8
    • Direct Call To __clone() (Php/DirectCallToClone)
    • filter_input() As A Source (Security/FilterInputSource ; Security)
  • 1.4.6
    • Only Variable For Reference (Functions/OnlyVariableForReference)
  • 1.4.5
    • Add Default Value (Functions/AddDefaultValue)
  • 1.4.4
    • ext/seaslog (Extensions/Extseaslog)
  • 1.4.3
    • Class Could Be Final (Classes/CouldBeFinal)
    • Closure Could Be A Callback (Functions/Closure2String ; Performances, Suggestions)
    • Inconsistent Elseif (Structures/InconsistentElseif ; Analyze)
    • Use json_decode() Options (Structures/JsonWithOption ; Suggestions)
  • 1.4.2
    • Method Collision Traits (Traits/MethodCollisionTraits)
    • Undefined Insteadof (Traits/UndefinedInsteadof ; Analyze, LintButWontExec)
    • Undefined Variable (Variables/UndefinedVariable ; Analyze)
  • 1.4.1
    • Must Call Parent Constructor (Php/MustCallParentConstructor)
  • 1.4.0
    • PHP 7.3 Removed Functions (Php/Php73RemovedFunctions)
    • Trailing Comma In Calls (Php/TrailingComma ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
  • 1.3.9
    • Assert Function Is Reserved (Php/AssertFunctionIsReserved ; Analyze, CompatibilityPHP73)
    • Avoid Real (Php/AvoidReal ; Suggestions, Top10)
    • Case Insensitive Constants (Constants/CaseInsensitiveConstants ; Appinfo, CompatibilityPHP73)
    • Const Or Define Preference (Constants/ConstDefinePreference ; Preferences)
    • Continue Is For Loop (Structures/ContinueIsForLoop ; Analyze, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72, CompatibilityPHP73)
    • Could Be Abstract Class (Classes/CouldBeAbstractClass)
  • 1.3.8
    • Constant Case Preference (Constants/DefineInsensitivePreference)
    • Detect Current Class (Php/DetectCurrentClass ; Suggestions, CompatibilityPHP74)
    • Use is_countable (Php/CouldUseIsCountable ; Suggestions)
  • 1.3.7
    • Handle Arrays With Callback (Arrays/WithCallback)
  • 1.3.5
    • Locally Used Property In Trait (Traits/LocallyUsedProperty ; Internal)
    • PHP 7.0 Scalar Typehints (Php/PHP70scalartypehints ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • PHP 7.1 Scalar Typehints (Php/PHP71scalartypehints ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70)
    • PHP 7.2 Scalar Typehints (Php/PHP72scalartypehints ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71)
    • Undefined ::class (Classes/UndefinedStaticclass)
    • ext/lzf (Extensions/Extlzf ; Appinfo)
    • ext/msgpack (Extensions/Extmsgpack ; Appinfo)
  • 1.3.4
    • Ambiguous Visibilities (Classes/AmbiguousVisibilities)
    • Hash Algorithms Incompatible With PHP 7.1- (Php/HashAlgos71 ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70)
    • Hash Algorithms Incompatible With PHP 7.4- (Php/HashAlgos74 ; CompatibilityPHP74)
    • ext/csprng (Extensions/Extcsprng ; Appinfo)
  • 1.3.3
    • Abstract Or Implements (Classes/AbstractOrImplements)
    • Can’t Throw Throwable (Exceptions/CantThrow ; Analyze, LintButWontExec)
    • Incompatible Signature Methods (Classes/IncompatibleSignature ; Analyze, LintButWontExec)
    • Incompatible Signature Methods With Covariance (Classes/IncompatibleSignature74 ; Analyze)
    • ext/eio (Extensions/Exteio ; Appinfo)
  • 1.3.2
    • > Or < Comparisons (Structures/GtOrLtFavorite ; Preferences)
    • Compared But Not Assigned Strings (Structures/ComparedButNotAssignedStrings ; Under Work)
    • Could Be Static Closure (Functions/CouldBeStaticClosure)
    • Dont Mix ++ (Structures/DontMixPlusPlus ; Analyze)
    • Strict Or Relaxed Comparison (Structures/ComparisonFavorite ; Preferences)
    • move_uploaded_file Instead Of copy (Security/MoveUploadedFile ; Security)
  • 1.3.0
    • Check JSON (Structures/CheckJson ; Analyze)
    • Const Visibility Usage (Classes/ConstVisibilityUsage)
    • Should Use Operator (Structures/ShouldUseOperator ; Suggestions)
    • Single Use Variables (Variables/UniqueUsage ; Under Work)
  • 1.2.9
    • Compact Inexistant Variable (Php/CompactInexistant ; CompatibilityPHP73, Suggestions)
    • Configure Extract (Security/ConfigureExtract ; Security)
    • Flexible Heredoc (Php/FlexibleHeredoc ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • Method Signature Must Be Compatible (Classes/MethodSignatureMustBeCompatible)
    • Mismatch Type And Default (Functions/MismatchTypeAndDefault ; Analyze, LintButWontExec, Typechecks)
    • Use The Blind Var (Performances/UseBlindVar ; Performances)
  • 1.2.8
    • Cache Variable Outside Loop (Performances/CacheVariableOutsideLoop ; Performances)
    • Cant Instantiate Class (Classes/CantInstantiateClass)
    • Do In Base (Performances/DoInBase ; Performances)
    • Php/FailingAnalysis (Php/FailingAnalysis ; Internal)
    • Typehinted References (Functions/TypehintedReferences ; Analyze)
    • Weak Typing (Classes/WeakType ; Analyze)
    • strpos() Too Much (Performances/StrposTooMuch ; Analyze)
  • 1.2.7
    • ext/cmark (Extensions/Extcmark)
  • 1.2.6
    • Callback Needs Return (Functions/CallbackNeedsReturn)
    • Could Use array_unique (Structures/CouldUseArrayUnique ; Suggestions)
    • Missing Parenthesis (Structures/MissingParenthesis ; Analyze, Simple, Level 5)
    • One If Is Sufficient (Structures/OneIfIsSufficient ; Suggestions)
  • 1.2.5
    • Wrong Range Check (Structures/WrongRange ; Analyze)
    • ext/zookeeper (Extensions/Extzookeeper)
  • 1.2.4
    • Processing Collector (Performances/RegexOnCollector)
  • 1.2.3
    • Don’t Unset Properties (Classes/DontUnsetProperties)
    • Redefined Private Property (Classes/RedefinedPrivateProperty ; Analyze)
    • Strtr Arguments (Php/StrtrArguments ; Analyze)
  • 1.2.2
    • Drop Substr Last Arg (Structures/SubstrLastArg)
  • 1.2.1
    • Possible Increment (Structures/PossibleIncrement ; Suggestions)
    • Properties Declaration Consistence (Classes/PPPDeclarationStyle)
  • 1.1.10
    • Too Many Native Calls (Php/TooManyNativeCalls)
  • 1.1.9
    • Should Preprocess Chr (Php/ShouldPreprocess ; Suggestions)
    • Too Many Parameters (Functions/TooManyParameters)
  • 1.1.8
    • Mass Creation Of Arrays (Arrays/MassCreation)
    • ext/db2 (Extensions/Extdb2 ; Appinfo)
  • 1.1.7
    • Could Use array_fill_keys (Structures/CouldUseArrayFillKeys ; Suggestions)
    • Dynamic Library Loading (Security/DynamicDl ; Security)
    • PHP 7.3 Last Empty Argument (Php/PHP73LastEmptyArgument ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • Property Could Be Local (Classes/PropertyCouldBeLocal)
    • Use Count Recursive (Structures/UseCountRecursive ; Suggestions)
    • ext/leveldb (Extensions/Extleveldb ; Appinfo)
    • ext/opencensus (Extensions/Extopencensus ; Appinfo)
    • ext/uopz (Extensions/Extuopz ; Appinfo)
    • ext/varnish (Extensions/Extvarnish ; Appinfo)
    • ext/xxtea (Extensions/Extxxtea ; Appinfo)
  • 1.1.6
    • Could Use Compact (Structures/CouldUseCompact ; Suggestions)
    • Foreach On Object (Php/ForeachObject)
    • List With Reference (Php/ListWithReference ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • Test Then Cast (Structures/TestThenCast ; Analyze)
  • 1.1.5
    • Possible Infinite Loop (Structures/PossibleInfiniteLoop ; Analyze)
    • Should Use Math (Structures/ShouldUseMath ; Suggestions)
    • ext/hrtime (Extensions/Exthrtime)
  • 1.1.4
    • Double array_flip() (Performances/DoubleArrayFlip ; Performances)
    • Fallback Function (Functions/FallbackFunction ; Appinfo)
    • Find Key Directly (Structures/GoToKeyDirectly ; Under Work)
    • Reuse Variable (Structures/ReuseVariable ; Suggestions)
    • Useless Catch (Exceptions/UselessCatch)
  • 1.1.3
    • Useless Referenced Argument (Functions/UselessReferenceArgument)
  • 1.1.2
    • Local Globals (Variables/LocalGlobals ; )
    • Missing Include (Files/MissingInclude)
  • 1.1.1
    • Inclusion Wrong Case (Files/InclusionWrongCase)
  • 1.0.11
    • No Net For Xml Load (Security/NoNetForXmlLoad ; Security)
    • Unused Inherited Variable In Closure (Functions/UnusedInheritedVariable)
  • 1.0.10
    • Sqlite3 Requires Single Quotes (Security/Sqlite3RequiresSingleQuotes)
  • 1.0.8
    • Identical Consecutive Expression (Structures/IdenticalConsecutive ; Analyze)
    • Identical On Both Sides (Structures/IdenticalOnBothSides ; Analyze)
    • Mistaken Concatenation (Arrays/MistakenConcatenation)
    • No Reference For Ternary (Php/NoReferenceForTernary ; Analyze)
  • 1.0.7
    • Not A Scalar Type (Php/NotScalarType)
    • Should Use array_filter() (Php/ShouldUseArrayFilter ; Suggestions)
  • 1.0.6
    • Never Used Parameter (Functions/NeverUsedParameter ; Analyze, Suggestions)
    • Use Named Boolean In Argument Definition (Functions/AvoidBooleanArgument ; Analyze)
    • ext/igbinary (Extensions/Extigbinary)
  • 1.0.5
    • Assigned In One Branch (Structures/AssignedInOneBranch ; Under Work)
    • Environment Variables (Variables/UncommonEnvVar ; Appinfo)
    • Invalid Regex (Structures/InvalidRegex ; Analyze)
    • Parent First (Classes/ParentFirst)
    • Same Variables Foreach (Structures/AutoUnsetForeach ; Analyze)
  • 1.0.4
    • Argon2 Usage (Php/Argon2Usage ; Appinfo, Appcontent)
    • Array Index (Type/ArrayIndex ; Inventory, Appinfo)
    • Avoid set_error_handler $context Argument (Php/AvoidSetErrorHandlerContextArg ; CompatibilityPHP72)
    • Can’t Count Non-Countable (Structures/CanCountNonCountable ; CompatibilityPHP72)
    • Crypto Usage (Php/CryptoUsage ; Appinfo, Appcontent)
    • Dl() Usage (Php/DlUsage ; Appinfo)
    • Don’t Send $this In Constructor (Classes/DontSendThisInConstructor ; Analyze)
    • Hash Will Use Objects (Php/HashUsesObjects ; CompatibilityPHP72)
    • Incoming Variable Index Inventory (Type/GPCIndex ; Inventory, Appinfo, Appcontent)
    • Integer As Property (Classes/IntegerAsProperty ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71)
    • Missing New ? (Structures/MissingNew ; Analyze)
    • No get_class() With Null (Structures/NoGetClassNull ; Analyze, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • Php 7.2 New Class (Php/Php72NewClasses ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • Php 7.4 New Class (Php/Php74NewClasses ; CompatibilityPHP74)
    • Slice Arrays First (Arrays/SliceFirst)
    • Unknown Pcre2 Option (Php/UnknownPcre2Option ; Analyze, CompatibilityPHP73)
    • Use List With Foreach (Structures/UseListWithForeach ; Suggestions, Top10)
    • Use PHP7 Encapsed Strings (Performances/PHP7EncapsedStrings ; Performances)
    • ext/vips (Extensions/Extvips ; Appinfo, Appcontent)
  • 1.0.3
    • Ambiguous Static (Classes/AmbiguousStatic)
    • Drupal Usage (Vendors/Drupal ; Appinfo)
    • FuelPHP Usage (Vendors/Fuel ; Appinfo, Appcontent)
    • Phalcon Usage (Vendors/Phalcon ; Appinfo)
  • 1.0.1
    • Could Be Else (Structures/CouldBeElse ; Analyze)
    • Next Month Trap (Structures/NextMonthTrap ; Analyze, Top10)
    • Printf Number Of Arguments (Structures/PrintfArguments ; Analyze)
    • Simple Switch (Performances/SimpleSwitch)
    • Substring First (Performances/SubstrFirst ; Performances, Suggestions, Top10)
  • 0.12.17
    • Is A PHP Magic Property (Classes/IsaMagicProperty)
  • 0.12.16
    • Cookies Variables (Php/CookiesVariables)
    • Date Formats (Php/DateFormats ; Inventory)
    • Incoming Variables (Php/IncomingVariables ; Inventory)
    • Session Variables (Php/SessionVariables ; Inventory)
    • Too Complex Expression (Structures/ComplexExpression ; Appinfo)
    • Unconditional Break In Loop (Structures/UnconditionLoopBreak ; Analyze, Level 3)
  • 0.12.15
    • Always Anchor Regex (Security/AnchorRegex)
    • Is Actually Zero (Structures/IsZero ; Analyze, Level 2)
    • Multiple Type Variable (Structures/MultipleTypeVariable ; Analyze, Level 4)
    • Session Lazy Write (Security/SessionLazyWrite ; Security)
  • 0.12.14
    • Regex Inventory (Type/Regex ; Inventory, Appinfo, Appcontent)
    • Switch Fallthrough (Structures/Fallthrough ; Inventory, Security, Stats)
    • Upload Filename Injection (Security/UploadFilenameInjection)
  • 0.12.12
    • Use pathinfo() Arguments (Php/UsePathinfoArgs ; Performances)
    • ext/parle (Extensions/Extparle)
  • 0.12.11
    • Could Be Protected Class Constant (Classes/CouldBeProtectedConstant ; ClassReview)
    • Could Be Protected Method (Classes/CouldBeProtectedMethod ; ClassReview)
    • Method Could Be Private Method (Classes/CouldBePrivateMethod)
    • Method Used Below (Classes/MethodUsedBelow ; )
    • Pathinfo() Returns May Vary (Php/PathinfoReturns ; Analyze, Level 4)
  • 0.12.10
    • Constant Used Below (Classes/ConstantUsedBelow)
    • Could Be Private Class Constant (Classes/CouldBePrivateConstante ; ClassReview)
  • 0.12.9
    • Shell Favorite (Php/ShellFavorite)
  • 0.12.8
    • ext/fam (Extensions/Extfam)
    • ext/rdkafka (Extensions/Extrdkafka ; Appinfo)
  • 0.12.7
    • Should Use Foreach (Structures/ShouldUseForeach)
  • 0.12.5
    • Logical To in_array (Performances/LogicalToInArray)
    • No Substr Minus One (Php/NoSubstrMinusOne ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70)
  • 0.12.4
    • Assign With And (Php/AssignAnd ; Analyze)
    • Avoid Concat In Loop (Performances/NoConcatInLoop ; Performances, Top10)
    • Child Class Removes Typehint (Classes/ChildRemoveTypehint)
    • Isset Multiple Arguments (Php/IssetMultipleArgs ; Suggestions, php-cs-fixable)
    • Logical Operators Favorite (Php/LetterCharsLogicalFavorite ; Preferences, Top10)
    • No Magic With Array (Classes/NoMagicWithArray ; Analyze, Level 4, LintButWontExec)
    • Optional Parameter (Functions/OptionalParameter ; DefensiveProgrammingTM)
    • PHP 7.2 Object Keyword (Php/Php72ObjectKeyword ; CompatibilityPHP72)
    • ext/xattr (Extensions/Extxattr ; Appinfo)
  • 0.12.3
    • Group Use Trailing Comma (Php/GroupUseTrailingComma ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71)
    • Mismatched Default Arguments (Functions/MismatchedDefaultArguments ; Analyze, Typechecks)
    • Mismatched Typehint (Functions/MismatchedTypehint ; Analyze, Typechecks)
    • Scalar Or Object Property (Classes/ScalarOrObjectProperty)
  • 0.12.2
    • Mkdir Default (Security/MkdirDefault ; Security)
    • ext/lapack (Extensions/Extlapack)
    • strict_types Preference (Php/DeclareStrict ; Appinfo, Preferences)
  • 0.12.1
    • Const Or Define (Structures/ConstDefineFavorite ; Appinfo)
    • Declare strict_types Usage (Php/DeclareStrictType ; Appinfo, Preferences)
    • Encoding Usage (Php/DeclareEncoding)
    • Mismatched Ternary Alternatives (Structures/MismatchedTernary ; Analyze, Suggestions, Level 4)
    • No Return Or Throw In Finally (Structures/NoReturnInFinally ; Security)
    • Ticks Usage (Php/DeclareTicks ; Appinfo, Preferences)
  • 0.12.0
    • Heredoc Delimiter (Structures/HeredocDelimiterFavorite ; Coding Conventions)
    • Multiple Functions Declarations (Functions/MultipleDeclarations ; Appinfo)
    • Non Breakable Space In Names (Structures/NonBreakableSpaceInNames ; Appinfo, Appcontent)
    • ext/swoole (Extensions/Extswoole)
  • 0.11.8
    • Cant Inherit Abstract Method (Classes/CantInheritAbstractMethod)
    • Codeigniter usage (Vendors/Codeigniter ; Appinfo)
    • Ez cms usage (Vendors/Ez ; Appinfo)
    • Joomla usage (Vendors/Joomla ; Appinfo, Appcontent)
    • Laravel usage (Vendors/Laravel ; Appinfo, Appcontent)
    • Symfony usage (Vendors/Symfony ; Appinfo)
    • Use session_start() Options (Php/UseSessionStartOptions ; Suggestions)
    • Wordpress usage (Vendors/Wordpress ; Appinfo)
    • Yii usage (Vendors/Yii ; Appinfo, Appcontent)
  • 0.11.7
    • Forgotten Interface (Interfaces/CouldUseInterface ; Analyze)
    • Order Of Declaration (Classes/OrderOfDeclaration)
  • 0.11.6
    • Concatenation Interpolation Consistence (Structures/ConcatenationInterpolationFavorite ; Preferences)
    • Could Make A Function (Functions/CouldCentralize ; Analyze, Suggestions)
    • Courier Anti-Pattern (Patterns/CourrierAntiPattern ; Appinfo, Appcontent, Dismell)
    • DI Cyclic Dependencies (Classes/TypehintCyclicDependencies ; Dismell)
    • Dependency Injection (Patterns/DependencyInjection ; Appinfo)
    • PSR-13 Usage (Psr/Psr13Usage ; Appinfo)
    • PSR-16 Usage (Psr/Psr16Usage ; Appinfo)
    • PSR-3 Usage (Psr/Psr3Usage ; Appinfo)
    • PSR-6 Usage (Psr/Psr6Usage ; Appinfo)
    • PSR-7 Usage (Psr/Psr7Usage ; Appinfo)
    • Too Many Injections (Classes/TooManyInjections)
    • ext/gender (Extensions/Extgender ; Appinfo)
    • ext/judy (Extensions/Extjudy ; Appinfo)
  • 0.11.5
    • Could Typehint (Functions/CouldTypehint ; Typechecks)
    • Implemented Methods Are Public (Classes/ImplementedMethodsArePublic)
    • Mixed Concat And Interpolation (Structures/MixedConcatInterpolation ; Analyze, Coding Conventions)
    • No Reference On Left Side (Structures/NoReferenceOnLeft ; Analyze)
    • PSR-11 Usage (Psr/Psr11Usage ; Appinfo)
    • ext/stats (Extensions/Extstats ; Appinfo)
  • 0.11.4
    • No Class As Typehint (Functions/NoClassAsTypehint)
    • Use Browscap (Php/UseBrowscap ; Appinfo)
    • Use Debug (Structures/UseDebug ; Appinfo)
  • 0.11.3
    • No Return Used (Functions/NoReturnUsed ; Analyze, Suggestions, Level 4)
    • Only Variable Passed By Reference (Functions/OnlyVariablePassedByReference ; Analyze)
    • Try With Multiple Catch (Php/TryMultipleCatch ; Appinfo)
    • ext/grpc (Extensions/Extgrpc)
    • ext/sphinx (Extensions/Extsphinx ; Appinfo)
  • 0.11.2
    • Alternative Syntax Consistence (Structures/AlternativeConsistenceByFile ; Analyze)
    • Randomly Sorted Arrays (Arrays/RandomlySortedLiterals)
  • 0.11.1
    • Difference Consistence (Structures/DifferencePreference)
    • No Empty Regex (Structures/NoEmptyRegex ; Analyze)
  • 0.11.0
    • Could Use str_repeat() (Structures/CouldUseStrrepeat ; Analyze, Level 1, Top10)
    • Crc32() Might Be Negative (Php/Crc32MightBeNegative ; Analyze, PHP recommendations)
    • Empty Final Element (Arrays/EmptyFinal)
    • Strings With Strange Space (Type/StringWithStrangeSpace ; Analyze)
    • Suspicious Comparison (Structures/SuspiciousComparison ; Analyze, Level 3)
  • 0.10.9
    • Displays Text (Php/Prints ; Internal)
    • Method Is Overwritten (Classes/MethodIsOverwritten)
    • No Class In Global (Php/NoClassInGlobal ; Analyze)
    • Repeated Regex (Structures/RepeatedRegex ; Analyze, Level 1)
  • 0.10.7
    • Group Use Declaration (Php/GroupUseDeclaration)
    • Missing Cases In Switch (Structures/MissingCases ; Analyze)
    • New Constants In PHP 7.2 (Php/Php72NewConstants ; CompatibilityPHP72)
    • New Functions In PHP 7.2 (Php/Php72NewFunctions ; CompatibilityPHP72)
    • New Functions In PHP 7.3 (Php/Php73NewFunctions ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72, CompatibilityPHP73)
  • 0.10.6
    • Check All Types (Structures/CheckAllTypes ; Analyze)
    • Do Not Cast To Int (Php/NoCastToInt ; )
    • Manipulates INF (Php/IsINF)
    • Manipulates NaN (Php/IsNAN ; Appinfo)
    • Set Cookie Safe Arguments (Security/SetCookieArgs ; Security)
    • Should Use SetCookie() (Php/UseSetCookie ; Analyze)
    • Use Cookies (Php/UseCookies ; Appinfo, Appcontent)
  • 0.10.5
    • Could Be Typehinted Callable (Functions/CouldBeCallable ; Suggestions, Typechecks)
    • Encoded Simple Letters (Security/EncodedLetters ; Security)
    • Regex Delimiter (Structures/RegexDelimiter ; Preferences)
    • Strange Name For Constants (Constants/StrangeName ; Analyze)
    • Strange Name For Variables (Variables/StrangeName ; Analyze)
    • Too Many Finds (Classes/TooManyFinds)
  • 0.10.4
    • No Need For Else (Structures/NoNeedForElse ; Analyze)
    • Should Use session_regenerateid() (Security/ShouldUseSessionRegenerateId ; Security)
    • ext/ds (Extensions/Extds)
  • 0.10.3
    • Multiple Alias Definitions Per File (Namespaces/MultipleAliasDefinitionPerFile ; Analyze)
    • Property Used In One Method Only (Classes/PropertyUsedInOneMethodOnly ; Analyze)
    • Used Once Property (Classes/UsedOnceProperty ; Analyze)
    • __DIR__ Then Slash (Structures/DirThenSlash ; Analyze, Level 3)
    • self, parent, static Outside Class (Classes/NoPSSOutsideClass)
  • 0.10.2
    • Class Function Confusion (Php/ClassFunctionConfusion ; Semantics)
    • Forgotten Thrown (Exceptions/ForgottenThrown)
    • Should Use array_column() (Php/ShouldUseArrayColumn ; Performances, Suggestions, Level 4)
    • ext/libsodium (Extensions/Extlibsodium ; Appinfo, Appcontent)
  • 0.10.1
    • All strings (Type/CharString ; Inventory)
    • SQL queries (Type/Sql ; Inventory, Appinfo)
    • Strange Names For Methods (Classes/StrangeName)
  • 0.10.0
    • Error_Log() Usage (Php/ErrorLogUsage ; Appinfo)
    • No Boolean As Default (Functions/NoBooleanAsDefault ; Analyze)
    • Raised Access Level (Classes/RaisedAccessLevel)
  • 0.9.9
    • PHP 7.2 Deprecations (Php/Php72Deprecation)
    • PHP 7.2 Removed Functions (Php/Php72RemovedFunctions ; CompatibilityPHP72)
  • 0.9.8
    • Assigned Twice (Variables/AssignedTwiceOrMore ; Analyze)
    • New Line Style (Structures/NewLineStyle ; Preferences)
    • New On Functioncall Or Identifier (Classes/NewOnFunctioncallOrIdentifier)
  • 0.9.7
    • Avoid Large Array Assignation (Structures/NoAssignationInFunction ; Performances)
    • Could Be Protected Property (Classes/CouldBeProtectedProperty)
    • Long Arguments (Structures/LongArguments ; Analyze)
  • 0.9.6
    • Avoid glob() Usage (Performances/NoGlob ; Performances)
    • Fetch One Row Format (Performances/FetchOneRowFormat)
  • 0.9.5
    • One Expression Brackets Consistency (Structures/OneExpressionBracketsConsistency ; Preferences)
    • Should Use Function (Php/ShouldUseFunction ; Performances)
    • ext/mongodb (Extensions/Extmongodb)
    • ext/zbarcode (Extensions/Extzbarcode ; Appinfo)
  • 0.9.4
    • Class Should Be Final By Ocramius (Classes/FinalByOcramius)
    • String (Extensions/Extstring ; Appinfo, Appcontent)
    • ext/mhash (Extensions/Extmhash ; Appinfo, CompatibilityPHP54, Appcontent)
  • 0.9.3
    • Close Tags Consistency (Php/CloseTagsConsistency)
    • Unset() Or (unset) (Php/UnsetOrCast ; Preferences)
  • 0.9.2
    • $GLOBALS Or global (Php/GlobalsVsGlobal ; Preferences)
    • Illegal Name For Method (Classes/WrongName)
    • Too Many Local Variables (Functions/TooManyLocalVariables ; Analyze)
    • Use Composer Lock (Composer/UseComposerLock ; Appinfo)
    • ext/ncurses (Extensions/Extncurses ; Appinfo)
    • ext/newt (Extensions/Extnewt ; Appinfo)
    • ext/nsapi (Extensions/Extnsapi ; Appinfo)
  • 0.9.1
    • Avoid Using stdClass (Php/UseStdclass ; Analyze, OneFile, Simple, Level 4)
    • Avoid array_push() (Performances/AvoidArrayPush ; Performances, PHP recommendations)
    • Could Return Void (Functions/CouldReturnVoid)
    • Invalid Octal In String (Type/OctalInString ; Inventory, CompatibilityPHP71)
  • 0.9.0
    • Getting Last Element (Arrays/GettingLastElement)
    • Rethrown Exceptions (Exceptions/Rethrown ; Dead code)
  • 0.8.9
    • Array() / [ ] Consistence (Arrays/ArrayBracketConsistence)
    • Bail Out Early (Structures/BailOutEarly ; Analyze, OneFile, Simple, Level 4)
    • Die Exit Consistence (Structures/DieExitConsistance ; Preferences)
    • Dont Change The Blind Var (Structures/DontChangeBlindKey ; Analyze)
    • More Than One Level Of Indentation (Structures/OneLevelOfIndentation ; Calisthenics)
    • One Dot Or Object Operator Per Line (Structures/OneDotOrObjectOperatorPerLine ; Calisthenics)
    • PHP 7.1 Microseconds (Php/Php71microseconds ; CompatibilityPHP71)
    • Unitialized Properties (Classes/UnitializedProperties ; OneFile, Simple, Suggestions, Level 4, Top10)
    • Useless Check (Structures/UselessCheck ; Analyze, OneFile, Simple, Level 1)
  • 0.8.7
    • Don’t Echo Error (Security/DontEchoError ; Analyze, Security, Simple, Level 1)
    • No isset() With empty() (Structures/NoIssetWithEmpty ; Analyze, PHP recommendations, OneFile, RadwellCodes, Simple, Level 4)
    • Use Class Operator (Classes/UseClassOperator)
    • Useless Casting (Structures/UselessCasting ; Analyze, PHP recommendations, OneFile, RadwellCodes, Simple, Level 4)
    • ext/rar (Extensions/Extrar ; Appinfo)
    • time() Vs strtotime() (Performances/timeVsstrtotime ; Performances, OneFile, RadwellCodes)
  • 0.8.6
    • Drop Else After Return (Structures/DropElseAfterReturn)
    • Modernize Empty With Expression (Structures/ModernEmpty ; Analyze, OneFile, Simple)
    • Use Positive Condition (Structures/UsePositiveCondition ; Analyze, OneFile, Simple)
  • 0.8.5
    • Should Make Ternary (Structures/ShouldMakeTernary ; Analyze, OneFile, Simple)
    • Unused Returned Value (Functions/UnusedReturnedValue)
  • 0.8.4
    • $HTTP_RAW_POST_DATA Usage (Php/RawPostDataUsage ; Appinfo, CompatibilityPHP56)
    • $this Belongs To Classes Or Traits (Classes/ThisIsForClasses ; Analyze, Simple)
    • $this Is Not An Array (Classes/ThisIsNotAnArray ; Analyze)
    • $this Is Not For Static Methods (Classes/ThisIsNotForStatic ; Analyze)
    • ** For Exponent (Php/NewExponent ; Suggestions, php-cs-fixable)
    • ::class (Php/StaticclassUsage ; CompatibilityPHP54, CompatibilityPHP53)
    • <?= Usage (Php/EchoTagUsage ; Appinfo, Simple)
    • @ Operator (Structures/Noscream ; Analyze, Appinfo, Performances, ClearPHP)
    • Abstract Class Usage (Classes/Abstractclass ; Appinfo, Appcontent)
    • Abstract Methods Usage (Classes/Abstractmethods ; Appinfo, Appcontent)
    • Abstract Static Methods (Classes/AbstractStatic ; Analyze, Simple)
    • Access Protected Structures (Classes/AccessProtected ; Analyze, Simple)
    • Accessing Private (Classes/AccessPrivate ; Analyze, Simple)
    • Adding Zero (Structures/AddZero ; Analyze, OneFile, ClearPHP, Simple, Level 1)
    • Aliases (Namespaces/Alias ; Appinfo)
    • Aliases Usage (Functions/AliasesUsage ; Analyze, OneFile, ClearPHP, Simple, Level 1)
    • All Uppercase Variables (Variables/VariableUppercase ; Coding Conventions)
    • Already Parents Interface (Interfaces/AlreadyParentsInterface ; Analyze, Suggestions, Level 3)
    • Altering Foreach Without Reference (Structures/AlteringForeachWithoutReference ; Analyze, ClearPHP, Simple, Level 1)
    • Alternative Syntax (Php/AlternativeSyntax ; Appinfo)
    • Always Positive Comparison (Structures/NeverNegative ; Analyze, Simple)
    • Ambiguous Array Index (Arrays/AmbiguousKeys)
    • Anonymous Classes (Classes/Anonymous ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Argument Should Be Typehinted (Functions/ShouldBeTypehinted ; Typechecks)
    • Array Index (Arrays/Arrayindex ; Appinfo)
    • Arrays Is Modified (Arrays/IsModified ; Internal)
    • Arrays Is Read (Arrays/IsRead ; Internal)
    • Assertions (Php/AssertionUsage ; Appinfo)
    • Assign Default To Properties (Classes/MakeDefault ; Analyze, ClearPHP, Simple, Level 2)
    • Autoloading (Php/AutoloadUsage ; Appinfo)
    • Avoid Parenthesis (Structures/PrintWithoutParenthesis ; Analyze, Simple)
    • Avoid Those Hash Functions (Security/AvoidThoseCrypto ; Security)
    • Avoid array_unique() (Structures/NoArrayUnique ; Performances)
    • Avoid get_class() (Structures/UseInstanceof ; Analyze, Simple)
    • Avoid sleep()/usleep() (Security/NoSleep ; Security)
    • Bad Constants Names (Constants/BadConstantnames ; Analyze, PHP recommendations)
    • Binary Glossary (Type/Binary ; Inventory, Appinfo, CompatibilityPHP53)
    • Blind Variables (Variables/Blind ; )
    • Bracketless Blocks (Structures/Bracketless ; Coding Conventions)
    • Break Outside Loop (Structures/BreakOutsideLoop ; Analyze, CompatibilityPHP70)
    • Break With 0 (Structures/Break0 ; CompatibilityPHP53, OneFile)
    • Break With Non Integer (Structures/BreakNonInteger ; CompatibilityPHP54, OneFile)
    • Buried Assignation (Structures/BuriedAssignation ; Analyze)
    • Calltime Pass By Reference (Structures/CalltimePassByReference ; CompatibilityPHP54)
    • Can’t Disable Class (Security/CantDisableClass ; Appinfo)
    • Can’t Disable Function (Security/CantDisableFunction ; Appinfo, Appcontent)
    • Can’t Extend Final (Classes/CantExtendFinal ; Analyze, Dead code, Simple)
    • Cant Use Return Value In Write Context (Php/CantUseReturnValueInWriteContext ; CompatibilityPHP54, CompatibilityPHP53)
    • Cast To Boolean (Structures/CastToBoolean ; Analyze, OneFile, Simple, Level 1)
    • Cast Usage (Php/CastingUsage ; Appinfo)
    • Catch Overwrite Variable (Structures/CatchShadowsVariable ; Analyze, ClearPHP, Simple)
    • Caught Exceptions (Exceptions/CaughtExceptions ; )
    • Caught Expressions (Php/TryCatchUsage ; Appinfo)
    • Class Const With Array (Php/ClassConstWithArray ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • Class Has Fluent Interface (Classes/HasFluentInterface ; )
    • Class Usage (Classes/ClassUsage ; )
    • Class, Interface Or Trait With Identical Names (Classes/CitSameName ; Analyze)
    • Classes Mutually Extending Each Other (Classes/MutualExtension ; LintButWontExec, ClassReview)
    • Classes Names (Classes/Classnames ; Appinfo)
    • Clone Usage (Classes/CloningUsage ; Appinfo)
    • Close Tags (Php/CloseTags ; Coding Conventions)
    • Closure May Use $this (Php/ClosureThisSupport ; CompatibilityPHP53)
    • Closures Glossary (Functions/Closures ; Appinfo)
    • Coalesce (Php/Coalesce ; Appinfo, Appcontent)
    • Common Alternatives (Structures/CommonAlternatives ; Analyze, Simple)
    • Compare Hash (Security/CompareHash ; Security, ClearPHP)
    • Compared Comparison (Structures/ComparedComparison ; Analyze)
    • Composer Namespace (Composer/IsComposerNsname ; Appinfo, Internal)
    • Composer Usage (Composer/UseComposer ; Appinfo)
    • Composer’s autoload (Composer/Autoload ; Appinfo)
    • Concrete Visibility (Interfaces/ConcreteVisibility ; Analyze, Simple, LintButWontExec)
    • Conditional Structures (Structures/ConditionalStructures ; )
    • Conditioned Constants (Constants/ConditionedConstants ; Appinfo, Internal)
    • Conditioned Function (Functions/ConditionedFunctions ; Appinfo, Internal)
    • Confusing Names (Variables/CloseNaming ; Under Work)
    • Const With Array (Php/ConstWithArray ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • Constant Class (Classes/ConstantClass ; Analyze, Simple)
    • Constant Comparison (Structures/ConstantComparisonConsistance ; Coding Conventions, Preferences)
    • Constant Conditions (Structures/ConstantConditions ; )
    • Constant Definition (Classes/ConstantDefinition ; Appinfo, Stats)
    • Constant Scalar Expression (Php/ConstantScalarExpression ; )
    • Constant Scalar Expressions (Structures/ConstantScalarExpression ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • Constants (Constants/Constantnames ; Inventory, Stats)
    • Constants Created Outside Its Namespace (Constants/CreatedOutsideItsNamespace ; Analyze)
    • Constants Usage (Constants/ConstantUsage ; Appinfo)
    • Constants With Strange Names (Constants/ConstantStrangeNames ; Analyze, Simple)
    • Constructors (Classes/Constructor ; Internal)
    • Continents (Type/Continents ; )
    • Could Be Class Constant (Classes/CouldBeClassConstant ; ClassReview)
    • Could Be Static (Structures/CouldBeStatic ; Analyze, OneFile, ClassReview)
    • Could Use Alias (Namespaces/CouldUseAlias ; OneFile, Suggestions)
    • Could Use Short Assignation (Structures/CouldUseShortAssignation ; Analyze, Performances, OneFile, Simple)
    • Could Use __DIR__ (Structures/CouldUseDir ; Analyze, Simple, Suggestions, Level 3, php-cs-fixable)
    • Could Use self (Classes/ShouldUseSelf ; Analyze, Simple, Suggestions, Level 3, ClassReview)
    • Custom Class Usage (Classes/AvoidUsing ; Custom)
    • Custom Constant Usage (Constants/CustomConstantUsage ; )
    • Dangling Array References (Structures/DanglingArrayReferences ; Analyze, PHP recommendations, ClearPHP, Simple, Level 1, Top10)
    • Deep Definitions (Functions/DeepDefinitions ; Analyze, Appinfo, Simple)
    • Define With Array (Php/DefineWithArray ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Defined Class Constants (Classes/DefinedConstants ; Internal)
    • Defined Exceptions (Exceptions/DefinedExceptions ; Appinfo)
    • Defined Parent MP (Classes/DefinedParentMP ; Internal)
    • Defined Properties (Classes/DefinedProperty ; Internal)
    • Defined static:: Or self:: (Classes/DefinedStaticMP ; Internal)
    • Definitions Only (Files/DefinitionsOnly ; Internal)
    • Dependant Trait (Traits/DependantTrait ; Analyze, Level 3)
    • Deprecated Functions (Php/Deprecated ; Analyze)
    • Dereferencing String And Arrays (Structures/DereferencingAS ; Appinfo, CompatibilityPHP54, CompatibilityPHP53)
    • Direct Injection (Security/DirectInjection ; Security)
    • Directives Usage (Php/DirectivesUsage ; Appinfo)
    • Don’t Change Incomings (Structures/NoChangeIncomingVariables ; Analyze)
    • Double Assignation (Structures/DoubleAssignation ; Analyze)
    • Double Instructions (Structures/DoubleInstruction ; Analyze, Simple)
    • Duplicate Calls (Structures/DuplicateCalls ; )
    • Dynamic Calls (Structures/DynamicCalls ; Appinfo, Internal, Stats)
    • Dynamic Class Constant (Classes/DynamicConstantCall ; Appinfo)
    • Dynamic Classes (Classes/DynamicClass ; Appinfo)
    • Dynamic Code (Structures/DynamicCode ; Appinfo)
    • Dynamic Function Call (Functions/Dynamiccall ; Appinfo, Internal, Stats)
    • Dynamic Methodcall (Classes/DynamicMethodCall ; Appinfo)
    • Dynamic New (Classes/DynamicNew ; Appinfo)
    • Dynamic Property (Classes/DynamicPropertyCall ; Appinfo)
    • Dynamically Called Classes (Classes/VariableClasses ; Appinfo, Stats)
    • Echo Or Print (Structures/EchoPrintConsistance ; Coding Conventions, Preferences)
    • Echo With Concat (Structures/EchoWithConcat ; Analyze, Performances, Simple, Suggestions)
    • Ellipsis Usage (Php/EllipsisUsage ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • Else If Versus Elseif (Structures/ElseIfElseif ; Analyze, Simple, php-cs-fixable, Rector)
    • Else Usage (Structures/ElseUsage ; Appinfo, Appcontent, Calisthenics, Stats)
    • Email Addresses (Type/Email ; Inventory, Appinfo)
    • Empty Blocks (Structures/EmptyBlocks ; Analyze, Simple)
    • Empty Classes (Classes/EmptyClass ; Analyze, Simple)
    • Empty Function (Functions/EmptyFunction ; Analyze, Simple)
    • Empty Instructions (Structures/EmptyLines ; Analyze, Dead code, Simple)
    • Empty Interfaces (Interfaces/EmptyInterface ; Analyze, Simple)
    • Empty List (Php/EmptyList ; Analyze, CompatibilityPHP70)
    • Empty Namespace (Namespaces/EmptyNamespace ; Analyze, Dead code, OneFile, Simple)
    • Empty Slots In Arrays (Arrays/EmptySlots ; Coding Conventions)
    • Empty Traits (Traits/EmptyTrait ; Analyze, Simple)
    • Empty Try Catch (Structures/EmptyTryCatch ; Analyze, Level 3)
    • Empty With Expression (Structures/EmptyWithExpression ; OneFile, Suggestions)
    • Error Messages (Structures/ErrorMessages ; Appinfo)
    • Eval() Usage (Structures/EvalUsage ; Analyze, Appinfo, Security, Performances, OneFile, ClearPHP, Simple)
    • Exception Order (Exceptions/AlreadyCaught ; Dead code)
    • Exit() Usage (Structures/ExitUsage ; Analyze, Appinfo, OneFile, ClearPHP)
    • Exit-like Methods (Functions/KillsApp ; Internal)
    • Exponent Usage (Php/ExponentUsage ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • External Config Files (Files/Services ; Internal)
    • Failed Substr Comparison (Structures/FailingSubstrComparison ; Analyze, Simple, Level 3, Top10)
    • File Is Component (Files/IsComponent ; Internal)
    • File Uploads (Structures/FileUploadUsage ; Appinfo)
    • File Usage (Structures/FileUsage ; Appinfo)
    • Final Class Usage (Classes/Finalclass ; LintButWontExec, ClassReview)
    • Final Methods Usage (Classes/Finalmethod ; LintButWontExec, ClassReview)
    • Fopen Binary Mode (Portability/FopenMode ; Portability)
    • For Using Functioncall (Structures/ForWithFunctioncall ; Performances, ClearPHP, Simple, Level 1, Top10)
    • Foreach Don’t Change Pointer (Php/ForeachDontChangePointer ; CompatibilityPHP70)
    • Foreach Needs Reference Array (Structures/ForeachNeedReferencedSource ; Under Work)
    • Foreach Reference Is Not Modified (Structures/ForeachReferenceIsNotModified ; Analyze, Simple)
    • Foreach With list() (Structures/ForeachWithList ; CompatibilityPHP54, CompatibilityPHP53)
    • Forgotten Visibility (Classes/NonPpp ; Analyze, ClearPHP, Simple, Level 1)
    • Forgotten Whitespace (Structures/ForgottenWhiteSpace ; Analyze)
    • Fully Qualified Constants (Namespaces/ConstantFullyQualified ; Analyze)
    • Function Called With Other Case Than Defined (Functions/FunctionCalledWithOtherCase ; )
    • Function Subscripting (Structures/FunctionSubscripting ; Appinfo, CompatibilityPHP53)
    • Function Subscripting, Old Style (Structures/FunctionPreSubscripting ; Suggestions)
    • Functioncall Is Global (Functions/IsGlobal ; Under Work)
    • Functions Glossary (Functions/Functionnames ; Appinfo)
    • Functions In Loop Calls (Functions/LoopCalling ; Under Work)
    • Functions Removed In PHP 5.4 (Php/Php54RemovedFunctions ; CompatibilityPHP54)
    • Functions Removed In PHP 5.5 (Php/Php55RemovedFunctions ; CompatibilityPHP55)
    • Functions Using Reference (Functions/FunctionsUsingReference ; Appinfo, Appcontent)
    • GPRC Aliases (Security/GPRAliases ; Internal)
    • Global Code Only (Files/GlobalCodeOnly ; Internal)
    • Global Import (Namespaces/GlobalImport ; Internal)
    • Global In Global (Structures/GlobalInGlobal ; Appinfo)
    • Global Inside Loop (Structures/GlobalOutsideLoop ; Performances)
    • Global Usage (Structures/GlobalUsage ; Analyze, Appinfo, ClearPHP)
    • Globals (Variables/Globals ; Internal)
    • Goto Names (Php/Gotonames ; Appinfo, ClearPHP)
    • HTTP Status Code (Type/HttpStatus ; Inventory)
    • Hardcoded Passwords (Functions/HardcodedPasswords ; Analyze, Security, OneFile, Simple, Level 3)
    • Has Magic Property (Classes/HasMagicProperty ; Internal)
    • Has Variable Arguments (Functions/VariableArguments ; Appinfo, Internal)
    • Hash Algorithms (Php/HashAlgos ; Analyze, Level 4)
    • Hash Algorithms Incompatible With PHP 5.3 (Php/HashAlgos53 ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • Hash Algorithms Incompatible With PHP 5.4/5.5 (Php/HashAlgos54 ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72)
    • Heredoc Delimiter Glossary (Type/Heredoc ; Appinfo)
    • Hexadecimal Glossary (Type/Hexadecimal ; Inventory, Appinfo)
    • Hexadecimal In String (Type/HexadecimalString ; Inventory, CompatibilityPHP70, CompatibilityPHP71)
    • Hidden Use Expression (Namespaces/HiddenUse ; Analyze, OneFile, Simple)
    • Htmlentities Calls (Structures/Htmlentitiescall ; Analyze, Simple)
    • Http Headers (Type/HttpHeader ; Inventory)
    • Identical Conditions (Structures/IdenticalConditions ; Analyze, Simple)
    • If With Same Conditions (Structures/IfWithSameConditions ; Analyze, Simple)
    • Iffectations (Structures/Iffectation ; Analyze)
    • Implement Is For Interface (Classes/ImplementIsForInterface ; Analyze, Simple)
    • Implicit Global (Structures/ImplicitGlobal ; Analyze)
    • Implied If (Structures/ImpliedIf ; Analyze, ClearPHP, Simple)
    • Inclusions (Structures/IncludeUsage ; Appinfo)
    • Incompilable Files (Php/Incompilable ; Analyze, Appinfo, ClearPHP, Simple)
    • Inconsistent Concatenation (Structures/InconsistentConcatenation ; Internal)
    • Indices Are Int Or String (Structures/IndicesAreIntOrString ; Analyze, OneFile, Simple)
    • Indirect Injection (Security/IndirectInjection ; Security)
    • Instantiating Abstract Class (Classes/InstantiatingAbstractClass ; Analyze, Simple)
    • Interface Arguments (Variables/InterfaceArguments ; )
    • Interface Methods (Interfaces/InterfaceMethod ; )
    • Interfaces Glossary (Interfaces/Interfacenames ; Appinfo)
    • Interfaces Usage (Interfaces/InterfaceUsage ; )
    • Internally Used Properties (Classes/PropertyUsedInternally ; )
    • Internet Ports (Type/Ports ; Inventory)
    • Interpolation (Type/StringInterpolation ; Coding Conventions)
    • Invalid Constant Name (Constants/InvalidName ; Analyze, Simple)
    • Is An Extension Class (Classes/IsExtClass ; )
    • Is An Extension Constant (Constants/IsExtConstant ; Internal, First)
    • Is An Extension Function (Functions/IsExtFunction ; Internal, First)
    • Is An Extension Interface (Interfaces/IsExtInterface ; Internal, First)
    • Is CLI Script (Files/IsCliScript ; Appinfo, Internal)
    • Is Composer Class (Composer/IsComposerClass ; Internal)
    • Is Composer Interface (Composer/IsComposerInterface ; Internal)
    • Is Extension Trait (Traits/IsExtTrait ; Internal, First)
    • Is Generator (Functions/IsGenerator ; Appinfo, Internal)
    • Is Global Constant (Constants/IsGlobalConstant ; Internal)
    • Is Interface Method (Classes/IsInterfaceMethod ; Internal)
    • Is Library (Project/IsLibrary ; )
    • Is Not Class Family (Classes/IsNotFamily ; Internal)
    • Is PHP Constant (Constants/IsPhpConstant ; Internal)
    • Is Upper Family (Classes/IsUpperFamily ; Internal)
    • Joining file() (Performances/JoinFile ; Performances)
    • Labels (Php/Labelnames ; Appinfo)
    • Linux Only Files (Portability/LinuxOnlyFiles ; Portability)
    • List Short Syntax (Php/ListShortSyntax ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, Internal, CompatibilityPHP53, CompatibilityPHP70)
    • List With Appends (Php/ListWithAppends ; CompatibilityPHP70)
    • List With Keys (Php/ListWithKeys ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, Appcontent, CompatibilityPHP53, CompatibilityPHP70)
    • Locally Unused Property (Classes/LocallyUnusedProperty ; Dead code, Simple)
    • Locally Used Property (Classes/LocallyUsedProperty ; Internal)
    • Logical Mistakes (Structures/LogicalMistakes ; Analyze, Simple, Level 1)
    • Logical Should Use Symbolic Operators (Php/LogicalInLetters ; Analyze, OneFile, ClearPHP, Simple, Suggestions, Level 2, Top10, php-cs-fixable)
    • Lone Blocks (Structures/LoneBlock ; Analyze, Simple, Level 4)
    • Lost References (Variables/LostReferences ; Analyze, Simple)
    • Magic Constant Usage (Constants/MagicConstantUsage ; Appinfo)
    • Magic Methods (Classes/MagicMethod ; Appinfo)
    • Magic Visibility (Classes/toStringPss ; CompatibilityPHP70, Simple)
    • Mail Usage (Structures/MailUsage ; Appinfo)
    • Make Global A Property (Classes/MakeGlobalAProperty ; Analyze, Simple)
    • Make One Call With Array (Performances/MakeOneCall ; Performances)
    • Malformed Octal (Type/MalformedOctal ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Mark Callable (Functions/MarkCallable ; Appinfo, Internal, First)
    • Md5 Strings (Type/Md5String ; Inventory, Appinfo)
    • Method Has Fluent Interface (Functions/HasFluentInterface ; )
    • Method Has No Fluent Interface (Functions/HasNotFluentInterface ; )
    • Methodcall On New (Php/MethodCallOnNew ; CompatibilityPHP53)
    • Methods Without Return (Functions/WithoutReturn ; Analyze)
    • Mime Types (Type/MimeType ; Inventory)
    • Mixed Keys Arrays (Arrays/MixedKeys ; CompatibilityPHP54, CompatibilityPHP53)
    • Multidimensional Arrays (Arrays/Multidimensional ; Appinfo)
    • Multiple Alias Definitions (Namespaces/MultipleAliasDefinitions ; Analyze, Simple)
    • Multiple Catch (Structures/MultipleCatch ; Appinfo, Internal)
    • Multiple Class Declarations (Classes/MultipleDeclarations ; Analyze, Simple)
    • Multiple Classes In One File (Classes/MultipleClassesInFile ; Appinfo, Coding Conventions)
    • Multiple Constant Definition (Constants/MultipleConstantDefinition ; Analyze, Simple)
    • Multiple Definition Of The Same Argument (Functions/MultipleSameArguments ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, OneFile, ClearPHP, Simple)
    • Multiple Exceptions Catch() (Exceptions/MultipleCatch ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70)
    • Multiple Identical Trait Or Interface (Classes/MultipleTraitOrInterface ; Analyze, OneFile, Simple)
    • Multiple Index Definition (Arrays/MultipleIdenticalKeys ; Analyze, OneFile, Simple)
    • Multiple Returns (Functions/MultipleReturn ; )
    • Multiples Identical Case (Structures/MultipleDefinedCase ; Analyze, OneFile, ClearPHP, Simple, Level 1)
    • Multiply By One (Structures/MultiplyByOne ; Analyze, OneFile, ClearPHP, Simple, Level 1)
    • Must Return Methods (Functions/MustReturn ; Analyze, Simple, Level 2, LintButWontExec)
    • Namespaces (Namespaces/NamespaceUsage ; Appinfo)
    • Namespaces Glossary (Namespaces/Namespacesnames ; Appinfo)
    • Negative Power (Structures/NegativePow ; Analyze, OneFile, Simple, Level 3)
    • Nested Ifthen (Structures/NestedIfthen ; Analyze, RadwellCodes)
    • Nested Loops (Structures/NestedLoops ; Appinfo)
    • Nested Ternary (Structures/NestedTernary ; Analyze, ClearPHP, Simple, Level 1)
    • Never Used Properties (Classes/PropertyNeverUsed ; Analyze, Simple)
    • New Functions In PHP 5.4 (Php/Php54NewFunctions ; CompatibilityPHP53)
    • New Functions In PHP 5.5 (Php/Php55NewFunctions ; CompatibilityPHP54, CompatibilityPHP53)
    • New Functions In PHP 5.6 (Php/Php56NewFunctions ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • New Functions In PHP 7.0 (Php/Php70NewFunctions ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • New Functions In PHP 7.1 (Php/Php71NewFunctions ; CompatibilityPHP71)
    • No Choice (Structures/NoChoice ; Analyze, Simple, Level 2, Top10)
    • No Count With 0 (Performances/NotCountNull ; Performances)
    • No Direct Access (Structures/NoDirectAccess ; Appinfo)
    • No Direct Call To Magic Method (Classes/DirectCallToMagicMethod ; Analyze, Level 2)
    • No Direct Usage (Structures/NoDirectUsage ; Analyze, Simple)
    • No Hardcoded Hash (Structures/NoHardcodedHash ; Analyze, Security, Simple)
    • No Hardcoded Ip (Structures/NoHardcodedIp ; Analyze, Security, ClearPHP, Simple)
    • No Hardcoded Path (Structures/NoHardcodedPath ; Analyze, ClearPHP, Simple)
    • No Hardcoded Port (Structures/NoHardcodedPort ; Analyze, Security, ClearPHP, Simple)
    • No List With String (Php/NoListWithString ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • No Parenthesis For Language Construct (Structures/NoParenthesisForLanguageConstruct ; Analyze, ClearPHP, RadwellCodes, Simple, Suggestions, Level 2)
    • No Plus One (Structures/PlusEgalOne ; Coding Conventions, OneFile)
    • No Public Access (Classes/NoPublicAccess ; Analyze)
    • No Real Comparison (Type/NoRealComparison ; Analyze, Simple, Level 2, Top10)
    • No Self Referencing Constant (Classes/NoSelfReferencingConstant ; Analyze, Simple, LintButWontExec, ClassReview)
    • No String With Append (Php/NoStringWithAppend ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • No Substr() One (Structures/NoSubstrOne ; Analyze, Performances, CompatibilityPHP71, Simple, Suggestions, Level 2, Top10)
    • No array_merge() In Loops (Performances/ArrayMergeInLoops ; Analyze, Performances, ClearPHP, Simple, Level 2, Top10)
    • Non Ascii Variables (Variables/VariableNonascii ; Analyze)
    • Non Static Methods Called In A Static (Classes/NonStaticMethodsCalledStatic ; Analyze, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, Simple)
    • Non-constant Index In Array (Arrays/NonConstantArray ; Analyze, Simple)
    • Non-lowercase Keywords (Php/UpperCaseKeyword ; Coding Conventions, RadwellCodes)
    • Normal Methods (Classes/NormalMethods ; Appcontent)
    • Normal Property (Classes/NormalProperty ; Under Work)
    • Not Definitions Only (Files/NotDefinitionsOnly ; Appinfo)
    • Not Not (Structures/NotNot ; Analyze, OneFile, Simple)
    • Not Same Name As File (Classes/NotSameNameAsFile ; )
    • Not Same Name As File (Classes/SameNameAsFile ; Internal)
    • Nowdoc Delimiter Glossary (Type/Nowdoc ; Appinfo)
    • Null Coalesce (Php/NullCoalesce ; )
    • Null On New (Classes/NullOnNew ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, OneFile, Simple)
    • Objects Don’t Need References (Structures/ObjectReferences ; Analyze, OneFile, ClearPHP, Simple, Level 2, Top10)
    • Octal Glossary (Type/Octal ; Appinfo)
    • Old Style Constructor (Classes/OldStyleConstructor ; Analyze, Appinfo, OneFile, ClearPHP, Simple)
    • Old Style __autoload() (Php/oldAutoloadUsage ; Analyze, OneFile, ClearPHP, Simple)
    • One Letter Functions (Functions/OneLetterFunctions ; Coding Conventions, Semantics)
    • One Object Operator Per Line (Classes/OneObjectOperatorPerLine ; Calisthenics)
    • One Variable String (Type/OneVariableStrings ; Analyze, RadwellCodes, Simple)
    • Only Static Methods (Classes/OnlyStaticMethods ; Internal)
    • Only Variable Returned By Reference (Structures/OnlyVariableReturnedByReference ; Analyze, Simple)
    • Or Die (Structures/OrDie ; Analyze, OneFile, ClearPHP, Simple)
    • Overwriting Variable (Variables/Overwriting ; )
    • Overwritten Class Const (Classes/OverwrittenConst ; Appinfo)
    • Overwritten Exceptions (Exceptions/OverwriteException ; Analyze, Simple, Suggestions, Level 4)
    • Overwritten Literals (Variables/OverwrittenLiterals ; Analyze)
    • PHP 7.0 New Classes (Php/Php70NewClasses ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • PHP 7.0 New Interfaces (Php/Php70NewInterfaces ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • PHP 7.0 Removed Directives (Php/Php70RemovedDirective ; CompatibilityPHP70, CompatibilityPHP71)
    • PHP 7.0 Removed Functions (Php/Php70RemovedFunctions ; CompatibilityPHP70, CompatibilityPHP71)
    • PHP 7.1 Removed Directives (Php/Php71RemovedDirective ; CompatibilityPHP71)
    • PHP Arrays Index (Arrays/Phparrayindex ; Appinfo)
    • PHP Bugfixes (Php/MiddleVersion ; Appinfo, Appcontent)
    • PHP Constant Usage (Constants/PhpConstantUsage ; Appinfo)
    • PHP Handlers Usage (Php/SetHandlers ; )
    • PHP Interfaces (Interfaces/Php ; )
    • PHP Keywords As Names (Php/ReservedNames ; Analyze, Simple)
    • PHP Sapi (Type/Sapi ; Internal)
    • PHP Variables (Variables/VariablePhp ; )
    • PHP5 Indirect Variable Expression (Variables/Php5IndirectExpression ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • PHP7 Dirname (Structures/PHP7Dirname ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, Suggestions, php-cs-fixable)
    • Parent, Static Or Self Outside Class (Classes/PssWithoutClass ; Analyze, Simple)
    • Parenthesis As Parameter (Php/ParenthesisAsParameter ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Pear Usage (Php/PearUsage ; Appinfo, Appcontent)
    • Perl Regex (Type/Pcre ; Inventory)
    • Php 7 Indirect Expression (Variables/Php7IndirectExpression ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70)
    • Php 7.1 New Class (Php/Php71NewClasses ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70)
    • Php7 Relaxed Keyword (Php/Php7RelaxedKeyword ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Phpinfo (Structures/PhpinfoUsage ; Security, OneFile, Simple)
    • Pre-increment (Performances/PrePostIncrement ; Analyze, Performances, Simple, Level 4)
    • Preprocess Arrays (Arrays/ShouldPreprocess ; Suggestions)
    • Preprocessable (Structures/ShouldPreprocess ; Analyze, Rector)
    • Print And Die (Structures/PrintAndDie ; Analyze, Simple)
    • Property Could Be Private Property (Classes/CouldBePrivate ; ClassReview)
    • Property Is Modified (Classes/IsModified ; Internal)
    • Property Is Read (Classes/IsRead ; Internal)
    • Property Names (Classes/PropertyDefinition ; Internal)
    • Property Used Above (Classes/PropertyUsedAbove ; Internal)
    • Property Used Below (Classes/PropertyUsedBelow ; Internal)
    • Property Variable Confusion (Structures/PropertyVariableConfusion ; Semantics)
    • Queries In Loops (Structures/QueriesInLoop ; Analyze, OneFile, Simple, Level 1, Top10)
    • Random Without Try (Structures/RandomWithoutTry ; Security)
    • Real Functions (Functions/RealFunctions ; Appcontent, Stats)
    • Real Variables (Variables/RealVariables ; Appcontent, Stats)
    • Recursive Functions (Functions/Recursive ; Appinfo)
    • Redeclared PHP Functions (Functions/RedeclaredPhpFunction ; Analyze, Appinfo, Simple)
    • Redefined Class Constants (Classes/RedefinedConstants ; Analyze, Simple)
    • Redefined Default (Classes/RedefinedDefault ; Analyze, Simple)
    • Redefined Methods (Classes/RedefinedMethods ; Appinfo)
    • Redefined PHP Traits (Traits/Php ; Appinfo)
    • Redefined Property (Classes/RedefinedProperty ; ClassReview)
    • References (Variables/References ; Appinfo)
    • Register Globals (Security/RegisterGlobals ; Security)
    • Relay Function (Functions/RelayFunction ; Analyze)
    • Repeated print() (Structures/RepeatedPrint ; Analyze, Simple, Suggestions, Level 3, Top10)
    • Reserved Keywords In PHP 7 (Php/ReservedKeywords7 ; CompatibilityPHP70)
    • Resources Usage (Structures/ResourcesUsage ; Appinfo)
    • Results May Be Missing (Structures/ResultMayBeMissing ; Analyze, Simple)
    • Return True False (Structures/ReturnTrueFalse ; Analyze, Simple, Level 1)
    • Return Typehint Usage (Php/ReturnTypehintUsage ; Appinfo, Internal)
    • Return With Parenthesis (Php/ReturnWithParenthesis ; Coding Conventions, PHP recommendations, Suggestions)
    • Return void (Structures/ReturnVoid ; )
    • Safe Curl Options (Security/CurlOptions ; Security)
    • Same Conditions In Condition (Structures/SameConditions ; Analyze, Simple)
    • Scalar Typehint Usage (Php/ScalarTypehintUsage ; Appinfo)
    • Sensitive Argument (Security/SensitiveArgument ; Internal)
    • Sequences In For (Structures/SequenceInFor ; )
    • Setlocale() Uses Constants (Structures/SetlocaleNeedsConstants ; CompatibilityPHP70)
    • Several Instructions On The Same Line (Structures/OneLineTwoInstructions ; Analyze)
    • Shell Usage (Structures/ShellUsage ; Appinfo)
    • Short Open Tags (Php/ShortOpenTagRequired ; Analyze, Simple)
    • Short Syntax For Arrays (Arrays/ArrayNSUsage ; Appinfo, CompatibilityPHP53)
    • Should Be Single Quote (Type/ShouldBeSingleQuote ; Coding Conventions, ClearPHP)
    • Should Chain Exception (Structures/ShouldChainException ; Analyze, Simple)
    • Should Make Alias (Namespaces/ShouldMakeAlias ; Analyze, OneFile, Simple)
    • Should Typecast (Type/ShouldTypecast ; Analyze, OneFile, Simple)
    • Should Use Coalesce (Php/ShouldUseCoalesce ; Analyze, Simple, Suggestions, Level 3)
    • Should Use Constants (Functions/ShouldUseConstants ; Analyze, Simple)
    • Should Use Local Class (Classes/ShouldUseThis ; Analyze, ClearPHP, Simple)
    • Should Use Prepared Statement (Security/ShouldUsePreparedStatement ; Analyze, Security, Simple)
    • Silently Cast Integer (Type/SilentlyCastInteger ; Analyze, Simple)
    • Simple Global Variable (Php/GlobalWithoutSimpleVariable ; CompatibilityPHP70)
    • Simplify Regex (Structures/SimplePreg ; Performances)
    • Slow Functions (Performances/SlowFunctions ; Performances, OneFile)
    • Special Integers (Type/SpecialIntegers ; Inventory)
    • Static Loop (Structures/StaticLoop ; Analyze, Simple, Level 4)
    • Static Methods (Classes/StaticMethods ; Appinfo)
    • Static Methods Called From Object (Classes/StaticMethodsCalledFromObject ; Analyze, Simple)
    • Static Methods Can’t Contain $this (Classes/StaticContainsThis ; Analyze, ClearPHP, Simple, Level 1)
    • Static Properties (Classes/StaticProperties ; Appinfo)
    • Static Variables (Variables/StaticVariables ; Appinfo)
    • Strict Comparison With Booleans (Structures/BooleanStrictComparison ; Analyze, Simple, Suggestions, Level 2)
    • String May Hold A Variable (Type/StringHoldAVariable ; Analyze, Simple)
    • String glossary (Type/String ; )
    • Strpos()-like Comparison (Structures/StrposCompare ; Analyze, PHP recommendations, ClearPHP, Simple, Level 2, Top10)
    • Super Global Usage (Php/SuperGlobalUsage ; Appinfo)
    • Super Globals Contagion (Security/SuperGlobalContagion ; Internal)
    • Switch To Switch (Structures/SwitchToSwitch ; Analyze, RadwellCodes, Simple)
    • Switch With Too Many Default (Structures/SwitchWithMultipleDefault ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, ClearPHP, Simple)
    • Switch Without Default (Structures/SwitchWithoutDefault ; Analyze, ClearPHP, Simple)
    • Ternary In Concat (Structures/TernaryInConcat ; Analyze, Simple, Level 3)
    • Test Class (Classes/TestClass ; Appinfo)
    • Throw (Php/ThrowUsage ; Appinfo)
    • Throw Functioncall (Exceptions/ThrowFunctioncall ; Analyze, Simple, Level 1)
    • Throw In Destruct (Classes/ThrowInDestruct ; Analyze, Simple)
    • Thrown Exceptions (Exceptions/ThrownExceptions ; Appinfo)
    • Throws An Assignement (Structures/ThrowsAndAssign ; Analyze, Simple)
    • Timestamp Difference (Structures/TimestampDifference ; Analyze, Simple, Level 3)
    • Too Many Children (Classes/TooManyChildren ; Suggestions)
    • Trait Methods (Traits/TraitMethod ; )
    • Trait Names (Traits/Traitnames ; Appinfo)
    • Traits Usage (Traits/TraitUsage ; Appinfo)
    • Trigger Errors (Php/TriggerErrorUsage ; Appinfo)
    • True False Inconsistant Case (Constants/InconsistantCase ; Preferences)
    • Try With Finally (Structures/TryFinally ; Appinfo, Internal)
    • Typehints (Functions/Typehints ; Appinfo)
    • URL List (Type/Url ; Inventory, Appinfo)
    • Uncaught Exceptions (Exceptions/UncaughtExceptions ; Analyze)
    • Unchecked Resources (Structures/UncheckedResources ; Analyze, ClearPHP, Simple, Level 2)
    • Undefined Caught Exceptions (Exceptions/CaughtButNotThrown ; Dead code)
    • Undefined Class Constants (Classes/UndefinedConstants ; Analyze)
    • Undefined Classes (Classes/UndefinedClasses ; Analyze)
    • Undefined Constants (Constants/UndefinedConstants ; Analyze, CompatibilityPHP72, Simple)
    • Undefined Functions (Functions/UndefinedFunctions ; Analyze)
    • Undefined Interfaces (Interfaces/UndefinedInterfaces ; Analyze)
    • Undefined Parent (Classes/UndefinedParentMP ; Analyze, Simple)
    • Undefined Properties (Classes/UndefinedProperty ; Analyze, ClearPHP, Simple)
    • Undefined Trait (Traits/UndefinedTrait ; Analyze, LintButWontExec)
    • Undefined static:: Or self:: (Classes/UndefinedStaticMP ; Analyze, Simple)
    • Unicode Blocks (Type/UnicodeBlock ; Inventory)
    • Unicode Escape Partial (Php/UnicodeEscapePartial ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Unicode Escape Syntax (Php/UnicodeEscapeSyntax ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • Unknown Directive Name (Php/DirectiveName ; Internal)
    • Unkown Regex Options (Structures/UnknownPregOption ; Analyze, Simple)
    • Unpreprocessed Values (Structures/Unpreprocessed ; Analyze, OneFile, ClearPHP, Simple)
    • Unreachable Code (Structures/UnreachableCode ; Dead code, OneFile, ClearPHP, Simple, Suggestions, Level 3)
    • Unresolved Catch (Classes/UnresolvedCatch ; Dead code, ClearPHP)
    • Unresolved Classes (Classes/UnresolvedClasses ; Analyze)
    • Unresolved Instanceof (Classes/UnresolvedInstanceof ; Analyze, Dead code, ClearPHP, Simple, Top10)
    • Unresolved Use (Namespaces/UnresolvedUse ; Analyze, ClearPHP, Simple)
    • Unserialize Second Arg (Security/UnserializeSecondArg ; Security)
    • Unset Arguments (Functions/UnsetOnArguments ; OneFile)
    • Unset In Foreach (Structures/UnsetInForeach ; Analyze, Dead code, OneFile, Simple)
    • Unthrown Exception (Exceptions/Unthrown ; Analyze, Dead code, ClearPHP, Simple)
    • Unused Arguments (Functions/UnusedArguments ; Analyze, Simple)
    • Unused Classes (Classes/UnusedClass ; Analyze, Dead code, Simple)
    • Unused Constants (Constants/UnusedConstants ; Dead code, Simple)
    • Unused Functions (Functions/UnusedFunctions ; Dead code, Simple)
    • Unused Global (Structures/UnusedGlobal ; Analyze, Simple)
    • Unused Interfaces (Interfaces/UnusedInterfaces ; Dead code, Simple, Suggestions, Level 2)
    • Unused Label (Structures/UnusedLabel ; Dead code, Simple)
    • Unused Methods (Classes/UnusedMethods ; Dead code, Simple)
    • Unused Private Methods (Classes/UnusedPrivateMethod ; Dead code, OneFile, Simple)
    • Unused Private Properties (Classes/UnusedPrivateProperty ; Dead code, OneFile, Simple)
    • Unused Protected Methods (Classes/UnusedProtectedMethods ; Dead code)
    • Unused Traits (Traits/UnusedTrait ; Simple)
    • Unused Use (Namespaces/UnusedUse ; Dead code, ClearPHP, Simple)
    • Unusual Case For PHP Functions (Php/UpperCaseFunction ; Coding Conventions)
    • Usage Of class_alias() (Classes/ClassAliasUsage ; Appinfo)
    • Use === null (Php/IsnullVsEqualNull ; Analyze, OneFile, RadwellCodes, Simple, php-cs-fixable)
    • Use Cli (Php/UseCli ; Appinfo)
    • Use Const And Functions (Namespaces/UseFunctionsConstants ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • Use Constant (Structures/UseConstant ; Analyze, PHP recommendations, php-cs-fixable)
    • Use Constant As Arguments (Functions/UseConstantAsArguments ; Analyze, Simple)
    • Use Instanceof (Classes/UseInstanceof ; Analyze, Simple)
    • Use Lower Case For Parent, Static And Self (Php/CaseForPSS ; CompatibilityPHP54, CompatibilityPHP53)
    • Use Nullable Type (Php/UseNullableType ; Appinfo, CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53, CompatibilityPHP70)
    • Use PHP Object API (Php/UseObjectApi ; Analyze, ClearPHP, Simple)
    • Use Pathinfo (Php/UsePathinfo ; Analyze, Simple, Level 3)
    • Use System Tmp (Structures/UseSystemTmp ; Analyze, Simple, Level 3)
    • Use This (Classes/UseThis ; Internal)
    • Use Web (Php/UseWeb ; Appinfo)
    • Use With Fully Qualified Name (Namespaces/UseWithFullyQualifiedNS ; Analyze, Coding Conventions, PHP recommendations, Simple)
    • Use const (Constants/ConstRecommended ; Analyze, Coding Conventions, Top10)
    • Use password_hash() (Php/Password55 ; CompatibilityPHP55)
    • Use random_int() (Php/BetterRand ; Analyze, Security, CompatibilityPHP71, Simple, Level 2)
    • Used Classes (Classes/UsedClass ; Internal)
    • Used Functions (Functions/UsedFunctions ; Internal)
    • Used Interfaces (Interfaces/UsedInterfaces ; Internal)
    • Used Methods (Classes/UsedMethods ; Internal)
    • Used Once Variables (In Scope) (Variables/VariableUsedOnceByContext ; Analyze, OneFile, ClearPHP, Simple, Level 4)
    • Used Once Variables (Variables/VariableUsedOnce ; Analyze, OneFile, Simple, Top10)
    • Used Private Methods (Classes/UsedPrivateMethod ; Internal)
    • Used Protected Method (Classes/UsedProtectedMethod ; )
    • Used Static Properties (Classes/UsedPrivateProperty ; Internal)
    • Used Trait (Traits/UsedTrait ; Internal)
    • Used Use (Namespaces/UsedUse ; )
    • Useless Abstract Class (Classes/UselessAbstract ; Analyze, Simple)
    • Useless Brackets (Structures/UselessBrackets ; Analyze, RadwellCodes, Simple)
    • Useless Constructor (Classes/UselessConstructor ; Analyze, Simple, Level 3)
    • Useless Final (Classes/UselessFinal ; Analyze, OneFile, ClearPHP, Simple)
    • Useless Global (Structures/UselessGlobal ; Analyze, OneFile, Simple, Level 2)
    • Useless Instructions (Structures/UselessInstruction ; Analyze, OneFile, ClearPHP, Simple, Level 1)
    • Useless Interfaces (Interfaces/UselessInterfaces ; Analyze, ClearPHP, Simple, ClassReview, Typechecks)
    • Useless Parenthesis (Structures/UselessParenthesis ; Analyze, Simple)
    • Useless Return (Functions/UselessReturn ; Analyze, OneFile, Simple, Level 4)
    • Useless Switch (Structures/UselessSwitch ; Analyze, Simple)
    • Useless Unset (Structures/UselessUnset ; Analyze, OneFile, ClearPHP, Simple, Level 2)
    • Uses Default Values (Functions/UsesDefaultArguments ; Analyze, Simple)
    • Uses Environment (Php/UsesEnv ; Appinfo, Appcontent)
    • Using $this Outside A Class (Classes/UsingThisOutsideAClass ; Analyze, CompatibilityPHP71, Simple, LintButWontExec)
    • Using Short Tags (Structures/ShortTags ; Appinfo)
    • Usort Sorting In PHP 7.0 (Php/UsortSorting ; CompatibilityPHP70)
    • Var Keyword (Classes/OldStyleVar ; Analyze, OneFile, ClearPHP, Simple, Level 1)
    • Variable Constants (Constants/VariableConstant ; Appinfo, Stats)
    • Variable Is Modified (Variables/IsModified ; Internal)
    • Variable Is Read (Variables/IsRead ; Internal)
    • Variables Variables (Variables/VariableVariables ; Appinfo, Stats)
    • Variables With Long Names (Variables/VariableLong ; Appinfo)
    • Variables With One Letter Names (Variables/VariableOneLetter ; Semantics)
    • While(List() = Each()) (Structures/WhileListEach ; Analyze, Performances, OneFile, Simple, Suggestions, Level 2)
    • Written Only Variables (Variables/WrittenOnlyVariable ; Analyze, OneFile, Simple)
    • Wrong Class Name Case (Classes/WrongCase ; Coding Conventions, RadwellCodes, Simple)
    • Wrong Function Name Case (Functions/WrongCase ; Coding Conventions)
    • Wrong Number Of Arguments (Functions/WrongNumberOfArguments ; Analyze, OneFile, Simple)
    • Wrong Number Of Arguments In Methods (Functions/WrongNumberOfArgumentsMethods ; Under Work)
    • Wrong Optional Parameter (Functions/WrongOptionalParameter ; Analyze, Simple, Level 1)
    • Wrong Parameter Type (Php/InternalParameterType ; Analyze, OneFile, Simple)
    • Wrong fopen() Mode (Php/FopenMode ; Analyze)
    • Yield From Usage (Php/YieldFromUsage ; Appinfo, Appcontent)
    • Yield Usage (Php/YieldUsage ; Appinfo, Appcontent)
    • Yoda Comparison (Structures/YodaComparison ; Coding Conventions)
    • __debugInfo() Usage (Php/debugInfoUsage ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP53)
    • __halt_compiler (Php/Haltcompiler ; Appinfo)
    • __toString() Throws Exception (Structures/toStringThrowsException ; Analyze, OneFile, Simple)
    • crypt() Without Salt (Structures/CryptWithoutSalt ; CompatibilityPHP54)
    • error_reporting() With Integers (Structures/ErrorReportingWithInteger ; Analyze, Simple)
    • eval() Without Try (Structures/EvalWithoutTry ; Analyze, Security, Simple, Level 3)
    • ext/0mq (Extensions/Extzmq ; Appinfo)
    • ext/amqp (Extensions/Extamqp ; Appinfo)
    • ext/apache (Extensions/Extapache ; Appinfo)
    • ext/apc (Extensions/Extapc ; Appinfo, CompatibilityPHP55)
    • ext/apcu (Extensions/Extapcu ; Appinfo)
    • ext/array (Extensions/Extarray ; Appinfo)
    • ext/bcmath (Extensions/Extbcmath ; Appinfo)
    • ext/bzip2 (Extensions/Extbzip2 ; Appinfo)
    • ext/cairo (Extensions/Extcairo ; Appinfo)
    • ext/calendar (Extensions/Extcalendar ; Appinfo)
    • ext/com (Extensions/Extcom ; Appinfo)
    • ext/crypto (Extensions/Extcrypto ; Appinfo)
    • ext/ctype (Extensions/Extctype ; Appinfo)
    • ext/curl (Extensions/Extcurl ; Appinfo)
    • ext/cyrus (Extensions/Extcyrus ; Appinfo)
    • ext/date (Extensions/Extdate ; Appinfo)
    • ext/dba (Extensions/Extdba ; Appinfo, CompatibilityPHP53)
    • ext/dio (Extensions/Extdio ; Appinfo)
    • ext/dom (Extensions/Extdom ; Appinfo)
    • ext/eaccelerator (Extensions/Exteaccelerator ; Appinfo)
    • ext/enchant (Extensions/Extenchant ; Appinfo)
    • ext/ereg (Extensions/Extereg ; Appinfo, CompatibilityPHP70)
    • ext/ev (Extensions/Extev ; Appinfo)
    • ext/event (Extensions/Extevent ; Appinfo)
    • ext/exif (Extensions/Extexif ; Appinfo)
    • ext/expect (Extensions/Extexpect ; Appinfo)
    • ext/fann (Extensions/Extfann ; Appinfo)
    • ext/fdf (Extensions/Extfdf ; Appinfo, CompatibilityPHP53)
    • ext/ffmpeg (Extensions/Extffmpeg ; Appinfo)
    • ext/file (Extensions/Extfile ; Appinfo)
    • ext/fileinfo (Extensions/Extfileinfo ; Appinfo)
    • ext/filter (Extensions/Extfilter ; Appinfo)
    • ext/fpm (Extensions/Extfpm ; Appinfo)
    • ext/ftp (Extensions/Extftp ; Appinfo)
    • ext/gd (Extensions/Extgd ; Appinfo)
    • ext/gearman (Extensions/Extgearman ; Appinfo)
    • ext/geoip (Extensions/Extgeoip ; Appinfo)
    • ext/gettext (Extensions/Extgettext ; Appinfo)
    • ext/gmagick (Extensions/Extgmagick ; Appinfo)
    • ext/gmp (Extensions/Extgmp ; Appinfo)
    • ext/gnupgp (Extensions/Extgnupg ; Appinfo)
    • ext/hash (Extensions/Exthash ; Appinfo)
    • ext/ibase (Extensions/Extibase ; Appinfo)
    • ext/iconv (Extensions/Exticonv ; Appinfo)
    • ext/iis (Extensions/Extiis ; Appinfo, Portability)
    • ext/imagick (Extensions/Extimagick ; Appinfo)
    • ext/imap (Extensions/Extimap ; Appinfo)
    • ext/info (Extensions/Extinfo ; Appinfo)
    • ext/inotify (Extensions/Extinotify ; Appinfo)
    • ext/intl (Extensions/Extintl ; Appinfo)
    • ext/json (Extensions/Extjson ; Appinfo)
    • ext/kdm5 (Extensions/Extkdm5 ; Appinfo)
    • ext/ldap (Extensions/Extldap ; Appinfo)
    • ext/libevent (Extensions/Extlibevent ; Appinfo)
    • ext/libxml (Extensions/Extlibxml ; Appinfo)
    • ext/lua (Extensions/Extlua ; Appinfo)
    • ext/mail (Extensions/Extmail ; Appinfo)
    • ext/mailparse (Extensions/Extmailparse ; Appinfo)
    • ext/math (Extensions/Extmath ; Appinfo)
    • ext/mbstring (Extensions/Extmbstring ; Appinfo)
    • ext/mcrypt (Extensions/Extmcrypt ; Appinfo, CompatibilityPHP71)
    • ext/memcache (Extensions/Extmemcache ; Appinfo)
    • ext/memcached (Extensions/Extmemcached ; Appinfo)
    • ext/ming (Extensions/Extming ; Appinfo, CompatibilityPHP53)
    • ext/mongo (Extensions/Extmongo ; Appinfo)
    • ext/mssql (Extensions/Extmssql ; Appinfo)
    • ext/mysql (Extensions/Extmysql ; Appinfo, CompatibilityPHP55)
    • ext/mysqli (Extensions/Extmysqli ; Appinfo)
    • ext/ob (Extensions/Extob ; Appinfo)
    • ext/oci8 (Extensions/Extoci8 ; Appinfo)
    • ext/odbc (Extensions/Extodbc ; Appinfo)
    • ext/opcache (Extensions/Extopcache ; Appinfo)
    • ext/openssl (Extensions/Extopenssl ; Appinfo)
    • ext/parsekit (Extensions/Extparsekit ; Appinfo)
    • ext/password (Extensions/Extpassword ; Appinfo, Appcontent)
    • ext/pcntl (Extensions/Extpcntl ; Appinfo)
    • ext/pcre (Extensions/Extpcre ; Appinfo)
    • ext/pdo (Extensions/Extpdo ; Appinfo)
    • ext/pecl_http (Extensions/Exthttp ; Appinfo, Appcontent)
    • ext/pgsql (Extensions/Extpgsql ; Appinfo)
    • ext/phalcon (Extensions/Extphalcon ; Appinfo)
    • ext/phar (Extensions/Extphar ; Appinfo)
    • ext/php-ast (Extensions/Extast ; Appinfo)
    • ext/posix (Extensions/Extposix ; Appinfo)
    • ext/proctitle (Extensions/Extproctitle ; Appinfo)
    • ext/pspell (Extensions/Extpspell ; Appinfo)
    • ext/readline (Extensions/Extreadline ; Appinfo)
    • ext/recode (Extensions/Extrecode ; Appinfo, Portability)
    • ext/redis (Extensions/Extredis ; Appinfo)
    • ext/reflection (Extensions/Extreflection ; Appinfo)
    • ext/runkit (Extensions/Extrunkit ; Appinfo)
    • ext/sem (Extensions/Extsem ; Appinfo)
    • ext/session (Extensions/Extsession ; Appinfo)
    • ext/shmop (Extensions/Extshmop ; Appinfo)
    • ext/simplexml (Extensions/Extsimplexml ; Appinfo)
    • ext/snmp (Extensions/Extsnmp ; Appinfo)
    • ext/soap (Extensions/Extsoap ; Appinfo)
    • ext/sockets (Extensions/Extsockets ; Appinfo)
    • ext/spl (Extensions/Extspl ; Appinfo)
    • ext/sqlite (Extensions/Extsqlite ; Appinfo)
    • ext/sqlite3 (Extensions/Extsqlite3 ; Appinfo)
    • ext/sqlsrv (Extensions/Extsqlsrv ; Appinfo)
    • ext/ssh2 (Extensions/Extssh2 ; Appinfo)
    • ext/standard (Extensions/Extstandard ; Appinfo)
    • ext/suhosin (Extensions/Extsuhosin ; Appinfo)
    • ext/tidy (Extensions/Exttidy ; Appinfo)
    • ext/tokenizer (Extensions/Exttokenizer ; Appinfo)
    • ext/tokyotyrant (Extensions/Exttokyotyrant ; Appinfo)
    • ext/trader (Extensions/Exttrader ; Appinfo)
    • ext/v8js (Extensions/Extv8js ; Appinfo)
    • ext/wddx (Extensions/Extwddx ; Appinfo)
    • ext/wikidiff2 (Extensions/Extwikidiff2 ; Appinfo)
    • ext/wincache (Extensions/Extwincache ; Appinfo, Portability)
    • ext/xcache (Extensions/Extxcache ; Appinfo)
    • ext/xdebug (Extensions/Extxdebug ; Appinfo)
    • ext/xdiff (Extensions/Extxdiff ; Appinfo)
    • ext/xhprof (Extensions/Extxhprof ; Appinfo)
    • ext/xml (Extensions/Extxml ; Appinfo)
    • ext/xmlreader (Extensions/Extxmlreader ; Appinfo)
    • ext/xmlrpc (Extensions/Extxmlrpc ; Appinfo)
    • ext/xmlwriter (Extensions/Extxmlwriter ; Appinfo)
    • ext/xsl (Extensions/Extxsl ; Appinfo)
    • ext/yaml (Extensions/Extyaml ; Appinfo)
    • ext/yis (Extensions/Extyis ; Appinfo)
    • ext/zip (Extensions/Extzip ; Appinfo)
    • ext/zlib (Extensions/Extzlib ; Appinfo)
    • func_get_arg() Modified (Functions/funcGetArgModified ; Analyze, CompatibilityPHP70, Simple)
    • include_once() Usage (Structures/OnceUsage ; Analyze, Appinfo)
    • isset() With Constant (Structures/IssetWithConstant ; CompatibilityPHP54, CompatibilityPHP55, CompatibilityPHP56, CompatibilityPHP53)
    • list() May Omit Variables (Structures/ListOmissions ; Analyze, Simple, Suggestions, Level 3)
    • mcrypt_create_iv() With Default Values (Structures/McryptcreateivWithoutOption ; CompatibilityPHP70)
    • parse_str() Warning (Security/parseUrlWithoutParameters ; Security)
    • preg_match_all() Flag (Php/PregMatchAllFlag ; Simple, Suggestions)
    • preg_replace With Option e (Structures/pregOptionE ; Analyze, Security, CompatibilityPHP70, CompatibilityPHP71, CompatibilityPHP72, Simple)
    • set_exception_handler() Warning (Php/SetExceptionHandlerPHP7 ; CompatibilityPHP70)
    • var_dump()… Usage (Structures/VardumpUsage ; Analyze, Security, ClearPHP)
  • 0.8.3
    • Variable Global (Structures/VariableGlobal)

19.8. PHP Error messages

Exakat helps reduce the amount of error and warning that code is producing by reporting pattern that are likely to emit errors.

83 PHP error message detailled :

19.9. External services

List of external services whose configuration files has been commited in the code.

19.11. Ruleset configurations

INI configuration for built-in rulesets. Copy them in config/themes.ini, and make your owns.

23 rulesets detailled here :

Analyze This ruleset centralizes a large number of classic trap and pitfalls when writing PHP. _______

[Analyze]
analyzer[] = “Arrays/AmbiguousKeys”;
analyzer[] = “Arrays/MultipleIdenticalKeys”;
analyzer[] = “Arrays/NoSpreadForHash”;
analyzer[] = “Arrays/NonConstantArray”;
analyzer[] = “Arrays/NullBoolean”;
analyzer[] = “Arrays/RandomlySortedLiterals”;
analyzer[] = “Arrays/TooManyDimensions”;
analyzer[] = “Classes/AbstractOrImplements”;
analyzer[] = “Classes/AbstractStatic”;
analyzer[] = “Classes/AccessPrivate”;
analyzer[] = “Classes/AccessProtected”;
analyzer[] = “Classes/AmbiguousStatic”;
analyzer[] = “Classes/AmbiguousVisibilities”;
analyzer[] = “Classes/AvoidOptionArrays”;
analyzer[] = “Classes/AvoidOptionalProperties”;
analyzer[] = “Classes/CantExtendFinal”;
analyzer[] = “Classes/CantInstantiateClass”;
analyzer[] = “Classes/CheckOnCallUsage”;
analyzer[] = “Classes/CitSameName”;
analyzer[] = “Classes/CloneWithNonObject”;
analyzer[] = “Classes/ConstantClass”;
analyzer[] = “Classes/CouldBeAbstractClass”;
analyzer[] = “Classes/CouldBeFinal”;
analyzer[] = “Classes/CouldBeStatic”;
analyzer[] = “Classes/DependantAbstractClass”;
analyzer[] = “Classes/DirectCallToMagicMethod”;
analyzer[] = “Classes/DontSendThisInConstructor”;
analyzer[] = “Classes/DontUnsetProperties”;
analyzer[] = “Classes/EmptyClass”;
analyzer[] = “Classes/FinalByOcramius”;
analyzer[] = “Classes/IdenticalMethods”;
analyzer[] = “Classes/ImplementIsForInterface”;
analyzer[] = “Classes/ImplementedMethodsArePublic”;
analyzer[] = “Classes/IncompatibleSignature”;
analyzer[] = “Classes/IncompatibleSignature74”;
analyzer[] = “Classes/InstantiatingAbstractClass”;
analyzer[] = “Classes/MakeDefault”;
analyzer[] = “Classes/MakeGlobalAProperty”;
analyzer[] = “Classes/MethodSignatureMustBeCompatible”;
analyzer[] = “Classes/MultipleDeclarations”;
analyzer[] = “Classes/MultipleTraitOrInterface”;
analyzer[] = “Classes/NoMagicWithArray”;
analyzer[] = “Classes/NoPSSOutsideClass”;
analyzer[] = “Classes/NoParent”;
analyzer[] = “Classes/NoPublicAccess”;
analyzer[] = “Classes/NoSelfReferencingConstant”;
analyzer[] = “Classes/NonNullableSetters”;
analyzer[] = “Classes/NonPpp”;
analyzer[] = “Classes/NonStaticMethodsCalledStatic”;
analyzer[] = “Classes/OldStyleConstructor”;
analyzer[] = “Classes/OldStyleVar”;
analyzer[] = “Classes/ParentFirst”;
analyzer[] = “Classes/PropertyCouldBeLocal”;
analyzer[] = “Classes/PropertyNeverUsed”;
analyzer[] = “Classes/PropertyUsedInOneMethodOnly”;
analyzer[] = “Classes/PssWithoutClass”;
analyzer[] = “Classes/RedefinedConstants”;
analyzer[] = “Classes/RedefinedDefault”;
analyzer[] = “Classes/RedefinedPrivateProperty”;
analyzer[] = “Classes/ScalarOrObjectProperty”;
analyzer[] = “Classes/ShouldUseSelf”;
analyzer[] = “Classes/ShouldUseThis”;
analyzer[] = “Classes/StaticContainsThis”;
analyzer[] = “Classes/StaticMethodsCalledFromObject”;
analyzer[] = “Classes/ThisIsForClasses”;
analyzer[] = “Classes/ThisIsNotAnArray”;
analyzer[] = “Classes/ThisIsNotForStatic”;
analyzer[] = “Classes/ThrowInDestruct”;
analyzer[] = “Classes/TooManyDereferencing”;
analyzer[] = “Classes/TooManyFinds”;
analyzer[] = “Classes/TooManyInjections”;
analyzer[] = “Classes/UndeclaredStaticProperty”;
analyzer[] = “Classes/UndefinedClasses”;
analyzer[] = “Classes/UndefinedConstants”;
analyzer[] = “Classes/UndefinedParentMP”;
analyzer[] = “Classes/UndefinedProperty”;
analyzer[] = “Classes/UndefinedStaticMP”;
analyzer[] = “Classes/UndefinedStaticclass”;
analyzer[] = “Classes/UnresolvedClasses”;
analyzer[] = “Classes/UnresolvedInstanceof”;
analyzer[] = “Classes/UnusedClass”;
analyzer[] = “Classes/UnusedConstant”;
analyzer[] = “Classes/UseClassOperator”;
analyzer[] = “Classes/UseInstanceof”;
analyzer[] = “Classes/UsedOnceProperty”;
analyzer[] = “Classes/UselessAbstract”;
analyzer[] = “Classes/UselessConstructor”;
analyzer[] = “Classes/UselessFinal”;
analyzer[] = “Classes/UsingThisOutsideAClass”;
analyzer[] = “Classes/WeakType”;
analyzer[] = “Classes/WrongName”;
analyzer[] = “Constants/BadConstantnames”;
analyzer[] = “Constants/ConstRecommended”;
analyzer[] = “Constants/ConstantStrangeNames”;
analyzer[] = “Constants/CreatedOutsideItsNamespace”;
analyzer[] = “Constants/InvalidName”;
analyzer[] = “Constants/MultipleConstantDefinition”;
analyzer[] = “Constants/StrangeName”;
analyzer[] = “Constants/UndefinedConstants”;
analyzer[] = “Exceptions/CantThrow”;
analyzer[] = “Exceptions/ForgottenThrown”;
analyzer[] = “Exceptions/OverwriteException”;
analyzer[] = “Exceptions/ThrowFunctioncall”;
analyzer[] = “Exceptions/UncaughtExceptions”;
analyzer[] = “Exceptions/Unthrown”;
analyzer[] = “Exceptions/UselessCatch”;
analyzer[] = “Files/InclusionWrongCase”;
analyzer[] = “Files/MissingInclude”;
analyzer[] = “Functions/AliasesUsage”;
analyzer[] = “Functions/AvoidBooleanArgument”;
analyzer[] = “Functions/CallbackNeedsReturn”;
analyzer[] = “Functions/CouldCentralize”;
analyzer[] = “Functions/DeepDefinitions”;
analyzer[] = “Functions/EmptyFunction”;
analyzer[] = “Functions/HardcodedPasswords”;
analyzer[] = “Functions/InsufficientTypehint”;
analyzer[] = “Functions/MismatchTypeAndDefault”;
analyzer[] = “Functions/MismatchedDefaultArguments”;
analyzer[] = “Functions/MismatchedTypehint”;
analyzer[] = “Functions/MustReturn”;
analyzer[] = “Functions/NeverUsedParameter”;
analyzer[] = “Functions/NoBooleanAsDefault”;
analyzer[] = “Functions/NoLiteralForReference”;
analyzer[] = “Functions/NoReturnUsed”;
analyzer[] = “Functions/OnlyVariableForReference”;
analyzer[] = “Functions/OnlyVariablePassedByReference”;
analyzer[] = “Functions/RedeclaredPhpFunction”;
analyzer[] = “Functions/RelayFunction”;
analyzer[] = “Functions/ShouldUseConstants”;
analyzer[] = “Functions/ShouldYieldWithKey”;
analyzer[] = “Functions/TooManyLocalVariables”;
analyzer[] = “Functions/TypehintMustBeReturned”;
analyzer[] = “Functions/TypehintedReferences”;
analyzer[] = “Functions/UndefinedFunctions”;
analyzer[] = “Functions/UnusedArguments”;
analyzer[] = “Functions/UnusedInheritedVariable”;
analyzer[] = “Functions/UnusedReturnedValue”;
analyzer[] = “Functions/UseConstantAsArguments”;
analyzer[] = “Functions/UselessReferenceArgument”;
analyzer[] = “Functions/UselessReturn”;
analyzer[] = “Functions/UsesDefaultArguments”;
analyzer[] = “Functions/WithoutReturn”;
analyzer[] = “Functions/WrongNumberOfArguments”;
analyzer[] = “Functions/WrongOptionalParameter”;
analyzer[] = “Functions/WrongReturnedType”;
analyzer[] = “Functions/WrongTypeWithCall”;
analyzer[] = “Functions/funcGetArgModified”;
analyzer[] = “Interfaces/AlreadyParentsInterface”;
analyzer[] = “Interfaces/CantImplementTraversable”;
analyzer[] = “Interfaces/ConcreteVisibility”;
analyzer[] = “Interfaces/CouldUseInterface”;
analyzer[] = “Interfaces/EmptyInterface”;
analyzer[] = “Interfaces/IsNotImplemented”;
analyzer[] = “Interfaces/NoGaranteeForPropertyConstant”;
analyzer[] = “Interfaces/RepeatedInterface”;
analyzer[] = “Interfaces/UndefinedInterfaces”;
analyzer[] = “Interfaces/UselessInterfaces”;
analyzer[] = “Namespaces/ConstantFullyQualified”;
analyzer[] = “Namespaces/EmptyNamespace”;
analyzer[] = “Namespaces/HiddenUse”;
analyzer[] = “Namespaces/MultipleAliasDefinitionPerFile”;
analyzer[] = “Namespaces/MultipleAliasDefinitions”;
analyzer[] = “Namespaces/ShouldMakeAlias”;
analyzer[] = “Namespaces/UnresolvedUse”;
analyzer[] = “Namespaces/UseWithFullyQualifiedNS”;
analyzer[] = “Performances/ArrayMergeInLoops”;
analyzer[] = “Performances/LogicalToInArray”;
analyzer[] = “Performances/MemoizeMagicCall”;
analyzer[] = “Performances/PrePostIncrement”;
analyzer[] = “Performances/StrposTooMuch”;
analyzer[] = “Performances/UseArraySlice”;
analyzer[] = “Php/ArrayKeyExistsWithObjects”;
analyzer[] = “Php/AssertFunctionIsReserved”;
analyzer[] = “Php/AssignAnd”;
analyzer[] = “Php/AvoidMbDectectEncoding”;
analyzer[] = “Php/BetterRand”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/Crc32MightBeNegative”;
analyzer[] = “Php/Deprecated”;
analyzer[] = “Php/EmptyList”;
analyzer[] = “Php/FopenMode”;
analyzer[] = “Php/ForeachObject”;
analyzer[] = “Php/HashAlgos”;
analyzer[] = “Php/Incompilable”;
analyzer[] = “Php/InternalParameterType”;
analyzer[] = “Php/IsAWithString”;
analyzer[] = “Php/IsnullVsEqualNull”;
analyzer[] = “Php/LogicalInLetters”;
analyzer[] = “Php/MissingSubpattern”;
analyzer[] = “Php/MustCallParentConstructor”;
analyzer[] = “Php/NoClassInGlobal”;
analyzer[] = “Php/NoReferenceForTernary”;
analyzer[] = “Php/PathinfoReturns”;
analyzer[] = “Php/ReservedNames”;
analyzer[] = “Php/ScalarAreNotArrays”;
analyzer[] = “Php/ShortOpenTagRequired”;
analyzer[] = “Php/ShouldUseCoalesce”;
analyzer[] = “Php/StrtrArguments”;
analyzer[] = “Php/TooManyNativeCalls”;
analyzer[] = “Php/UnknownPcre2Option”;
analyzer[] = “Php/UseObjectApi”;
analyzer[] = “Php/UsePathinfo”;
analyzer[] = “Php/UseSetCookie”;
analyzer[] = “Php/UseStdclass”;
analyzer[] = “Php/oldAutoloadUsage”;
analyzer[] = “Security/DontEchoError”;
analyzer[] = “Security/ShouldUsePreparedStatement”;
analyzer[] = “Structures/AddZero”;
analyzer[] = “Structures/AlteringForeachWithoutReference”;
analyzer[] = “Structures/AlternativeConsistenceByFile”;
analyzer[] = “Structures/AlwaysFalse”;
analyzer[] = “Structures/ArrayMergeAndVariadic”;
analyzer[] = “Structures/AssigneAndCompare”;
analyzer[] = “Structures/AutoUnsetForeach”;
analyzer[] = “Structures/BailOutEarly”;
analyzer[] = “Structures/BooleanStrictComparison”;
analyzer[] = “Structures/BreakOutsideLoop”;
analyzer[] = “Structures/BuriedAssignation”;
analyzer[] = “Structures/CastToBoolean”;
analyzer[] = “Structures/CastingTernary”;
analyzer[] = “Structures/CatchShadowsVariable”;
analyzer[] = “Structures/CheckAllTypes”;
analyzer[] = “Structures/CheckJson”;
analyzer[] = “Structures/CoalesceAndConcat”;
analyzer[] = “Structures/CommonAlternatives”;
analyzer[] = “Structures/ComparedComparison”;
analyzer[] = “Structures/ConcatEmpty”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/CouldBeElse”;
analyzer[] = “Structures/CouldBeStatic”;
analyzer[] = “Structures/CouldUseDir”;
analyzer[] = “Structures/CouldUseShortAssignation”;
analyzer[] = “Structures/CouldUseStrrepeat”;
analyzer[] = “Structures/DanglingArrayReferences”;
analyzer[] = “Structures/DirThenSlash”;
analyzer[] = “Structures/DontChangeBlindKey”;
analyzer[] = “Structures/DontMixPlusPlus”;
analyzer[] = “Structures/DontReadAndWriteInOneExpression”;
analyzer[] = “Structures/DoubleAssignation”;
analyzer[] = “Structures/DoubleInstruction”;
analyzer[] = “Structures/DropElseAfterReturn”;
analyzer[] = “Structures/EchoWithConcat”;
analyzer[] = “Structures/ElseIfElseif”;
analyzer[] = “Structures/EmptyBlocks”;
analyzer[] = “Structures/EmptyLines”;
analyzer[] = “Structures/EmptyTryCatch”;
analyzer[] = “Structures/ErrorReportingWithInteger”;
analyzer[] = “Structures/EvalUsage”;
analyzer[] = “Structures/EvalWithoutTry”;
analyzer[] = “Structures/ExitUsage”;
analyzer[] = “Structures/FailingSubstrComparison”;
analyzer[] = “Structures/ForeachReferenceIsNotModified”;
analyzer[] = “Structures/ForeachSourceValue”;
analyzer[] = “Structures/ForgottenWhiteSpace”;
analyzer[] = “Structures/GlobalUsage”;
analyzer[] = “Structures/Htmlentitiescall”;
analyzer[] = “Structures/IdenticalConditions”;
analyzer[] = “Structures/IdenticalConsecutive”;
analyzer[] = “Structures/IdenticalOnBothSides”;
analyzer[] = “Structures/IfWithSameConditions”;
analyzer[] = “Structures/Iffectation”;
analyzer[] = “Structures/ImplicitGlobal”;
analyzer[] = “Structures/ImpliedIf”;
analyzer[] = “Structures/ImplodeArgsOrder”;
analyzer[] = “Structures/InconsistentElseif”;
analyzer[] = “Structures/IndicesAreIntOrString”;
analyzer[] = “Structures/InfiniteRecursion”;
analyzer[] = “Structures/InvalidPackFormat”;
analyzer[] = “Structures/InvalidRegex”;
analyzer[] = “Structures/IsZero”;
analyzer[] = “Structures/ListOmissions”;
analyzer[] = “Structures/LogicalMistakes”;
analyzer[] = “Structures/LoneBlock”;
analyzer[] = “Structures/LongArguments”;
analyzer[] = “Structures/MaxLevelOfIdentation”;
analyzer[] = “Structures/MbstringThirdArg”;
analyzer[] = “Structures/MbstringUnknownEncoding”;
analyzer[] = “Structures/MergeIfThen”;
analyzer[] = “Structures/MismatchedTernary”;
analyzer[] = “Structures/MissingCases”;
analyzer[] = “Structures/MissingNew”;
analyzer[] = “Structures/MissingParenthesis”;
analyzer[] = “Structures/MixedConcatInterpolation”;
analyzer[] = “Structures/ModernEmpty”;
analyzer[] = “Structures/MultipleDefinedCase”;
analyzer[] = “Structures/MultipleTypeVariable”;
analyzer[] = “Structures/MultiplyByOne”;
analyzer[] = “Structures/NegativePow”;
analyzer[] = “Structures/NestedIfthen”;
analyzer[] = “Structures/NestedTernary”;
analyzer[] = “Structures/NeverNegative”;
analyzer[] = “Structures/NextMonthTrap”;
analyzer[] = “Structures/NoAppendOnSource”;
analyzer[] = “Structures/NoChangeIncomingVariables”;
analyzer[] = “Structures/NoChoice”;
analyzer[] = “Structures/NoDirectUsage”;
analyzer[] = “Structures/NoEmptyRegex”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/NoHardcodedHash”;
analyzer[] = “Structures/NoHardcodedIp”;
analyzer[] = “Structures/NoHardcodedPath”;
analyzer[] = “Structures/NoHardcodedPort”;
analyzer[] = “Structures/NoIssetWithEmpty”;
analyzer[] = “Structures/NoNeedForElse”;
analyzer[] = “Structures/NoParenthesisForLanguageConstruct”;
analyzer[] = “Structures/NoReferenceOnLeft”;
analyzer[] = “Structures/NoSubstrOne”;
analyzer[] = “Structures/NoVariableIsACondition”;
analyzer[] = “Structures/Noscream”;
analyzer[] = “Structures/NotNot”;
analyzer[] = “Structures/ObjectReferences”;
analyzer[] = “Structures/OnceUsage”;
analyzer[] = “Structures/OneLineTwoInstructions”;
analyzer[] = “Structures/OnlyVariableReturnedByReference”;
analyzer[] = “Structures/OrDie”;
analyzer[] = “Structures/PossibleInfiniteLoop”;
analyzer[] = “Structures/PrintAndDie”;
analyzer[] = “Structures/PrintWithoutParenthesis”;
analyzer[] = “Structures/PrintfArguments”;
analyzer[] = “Structures/QueriesInLoop”;
analyzer[] = “Structures/RepeatedPrint”;
analyzer[] = “Structures/RepeatedRegex”;
analyzer[] = “Structures/ResultMayBeMissing”;
analyzer[] = “Structures/ReturnTrueFalse”;
analyzer[] = “Structures/SameConditions”;
analyzer[] = “Structures/ShouldChainException”;
analyzer[] = “Structures/ShouldMakeTernary”;
analyzer[] = “Structures/ShouldPreprocess”;
analyzer[] = “Structures/ShouldUseExplodeArgs”;
analyzer[] = “Structures/StaticLoop”;
analyzer[] = “Structures/StripTagsSkipsClosedTag”;
analyzer[] = “Structures/StrposCompare”;
analyzer[] = “Structures/SuspiciousComparison”;
analyzer[] = “Structures/SwitchToSwitch”;
analyzer[] = “Structures/SwitchWithoutDefault”;
analyzer[] = “Structures/TernaryInConcat”;
analyzer[] = “Structures/TestThenCast”;
analyzer[] = “Structures/ThrowsAndAssign”;
analyzer[] = “Structures/TimestampDifference”;
analyzer[] = “Structures/UncheckedResources”;
analyzer[] = “Structures/UnconditionLoopBreak”;
analyzer[] = “Structures/UnknownPregOption”;
analyzer[] = “Structures/Unpreprocessed”;
analyzer[] = “Structures/UnsetInForeach”;
analyzer[] = “Structures/UnusedGlobal”;
analyzer[] = “Structures/UseConstant”;
analyzer[] = “Structures/UseInstanceof”;
analyzer[] = “Structures/UsePositiveCondition”;
analyzer[] = “Structures/UseSystemTmp”;
analyzer[] = “Structures/UselessBrackets”;
analyzer[] = “Structures/UselessCasting”;
analyzer[] = “Structures/UselessCheck”;
analyzer[] = “Structures/UselessGlobal”;
analyzer[] = “Structures/UselessInstruction”;
analyzer[] = “Structures/UselessParenthesis”;
analyzer[] = “Structures/UselessSwitch”;
analyzer[] = “Structures/UselessUnset”;
analyzer[] = “Structures/VardumpUsage”;
analyzer[] = “Structures/WhileListEach”;
analyzer[] = “Structures/WrongRange”;
analyzer[] = “Structures/pregOptionE”;
analyzer[] = “Structures/toStringThrowsException”;
analyzer[] = “Traits/AlreadyParentsTrait”;
analyzer[] = “Traits/CouldUseTrait”;
analyzer[] = “Traits/DependantTrait”;
analyzer[] = “Traits/EmptyTrait”;
analyzer[] = “Traits/MethodCollisionTraits”;
analyzer[] = “Traits/TraitNotFound”;
analyzer[] = “Traits/UndefinedInsteadof”;
analyzer[] = “Traits/UndefinedTrait”;
analyzer[] = “Traits/UselessAlias”;
analyzer[] = “Type/NoRealComparison”;
analyzer[] = “Type/OneVariableStrings”;
analyzer[] = “Type/ShouldTypecast”;
analyzer[] = “Type/SilentlyCastInteger”;
analyzer[] = “Type/StringHoldAVariable”;
analyzer[] = “Type/StringWithStrangeSpace”;
analyzer[] = “Variables/AssignedTwiceOrMore”;
analyzer[] = “Variables/LostReferences”;
analyzer[] = “Variables/OverwrittenLiterals”;
analyzer[] = “Variables/StrangeName”;
analyzer[] = “Variables/UndefinedVariable”;
analyzer[] = “Variables/VariableNonascii”;
analyzer[] = “Variables/VariableUsedOnce”;
analyzer[] = “Variables/VariableUsedOnceByContext”;
analyzer[] = “Variables/WrittenOnlyVariable”;|

ClassReview This ruleset focuses on classes construction issues, and their related structures : traits, interfaces, methodes, properties, constants. ___________

[ClassReview]
analyzer[] = “Classes/AvoidOptionArrays”;
analyzer[] = “Classes/CouldBeAbstractClass”;
analyzer[] = “Classes/CouldBeClassConstant”;
analyzer[] = “Classes/CouldBeFinal”;
analyzer[] = “Classes/CouldBePrivate”;
analyzer[] = “Classes/CouldBePrivateConstante”;
analyzer[] = “Classes/CouldBePrivateMethod”;
analyzer[] = “Classes/CouldBeProtectedConstant”;
analyzer[] = “Classes/CouldBeProtectedMethod”;
analyzer[] = “Classes/CouldBeProtectedProperty”;
analyzer[] = “Classes/CouldBeStatic”;
analyzer[] = “Classes/DependantAbstractClass”;
analyzer[] = “Classes/DisconnectedClasses”;
analyzer[] = “Classes/Finalclass”;
analyzer[] = “Classes/Finalmethod”;
analyzer[] = “Classes/IdenticalMethods”;
analyzer[] = “Classes/InsufficientPropertyTypehint”;
analyzer[] = “Classes/MutualExtension”;
analyzer[] = “Classes/NoParent”;
analyzer[] = “Classes/NoSelfReferencingConstant”;
analyzer[] = “Classes/NonNullableSetters”;
analyzer[] = “Classes/PropertyCouldBeLocal”;
analyzer[] = “Classes/RaisedAccessLevel”;
analyzer[] = “Classes/RedefinedProperty”;
analyzer[] = “Classes/ShouldUseSelf”;
analyzer[] = “Classes/UndeclaredStaticProperty”;
analyzer[] = “Classes/UnreachableConstant”;
analyzer[] = “Classes/UnusedConstant”;
analyzer[] = “Functions/ExceedingTypehint”;
analyzer[] = “Functions/NullableWithoutCheck”;
analyzer[] = “Functions/WrongReturnedType”;
analyzer[] = “Interfaces/AvoidSelfInInterface”;
analyzer[] = “Interfaces/IsNotImplemented”;
analyzer[] = “Interfaces/NoGaranteeForPropertyConstant”;
analyzer[] = “Interfaces/UselessInterfaces”;
analyzer[] = “Performances/MemoizeMagicCall”;
analyzer[] = “Structures/CouldBeStatic”;
analyzer[] = “Traits/SelfUsingTrait”;|

Coding Conventions This ruleset centralizes all analysis related to coding conventions. Sometimes, those are easy to extract with static analysis, and so here they are. No all o them are available. __________________

[Coding Conventions]
analyzer[] = “Arrays/EmptySlots”;
analyzer[] = “Arrays/MistakenConcatenation”;
analyzer[] = “Classes/MultipleClassesInFile”;
analyzer[] = “Classes/OrderOfDeclaration”;
analyzer[] = “Classes/WrongCase”;
analyzer[] = “Constants/ConstRecommended”;
analyzer[] = “Functions/OneLetterFunctions”;
analyzer[] = “Functions/WrongCase”;
analyzer[] = “Functions/WrongTypehintedName”;
analyzer[] = “Namespaces/UseWithFullyQualifiedNS”;
analyzer[] = “Namespaces/WrongCase”;
analyzer[] = “Php/CloseTags”;
analyzer[] = “Php/ReturnWithParenthesis”;
analyzer[] = “Php/UpperCaseFunction”;
analyzer[] = “Php/UpperCaseKeyword”;
analyzer[] = “Structures/Bracketless”;
analyzer[] = “Structures/ConstantComparisonConsistance”;
analyzer[] = “Structures/DontBeTooManual”;
analyzer[] = “Structures/EchoPrintConsistance”;
analyzer[] = “Structures/HeredocDelimiterFavorite”;
analyzer[] = “Structures/MixedConcatInterpolation”;
analyzer[] = “Structures/PlusEgalOne”;
analyzer[] = “Structures/YodaComparison”;
analyzer[] = “Type/ShouldBeSingleQuote”;
analyzer[] = “Type/SimilarIntegers”;
analyzer[] = “Type/StringInterpolation”;
analyzer[] = “Variables/VariableUppercase”;|

CompatibilityPHP53 This ruleset centralizes all analysis for the migration from PHP 5.2 to 5.3. __________________

[CompatibilityPHP53]
analyzer[] = “Arrays/ArrayNSUsage”;
analyzer[] = “Arrays/MixedKeys”;
analyzer[] = “Classes/Anonymous”;
analyzer[] = “Classes/CantInheritAbstractMethod”;
analyzer[] = “Classes/ChildRemoveTypehint”;
analyzer[] = “Classes/ConstVisibilityUsage”;
analyzer[] = “Classes/IntegerAsProperty”;
analyzer[] = “Classes/NonStaticMethodsCalledStatic”;
analyzer[] = “Classes/NullOnNew”;
analyzer[] = “Exceptions/MultipleCatch”;
analyzer[] = “Extensions/Extdba”;
analyzer[] = “Extensions/Extfdf”;
analyzer[] = “Extensions/Extming”;
analyzer[] = “Functions/GeneratorCannotReturn”;
analyzer[] = “Functions/MultipleSameArguments”;
analyzer[] = “Namespaces/UseFunctionsConstants”;
analyzer[] = “Php/CantUseReturnValueInWriteContext”;
analyzer[] = “Php/CaseForPSS”;
analyzer[] = “Php/ClassConstWithArray”;
analyzer[] = “Php/ClosureThisSupport”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/ConstWithArray”;
analyzer[] = “Php/DefineWithArray”;
analyzer[] = “Php/DirectCallToClone”;
analyzer[] = “Php/EllipsisUsage”;
analyzer[] = “Php/ExponentUsage”;
analyzer[] = “Php/FlexibleHeredoc”;
analyzer[] = “Php/GroupUseDeclaration”;
analyzer[] = “Php/GroupUseTrailingComma”;
analyzer[] = “Php/HashAlgos53”;
analyzer[] = “Php/HashAlgos71”;
analyzer[] = “Php/ListShortSyntax”;
analyzer[] = “Php/ListWithKeys”;
analyzer[] = “Php/ListWithReference”;
analyzer[] = “Php/MethodCallOnNew”;
analyzer[] = “Php/NoListWithString”;
analyzer[] = “Php/NoReferenceForStaticProperty”;
analyzer[] = “Php/NoReturnForGenerator”;
analyzer[] = “Php/NoStringWithAppend”;
analyzer[] = “Php/NoSubstrMinusOne”;
analyzer[] = “Php/PHP70scalartypehints”;
analyzer[] = “Php/PHP71scalartypehints”;
analyzer[] = “Php/PHP72scalartypehints”;
analyzer[] = “Php/PHP73LastEmptyArgument”;
analyzer[] = “Php/ParenthesisAsParameter”;
analyzer[] = “Php/Php54NewFunctions”;
analyzer[] = “Php/Php55NewFunctions”;
analyzer[] = “Php/Php56NewFunctions”;
analyzer[] = “Php/Php70NewClasses”;
analyzer[] = “Php/Php70NewFunctions”;
analyzer[] = “Php/Php70NewInterfaces”;
analyzer[] = “Php/Php71NewClasses”;
analyzer[] = “Php/Php72NewClasses”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/Php7RelaxedKeyword”;
analyzer[] = “Php/StaticclassUsage”;
analyzer[] = “Php/TrailingComma”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnicodeEscapePartial”;
analyzer[] = “Php/UnicodeEscapeSyntax”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Php/UseNullableType”;
analyzer[] = “Php/debugInfoUsage”;
analyzer[] = “Structures/Break0”;
analyzer[] = “Structures/ConstantScalarExpression”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/DereferencingAS”;
analyzer[] = “Structures/ForeachWithList”;
analyzer[] = “Structures/FunctionSubscripting”;
analyzer[] = “Structures/IssetWithConstant”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/PHP7Dirname”;
analyzer[] = “Structures/SwitchWithMultipleDefault”;
analyzer[] = “Structures/VariableGlobal”;
analyzer[] = “Type/Binary”;
analyzer[] = “Type/MalformedOctal”;
analyzer[] = “Variables/Php5IndirectExpression”;
analyzer[] = “Variables/Php7IndirectExpression”;|

CompatibilityPHP54 This ruleset centralizes all analysis for the migration from PHP 5.3 to 5.4. __________________

[CompatibilityPHP54]
analyzer[] = “Arrays/MixedKeys”;
analyzer[] = “Classes/Anonymous”;
analyzer[] = “Classes/CantInheritAbstractMethod”;
analyzer[] = “Classes/ChildRemoveTypehint”;
analyzer[] = “Classes/ConstVisibilityUsage”;
analyzer[] = “Classes/IntegerAsProperty”;
analyzer[] = “Classes/NonStaticMethodsCalledStatic”;
analyzer[] = “Classes/NullOnNew”;
analyzer[] = “Exceptions/MultipleCatch”;
analyzer[] = “Extensions/Extmhash”;
analyzer[] = “Functions/GeneratorCannotReturn”;
analyzer[] = “Functions/MultipleSameArguments”;
analyzer[] = “Namespaces/UseFunctionsConstants”;
analyzer[] = “Php/CantUseReturnValueInWriteContext”;
analyzer[] = “Php/CaseForPSS”;
analyzer[] = “Php/ClassConstWithArray”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/ConstWithArray”;
analyzer[] = “Php/DefineWithArray”;
analyzer[] = “Php/DirectCallToClone”;
analyzer[] = “Php/EllipsisUsage”;
analyzer[] = “Php/ExponentUsage”;
analyzer[] = “Php/FlexibleHeredoc”;
analyzer[] = “Php/GroupUseDeclaration”;
analyzer[] = “Php/GroupUseTrailingComma”;
analyzer[] = “Php/HashAlgos53”;
analyzer[] = “Php/HashAlgos54”;
analyzer[] = “Php/HashAlgos71”;
analyzer[] = “Php/ListShortSyntax”;
analyzer[] = “Php/ListWithKeys”;
analyzer[] = “Php/ListWithReference”;
analyzer[] = “Php/NoListWithString”;
analyzer[] = “Php/NoReferenceForStaticProperty”;
analyzer[] = “Php/NoReturnForGenerator”;
analyzer[] = “Php/NoStringWithAppend”;
analyzer[] = “Php/NoSubstrMinusOne”;
analyzer[] = “Php/PHP70scalartypehints”;
analyzer[] = “Php/PHP71scalartypehints”;
analyzer[] = “Php/PHP72scalartypehints”;
analyzer[] = “Php/PHP73LastEmptyArgument”;
analyzer[] = “Php/ParenthesisAsParameter”;
analyzer[] = “Php/Php54RemovedFunctions”;
analyzer[] = “Php/Php55NewFunctions”;
analyzer[] = “Php/Php56NewFunctions”;
analyzer[] = “Php/Php70NewClasses”;
analyzer[] = “Php/Php70NewFunctions”;
analyzer[] = “Php/Php70NewInterfaces”;
analyzer[] = “Php/Php71NewClasses”;
analyzer[] = “Php/Php72NewClasses”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/Php7RelaxedKeyword”;
analyzer[] = “Php/StaticclassUsage”;
analyzer[] = “Php/TrailingComma”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnicodeEscapePartial”;
analyzer[] = “Php/UnicodeEscapeSyntax”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Php/UseNullableType”;
analyzer[] = “Php/debugInfoUsage”;
analyzer[] = “Structures/BreakNonInteger”;
analyzer[] = “Structures/CalltimePassByReference”;
analyzer[] = “Structures/ConstantScalarExpression”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/CryptWithoutSalt”;
analyzer[] = “Structures/DereferencingAS”;
analyzer[] = “Structures/ForeachWithList”;
analyzer[] = “Structures/IssetWithConstant”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/PHP7Dirname”;
analyzer[] = “Structures/SwitchWithMultipleDefault”;
analyzer[] = “Structures/VariableGlobal”;
analyzer[] = “Type/MalformedOctal”;
analyzer[] = “Variables/Php5IndirectExpression”;
analyzer[] = “Variables/Php7IndirectExpression”;|

CompatibilityPHP55 This ruleset centralizes all analysis for the migration from PHP 5.4 to 5.5. __________________

[CompatibilityPHP55]
analyzer[] = “Classes/Anonymous”;
analyzer[] = “Classes/CantInheritAbstractMethod”;
analyzer[] = “Classes/ChildRemoveTypehint”;
analyzer[] = “Classes/ConstVisibilityUsage”;
analyzer[] = “Classes/IntegerAsProperty”;
analyzer[] = “Classes/NonStaticMethodsCalledStatic”;
analyzer[] = “Classes/NullOnNew”;
analyzer[] = “Exceptions/MultipleCatch”;
analyzer[] = “Extensions/Extapc”;
analyzer[] = “Extensions/Extmysql”;
analyzer[] = “Functions/GeneratorCannotReturn”;
analyzer[] = “Functions/MultipleSameArguments”;
analyzer[] = “Namespaces/UseFunctionsConstants”;
analyzer[] = “Php/ClassConstWithArray”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/ConstWithArray”;
analyzer[] = “Php/DefineWithArray”;
analyzer[] = “Php/DirectCallToClone”;
analyzer[] = “Php/EllipsisUsage”;
analyzer[] = “Php/ExponentUsage”;
analyzer[] = “Php/FlexibleHeredoc”;
analyzer[] = “Php/GroupUseDeclaration”;
analyzer[] = “Php/GroupUseTrailingComma”;
analyzer[] = “Php/HashAlgos53”;
analyzer[] = “Php/HashAlgos54”;
analyzer[] = “Php/HashAlgos71”;
analyzer[] = “Php/ListShortSyntax”;
analyzer[] = “Php/ListWithKeys”;
analyzer[] = “Php/ListWithReference”;
analyzer[] = “Php/NoListWithString”;
analyzer[] = “Php/NoReferenceForStaticProperty”;
analyzer[] = “Php/NoReturnForGenerator”;
analyzer[] = “Php/NoStringWithAppend”;
analyzer[] = “Php/NoSubstrMinusOne”;
analyzer[] = “Php/PHP70scalartypehints”;
analyzer[] = “Php/PHP71scalartypehints”;
analyzer[] = “Php/PHP72scalartypehints”;
analyzer[] = “Php/PHP73LastEmptyArgument”;
analyzer[] = “Php/ParenthesisAsParameter”;
analyzer[] = “Php/Password55”;
analyzer[] = “Php/Php55RemovedFunctions”;
analyzer[] = “Php/Php56NewFunctions”;
analyzer[] = “Php/Php70NewClasses”;
analyzer[] = “Php/Php70NewFunctions”;
analyzer[] = “Php/Php70NewInterfaces”;
analyzer[] = “Php/Php71NewClasses”;
analyzer[] = “Php/Php72NewClasses”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/Php7RelaxedKeyword”;
analyzer[] = “Php/TrailingComma”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnicodeEscapePartial”;
analyzer[] = “Php/UnicodeEscapeSyntax”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Php/UseNullableType”;
analyzer[] = “Php/debugInfoUsage”;
analyzer[] = “Structures/ConstantScalarExpression”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/IssetWithConstant”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/PHP7Dirname”;
analyzer[] = “Structures/SwitchWithMultipleDefault”;
analyzer[] = “Structures/VariableGlobal”;
analyzer[] = “Type/MalformedOctal”;
analyzer[] = “Variables/Php5IndirectExpression”;
analyzer[] = “Variables/Php7IndirectExpression”;|

CompatibilityPHP56 This ruleset centralizes all analysis for the migration from PHP 5.5 to 5.6. __________________

[CompatibilityPHP56]
analyzer[] = “Classes/Anonymous”;
analyzer[] = “Classes/CantInheritAbstractMethod”;
analyzer[] = “Classes/ChildRemoveTypehint”;
analyzer[] = “Classes/ConstVisibilityUsage”;
analyzer[] = “Classes/IntegerAsProperty”;
analyzer[] = “Classes/NonStaticMethodsCalledStatic”;
analyzer[] = “Classes/NullOnNew”;
analyzer[] = “Exceptions/MultipleCatch”;
analyzer[] = “Functions/GeneratorCannotReturn”;
analyzer[] = “Functions/MultipleSameArguments”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/DefineWithArray”;
analyzer[] = “Php/DirectCallToClone”;
analyzer[] = “Php/FlexibleHeredoc”;
analyzer[] = “Php/GroupUseDeclaration”;
analyzer[] = “Php/GroupUseTrailingComma”;
analyzer[] = “Php/HashAlgos53”;
analyzer[] = “Php/HashAlgos54”;
analyzer[] = “Php/HashAlgos71”;
analyzer[] = “Php/ListShortSyntax”;
analyzer[] = “Php/ListWithKeys”;
analyzer[] = “Php/ListWithReference”;
analyzer[] = “Php/NoListWithString”;
analyzer[] = “Php/NoReferenceForStaticProperty”;
analyzer[] = “Php/NoReturnForGenerator”;
analyzer[] = “Php/NoStringWithAppend”;
analyzer[] = “Php/NoSubstrMinusOne”;
analyzer[] = “Php/PHP70scalartypehints”;
analyzer[] = “Php/PHP71scalartypehints”;
analyzer[] = “Php/PHP72scalartypehints”;
analyzer[] = “Php/PHP73LastEmptyArgument”;
analyzer[] = “Php/ParenthesisAsParameter”;
analyzer[] = “Php/Php70NewClasses”;
analyzer[] = “Php/Php70NewFunctions”;
analyzer[] = “Php/Php70NewInterfaces”;
analyzer[] = “Php/Php71NewClasses”;
analyzer[] = “Php/Php72NewClasses”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/Php7RelaxedKeyword”;
analyzer[] = “Php/RawPostDataUsage”;
analyzer[] = “Php/TrailingComma”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnicodeEscapePartial”;
analyzer[] = “Php/UnicodeEscapeSyntax”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Php/UseNullableType”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/IssetWithConstant”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/PHP7Dirname”;
analyzer[] = “Structures/SwitchWithMultipleDefault”;
analyzer[] = “Structures/VariableGlobal”;
analyzer[] = “Type/MalformedOctal”;
analyzer[] = “Variables/Php5IndirectExpression”;
analyzer[] = “Variables/Php7IndirectExpression”;|

CompatibilityPHP70 This ruleset centralizes all analysis for the migration from PHP 5.6 to 7.0. __________________

[CompatibilityPHP70]
analyzer[] = “Classes/CantInheritAbstractMethod”;
analyzer[] = “Classes/ChildRemoveTypehint”;
analyzer[] = “Classes/ConstVisibilityUsage”;
analyzer[] = “Classes/IntegerAsProperty”;
analyzer[] = “Classes/toStringPss”;
analyzer[] = “Exceptions/MultipleCatch”;
analyzer[] = “Extensions/Extereg”;
analyzer[] = “Functions/funcGetArgModified”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/EmptyList”;
analyzer[] = “Php/FlexibleHeredoc”;
analyzer[] = “Php/ForeachDontChangePointer”;
analyzer[] = “Php/GlobalWithoutSimpleVariable”;
analyzer[] = “Php/GroupUseTrailingComma”;
analyzer[] = “Php/HashAlgos53”;
analyzer[] = “Php/HashAlgos54”;
analyzer[] = “Php/HashAlgos71”;
analyzer[] = “Php/ListShortSyntax”;
analyzer[] = “Php/ListWithAppends”;
analyzer[] = “Php/ListWithKeys”;
analyzer[] = “Php/ListWithReference”;
analyzer[] = “Php/NoReferenceForStaticProperty”;
analyzer[] = “Php/NoSubstrMinusOne”;
analyzer[] = “Php/PHP71scalartypehints”;
analyzer[] = “Php/PHP72scalartypehints”;
analyzer[] = “Php/PHP73LastEmptyArgument”;
analyzer[] = “Php/Php70RemovedDirective”;
analyzer[] = “Php/Php70RemovedFunctions”;
analyzer[] = “Php/Php71NewClasses”;
analyzer[] = “Php/Php72NewClasses”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/ReservedKeywords7”;
analyzer[] = “Php/SetExceptionHandlerPHP7”;
analyzer[] = “Php/TrailingComma”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Php/UseNullableType”;
analyzer[] = “Php/UsortSorting”;
analyzer[] = “Structures/BreakOutsideLoop”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/McryptcreateivWithoutOption”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/SetlocaleNeedsConstants”;
analyzer[] = “Structures/pregOptionE”;
analyzer[] = “Type/HexadecimalString”;
analyzer[] = “Variables/Php7IndirectExpression”;|

CompatibilityPHP71 This ruleset centralizes all analysis for the migration from PHP 7.0 to 7.1. __________________

[CompatibilityPHP71]
analyzer[] = “Arrays/StringInitialization”;
analyzer[] = “Classes/CantInheritAbstractMethod”;
analyzer[] = “Classes/ChildRemoveTypehint”;
analyzer[] = “Classes/IntegerAsProperty”;
analyzer[] = “Classes/UsingThisOutsideAClass”;
analyzer[] = “Extensions/Extmcrypt”;
analyzer[] = “Php/BetterRand”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/FlexibleHeredoc”;
analyzer[] = “Php/GroupUseTrailingComma”;
analyzer[] = “Php/HashAlgos53”;
analyzer[] = “Php/HashAlgos54”;
analyzer[] = “Php/ListWithReference”;
analyzer[] = “Php/NoReferenceForStaticProperty”;
analyzer[] = “Php/PHP72scalartypehints”;
analyzer[] = “Php/PHP73LastEmptyArgument”;
analyzer[] = “Php/Php70RemovedDirective”;
analyzer[] = “Php/Php70RemovedFunctions”;
analyzer[] = “Php/Php71NewFunctions”;
analyzer[] = “Php/Php71RemovedDirective”;
analyzer[] = “Php/Php71microseconds”;
analyzer[] = “Php/Php72NewClasses”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/TrailingComma”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/NoSubstrOne”;
analyzer[] = “Structures/pregOptionE”;
analyzer[] = “Type/HexadecimalString”;
analyzer[] = “Type/OctalInString”;|

CompatibilityPHP72 This ruleset centralizes all analysis for the migration from PHP 7.1 to 7.2. __________________

[CompatibilityPHP72]
analyzer[] = “Constants/UndefinedConstants”;
analyzer[] = “Php/AvoidSetErrorHandlerContextArg”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/FlexibleHeredoc”;
analyzer[] = “Php/HashAlgos53”;
analyzer[] = “Php/HashAlgos54”;
analyzer[] = “Php/HashUsesObjects”;
analyzer[] = “Php/ListWithReference”;
analyzer[] = “Php/NoReferenceForStaticProperty”;
analyzer[] = “Php/PHP73LastEmptyArgument”;
analyzer[] = “Php/Php72Deprecation”;
analyzer[] = “Php/Php72NewClasses”;
analyzer[] = “Php/Php72NewConstants”;
analyzer[] = “Php/Php72NewFunctions”;
analyzer[] = “Php/Php72ObjectKeyword”;
analyzer[] = “Php/Php72RemovedFunctions”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/TrailingComma”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Structures/CanCountNonCountable”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/NoGetClassNull”;
analyzer[] = “Structures/pregOptionE”;|

CompatibilityPHP73 This ruleset centralizes all analysis for the migration from PHP 7.2 to 7.3. __________________

[CompatibilityPHP73]
analyzer[] = “Constants/CaseInsensitiveConstants”;
analyzer[] = “Php/AssertFunctionIsReserved”;
analyzer[] = “Php/CompactInexistant”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/IntegerSeparatorUsage”;
analyzer[] = “Php/Php73NewFunctions”;
analyzer[] = “Php/Php73RemovedFunctions”;
analyzer[] = “Php/Php74NewDirective”;
analyzer[] = “Php/TypedPropertyUsage”;
analyzer[] = “Php/UnknownPcre2Option”;
analyzer[] = “Php/UnpackingInsideArrays”;
analyzer[] = “Structures/ContinueIsForLoop”;
analyzer[] = “Structures/DontReadAndWriteInOneExpression”;|

CompatibilityPHP74 This ruleset centralizes all analysis for the migration from PHP 7.3 to 7.4. __________________

[CompatibilityPHP74]
analyzer[] = “Functions/UnbindingClosures”;
analyzer[] = “Php/ArrayKeyExistsWithObjects”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/DetectCurrentClass”;
analyzer[] = “Php/FilterToAddSlashes”;
analyzer[] = “Php/HashAlgos74”;
analyzer[] = “Php/IdnUts46”;
analyzer[] = “Php/NestedTernaryWithoutParenthesis”;
analyzer[] = “Php/NoMoreCurlyArrays”;
analyzer[] = “Php/Php74Deprecation”;
analyzer[] = “Php/Php74NewClasses”;
analyzer[] = “Php/Php74NewConstants”;
analyzer[] = “Php/Php74NewFunctions”;
analyzer[] = “Php/Php74RemovedDirective”;
analyzer[] = “Php/Php74RemovedFunctions”;
analyzer[] = “Php/Php74ReservedKeyword”;
analyzer[] = “Php/Php74mbstrrpos3rdArg”;
analyzer[] = “Php/ReflectionExportIsDeprecated”;
analyzer[] = “Php/ScalarAreNotArrays”;
analyzer[] = “Structures/CurlVersionNow”;
analyzer[] = “Structures/DontReadAndWriteInOneExpression”;
analyzer[] = “Structures/OpensslRandomPseudoByteSecondArg”;|

CompatibilityPHP80 This ruleset centralizes all analysis for the migration from PHP 7.4 to 8.0. __________________

[CompatibilityPHP80]
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/Php80RemovedConstant”;
analyzer[] = “Php/Php80RemovedFunctions”;|

Dead code This ruleset focuses on dead code : expressions or even structures that are written, valid but never used. _________

[Dead code]
analyzer[] = “Classes/CantExtendFinal”;
analyzer[] = “Classes/LocallyUnusedProperty”;
analyzer[] = “Classes/UnresolvedCatch”;
analyzer[] = “Classes/UnresolvedInstanceof”;
analyzer[] = “Classes/UnusedClass”;
analyzer[] = “Classes/UnusedMethods”;
analyzer[] = “Classes/UnusedPrivateMethod”;
analyzer[] = “Classes/UnusedPrivateProperty”;
analyzer[] = “Classes/UnusedProtectedMethods”;
analyzer[] = “Constants/UnusedConstants”;
analyzer[] = “Exceptions/AlreadyCaught”;
analyzer[] = “Exceptions/CaughtButNotThrown”;
analyzer[] = “Exceptions/Rethrown”;
analyzer[] = “Exceptions/Unthrown”;
analyzer[] = “Functions/UnusedFunctions”;
analyzer[] = “Functions/UnusedInheritedVariable”;
analyzer[] = “Functions/UnusedReturnedValue”;
analyzer[] = “Functions/UselessTypeCheck”;
analyzer[] = “Interfaces/UnusedInterfaces”;
analyzer[] = “Namespaces/EmptyNamespace”;
analyzer[] = “Namespaces/UnusedUse”;
analyzer[] = “Structures/EmptyLines”;
analyzer[] = “Structures/UnreachableCode”;
analyzer[] = “Structures/UnsetInForeach”;
analyzer[] = “Structures/UnusedLabel”;
analyzer[] = “Traits/SelfUsingTrait”;|

LintButWontExec This ruleset focuses on PHP code that lint (php -l), but that will not run. As such, this ruleset tries to go further than PHP, by connecting files, just like during execution. _______________

[LintButWontExec]
analyzer[] = “Classes/AbstractOrImplements”;
analyzer[] = “Classes/CloneWithNonObject”;
analyzer[] = “Classes/Finalclass”;
analyzer[] = “Classes/Finalmethod”;
analyzer[] = “Classes/IncompatibleSignature”;
analyzer[] = “Classes/MethodSignatureMustBeCompatible”;
analyzer[] = “Classes/MutualExtension”;
analyzer[] = “Classes/NoMagicWithArray”;
analyzer[] = “Classes/NoPSSOutsideClass”;
analyzer[] = “Classes/NoSelfReferencingConstant”;
analyzer[] = “Classes/RaisedAccessLevel”;
analyzer[] = “Classes/UsingThisOutsideAClass”;
analyzer[] = “Exceptions/CantThrow”;
analyzer[] = “Functions/MismatchTypeAndDefault”;
analyzer[] = “Functions/MustReturn”;
analyzer[] = “Functions/OnlyVariableForReference”;
analyzer[] = “Functions/TypehintMustBeReturned”;
analyzer[] = “Interfaces/CantImplementTraversable”;
analyzer[] = “Interfaces/ConcreteVisibility”;
analyzer[] = “Interfaces/RepeatedInterface”;
analyzer[] = “Traits/MethodCollisionTraits”;
analyzer[] = “Traits/TraitNotFound”;
analyzer[] = “Traits/UndefinedInsteadof”;
analyzer[] = “Traits/UndefinedTrait”;
analyzer[] = “Traits/UselessAlias”;|

Performances This ruleset focuses on performances issues : anything that slows the code’s execution. ____________

[Performances]
analyzer[] = “Arrays/GettingLastElement”;
analyzer[] = “Arrays/SliceFirst”;
analyzer[] = “Classes/MakeMagicConcrete”;
analyzer[] = “Classes/UseClassOperator”;
analyzer[] = “Functions/Closure2String”;
analyzer[] = “Performances/ArrayKeyExistsSpeedup”;
analyzer[] = “Performances/ArrayMergeInLoops”;
analyzer[] = “Performances/Autoappend”;
analyzer[] = “Performances/AvoidArrayPush”;
analyzer[] = “Performances/CacheVariableOutsideLoop”;
analyzer[] = “Performances/CsvInLoops”;
analyzer[] = “Performances/DoInBase”;
analyzer[] = “Performances/DoubleArrayFlip”;
analyzer[] = “Performances/FetchOneRowFormat”;
analyzer[] = “Performances/IssetWholeArray”;
analyzer[] = “Performances/JoinFile”;
analyzer[] = “Performances/MakeOneCall”;
analyzer[] = “Performances/MbStringInLoop”;
analyzer[] = “Performances/NoConcatInLoop”;
analyzer[] = “Performances/NoGlob”;
analyzer[] = “Performances/NotCountNull”;
analyzer[] = “Performances/PHP7EncapsedStrings”;
analyzer[] = “Performances/Php74ArrayKeyExists”;
analyzer[] = “Performances/PrePostIncrement”;
analyzer[] = “Performances/RegexOnArrays”;
analyzer[] = “Performances/RegexOnCollector”;
analyzer[] = “Performances/SimpleSwitch”;
analyzer[] = “Performances/SlowFunctions”;
analyzer[] = “Performances/SubstrFirst”;
analyzer[] = “Performances/UseBlindVar”;
analyzer[] = “Performances/timeVsstrtotime”;
analyzer[] = “Php/ShouldUseArrayColumn”;
analyzer[] = “Php/ShouldUseFunction”;
analyzer[] = “Php/UsePathinfoArgs”;
analyzer[] = “Structures/CouldUseShortAssignation”;
analyzer[] = “Structures/EchoWithConcat”;
analyzer[] = “Structures/EvalUsage”;
analyzer[] = “Structures/ForWithFunctioncall”;
analyzer[] = “Structures/GlobalOutsideLoop”;
analyzer[] = “Structures/NoArrayUnique”;
analyzer[] = “Structures/NoAssignationInFunction”;
analyzer[] = “Structures/NoSubstrOne”;
analyzer[] = “Structures/Noscream”;
analyzer[] = “Structures/SimplePreg”;
analyzer[] = “Structures/WhileListEach”;|

Rector [Rector](https://github.com/rectorphp/rector) is a reconstructor tool. It applies modifications in the PHP code automatically. Exakat finds results which may be automatically updated with rector. ______

[Rector]
analyzer[] = “Php/IsAWithString”;
analyzer[] = “Structures/ElseIfElseif”;
analyzer[] = “Structures/ShouldPreprocess”;|

Security This ruleset focuses on code security. ________

[Security]
analyzer[] = “Functions/HardcodedPasswords”;
analyzer[] = “Php/BetterRand”;
analyzer[] = “Security/AnchorRegex”;
analyzer[] = “Security/AvoidThoseCrypto”;
analyzer[] = “Security/CompareHash”;
analyzer[] = “Security/ConfigureExtract”;
analyzer[] = “Security/CurlOptions”;
analyzer[] = “Security/DirectInjection”;
analyzer[] = “Security/DontEchoError”;
analyzer[] = “Security/DynamicDl”;
analyzer[] = “Security/EncodedLetters”;
analyzer[] = “Security/FilterInputSource”;
analyzer[] = “Security/IndirectInjection”;
analyzer[] = “Security/IntegerConversion”;
analyzer[] = “Security/MinusOneOnError”;
analyzer[] = “Security/MkdirDefault”;
analyzer[] = “Security/MoveUploadedFile”;
analyzer[] = “Security/NoEntIgnore”;
analyzer[] = “Security/NoNetForXmlLoad”;
analyzer[] = “Security/NoSleep”;
analyzer[] = “Security/NoWeakSSLCrypto”;
analyzer[] = “Security/RegisterGlobals”;
analyzer[] = “Security/SafeHttpHeaders”;
analyzer[] = “Security/SessionLazyWrite”;
analyzer[] = “Security/SetCookieArgs”;
analyzer[] = “Security/ShouldUsePreparedStatement”;
analyzer[] = “Security/ShouldUseSessionRegenerateId”;
analyzer[] = “Security/Sqlite3RequiresSingleQuotes”;
analyzer[] = “Security/UnserializeSecondArg”;
analyzer[] = “Security/UploadFilenameInjection”;
analyzer[] = “Security/parseUrlWithoutParameters”;
analyzer[] = “Structures/EvalUsage”;
analyzer[] = “Structures/EvalWithoutTry”;
analyzer[] = “Structures/Fallthrough”;
analyzer[] = “Structures/NoHardcodedHash”;
analyzer[] = “Structures/NoHardcodedIp”;
analyzer[] = “Structures/NoHardcodedPort”;
analyzer[] = “Structures/NoReturnInFinally”;
analyzer[] = “Structures/PhpinfoUsage”;
analyzer[] = “Structures/RandomWithoutTry”;
analyzer[] = “Structures/VardumpUsage”;
analyzer[] = “Structures/pregOptionE”;|

Semantics This ruleset focuses on human interpretation of the code. It reviews special values of literals, and named structures. _________

[Semantics]
analyzer[] = “Arrays/WeirdIndex”;
analyzer[] = “Functions/OneLetterFunctions”;
analyzer[] = “Functions/ParameterHiding”;
analyzer[] = “Functions/WrongTypehintedName”;
analyzer[] = “Php/ClassFunctionConfusion”;
analyzer[] = “Structures/PropertyVariableConfusion”;
analyzer[] = “Type/DuplicateLiteral”;
analyzer[] = “Type/SimilarIntegers”;
analyzer[] = “Variables/VariableOneLetter”;|

Suggestions This ruleset focuses on possibly better syntax than the one currently used. Those may be code modernization, alternatives, more efficient solutions, or simply left over from older versions. ___________

[Suggestions]
analyzer[] = “Arrays/RandomlySortedLiterals”;
analyzer[] = “Arrays/ShouldPreprocess”;
analyzer[] = “Arrays/SliceFirst”;
analyzer[] = “Classes/ParentFirst”;
analyzer[] = “Classes/ShouldDeepClone”;
analyzer[] = “Classes/ShouldHaveDestructor”;
analyzer[] = “Classes/ShouldUseSelf”;
analyzer[] = “Classes/TooManyChildren”;
analyzer[] = “Classes/UnitializedProperties”;
analyzer[] = “Constants/CouldBeConstant”;
analyzer[] = “Exceptions/CouldUseTry”;
analyzer[] = “Exceptions/OverwriteException”;
analyzer[] = “Functions/AddDefaultValue”;
analyzer[] = “Functions/Closure2String”;
analyzer[] = “Functions/CouldBeCallable”;
analyzer[] = “Functions/CouldBeStaticClosure”;
analyzer[] = “Functions/CouldCentralize”;
analyzer[] = “Functions/CouldReturnVoid”;
analyzer[] = “Functions/MultipleIdenticalClosure”;
analyzer[] = “Functions/NeverUsedParameter”;
analyzer[] = “Functions/NoReturnUsed”;
analyzer[] = “Functions/TooManyParameters”;
analyzer[] = “Functions/UselessArgument”;
analyzer[] = “Functions/UselessDefault”;
analyzer[] = “Interfaces/AlreadyParentsInterface”;
analyzer[] = “Interfaces/UnusedInterfaces”;
analyzer[] = “Namespaces/CouldUseAlias”;
analyzer[] = “Performances/ArrayKeyExistsSpeedup”;
analyzer[] = “Performances/IssetWholeArray”;
analyzer[] = “Performances/SubstrFirst”;
analyzer[] = “Php/AvoidReal”;
analyzer[] = “Php/CompactInexistant”;
analyzer[] = “Php/CouldUseIsCountable”;
analyzer[] = “Php/DetectCurrentClass”;
analyzer[] = “Php/ImplodeOneArg”;
analyzer[] = “Php/IssetMultipleArgs”;
analyzer[] = “Php/LogicalInLetters”;
analyzer[] = “Php/NewExponent”;
analyzer[] = “Php/PregMatchAllFlag”;
analyzer[] = “Php/ReturnWithParenthesis”;
analyzer[] = “Php/ShouldPreprocess”;
analyzer[] = “Php/ShouldUseArrayColumn”;
analyzer[] = “Php/ShouldUseArrayFilter”;
analyzer[] = “Php/ShouldUseCoalesce”;
analyzer[] = “Php/UseDateTimeImmutable”;
analyzer[] = “Php/UseSessionStartOptions”;
analyzer[] = “Structures/BasenameSuffix”;
analyzer[] = “Structures/BooleanStrictComparison”;
analyzer[] = “Structures/CouldUseArrayFillKeys”;
analyzer[] = “Structures/CouldUseArrayUnique”;
analyzer[] = “Structures/CouldUseCompact”;
analyzer[] = “Structures/CouldUseDir”;
analyzer[] = “Structures/DirectlyUseFile”;
analyzer[] = “Structures/DontLoopOnYield”;
analyzer[] = “Structures/DropElseAfterReturn”;
analyzer[] = “Structures/EchoWithConcat”;
analyzer[] = “Structures/EmptyWithExpression”;
analyzer[] = “Structures/FunctionPreSubscripting”;
analyzer[] = “Structures/JsonWithOption”;
analyzer[] = “Structures/ListOmissions”;
analyzer[] = “Structures/MismatchedTernary”;
analyzer[] = “Structures/MultipleUnset”;
analyzer[] = “Structures/NamedRegex”;
analyzer[] = “Structures/NoNeedGetClass”;
analyzer[] = “Structures/NoParenthesisForLanguageConstruct”;
analyzer[] = “Structures/NoSubstrOne”;
analyzer[] = “Structures/OneIfIsSufficient”;
analyzer[] = “Structures/PHP7Dirname”;
analyzer[] = “Structures/PossibleIncrement”;
analyzer[] = “Structures/RepeatedPrint”;
analyzer[] = “Structures/ReuseVariable”;
analyzer[] = “Structures/SetAside”;
analyzer[] = “Structures/ShouldUseForeach”;
analyzer[] = “Structures/ShouldUseMath”;
analyzer[] = “Structures/ShouldUseOperator”;
analyzer[] = “Structures/SubstrLastArg”;
analyzer[] = “Structures/SubstrToTrim”;
analyzer[] = “Structures/UnreachableCode”;
analyzer[] = “Structures/UseArrayFunctions”;
analyzer[] = “Structures/UseCaseValue”;
analyzer[] = “Structures/UseCountRecursive”;
analyzer[] = “Structures/UseListWithForeach”;
analyzer[] = “Structures/UseUrlQueryFunctions”;
analyzer[] = “Structures/WhileListEach”;
analyzer[] = “Traits/MultipleUsage”;
analyzer[] = “Variables/ComplexDynamicNames”;|

Top10 This ruleset is a selection of analysis, with the top 10 most common. Actually, it is a little larger than that. _____

[Top10]
analyzer[] = “Classes/DontUnsetProperties”;
analyzer[] = “Classes/UnitializedProperties”;
analyzer[] = “Classes/UnresolvedInstanceof”;
analyzer[] = “Constants/ConstRecommended”;
analyzer[] = “Functions/ShouldYieldWithKey”;
analyzer[] = “Performances/ArrayMergeInLoops”;
analyzer[] = “Performances/CsvInLoops”;
analyzer[] = “Performances/NoConcatInLoop”;
analyzer[] = “Performances/SubstrFirst”;
analyzer[] = “Php/AvoidReal”;
analyzer[] = “Php/ConcatAndAddition”;
analyzer[] = “Php/LetterCharsLogicalFavorite”;
analyzer[] = “Php/LogicalInLetters”;
analyzer[] = “Php/MissingSubpattern”;
analyzer[] = “Structures/CouldUseStrrepeat”;
analyzer[] = “Structures/DanglingArrayReferences”;
analyzer[] = “Structures/FailingSubstrComparison”;
analyzer[] = “Structures/ForWithFunctioncall”;
analyzer[] = “Structures/NextMonthTrap”;
analyzer[] = “Structures/NoChoice”;
analyzer[] = “Structures/NoSubstrOne”;
analyzer[] = “Structures/ObjectReferences”;
analyzer[] = “Structures/QueriesInLoop”;
analyzer[] = “Structures/RepeatedPrint”;
analyzer[] = “Structures/StrposCompare”;
analyzer[] = “Structures/UseListWithForeach”;
analyzer[] = “Type/NoRealComparison”;
analyzer[] = “Variables/VariableUsedOnce”;|

Typechecks This ruleset focuses on typehinting. Missing typehint, or inconsistent typehint, are reported. __________

[Typechecks]
analyzer[] = “Classes/ChildRemoveTypehint”;
analyzer[] = “Functions/BadTypehintRelay”;
analyzer[] = “Functions/CouldBeCallable”;
analyzer[] = “Functions/CouldTypeWithArray”;
analyzer[] = “Functions/CouldTypeWithBool”;
analyzer[] = “Functions/CouldTypeWithInt”;
analyzer[] = “Functions/CouldTypeWithIterable”;
analyzer[] = “Functions/CouldTypeWithString”;
analyzer[] = “Functions/CouldTypehint”;
analyzer[] = “Functions/InsufficientTypehint”;
analyzer[] = “Functions/MismatchTypeAndDefault”;
analyzer[] = “Functions/MismatchedDefaultArguments”;
analyzer[] = “Functions/MismatchedTypehint”;
analyzer[] = “Functions/NoClassAsTypehint”;
analyzer[] = “Functions/ShouldBeTypehinted”;
analyzer[] = “Functions/WrongTypeWithCall”;
analyzer[] = “Interfaces/UselessInterfaces”;
analyzer[] = “Php/NotScalarType”;|

php-cs-fixable [PHP-CS-fixer](https://github.com/FriendsOfPHP/PHP-CS-Fixer) is a tool to automatically fix PHP Coding Standards issues. It applies modifications in the PHP code automatically. Exakat finds results which may be automatically updated with php-cs-fixer. ______________

[php-cs-fixable]
analyzer[] = “Classes/DontUnsetProperties”;
analyzer[] = “Php/ImplodeOneArg”;
analyzer[] = “Php/IsnullVsEqualNull”;
analyzer[] = “Php/IssetMultipleArgs”;
analyzer[] = “Php/LogicalInLetters”;
analyzer[] = “Php/NewExponent”;
analyzer[] = “Structures/CouldUseDir”;
analyzer[] = “Structures/ElseIfElseif”;
analyzer[] = “Structures/MultipleUnset”;
analyzer[] = “Structures/PHP7Dirname”;
analyzer[] = “Structures/UseConstant”;|