PrimitiveRules

SUGGESTION

Simplification

View source code on GitHub

Suppression

Disable all rules by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$).* as compiler argument.

Table of contents
  1. LessThan
  2. LessThanOrEqualTo
  3. GreaterThan
  4. GreaterThanOrEqualTo
  5. LongToIntExact
  6. CharacterBytes
  7. ShortBytes
  8. IntegerBytes
  9. LongBytes
  10. FloatBytes
  11. DoubleBytes
  12. IntegerSignumIsPositive
  13. IntegerSignumIsNegative
  14. LongSignumIsPositive
  15. LongSignumIsNegative
  16. IntegerCompareUnsigned
  17. LongCompareUnsigned
  18. IntegerDivideUnsigned
  19. LongDivideUnsigned
  20. IntegerRemainderUnsigned
  21. LongRemainderUnsigned
  22. IntegerParseUnsignedInt
  23. LongParseUnsignedLong
  24. IntegerParseUnsignedIntWithRadix
  25. LongParseUnsignedLongWithRadix
  26. IntegerToUnsignedString
  27. LongToUnsignedString
  28. IntegerToUnsignedStringWithRadix
  29. LongToUnsignedStringWithRadix
  30. ArraysCompareUnsignedBytes
  31. ArraysCompareUnsignedInts
  32. ArraysCompareUnsignedLongs

LessThan

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LessThan") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LessThan).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testLessThan() {
   return ImmutableSet.of(
-      !((byte) 3 >= (byte) 4),
-      !((char) 3 >= (char) 4),
-      !((short) 3 >= (short) 4),
-      !(3 >= 4),
-      !(3L >= 4L),
-      !(3F >= 4F),
-      !(3.0 >= 4.0));
+      (byte) 3 < (byte) 4,
+      (char) 3 < (char) 4,
+      (short) 3 < (short) 4,
+      3 < 4,
+      3L < 4L,
+      3F < 4F,
+      3.0 < 4.0);
 }

LessThanOrEqualTo

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LessThanOrEqualTo") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LessThanOrEqualTo).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testLessThanOrEqualTo() {
   return ImmutableSet.of(
-      !((byte) 3 > (byte) 4),
-      !((char) 3 > (char) 4),
-      !((short) 3 > (short) 4),
-      !(3 > 4),
-      !(3L > 4L),
-      !(3F > 4F),
-      !(3.0 > 4.0));
+      (byte) 3 <= (byte) 4,
+      (char) 3 <= (char) 4,
+      (short) 3 <= (short) 4,
+      3 <= 4,
+      3L <= 4L,
+      3F <= 4F,
+      3.0 <= 4.0);
 }

GreaterThan

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("GreaterThan") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$GreaterThan).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testGreaterThan() {
   return ImmutableSet.of(
-      !((byte) 3 <= (byte) 4),
-      !((char) 3 <= (char) 4),
-      !((short) 3 <= (short) 4),
-      !(3 <= 4),
-      !(3L <= 4L),
-      !(3F <= 4F),
-      !(3.0 <= 4.0));
+      (byte) 3 > (byte) 4,
+      (char) 3 > (char) 4,
+      (short) 3 > (short) 4,
+      3 > 4,
+      3L > 4L,
+      3F > 4F,
+      3.0 > 4.0);
 }

GreaterThanOrEqualTo

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("GreaterThanOrEqualTo") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$GreaterThanOrEqualTo).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testGreaterThanOrEqualTo() {
   return ImmutableSet.of(
-      !((byte) 3 < (byte) 4),
-      !((char) 3 < (char) 4),
-      !((short) 3 < (short) 4),
-      !(3 < 4),
-      !(3L < 4L),
-      !(3F < 4F),
-      !(3.0 < 4.0));
+      (byte) 3 >= (byte) 4,
+      (char) 3 >= (char) 4,
+      (short) 3 >= (short) 4,
+      3 >= 4,
+      3L >= 4L,
+      3F >= 4F,
+      3.0 >= 4.0);
 }

LongToIntExact

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongToIntExact") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongToIntExact).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testLongToIntExact() {
-  return Ints.checkedCast(Long.MAX_VALUE);
+  return Math.toIntExact(Long.MAX_VALUE);
 }

CharacterBytes

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("CharacterBytes") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$CharacterBytes).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testCharacterBytes() {
-  return Chars.BYTES;
+  return Character.BYTES;
 }

ShortBytes

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("ShortBytes") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$ShortBytes).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testShortBytes() {
-  return Shorts.BYTES;
+  return Short.BYTES;
 }

IntegerBytes

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerBytes") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerBytes).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testIntegerBytes() {
-  return Ints.BYTES;
+  return Integer.BYTES;
 }

LongBytes

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongBytes") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongBytes).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testLongBytes() {
-  return Longs.BYTES;
+  return Long.BYTES;
 }

FloatBytes

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("FloatBytes") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$FloatBytes).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testFloatBytes() {
-  return Floats.BYTES;
+  return Float.BYTES;
 }

DoubleBytes

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("DoubleBytes") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$DoubleBytes).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testDoubleBytes() {
-  return Doubles.BYTES;
+  return Double.BYTES;
 }

IntegerSignumIsPositive

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerSignumIsPositive") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerSignumIsPositive).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testIntegerSignumIsPositive() {
   return ImmutableSet.of(
-      Integer.signum(1) > 0,
-      Integer.signum(2) >= 1,
-      Integer.signum(3) <= 0,
-      Integer.signum(4) < 1);
+      Integer.signum(1) == 1,
+      Integer.signum(2) == 1,
+      Integer.signum(3) != 1,
+      Integer.signum(4) != 1);
 }

IntegerSignumIsNegative

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerSignumIsNegative") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerSignumIsNegative).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testIntegerSignumIsNegative() {
   return ImmutableSet.of(
-      Integer.signum(1) < 0,
-      Integer.signum(2) <= -1,
-      Integer.signum(3) >= 0,
-      Integer.signum(4) > -1);
+      Integer.signum(1) == -1,
+      Integer.signum(2) == -1,
+      Integer.signum(3) != -1,
+      Integer.signum(4) != -1);
 }

LongSignumIsPositive

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongSignumIsPositive") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongSignumIsPositive).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testLongSignumIsPositive() {
   return ImmutableSet.of(
-      Long.signum(1L) > 0, Long.signum(2L) >= 1, Long.signum(3L) <= 0, Long.signum(4L) < 1);
+      Long.signum(1L) == 1, Long.signum(2L) == 1, Long.signum(3L) != 1, Long.signum(4L) != 1);
 }

LongSignumIsNegative

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongSignumIsNegative") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongSignumIsNegative).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Boolean> testLongSignumIsNegative() {
   return ImmutableSet.of(
-      Long.signum(1L) < 0, Long.signum(2L) <= -1, Long.signum(3L) >= 0, Long.signum(4L) > -1);
+      Long.signum(1L) == -1, Long.signum(2L) == -1, Long.signum(3L) != -1, Long.signum(4L) != -1);
 }

IntegerCompareUnsigned

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerCompareUnsigned") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerCompareUnsigned).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testIntegerCompareUnsigned() {
-  return UnsignedInts.compare(1, 2);
+  return Integer.compareUnsigned(1, 2);
 }

LongCompareUnsigned

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongCompareUnsigned") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongCompareUnsigned).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 long testLongCompareUnsigned() {
-  return UnsignedLongs.compare(1, 2);
+  return Long.compareUnsigned(1, 2);
 }

IntegerDivideUnsigned

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerDivideUnsigned") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerDivideUnsigned).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testIntegerDivideUnsigned() {
-  return UnsignedInts.divide(1, 2);
+  return Integer.divideUnsigned(1, 2);
 }

LongDivideUnsigned

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongDivideUnsigned") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongDivideUnsigned).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 long testLongDivideUnsigned() {
-  return UnsignedLongs.divide(1, 2);
+  return Long.divideUnsigned(1, 2);
 }

IntegerRemainderUnsigned

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerRemainderUnsigned") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerRemainderUnsigned).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testIntegerRemainderUnsigned() {
-  return UnsignedInts.remainder(1, 2);
+  return Integer.remainderUnsigned(1, 2);
 }

LongRemainderUnsigned

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongRemainderUnsigned") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongRemainderUnsigned).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 long testLongRemainderUnsigned() {
-  return UnsignedLongs.remainder(1, 2);
+  return Long.remainderUnsigned(1, 2);
 }

IntegerParseUnsignedInt

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerParseUnsignedInt") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerParseUnsignedInt).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Integer> testIntegerParseUnsignedInt() {
-  return ImmutableSet.of(UnsignedInts.parseUnsignedInt("1"), Integer.parseUnsignedInt("2", 10));
+  return ImmutableSet.of(Integer.parseUnsignedInt("1"), Integer.parseUnsignedInt("2"));
 }

LongParseUnsignedLong

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongParseUnsignedLong") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongParseUnsignedLong).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Long> testLongParseUnsignedLong() {
-  return ImmutableSet.of(UnsignedLongs.parseUnsignedLong("1"), Long.parseUnsignedLong("2", 10));
+  return ImmutableSet.of(Long.parseUnsignedLong("1"), Long.parseUnsignedLong("2"));
 }

IntegerParseUnsignedIntWithRadix

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerParseUnsignedIntWithRadix") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerParseUnsignedIntWithRadix).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 int testIntegerParseUnsignedIntWithRadix() {
-  return UnsignedInts.parseUnsignedInt("1", 2);
+  return Integer.parseUnsignedInt("1", 2);
 }

LongParseUnsignedLongWithRadix

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongParseUnsignedLongWithRadix") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongParseUnsignedLongWithRadix).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 long testLongParseUnsignedLongWithRadix() {
-  return UnsignedLongs.parseUnsignedLong("1", 2);
+  return Long.parseUnsignedLong("1", 2);
 }

IntegerToUnsignedString

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerToUnsignedString") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerToUnsignedString).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<String> testIntegerToUnsignedString() {
-  return ImmutableSet.of(UnsignedInts.toString(1), Integer.toUnsignedString(2, 10));
+  return ImmutableSet.of(Integer.toUnsignedString(1), Integer.toUnsignedString(2));
 }

LongToUnsignedString

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongToUnsignedString") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongToUnsignedString).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<String> testLongToUnsignedString() {
-  return ImmutableSet.of(UnsignedLongs.toString(1), Long.toUnsignedString(2, 10));
+  return ImmutableSet.of(Long.toUnsignedString(1), Long.toUnsignedString(2));
 }

IntegerToUnsignedStringWithRadix

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("IntegerToUnsignedStringWithRadix") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$IntegerToUnsignedStringWithRadix).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 String testIntegerToUnsignedStringWithRadix() {
-  return UnsignedInts.toString(1, 2);
+  return Integer.toUnsignedString(1, 2);
 }

LongToUnsignedStringWithRadix

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("LongToUnsignedStringWithRadix") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$LongToUnsignedStringWithRadix).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 String testLongToUnsignedStringWithRadix() {
-  return UnsignedLongs.toString(1, 2);
+  return Long.toUnsignedString(1, 2);
 }

ArraysCompareUnsignedBytes

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("ArraysCompareUnsignedBytes") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$ArraysCompareUnsignedBytes).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Comparator<byte[]> testArraysCompareUnsignedBytes() {
-  return UnsignedBytes.lexicographicalComparator();
+  return Arrays::compareUnsigned;
 }

ArraysCompareUnsignedInts

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("ArraysCompareUnsignedInts") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$ArraysCompareUnsignedInts).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Comparator<int[]> testArraysCompareUnsignedInts() {
-  return UnsignedInts.lexicographicalComparator();
+  return Arrays::compareUnsigned;
 }

ArraysCompareUnsignedLongs

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("ArraysCompareUnsignedLongs") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!PrimitiveRules\$ArraysCompareUnsignedLongs).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Comparator<long[]> testArraysCompareUnsignedLongs() {
-  return UnsignedLongs.lexicographicalComparator();
+  return Arrays::compareUnsigned;
 }

Copyright © 2017-2025 Picnic Technologies BV