/
SourceChecker.java
2802 lines (2492 loc) · 104 KB
/
SourceChecker.java
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
package org.checkerframework.framework.source;
import com.sun.source.tree.AnnotationTree;
import com.sun.source.tree.ClassTree;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.Tree;
import com.sun.source.tree.VariableTree;
import com.sun.source.util.SourcePositions;
import com.sun.source.util.TreePath;
import com.sun.source.util.Trees;
import com.sun.tools.javac.code.Source;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.DiagnosticSource;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
import com.sun.tools.javac.util.Log;
import io.github.classgraph.ClassGraph;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.URI;
import java.time.Instant;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.NavigableSet;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import java.util.SortedSet;
import java.util.StringJoiner;
import java.util.TreeSet;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import javax.tools.Diagnostic;
import javax.tools.Diagnostic.Kind;
import org.checkerframework.checker.compilermsgs.qual.CompilerMessageKey;
import org.checkerframework.checker.formatter.qual.FormatMethod;
import org.checkerframework.checker.interning.qual.InternedDistinct;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.checkerframework.checker.signature.qual.CanonicalName;
import org.checkerframework.checker.signature.qual.FullyQualifiedName;
import org.checkerframework.common.basetype.BaseTypeChecker;
import org.checkerframework.framework.qual.AnnotatedFor;
import org.checkerframework.framework.type.AnnotatedTypeFactory;
import org.checkerframework.framework.util.CheckerMain;
import org.checkerframework.framework.util.OptionConfiguration;
import org.checkerframework.javacutil.AbstractTypeProcessor;
import org.checkerframework.javacutil.AnnotationProvider;
import org.checkerframework.javacutil.AnnotationUtils;
import org.checkerframework.javacutil.BugInCF;
import org.checkerframework.javacutil.ElementUtils;
import org.checkerframework.javacutil.SystemUtil;
import org.checkerframework.javacutil.TreePathUtil;
import org.checkerframework.javacutil.TreeUtils;
import org.checkerframework.javacutil.TypeSystemError;
import org.checkerframework.javacutil.UserError;
import org.plumelib.util.CollectionsPlume;
import org.plumelib.util.SystemPlume;
import org.plumelib.util.UtilPlume;
/**
* An abstract annotation processor designed for implementing a source-file checker as an annotation
* processor (a compiler plug-in). It provides an interface to {@code javac}'s annotation processing
* API, routines for error reporting via the JSR 199 compiler API, and an implementation for using a
* {@link SourceVisitor} to perform the type-checking.
*
* <p>Most type-checker plug-ins should extend {@link BaseTypeChecker}, instead of this class. Only
* checkers that require annotated types but not subtype checking (e.g. for testing purposes) should
* extend this. Non-type checkers (e.g. for enforcing coding styles) may extend {@link
* AbstractProcessor} (or even this class).
*/
@SupportedOptions({
// When adding a new standard option:
// 1. Add a brief blurb here about the use case
// and a pointer to one prominent use of the option.
// 2. Update the Checker Framework manual:
// * docs/manual/introduction.tex contains a list of all options,
// which should be in the same order as this source code file.
// * a specific section should contain a detailed discussion.
///
/// Unsound checking: ignore some errors
///
// A comma-separated list of warnings to suppress
// org.checkerframework.framework.source.SourceChecker.createSuppressWarnings
"suppressWarnings",
// Set inclusion/exclusion of type uses or definitions
// org.checkerframework.framework.source.SourceChecker.shouldSkipUses and similar
"skipUses",
"onlyUses",
"skipDefs",
"onlyDefs",
// Unsoundly assume all methods have no side effects, are deterministic, or both.
"assumeSideEffectFree",
"assumeDeterministic",
"assumePure",
// Whether to assume that assertions are enabled or disabled
// org.checkerframework.framework.flow.CFCFGBuilder.CFCFGBuilder
"assumeAssertionsAreEnabled",
"assumeAssertionsAreDisabled",
// Treat checker errors as warnings
// org.checkerframework.framework.source.SourceChecker.report
"warns",
///
/// More sound (strict checking): enable errors that are disabled by default
///
// The next ones *increase* rather than *decrease* soundness. They will eventually be replaced by
// their complements (except -AconcurrentSemantics) and moved into the above section.
// TODO: Checking of bodies of @SideEffectFree, @Deterministic, and
// @Pure methods is temporarily disabled unless -AcheckPurityAnnotations is
// supplied on the command line.
// Re-enable it after making the analysis more precise.
// org.checkerframework.common.basetype.BaseTypeVisitor.visitMethod(MethodTree, Void)
"checkPurityAnnotations",
// TODO: Temporary option to make array subtyping invariant,
// which will be the new default soon.
"invariantArrays",
// TODO: Temporary option to make casts stricter, in particular when
// casting to an array or generic type. This will be the new default soon.
"checkCastElementType",
// Whether to use conservative defaults for bytecode and/or source code.
// This option takes arguments "source" and/or "bytecode".
// The default is "-source,-bytecode" (eventually this will be changed to "-source,bytecode").
// Note, in source code, conservative defaults are never
// applied to code in the scope of an @AnnotatedFor.
// See the "Compiling partially-annotated libraries" and
// "Default qualifiers for \<.class> files (conservative library defaults)"
// sections in the manual for more details
// org.checkerframework.framework.source.SourceChecker.useConservativeDefault
"useConservativeDefaultsForUncheckedCode",
// Temporary, for backward compatibility
"useDefaultsForUncheckedCode",
// Whether to assume sound concurrent semantics or
// simplified sequential semantics
// org.checkerframework.framework.flow.CFAbstractTransfer.sequentialSemantics
"concurrentSemantics",
// Whether to use a conservative value for type arguments that could not be inferred.
// See Issue 979.
"conservativeUninferredTypeArguments",
// Whether to ignore all subtype tests for type arguments that
// were inferred for a raw type. Defaults to true.
// org.checkerframework.framework.type.TypeHierarchy.isSubtypeTypeArguments
"ignoreRawTypeArguments",
///
/// Type-checking modes: enable/disable functionality
///
// Lint options
// org.checkerframework.framework.source.SourceChecker.getSupportedLintOptions() and similar
"lint",
// Whether to suggest methods that could be marked @SideEffectFree,
// @Deterministic, or @Pure
// org.checkerframework.common.basetype.BaseTypeVisitor.visitMethod(MethodTree, Void)
"suggestPureMethods",
// Whether to resolve reflective method invocations.
// "-AresolveReflection=debug" causes debugging information
// to be output.
"resolveReflection",
// Whether to use whole-program inference. Takes an argument to specify the output format:
// "-Ainfer=stubs" or "-Ainfer=jaifs".
"infer",
// Whether to output a copy of each file for which annotations were inferred, formatted
// as an ajava file. Can only be used with -Ainfer=ajava
"inferOutputOriginal",
// With each warning, in addition to the concrete error key,
// output the SuppressWarnings strings that can be used to
// suppress that warning.
"showSuppressWarningsStrings",
// Warn about @SuppressWarnings annotations that do not suppress any warnings.
// org.checkerframework.common.basetype.BaseTypeChecker.warnUnneededSuppressions
// org.checkerframework.framework.source.SourceChecker.warnUnneededSuppressions
// org.checkerframework.framework.source.SourceChecker.shouldSuppressWarnings(javax.lang.model.element.Element, java.lang.String)
// org.checkerframework.framework.source.SourceVisitor.checkForSuppressWarningsAnno
"warnUnneededSuppressions",
// Exceptions to -AwarnUnneededSuppressions.
"warnUnneededSuppressionsExceptions",
// Require that warning suppression annotations contain a checker key as a prefix in order for
// the warning to be suppressed.
// org.checkerframework.framework.source.SourceChecker.checkSuppressWarnings(java.lang.String[],
// java.lang.String)
"requirePrefixInWarningSuppressions",
// Permit running under JDKs other than those the Checker Framework officially supports.
"permitUnsupportedJdkVersion",
// Ignore annotations in bytecode that have invalid annotation locations.
// See https://github.com/typetools/checker-framework/issues/2173
// org.checkerframework.framework.type.ElementAnnotationApplier.apply
"ignoreInvalidAnnotationLocations",
///
/// Partially-annotated libraries
///
// Additional stub files to use
// org.checkerframework.framework.type.AnnotatedTypeFactory.parseStubFiles()
"stubs",
// Additional ajava files to use
// org.checkerframework.framework.type.AnnotatedTypeFactory.parserAjavaFiles()
"ajava",
// Whether to print warnings about types/members in a stub file
// that were not found on the class path
// org.checkerframework.framework.stub.AnnotationFileParser.warnIfNotFound
"stubWarnIfNotFound",
"stubNoWarnIfNotFound",
// Whether to ignore missing classes even when warnIfNotFound is set to true and other classes
// from the same package are present (useful if a package spans more than one jar).
// org.checkerframework.framework.stub.AnnotationFileParser.warnIfNotFoundIgnoresClasses
"stubWarnIfNotFoundIgnoresClasses",
// Whether to print warnings about stub files that overwrite annotations from bytecode.
"stubWarnIfOverwritesBytecode",
// Whether to print warnings about stub files that are redundant with the annotations from
// bytecode.
"stubWarnIfRedundantWithBytecode",
// Whether to issue a NOTE rather than a WARNING for -AstubWarn* command-line options
"stubWarnNote",
// With this option, annotations in stub files are used EVEN IF THE SOURCE FILE IS
// PRESENT. Only use this option when you intend to store types in stub files rather than
// directly in source code, such as during whole-program inference. The annotations in the
// stub files will be glb'd with those in the source code before local inference begins.
"mergeStubsWithSource",
// Already listed above, but worth noting again in this section:
// "useConservativeDefaultsForUncheckedCode"
///
/// Debugging
///
/// Amount of detail in messages
// Print the version of the Checker Framework
"version",
// Print info about git repository from which the Checker Framework was compiled
"printGitProperties",
// Whether to print @InvisibleQualifier marked annotations
// org.checkerframework.framework.type.AnnotatedTypeMirror.toString()
"printAllQualifiers",
// Whether to print [] around a set of type parameters in order to clearly see where they end
// e.g. <E extends F, F extends Object>
// without this option the E is printed: E extends F extends Object
// with this option: E [ extends F [ extends Object super Void ] super Void ]
// when multiple type variables are used this becomes useful very quickly
"printVerboseGenerics",
// Whether to NOT output a stack trace for each framework error.
// org.checkerframework.framework.source.SourceChecker.logBugInCF
"noPrintErrorStack",
// If true, issue a NOTE rather than a WARNING when performance is impeded by memory constraints.
"noWarnMemoryConstraints",
// Only output error code, useful for testing framework
// org.checkerframework.framework.source.SourceChecker.message(Kind, Object, String, Object...)
"nomsgtext",
/// Format of messages
// Output detailed message in simple-to-parse format, useful
// for tools parsing Checker Framework output.
// org.checkerframework.framework.source.SourceChecker.message(Kind, Object, String, Object...)
"detailedmsgtext",
/// Stub and JDK libraries
// Ignore the standard jdk.astub file; primarily for testing or debugging.
// org.checkerframework.framework.type.AnnotatedTypeFactory.parseStubFiles()
"ignorejdkastub",
// Whether to check that the annotated JDK is correctly provided
// org.checkerframework.common.basetype.BaseTypeVisitor.checkForAnnotatedJdk()
"permitMissingJdk",
"nocheckjdk", // temporary, for backward compatibility
// Parse all JDK files at startup rather than as needed.
// org.checkerframework.framework.stub.AnnotationFileElementTypes.AnnotationFileElementTypes
"parseAllJdk",
// Whether to print debugging messages while processing the stub files
// org.checkerframework.framework.stub.AnnotationFileParser.debugAnnotationFileParser
"stubDebug",
/// Progress tracing
// Output file names before checking
// org.checkerframework.framework.source.SourceChecker.typeProcess()
"filenames",
// Output all subtyping checks
// org.checkerframework.common.basetype.BaseTypeVisitor
"showchecks",
// Output information about intermediate steps in method type argument inference
// org.checkerframework.framework.util.typeinference.DefaultTypeArgumentInference
"showInferenceSteps",
// Output a stack trace when reporting errors or warnings
// org.checkerframework.common.basetype.SourceChecker.printStackTrace()
"dumpOnErrors",
/// Visualizing the CFG
// Implemented in the wrapper rather than this file, but worth noting here.
// -AoutputArgsToFile
// Mechanism to visualize the control flow graph (CFG).
// The argument is a sequence of values or key-value pairs.
// The first argument has to be the fully-qualified name of the
// org.checkerframework.dataflow.cfg.CFGVisualizer implementation that should be used. The
// remaining values or key-value pairs are passed to CFGVisualizer.init.
// For example:
// -Acfgviz=MyViz,a,b=c,d
// instantiates class MyViz and calls CFGVisualizer.init
// with {"a" -> true, "b" -> "c", "d" -> true}.
"cfgviz",
// Directory for .dot files generated from the CFG visualization in
// org.checkerframework.dataflow.cfg.DOTCFGVisualizer
// as initialized by
// org.checkerframework.framework.type.GenericAnnotatedTypeFactory.createCFGVisualizer()
// -Aflowdotdir=xyz
// is short-hand for
// -Acfgviz=org.checkerframework.dataflow.cfg.DOTCFGVisualizer,outdir=xyz
"flowdotdir",
// Enable additional output in the CFG visualization.
// -Averbosecfg
// is short-hand for
// -Acfgviz=MyClass,verbose
"verbosecfg",
/// Caches
// Set the cache size for caches in AnnotatedTypeFactory
"atfCacheSize",
// Sets AnnotatedTypeFactory shouldCache to false
"atfDoNotCache",
/// Miscellaneous debugging options
// Whether to output resource statistics at JVM shutdown
// org.checkerframework.framework.source.SourceChecker.shutdownHook()
"resourceStats",
// Parse all JDK files at startup rather than as needed.
"parseAllJdk",
// Run checks that test ajava files.
//
// Whenever processing a source file, parse it with JavaParser and check that the AST can be
// matched with javac's tree. Crash if not. For testing the class JointJavacJavaParserVisitor.
//
// Also checks that annotations can be inserted. For each Java file, clears all annotations and
// reinserts them, then checks if the original and modified ASTs are equivalent.
"ajavaChecks",
})
public abstract class SourceChecker extends AbstractTypeProcessor implements OptionConfiguration {
// TODO A checker should export itself through a separate interface, and maybe have an interface
// for all the methods for which it's safe to override.
/** The message key that will suppress all warnings (it matches any message key). */
public static final String SUPPRESS_ALL_MESSAGE_KEY = "all";
/** The SuppressWarnings prefix that will suppress warnings for all checkers. */
public static final String SUPPRESS_ALL_PREFIX = "allcheckers";
/** The message key emitted when an unused warning suppression is found. */
public static final @CompilerMessageKey String UNNEEDED_SUPPRESSION_KEY = "unneeded.suppression";
/** File name of the localized messages. */
protected static final String MSGS_FILE = "messages.properties";
/**
* Maps error keys to localized/custom error messages. Do not use directly; call {@link
* #fullMessageOf} or {@link #processArg}.
*/
protected Properties messagesProperties;
/** Used to report error messages and warnings via the compiler. */
protected Messager messager;
/** Element utilities. */
protected Elements elements;
/** Tree utilities; used as a helper for the {@link SourceVisitor}. */
protected Trees trees;
/** Type utilities. */
protected Types types;
/** The source tree that is being scanned. */
protected @InternedDistinct CompilationUnitTree currentRoot;
/** The visitor to use. */
protected SourceVisitor<?, ?> visitor;
/**
* Exceptions to {@code -AwarnUnneededSuppressions} processing. No warning about unneeded
* suppressions is issued if the SuppressWarnings string matches this pattern.
*/
private @Nullable Pattern warnUnneededSuppressionsExceptions;
/**
* SuppressWarnings strings supplied via the -AsuppressWarnings option. Do not use directly, call
* {@link #getSuppressWarningsStringsFromOption()}.
*/
private String @Nullable [] suppressWarningsStringsFromOption;
/**
* If true, use the "allcheckers:" warning string prefix.
*
* <p>Checkers that never issue any error messages should set this to false. That prevents {@code
* -AwarnUnneededSuppressions} from issuing warnings about
* {@code @SuppressWarnings("allcheckers:...")}.
*/
protected boolean useAllcheckersPrefix = true;
/**
* Regular expression pattern to specify Java classes that are not annotated, so warnings about
* uses of them should be suppressed.
*
* <p>It contains the pattern specified by the user, through the option {@code checkers.skipUses};
* otherwise it contains a pattern that can match no class.
*/
private Pattern skipUsesPattern;
/**
* Regular expression pattern to specify Java classes that are annotated, so warnings about them
* should be issued but warnings about all other classes should be suppressed.
*
* <p>It contains the pattern specified by the user, through the option {@code checkers.onlyUses};
* otherwise it contains a pattern that matches every class.
*/
private Pattern onlyUsesPattern;
/**
* Regular expression pattern to specify Java classes whose definition should not be checked.
*
* <p>It contains the pattern specified by the user, through the option {@code checkers.skipDefs};
* otherwise it contains a pattern that can match no class.
*/
private Pattern skipDefsPattern;
/**
* Regular expression pattern to specify Java classes whose definition should be checked.
*
* <p>It contains the pattern specified by the user, through the option {@code checkers.onlyDefs};
* otherwise it contains a pattern that matches every class.
*/
private Pattern onlyDefsPattern;
/** The supported lint options. */
private Set<String> supportedLints;
/** The enabled lint options. */
private Set<String> activeLints;
/**
* The active options for this checker. This is a processed version of {@link
* ProcessingEnvironment#getOptions()}: If the option is of the form "-ACheckerName_key=value" and
* the current checker class, or one of its superclasses, is named "CheckerName", then add key
* → value. If the option is of the form "-ACheckerName_key=value" and the current checker
* class, and none of its superclasses, is named "CheckerName", then do not add key → value.
* If the option is of the form "-Akey=value", then add key → value.
*
* <p>Both the simple and the canonical name of the checker can be used. Superclasses of the
* current checker are also considered.
*/
private Map<String, String> activeOptions;
/**
* The string that separates the checker name from the option name in a "-A" command-line
* argument. This string may only consist of valid Java identifier part characters, because it
* will be used within the key of an option.
*/
protected static final String OPTION_SEPARATOR = "_";
/**
* The checker that called this one, whether that be a BaseTypeChecker (used as a compound
* checker) or an AggregateChecker. Null if this is the checker that calls all others. Note that
* in the case of a compound checker, the compound checker is the parent, not the checker that was
* run prior to this one by the compound checker.
*/
protected @Nullable SourceChecker parentChecker;
/** List of upstream checker names. Includes the current checker. */
protected List<@FullyQualifiedName String> upstreamCheckerNames;
@Override
public final synchronized void init(ProcessingEnvironment env) {
ProcessingEnvironment unwrappedEnv = unwrapProcessingEnvironment(env);
super.init(unwrappedEnv);
// The processingEnvironment field will be set by the superclass's init method.
// This is used to trigger AggregateChecker's setProcessingEnvironment.
setProcessingEnvironment(unwrappedEnv);
// Keep in sync with check in checker-framework/build.gradle .
int jreVersion = SystemUtil.jreVersion;
if (jreVersion != 8 && jreVersion != 11 && jreVersion != 17 && jreVersion != 18) {
message(
(hasOption("permitUnsupportedJdkVersion") ? Kind.NOTE : Kind.WARNING),
"The Checker Framework is tested with JDK 8, 11, 17, and 18."
+ " You are using version %d.",
jreVersion);
}
if (!hasOption("warnUnneededSuppressionsExceptions")) {
warnUnneededSuppressionsExceptions = null;
} else {
String warnUnneededSuppressionsExceptionsString =
getOption("warnUnneededSuppressionsExceptions");
if (warnUnneededSuppressionsExceptionsString == null) {
throw new UserError("Must supply an argument to -AwarnUnneededSuppressionsExceptions");
}
try {
warnUnneededSuppressionsExceptions =
Pattern.compile(warnUnneededSuppressionsExceptionsString);
} catch (PatternSyntaxException e) {
throw new UserError(
"Argument to -AwarnUnneededSuppressionsExceptions is not a regular expression: "
+ e.getMessage());
}
}
if (hasOption("printGitProperties")) {
printGitProperties();
}
}
///////////////////////////////////////////////////////////////////////////
/// Getters and setters
///
/**
* Returns the {@link ProcessingEnvironment} that was supplied to this checker.
*
* @return the {@link ProcessingEnvironment} that was supplied to this checker
*/
public ProcessingEnvironment getProcessingEnvironment() {
return this.processingEnv;
}
/**
* Set the processing environment of the current checker.
*
* @param env the new processing environment
*/
// This method is protected only to allow the AggregateChecker and BaseTypeChecker to call it.
protected void setProcessingEnvironment(ProcessingEnvironment env) {
this.processingEnv = env;
this.elements = processingEnv.getElementUtils();
this.trees = Trees.instance(processingEnv);
this.types = processingEnv.getTypeUtils();
}
/** Set the parent checker of the current checker. */
protected void setParentChecker(SourceChecker parentChecker) {
this.parentChecker = parentChecker;
}
/**
* Returns the immediate parent checker of the current checker.
*
* @return the immediate parent checker of the current checker, or null if there is none
*/
public @Nullable SourceChecker getParentChecker() {
return this.parentChecker;
}
/**
* Invoked when the current compilation unit root changes.
*
* @param newRoot the new compilation unit root
*/
@SuppressWarnings("interning:assignment") // used in == tests
protected void setRoot(CompilationUnitTree newRoot) {
this.currentRoot = newRoot;
visitor.setRoot(currentRoot);
}
/**
* Returns a list containing this checker name and all checkers it is a part of (that is, checkers
* that called it).
*
* @return a list containing this checker name and all checkers it is a part of (that is, checkers
* that called it)
*/
public List<@FullyQualifiedName String> getUpstreamCheckerNames() {
if (upstreamCheckerNames == null) {
upstreamCheckerNames = new ArrayList<>();
SourceChecker checker = this;
while (checker != null) {
upstreamCheckerNames.add(checker.getClass().getCanonicalName());
checker = checker.parentChecker;
}
}
return upstreamCheckerNames;
}
/**
* Returns the OptionConfiguration associated with this.
*
* @return the OptionConfiguration associated with this
*/
public OptionConfiguration getOptionConfiguration() {
return this;
}
/**
* Returns the element utilities associated with this.
*
* @return the element utilities associated with this
*/
public Elements getElementUtils() {
return elements;
}
/**
* Returns the type utilities associated with this.
*
* @return the type utilities associated with this
*/
public Types getTypeUtils() {
return types;
}
/**
* Returns the tree utilities associated with this.
*
* @return the tree utilities associated with this
*/
public Trees getTreeUtils() {
return trees;
}
/**
* Returns the SourceVisitor associated with this.
*
* @return the SourceVisitor associated with this
*/
public SourceVisitor<?, ?> getVisitor() {
return this.visitor;
}
/**
* Provides the {@link SourceVisitor} that the checker should use to scan input source trees.
*
* @return a {@link SourceVisitor} to use to scan source trees
*/
protected abstract SourceVisitor<?, ?> createSourceVisitor();
/**
* Returns the AnnotationProvider (the type factory) associated with this.
*
* @return the AnnotationProvider (the type factory) associated with this
*/
public AnnotationProvider getAnnotationProvider() {
throw new UnsupportedOperationException(
"getAnnotationProvider is not implemented for this class.");
}
/**
* Provides a mapping of error keys to custom error messages.
*
* <p>As a default, this implementation builds a {@link Properties} out of file {@code
* messages.properties}. It accumulates all the properties files in the Java class hierarchy from
* the checker up to {@code SourceChecker}. This permits subclasses to inherit default messages
* while being able to override them.
*
* @return a {@link Properties} that maps error keys to error message text
*/
public Properties getMessagesProperties() {
if (messagesProperties != null) {
return messagesProperties;
}
messagesProperties = new Properties();
ArrayDeque<Class<?>> checkers = new ArrayDeque<>();
Class<?> currClass = this.getClass();
while (currClass != AbstractTypeProcessor.class) {
checkers.addFirst(currClass);
currClass = currClass.getSuperclass();
}
for (Class<?> checker : checkers) {
messagesProperties.putAll(getProperties(checker, MSGS_FILE, true));
}
return messagesProperties;
}
/**
* Return the given skip pattern if supplied by the user, or else a pattern that matches nothing.
*
* @param patternName "skipUses" or "skipDefs"
* @param options the command-line options
* @return the user-supplied regex for the given pattern, or a regex that matches nothing
*/
private Pattern getSkipPattern(String patternName, Map<String, String> options) {
// Default is an illegal Java identifier substring
// so that it won't match anything.
// Note that AnnotatedType's toString output format contains characters such as "():{}".
return getPattern(patternName, options, "\\]'\"\\]");
}
/**
* Return the given only pattern if supplied by the user, or else a pattern that matches
* everything.
*
* @param patternName "onlyUses" or "onlyDefs"
* @param options the command-line options
* @return the user-supplied regex for the given pattern, or a regex that matches everything
*/
private Pattern getOnlyPattern(String patternName, Map<String, String> options) {
// default matches everything
return getPattern(patternName, options, ".");
}
private Pattern getPattern(
String patternName, Map<String, String> options, String defaultPattern) {
String pattern = "";
if (options.containsKey(patternName)) {
pattern = options.get(patternName);
if (pattern == null) {
message(
Kind.WARNING,
"The " + patternName + " property is empty; please fix your command line");
pattern = "";
}
} else if (System.getProperty("checkers." + patternName) != null) {
pattern = System.getProperty("checkers." + patternName);
} else if (System.getenv(patternName) != null) {
pattern = System.getenv(patternName);
}
if (pattern.indexOf("/") != -1) {
message(
Kind.WARNING,
"The "
+ patternName
+ " property contains \"/\", which will never match a class name: "
+ pattern);
}
if (pattern.equals("")) {
pattern = defaultPattern;
}
return Pattern.compile(pattern);
}
private Pattern getSkipUsesPattern(Map<String, String> options) {
return getSkipPattern("skipUses", options);
}
private Pattern getOnlyUsesPattern(Map<String, String> options) {
return getOnlyPattern("onlyUses", options);
}
private Pattern getSkipDefsPattern(Map<String, String> options) {
return getSkipPattern("skipDefs", options);
}
private Pattern getOnlyDefsPattern(Map<String, String> options) {
return getOnlyPattern("onlyDefs", options);
}
///////////////////////////////////////////////////////////////////////////
/// Type-checking
///
/**
* {@inheritDoc}
*
* <p>Type-checkers are not supposed to override this. Instead override initChecker. This allows
* us to handle BugInCF only here and doesn't require all overriding implementations to be aware
* of BugInCF.
*
* @see AbstractProcessor#init(ProcessingEnvironment)
* @see SourceChecker#initChecker()
*/
@Override
public void typeProcessingStart() {
try {
super.typeProcessingStart();
initChecker();
if (this.messager == null) {
messager = processingEnv.getMessager();
messager.printMessage(
Kind.WARNING,
"You have forgotten to call super.initChecker in your "
+ "subclass of SourceChecker, "
+ this.getClass()
+ "! Please ensure your checker is properly initialized.");
}
if (shouldAddShutdownHook()) {
Runtime.getRuntime()
.addShutdownHook(
new Thread() {
@Override
public void run() {
shutdownHook();
}
});
}
if (hasOption("version")) {
messager.printMessage(Kind.NOTE, "Checker Framework " + getCheckerVersion());
}
} catch (UserError ce) {
logUserError(ce);
} catch (TypeSystemError ce) {
logTypeSystemError(ce);
} catch (BugInCF ce) {
logBugInCF(ce);
} catch (Throwable t) {
logBugInCF(wrapThrowableAsBugInCF("SourceChecker.typeProcessingStart", t, null));
}
}
/**
* Initialize the checker.
*
* @see AbstractProcessor#init(ProcessingEnvironment)
*/
public void initChecker() {
// Grab the Trees and Messager instances now; other utilities
// (like Types and Elements) can be retrieved by subclasses.
@Nullable Trees trees = Trees.instance(processingEnv);
assert trees != null;
this.trees = trees;
this.messager = processingEnv.getMessager();
this.messagesProperties = getMessagesProperties();
this.visitor = createSourceVisitor();
// Validate the lint flags, if they haven't been used already.
if (this.activeLints == null) {
this.activeLints = createActiveLints(getOptions());
}
}
/** Output the warning about source level at most once. */
private boolean warnedAboutSourceLevel = false;
/**
* If true, javac failed to compile the code or a previously-run annotation processor issued an
* error.
*/
protected boolean javacErrored = false;
/** Output the warning about memory at most once. */
private boolean warnedAboutGarbageCollection = false;
/**
* The number of errors at the last exit of the type processor. At entry to the type processor we
* check whether the current error count is higher and then don't process the file, as it contains
* some Java errors. Needs to be protected to allow access from AggregateChecker and
* BaseTypeChecker.
*/
protected int errsOnLastExit = 0;
/**
* Report "type.checking.not.run" error.
*
* @param p error is reported at the leaf of the path
*/
@SuppressWarnings("interning:assignment") // used in == tests
protected void reportJavacError(TreePath p) {
// If javac issued any errors, do not type check any file, so that the Checker Framework
// does not have to deal with error types.
currentRoot = p.getCompilationUnit();
reportError(p.getLeaf(), "type.checking.not.run", getClass().getSimpleName());
}
/**
* Type-check the code using this checker's visitor.
*
* @see Processor#process(Set, RoundEnvironment)
*/
@Override
public void typeProcess(TypeElement e, TreePath p) {
if (javacErrored) {
reportJavacError(p);
return;
}
// Cannot use BugInCF here because it is outside of the try/catch for BugInCF.
if (e == null) {
messager.printMessage(Kind.ERROR, "Refusing to process empty TypeElement");
return;
}
if (p == null) {
messager.printMessage(Kind.ERROR, "Refusing to process empty TreePath in TypeElement: " + e);
return;
}
if (!warnedAboutGarbageCollection) {
String gcUsageMessage = SystemPlume.gcUsageMessage(.25, 60);
if (gcUsageMessage != null) {
boolean noWarnMemoryConstraints =
(processingEnv != null
&& processingEnv.getOptions() != null
&& processingEnv.getOptions().containsKey("noWarnMemoryConstraints"));
Kind kind = noWarnMemoryConstraints ? Kind.NOTE : Kind.WARNING;
messager.printMessage(kind, gcUsageMessage);
warnedAboutGarbageCollection = true;
}
}
Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
Source source = Source.instance(context);
// Don't use source.allowTypeAnnotations() because that API changed after 9.
// Also the enum constant Source.JDK1_8 was renamed at some point...
if (!warnedAboutSourceLevel && source.compareTo(Source.lookup("8")) < 0) {
messager.printMessage(
Kind.WARNING, "-source " + source.name + " does not support type annotations");
warnedAboutSourceLevel = true;
}
Log log = Log.instance(context);
if (log.nerrors > this.errsOnLastExit) {
this.errsOnLastExit = log.nerrors;
javacErrored = true;
reportJavacError(p);
return;
}
if (visitor == null) {
// typeProcessingStart invokes initChecker, which should have set the visitor. If the field is
// still null, an exception occurred during initialization, which was already logged
// there. Don't also cause a NPE here.
return;
}
if (p.getCompilationUnit() != currentRoot) {
setRoot(p.getCompilationUnit());
if (hasOption("filenames")) {
// TODO: Have a command-line option to turn the timestamps on/off too, because
// they are nondeterministic across runs.
// Add timestamp to indicate how long operations are taking.
// Duplicate messages are suppressed, so this might not appear in front of every "
// is type-checking " message (when a file takes less than a second to type-check).
message(Kind.NOTE, Instant.now().toString());
message(