import com.google.errorprone.VisitorState; //导入依赖的package包/类
private void handleChainFromFilter(
    StreamTypeRecord streamType,
    MethodInvocationTree observableDotFilter,
    Tree filterMethodOrLambda,
    VisitorState state) {
  // Traverse the observable call chain out through any pass-through methods
  MethodInvocationTree outerCallInChain = observableOuterCallInChain.get(observableDotFilter);
  while (outerCallInChain != null
      && streamType.matchesType(ASTHelpers.getReceiverType(outerCallInChain), state)
      && streamType.isPassthroughMethod(ASTHelpers.getSymbol(outerCallInChain))) {
    outerCallInChain = observableOuterCallInChain.get(outerCallInChain);
  }
  // Check for a map method
  MethodInvocationTree mapCallsite = observableOuterCallInChain.get(observableDotFilter);
  if (outerCallInChain != null
      && observableCallToInnerMethodOrLambda.containsKey(outerCallInChain)) {
    // Update mapToFilterMap
    Symbol.MethodSymbol mapMethod = ASTHelpers.getSymbol(outerCallInChain);
    if (streamType.isMapMethod(mapMethod)) {
      MaplikeToFilterInstanceRecord record =
          new MaplikeToFilterInstanceRecord(
              streamType.getMaplikeMethodRecord(mapMethod), filterMethodOrLambda);
      mapToFilterMap.put(observableCallToInnerMethodOrLambda.get(outerCallInChain), record);
    }
  }
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public void onMatchLambdaExpression(
    NullAway analysis,
    LambdaExpressionTree tree,
    VisitorState state,
    Symbol.MethodSymbol methodSymbol) {
  if (filterMethodOrLambdaSet.contains(tree)
      && tree.getBodyKind().equals(LambdaExpressionTree.BodyKind.EXPRESSION)) {
    expressionBodyToFilterLambda.put((ExpressionTree) tree.getBody(), tree);
    // Single expression lambda, onMatchReturn will not be triggered, force the dataflow analysis
    // here
    AccessPathNullnessAnalysis nullnessAnalysis = analysis.getNullnessAnalysis(state);
    nullnessAnalysis.forceRunOnMethod(state.getPath(), state.context);
  }
  if (mapToFilterMap.containsKey(tree)) {
    bodyToMethodOrLambda.put(tree.getBody(), tree);
  }
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public void onMatchReturn(NullAway analysis, ReturnTree tree, VisitorState state) {
  // Figure out the enclosing method node
  TreePath enclosingMethodOrLambda =
      NullabilityUtil.findEnclosingMethodOrLambdaOrInitializer(state.getPath());
  if (enclosingMethodOrLambda == null) {
    throw new RuntimeException("no enclosing method, lambda or initializer!");
  }
  if (!(enclosingMethodOrLambda.getLeaf() instanceof MethodTree
      || enclosingMethodOrLambda.getLeaf() instanceof LambdaExpressionTree)) {
    throw new RuntimeException(
        "return statement outside of a method or lambda! (e.g. in an initializer block)");
  }
  Tree leaf = enclosingMethodOrLambda.getLeaf();
  if (filterMethodOrLambdaSet.contains(leaf)) {
    returnToEnclosingMethodOrLambda.put(tree, leaf);
    // We need to manually trigger the dataflow analysis to run on the filter method,
    // this ensures onDataflowVisitReturn(...) gets called for all return statements in this
    // method before
    // onDataflowInitialStore(...) is called for all successor methods in the observable chain.
    // Caching should prevent us from re-analyzing any given method.
    AccessPathNullnessAnalysis nullnessAnalysis = analysis.getNullnessAnalysis(state);
    nullnessAnalysis.forceRunOnMethod(new TreePath(state.getPath(), leaf), state.context);
  }
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public Description matchNewClass(NewClassTree tree, VisitorState state) {
  if (!matchWithinClass) {
    return Description.NO_MATCH;
  }
  Symbol.MethodSymbol methodSymbol = ASTHelpers.getSymbol(tree);
  if (methodSymbol == null) {
    throw new RuntimeException("not expecting unresolved method here");
  }
  List<? extends ExpressionTree> actualParams = tree.getArguments();
  if (tree.getClassBody() != null && actualParams.size() > 0) {
    // passing parameters to constructor of anonymous class
    // this constructor just invokes the constructor of the superclass, and
    // in the AST does not have the parameter nullability annotations from the superclass.
    // so, treat as if the superclass constructor is being invoked directly
    // see https://github.com/uber/NullAway/issues/102
    Type supertype = state.getTypes().supertype(methodSymbol.owner.type);
    Symbol.MethodSymbol superConstructor =
        findSuperConstructorInType(methodSymbol, supertype, state.getTypes());
    if (superConstructor == null) {
      throw new RuntimeException("must find constructor in supertype");
    }
    methodSymbol = superConstructor;
  }
  return handleInvocation(state, methodSymbol, actualParams);
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
  if (!matchWithinClass) {
    return Description.NO_MATCH;
  }
  Symbol symbol = ASTHelpers.getSymbol(tree);
  // some checks for cases where we know it is not
  // a null dereference
  if (symbol == null || symbol.getSimpleName().toString().equals("class") || symbol.isEnum()) {
    return Description.NO_MATCH;
  }

  Description badDeref = matchDereference(tree.getExpression(), tree, state);
  if (!badDeref.equals(Description.NO_MATCH)) {
    return badDeref;
  }
  // if we're accessing a field of this, make sure we're not reading the field before init
  if (tree.getExpression() instanceof IdentifierTree
      && ((IdentifierTree) tree.getExpression()).getName().toString().equals("this")) {
    return checkForReadBeforeInit(tree, state);
  }
  return Description.NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
private Description checkReturnExpression(
    Tree tree, ExpressionTree retExpr, Symbol.MethodSymbol methodSymbol, VisitorState state) {
  Type returnType = methodSymbol.getReturnType();
  if (returnType.isPrimitive()) {
    // check for unboxing
    return doUnboxingCheck(state, retExpr);
  }
  if (returnType.toString().equals("java.lang.Void")) {
    return Description.NO_MATCH;
  }
  if (NullabilityUtil.fromUnannotatedPackage(methodSymbol, config)
      || Nullness.hasNullableAnnotation(methodSymbol)) {
    return Description.NO_MATCH;
  }
  if (mayBeNullExpr(state, retExpr)) {
    String message = "returning @Nullable expression from method with @NonNull return type";
    return createErrorDescriptionForNullAssignment(
        MessageTypes.RETURN_NULLABLE, tree, message, retExpr, state.getPath());
  }
  return Description.NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public Description matchLambdaExpression(LambdaExpressionTree tree, VisitorState state) {
  Symbol.MethodSymbol methodSymbol =
      NullabilityUtil.getFunctionalInterfaceMethod(tree, state.getTypes());
  handler.onMatchLambdaExpression(this, tree, state, methodSymbol);
  Description description = checkParamOverriding(tree, tree.getParameters(), methodSymbol, true);
  if (description != Description.NO_MATCH) {
    return description;
  }
  if (tree.getBodyKind() == LambdaExpressionTree.BodyKind.EXPRESSION
      && methodSymbol.getReturnType().getKind() != TypeKind.VOID) {
    ExpressionTree resExpr = (ExpressionTree) tree.getBody();
    return checkReturnExpression(tree, resExpr, methodSymbol, state);
  }
  return Description.NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
private boolean relevantInitializerMethodOrBlock(
    TreePath enclosingBlockPath, VisitorState state) {
  Tree methodLambdaOrBlock = enclosingBlockPath.getLeaf();
  if (methodLambdaOrBlock instanceof LambdaExpressionTree) {
    return false;
  } else if (methodLambdaOrBlock instanceof MethodTree) {
    MethodTree methodTree = (MethodTree) methodLambdaOrBlock;
    if (isConstructor(methodTree) && !constructorInvokesAnother(methodTree, state)) return true;
    if (ASTHelpers.getSymbol(methodTree).isStatic()) {
      Set<MethodTree> staticInitializerMethods =
          class2Entities.get(enclosingClassSymbol(enclosingBlockPath)).staticInitializerMethods();
      return staticInitializerMethods.size() == 1
          && staticInitializerMethods.contains(methodTree);
    } else {
      Set<MethodTree> instanceInitializerMethods =
          class2Entities
              .get(enclosingClassSymbol(enclosingBlockPath))
              .instanceInitializerMethods();
      return instanceInitializerMethods.size() == 1
          && instanceInitializerMethods.contains(methodTree);
    }
  } else {
    // initializer or field declaration
    return true;
  }
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
private Description checkPossibleUninitFieldRead(
    ExpressionTree tree,
    VisitorState state,
    Symbol symbol,
    TreePath path,
    TreePath enclosingBlockPath) {
  if (!fieldInitializedByPreviousInitializer(symbol, enclosingBlockPath, state)
      && !fieldAlwaysInitializedBeforeRead(symbol, path, state, enclosingBlockPath)) {
    return createErrorDescription(
        MessageTypes.NONNULL_FIELD_READ_BEFORE_INIT,
        tree,
        "read of @NonNull field " + symbol + " before initialization",
        path);
  } else {
    return Description.NO_MATCH;
  }
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public Description matchBinary(BinaryTree tree, VisitorState state) {
  ExpressionTree leftOperand = tree.getLeftOperand();
  ExpressionTree rightOperand = tree.getRightOperand();
  Type leftType = ASTHelpers.getType(leftOperand);
  Type rightType = ASTHelpers.getType(rightOperand);
  if (leftType == null || rightType == null) {
    throw new RuntimeException();
  }
  if (leftType.isPrimitive() && !rightType.isPrimitive()) {
    return doUnboxingCheck(state, rightOperand);
  }
  if (rightType.isPrimitive() && !leftType.isPrimitive()) {
    return doUnboxingCheck(state, leftOperand);
  }
  return Description.NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
/**
 * if any expression has non-primitive type, we should check that it can't be null as it is
 * getting unboxed
 *
 * @param expressions expressions to check
 * @return error Description if an error is found, otherwise NO_MATCH
 */
private Description doUnboxingCheck(VisitorState state, ExpressionTree... expressions) {
  for (ExpressionTree tree : expressions) {
    Type type = ASTHelpers.getType(tree);
    if (type == null) {
      throw new RuntimeException("was not expecting null type");
    }
    if (!type.isPrimitive()) {
      if (mayBeNullExpr(state, tree)) {
        return createErrorDescription(
            MessageTypes.UNBOX_NULLABLE, tree, "unboxing of a @Nullable value", state.getPath());
      }
    }
  }
  return Description.NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
/**
 * @param entities field init info
 * @param state visitor state
 * @return a map from each constructor C to the nonnull fields that C does *not* initialize
 */
private SetMultimap<MethodTree, Symbol> checkConstructorInitialization(
    FieldInitEntities entities, VisitorState state) {
  SetMultimap<MethodTree, Symbol> result = LinkedHashMultimap.create();
  Set<Symbol> nonnullInstanceFields = entities.nonnullInstanceFields();
  Trees trees = Trees.instance(JavacProcessingEnvironment.instance(state.context));
  for (MethodTree constructor : entities.constructors()) {
    if (constructorInvokesAnother(constructor, state)) {
      continue;
    }
    Set<Element> guaranteedNonNull =
        guaranteedNonNullForConstructor(entities, state, trees, constructor);
    for (Symbol fieldSymbol : nonnullInstanceFields) {
      if (!guaranteedNonNull.contains(fieldSymbol)) {
        result.put(constructor, fieldSymbol);
      }
    }
  }
  return result;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
private void addGuaranteedNonNullFromInvokes(
    VisitorState state,
    Trees trees,
    Set<Element> safeInitMethods,
    AccessPathNullnessAnalysis nullnessAnalysis,
    Set<Element> guaranteedNonNull) {
  for (Element invoked : safeInitMethods) {
    Tree invokedTree = trees.getTree(invoked);
    guaranteedNonNull.addAll(
        nullnessAnalysis.getNonnullFieldsOfReceiverAtExit(
            new TreePath(state.getPath(), invokedTree), state.context));
  }
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
private boolean isInitializerMethod(VisitorState state, Symbol.MethodSymbol symbol) {
  if (ASTHelpers.hasDirectAnnotationWithSimpleName(symbol, "Initializer")
      || config.isKnownInitializerMethod(symbol)) {
    return true;
  }
  for (AnnotationMirror anno : symbol.getAnnotationMirrors()) {
    String annoTypeStr = anno.getAnnotationType().toString();
    if (config.isInitializerMethodAnnotation(annoTypeStr)) {
      return true;
    }
  }
  Symbol.MethodSymbol closestOverriddenMethod =
      getClosestOverriddenMethod(symbol, state.getTypes());
  if (closestOverriddenMethod == null) {
    return false;
  }
  return isInitializerMethod(state, closestOverriddenMethod);
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
private boolean isExcludedClass(Symbol.ClassSymbol classSymbol, VisitorState state) {
  String className = classSymbol.getQualifiedName().toString();
  if (config.isExcludedClass(className)) {
    return true;
  }
  if (!config.fromAnnotatedPackage(className)) {
    return true;
  }
  // check annotations
  for (AnnotationMirror anno : classSymbol.getAnnotationMirrors()) {
    if (config.isExcludedClassAnnotation(anno.getAnnotationType().toString())) {
      return true;
    }
  }
  return false;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
private Description matchDereference(
    ExpressionTree baseExpression, ExpressionTree derefExpression, VisitorState state) {
  Symbol dereferenced = ASTHelpers.getSymbol(baseExpression);
  if (dereferenced == null
      || dereferenced.type.isPrimitive()
      || !kindMayDeferenceNull(dereferenced.getKind())) {
    // we know we don't have a null dereference here
    return Description.NO_MATCH;
  }
  if (mayBeNullExpr(state, baseExpression)) {
    String message = "dereferenced expression " + baseExpression.toString() + " is @Nullable";
    return createErrorDescriptionForNullAssignment(
        MessageTypes.DEREFERENCE_NULLABLE,
        derefExpression,
        message,
        baseExpression,
        state.getPath());
  }
  return Description.NO_MATCH;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public boolean matches(ExpressionTree tree, VisitorState state) {
  if (!(tree instanceof MethodInvocationTree)) {
    return false;
  }
  MethodInvocationTree invTree = (MethodInvocationTree) tree;

  final MemberSelectTree memberTree = (MemberSelectTree) invTree.getMethodSelect();
  if (!memberTree.getIdentifier().contentEquals(TO)) {
    return false;
  }

  for (MethodMatchers.MethodNameMatcher nameMatcher : METHOD_NAME_MATCHERS) {
    if (nameMatcher.matches(invTree, state)) {
      ExpressionTree arg = invTree.getArguments().get(0);
      final Type scoper = state.getTypeFromString("com.uber.autodispose.Scoper");
      return ASTHelpers.isSubtype(ASTHelpers.getType(arg), scoper, state);
    }
  }
  return false;
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
@Override
public Description matchReturn(ReturnTree tree, VisitorState state) {
  if (tree.getExpression() == null) {
    return NO_MATCH;
  }
  Type type = null;
  outer:
  for (Tree parent : state.getPath()) {
    switch (parent.getKind()) {
      case METHOD:
        type = ASTHelpers.getType(((MethodTree) parent).getReturnType());
        break outer;
      case LAMBDA_EXPRESSION:
        type = state.getTypes().findDescriptorType(ASTHelpers.getType(parent)).getReturnType();
        break outer;
      default: // fall out
    }
  }
  if (type == null) {
    return NO_MATCH;
  }
  return check(type, tree.getExpression());
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
/** Deletes an entry and its delimiter from a list. */
private static void removeFromList(
    SuggestedFix.Builder fix, VisitorState state, List<? extends Tree> arguments, Tree tree) {
  int idx = arguments.indexOf(tree);
  if (idx == arguments.size() - 1) {
    fix.replace(
        state.getEndPosition(arguments.get(arguments.size() - 1)),
        state.getEndPosition(tree),
        "");
  } else {
    fix.replace(
        ((JCTree) tree).getStartPosition(),
        ((JCTree) arguments.get(idx + 1)).getStartPosition(),
        "");
  }
}
 

import com.google.errorprone.VisitorState; //导入依赖的package包/类
/**
 * Recognize a small set of known-immutable types that are safe for DCL even without a volatile
 * field.
 */
private static boolean isImmutable(Type type, VisitorState state) {
  switch (type.getKind()) {
    case BOOLEAN:
    case BYTE:
    case SHORT:
    case INT:
    case CHAR:
    case FLOAT:
      return true;
    case LONG:
    case DOUBLE:
      // double-width primitives aren't written atomically
      return true;
    default:
      break;
  }
  return IMMUTABLE_WHITELIST.contains(
      state.getTypes().erasure(type).tsym.getQualifiedName().toString());
}