Java Immutable类代码示例

import com.google.errorprone.annotations.Immutable; //导入依赖的package包/类
/** Check for classes without {@code @Immutable} that have immutable supertypes. */
private Description checkSubtype(ClassTree tree, VisitorState state) {
  ClassSymbol sym = ASTHelpers.getSymbol(tree);
  if (sym == null) {
    return NO_MATCH;
  }
  Type superType = immutableSupertype(sym, state);
  if (superType == null) {
    return NO_MATCH;
  }
  String message =
      String.format(
          "Class extends @Immutable type %s, but is not annotated as immutable", superType);
  Fix fix =
      SuggestedFix.builder()
          .prefixWith(tree, "@Immutable ")
          .addImport(Immutable.class.getName())
          .build();
  return buildDescription(tree).setMessage(message).addFix(fix).build();
}
 

import com.google.errorprone.annotations.Immutable; //导入依赖的package包/类
/**
 * Returns the type of the first superclass or superinterface in the hierarchy annotated with
 * {@code @Immutable}, or {@code null} if no such super type exists.
 */
private static Type immutableSupertype(Symbol sym, VisitorState state) {
  for (Type superType : state.getTypes().closure(sym.type)) {
    if (superType.equals(sym.type)) {
      continue;
    }
    // Don't use getImmutableAnnotation here: subtypes of trusted types are
    // also trusted, only check for explicitly annotated supertypes.
    if (ASTHelpers.hasAnnotation(superType.tsym, Immutable.class, state)) {
      return superType;
    }
    // We currently trust that @interface annotations are immutable, but don't enforce that
    // custom interface implementations are also immutable. That means the check can be
    // defeated by writing a custom mutable annotation implementation, and passing it around
    // using the superclass type.
    //
    // TODO(b/25630189): fix this
    //
    // if (superType.tsym.getKind() == ElementKind.ANNOTATION_TYPE) {
    //   return superType;
    // }
  }
  return null;
}
 

import com.google.errorprone.annotations.Immutable; //导入依赖的package包/类
@Override
public Description matchClass(ClassTree tree, VisitorState state) {
  ClassSymbol symbol = getSymbol(tree);
  if (symbol == null || !symbol.isEnum()) {
    return NO_MATCH;
  }

  if (ASTHelpers.hasAnnotation(symbol, Immutable.class, state)
      && !implementsImmutableInterface(symbol)) {
    AnnotationTree annotation =
        ASTHelpers.getAnnotationWithSimpleName(tree.getModifiers().getAnnotations(), "Immutable");
    if (annotation != null) {
      state.reportMatch(
          buildDescription(annotation)
              .setMessage(ANNOTATED_ENUM_MESSAGE)
              .addFix(SuggestedFix.delete(annotation))
              .build());
    } else {
      state.reportMatch(buildDescription(tree).setMessage(ANNOTATED_ENUM_MESSAGE).build());
    }
  }

  Violation info =
      new ImmutableAnalysis(
              this,
              state,
              wellKnownMutability,
              ImmutableSet.of(
                  Immutable.class.getName(),
                  javax.annotation.concurrent.Immutable.class.getName()))
          .checkForImmutability(
              Optional.of(tree), ImmutableSet.of(), getType(tree), this::describe);

  if (!info.isPresent()) {
    return NO_MATCH;
  }

  return describe(tree, info).build();
}
 

import com.google.errorprone.annotations.Immutable; //导入依赖的package包/类
ImmutableAnalysis(
    BugChecker bugChecker, VisitorState state, WellKnownMutability wellKnownMutability) {
  this(
      bugChecker,
      state,
      wellKnownMutability,
      ImmutableSet.of(Immutable.class.getName()));
}
 

import com.google.errorprone.annotations.Immutable; //导入依赖的package包/类
private static boolean implementsImmutableInterface(ClassSymbol symbol) {
  return Streams.concat(symbol.getInterfaces().stream(), Stream.of(symbol.getSuperclass()))
      .anyMatch(supertype -> supertype.asElement().getAnnotation(Immutable.class) != null);
}
 

import com.google.errorprone.annotations.Immutable; //导入依赖的package包/类
@Override
public Description matchClass(ClassTree tree, VisitorState state) {
  ClassSymbol symbol = getSymbol(tree);
  if (symbol == null
      || symbol.isAnnotationType()
      || !WellKnownMutability.isAnnotation(state, symbol.type)) {
    return NO_MATCH;
  }
  if (!Collections.disjoint(getGeneratedBy(symbol, state), PROCESSOR_BLACKLIST)) {
    return NO_MATCH;
  }

  if (ASTHelpers.hasAnnotation(symbol, Immutable.class, state)) {
    AnnotationTree annotation =
        ASTHelpers.getAnnotationWithSimpleName(tree.getModifiers().getAnnotations(), "Immutable");
    if (annotation != null) {
      state.reportMatch(
          buildDescription(annotation)
              .setMessage(ANNOTATED_ANNOTATION_MESSAGE)
              .addFix(SuggestedFix.delete(annotation))
              .build());
    } else {
      state.reportMatch(buildDescription(tree).setMessage(ANNOTATED_ANNOTATION_MESSAGE).build());
    }
  }

  Violation info =
      new ImmutableAnalysis(
              this,
              state,
              wellKnownMutability,
              ImmutableSet.of(
                  Immutable.class.getName(),
                  javax.annotation.concurrent.Immutable.class.getName()))
          .checkForImmutability(
              Optional.of(tree), ImmutableSet.of(), getType(tree), this::describeClass);

  if (!info.isPresent()) {
    return NO_MATCH;
  }
  return describeClass(tree, info).build();
}