-
Notifications
You must be signed in to change notification settings - Fork 359
/
Config.php
1695 lines (1497 loc) · 74.6 KB
/
Config.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?php
declare(strict_types=1);
namespace Phan;
use Phan\Config\Initializer;
use Phan\Library\Paths;
use Phan\Library\StringUtil;
use function array_key_exists;
use function gettype;
use function in_array;
use function is_array;
use function is_bool;
use function is_float;
use function is_int;
use function is_null;
use function is_string;
use const PHP_EOL;
use const PHP_VERSION;
use const STDERR;
/**
* Program configuration.
*
* Many of the settings in this class can be overridden in .phan/config.php.
*
* Some configuration can be overridden on the command line.
* See `./phan -h` for command line usage, or take a
* look at \Phan\CLI.php for more details on CLI usage.
*
* For efficiency, all of these methods are static methods.
* Configuration is fetched frequently, and static methods were much faster than magic __get().
* @phan-file-suppress PhanPluginDescriptionlessCommentOnPublicMethod
*/
class Config
{
/**
* The version of the AST (defined in php-ast) that we're using.
* @see https://github.com/nikic/php-ast#ast-versioning
*/
public const AST_VERSION = 70;
/**
* The minimum AST extension version in the oldest php version supported by Phan.
*/
public const MINIMUM_AST_EXTENSION_VERSION = '1.0.1';
/**
* The version of the Phan plugin system.
* Plugin files that wish to be backwards compatible may check this and
* return different classes based on its existence and
* the results of version_compare.
* PluginV3 will correspond to 2.x.y, PluginV3 will correspond to 3.x.y, etc.
* New features increment minor versions, and bug fixes increment patch versions.
* @suppress PhanUnreferencedPublicClassConstant
*/
public const PHAN_PLUGIN_VERSION = '3.3.0';
/**
* @var string|null
* The root directory of the project. This is used to
* store canonical path names and find project resources
*/
private static $project_root_directory = null;
/**
* Configuration options
*/
private static $configuration = self::DEFAULT_CONFIGURATION;
// The most commonly accessed configs:
/** @var bool replicates Config::getValue('null_casts_as_any_type') */
private static $null_casts_as_any_type = false;
/** @var bool replicates Config::getValue('null_casts_as_array') */
private static $null_casts_as_array = false;
/** @var bool replicates Config::getValue('array_casts_as_null') */
private static $array_casts_as_null = false;
/** @var bool replicates Config::getValue('strict_method_checking') */
private static $strict_method_checking = false;
/** @var bool replicates Config::getValue('strict_param_checking') */
private static $strict_param_checking = false;
/** @var bool replicates Config::getValue('strict_property_checking') */
private static $strict_property_checking = false;
/** @var bool replicates Config::getValue('strict_return_checking') */
private static $strict_return_checking = false;
/** @var bool replicates Config::getValue('strict_object_checking') */
private static $strict_object_checking = false;
/** @var bool replicates Config::getValue('track_references') */
private static $track_references = false;
/** @var bool replicates Config::getValue('backward_compatibility_checks') */
private static $backward_compatibility_checks = false;
/** @var bool replicates Config::getValue('quick_mode') */
private static $quick_mode = false;
// End of the most commonly accessed configs.
/** @var int the 5-digit PHP version id which is closest to matching the PHP_VERSION_ID for the 'target_php_version' string */
private static $closest_target_php_version_id;
/** @var int the 5-digit PHP version id which is closest to matching the PHP_VERSION_ID for the 'minimum_target_php_version' string */
private static $closest_minimum_target_php_version_id;
/**
* This constant contains the default values for Phan's configuration settings.
*
* Both your project's `.phan/config.php` file and the CLI flags used to invoke Phan
* will override these defaults.
*
* NOTE: The line comments for individual configuration settings are written in markdown.
* They are extracted by `\Phan\Config\Initializer` and used in the following places:
*
* 1. The configuration automatically generated by `phan --init`.
* 2. The GitHub Wiki documentation generated by `internal/update_wiki_config_types.php`.
*/
public const DEFAULT_CONFIGURATION = [
// The PHP version that the codebase will be checked for compatibility against.
// For best results, the PHP binary used to run Phan should have the same PHP version.
// (Phan relies on Reflection for some types, param counts,
// and checks for undefined classes/methods/functions)
//
// Supported values: `'5.6'`, `'7.0'`, `'7.1'`, `'7.2'`, `'7.3'`, `'7.4'`, `null`.
// If this is set to `null`,
// then Phan assumes the PHP version which is closest to the minor version
// of the php executable used to execute Phan.
//
// Note that the **only** effect of choosing `'5.6'` is to infer that functions removed in php 7.0 exist.
// (See `backward_compatibility_checks` for additional options)
'target_php_version' => null,
// The PHP version that will be used for feature/syntax compatibility warnings.
//
// Supported values: `'5.6'`, `'7.0'`, `'7.1'`, `'7.2'`, `'7.3'`, `'7.4'`, `null`.
// If this is set to `null`, Phan will first attempt to infer the value from
// the project's composer.json's `{"require": {"php": "version range"}}` if possible.
// If that could not be determined, then Phan assumes `target_php_version`.
'minimum_target_php_version' => null,
// Default: true. If this is set to true,
// and `target_php_version` is newer than the version used to run Phan,
// Phan will act as though functions added in newer PHP versions exist.
//
// NOTE: Currently, this only affects `Closure::fromCallable()`
'pretend_newer_core_methods_exist' => true,
// Make the tolerant-php-parser polyfill generate doc comments
// for all types of elements, even if php-ast wouldn't (for an older PHP version)
'polyfill_parse_all_element_doc_comments' => true,
// A list of individual files to include in analysis
// with a path relative to the root directory of the
// project.
'file_list' => [],
// A list of directories that should be parsed for class and
// method information. After excluding the directories
// defined in `exclude_analysis_directory_list`, the remaining
// files will be statically analyzed for errors.
//
// Thus, both first-party and third-party code being used by
// your application should be included in this list.
'directory_list' => [],
// For internal use by Phan to quickly check for membership in directory_list.
'__directory_regex' => null,
// Whether to enable debugging output to stderr
'debug_output' => false,
// List of case-insensitive file extensions supported by Phan.
// (e.g. `['php', 'html', 'htm']`)
'analyzed_file_extensions' => ['php'],
// A regular expression to match files to be excluded
// from parsing and analysis and will not be read at all.
//
// This is useful for excluding groups of test or example
// directories/files, unanalyzable files, or files that
// can't be removed for whatever reason.
// (e.g. `'@Test\.php$@'`, or `'@vendor/.*/(tests|Tests)/@'`)
'exclude_file_regex' => '',
// A list of files that will be excluded from parsing and analysis
// and will not be read at all.
//
// This is useful for excluding hopelessly unanalyzable
// files that can't be removed for whatever reason.
'exclude_file_list' => [],
// Enable this to enable checks of require/include statements referring to valid paths.
// The settings `include_paths` and `warn_about_relative_include_statement` affect the checks.
'enable_include_path_checks' => false,
// A list of [include paths](https://secure.php.net/manual/en/ini.core.php#ini.include-path) to check when checking if `require_once`, `include`, etc. are pointing to valid files.
//
// To refer to the directory of the file being analyzed, use `'.'`
// To refer to the project root directory, use \Phan\Config::getProjectRootDirectory()
//
// (E.g. `['.', \Phan\Config::getProjectRootDirectory() . '/src/folder-added-to-include_path']`)
//
// This is ignored if `enable_include_path_checks` is not `true`.
'include_paths' => ['.'],
// Enable this to warn about the use of relative paths in `require_once`, `include`, etc.
// Relative paths are harder to reason about, and opcache may have issues with relative paths in edge cases.
//
// This is ignored if `enable_include_path_checks` is not `true`.
'warn_about_relative_include_statement' => false,
// A directory list that defines files that will be excluded
// from static analysis, but whose class and method
// information should be included.
//
// Generally, you'll want to include the directories for
// third-party code (such as "vendor/") in this list.
//
// n.b.: If you'd like to parse but not analyze 3rd
// party code, directories containing that code
// should be added to the `directory_list` as well as
// to `exclude_analysis_directory_list`.
'exclude_analysis_directory_list' => [],
// This is set internally by Phan based on exclude_analysis_directory_list
'__exclude_analysis_regex' => null,
// A list of files that will be included in static analysis,
// **to the exclusion of others.**
//
// This typically should not get put in your Phan config file.
// It gets set by `--include-analysis-file-list`.
//
// Use `directory_list` and `file_list` instead to add files
// to be parsed and analyzed, and `exclude_*` to exclude files
// and folders from analysis.
'include_analysis_file_list' => [],
// Backwards Compatibility Checking. This is slow
// and expensive, but you should consider running
// it before upgrading your version of PHP to a
// new version that has backward compatibility
// breaks.
//
// If you are migrating from PHP 5 to PHP 7,
// you should also look into using
// [php7cc (no longer maintained)](https://github.com/sstalle/php7cc)
// and [php7mar](https://github.com/Alexia/php7mar),
// which have different backwards compatibility checks.
//
// If you are still using versions of php older than 5.6,
// `PHP53CompatibilityPlugin` may be worth looking into if you are not running
// syntax checks for php 5.3 through another method such as
// `InvokePHPNativeSyntaxCheckPlugin` (see .phan/plugins/README.md).
'backward_compatibility_checks' => true,
// A set of fully qualified class-names for which
// a call to `parent::__construct()` is required.
'parent_constructor_required' => [],
// If true, this runs a quick version of checks that takes less
// time at the cost of not running as thorough
// of an analysis. You should consider setting this
// to true only when you wish you had more **undiagnosed** issues
// to fix in your code base.
//
// In quick-mode the scanner doesn't rescan a function
// or a method's code block every time a call is seen.
// This means that the problem here won't be detected:
//
// ```php
// <?php
// function test($arg):int {
// return $arg;
// }
// test("abc");
// ```
//
// This would normally generate:
//
// ```
// test.php:3 PhanTypeMismatchReturn Returning type string but test() is declared to return int
// ```
//
// The initial scan of the function's code block has no
// type information for `$arg`. It isn't until we see
// the call and rescan `test()`'s code block that we can
// detect that it is actually returning the passed in
// `string` instead of an `int` as declared.
'quick_mode' => false,
// The maximum recursion depth that can be reached when analyzing the code.
// This setting only takes effect when quick_mode is disabled.
// A higher limit will make the analysis more accurate, but could possibly
// make it harder to track the code bit where a detected issue originates.
// As long as this is kept relatively low, performance is usually not affected
// by changing this setting.
'maximum_recursion_depth' => 2,
// If enabled, check all methods that override a
// parent method to make sure its signature is
// compatible with the parent's.
//
// This check can add quite a bit of time to the analysis.
//
// This will also check if final methods are overridden, etc.
'analyze_signature_compatibility' => true,
// Set this to true to allow contravariance in real parameter types of method overrides
// (Users may enable this if analyzing projects that support only php 7.2+)
//
// See [this note about PHP 7.2's new features](https://secure.php.net/manual/en/migration72.new-features.php#migration72.new-features.param-type-widening).
// This is false by default. (By default, Phan will warn if real parameter types are omitted in an override)
//
// If this is null, this will be inferred from `target_php_version`.
'allow_method_param_type_widening' => null,
// Set this to true to make Phan guess that undocumented parameter types
// (for optional parameters) have the same type as default values
// (Instead of combining that type with `mixed`).
//
// E.g. `function my_method($x = 'val')` would make Phan infer that `$x` had a type of `string`, not `string|mixed`.
// Phan will not assume it knows specific types if the default value is `false` or `null`.
'guess_unknown_parameter_type_using_default' => false,
// Allow adding types to vague return types such as @return object, @return ?mixed in function/method/closure union types.
// Normally, Phan only adds inferred returned types when there is no `@return` type or real return type signature..
// This setting can be disabled on individual methods by adding `@phan-hardcode-return-type` to the doc comment.
//
// Disabled by default. This is more useful with `--analyze-twice`.
'allow_overriding_vague_return_types' => false,
// When enabled, infer that the types of the properties of `$this` are equal to their default values at the start of `__construct()`.
// This will have some false positives due to Phan not checking for setters and initializing helpers.
// This does not affect inherited properties.
//
// Set to true to enable.
'infer_default_properties_in_construct' => false,
// If enabled, inherit any missing phpdoc for types from
// the parent method if none is provided.
//
// NOTE: This step will only be performed if `analyze_signature_compatibility` is also enabled.
'inherit_phpdoc_types' => true,
// The minimum severity level to report on. This can be
// set to `Issue::SEVERITY_LOW`, `Issue::SEVERITY_NORMAL` or
// `Issue::SEVERITY_CRITICAL`. Setting it to only
// critical issues is a good place to start on a big
// sloppy mature code base.
'minimum_severity' => Issue::SEVERITY_LOW,
// If enabled, missing properties will be created when
// they are first seen. If false, we'll report an
// error message if there is an attempt to write
// to a class property that wasn't explicitly
// defined.
'allow_missing_properties' => false,
// If enabled, allow null to be cast as any array-like type.
//
// This is an incremental step in migrating away from `null_casts_as_any_type`.
// If `null_casts_as_any_type` is true, this has no effect.
'null_casts_as_array' => false,
// If enabled, allow any array-like type to be cast to null.
// This is an incremental step in migrating away from `null_casts_as_any_type`.
// If `null_casts_as_any_type` is true, this has no effect.
'array_casts_as_null' => false,
// If enabled, null can be cast to any type and any
// type can be cast to null. Setting this to true
// will cut down on false positives.
'null_casts_as_any_type' => false,
// If enabled, Phan will warn if **any** type in a method invocation's object
// is definitely not an object,
// or if **any** type in an invoked expression is not a callable.
// Setting this to true will introduce numerous false positives
// (and reveal some bugs).
'strict_method_checking' => false,
// If enabled, Phan will warn if **any** type in the argument's union type
// cannot be cast to a type in the parameter's expected union type.
// Setting this to true will introduce numerous false positives
// (and reveal some bugs).
'strict_param_checking' => false,
// If enabled, Phan will warn if **any** type in a property assignment's union type
// cannot be cast to a type in the property's declared union type.
// Setting this to true will introduce numerous false positives
// (and reveal some bugs).
'strict_property_checking' => false,
// If enabled, Phan will warn if **any** type in a returned value's union type
// cannot be cast to the declared return type.
// Setting this to true will introduce numerous false positives
// (and reveal some bugs).
'strict_return_checking' => false,
// If enabled, Phan will warn if **any** type of the object expression for a property access
// does not contain that property.
'strict_object_checking' => false,
// If enabled, Phan will act as though it's certain of real return types of a subset of internal functions,
// even if those return types aren't available in reflection (real types were taken from php 7.3 or 8.0-dev, depending on target_php_version).
//
// Note that with php 7 and earlier, php would return null or false for many internal functions if the argument types or counts were incorrect.
// As a result, enabling this setting with target_php_version 8.0 may result in false positives for `--redundant-condition-detection` when codebases also support php 7.x.
'assume_real_types_for_internal_functions' => false,
// If enabled, scalars (int, float, bool, string, null)
// are treated as if they can cast to each other.
// This does not affect checks of array keys. See `scalar_array_key_cast`.
'scalar_implicit_cast' => false,
// If enabled, any scalar array keys (int, string)
// are treated as if they can cast to each other.
// E.g. `array<int,stdClass>` can cast to `array<string,stdClass>` and vice versa.
// Normally, a scalar type such as int could only cast to/from int and mixed.
'scalar_array_key_cast' => false,
// If this has entries, scalars (int, float, bool, string, null)
// are allowed to perform the casts listed.
//
// E.g. `['int' => ['float', 'string'], 'float' => ['int'], 'string' => ['int'], 'null' => ['string']]`
// allows casting null to a string, but not vice versa.
// (subset of `scalar_implicit_cast`)
'scalar_implicit_partial' => [],
// If true, Phan will convert the type of a possibly undefined array offset to the nullable, defined equivalent.
// If false, Phan will convert the type of a possibly undefined array offset to the defined equivalent (without converting to nullable).
'convert_possibly_undefined_offset_to_nullable' => false,
// If true, seemingly undeclared variables in the global
// scope will be ignored.
//
// This is useful for projects with complicated cross-file
// globals that you have no hope of fixing.
'ignore_undeclared_variables_in_global_scope' => false,
// If true, check to make sure the return type declared
// in the doc-block (if any) matches the return type
// declared in the method signature.
'check_docblock_signature_return_type_match' => true,
// If true, check to make sure the param types declared
// in the doc-block (if any) matches the param types
// declared in the method signature.
'check_docblock_signature_param_type_match' => true,
// If true, make narrowed types from phpdoc params override
// the real types from the signature, when real types exist.
// (E.g. allows specifying desired lists of subclasses,
// or to indicate a preference for non-nullable types over nullable types)
//
// Affects analysis of the body of the method and the param types passed in by callers.
//
// (*Requires `check_docblock_signature_param_type_match` to be true*)
'prefer_narrowed_phpdoc_param_type' => true,
// (*Requires `check_docblock_signature_return_type_match` to be true*)
//
// If true, make narrowed types from phpdoc returns override
// the real types from the signature, when real types exist.
//
// (E.g. allows specifying desired lists of subclasses,
// or to indicate a preference for non-nullable types over nullable types)
//
// This setting affects the analysis of return statements in the body of the method and the return types passed in by callers.
'prefer_narrowed_phpdoc_return_type' => true,
// Set to true in order to attempt to detect dead
// (unreferenced) code. Keep in mind that the
// results will only be a guess given that classes,
// properties, constants and methods can be referenced
// as variables (like `$class->$property` or
// `$class->$method()`) in ways that we're unable
// to make sense of.
//
// To more aggressively detect dead code,
// you may want to set `dead_code_detection_prefer_false_negative` to `false`.
'dead_code_detection' => false,
// Set to true in order to attempt to detect unused variables.
// `dead_code_detection` will also enable unused variable detection.
//
// This has a few known false positives, e.g. for loops or branches.
'unused_variable_detection' => false,
// Set to true in order to attempt to detect redundant and impossible conditions.
//
// This has some false positives involving loops,
// variables set in branches of loops, and global variables.
'redundant_condition_detection' => false,
// Set to true in order to attempt to detect error-prone truthiness/falsiness checks.
//
// This is not suitable for all codebases.
'error_prone_truthy_condition_detection' => false,
// Set to true in order to attempt to detect variables that could be replaced with constants or literals.
// (i.e. they are declared once (as a constant expression) and never modified)
// This is almost entirely false positives for most coding styles.
//
// This is intended to be used to check for bugs where a variable such as a boolean was declared but is no longer (or was never) modified.
'constant_variable_detection' => false,
// Set to true in order to emit issues such as `PhanUnusedPublicMethodParameter` instead of `PhanUnusedPublicNoOverrideMethodParameter`
// (i.e. assume any non-final non-private method can have overrides).
// This is useful in situations when parsing only a subset of the available files.
'unused_variable_detection_assume_override_exists' => false,
// Set this to true in order to aggressively assume class elements aren't overridden when analyzing uses of classes.
// This is useful for standalone applications which have all code analyzed by Phan.
//
// Currently, this just affects inferring that methods without return statements have type `void`
'assume_no_external_class_overrides' => false,
// Set to true in order to force tracking references to elements
// (functions/methods/consts/protected).
//
// `dead_code_detection` is another option which also causes references
// to be tracked.
'force_tracking_references' => false,
// If true, the dead code detection rig will
// prefer false negatives (not report dead code) to
// false positives (report dead code that is not
// actually dead).
//
// In other words, the graph of references will have
// too many edges rather than too few edges when guesses
// have to be made about what references what.
'dead_code_detection_prefer_false_negative' => true,
// If true, then before analysis, try to simplify AST into a form
// which improves Phan's type inference in edge cases.
//
// This may conflict with `dead_code_detection`.
// When this is true, this slows down analysis slightly.
//
// E.g. rewrites `if ($a = value() && $a > 0) {...}`
// into `$a = value(); if ($a) { if ($a > 0) {...}}`
//
// Defaults to true as of Phan 3.0.3.
// This still helps with some edge cases such as assignments in compound conditions.
'simplify_ast' => true,
// Enable this to warn about harmless redundant use for classes and namespaces such as `use Foo\bar` in namespace Foo.
//
// Note: This does not affect warnings about redundant uses in the global namespace.
'warn_about_redundant_use_namespaced_class' => false,
// If true, Phan will read `class_alias()` calls in the global scope, then
//
// 1. create aliases from the *parsed* files if no class definition was found, and
// 2. emit issues in the global scope if the source or target class is invalid.
// (If there are multiple possible valid original classes for an aliased class name,
// the one which will be created is unspecified.)
//
// NOTE: THIS IS EXPERIMENTAL, and the implementation may change.
'enable_class_alias_support' => false,
// If disabled, Phan will not read docblock type
// annotation comments for `@property`.
//
// - When enabled, in addition to inferring existence of magic properties,
// Phan will also warn when writing to `@property-read` and reading from `@property-read`.
// Phan will warn when writing to read-only properties and reading from write-only properties.
//
// Note: `read_type_annotations` must also be enabled.
'read_magic_property_annotations' => true,
// If disabled, Phan will not read docblock type
// annotation comments for `@method`.
//
// Note: `read_type_annotations` must also be enabled.
'read_magic_method_annotations' => true,
// If disabled, Phan will not read docblock type
// annotation comments for `@mixin`.
//
// Note: `read_type_annotations` must also be enabled.
'read_mixin_annotations' => true,
// If disabled, Phan will not read docblock type
// annotation comments (such as for `@return`, `@param`,
// `@var`, `@suppress`, `@deprecated`) and only rely on
// types expressed in code.
'read_type_annotations' => true,
// If enabled, Phan will cache ASTs generated by the polyfill/fallback to disk
// (except when running in the background as a language server/daemon)
//
// ASTs generated by the native AST library (php-ast) are never cached,
// because php-ast is faster than loading and unserializing data from the cache.
//
// Disabling this is faster when the cache won't be reused,
// e.g. if this would be run in a docker image without mounting the cache as a volume.
//
// The cache can be found at `sys_get_tmp_dir() . "/phan-$USERNAME"`.
'cache_polyfill_asts' => true,
// If enabled, warn about throw statement where the exception types
// are not documented in the PHPDoc of functions, methods, and closures.
'warn_about_undocumented_throw_statements' => false,
// If enabled (and `warn_about_undocumented_throw_statements` is enabled),
// Phan will warn about function/closure/method invocations that have `@throws`
// that aren't caught or documented in the invoking method.
'warn_about_undocumented_exceptions_thrown_by_invoked_functions' => false,
// Phan will not warn about lack of documentation of `@throws` for any of the configured classes or their subclasses.
// This only matters when `warn_about_undocumented_throw_statements` is true.
// The default is the empty array (Don't suppress any warnings)
//
// (E.g. `['RuntimeException', 'AssertionError', 'TypeError']`)
'exception_classes_with_optional_throws_phpdoc' => [ ],
// This setting maps case-insensitive strings to union types.
//
// This is useful if a project uses phpdoc that differs from the phpdoc2 standard.
//
// If the corresponding value is the empty string,
// then Phan will ignore that union type (E.g. can ignore 'the' in `@return the value`)
//
// If the corresponding value is not empty,
// then Phan will act as though it saw the corresponding UnionTypes(s)
// when the keys show up in a UnionType of `@param`, `@return`, `@var`, `@property`, etc.
//
// This matches the **entire string**, not parts of the string.
// (E.g. `@return the|null` will still look for a class with the name `the`, but `@return the` will be ignored with the below setting)
//
// (These are not aliases, this setting is ignored outside of doc comments).
// (Phan does not check if classes with these names exist)
//
// Example setting: `['unknown' => '', 'number' => 'int|float', 'char' => 'string', 'long' => 'int', 'the' => '']`
'phpdoc_type_mapping' => [ ],
// Set to true in order to ignore issue suppression.
// This is useful for testing the state of your code, but
// unlikely to be useful outside of that.
'disable_suppression' => false,
// Set to true in order to ignore line-based issue suppressions.
// Disabling both line and file-based suppressions is mildly faster.
'disable_line_based_suppression' => false,
// Set to true in order to ignore file-based issue suppressions.
'disable_file_based_suppression' => false,
// If set to true, we'll dump the AST instead of
// analyzing files
'dump_ast' => false,
// If set to a string, we'll dump the fully qualified lowercase
// function and method signatures instead of analyzing files.
'dump_signatures_file' => null,
// If set to true, we'll dump the list of files to parse
// to stdout instead of parsing and analyzing files.
'dump_parsed_file_list' => false,
// Include a progress bar in the output.
'progress_bar' => false,
// When true, use a different version of the progress bar
// that's suitable for Continuous Integration logs.
'__long_progress_bar' => false,
// If this much time (in seconds) has passed since the last update,
// then update the progress bar.
'progress_bar_sample_interval' => 0.1,
// The number of processes to fork off during the analysis
// phase.
'processes' => 1,
// Set to true to emit profiling data on how long various
// parts of Phan took to run. You likely don't care to do
// this.
'profiler_enabled' => false,
// Phan will give up on suggesting a different name in issue messages
// if the number of candidates (for a given suggestion category) is greater than `suggestion_check_limit`.
//
// Set this to `0` to disable most suggestions for similar names, and only suggest identical names in other namespaces.
// Set this to `PHP_INT_MAX` (or other large value) to always suggest similar names and identical names in other namespaces.
//
// Phan will be a bit slower when this config setting is large.
// A lower value such as 50 works for suggesting misspelled classes/constants in namespaces,
// but won't give you suggestions for globally namespaced functions.
'suggestion_check_limit' => 1000,
// Set this to true to disable suggestions for what to use instead of undeclared variables/classes/etc.
'disable_suggestions' => false,
// Add any issue types (such as `'PhanUndeclaredMethod'`)
// to this list to inhibit them from being reported.
'suppress_issue_types' => [
// 'PhanUndeclaredMethod',
],
// If this list is empty, no filter against issues types will be applied.
// If this list is non-empty, only issues within the list
// will be emitted by Phan.
//
// See https://github.com/phan/phan/wiki/Issue-Types-Caught-by-Phan
// for the full list of issues that Phan detects.
//
// Phan is capable of detecting hundreds of types of issues.
// Projects should almost always use `suppress_issue_types` instead.
'whitelist_issue_types' => [
// 'PhanUndeclaredClass',
],
// A custom list of additional superglobals and their types. **Only needed by projects using runkit/runkit7.**
//
// (Corresponding keys are declared in `runkit.superglobal` ini directive)
//
// `globals_type_map` should be set for setting the types of these superglobals.
// E.g `['_FOO']`;
'runkit_superglobals' => [],
// Override to hardcode existence and types of (non-builtin) globals in the global scope.
// Class names should be prefixed with `\`.
//
// (E.g. `['_FOO' => '\FooClass', 'page' => '\PageClass', 'userId' => 'int']`)
'globals_type_map' => [],
// Enable this to emit issue messages with markdown formatting.
'markdown_issue_messages' => false,
// Enable this with `--absolute-path-issue-messages` to use absolute paths in issue messages
'absolute_path_issue_messages' => false,
// If true, then hide the issue's column in plaintext and pylint output printers.
// Note that phan only knows the column for a tiny subset of issues.
'hide_issue_column' => false,
// Enable this to automatically use colorized phan output for the 'text' output format if the terminal supports it.
// Alternately, set PHAN_ENABLE_COLOR_OUTPUT=1.
// This config setting can be overridden with NO_COLOR=1 or PHAN_DISABLE_COLOR_OUTPUT=1.
'color_issue_messages_if_supported' => false,
// Emit colorized issue messages for the 'text' output mode (false by default with the 'text' output mode to supported terminals).
// NOTE: it is strongly recommended to enable this via other methods,
// since this is incompatible with most output formatters.
//
// This can be enabled by setting PHAN_ENABLE_COLOR_OUTPUT=1 or passing `--color` or by setting `color_issue_messages_if_supported`
'color_issue_messages' => null,
// In `--output-mode=verbose`, refuse to print lines of context that exceed this limit.
'max_verbose_snippet_length' => 1000,
// Allow overriding color scheme in `.phan/config.php` for printing issues, for individual types.
//
// See the keys of `Phan\Output\Colorizing::STYLES` for valid color names,
// and the keys of `Phan\Output\Colorizing::DEFAULT_COLOR_FOR_TEMPLATE` for valid color names.
//
// E.g. to change the color for the file (of an issue instance) to red, set this to `['FILE' => 'red']`
//
// E.g. to use the terminal's default color for the line (of an issue instance), set this to `['LINE' => 'none']`
'color_scheme' => [],
// Enable or disable support for generic templated
// class types.
'generic_types_enabled' => true,
// Assign files to be analyzed on random processes
// in random order. You very likely don't want to
// set this to true. This is meant for debugging
// and fuzz testing purposes only.
'randomize_file_order' => false,
// Setting this to true makes the process assignment for file analysis
// as predictable as possible, using consistent hashing.
//
// Even if files are added or removed, or process counts change,
// relatively few files will move to a different group.
// (use when the number of files is much larger than the process count)
//
// NOTE: If you rely on Phan parsing files/directories in the order
// that they were provided in this config, don't use this.
// See [this note in Phan's wiki](https://github.com/phan/phan/wiki/Different-Issue-Sets-On-Different-Numbers-of-CPUs).
'consistent_hashing_file_order' => false,
// Set by `--print-memory-usage-summary`. Prints a memory usage summary to stderr after analysis.
'print_memory_usage_summary' => false,
// By default, Phan will log error messages to stdout if PHP is using options that slow the analysis.
// (e.g. PHP is compiled with `--enable-debug` or when using Xdebug)
'skip_slow_php_options_warning' => false,
// By default, Phan will warn if the 'tokenizer' module isn't installed and enabled.
'skip_missing_tokenizer_warning' => false,
// This is the maximum frame length for crash reports
'debug_max_frame_length' => 1000,
// You can put paths to stubs of internal extensions in this config option.
// If the corresponding extension is **not** loaded, then Phan will use the stubs instead.
// Phan will continue using its detailed type annotations,
// but load the constants, classes, functions, and classes (and their Reflection types)
// from these stub files (doubling as valid php files).
// Use a different extension from php to avoid accidentally loading these.
// The `tools/make_stubs` script can be used to generate your own stubs (compatible with php 7.0+ right now)
//
// (e.g. `['xdebug' => '.phan/internal_stubs/xdebug.phan_php']`)
'autoload_internal_extension_signatures' => [
],
// This can be set to a list of extensions to limit Phan to using the reflection information of.
// If this is a list, then Phan will not use the reflection information of extensions outside of this list.
// The extensions loaded for a given php installation can be seen with `php -m` or `get_loaded_extensions(true)`.
//
// Note that this will only prevent Phan from loading reflection information for extensions outside of this set.
// If you want to add stubs, see `autoload_internal_extension_signatures`.
//
// If this is used, 'core', 'date', 'pcre', 'reflection', 'spl', and 'standard' will be automatically added.
//
// When this is an array, `ignore_undeclared_functions_with_known_signatures` will always be set to false.
// (because many of those functions will be outside of the configured list)
//
// Also see `ignore_undeclared_functions_with_known_signatures` to warn about using unknown functions.
'included_extension_subset' => null,
// Set this to false to emit `PhanUndeclaredFunction` issues for internal functions that Phan has signatures for,
// but aren't available in the codebase, or from Reflection.
// (may lead to false positives if an extension isn't loaded)
//
// If this is true(default), then Phan will not warn.
//
// Even when this is false, Phan will still infer return values and check parameters of internal functions
// if Phan has the signatures.
'ignore_undeclared_functions_with_known_signatures' => true,
// If a file to be analyzed can't be parsed,
// then use a slower PHP substitute for php-ast to try to parse the files.
// This setting is ignored if a file is excluded from analysis.
//
// NOTE: it is strongly recommended to enable this via the `--use-fallback-parser` CLI flag instead,
// since this may result in strange error messages for invalid files (e.g. if parsed but not analyzed).
'use_fallback_parser' => false,
// Use the polyfill parser based on tolerant-php-parser instead of the possibly missing native implementation
//
// NOTE: This makes parsing several times slower than the native implementation.
//
// NOTE: it is strongly recommended to enable this via the `--use-polyfill-parser` or `--force-polyfill-parser`
// since this may result in strange error messages for invalid files (e.g. if parsed but not analyzed).
'use_polyfill_parser' => false,
// Keep a reference to the original tolerant-php-parser node in the generated php-ast Node.
// This is extremely memory intensive, and only recommended if a Phan plugin is used for code reformatting, style checks, etc.
'__parser_keep_original_node' => false,
// Path to a Unix socket for a daemon to listen to files to analyze. Use command line option instead.
'daemonize_socket' => false,
// If a daemon should listen to files to analyze over TCP.
// This setting is mutually exclusive with `daemonize_socket`.
'daemonize_tcp' => false,
// TCP host for a daemon to listen to files to analyze.
'daemonize_tcp_host' => '127.0.0.1',
// TCP port (from 1024 to 65535) for a daemon to listen to files to analyze.
'daemonize_tcp_port' => 4846,
// If this is an array, it configures the way clients will communicate with the Phan language server.
// Possibilities: Exactly one of
//
// 1. `['stdin' => true]`
// 2. `['tcp-server' => string (address this server should listen on)]`
// 3. `['tcp' => string (address client is listening on)]`
'language_server_config' => false,
// Valid values: false, true. Should only be set via CLI (`--language-server-analyze-only-on-save`)
'language_server_analyze_only_on_save' => false,
// Valid values: null, 'info'. Used when developing or debugging a language server client of Phan.
'language_server_debug_level' => null,
// Set this to true to emit all issues detected from the language server (e.g. invalid phpdoc in parsed files),
// not just issues in files currently open in the editor/IDE.
// This can be very verbose and has more false positives.
'language_server_disable_output_filter' => false,
// This should only be set by CLI (`--language-server-force-missing-pcntl` or `language-server-require-pcntl`), which will set this to true for debugging.
// When true, this will manually back up the state of the PHP process and restore it.
'language_server_use_pcntl_fallback' => false,
// This should only be set via CLI (`--language-server-disable-go-to-definition` to disable)
// Affects "go to definition" and "go to type definition" of LSP.
'language_server_enable_go_to_definition' => true,
// This should only be set via CLI (`--language-server-disable-hover` to disable)
// Affects "hover" of LSP.
'language_server_enable_hover' => true,
// This should only be set via CLI (`--language-server-disable-completion` to disable)
// Affects "completion" of LSP.
'language_server_enable_completion' => true,
// Don't show the category name in issue messages.
// This makes error messages slightly shorter.
// Use `--language-server-hide-category` if you want to enable this.
'language_server_hide_category_of_issues' => false,
// Should be configured by --language-server-min-diagnostic-delay-ms.
// Use this for language clients that have race conditions processing diagnostics.
// Max value is 1000 ms.
'language_server_min_diagnostics_delay_ms' => 0,
// Set this to false to disable the plugins that Phan uses to infer more accurate return types of `array_map`, `array_filter`, and many other functions.
//
// Phan is slightly faster when these are disabled.
'enable_internal_return_type_plugins' => true,
// Set this to true to enable the plugins that Phan uses to infer more accurate return types of `implode`, `json_decode`, and many other functions.
//
// Phan is slightly faster when these are disabled.
'enable_extended_internal_return_type_plugins' => false,
// Set this to true to make Phan store a full Context inside variables, instead of a FileRef. This could provide more useful info to plugins,
// but will increase the memory usage by roughly 2.5%.
'record_variable_context_and_scope' => false,
// If a literal string type exceeds this length,
// then Phan converts it to a regular string type.
// This setting cannot be less than 50.
//
// This setting can be overridden if users wish to store strings that are even longer than 50 bytes.
'max_literal_string_type_length' => 200,
// internal
'dump_matching_functions' => false,
// This is the path to a file containing a list of pre-existing issues to ignore, on a per-file basis.
// It's recommended to set this with `--load-baseline=path/to/baseline.php`.
// A baseline file can be created or updated with `--save-baseline=path/to/baseline.php`.
'baseline_path' => null,
// For internal use only.
'__save_baseline_path' => null,
// This is the type of summary comment that will be generated when `--save-baseline=path/to/baseline.php` is used.
// Supported values: 'ordered_by_count' (default), 'ordered_by_type', 'none'.
// (The first type makes it easier to see uncommon issues when reading the code but is more prone to merge conflicts in version control)
// (Does not affect analysis)
'baseline_summary_type' => 'ordered_by_count',
// A list of plugin files to execute.
//
// Plugins which are bundled with Phan can be added here by providing their name (e.g. `'AlwaysReturnPlugin'`)
//
// Documentation about available bundled plugins can be found [here](https://github.com/phan/phan/tree/master/.phan/plugins).
//
// Alternately, you can pass in the full path to a PHP file with the plugin's implementation (e.g. `'vendor/phan/phan/.phan/plugins/AlwaysReturnPlugin.php'`)
'plugins' => [
],
// This can be used by third-party plugins that expect configuration.
//
// E.g. this is used by `InvokePHPNativeSyntaxCheckPlugin`
'plugin_config' => [
],
// This should only be set with `--analyze-twice`.
'__analyze_twice' => false,
// This should only be set with `--always-exit-successfully-after-analysis`
'__always_exit_successfully_after_analysis' => false,
];
public const COMPLETION_VSCODE = 'vscode';
/**
* Disallow the constructor.
*/
private function __construct()
{
}
/**
* @return string
* Get the root directory of the project that we're
* scanning