anchor.diff:    }
   }
   
  -class _Visitor extends UnifyingAstVisitor<void> {
  +class _Visitor extends RecursiveAstVisitor<void> {
     static final lateables =
         <CompilationUnitElement, List<VariableDeclaration>>{};
   
  
positive.code: 
    @override
    void visitFieldDeclaration(FieldDeclaration node) {
      for (var variable in node.fields.variables) {
        var parent = node.parent;
        // see https://github.com/dart-lang/linter/pull/2189#issuecomment-660115569
        // We could also include public members in private classes but to do that
        // we'd need to ensure that there are no instances of either the
        // enclosing class or any subclass of the enclosing class that are ever
        // accessible outside this library.
        if (parent != null &&
            (Identifier.isPrivateName(variable.name.name) ||
                _isPrivateExtension(parent))) {
          _visit(variable);
        }
      }
      super.visitFieldDeclaration(node);
    }
  
    @override
    void visitNode(AstNode node) {
      var parent = node.parent;
  
      Element? element;
      if (parent is AssignmentExpression && parent.leftHandSide == node) {
        element = parent.writeElement?.canonicalElement;
      } else {
        element = node.canonicalElement;
      }
  
      if (element != null) {
        if (parent is Expression) {
          parent = parent.unParenthesized;
        }
        if (node is SimpleIdentifier && node.inDeclarationContext()) {
          // ok
        } else if (parent is PostfixExpression &&
            parent.operand == node &&
            parent.operator.type == TokenType.BANG) {
          // ok non-null access
        } else if (parent is AssignmentExpression &&
            parent.operator.type == TokenType.EQ &&
            DartTypeUtilities.isNonNullable(
                context, parent.rightHandSide.staticType)) {
          // ok non-null access
        } else {
          nullableAccess[currentUnit]?.add(element);
        }
      }
      super.visitNode(node);
    }
  
    @override
  
negative.code:     }
      lateables[currentUnit]?.add(variable);
    }
  
    /// Checks whether [expression], which must be an [Identifier] or
    /// [PropertyAccess], and its [canonicalElement], represent a nullable access.
    void _visitIdentifierOrPropertyAccess(
        Expression expression, Element? canonicalElement) {
      assert(expression is Identifier || expression is PropertyAccess);
      if (canonicalElement != null) {
        var parent = expression.parent;
        if (parent is Expression) {
          parent = parent.unParenthesized;
        }
        if (expression is SimpleIdentifier && expression.inDeclarationContext()) {
          // This is OK.
        } else if (parent is PostfixExpression &&
            parent.operand == expression &&
            parent.operator.type == TokenType.BANG) {
          // This is OK; non-null access.
        } else {
          nullableAccess[currentUnit]?.add(canonicalElement);
        }
      }
    }
  }
  