anchor.diff:    }
   
     @override
  -  void beforeGetConstantInitializers(ConstructorElement constructor) {
  -    // Make sure we properly recorded the dependency.
  -    expect(
  -        computer.referenceGraph.containsPath(_nodeBeingEvaluated, constructor),
  -        isTrue);
  -  }
  +  void beforeGetConstantInitializers(ConstructorElement constructor) =>
  +      _checkPathTo(constructor);
   
     @override
  -  void beforeGetEvaluationResult(ConstantEvaluationTarget constant) {
  -    // Make sure we properly recorded the dependency.
  -    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, constant),
  -        isTrue);
  -  }
  +  void beforeGetEvaluationResult(ConstantEvaluationTarget constant) =>
  +      _checkPathTo(constant);
   
     @override
  -  void beforeGetFieldEvaluationResult(FieldElementImpl field) {
  -    // Make sure we properly recorded the dependency.
  -    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, field),
  -        isTrue);
  -  }
  +  void beforeGetFieldEvaluationResult(FieldElementImpl field) =>
  +      _checkPathTo(field);
   
     @override
  -  void beforeGetParameterDefault(ParameterElement parameter) {
  -    // Make sure we properly recorded the dependency.
  -    expect(computer.referenceGraph.containsPath(_nodeBeingEvaluated, parameter),
  -        isTrue);
  +  void beforeGetParameterDefault(ParameterElement parameter) =>
  +      _checkPathTo(parameter);
  +
  +  void _checkPathTo(ConstantEvaluationTarget target) {
  +    if (computer.referenceGraph.containsPath(_nodeBeingEvaluated, target)) {
  +      return; // pass
  +    }
  +    // print a nice error message on failure
  +    StringBuffer out = new StringBuffer();
  +    out.writeln("missing path in constant dependency graph");
  +    out.writeln("from $_nodeBeingEvaluated to $target");
  +    for (var s in context.analysisCache.sources) {
  +      String text = context.getContents(s).data;
  +      if (text != "") {
  +        out.writeln('''
  +=== ${s.shortName}
  +$text''');
  +      }
  +    }
  +    fail(out.toString());
     }
   }
   
  
positive.code:   }
  
    void test_computeValues_dependentVariables() {
      Source librarySource = addSource(r'''
  const int b = a;
  const int a = 0;''');
      LibraryElement libraryElement = resolve2(librarySource);
      CompilationUnit unit =
          analysisContext.resolveCompilationUnit(librarySource, libraryElement);
      expect(unit, isNotNull);
      ConstantValueComputer computer = _makeConstantValueComputer();
      computer.add(unit, librarySource, librarySource);
      computer.computeValues();
      NodeList<CompilationUnitMember> members = unit.declarations;
      expect(members, hasLength(2));
  
negative.code: 
    ConstantValueComputer _makeConstantValueComputer() {
      ConstantEvaluationValidator_ForTest validator =
          new ConstantEvaluationValidator_ForTest(analysisContext2);
      validator.computer = new ConstantValueComputer(
          analysisContext2,
          analysisContext2.typeProvider,
  