  Line 32) Byte.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 32) ImmutableList.of() ==> com.google.common.collect.ImmutableList.of()
  Line 33) Short.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 33) ImmutableList.of(BYTE) ==> java.util.List.of(E...)
  Line 34) Character.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 34) ImmutableList.of() ==> com.google.common.collect.ImmutableList.of()
  Line 35) Integer.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 35) ImmutableList.of(BYTE, SHORT, CHAR) ==> java.util.List.of(E...)
  Line 36) Long.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 36) ImmutableList.of(BYTE, SHORT, INT, CHAR) ==> java.util.List.of(E...)
  Line 37) Boolean.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 37) ImmutableList.of() ==> com.google.common.collect.ImmutableList.of()
  Line 38) Float.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 38) ImmutableList.of(LONG, INT, SHORT, BYTE, CHAR) ==> java.util.List.of(E...)
  Line 39) Double.class.getCanonicalName() ==> java.lang.Class.getCanonicalName()
  Line 39) ImmutableList.of(FLOAT, LONG, INT, SHORT, BYTE, CHAR) ==> java.util.List.of(E...)
  Line 40) ImmutableList.of(INT, BOOLEAN, LONG, CHAR, FLOAT, DOUBLE, SHORT, BYTE) ==> java.util.List.of(E...)
  Line 57) name.toLowerCase() ==> java.lang.String.toLowerCase()
  Line 59) ptu.describe().equals(name) ==> java.lang.String.equals(java.lang.Object)
  Line 59) ptu.describe() ==> com.github.javaparser.symbolsolver.model.typesystem.PrimitiveType.describe()
  Line 104) other.isPrimitive() ==> com.github.javaparser.symbolsolver.model.typesystem.Type.isPrimitive()
  Line 105) promotionTypes.contains(other) ==> java.util.List.contains(java.lang.Object)
  Line 106) other.isReferenceType() ==> com.github.javaparser.symbolsolver.model.typesystem.Type.isReferenceType()
  Line 107) other.asReferenceType().getQualifiedName().equals(boxTypeQName) ==> java.lang.String.equals(java.lang.Object)
  Line 107) other.asReferenceType().getQualifiedName() ==> com.github.javaparser.symbolsolver.model.typesystem.ReferenceType.getQualifiedName()
  Line 107) other.asReferenceType() ==> com.github.javaparser.symbolsolver.model.typesystem.Type.asReferenceType()
  Line 111) other.asReferenceType().getQualifiedName().equals(promotion.boxTypeQName) ==> java.lang.String.equals(java.lang.Object)
  Line 111) other.asReferenceType().getQualifiedName() ==> com.github.javaparser.symbolsolver.model.typesystem.ReferenceType.getQualifiedName()
  Line 111) other.asReferenceType() ==> com.github.javaparser.symbolsolver.model.typesystem.Type.asReferenceType()
  Line 116) other.isConstraint() ==> com.github.javaparser.symbolsolver.model.typesystem.Type.isConstraint()
  Line 117) this.isAssignableBy(other.asConstraintType().getBound()) ==> com.github.javaparser.symbolsolver.model.typesystem.PrimitiveType.isAssignableBy(com.github.javaparser.symbolsolver.model.typesystem.Type)
  Line 117) other.asConstraintType().getBound() ==> com.github.javaparser.symbolsolver.model.typesystem.LambdaConstraintType.getBound()
  Line 117) other.asConstraintType() ==> com.github.javaparser.symbolsolver.model.typesystem.Type.asConstraintType()
