Add more (incomplete) diagnostic support to the status pages

pkg/analysis_server/lib/src/status/validator.dart

+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library analysis_server.src.status.validator;
+
+import 'dart:collection';
+
+import 'package:analyzer/src/context/cache.dart';
+import 'package:analyzer/src/context/context.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/constant.dart';
+import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/engine.dart'
+    show AnalysisEngine, AnalysisResult, CacheState, ChangeSet;
+import 'package:analyzer/src/generated/error.dart';
+import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_collection.dart';
+import 'package:analyzer/src/task/dart.dart';
+import 'package:analyzer/src/task/html.dart';
+import 'package:analyzer/task/dart.dart';
+import 'package:analyzer/task/model.dart';
+import 'package:html/dom.dart' as html;
+
+/**
+ * A class used to compare two element models for equality.
+ */
+class ElementComparator {
+  /**
+   * The buffer to which any discovered differences will be recorded.
+   */
+  final StringBuffer _buffer = new StringBuffer();
+
+  /**
+   * A flag indicating whether a line break should be added the next time data
+   * is written to the [_buffer].
+   */
+  bool _needsLineBreak = false;
+
+  /**
+   * Initialize a newly created comparator.
+   */
+  ElementComparator();
+
+  /**
+   * A textual description of the differences that were found.
+   */
+  String get description => _buffer.toString();
+
+  /**
+   * Return `true` if at least one difference was found between the expected and
+   * actual elements.
+   */
+  bool get hasDifference => _buffer.length > 0;
+
+  /**
+   * Compare the [expected] and [actual] elements. The results of the comparison
+   * can be accessed via the [hasDifference] and [description] getters.
+   */
+  void compareElements(Element expected, Element actual) {
+    if (expected == null) {
+      if (actual != null) {
+        _writeMismatch(expected, actual, (Element element) {
+          return element == null ? 'null' : 'non null ${element.runtimeType}';
+        });
+      }
+    } else if (actual == null) {
+      _writeMismatch(expected, actual, (Element element) {
+        return element == null ? 'null' : 'non null ${element.runtimeType}';
+      });
+    } else if (expected is ClassElement && actual is ClassElement) {
+      _compareClassElements(expected, actual);
+    } else if (expected is CompilationUnitElement &&
+        actual is CompilationUnitElement) {
+      _compareCompilationUnitElements(expected, actual);
+    } else if (expected is ConstructorElement && actual is ConstructorElement) {
+      _compareConstructorElements(expected, actual);
+    } else if (expected is ExportElement && actual is ExportElement) {
+      _compareExportElements(expected, actual);
+    } else if (expected is FieldElement && actual is FieldElement) {
+      _compareFieldElements(expected, actual);
+    } else if (expected is FieldFormalParameterElement &&
+        actual is FieldFormalParameterElement) {
+      _compareFieldFormalParameterElements(expected, actual);
+    } else if (expected is FunctionElement && actual is FunctionElement) {
+      _compareFunctionElements(expected, actual);
+    } else if (expected is FunctionTypeAliasElement &&
+        actual is FunctionTypeAliasElement) {
+      _compareFunctionTypeAliasElements(expected, actual);
+    } else if (expected is ImportElement && actual is ImportElement) {
+      _compareImportElements(expected, actual);
+    } else if (expected is LabelElement && actual is LabelElement) {
+      _compareLabelElements(expected, actual);
+    } else if (expected is LibraryElement && actual is LibraryElement) {
+      _compareLibraryElements(expected, actual);
+    } else if (expected is LocalVariableElement &&
+        actual is LocalVariableElement) {
+      _compareLocalVariableElements(expected, actual);
+    } else if (expected is MethodElement && actual is MethodElement) {
+      _compareMethodElements(expected, actual);
+    } else if (expected is MultiplyDefinedElement &&
+        actual is MultiplyDefinedElement) {
+      _compareMultiplyDefinedElements(expected, actual);
+    } else if (expected is ParameterElement && actual is ParameterElement) {
+      _compareParameterElements(expected, actual);
+    } else if (expected is PrefixElement && actual is PrefixElement) {
+      _comparePrefixElements(expected, actual);
+    } else if (expected is PropertyAccessorElement &&
+        actual is PropertyAccessorElement) {
+      _comparePropertyAccessorElements(expected, actual);
+    } else if (expected is TopLevelVariableElement &&
+        actual is TopLevelVariableElement) {
+      _compareTopLevelVariableElements(expected, actual);
+    } else if (expected is TypeParameterElement &&
+        actual is TypeParameterElement) {
+      _compareTypeParameterElements(expected, actual);
+    } else {
+      _write('Expected an instance of ');
+      _write(expected.runtimeType);
+      _write('; found an instance of ');
+      _writeln(actual.runtimeType);
+    }
+  }
+
+  void _compareClassElements(ClassElement expected, ClassElement actual) {
+    _compareGenericElements(expected, actual);
+    //
+    // Compare attributes.
+    //
+    if (expected.hasReferenceToSuper != actual.hasReferenceToSuper) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ClassElement element) => element.hasReferenceToSuper
+              ? 'a class that references super'
+              : 'a class that does not reference super');
+    }
+    if (expected.isAbstract != actual.isAbstract) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ClassElement element) =>
+              element.isAbstract ? 'an abstract class' : 'a concrete class');
+    }
+    if (expected.isEnum != actual.isEnum ||
+        expected.isMixinApplication != actual.isMixinApplication) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ClassElement element) => element.isEnum
+              ? 'an enum'
+              : (element.isMixinApplication
+                  ? 'a mixin application'
+                  : 'a class'));
+    }
+    if (expected.isOrInheritsProxy != actual.isOrInheritsProxy) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ClassElement element) => element.isOrInheritsProxy
+              ? 'a class that is marked as a proxy'
+              : 'a class that is not marked as a proxy');
+    }
+    if (expected.isValidMixin != actual.isValidMixin) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ClassElement element) =>
+              element.isValidMixin ? 'a valid mixin' : 'an invalid mixin');
+    }
+    _compareTypes('supertype', expected.supertype, actual.supertype);
+    _compareTypeLists('mixin', expected.mixins, actual.mixins);
+    _compareTypeLists('interface', expected.interfaces, actual.interfaces);
+    //
+    // Compare children.
+    //
+    _compareElementLists(expected.accessors, actual.accessors);
+    _compareElementLists(expected.constructors, actual.constructors);
+    _compareElementLists(expected.fields, actual.fields);
+    _compareElementLists(expected.methods, actual.methods);
+    _compareElementLists(expected.typeParameters, actual.typeParameters);
+  }
+
+  void _compareCompilationUnitElements(
+      CompilationUnitElement expected, CompilationUnitElement actual) {
+    _compareGenericElements(expected, actual);
+    //
+    // Compare children.
+    //
+    _compareElementLists(expected.accessors, actual.accessors);
+    _compareElementLists(expected.enums, actual.enums);
+    _compareElementLists(expected.functions, actual.functions);
+    _compareElementLists(
+        expected.functionTypeAliases, actual.functionTypeAliases);
+    _compareElementLists(expected.topLevelVariables, actual.topLevelVariables);
+    _compareElementLists(expected.types, actual.types);
+  }
+
+  void _compareConstructorElements(
+      ConstructorElement expected, ConstructorElement actual) {
+    _compareExecutableElements(expected, actual, 'constructor');
+    //
+    // Compare attributes.
+    //
+    if (expected.isConst != actual.isConst) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ConstructorElement element) => element.isConst
+              ? 'a const constructor'
+              : 'a non-const constructor');
+    }
+    if (expected.isFactory != actual.isFactory) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ConstructorElement element) => element.isFactory
+              ? 'a factory constructor'
+              : 'a non-factory constructor');
+    }
+    if (expected.periodOffset != actual.periodOffset) {
+      _write('Expected a period offset of ');
+      _write(expected.periodOffset);
+      _write('; found ');
+      _writeln(actual.periodOffset);
+    }
+    if ((expected.redirectedConstructor == null) !=
+        (actual.redirectedConstructor == null)) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ConstructorElement element) => element.redirectedConstructor == null
+              ? 'a redirecting constructor'
+              : 'a non-redirecting constructor');
+    }
+  }
+
+  void _compareElementLists(List expected, List actual) {
+    Set<Element> extraElements = new HashSet<Element>();
+    Map<Element, Element> commonElements = new HashMap<Element, Element>();
+
+    Map<String, Element> expectedElements = new HashMap<String, Element>();
+    for (Element expectedElement in expected) {
+      expectedElements[expectedElement.name] = expectedElement;
+    }
+    for (Element actualElement in actual) {
+      String name = actualElement.name;
+      Element expectedElement = expectedElements[name];
+      if (expectedElement == null) {
+        extraElements.add(actualElement);
+      } else {
+        commonElements[expectedElement] = actualElement;
+        expectedElements.remove(name);
+      }
+    }
+
+    commonElements.forEach((Element expected, Element actual) {
+      compareElements(expected, actual);
+    });
+    void writeElement(Element element) {
+      _write('an instance of ');
+      _write(element.runtimeType);
+      if (element.name == null) {
+        _write(' with no name');
+      } else {
+        _write(' named ');
+        _write(element.name);
+      }
+    }
+    expectedElements.forEach((String name, Element element) {
+      _write('Expected ');
+      writeElement(element);
+      _writeln('; found no match');
+    });
+    extraElements.forEach((Element element) {
+      _write('Expected nothing; found ');
+      writeElement(element);
+    });
+  }
+
+  void _compareExecutableElements(
+      ExecutableElement expected, ExecutableElement actual, String kind) {
+    _compareGenericElements(expected, actual);
+    //
+    // Compare attributes.
+    //
+    if (expected.hasImplicitReturnType != actual.hasImplicitReturnType) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) => element.hasImplicitReturnType
+              ? 'an implicit return type'
+              : 'an explicit return type');
+    }
+    if (expected.isAbstract != actual.isAbstract) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) =>
+              element.isAbstract ? 'an abstract $kind' : 'a concrete $kind');
+    }
+    if (expected.isAsynchronous != actual.isAsynchronous) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) => element.isAsynchronous
+              ? 'an asynchronous $kind'
+              : 'a synchronous $kind');
+    }
+    if (expected.isExternal != actual.isExternal) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) => element.isExternal
+              ? 'an external $kind'
+              : 'a non-external $kind');
+    }
+    if (expected.isGenerator != actual.isGenerator) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) => element.isGenerator
+              ? 'a generator $kind'
+              : 'a non-generator $kind');
+    }
+    if (expected.isOperator != actual.isOperator) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) =>
+              element.isOperator ? 'an operator' : 'a non-operator $kind');
+    }
+    if (expected.isStatic != actual.isStatic) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) =>
+              element.isStatic ? 'a static $kind' : 'an instance $kind');
+    }
+    if ((expected.returnType == null) != (actual.returnType == null)) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ExecutableElement element) => element.returnType == null
+              ? 'a $kind with no return type'
+              : 'a $kind with a return type');
+    } else {
+      _compareTypes('return type', expected.returnType, actual.returnType);
+    }
+    //
+    // Compare children.
+    //
+    _compareElementLists(expected.functions, actual.functions);
+    _compareElementLists(expected.labels, actual.labels);
+    _compareElementLists(expected.localVariables, actual.localVariables);
+    _compareElementLists(expected.parameters, actual.parameters);
+    _compareElementLists(expected.typeParameters, actual.typeParameters);
+  }
+
+  void _compareExportElements(ExportElement expected, ExportElement actual) {
+    _compareUriReferencedElements(expected, actual);
+    //
+    // Compare attributes.
+    //
+    if ((expected.exportedLibrary == null) !=
+        (actual.exportedLibrary == null)) {
+      // TODO(brianwilkerson) Check for more than existence?
+      _writeMismatch(
+          expected,
+          actual,
+          (ExportElement element) => element.exportedLibrary == null
+              ? 'unresolved uri'
+              : 'uri resolved to ${element.exportedLibrary.source.fullName}');
+    }
+    //
+    // Compare children.
+    //
+    _compareElementLists(expected.combinators, actual.combinators);
+  }
+
+  void _compareFieldElements(FieldElement expected, FieldElement actual) {
+    _comparePropertyInducingElements(expected, actual, 'field');
+    //
+    // Compare attributes.
+    //
+    if (expected.isEnumConstant != actual.isEnumConstant) {
+      _writeMismatch(
+          expected,
+          actual,
+          (FieldElement element) =>
+              element.isEnumConstant ? 'an enum constant' : 'a normal field');
+    }
+  }
+
+  void _compareFieldFormalParameterElements(
+      FieldFormalParameterElement expected,
+      FieldFormalParameterElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _compareFunctionElements(
+      FunctionElement expected, FunctionElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _compareFunctionTypeAliasElements(
+      FunctionTypeAliasElement expected, FunctionTypeAliasElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _compareGenericElements(Element expected, Element actual) {
+    _compareMetadata(expected.metadata, actual.metadata);
+    if (expected.nameOffset != actual.nameOffset) {
+      _write('Expected name offset of ');
+      _write(expected.nameOffset);
+      _write('; found ');
+      _writeln(actual.nameOffset);
+    }
+    SourceRange expectedRange = expected.docRange;
+    SourceRange actualRange = actual.docRange;
+    if (expectedRange.offset != actualRange.offset ||
+        expectedRange.length != actualRange.length) {
+      _write('Expected documentation range of ');
+      _write(expectedRange);
+      _write('; found ');
+      _writeln(actualRange);
+    }
+  }
+
+  void _compareImportElements(ImportElement expected, ImportElement actual) {
+    _compareUriReferencedElements(expected, actual);
+    //
+    // Compare attributes.
+    //
+    if (expected.isDeferred != actual.isDeferred) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ImportElement element) => element.isDeferred
+              ? 'a deferred import'
+              : 'a non-deferred import');
+    }
+    if ((expected.importedLibrary == null) !=
+        (actual.importedLibrary == null)) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ImportElement element) => element.importedLibrary == null
+              ? 'unresolved uri'
+              : 'uri resolved to ${element.importedLibrary.source.fullName}');
+    }
+    if ((expected.prefix == null) != (actual.prefix == null)) {
+      _writeMismatch(
+          expected,
+          actual,
+          (ImportElement element) => element.prefix == null
+              ? 'no prefix'
+              : 'a prefix named ${element.prefix.name}');
+    }
+    if (expected.prefixOffset != actual.prefixOffset) {
+      _write('Expected a prefix offset of ');
+      _write(expected.prefixOffset);
+      _write('; found ');
+      _writeln(actual.prefixOffset);
+    }
+    //
+    // Compare children.
+    //
+    _compareElementLists(expected.combinators, actual.combinators);
+  }
+
+  void _compareLabelElements(LabelElement expected, LabelElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _compareLibraryElements(LibraryElement expected, LibraryElement actual) {
+    _compareGenericElements(expected, actual);
+    //
+    // Compare attributes.
+    //
+    // TODO(brianwilkerson) Implement this
+    expected.hasLoadLibraryFunction;
+    expected.name;
+    expected.source;
+    //
+    // Compare children.
+    //
+    _compareElementLists(expected.imports, actual.imports);
+    _compareElementLists(expected.exports, actual.exports);
+    _compareElementLists(expected.units, actual.units);
+  }
+
+  void _compareLocalVariableElements(
+      LocalVariableElement expected, LocalVariableElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _compareMetadata(
+      List<ElementAnnotation> expected, List<ElementAnnotation> actual) {
+    // TODO(brianwilkerson) Implement this
+  }
+
+  void _compareMethodElements(MethodElement expected, MethodElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareExecutableElements(expected, actual, 'method');
+    //
+    // Compare attributes.
+    //
+    if (expected.isStatic != actual.isStatic) {
+      _writeMismatch(
+          expected,
+          actual,
+          (FieldElement element) =>
+              element.isStatic ? 'a static field' : 'an instance field');
+    }
+  }
+
+  void _compareMultiplyDefinedElements(
+      MultiplyDefinedElement expected, MultiplyDefinedElement actual) {
+    // TODO(brianwilkerson) Implement this
+  }
+
+  void _compareParameterElements(
+      ParameterElement expected, ParameterElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _comparePrefixElements(PrefixElement expected, PrefixElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _comparePropertyAccessorElements(
+      PropertyAccessorElement expected, PropertyAccessorElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _comparePropertyInducingElements(PropertyInducingElement expected,
+      PropertyInducingElement actual, String kind) {
+    _compareVariableElements(expected, actual, kind);
+  }
+
+  void _compareTopLevelVariableElements(
+      TopLevelVariableElement expected, TopLevelVariableElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+  }
+
+  void _compareTypeLists(String descriptor, List<InterfaceType> expected,
+      List<InterfaceType> actual) {
+    int expectedLength = expected.length;
+    if (expectedLength != actual.length) {
+      _write('Expected ');
+      _write(expectedLength);
+      _write(' ');
+      _write(descriptor);
+      _write('s; found ');
+      _write(actual.length);
+    } else {
+      for (int i = 0; i < expectedLength; i++) {
+        _compareTypes(descriptor, expected[i], actual[i]);
+      }
+    }
+  }
+
+  void _compareTypeParameterElements(
+      TypeParameterElement expected, TypeParameterElement actual) {
+    // TODO(brianwilkerson) Implement this
+    _compareGenericElements(expected, actual);
+    expected.bound;
+  }
+
+  void _compareTypes(String descriptor, DartType expected, DartType actual) {
+    void compareNames() {
+      if (expected.name != actual.name) {
+        _write('Expected a ');
+        _write(descriptor);
+        _write(' named ');
+        _write(expected.name);
+        _write('; found a ');
+        _write(descriptor);
+        _write(' named ');
+        _write(actual.name);
+      }
+    }
+    void compareTypeArguments(
+        ParameterizedType expected, ParameterizedType actual) {
+      List<DartType> expectedArguments = expected.typeArguments;
+      List<DartType> actualArguments = actual.typeArguments;
+      int expectedLength = expectedArguments.length;
+      if (expectedLength != actualArguments.length) {
+        _write('Expected ');
+        _write(expectedLength);
+        _write(' type arguments; found ');
+        _write(actualArguments.length);
+      } else {
+        for (int i = 0; i < expectedLength; i++) {
+          _compareTypes(
+              'type argument', expectedArguments[i], actualArguments[i]);
+        }
+      }
+    }
+
+    if (expected == null) {
+      if (actual != null) {
+        _write('Expected no ');
+        _write(descriptor);
+        _write('; found a ');
+        _write(descriptor);
+        _write(' named ');
+        _write(actual.name);
+      }
+    } else if (actual == null) {
+      _write('Expected a ');
+      _write(descriptor);
+      _write(' named ');
+      _write(expected.name);
+      _write('; found none');
+    } else if ((expected.isBottom && actual.isBottom) ||
+        (expected.isDynamic && actual.isDynamic) ||
+        (expected.isVoid && actual.isVoid)) {
+      // The types are the same
+    } else if (expected is InterfaceType && actual is InterfaceType) {
+      compareNames();
+      compareTypeArguments(expected, actual);
+    } else if (expected is FunctionType && actual is FunctionType) {
+      compareNames();
+      compareTypeArguments(expected, actual);
+    } else if (expected is TypeParameterType && actual is TypeParameterType) {
+      compareNames();
+      _compareTypes('bound', expected.element.bound, actual.element.bound);
+    } else {
+      _write('Expected an instance of ');
+      _write(expected.runtimeType);
+      _write(' named ');
+      _write(expected.name);
+      _write('; found an instance of ');
+      _writeln(actual.runtimeType);
+      _write(' named ');
+      _write(actual.name);
+    }
+  }
+
+  void _compareUriReferencedElements(
+      UriReferencedElement expected, UriReferencedElement actual) {
+    _compareGenericElements(expected, actual);
+    //
+    // Compare attributes.
+    //
+    if (expected.uri != actual.uri) {
+      _write('Expected a uri of ');
+      _write(expected.uri);
+      _write('; found ');
+      _writeln(actual.uri);
+    }
+    if (expected.uriOffset != actual.uriOffset) {
+      _write('Expected a uri offset of ');
+      _write(expected.uriOffset);
+      _write('; found ');
+      _writeln(actual.uriOffset);
+    }
+  }
+
+  void _compareVariableElements(
+      VariableElement expected, VariableElement actual, String kind) {
+    _compareGenericElements(expected, actual);
+    //
+    // Compare attributes.
+    //
+    if ((expected.constantValue == null) != (actual.constantValue == null)) {
+      // TODO(brianwilkerson) Check for more than existence.
+      _writeMismatch(
+          expected,
+          actual,
+          (VariableElement element) => element.constantValue == null
+              ? 'a $kind with no constant value'
+              : 'a $kind with a constant value');
+    }
+    if (expected.hasImplicitType != actual.hasImplicitType) {
+      _writeMismatch(
+          expected,
+          actual,
+          (VariableElement element) => element.hasImplicitType
+              ? 'a $kind with an implicit type'
+              : 'a $kind with an explicit type');
+    }
+    if (expected.isConst != actual.isConst) {
+      _writeMismatch(
+          expected,
+          actual,
+          (VariableElement element) =>
+              element.isConst ? 'a const $kind' : 'a non-const $kind');
+    }
+    if (expected.isFinal != actual.isFinal) {
+      _writeMismatch(
+          expected,
+          actual,
+          (VariableElement element) =>
+              element.isFinal ? 'a final $kind' : 'a non-final $kind');
+    }
+    if (expected.isPotentiallyMutatedInClosure !=
+        actual.isPotentiallyMutatedInClosure) {
+      _writeMismatch(
+          expected,
+          actual,
+          (VariableElement element) => element.isPotentiallyMutatedInClosure
+              ? 'a $kind that is potentially mutated in a closure'
+              : 'a $kind that is not mutated in a closure');
+    }
+    if (expected.isPotentiallyMutatedInScope !=
+        actual.isPotentiallyMutatedInScope) {
+      _writeMismatch(
+          expected,
+          actual,
+          (VariableElement element) => element.isPotentiallyMutatedInScope
+              ? 'a $kind that is potentially mutated in its scope'
+              : 'a $kind that is not mutated in its scope');
+    }
+    if (expected.isStatic != actual.isStatic) {
+      _writeMismatch(
+          expected,
+          actual,
+          (VariableElement element) =>
+              element.isStatic ? 'a static $kind' : 'an instance $kind');
+    }
+    //
+    // Compare children.
+    //
+    compareElements(expected.initializer, actual.initializer);
+  }
+
+  void _write(Object value) {
+    if (_needsLineBreak) {
+      _buffer.write('</p><p>');
+      _needsLineBreak = false;
+    }
+    _buffer.write(value);
+  }
+
+  void _writeln(Object value) {
+    _buffer.write(value);
+    _needsLineBreak = true;
+  }
+
+  /**
+   * Write a simple message explaining that the [expected] and [actual] values
+   * were different, using the [describe] function to describe the values.
+   */
+  void _writeMismatch /*<E>*/ (Object /*=E*/ expected, Object /*=E*/ actual,
+      String describe(Object /*=E*/ value)) {
+    _write('Expected ');
+    _write(describe(expected));
+    _write('; found ');
+    _writeln(describe(actual));
+  }
+}
+
+/**
+ * The comparison of two analyses of the same target.
+ */
+class EntryComparison {
+  /**
+   * The target that was analyzed.
+   */
+  final AnalysisTarget target;
+
+  /**
+   * The cache entry from the original context.
+   */
+  final CacheEntry originalEntry;
+
+  /**
+   * The cache entry from the re-analysis in a cloned context.
+   */
+  final CacheEntry cloneEntry;
+
+  /**
+   * A flag indicating whether the target is obsolete. A target is obsolete if
+   * it is an element in an element model that was replaced at a some point.
+   */
+  bool obsoleteTarget = false;
+
+  /**
+   * A table mapping the results that were computed for the target to
+   * comparisons of the values of those results. The table only contains entries
+   * for results for which the comparison produced interesting data.
+   */
+  Map<ResultDescriptor, ResultComparison> resultMap =
+      new HashMap<ResultDescriptor, ResultComparison>();
+
+  /**
+   * Initialize a newly created comparison of the given [target]'s analysis,
+   * given the [originalEntry] from the original context and the [cloneEntry]
+   * from the cloned context.
+   */
+  EntryComparison(this.target, this.originalEntry, this.cloneEntry) {
+    _performComparison();
+  }
+
+  /**
+   * Return `true` if there is something interesting about the analysis of this
+   * target that should be reported.
+   */
+  bool hasInterestingState() => obsoleteTarget || resultMap.isNotEmpty;
+
+  /**
+   * Write an HTML formatted description of the validation results to the given
+   * [buffer].
+   */
+  void writeOn(StringBuffer buffer) {
+    buffer.write('<p>');
+    buffer.write(target);
+    buffer.write('</p>');
+    buffer.write('<blockquote>');
+    if (obsoleteTarget) {
+      buffer.write('<p><b>This target is obsolete.</b></p>');
+    }
+    List<ResultDescriptor> results = resultMap.keys.toList();
+    results.sort((ResultDescriptor first, ResultDescriptor second) =>
+        first.toString().compareTo(second.toString()));
+    for (ResultDescriptor result in results) {
+      resultMap[result].writeOn(buffer);
+    }
+    buffer.write('</blockquote>');
+  }
+
+  /**
+   * Compare all of the results that were computed in the two contexts, adding
+   * the interesting comparisons to the [resultMap].
+   */
+  void _compareResults() {
+    Set<ResultDescriptor> results = new Set<ResultDescriptor>();
+    results.addAll(originalEntry.nonInvalidResults);
+    results.addAll(cloneEntry.nonInvalidResults);
+
+    for (ResultDescriptor result in results) {
+      ResultComparison difference = new ResultComparison(this, result);
+      if (difference.hasInterestingState()) {
+        resultMap[result] = difference;
+      }
+    }
+  }
+
+  /**
+   * Return `true` if the target of this entry is an obsolete element.
+   */
+  bool _isTargetObsolete() {
+    if (target is Element) {
+      LibraryElement library = (target as Element).library;
+      AnalysisContextImpl context = library.context;
+      CacheEntry entry = context.analysisCache.get(library.source);
+      LibraryElement value = entry.getValue(LIBRARY_ELEMENT);
+      return value != library;
+    }
+    return false;
+  }
+
+  /**
+   * Determine whether or not there is any interesting difference between the
+   * original and cloned contexts.
+   */
+  void _performComparison() {
+    obsoleteTarget = _isTargetObsolete();
+    _compareResults();
+  }
+}
+
+/**
+ * The comparison of the value of a single result computed for a single target.
+ */
+class ResultComparison {
+  /**
+   * The entry for the target for which the result was computed.
+   */
+  final EntryComparison entry;
+
+  /**
+   * The result that was computed for the target.
+   */
+  final ResultDescriptor result;
+
+  /**
+   * A flag indicating whether the state of the result is different.
+   */
+  bool differentStates = false;
+
+  /**
+   * The result of comparing the values of the results, or `null` if the states
+   * are different or if the values are the same.
+   */
+  ValueComparison valueComparison;
+
+  /**
+   * Initialize a newly created result comparison.
+   */
+  ResultComparison(this.entry, this.result) {
+    _performComparison();
+  }
+
+  /**
+   * Return `true` if this object represents a difference between the original
+   * and cloned contexts.
+   */
+  bool hasInterestingState() => differentStates || valueComparison != null;
+
+  /**
+   * Write an HTML formatted description of the validation results to the given
+   * [buffer].
+   */
+  void writeOn(StringBuffer buffer) {
+    buffer.write('<p>');
+    buffer.write(result);
+    buffer.write('</p>');
+    buffer.write('<blockquote>');
+    if (differentStates) {
+      CacheState originalState = entry.originalEntry.getState(result);
+      CacheState cloneState = entry.cloneEntry.getState(result);
+      buffer.write('<p>Original state = ');
+      buffer.write(originalState.name);
+      buffer.write('; clone state = ');
+      buffer.write(cloneState.name);
+      buffer.write('</p>');
+    }
+    if (valueComparison != null) {
+      valueComparison.writeOn(buffer);
+    }
+    buffer.write('</blockquote>');
+  }
+
+  /**
+   * Determine whether the state of the result is different between the
+   * original and cloned contexts.
+   */
+  bool _areStatesDifferent(CacheState originalState, CacheState cloneState) {
+    if (originalState == cloneState) {
+      return false;
+    } else if (originalState == CacheState.FLUSHED &&
+        cloneState == CacheState.VALID) {
+      return false;
+    } else if (originalState == CacheState.VALID &&
+        cloneState == CacheState.FLUSHED) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Determine whether the value of the result is different between the
+   * original and cloned contexts.
+   */
+  void _compareValues(CacheState originalState, CacheState cloneState) {
+    if (originalState != cloneState || originalState != CacheState.VALID) {
+      return null;
+    }
+    ValueComparison comparison = new ValueComparison(
+        entry.originalEntry.getValue(result),
+        entry.cloneEntry.getValue(result));
+    if (comparison.hasInterestingState()) {
+      valueComparison = comparison;
+    }
+  }
+
+  /**
+   * Determine whether or not there is any interesting difference between the
+   * original and cloned contexts.
+   */
+  void _performComparison() {
+    CacheState originalState = entry.originalEntry.getState(result);
+    CacheState cloneState = entry.cloneEntry.getState(result);
+    if (_areStatesDifferent(originalState, cloneState)) {
+      differentStates = true;
+      _compareValues(originalState, cloneState);
+    }
+  }
+}
+
+/**
+ * The results of validating an analysis context.
+ *
+ * Validation is done by re-analyzing all of the explicitly added source in a
+ * new analysis context that is configured to be the same as the original
+ * context.
+ */
+class ValidationResults {
+  /**
+   * A set of targets that were in the original context that were not included
+   * in the re-created context.
+   */
+  Set<AnalysisTarget> extraTargets;
+
+  /**
+   * A set of targets that were in the re-created context that were not included
+   * in the original context.
+   */
+  Set<AnalysisTarget> missingTargets;
+
+  /**
+   * A table, keyed by targets, whose values are comparisons of the analysis of
+   * those targets. The table only contains entries for targets for which the
+   * comparison produced interesting data.
+   */
+  Map<AnalysisTarget, EntryComparison> targetMap =
+      new HashMap<AnalysisTarget, EntryComparison>();
+
+  /**
+   * Initialize a newly created validation result by validating the given
+   * [context].
+   */
+  ValidationResults(AnalysisContextImpl context) {
+    _validate(context);
+  }
+
+  /**
+   * Write an HTML formatted description of the validation results to the given
+   * [buffer].
+   */
+  void writeOn(StringBuffer buffer) {
+    if (extraTargets.isEmpty && missingTargets.isEmpty && targetMap.isEmpty) {
+      buffer.write('<p>No interesting results.</p>');
+      return;
+    }
+    if (extraTargets.isNotEmpty) {
+      buffer.write('<h4>Extra Targets</h4>');
+      buffer.write('<p style="commentary">');
+      buffer.write('Targets that exist in the original context that were not ');
+      buffer.write('re-created in the cloned context.');
+      buffer.write('</p>');
+      _writeTargetList(buffer, extraTargets.toList());
+    }
+    if (missingTargets.isNotEmpty) {
+      buffer.write('<h4>Missing Targets</h4>');
+      buffer.write('<p style="commentary">');
+      buffer.write('Targets that do <b>not</b> exist in the original context ');
+      buffer.write('but do exist in the cloned context.');
+      buffer.write('</p>');
+      _writeTargetList(buffer, missingTargets.toList());
+    }
+    if (targetMap.isNotEmpty) {
+      buffer.write('<h4>Differing Targets</h4>');
+      // TODO(brianwilkerson) Sort the list of targets.
+      for (EntryComparison comparison in targetMap.values) {
+        comparison.writeOn(buffer);
+      }
+    }
+  }
+
+  /**
+   * Analyze all of the explicit sources in the given [context].
+   */
+  void _analyze(AnalysisContextImpl context) {
+    while (true) {
+      AnalysisResult result = context.performAnalysisTask();
+      if (!result.hasMoreWork) {
+        return;
+      }
+    }
+  }
+
+  /**
+   * Create and return a new analysis context that will analyze files in the
+   * same way as the given [context].
+   */
+  AnalysisContextImpl _clone(AnalysisContextImpl context) {
+    AnalysisContextImpl clone = AnalysisEngine.instance.createAnalysisContext();
+
+    clone.analysisOptions = context.analysisOptions;
+    //clone.declaredVariables = context.declaredVariables;
+    clone.sourceFactory = context.sourceFactory.clone();
+    // TODO(brianwilkerson) Check content cache. We either need to copy the
+    // cache into the clone or ensure that the context's cache is empty.
+
+    ChangeSet changeSet = new ChangeSet();
+    for (AnalysisTarget target in context.explicitTargets) {
+      if (target is Source) {
+        changeSet.addedSource(target);
+      }
+    }
+    clone.applyChanges(changeSet);
+    return clone;
+  }
+
+  /**
+   * Compare the results produced in the [original] context to those produced in
+   * the [clone].
+   */
+  void _compareContexts(
+      AnalysisContextImpl original, AnalysisContextImpl clone) {
+    AnalysisCache originalCache = original.analysisCache;
+    AnalysisCache cloneCache = clone.analysisCache;
+    List<AnalysisTarget> originalTargets = _getKeys(original, originalCache);
+    List<AnalysisTarget> cloneTargets = _getKeys(clone, cloneCache);
+
+    extraTargets =
+        new HashSet<AnalysisTarget>(equals: _equal, hashCode: _hashCode);
+    extraTargets.addAll(originalTargets);
+    extraTargets.removeAll(cloneTargets);
+
+    missingTargets =
+        new HashSet<AnalysisTarget>(equals: _equal, hashCode: _hashCode);
+    missingTargets.addAll(cloneTargets);
+    missingTargets.removeAll(originalTargets);
+
+    for (AnalysisTarget cloneTarget in cloneTargets) {
+      if (!missingTargets.contains(cloneTarget)) {
+        AnalysisTarget originalTarget = _find(originalTargets, cloneTarget);
+        CacheEntry originalEntry = originalCache.get(originalTarget);
+        CacheEntry cloneEntry = cloneCache.get(cloneTarget);
+        EntryComparison comparison =
+            new EntryComparison(cloneTarget, originalEntry, cloneEntry);
+        if (comparison.hasInterestingState()) {
+          targetMap[cloneTarget] = comparison;
+        }
+      }
+    }
+  }
+
+  /**
+   * Find the target in the list of [originalTargets] that is equal to the
+   * [cloneTarget].
+   */
+  AnalysisTarget _find(
+      List<AnalysisTarget> originalTargets, AnalysisTarget cloneTarget) {
+    for (AnalysisTarget originalTarget in originalTargets) {
+      if (_equal(originalTarget, cloneTarget)) {
+        return originalTarget;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return a list of the analysis targets in the given [cache] that are owned
+   * by the given [context].
+   */
+  List<AnalysisTarget> _getKeys(
+      AnalysisContextImpl context, AnalysisCache cache) {
+    List<AnalysisTarget> targets = <AnalysisTarget>[];
+    MapIterator<AnalysisTarget, CacheEntry> iterator =
+        cache.iterator(context: context);
+    while (iterator.moveNext()) {
+      targets.add(iterator.key);
+    }
+    return targets;
+  }
+
+  /**
+   * Validate the given [context].
+   */
+  void _validate(AnalysisContextImpl context) {
+    AnalysisContextImpl clone = _clone(context);
+    _analyze(clone);
+    _compareContexts(context, clone);
+  }
+
+  /**
+   * Write the list of [targets] to the [buffer].
+   */
+  void _writeTargetList(StringBuffer buffer, List<AnalysisTarget> targets) {
+    // TODO(brianwilkerson) Sort the list of targets.
+    //targets.sort();
+    for (AnalysisTarget target in targets) {
+      buffer.write('<p>');
+      buffer.write(target);
+      buffer.write(' (');
+      buffer.write(target.runtimeType);
+      buffer.write(')');
+      buffer.write('</p>');
+    }
+  }
+
+  /**
+   * Return `true` if the [first] and [second] objects are equal.
+   */
+  static bool _equal(Object first, Object second) {
+    //
+    // Compare possible null values.
+    //
+    if (first == null) {
+      return second == null;
+    } else if (second == null) {
+      return false;
+    }
+    //
+    // Handle special cases.
+    //
+    if (first is ConstantEvaluationTarget_Annotation &&
+        second is ConstantEvaluationTarget_Annotation) {
+      return _equal(first.source, second.source) &&
+          _equal(first.librarySource, second.librarySource) &&
+          _equal(first.annotation, second.annotation);
+    } else if (first is AstNode && second is AstNode) {
+      return first.runtimeType == second.runtimeType &&
+          first.offset == second.offset &&
+          first.length == second.length;
+    }
+    //
+    // Handle the general case.
+    //
+    return first == second;
+  }
+
+  /**
+   * Return a hash code for the given [object].
+   */
+  static int _hashCode(Object object) {
+    //
+    // Handle special cases.
+    //
+    if (object is ConstantEvaluationTarget_Annotation) {
+      return object.source.hashCode;
+    } else if (object is AstNode) {
+      return object.offset;
+    }
+    //
+    // Handle the general case.
+    //
+    return object.hashCode;
+  }
+}
+
+class ValueComparison {
+  /**
+   * The result value from the original context.
+   */
+  final Object originalValue;
+
+  /**
+   * The result value from the cloned context.
+   */
+  final Object cloneValue;
+
+  /**
+   * A description of the difference between the original and clone values, or
+   * `null` if the values are equal.
+   */
+  String description = null;
+
+  /**
+   * Initialize a newly created value comparison to represents the difference,
+   * if any, between the [originalValue] and the [cloneValue].
+   */
+  ValueComparison(this.originalValue, this.cloneValue) {
+    _performComparison();
+  }
+
+  /**
+   * Return `true` if this object represents a difference between the original
+   * and cloned values.
+   */
+  bool hasInterestingState() => description != null;
+
+  /**
+   * Write an HTML formatted description of the validation results to the given
+   * [buffer].
+   */
+  void writeOn(StringBuffer buffer) {
+    buffer.write('<p>');
+    buffer.write(description);
+    buffer.write('</p>');
+  }
+
+  bool _compareAnalysisErrors(
+      AnalysisError expected, AnalysisError actual, StringBuffer buffer) {
+    if (actual.errorCode == expected.errorCode &&
+        actual.source == expected.source &&
+        actual.offset == expected.offset) {
+      return true;
+    }
+    if (buffer != null) {
+      void write(AnalysisError originalError) {
+        buffer.write('a ');
+        buffer.write(originalError.errorCode.uniqueName);
+        buffer.write(' in ');
+        buffer.write(originalError.source.fullName);
+        buffer.write(' at ');
+        buffer.write(originalError.offset);
+      }
+
+      buffer.write('Expected ');
+      write(expected);
+      buffer.write('; found ');
+      write(actual);
+    }
+    return false;
+  }
+
+  bool _compareAstNodes(AstNode expected, AstNode actual, StringBuffer buffer) {
+    if (AstComparator.equalNodes(actual, expected)) {
+      return true;
+    }
+    if (buffer != null) {
+      // TODO(brianwilkerson) Compute where the difference is rather than just
+      // whether there is a difference.
+      buffer.write('Different AST nodes');
+    }
+    return false;
+  }
+
+  bool _compareConstantEvaluationTargets(ConstantEvaluationTarget expected,
+      ConstantEvaluationTarget actual, StringBuffer buffer) {
+    if (actual is ConstantEvaluationTarget_Annotation) {
+      ConstantEvaluationTarget_Annotation expectedAnnotation = expected;
+      ConstantEvaluationTarget_Annotation actualAnnotation = actual;
+      if (actualAnnotation.source == expectedAnnotation.source &&
+          actualAnnotation.librarySource == expectedAnnotation.librarySource &&
+          actualAnnotation.annotation == expectedAnnotation.annotation) {
+        return true;
+      }
+      if (buffer != null) {
+        void write(ConstantEvaluationTarget_Annotation target) {
+          Annotation annotation = target.annotation;
+          buffer.write(annotation);
+          buffer.write(' at ');
+          buffer.write(annotation.offset);
+          buffer.write(' in ');
+          buffer.write(target.source);
+          buffer.write(' in ');
+          buffer.write(target.librarySource);
+        }
+
+        buffer.write('Expected ');
+        write(expectedAnnotation);
+        buffer.write('; found ');
+        write(actualAnnotation);
+      }
+      return false;
+    }
+    if (buffer != null) {
+      buffer.write('Unknown class of ConstantEvaluationTarget: ');
+      buffer.write(actual.runtimeType);
+    }
+    return false;
+  }
+
+  bool _compareDartScripts(
+      DartScript expected, DartScript actual, StringBuffer buffer) {
+    // TODO(brianwilkerson) Implement this.
+    return true;
+  }
+
+  bool _compareDocuments(
+      html.Document expected, html.Document actual, StringBuffer buffer) {
+    // TODO(brianwilkerson) Implement this.
+    return true;
+  }
+
+  bool _compareElements(Element expected, Element actual, StringBuffer buffer) {
+    ElementComparator comparator = new ElementComparator();
+    comparator.compareElements(expected, actual);
+    if (comparator.hasDifference) {
+      if (buffer != null) {
+        buffer.write(comparator.description);
+      }
+      return false;
+    }
+    return true;
+  }
+
+  bool _compareLibrarySpecificUnits(LibrarySpecificUnit expected,
+      LibrarySpecificUnit actual, StringBuffer buffer) {
+    if (actual.library.fullName == expected.library.fullName &&
+        actual.unit.fullName == expected.unit.fullName) {
+      return true;
+    }
+    if (buffer != null) {
+      buffer.write('Expected ');
+      buffer.write(expected);
+      buffer.write('; found ');
+      buffer.write(actual);
+    }
+    return false;
+  }
+
+  bool _compareLineInfos(
+      LineInfo expected, LineInfo actual, StringBuffer buffer) {
+    // TODO(brianwilkerson) Implement this.
+    return true;
+  }
+
+  bool _compareLists(List expected, List actual, StringBuffer buffer) {
+    int expectedLength = expected.length;
+    int actualLength = actual.length;
+    int left = 0;
+    while (left < expectedLength &&
+        left < actualLength &&
+        _compareObjects(expected[left], actual[left], null)) {
+      left++;
+    }
+    if (left == actualLength) {
+      if (left == expectedLength) {
+        // The lists are the same length and the elements are equal.
+        return true;
+      }
+      if (buffer != null) {
+        buffer.write('Expected a list of length ');
+        buffer.write(expectedLength);
+        buffer.write('; found a list of length ');
+        buffer.write(actualLength);
+        buffer.write(' that was a prefix of the expected list');
+      }
+      return false;
+    } else if (left == expectedLength) {
+      if (buffer != null) {
+        buffer.write('Expected a list of length ');
+        buffer.write(expectedLength);
+        buffer.write('; found a list of length ');
+        buffer.write(actualLength);
+        buffer.write(' that was an extension of the expected list');
+      }
+      return false;
+    }
+    int expectedRight = expectedLength - 1;
+    int actualRight = actualLength - 1;
+    while (expectedRight > left &&
+        actualRight > left &&
+        _compareObjects(expected[expectedRight], actual[actualRight], null)) {
+      actualRight--;
+      expectedRight--;
+    }
+    if (buffer != null) {
+      void write(int left, int right, int length) {
+        buffer.write('the elements (');
+        buffer.write(left);
+        buffer.write('..');
+        buffer.write(right);
+        buffer.write(') in a list of length ');
+        buffer.write(length);
+      }
+
+      buffer.write('Expected ');
+      write(left, expectedRight, expectedLength);
+      buffer.write(' to match ');
+      write(left, actualRight, actualLength);
+      buffer.write(' but they did not');
+    }
+    return false;
+  }
+
+  /**
+   * Return `true` if the [expected] and [actual] objects are equal. If they are
+   * not equal, and the given [buffer] is not `null`, then a description of the
+   * difference will be written to the [buffer].
+   */
+  bool _compareObjects(Object expected, Object actual, StringBuffer buffer) {
+    //
+    // Compare possible null values.
+    //
+    if (actual == null) {
+      if (expected == null) {
+        return true;
+      } else {
+        if (buffer != null) {
+          buffer.write('Expected an instance of ');
+          buffer.write(expected.runtimeType);
+          buffer.write('; found null');
+        }
+        return false;
+      }
+    }
+    Type actualType = actual.runtimeType;
+    if (expected == null) {
+      if (buffer != null) {
+        buffer.write('Expected null; found an instance of ');
+        buffer.write(actualType);
+      }
+      return false;
+    }
+    Type expectedType = expected.runtimeType;
+    //
+    // Compare the types.
+    //
+    if (expectedType != actualType) {
+      if (buffer != null) {
+        buffer.write('Expected an instance of ');
+        buffer.write(expectedType);
+        buffer.write('; found an instance of ');
+        buffer.write(actualType);
+      }
+      return false;
+    }
+    //
+    // Compare non-null values of the same type.
+    //
+    if (actual is bool) {
+      return _comparePrimitives(expected, actual, buffer);
+    } else if (actual is int) {
+      return _comparePrimitives(expected, actual, buffer);
+    } else if (actual is String) {
+      return _compareStrings(expected, actual, buffer);
+    } else if (actual is List) {
+      return _compareLists(expected, actual, buffer);
+    } else if (actual is AnalysisError) {
+      return _compareAnalysisErrors(expected, actual, buffer);
+    } else if (actual is AstNode) {
+      return _compareAstNodes(expected, actual, buffer);
+    } else if (actual is DartScript) {
+      return _compareDartScripts(expected, actual, buffer);
+    } else if (actual is html.Document) {
+      return _compareDocuments(expected, actual, buffer);
+    } else if (actual is Element) {
+      return _compareElements(expected, actual, buffer);
+    } else if (actual is LibrarySpecificUnit) {
+      return _compareLibrarySpecificUnits(expected, actual, buffer);
+    } else if (actual is LineInfo) {
+      return _compareLineInfos(expected, actual, buffer);
+    } else if (actual is ReferencedNames) {
+      return _compareReferencedNames(expected, actual, buffer);
+    } else if (actual is Source) {
+      return _compareSources(expected, actual, buffer);
+    } else if (actual is SourceKind) {
+      return _comparePrimitives(expected, actual, buffer);
+    } else if (actual is Token) {
+      return _compareTokenStreams(expected, actual, buffer);
+    } else if (actual is TypeProvider) {
+      return true;
+    } else if (actual is UsedLocalElements) {
+      return _compareUsedLocalElements(expected, actual, buffer);
+    } else if (actual is UsedImportedElements) {
+      return _compareUsedImportedElements(expected, actual, buffer);
+    } else if (actual is ConstantEvaluationTarget) {
+      return _compareConstantEvaluationTargets(expected, actual, buffer);
+    }
+    if (buffer != null) {
+      buffer.write('Cannot compare values of type ');
+      buffer.write(actualType);
+    }
+    return false;
+  }
+
+  bool _comparePrimitives(Object expected, Object actual, StringBuffer buffer) {
+    if (actual == expected) {
+      return true;
+    }
+    if (buffer != null) {
+      buffer.write('Expected ');
+      buffer.write(expected);
+      buffer.write('; found ');
+      buffer.write(actual);
+    }
+    return false;
+  }
+
+  bool _compareReferencedNames(
+      ReferencedNames expected, ReferencedNames actual, StringBuffer buffer) {
+    Set<String> expectedNames = expected.names;
+    Map<String, Set<String>> expectedUserToDependsOn = expected.userToDependsOn;
+    Set<String> expectedKeys = expectedUserToDependsOn.keys.toSet();
+
+    Set<String> actualNames = actual.names;
+    Map<String, Set<String>> actualUserToDependsOn = actual.userToDependsOn;
+    Set<String> actualKeys = actualUserToDependsOn.keys.toSet();
+
+    Set<String> missingNames = expectedNames.difference(actualNames);
+    Set<String> extraNames = actualNames.difference(expectedNames);
+    Set<String> missingKeys = expectedKeys.difference(actualKeys);
+    Set<String> extraKeys = actualKeys.difference(expectedKeys);
+    Map<String, List<Set<String>>> mismatchedDependencies =
+        new HashMap<String, List<Set<String>>>();
+    Set<String> commonKeys = expectedKeys.intersection(actualKeys);
+    for (String key in commonKeys) {
+      Set<String> expectedDependencies = expectedUserToDependsOn[key];
+      Set<String> actualDependencies = actualUserToDependsOn[key];
+      Set<String> missingDependencies =
+          expectedDependencies.difference(actualDependencies);
+      Set<String> extraDependencies =
+          actualDependencies.difference(expectedDependencies);
+      if (missingDependencies.isNotEmpty || extraDependencies.isNotEmpty) {
+        mismatchedDependencies[key] = [missingDependencies, extraDependencies];
+      }
+    }
+
+    if (missingNames.isEmpty &&
+        extraNames.isEmpty &&
+        missingKeys.isEmpty &&
+        extraKeys.isEmpty &&
+        mismatchedDependencies.isEmpty) {
+      return true;
+    }
+    if (buffer != null) {
+      void write(String title, Set<String> names) {
+        buffer.write(names.length);
+        buffer.write(' ');
+        buffer.write(title);
+        buffer.write(': {');
+        bool first = true;
+        for (String name in names) {
+          if (first) {
+            first = false;
+          } else {
+            buffer.write(', ');
+          }
+          buffer.write(name);
+        }
+        buffer.write('}');
+      }
+      bool needsNewline = false;
+      if (missingNames.isNotEmpty) {
+        buffer.write('Has ');
+        write('missing names', missingNames);
+        needsNewline = true;
+      }
+      if (extraNames.isNotEmpty) {
+        if (needsNewline) {
+          buffer.write('</p><p>');
+        }
+        buffer.write('Has ');
+        write('extra names', extraNames);
+        needsNewline = true;
+      }
+      if (missingKeys.isNotEmpty) {
+        if (needsNewline) {
+          buffer.write('</p><p>');
+        }
+        buffer.write('Has ');
+        write('missing keys', missingKeys);
+        needsNewline = true;
+      }
+      if (extraKeys.isNotEmpty) {
+        if (needsNewline) {
+          buffer.write('</p><p>');
+        }
+        buffer.write('Has ');
+        write('extra keys', extraKeys);
+        needsNewline = true;
+      }
+      mismatchedDependencies.forEach((String key, List<Set<String>> value) {
+        Set<String> missingDependencies = value[0];
+        Set<String> extraDependencies = value[1];
+        if (needsNewline) {
+          buffer.write('</p><p>');
+        }
+        buffer.write('The key ');
+        buffer.write(key);
+        buffer.write(' has ');
+        bool needsConjunction = false;
+        if (missingNames.isNotEmpty) {
+          write('missing dependencies', missingDependencies);
+          needsConjunction = true;
+        }
+        if (extraNames.isNotEmpty) {
+          if (needsConjunction) {
+            buffer.write(' and ');
+          }
+          write('extra dependencies', extraDependencies);
+        }
+        needsNewline = true;
+      });
+    }
+    return true;
+  }
+
+  bool _compareSources(Source expected, Source actual, StringBuffer buffer) {
+    if (actual.fullName == expected.fullName) {
+      return true;
+    }
+    if (buffer != null) {
+      buffer.write('Expected a source for ');
+      buffer.write(expected.fullName);
+      buffer.write('; found a source for ');
+      buffer.write(actual.fullName);
+    }
+    return false;
+  }
+
+  bool _compareStrings(String expected, String actual, StringBuffer buffer) {
+    if (actual == expected) {
+      return true;
+    }
+    int expectedLength = expected.length;
+    int actualLength = actual.length;
+    int left = 0;
+    while (left < actualLength &&
+        left < expectedLength &&
+        actual.codeUnitAt(left) == expected.codeUnitAt(left)) {
+      left++;
+    }
+    if (left == actualLength) {
+      if (buffer != null) {
+        buffer.write('Expected ...[');
+        buffer.write(expected.substring(left));
+        buffer.write(']; found ...[]');
+      }
+      return false;
+    } else if (left == expectedLength) {
+      if (buffer != null) {
+        buffer.write('Expected ...[]; found ...[');
+        buffer.write(actual.substring(left));
+        buffer.write(']');
+      }
+      return false;
+    }
+    int actualRight = actualLength - 1;
+    int expectedRight = expectedLength - 1;
+    while (actualRight > left &&
+        expectedRight > left &&
+        actual.codeUnitAt(actualRight) == expected.codeUnitAt(expectedRight)) {
+      actualRight--;
+      expectedRight--;
+    }
+    if (buffer != null) {
+      void write(String string, int left, int right) {
+        buffer.write('...[');
+        buffer.write(string.substring(left, right));
+        buffer.write(']... (');
+        buffer.write(left);
+        buffer.write('..');
+        buffer.write(right);
+        buffer.write(')');
+      }
+
+      buffer.write('Expected ');
+      write(expected, left, expectedRight);
+      buffer.write('; found ');
+      write(actual, left, actualRight);
+    }
+    return false;
+  }
+
+  bool _compareTokenStreams(Token expected, Token actual, StringBuffer buffer) {
+    bool equals(Token originalToken, Token cloneToken) {
+      return originalToken.type == cloneToken.type &&
+          originalToken.offset == cloneToken.offset &&
+          originalToken.lexeme == cloneToken.lexeme;
+    }
+
+    Token actualLeft = actual;
+    Token expectedLeft = expected;
+    while (actualLeft.type != TokenType.EOF &&
+        expectedLeft.type != TokenType.EOF &&
+        equals(actualLeft, expectedLeft)) {
+      actualLeft = actualLeft.next;
+      expectedLeft = expectedLeft.next;
+    }
+    if (actualLeft.type == TokenType.EOF &&
+        expectedLeft.type == TokenType.EOF) {
+      return true;
+    }
+    if (buffer != null) {
+      void write(Token token) {
+        buffer.write(token.type);
+        buffer.write(' at ');
+        buffer.write(token.offset);
+        buffer.write(' (');
+        buffer.write(token.lexeme);
+        buffer.write(')');
+      }
+
+      buffer.write('Expected ');
+      write(expectedLeft);
+      buffer.write('; found ');
+      write(actualLeft);
+    }
+    return false;
+  }
+
+  bool _compareUsedImportedElements(UsedImportedElements expected,
+      UsedImportedElements actual, StringBuffer buffer) {
+    // TODO(brianwilkerson) Implement this.
+    return true;
+  }
+
+  bool _compareUsedLocalElements(UsedLocalElements expected,
+      UsedLocalElements actual, StringBuffer buffer) {
+    // TODO(brianwilkerson) Implement this.
+    return true;
+  }
+
+  /**
+   * Determine whether or not there is any interesting difference between the
+   * original and cloned values.
+   */
+  void _performComparison() {
+    StringBuffer buffer = new StringBuffer();
+    if (!_compareObjects(cloneValue, originalValue, buffer)) {
+      description = buffer.toString();
+    }
+  }
+}