temporarily disable the nullable derereference analysis

reusablecfg/src/main/jastadd/NullableDereferenceAnalysis.jrag

-/**
- * Copyright 2015 Google Inc. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Adds an analysis that checks for dereferences of a parameter declared nullable.
- *
- * <p>When a method or constructor parameter is annotated with javax.annotation.Nullable,
- * we check that all dereferences of that parameter are guarded by a null-check. The
- * analysis is control-flow sensitive in that it will recognize if all control flow paths
- * to the dereference are effectively guarded by a null check, for example: {@code
- * if (p == null) return;
- * p.x(); // Guarded by null check above.
- * }
- *
- * <p>The analysis is not intraprocedural, so in order to avoid false positives
- * where a method call guards against nullness the analyzer assumes that
- * calling a method with an argument x results in an exception if x is null and
- * thus works like an effective null guard for x.
- *
- * <p>To find potential null dereferences on nullable parameters, the analysis does a forward CFG
- * traversal from the entry-point of the method. Note that this is only done whenever a
- * {@code @Nullable} parameter has been encountered in the method. The traversal explores all paths
- * from the method entry until it finds null guard statements such as {@code if (p != null)}. The
- * branches that are protected from nullness get pruned in the search and the search continues on
- * other branches. The search is performed by a {@code NullDereferenceLocator}, which implements the
- * {@code CfgSearch} interface. This visitor is invoked for each node in the CFG search, and it
- * decides if the search will continue from that node, or if the current edge should be skipped
- * (i.e., pruned).
- *
- * <p>In order to find the position in the CFG where a potential null dereference occurs, CFG marker
- * nodes are inserted. This is done by adding a synthesized non-terminal attribute (NTA) for
- * a CfgMarker on Dot (which represents Java dot expressions). This marker node appears
- * in the CFG as "nullable access" because it is inserted whenever a nullable variable is
- * dereferenced.
- *
- * <p>Dataflow analysis is not used, so in order to analyze a parameter it is required to be
- * effectively final, i.e. it is not assigned anywhere in side the body of the method/constructor.
- */
-aspect NullableDereferenceAnalysis {
-
-  // Give ParameterDeclaration access to the inherited compilationUnit attribute.
-  inh CompilationUnit ParameterDeclaration.compilationUnit();
-
-  ParameterDeclaration contributes nullableDereferenceFinding()
-      when nullableDereferenceFinding() != null
-      to CompilationUnit.findings()
-      for compilationUnit();
-
-  /**
-   * Generate a NullableDereference finding for this dot expression,
-   * if no finding should be reported this attribute returns {@code null}.
-   */
-  syn lazy ExtendJFinding ParameterDeclaration.nullableDereferenceFinding() {
-    if (!getModifiers().hasNullableAnnotation()) {
-      return null;
-    }
-    if (!isFinal() && !isEffectivelyFinal()) {
-      // Do not analyze non-effectively final parameters.
-      return null;
-    }
-    Expr location = findNullableDereference(this);
-    if (location == null) {
-      return null;
-    }
-    ExtendJFinding finding = location.finding("NullableDereference", String.format(
-        "Dereferencing %s, which was declared @Nullable.", name()));
-    if (compilationUnit().fromSource()) {
-      ASTNode modifierLocation = nullableModifierLocation();
-      int line = getLine(modifierLocation.getStart());
-      int startCol = getColumn(modifierLocation.getStart());
-      int endCol = getColumn(modifierLocation.getEnd());
-      if (startCol < endCol && line == getLine(modifierLocation.getEnd())) {
-        try {
-          InputStream data = compilationUnit().getClassSource().openInputStream();
-          java.util.Scanner scanner = new java.util.Scanner(data);
-          for (int i = 1; i < line && scanner.hasNextLine(); ++i) {
-            scanner.nextLine();
-          }
-          if (scanner.hasNextLine()) {
-            String text = scanner.nextLine();
-            finding.addFix("Remove the @Nullable annotation.",
-                line, line,
-                text.substring(0,startCol-1) + text.substring(endCol+1) + "\n");
-          }
-        } catch (IOException e) {
-          // Failed to unparse the current line.
-          // This is not a serious problem; we just don't give a fix suggestion.
-        }
-      }
-    }
-    return finding;
-  }
-
-  // Exclude variable arity parameters from Nullable dereference analysis.
-  // When a variable arity parameter is annotated @Nullable, that will most likely be intended as a
-  // @Nullable annotation for the individual parameters, not the containing argument array.
-  eq VariableArityParameterDeclaration.nullableDereferenceFinding() = null;
-
-  /**
-   * Find the location node for the javax.annotation.Nullable annotation in the modifier list.
-   * Returns {@code null} if the location of the modifier was not found.
-   */
-  syn ASTNode ParameterDeclaration.nullableModifierLocation() =
-      getModifiers().nullableModifierLocation();
-
-  syn ASTNode Modifiers.nullableModifierLocation() {
-    for (Modifier modifier : getModifierList()) {
-      if (modifier.isAnnotation("javax.annotation", "Nullable")) {
-        return modifier.locationNode();
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Find a location, not necessarily the first location, in the host method/constructor where the
-   * parameter is accessed without a null guard.
-   */
-  inh Expr ParameterDeclaration.findNullableDereference(Variable var);
-
-  eq Program.getChild().findNullableDereference(Variable var) = null;
-  eq BodyDecl.getChild().findNullableDereference(Variable var) = null;
-
-  eq MethodDecl.getParameter().findNullableDereference(Variable var) {
-    if (!hasBlock()) {
-      return null;
-    }
-    CfgNode cfgNode = entry().bfs(new NullDereferenceLocator(var));
-    return cfgNode == null ? null : cfgNode.receiverExpr();
-  }
-
-  eq ConstructorDecl.getParameter().findNullableDereference(Variable var) {
-    CfgNode cfgNode = entry().bfs(new NullDereferenceLocator(var));
-    return cfgNode == null ? null : cfgNode.receiverExpr();
-  }
-
-  /**
-   * A CFG visitor that searches in the forward CFG for a nullable dereference.
-   *
-   * <p>The search stops at parts of the search tree guarded by a null check
-   * on the receiver variable.
-   */
-  class NullDereferenceLocator implements CfgVisitor {
-    private final Variable var;
-
-    public NullDereferenceLocator(Variable var) {
-      this.var = var;
-    }
-
-    @Override public SearchAction processEdge(CfgNode pred, CfgNode succ) {
-      if (pred.isNullGuard(var, succ)) {
-        return SearchAction.SKIP;
-      }
-      Expr receiver = succ.receiverExpr();
-      if (receiver != null && receiver.isVariable(var) && !receiver.hasNullGuard(var)) {
-        return SearchAction.SUCCESSOR_MATCH;
-      }
-      return SearchAction.CONTINUE;
-    }
-  }
-
-  /**
-   * Returns the receiver expression if the CFG node is the child of a dereference expression.
-   * Returns {@code null} otherwise.
-   */
-  inh Expr CfgNode.receiverExpr();
-  eq Program.getChild().receiverExpr() = null;
-  eq BodyDecl.getChild().receiverExpr() = null;
-  eq BodyDecl.exit().receiverExpr() = null;
-  eq TryStmt.tryEntryMarker().receiverExpr() = null;
-  eq BreakStmt.marker().receiverExpr() = null;
-  eq ContinueStmt.marker().receiverExpr() = null;
-  eq ReturnStmt.marker().receiverExpr() = null;
-  eq MethodAccess.exceptionNode().receiverExpr() = null;
-  eq MethodAccess.call().receiverExpr() =
-      hasPrevExpr()
-      ? prevExpr()
-      : null;
-  eq ThrowStmt.exceptionNode().receiverExpr() = null;
-  eq TryStmt.exceptionNode().receiverExpr() = null;
-  eq ConditionalExpr.branch().receiverExpr() = null;
-  eq ConditionalExpr.thenEndMarker().receiverExpr() = null;
-  eq ConditionalExpr.elseEndMarker().receiverExpr() = null;
-  eq IfStmt.branch().receiverExpr() = null;
-  eq IfStmt.thenEndMarker().receiverExpr() = null;
-  eq IfStmt.elseEndMarker().receiverExpr() = null;
-  eq ForStmt.branch().receiverExpr() = null;
-  eq EnhancedForStmt.branch().receiverExpr() = null;
-  eq WhileStmt.branch().receiverExpr() = null;
-  eq DoStmt.branch().receiverExpr() = null;
-  eq SwitchStmt.branch().receiverExpr() = null;
-  eq LambdaBody.exit().receiverExpr() = null;
-  eq Dot.nullableDereferenceMarker().receiverExpr() = getLeft();
-
-  /** Marker node used to find location of a nullable dereference in the CFG.  */
-  syn nta CfgMarker Dot.nullableDereferenceMarker() = new CfgMarker();
-
-  /** Insert nullable dereference marker in the CFG.  */
-  refine SimpleCFG
-  eq Dot.getLeft().follow() =
-      getRight().isMethodAccess()
-      ? refined()
-      : nullableDereferenceMarker();
-
-  eq Dot.nullableDereferenceMarker().succ() = Collections.singleton(getRight().entry());
-
-  syn boolean CfgNode.isNullGuard(Variable var, CfgNode succ) = false;
-
-  /**
-   * We assume that calling a method with the variable var as an argument
-   * results in an exception thrown by the method call if var is null. This is
-   * not true for many methods, but it should reduce the false positive rate
-   * for the NullableDereference analyzer.
-   */
-  eq CfgMethodCall.isNullGuard(Variable var, CfgNode succ) {
-    if (succ instanceof CfgException) {
-      return false;
-    }
-    MethodAccess access = methodAccess();
-    for (Expr arg : access.getArgList()) {
-      if (arg.isVariable(var)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /** Check if this branch has a null-guarding condition.  */
-  eq CfgBranch.isNullGuard(Variable var, CfgNode succ) = inNullGuard(var, succ);
-
-  inh boolean CfgBranch.inNullGuard(Variable var, CfgNode succ);
-
-  eq IfStmt.branch().inNullGuard(Variable var, CfgNode succ) =
-      succ == getThen().entry()
-      ? getCondition().isNonNullWhenTrue(var)
-      : getCondition().isNonNullWhenFalse(var);
-
-  eq ConditionalExpr.branch().inNullGuard(Variable var, CfgNode succ) =
-      succ == getTrueExpr().entry()
-      ? getCondition().isNonNullWhenTrue(var)
-      : getCondition().isNonNullWhenFalse(var);
-
-  eq ForStmt.branch().inNullGuard(Variable var, CfgNode succ) =
-      succ == getStmt().entry()
-      ? getCondition().isNonNullWhenTrue(var)
-      : getCondition().isNonNullWhenFalse(var);
-
-  eq WhileStmt.branch().inNullGuard(Variable var, CfgNode succ) =
-      succ == getStmt().entry()
-      ? getCondition().isNonNullWhenTrue(var)
-      : getCondition().isNonNullWhenFalse(var);
-
-  eq EnhancedForStmt.branch().inNullGuard(Variable var, CfgNode succ) = false;
-  eq DoStmt.branch().inNullGuard(Variable var, CfgNode succ) = false;
-  eq SwitchStmt.branch().inNullGuard(Variable var, CfgNode succ) = false;
-
-  /** Returns {@code true} if this set of modifiers includes {@code javax.annotation.Nullable}.  */
-  syn boolean Modifiers.hasNullableAnnotation() = hasAnnotation("javax.annotation", "Nullable");
-
-  /** Return {@code true} if this expression is guarded by a != null check for var.  */
-  inh boolean Expr.hasNullGuard(Variable var);
-  eq Program.getChild().hasNullGuard(Variable var) = false;
-  eq IfStmt.getThen().hasNullGuard(Variable var) = getCondition().isNonNullWhenTrue(var);
-  eq IfStmt.getElse().hasNullGuard(Variable var) = getCondition().isNonNullWhenFalse(var);
-  eq WhileStmt.getStmt().hasNullGuard(Variable var) = getCondition().isNonNullWhenTrue(var);
-  eq ForStmt.getStmt().hasNullGuard(Variable var) = getCondition().isNonNullWhenTrue(var);
-  eq ConditionalExpr.getTrueExpr().hasNullGuard(Variable var) =
-      getCondition().isNonNullWhenTrue(var) || hasNullGuard(var);
-  eq ConditionalExpr.getFalseExpr().hasNullGuard(Variable var) =
-      getCondition().isNonNullWhenFalse(var) || hasNullGuard(var);
-  eq AndLogicalExpr.getRightOperand().hasNullGuard(Variable var) =
-      getLeftOperand().isNonNullWhenTrue(var) || hasNullGuard(var);
-  eq AndBitwiseExpr.getRightOperand().hasNullGuard(Variable var) =
-      getLeftOperand().isNonNullWhenTrue(var) || hasNullGuard(var);
-  eq OrLogicalExpr.getRightOperand().hasNullGuard(Variable var) =
-      getLeftOperand().isNonNullWhenFalse(var) || hasNullGuard(var);
-
-  /** @return {@code true} if the variable var is null when this expression is true. */
-  syn boolean Expr.isNullWhenTrue(Variable var) = false;
-
-  eq NEExpr.isNullWhenTrue(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNullWhenTrue(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNullWhenTrue(var);
-
-  eq EQExpr.isNullWhenTrue(Variable var) =
-      getLeftOperand().isNull() && getRightOperand().varDecl() == var
-      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
-      || getLeftOperand().isTrue() && getRightOperand().isNullWhenTrue(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNullWhenTrue(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNullWhenFalse(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNullWhenFalse(var);
-
-  eq LogNotExpr.isNullWhenTrue(Variable var) = getOperand().isNullWhenFalse(var);
-
-  eq ParExpr.isNullWhenTrue(Variable var) = getExpr().isNullWhenTrue(var);
-
-  eq AndLogicalExpr.isNullWhenTrue(Variable var) =
-      getLeftOperand().isNullWhenTrue(var) || getRightOperand().isNullWhenTrue(var);
-
-  eq AndBitwiseExpr.isNullWhenTrue(Variable var) =
-      getLeftOperand().isNullWhenTrue(var) || getRightOperand().isNullWhenTrue(var);
-
-  eq OrLogicalExpr.isNullWhenTrue(Variable var) =
-      getLeftOperand().isFalse() && getRightOperand().isNullWhenTrue(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNullWhenTrue(var);
-
-  eq Dot.isNullWhenTrue(Variable var) =
-      !getLeft().isVariable(var) && getRight().isNullWhenTrue(var);
-
-  // Assume that a method call to X.isNull_(var) is equivalent to a null test on var.
-  eq MethodAccess.isNullWhenTrue(Variable var) =
-      name().startsWith("isNull") && getNumArg() == 1 && getArg(0).isVariable(var);
-
-  eq VarAccess.isNullWhenTrue(Variable var) = decl().isNullWhenTrue(var);
-
-  syn boolean Variable.isNullWhenTrue(Variable var);
-  eq EnumConstant.isNullWhenTrue(Variable var) = false;
-  eq ParameterDeclaration.isNullWhenTrue(Variable var) = false;
-  eq FieldDeclarator.isNullWhenTrue(Variable var) = false;
-  eq CatchParameterDeclaration.isNullWhenTrue(Variable var) = false;
-  eq InferredParameterDeclaration.isNullWhenTrue(Variable var) = false;
-  eq VariableDeclarator.isNullWhenTrue(Variable var) =
-      type().isBoolean() && hasInit() && isEffectivelyFinal()
-      ? getInit().isNullWhenTrue(var)
-      : false;
-
-  /** @return {@code true} if the variable var is null when this expression is false. */
-  syn boolean Expr.isNullWhenFalse(Variable var) = false;
-
-  eq NEExpr.isNullWhenFalse(Variable var) =
-      getLeftOperand().isNull() && getRightOperand().varDecl() == var
-      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
-      || getLeftOperand().isTrue() && getRightOperand().isNullWhenTrue(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNullWhenTrue(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNullWhenFalse(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNullWhenFalse(var);
-
-  eq EQExpr.isNullWhenFalse(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNullWhenTrue(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNullWhenTrue(var);
-
-  eq LogNotExpr.isNullWhenFalse(Variable var) = getOperand().isNullWhenTrue(var);
-
-  eq ParExpr.isNullWhenFalse(Variable var) = getExpr().isNullWhenFalse(var);
-
-  eq AndLogicalExpr.isNullWhenFalse(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var);
-
-  eq AndBitwiseExpr.isNullWhenFalse(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var);
-
-  eq OrLogicalExpr.isNullWhenFalse(Variable var) =
-      getLeftOperand().isNullWhenFalse(var) && getRightOperand().isNullWhenFalse(var);
-
-  eq Dot.isNullWhenFalse(Variable var) =
-      !getLeft().isVariable(var) && getRight().isNullWhenFalse(var);
-
-  // Assume that a method call to X.isNo{t,n}Null_(var) is equivalent to a non-null test on var.
-  eq MethodAccess.isNullWhenFalse(Variable var) =
-      (name().startsWith("isNotNull") || name().startsWith("isNonNull"))
-      && getNumArg() == 1 && getArg(0).isVariable(var);
-
-  eq VarAccess.isNullWhenFalse(Variable var) = decl().isNullWhenFalse(var);
-
-  syn boolean Variable.isNullWhenFalse(Variable var);
-  eq EnumConstant.isNullWhenFalse(Variable var) = false;
-  eq ParameterDeclaration.isNullWhenFalse(Variable var) = false;
-  eq FieldDeclarator.isNullWhenFalse(Variable var) = false;
-  eq CatchParameterDeclaration.isNullWhenFalse(Variable var) = false;
-  eq InferredParameterDeclaration.isNullWhenFalse(Variable var) = false;
-  eq VariableDeclarator.isNullWhenFalse(Variable var) =
-      type().isBoolean() && hasInit() && isEffectivelyFinal()
-      ? getInit().isNullWhenFalse(var)
-      : false;
-
-  /** @return {@code true} if the variable var is non-null when this expression is true. */
-  syn boolean Expr.isNonNullWhenTrue(Variable var) = false;
-
-  eq NEExpr.isNonNullWhenTrue(Variable var) =
-      getLeftOperand().isNull() && getRightOperand().varDecl() == var
-      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
-      || getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenTrue(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenTrue(var);
-
-  eq EQExpr.isNonNullWhenTrue(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenTrue(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenTrue(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenFalse(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenFalse(var);
-
-  eq LogNotExpr.isNonNullWhenTrue(Variable var) = getOperand().isNullWhenTrue(var);
-
-  eq ParExpr.isNonNullWhenTrue(Variable var) = getExpr().isNonNullWhenTrue(var);
-
-  eq AndLogicalExpr.isNonNullWhenTrue(Variable var) =
-      getLeftOperand().isNonNullWhenTrue(var) || getRightOperand().isNonNullWhenTrue(var);
-
-  eq AndBitwiseExpr.isNonNullWhenTrue(Variable var) =
-      getLeftOperand().isNonNullWhenTrue(var) || getRightOperand().isNonNullWhenTrue(var);
-
-  eq OrLogicalExpr.isNonNullWhenTrue(Variable var) =
-      getLeftOperand().isFalse() && getRightOperand().isNonNullWhenTrue(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenTrue(var);
-
-  eq Dot.isNonNullWhenTrue(Variable var) =
-      !getLeft().isVariable(var) && getRight().isNonNullWhenTrue(var);
-
-  // Assume that a method call to X.isNo{t,n}Null_(var) is equivalent to a non-null test on var.
-  eq MethodAccess.isNonNullWhenTrue(Variable var) =
-      (name().startsWith("isNotNull") || name().startsWith("isNonNull"))
-      && getNumArg() == 1 && getArg(0).isVariable(var);
-
-  eq VarAccess.isNonNullWhenTrue(Variable var) = decl().isNonNullWhenTrue(var);
-
-  syn boolean Variable.isNonNullWhenTrue(Variable var);
-  eq EnumConstant.isNonNullWhenTrue(Variable var) = false;
-  eq ParameterDeclaration.isNonNullWhenTrue(Variable var) = false;
-  eq FieldDeclarator.isNonNullWhenTrue(Variable var) = false;
-  eq CatchParameterDeclaration.isNonNullWhenTrue(Variable var) = false;
-  eq InferredParameterDeclaration.isNonNullWhenTrue(Variable var) = false;
-  eq VariableDeclarator.isNonNullWhenTrue(Variable var) =
-      type().isBoolean() && hasInit() && isEffectivelyFinal()
-      ? getInit().isNonNullWhenTrue(var)
-      : false;
-
-  // An instanceof check guards against the variable being null.
-  eq InstanceOfExpr.isNonNullWhenTrue(Variable var) = getExpr().isVariable(var);
-
-  /** @return {@code true} if the variable var is non-null when this expression is false. */
-  syn boolean Expr.isNonNullWhenFalse(Variable var) = false;
-
-  eq NEExpr.isNonNullWhenFalse(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenTrue(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenTrue(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenFalse(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenFalse(var);
-
-  eq EQExpr.isNonNullWhenFalse(Variable var) =
-      getLeftOperand().isNull() && getRightOperand().varDecl() == var
-      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
-      || getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var)
-      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenTrue(var)
-      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenTrue(var);
-
-  eq LogNotExpr.isNonNullWhenFalse(Variable var) = getOperand().isNonNullWhenTrue(var);
-
-  eq ParExpr.isNonNullWhenFalse(Variable var) = getExpr().isNonNullWhenFalse(var);
-
-  eq AndLogicalExpr.isNonNullWhenFalse(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var);
-
-  eq AndBitwiseExpr.isNonNullWhenFalse(Variable var) =
-      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
-      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var);
-
-  eq OrLogicalExpr.isNonNullWhenFalse(Variable var) =
-      getLeftOperand().isNonNullWhenFalse(var) || getRightOperand().isNonNullWhenFalse(var);
-
-  eq Dot.isNonNullWhenFalse(Variable var) =
-      !getLeft().isVariable(var) && getRight().isNonNullWhenFalse(var);
-
-  // Assume that a method call to X.isNull_(var) is equivalent to a null test on var.
-  eq MethodAccess.isNonNullWhenFalse(Variable var) =
-      name().startsWith("isNull") && getNumArg() == 1 && getArg(0).isVariable(var);
-
-  eq VarAccess.isNonNullWhenFalse(Variable var) = decl().isNonNullWhenFalse(var);
-
-  syn boolean Variable.isNonNullWhenFalse(Variable var);
-  eq EnumConstant.isNonNullWhenFalse(Variable var) = false;
-  eq ParameterDeclaration.isNonNullWhenFalse(Variable var) = false;
-  eq FieldDeclarator.isNonNullWhenFalse(Variable var) = false;
-  eq CatchParameterDeclaration.isNonNullWhenFalse(Variable var) = false;
-  eq InferredParameterDeclaration.isNonNullWhenFalse(Variable var) = false;
-  eq VariableDeclarator.isNonNullWhenFalse(Variable var) =
-      type().isBoolean() && hasInit() && isEffectivelyFinal()
-      ? getInit().isNonNullWhenFalse(var)
-      : false;
-
-  syn boolean Expr.isNull() = type().isNull();
-  eq NullLiteral.isNull() = true;
-}
+///**
+// * Copyright 2015 Google Inc. All Rights Reserved.
+// *
+// * Licensed under the Apache License, Version 2.0 (the "License");
+// * you may not use this file except in compliance with the License.
+// * You may obtain a copy of the License at
+// *
+// *     http://www.apache.org/licenses/LICENSE-2.0
+// *
+// * Unless required by applicable law or agreed to in writing, software
+// * distributed under the License is distributed on an "AS IS" BASIS,
+// * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// * See the License for the specific language governing permissions and
+// * limitations under the License.
+// */
+//
+///**
+// * Adds an analysis that checks for dereferences of a parameter declared nullable.
+// *
+// * <p>When a method or constructor parameter is annotated with javax.annotation.Nullable,
+// * we check that all dereferences of that parameter are guarded by a null-check. The
+// * analysis is control-flow sensitive in that it will recognize if all control flow paths
+// * to the dereference are effectively guarded by a null check, for example: {@code
+// * if (p == null) return;
+// * p.x(); // Guarded by null check above.
+// * }
+// *
+// * <p>The analysis is not intraprocedural, so in order to avoid false positives
+// * where a method call guards against nullness the analyzer assumes that
+// * calling a method with an argument x results in an exception if x is null and
+// * thus works like an effective null guard for x.
+// *
+// * <p>To find potential null dereferences on nullable parameters, the analysis does a forward CFG
+// * traversal from the entry-point of the method. Note that this is only done whenever a
+// * {@code @Nullable} parameter has been encountered in the method. The traversal explores all paths
+// * from the method entry until it finds null guard statements such as {@code if (p != null)}. The
+// * branches that are protected from nullness get pruned in the search and the search continues on
+// * other branches. The search is performed by a {@code NullDereferenceLocator}, which implements the
+// * {@code CfgSearch} interface. This visitor is invoked for each node in the CFG search, and it
+// * decides if the search will continue from that node, or if the current edge should be skipped
+// * (i.e., pruned).
+// *
+// * <p>In order to find the position in the CFG where a potential null dereference occurs, CFG marker
+// * nodes are inserted. This is done by adding a synthesized non-terminal attribute (NTA) for
+// * a CfgMarker on Dot (which represents Java dot expressions). This marker node appears
+// * in the CFG as "nullable access" because it is inserted whenever a nullable variable is
+// * dereferenced.
+// *
+// * <p>Dataflow analysis is not used, so in order to analyze a parameter it is required to be
+// * effectively final, i.e. it is not assigned anywhere in side the body of the method/constructor.
+// */
+//aspect NullableDereferenceAnalysis {
+//
+//  // Give ParameterDeclaration access to the inherited compilationUnit attribute.
+//  inh CompilationUnit ParameterDeclaration.compilationUnit();
+//
+//  ParameterDeclaration contributes nullableDereferenceFinding()
+//      when nullableDereferenceFinding() != null
+//      to CompilationUnit.findings()
+//      for compilationUnit();
+//
+//  /**
+//   * Generate a NullableDereference finding for this dot expression,
+//   * if no finding should be reported this attribute returns {@code null}.
+//   */
+//  syn lazy ExtendJFinding ParameterDeclaration.nullableDereferenceFinding() {
+//    if (!getModifiers().hasNullableAnnotation()) {
+//      return null;
+//    }
+//    if (!isFinal() && !isEffectivelyFinal()) {
+//      // Do not analyze non-effectively final parameters.
+//      return null;
+//    }
+//    Expr location = findNullableDereference(this);
+//    if (location == null) {
+//      return null;
+//    }
+//    ExtendJFinding finding = location.finding("NullableDereference", String.format(
+//        "Dereferencing %s, which was declared @Nullable.", name()));
+//    if (compilationUnit().fromSource()) {
+//      ASTNode modifierLocation = nullableModifierLocation();
+//      int line = getLine(modifierLocation.getStart());
+//      int startCol = getColumn(modifierLocation.getStart());
+//      int endCol = getColumn(modifierLocation.getEnd());
+//      if (startCol < endCol && line == getLine(modifierLocation.getEnd())) {
+//        try {
+//          InputStream data = compilationUnit().getClassSource().openInputStream();
+//          java.util.Scanner scanner = new java.util.Scanner(data);
+//          for (int i = 1; i < line && scanner.hasNextLine(); ++i) {
+//            scanner.nextLine();
+//          }
+//          if (scanner.hasNextLine()) {
+//            String text = scanner.nextLine();
+//            finding.addFix("Remove the @Nullable annotation.",
+//                line, line,
+//                text.substring(0,startCol-1) + text.substring(endCol+1) + "\n");
+//          }
+//        } catch (IOException e) {
+//          // Failed to unparse the current line.
+//          // This is not a serious problem; we just don't give a fix suggestion.
+//        }
+//      }
+//    }
+//    return finding;
+//  }
+//
+//  // Exclude variable arity parameters from Nullable dereference analysis.
+//  // When a variable arity parameter is annotated @Nullable, that will most likely be intended as a
+//  // @Nullable annotation for the individual parameters, not the containing argument array.
+//  eq VariableArityParameterDeclaration.nullableDereferenceFinding() = null;
+//
+//  /**
+//   * Find the location node for the javax.annotation.Nullable annotation in the modifier list.
+//   * Returns {@code null} if the location of the modifier was not found.
+//   */
+//  syn ASTNode ParameterDeclaration.nullableModifierLocation() =
+//      getModifiers().nullableModifierLocation();
+//
+//  syn ASTNode Modifiers.nullableModifierLocation() {
+//    for (Modifier modifier : getModifierList()) {
+//      if (modifier.isAnnotation("javax.annotation", "Nullable")) {
+//        return modifier.locationNode();
+//      }
+//    }
+//    return null;
+//  }
+//
+//  /**
+//   * Find a location, not necessarily the first location, in the host method/constructor where the
+//   * parameter is accessed without a null guard.
+//   */
+//  inh Expr ParameterDeclaration.findNullableDereference(Variable var);
+//
+//  eq Program.getChild().findNullableDereference(Variable var) = null;
+//  eq BodyDecl.getChild().findNullableDereference(Variable var) = null;
+//
+//  eq MethodDecl.getParameter().findNullableDereference(Variable var) {
+//    if (!hasBlock()) {
+//      return null;
+//    }
+//    CfgNode cfgNode = entry().bfs(new NullDereferenceLocator(var));
+//    return cfgNode == null ? null : cfgNode.receiverExpr();
+//  }
+//
+//  eq ConstructorDecl.getParameter().findNullableDereference(Variable var) {
+//    CfgNode cfgNode = entry().bfs(new NullDereferenceLocator(var));
+//    return cfgNode == null ? null : cfgNode.receiverExpr();
+//  }
+//
+//  /**
+//   * A CFG visitor that searches in the forward CFG for a nullable dereference.
+//   *
+//   * <p>The search stops at parts of the search tree guarded by a null check
+//   * on the receiver variable.
+//   */
+//  class NullDereferenceLocator implements CfgVisitor {
+//    private final Variable var;
+//
+//    public NullDereferenceLocator(Variable var) {
+//      this.var = var;
+//    }
+//
+//    @Override public SearchAction processEdge(CfgNode pred, CfgNode succ) {
+//      if (pred.isNullGuard(var, succ)) {
+//        return SearchAction.SKIP;
+//      }
+//      Expr receiver = succ.receiverExpr();
+//      if (receiver != null && receiver.isVariable(var) && !receiver.hasNullGuard(var)) {
+//        return SearchAction.SUCCESSOR_MATCH;
+//      }
+//      return SearchAction.CONTINUE;
+//    }
+//  }
+//
+//  /**
+//   * Returns the receiver expression if the CFG node is the child of a dereference expression.
+//   * Returns {@code null} otherwise.
+//   */
+//  inh Expr CfgNode.receiverExpr();
+//  eq Program.getChild().receiverExpr() = null;
+//  eq BodyDecl.getChild().receiverExpr() = null;
+//  eq BodyDecl.exit().receiverExpr() = null;
+//  eq TryStmt.tryEntryMarker().receiverExpr() = null;
+//  eq BreakStmt.marker().receiverExpr() = null;
+//  eq ContinueStmt.marker().receiverExpr() = null;
+//  eq ReturnStmt.marker().receiverExpr() = null;
+//  eq MethodAccess.exceptionNode().receiverExpr() = null;
+//  eq MethodAccess.call().receiverExpr() =
+//      hasPrevExpr()
+//      ? prevExpr()
+//      : null;
+//  eq ThrowStmt.exceptionNode().receiverExpr() = null;
+//  eq TryStmt.exceptionNode().receiverExpr() = null;
+//  eq ConditionalExpr.branch().receiverExpr() = null;
+//  eq ConditionalExpr.thenEndMarker().receiverExpr() = null;
+//  eq ConditionalExpr.elseEndMarker().receiverExpr() = null;
+//  eq IfStmt.branch().receiverExpr() = null;
+//  eq IfStmt.thenEndMarker().receiverExpr() = null;
+//  eq IfStmt.elseEndMarker().receiverExpr() = null;
+//  eq ForStmt.branch().receiverExpr() = null;
+//  eq EnhancedForStmt.branch().receiverExpr() = null;
+//  eq WhileStmt.branch().receiverExpr() = null;
+//  eq DoStmt.branch().receiverExpr() = null;
+//  eq SwitchStmt.branch().receiverExpr() = null;
+//  eq LambdaBody.exit().receiverExpr() = null;
+//  eq Dot.nullableDereferenceMarker().receiverExpr() = getLeft();
+//
+//  /** Marker node used to find location of a nullable dereference in the CFG.  */
+//  syn nta CfgMarker Dot.nullableDereferenceMarker() = new CfgMarker();
+//
+//  /** Insert nullable dereference marker in the CFG.  */
+//  refine SimpleCFG
+//  eq Dot.getLeft().follow() =
+//      getRight().isMethodAccess()
+//      ? refined()
+//      : nullableDereferenceMarker();
+//
+//  eq Dot.nullableDereferenceMarker().succ() = Collections.singleton(getRight().entry());
+//
+//  syn boolean CfgNode.isNullGuard(Variable var, CfgNode succ) = false;
+//
+//  /**
+//   * We assume that calling a method with the variable var as an argument
+//   * results in an exception thrown by the method call if var is null. This is
+//   * not true for many methods, but it should reduce the false positive rate
+//   * for the NullableDereference analyzer.
+//   */
+//  eq CfgMethodCall.isNullGuard(Variable var, CfgNode succ) {
+//    if (succ instanceof CfgException) {
+//      return false;
+//    }
+//    MethodAccess access = methodAccess();
+//    for (Expr arg : access.getArgList()) {
+//      if (arg.isVariable(var)) {
+//        return true;
+//      }
+//    }
+//    return false;
+//  }
+//
+//  /** Check if this branch has a null-guarding condition.  */
+//  eq CfgBranch.isNullGuard(Variable var, CfgNode succ) = inNullGuard(var, succ);
+//
+//  inh boolean CfgBranch.inNullGuard(Variable var, CfgNode succ);
+//
+//  eq IfStmt.branch().inNullGuard(Variable var, CfgNode succ) =
+//      succ == getThen().entry()
+//      ? getCondition().isNonNullWhenTrue(var)
+//      : getCondition().isNonNullWhenFalse(var);
+//
+//  eq ConditionalExpr.branch().inNullGuard(Variable var, CfgNode succ) =
+//      succ == getTrueExpr().entry()
+//      ? getCondition().isNonNullWhenTrue(var)
+//      : getCondition().isNonNullWhenFalse(var);
+//
+//  eq ForStmt.branch().inNullGuard(Variable var, CfgNode succ) =
+//      succ == getStmt().entry()
+//      ? getCondition().isNonNullWhenTrue(var)
+//      : getCondition().isNonNullWhenFalse(var);
+//
+//  eq WhileStmt.branch().inNullGuard(Variable var, CfgNode succ) =
+//      succ == getStmt().entry()
+//      ? getCondition().isNonNullWhenTrue(var)
+//      : getCondition().isNonNullWhenFalse(var);
+//
+//  eq EnhancedForStmt.branch().inNullGuard(Variable var, CfgNode succ) = false;
+//  eq DoStmt.branch().inNullGuard(Variable var, CfgNode succ) = false;
+//  eq SwitchStmt.branch().inNullGuard(Variable var, CfgNode succ) = false;
+//
+//  /** Returns {@code true} if this set of modifiers includes {@code javax.annotation.Nullable}.  */
+//  syn boolean Modifiers.hasNullableAnnotation() = hasAnnotation("javax.annotation", "Nullable");
+//
+//  /** Return {@code true} if this expression is guarded by a != null check for var.  */
+//  inh boolean Expr.hasNullGuard(Variable var);
+//  eq Program.getChild().hasNullGuard(Variable var) = false;
+//  eq IfStmt.getThen().hasNullGuard(Variable var) = getCondition().isNonNullWhenTrue(var);
+//  eq IfStmt.getElse().hasNullGuard(Variable var) = getCondition().isNonNullWhenFalse(var);
+//  eq WhileStmt.getStmt().hasNullGuard(Variable var) = getCondition().isNonNullWhenTrue(var);
+//  eq ForStmt.getStmt().hasNullGuard(Variable var) = getCondition().isNonNullWhenTrue(var);
+//  eq ConditionalExpr.getTrueExpr().hasNullGuard(Variable var) =
+//      getCondition().isNonNullWhenTrue(var) || hasNullGuard(var);
+//  eq ConditionalExpr.getFalseExpr().hasNullGuard(Variable var) =
+//      getCondition().isNonNullWhenFalse(var) || hasNullGuard(var);
+//  eq AndLogicalExpr.getRightOperand().hasNullGuard(Variable var) =
+//      getLeftOperand().isNonNullWhenTrue(var) || hasNullGuard(var);
+//  eq AndBitwiseExpr.getRightOperand().hasNullGuard(Variable var) =
+//      getLeftOperand().isNonNullWhenTrue(var) || hasNullGuard(var);
+//  eq OrLogicalExpr.getRightOperand().hasNullGuard(Variable var) =
+//      getLeftOperand().isNonNullWhenFalse(var) || hasNullGuard(var);
+//
+//  /** @return {@code true} if the variable var is null when this expression is true. */
+//  syn boolean Expr.isNullWhenTrue(Variable var) = false;
+//
+//  eq NEExpr.isNullWhenTrue(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNullWhenTrue(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNullWhenTrue(var);
+//
+//  eq EQExpr.isNullWhenTrue(Variable var) =
+//      getLeftOperand().isNull() && getRightOperand().varDecl() == var
+//      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
+//      || getLeftOperand().isTrue() && getRightOperand().isNullWhenTrue(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNullWhenTrue(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNullWhenFalse(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNullWhenFalse(var);
+//
+//  eq LogNotExpr.isNullWhenTrue(Variable var) = getOperand().isNullWhenFalse(var);
+//
+//  eq ParExpr.isNullWhenTrue(Variable var) = getExpr().isNullWhenTrue(var);
+//
+//  eq AndLogicalExpr.isNullWhenTrue(Variable var) =
+//      getLeftOperand().isNullWhenTrue(var) || getRightOperand().isNullWhenTrue(var);
+//
+//  eq AndBitwiseExpr.isNullWhenTrue(Variable var) =
+//      getLeftOperand().isNullWhenTrue(var) || getRightOperand().isNullWhenTrue(var);
+//
+//  eq OrLogicalExpr.isNullWhenTrue(Variable var) =
+//      getLeftOperand().isFalse() && getRightOperand().isNullWhenTrue(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNullWhenTrue(var);
+//
+//  eq Dot.isNullWhenTrue(Variable var) =
+//      !getLeft().isVariable(var) && getRight().isNullWhenTrue(var);
+//
+//  // Assume that a method call to X.isNull_(var) is equivalent to a null test on var.
+//  eq MethodAccess.isNullWhenTrue(Variable var) =
+//      name().startsWith("isNull") && getNumArg() == 1 && getArg(0).isVariable(var);
+//
+//  eq VarAccess.isNullWhenTrue(Variable var) = decl().isNullWhenTrue(var);
+//
+//  syn boolean Variable.isNullWhenTrue(Variable var);
+//  eq EnumConstant.isNullWhenTrue(Variable var) = false;
+//  eq ParameterDeclaration.isNullWhenTrue(Variable var) = false;
+//  eq FieldDeclarator.isNullWhenTrue(Variable var) = false;
+//  eq CatchParameterDeclaration.isNullWhenTrue(Variable var) = false;
+//  eq InferredParameterDeclaration.isNullWhenTrue(Variable var) = false;
+//  eq VariableDeclarator.isNullWhenTrue(Variable var) =
+//      type().isBoolean() && hasInit() && isEffectivelyFinal()
+//      ? getInit().isNullWhenTrue(var)
+//      : false;
+//
+//  /** @return {@code true} if the variable var is null when this expression is false. */
+//  syn boolean Expr.isNullWhenFalse(Variable var) = false;
+//
+//  eq NEExpr.isNullWhenFalse(Variable var) =
+//      getLeftOperand().isNull() && getRightOperand().varDecl() == var
+//      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
+//      || getLeftOperand().isTrue() && getRightOperand().isNullWhenTrue(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNullWhenTrue(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNullWhenFalse(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNullWhenFalse(var);
+//
+//  eq EQExpr.isNullWhenFalse(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNullWhenTrue(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNullWhenTrue(var);
+//
+//  eq LogNotExpr.isNullWhenFalse(Variable var) = getOperand().isNullWhenTrue(var);
+//
+//  eq ParExpr.isNullWhenFalse(Variable var) = getExpr().isNullWhenFalse(var);
+//
+//  eq AndLogicalExpr.isNullWhenFalse(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var);
+//
+//  eq AndBitwiseExpr.isNullWhenFalse(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNullWhenFalse(var);
+//
+//  eq OrLogicalExpr.isNullWhenFalse(Variable var) =
+//      getLeftOperand().isNullWhenFalse(var) && getRightOperand().isNullWhenFalse(var);
+//
+//  eq Dot.isNullWhenFalse(Variable var) =
+//      !getLeft().isVariable(var) && getRight().isNullWhenFalse(var);
+//
+//  // Assume that a method call to X.isNo{t,n}Null_(var) is equivalent to a non-null test on var.
+//  eq MethodAccess.isNullWhenFalse(Variable var) =
+//      (name().startsWith("isNotNull") || name().startsWith("isNonNull"))
+//      && getNumArg() == 1 && getArg(0).isVariable(var);
+//
+//  eq VarAccess.isNullWhenFalse(Variable var) = decl().isNullWhenFalse(var);
+//
+//  syn boolean Variable.isNullWhenFalse(Variable var);
+//  eq EnumConstant.isNullWhenFalse(Variable var) = false;
+//  eq ParameterDeclaration.isNullWhenFalse(Variable var) = false;
+//  eq FieldDeclarator.isNullWhenFalse(Variable var) = false;
+//  eq CatchParameterDeclaration.isNullWhenFalse(Variable var) = false;
+//  eq InferredParameterDeclaration.isNullWhenFalse(Variable var) = false;
+//  eq VariableDeclarator.isNullWhenFalse(Variable var) =
+//      type().isBoolean() && hasInit() && isEffectivelyFinal()
+//      ? getInit().isNullWhenFalse(var)
+//      : false;
+//
+//  /** @return {@code true} if the variable var is non-null when this expression is true. */
+//  syn boolean Expr.isNonNullWhenTrue(Variable var) = false;
+//
+//  eq NEExpr.isNonNullWhenTrue(Variable var) =
+//      getLeftOperand().isNull() && getRightOperand().varDecl() == var
+//      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
+//      || getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenTrue(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenTrue(var);
+//
+//  eq EQExpr.isNonNullWhenTrue(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenTrue(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenTrue(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenFalse(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenFalse(var);
+//
+//  eq LogNotExpr.isNonNullWhenTrue(Variable var) = getOperand().isNullWhenTrue(var);
+//
+//  eq ParExpr.isNonNullWhenTrue(Variable var) = getExpr().isNonNullWhenTrue(var);
+//
+//  eq AndLogicalExpr.isNonNullWhenTrue(Variable var) =
+//      getLeftOperand().isNonNullWhenTrue(var) || getRightOperand().isNonNullWhenTrue(var);
+//
+//  eq AndBitwiseExpr.isNonNullWhenTrue(Variable var) =
+//      getLeftOperand().isNonNullWhenTrue(var) || getRightOperand().isNonNullWhenTrue(var);
+//
+//  eq OrLogicalExpr.isNonNullWhenTrue(Variable var) =
+//      getLeftOperand().isFalse() && getRightOperand().isNonNullWhenTrue(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenTrue(var);
+//
+//  eq Dot.isNonNullWhenTrue(Variable var) =
+//      !getLeft().isVariable(var) && getRight().isNonNullWhenTrue(var);
+//
+//  // Assume that a method call to X.isNo{t,n}Null_(var) is equivalent to a non-null test on var.
+//  eq MethodAccess.isNonNullWhenTrue(Variable var) =
+//      (name().startsWith("isNotNull") || name().startsWith("isNonNull"))
+//      && getNumArg() == 1 && getArg(0).isVariable(var);
+//
+//  eq VarAccess.isNonNullWhenTrue(Variable var) = decl().isNonNullWhenTrue(var);
+//
+//  syn boolean Variable.isNonNullWhenTrue(Variable var);
+//  eq EnumConstant.isNonNullWhenTrue(Variable var) = false;
+//  eq ParameterDeclaration.isNonNullWhenTrue(Variable var) = false;
+//  eq FieldDeclarator.isNonNullWhenTrue(Variable var) = false;
+//  eq CatchParameterDeclaration.isNonNullWhenTrue(Variable var) = false;
+//  eq InferredParameterDeclaration.isNonNullWhenTrue(Variable var) = false;
+//  eq VariableDeclarator.isNonNullWhenTrue(Variable var) =
+//      type().isBoolean() && hasInit() && isEffectivelyFinal()
+//      ? getInit().isNonNullWhenTrue(var)
+//      : false;
+//
+//  // An instanceof check guards against the variable being null.
+//  eq InstanceOfExpr.isNonNullWhenTrue(Variable var) = getExpr().isVariable(var);
+//
+//  /** @return {@code true} if the variable var is non-null when this expression is false. */
+//  syn boolean Expr.isNonNullWhenFalse(Variable var) = false;
+//
+//  eq NEExpr.isNonNullWhenFalse(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenTrue(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenTrue(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenFalse(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenFalse(var);
+//
+//  eq EQExpr.isNonNullWhenFalse(Variable var) =
+//      getLeftOperand().isNull() && getRightOperand().varDecl() == var
+//      || getRightOperand().isNull() && getLeftOperand().varDecl() == var
+//      || getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var)
+//      || getLeftOperand().isFalse() && getRightOperand().isNonNullWhenTrue(var)
+//      || getRightOperand().isFalse() && getLeftOperand().isNonNullWhenTrue(var);
+//
+//  eq LogNotExpr.isNonNullWhenFalse(Variable var) = getOperand().isNonNullWhenTrue(var);
+//
+//  eq ParExpr.isNonNullWhenFalse(Variable var) = getExpr().isNonNullWhenFalse(var);
+//
+//  eq AndLogicalExpr.isNonNullWhenFalse(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var);
+//
+//  eq AndBitwiseExpr.isNonNullWhenFalse(Variable var) =
+//      getLeftOperand().isTrue() && getRightOperand().isNonNullWhenFalse(var)
+//      || getRightOperand().isTrue() && getLeftOperand().isNonNullWhenFalse(var);
+//
+//  eq OrLogicalExpr.isNonNullWhenFalse(Variable var) =
+//      getLeftOperand().isNonNullWhenFalse(var) || getRightOperand().isNonNullWhenFalse(var);
+//
+//  eq Dot.isNonNullWhenFalse(Variable var) =
+//      !getLeft().isVariable(var) && getRight().isNonNullWhenFalse(var);
+//
+//  // Assume that a method call to X.isNull_(var) is equivalent to a null test on var.
+//  eq MethodAccess.isNonNullWhenFalse(Variable var) =
+//      name().startsWith("isNull") && getNumArg() == 1 && getArg(0).isVariable(var);
+//
+//  eq VarAccess.isNonNullWhenFalse(Variable var) = decl().isNonNullWhenFalse(var);
+//
+//  syn boolean Variable.isNonNullWhenFalse(Variable var);
+//  eq EnumConstant.isNonNullWhenFalse(Variable var) = false;
+//  eq ParameterDeclaration.isNonNullWhenFalse(Variable var) = false;
+//  eq FieldDeclarator.isNonNullWhenFalse(Variable var) = false;
+//  eq CatchParameterDeclaration.isNonNullWhenFalse(Variable var) = false;
+//  eq InferredParameterDeclaration.isNonNullWhenFalse(Variable var) = false;
+//  eq VariableDeclarator.isNonNullWhenFalse(Variable var) =
+//      type().isBoolean() && hasInit() && isEffectivelyFinal()
+//      ? getInit().isNonNullWhenFalse(var)
+//      : false;
+//
+//  syn boolean Expr.isNull() = type().isNull();
+//  eq NullLiteral.isNull() = true;
+//}

reusablecfg/src/main/jastadd/PrintCfg.jrag

@@ -137,7 +137,7 @@ aspect PrintCfg {
   eq ReturnStmt.marker().markerName() = "return";
   eq TryStmt.tryEntryMarker().markerName() = "try";
   eq Program.getChild().markerName() = "marker";
-  eq Dot.nullableDereferenceMarker().markerName() = "nullable access";
+//  eq Dot.nullableDereferenceMarker().markerName() = "nullable access";
   eq ForStmt.loopEndMarker().markerName() = "for-end";
   eq EnhancedForStmt.loopEndMarker().markerName() = "for-end";
   eq WhileStmt.loopEndMarker().markerName() = "while-end";

reusablecfg/src/main/jastadd/PrintCfgTest.jrag

@@ -171,7 +171,7 @@ aspect PrintCfgTest {
   eq ReturnStmt.marker().markerVarName() = "returnMarker";
   eq TryStmt.tryEntryMarker().markerVarName() = "tryEntry";
   eq Program.getChild().markerVarName() = "marker";
-  eq Dot.nullableDereferenceMarker().markerVarName() = "nullable";
+//  eq Dot.nullableDereferenceMarker().markerVarName() = "nullable";
   eq ForStmt.loopEndMarker().markerVarName() = "forEnd";
   eq EnhancedForStmt.loopEndMarker().markerVarName() = "forEnd";
   eq WhileStmt.loopEndMarker().markerVarName() = "whileEnd";

reusablecfg/src/test/java/de/tudresden/inf/st/reusablecfg/NullableDereferenceTest.java

@@ -36,110 +36,114 @@ import java.util.Collection;
 @RunWith(JUnit4.class)
 public class NullableDereferenceTest {
 
-  @Test public void suggestedFixEndsWithNewline() {
-    CompilationUnit unit = StmtCfgTest.parseFile("NullableNullGuard01",
-        Program.ANALYZER_TYPE_FILTER);
-    Collection<ExtendJFinding> findings = unit.findings();
-    assertThat(findings).isNotEmpty();
-    ExtendJFinding finding = findings.iterator().next();
-    assertThat(finding.fixes).hasSize(1);
-    assertThat(finding.fixes.iterator().next().newText).endsWith("\n");
-  }
-
-  @Test public void nullGuards01() {
-    Collection<String> findings = StmtCfgTest.findings("NullableNullGuard01");
-    assertThat(findings).containsExactly(
-        "../simplecfg/testdata/NullableNullGuard01.javax:42:25: Dereferencing p, which was declared @Nullable.",
-        "../simplecfg/testdata/NullableNullGuard01.javax:49:12: Dereferencing p, which was declared @Nullable.",
-        "../simplecfg/testdata/NullableNullGuard01.javax:62:12: Dereferencing p, which was declared @Nullable.",
-        "../simplecfg/testdata/NullableNullGuard01.javax:93:12: Dereferencing q, which was declared @Nullable."
-        );
-  }
-
-  @Test public void nullGuards02() {
-    Collection<String> findings = StmtCfgTest.findings("NullableNullGuard02");
-    assertThat(findings).containsExactly(
-        "../simplecfg/testdata/NullableNullGuard02.javax:49:7: Dereferencing p, which was declared @Nullable.",
-        "../simplecfg/testdata/NullableNullGuard02.javax:54:7: Dereferencing p, which was declared @Nullable."
-        );
-  }
-
-  @Test public void nullGuards03() {
-    Collection<Integer> lines = StmtCfgTest.findingLines("NullableNullGuard03",
-        Program.ANALYZER_TYPE_FILTER);
-    assertThat(lines).containsExactly(28, 34, 41, 48, 113, 119);
-  }
-
-  @Test public void methodNullGuard01() {
-    Collection<String> findings = StmtCfgTest.findings("NullableMethodNullGuard01");
-    assertThat(findings).isEmpty();
-  }
-
-  @Test public void dataflow01() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDataflow01");
-    assertThat(findings).containsExactly(
-        "../simplecfg/testdata/NullableDataflow01.javax:27:7: Dereferencing p, which was declared @Nullable.",
-        "../simplecfg/testdata/NullableDataflow01.javax:35:7: Dereferencing p, which was declared @Nullable."
-        );
-  }
-
-  @Test public void instanceOf() {
-    Collection<String> findings = StmtCfgTest.findings("NullableInstanceOf");
-    assertThat(findings).isEmpty();
-  }
-
-  @Test public void variableArity() {
-    Collection<String> findings = StmtCfgTest.findings("NullableVariableArity");
-    assertThat(findings).isEmpty();
-  }
-
-  @Test public void nullableDereference01() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereference01");
-    assertThat(findings).containsExactly(
-        "../simplecfg/testdata/NullableDereference01.javax:27:12: Dereferencing p, which was declared @Nullable.",
-        "../simplecfg/testdata/NullableDereference01.javax:31:12: Dereferencing p, which was declared @Nullable."
-        );
-  }
-
-  /** Test false positive for GitHub issue #10. */
-  @Test public void issue10() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue10");
-    assertThat(findings).containsExactly(
-        "../simplecfg/testdata/NullableDereferenceIssue10.javax:34:31: Dereferencing y, which was declared @Nullable."
-        );
-  }
-
-  @Test public void issue11() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue11");
-    assertThat(findings).isEmpty();
-  }
-
-  @Test public void issue12() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue12");
-    assertThat(findings).isEmpty();
-  }
-
-  @Test public void eqExpr() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceEqExpr");
-    assertThat(findings).isEmpty();
-  }
-
-  @Test public void neExpr() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceNeExpr");
-    assertThat(findings).isEmpty();
-  }
-
-  @Test public void methodCall() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceMethodCall");
-    assertThat(findings).containsExactly(
-        "../simplecfg/testdata/NullableDereferenceMethodCall.javax:41:16: "
-        + "Dereferencing p, which was declared @Nullable.");
-  }
-
-  @Test public void issue13() {
-    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue13");
-    assertThat(findings).containsExactly(
-        "../simplecfg/testdata/NullableDereferenceIssue13.javax:33:7: "
-        + "Dereferencing obj, which was declared @Nullable.");
-  }
+  @Test public void test() {
+    // this is a dummy test to appease intellij
+  }
+
+//  @Test public void suggestedFixEndsWithNewline() {
+//    CompilationUnit unit = StmtCfgTest.parseFile("NullableNullGuard01",
+//        Program.ANALYZER_TYPE_FILTER);
+//    Collection<ExtendJFinding> findings = unit.findings();
+//    assertThat(findings).isNotEmpty();
+//    ExtendJFinding finding = findings.iterator().next();
+//    assertThat(finding.fixes).hasSize(1);
+//    assertThat(finding.fixes.iterator().next().newText).endsWith("\n");
+//  }
+//
+//  @Test public void nullGuards01() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableNullGuard01");
+//    assertThat(findings).containsExactly(
+//        "../simplecfg/testdata/NullableNullGuard01.javax:42:25: Dereferencing p, which was declared @Nullable.",
+//        "../simplecfg/testdata/NullableNullGuard01.javax:49:12: Dereferencing p, which was declared @Nullable.",
+//        "../simplecfg/testdata/NullableNullGuard01.javax:62:12: Dereferencing p, which was declared @Nullable.",
+//        "../simplecfg/testdata/NullableNullGuard01.javax:93:12: Dereferencing q, which was declared @Nullable."
+//        );
+//  }
+//
+//  @Test public void nullGuards02() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableNullGuard02");
+//    assertThat(findings).containsExactly(
+//        "../simplecfg/testdata/NullableNullGuard02.javax:49:7: Dereferencing p, which was declared @Nullable.",
+//        "../simplecfg/testdata/NullableNullGuard02.javax:54:7: Dereferencing p, which was declared @Nullable."
+//        );
+//  }
+//
+//  @Test public void nullGuards03() {
+//    Collection<Integer> lines = StmtCfgTest.findingLines("NullableNullGuard03",
+//        Program.ANALYZER_TYPE_FILTER);
+//    assertThat(lines).containsExactly(28, 34, 41, 48, 113, 119);
+//  }
+//
+//  @Test public void methodNullGuard01() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableMethodNullGuard01");
+//    assertThat(findings).isEmpty();
+//  }
+//
+//  @Test public void dataflow01() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDataflow01");
+//    assertThat(findings).containsExactly(
+//        "../simplecfg/testdata/NullableDataflow01.javax:27:7: Dereferencing p, which was declared @Nullable.",
+//        "../simplecfg/testdata/NullableDataflow01.javax:35:7: Dereferencing p, which was declared @Nullable."
+//        );
+//  }
+//
+//  @Test public void instanceOf() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableInstanceOf");
+//    assertThat(findings).isEmpty();
+//  }
+//
+//  @Test public void variableArity() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableVariableArity");
+//    assertThat(findings).isEmpty();
+//  }
+//
+//  @Test public void nullableDereference01() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereference01");
+//    assertThat(findings).containsExactly(
+//        "../simplecfg/testdata/NullableDereference01.javax:27:12: Dereferencing p, which was declared @Nullable.",
+//        "../simplecfg/testdata/NullableDereference01.javax:31:12: Dereferencing p, which was declared @Nullable."
+//        );
+//  }
+//
+//  /** Test false positive for GitHub issue #10. */
+//  @Test public void issue10() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue10");
+//    assertThat(findings).containsExactly(
+//        "../simplecfg/testdata/NullableDereferenceIssue10.javax:34:31: Dereferencing y, which was declared @Nullable."
+//        );
+//  }
+//
+//  @Test public void issue11() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue11");
+//    assertThat(findings).isEmpty();
+//  }
+//
+//  @Test public void issue12() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue12");
+//    assertThat(findings).isEmpty();
+//  }
+//
+//  @Test public void eqExpr() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceEqExpr");
+//    assertThat(findings).isEmpty();
+//  }
+//
+//  @Test public void neExpr() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceNeExpr");
+//    assertThat(findings).isEmpty();
+//  }
+//
+//  @Test public void methodCall() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceMethodCall");
+//    assertThat(findings).containsExactly(
+//        "../simplecfg/testdata/NullableDereferenceMethodCall.javax:41:16: "
+//        + "Dereferencing p, which was declared @Nullable.");
+//  }
+//
+//  @Test public void issue13() {
+//    Collection<String> findings = StmtCfgTest.findings("NullableDereferenceIssue13");
+//    assertThat(findings).containsExactly(
+//        "../simplecfg/testdata/NullableDereferenceIssue13.javax:33:7: "
+//        + "Dereferencing obj, which was declared @Nullable.");
+//  }
 }