PrimitiveRules

SUGGESTION

Simplification

View source code on GitHub

Suppression

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

Table of contents

LessThan
LessThanOrEqualTo
GreaterThan
GreaterThanOrEqualTo
LongToIntExact
BooleanHashCode
ByteHashCode
CharacterHashCode
ShortHashCode
IntegerHashCode
LongHashCode
FloatHashCode
DoubleHashCode
CharacterBytes
ShortBytes
IntegerBytes
LongBytes
FloatBytes
DoubleBytes
FloatIsFinite
DoubleIsFinite
IntegerSignumIsPositive
IntegerSignumIsNegative
LongSignumIsPositive
LongSignumIsNegative
IntegerCompareUnsigned
LongCompareUnsigned
IntegerDivideUnsigned
LongDivideUnsigned
IntegerRemainderUnsigned
LongRemainderUnsigned
IntegerParseUnsignedInt
LongParseUnsignedLong
IntegerParseUnsignedIntWithRadix
LongParseUnsignedLongWithRadix
IntegerToUnsignedString
LongToUnsignedString
IntegerToUnsignedStringWithRadix
LongToUnsignedStringWithRadix
ArraysCompareUnsignedBytes
ArraysCompareUnsignedInts
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);
 }

BooleanHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testBooleanHashCode() {
-  return Booleans.hashCode(true);
+  return Boolean.hashCode(true);
 }

ByteHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testByteHashCode() {
-  return Bytes.hashCode((byte) 1);
+  return Byte.hashCode((byte) 1);
 }

CharacterHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testCharacterHashCode() {
-  return Chars.hashCode('a');
+  return Character.hashCode('a');
 }

ShortHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testShortHashCode() {
-  return Shorts.hashCode((short) 1);
+  return Short.hashCode((short) 1);
 }

IntegerHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testIntegerHashCode() {
-  return Ints.hashCode(1);
+  return Integer.hashCode(1);
 }

LongHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testLongHashCode() {
-  return Longs.hashCode(1);
+  return Long.hashCode(1);
 }

FloatHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testFloatHashCode() {
-  return Floats.hashCode(1);
+  return Float.hashCode(1);
 }

DoubleHashCode

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 int testDoubleHashCode() {
-  return Doubles.hashCode(1);
+  return Double.hashCode(1);
 }

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;
 }

FloatIsFinite

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 boolean testFloatIsFinite() {
-  return Floats.isFinite(1);
+  return Float.isFinite(1);
 }

DoubleIsFinite

SUGGESTION

Simplification

Suppression

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

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

Samples

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

 boolean testDoubleIsFinite() {
-  return Doubles.isFinite(1);
+  return Double.isFinite(1);
 }

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;
 }