ImmutableChecker(ImmutableSet<String> immutableAnnotations) { this(ErrorProneFlags.empty(), immutableAnnotations); }
public MethodCanBeStatic(ErrorProneFlags flags) { boolean findingPerSite = flags.getBoolean("MethodCanBeStatic:FindingPerSite").orElse(false); this.findingOutputStyle = findingPerSite ? FindingOutputStyle.FINDING_PER_SITE : FindingOutputStyle.ONE_FINDING; }
/** * Gets the flag value for the given key as an Integer, wrapped in an {@link Optional}, which is * empty if the flag is unset. * * <p>If the flag's value cannot be interpreted as an Integer, throws a {@link * NumberFormatException} (note: float values will *not* be interpreted as integers and will throw * an exception!) */ public Optional<Integer> getInteger(String key) { return this.get(key).map(Integer::valueOf); }
/** * Gets the flag value for an enum of the given type, wrapped in an {@link Optional}, which is * empty if the flag is unset. */ public <T extends Enum<T>> Optional<T> getEnum(String key, Class<T> clazz) { return this.get(key).map(value -> asEnumValue(key, value, clazz)); }
/** * Returns a new ErrorProneFlags object with the values of two ErrorProneFlags objects added * together. For flags that appear in both instances, the values in {@code other} override {@code * this}. */ @CheckReturnValue public ErrorProneFlags plus(ErrorProneFlags other) { Map<String, String> combinedMaps = new HashMap<>(this.getFlagsMap()); combinedMaps.putAll(other.getFlagsMap()); return ErrorProneFlags.fromMap(combinedMaps); }
public Unused(ErrorProneFlags flags) { ImmutableSet.Builder<String> methodAnnotationsExemptingParameters = ImmutableSet.<String>builder() .add("org.robolectric.annotation.Implementation"); flags .getList("Unused:methodAnnotationsExemptingParameters") .ifPresent(methodAnnotationsExemptingParameters::addAll); this.methodAnnotationsExemptingParameters = methodAnnotationsExemptingParameters.build(); this.reportInjectedFields = flags.getBoolean("Unused:ReportInjectedFields").orElse(false); }
ErrorProneCLIFlagsConfig(ErrorProneFlags flags) { if (!flags.get(FL_ANNOTATED_PACKAGES).isPresent()) { throw new IllegalStateException( "DO NOT report an issue to Error Prone for this crash! NullAway configuration is " getFlagStringSet(flags, FL_INITIALIZER_ANNOT, DEFAULT_INITIALIZER_ANNOT); externalInitAnnotations = getFlagStringSet(flags, FL_EXTERNAL_INIT_ANNOT); isExhaustiveOverride = flags.getBoolean(FL_EXHAUSTIVE_OVERRIDE).orElse(false); isSuggestSuppressions = flags.getBoolean(FL_SUGGEST_SUPPRESSIONS).orElse(false); isAcknowledgeRestrictive = flags.getBoolean(FL_ACKNOWLEDGE_RESTRICTIVE).orElse(false); treatGeneratedAsUnannotated = flags.getBoolean(FL_GENERATED_UNANNOTATED).orElse(false); assertsEnabled = flags.getBoolean(FL_ASSERTS_ENABLED).orElse(false); fieldAnnotPattern = getPackagePattern( getFlagStringSet(flags, FL_EXCLUDED_FIELD_ANNOT, DEFAULT_EXCLUDED_FIELD_ANNOT)); castToNonNullMethod = flags.get(FL_CTNN_METHOD).orElse(null); autofixSuppressionComment = flags.get(FL_SUPPRESS_COMMENT).orElse(""); if (autofixSuppressionComment.contains("\n")) { throw new IllegalStateException( jarInferEnabled = flags.getBoolean(FL_JI_ENABLED).orElse(false); jarInferUseReturnAnnotations = flags.getBoolean(FL_JI_USE_RETURN).orElse(false); jarInferRegexStripModelJarName = flags.get(FL_JI_REGEX_MODEL_PATH).orElse(BASENAME_REGEX); jarInferRegexStripCodeJarName = flags.get(FL_JI_REGEX_CODE_PATH).orElse(BASENAME_REGEX); errorURL = flags.get(FL_ERROR_URL).orElse(DEFAULT_URL);
Map<String, Severity> severityOverrides = errorProneOptions.getSeverityMap(); if (severityOverrides.isEmpty() && errorProneOptions.getFlags().isEmpty() && !errorProneOptions.isEnableAllChecksAsWarnings() && !errorProneOptions.isDropErrorsToWarnings() Map<String, SeverityLevel> severities = new LinkedHashMap<>(severities()); Set<String> disabled = new HashSet<>(disabled()); Map<String, String> flagsMap = new HashMap<>(getFlags().getFlagsMap()); flagsMap.putAll(errorProneOptions.getFlags().getFlagsMap()); ImmutableMap.copyOf(severities), ImmutableSet.copyOf(disabled), ErrorProneFlags.fromMap(flagsMap));
public static WellKnownMutability fromFlags(ErrorProneFlags flags) { List<String> immutable = flags.getList("Immutable:KnownImmutable").orElse(ImmutableList.of()); List<String> unsafe = flags.getList("Immutable:KnownUnsafe").orElse(ImmutableList.of()); return new WellKnownMutability(immutable, unsafe); }
public static ErrorProneFlags fromMap(Map<String, String> flagsMap) { return new ErrorProneFlags(ImmutableMap.copyOf(flagsMap)); }
public ErrorProneFlags build() { return fromMap(flagsMap); } }
@Before public void setup() { // With AutoFixSuppressionComment ErrorProneFlags.Builder b = ErrorProneFlags.builder(); b.putFlag("NullAway:AnnotatedPackages", "com.uber,com.ubercab,io.reactivex"); b.putFlag("NullAway:SuggestSuppressions", "true"); b.putFlag("NullAway:AutoFixSuppressionComment", "PR #000000"); flags = b.build(); // Without AutoFixSuppressionComment b = ErrorProneFlags.builder(); b.putFlag("NullAway:AnnotatedPackages", "com.uber,com.ubercab,io.reactivex"); b.putFlag("NullAway:SuggestSuppressions", "true"); flagsNoAutoFixSuppressionComment = b.build(); }
@SuppressWarnings("WeakerAccess") // Public for ErrorProne public UseAutoDispose(ErrorProneFlags flags) { Optional<ImmutableSet<String>> inputClasses = flags.getList("TypesWithScope").map(ImmutableSet::copyOf); Optional<Boolean> overrideScopes = flags.getBoolean("OverrideScopes"); ImmutableSet<String> classesWithScope = getClassesWithScope(inputClasses, overrideScopes); matcher = allOf(SUBSCRIBE_METHOD, matcher(classesWithScope)); lenient = flags.getBoolean("Lenient").orElse(false); }
/** * Gets the flag value for a comma-separated set of enums of the given type, wrapped in an {@link * Optional}, which is empty if the flag is unset. If the flag is explicitly set to empty, an * empty set will be returned. */ public <T extends Enum<T>> Optional<ImmutableSet<T>> getEnumSet(String key, Class<T> clazz) { return this.get(key) .map( value -> Streams.stream(Splitter.on(',').omitEmptyStrings().split(value)) .map(v -> asEnumValue(key, v, clazz)) .collect(toImmutableSet())); }
Map<String, Severity> severityOverrides = errorProneOptions.getSeverityMap(); if (severityOverrides.isEmpty() && errorProneOptions.getFlags().isEmpty() && !errorProneOptions.isEnableAllChecksAsWarnings() && !errorProneOptions.isDropErrorsToWarnings() Map<String, SeverityLevel> severities = new LinkedHashMap<>(severities()); Set<String> disabled = new HashSet<>(disabled()); Map<String, String> flagsMap = new HashMap<>(getFlags().getFlagsMap()); flagsMap.putAll(errorProneOptions.getFlags().getFlagsMap()); ImmutableMap.copyOf(severities), ImmutableSet.copyOf(disabled), ErrorProneFlags.fromMap(flagsMap));
/** * Returns a new ErrorProneFlags object with the values of two ErrorProneFlags objects added * together. For flags that appear in both instances, the values in {@code other} override {@code * this}. */ @CheckReturnValue public ErrorProneFlags plus(ErrorProneFlags other) { Map<String, String> combinedMaps = new HashMap<>(this.getFlagsMap()); combinedMaps.putAll(other.getFlagsMap()); return ErrorProneFlags.fromMap(combinedMaps); }
public static WellKnownMutability fromFlags(ErrorProneFlags flags) { ImmutableList<String> immutable = flags.getList("Immutable:KnownImmutable").orElse(ImmutableList.of()); ImmutableList<String> unsafe = flags.getList("Immutable:KnownUnsafe").orElse(ImmutableList.of()); return new WellKnownMutability(immutable, unsafe); }
public static ErrorProneFlags empty() { return new ErrorProneFlags(ImmutableMap.of()); }
public ErrorProneFlags build() { return fromMap(flagsMap); } }
@Before public void setup() { ErrorProneFlags.Builder b = ErrorProneFlags.builder(); b.putFlag("NullAway:AnnotatedPackages", "com.uber,com.ubercab,io.reactivex"); b.putFlag("NullAway:CastToNonNullMethod", "com.uber.nullaway.testdata.Util.castToNonNull"); b.putFlag("NullAway:SuggestSuppressions", "true"); flags = b.build(); }