// 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 dart2js.serialization_test;

import 'dart:io';
import '../memory_compiler.dart';
import 'package:async_helper/async_helper.dart';
import 'package:compiler/src/commandline_options.dart';
import 'package:compiler/src/common.dart';
import 'package:compiler/src/common/resolution.dart';
import 'package:compiler/src/constants/constructors.dart';
import 'package:compiler/src/compiler.dart';
import 'package:compiler/src/diagnostics/invariant.dart';
import 'package:compiler/src/elements/elements.dart';
import 'package:compiler/src/elements/resolution_types.dart';
import 'package:compiler/src/elements/visitor.dart';
import 'package:compiler/src/filenames.dart';
import 'package:compiler/src/library_loader.dart';
import 'package:compiler/src/ordered_typeset.dart';
import 'package:compiler/src/serialization/element_serialization.dart';
import 'package:compiler/src/serialization/equivalence.dart';
import 'package:compiler/src/serialization/json_serializer.dart';
import 'package:compiler/src/serialization/serialization.dart';
import 'package:expect/expect.dart';
import '../equivalence/check_helpers.dart';

const TEST_SOURCES = const <String, String>{
  'main.dart': '''
import 'library.dart';
import 'deferred_library.dart' deferred as prefix;

asyncMethod() async {}
asyncStarMethod() async* {}
syncStarMethod() sync* {}
get asyncGetter async {}
get asyncStarGetter async* {}
get syncStarGetter sync* {}

genericMethod<T>() {}

class Class1 {
  factory Class1.deferred() = prefix.DeferredClass;
  factory Class1.unresolved() = Unresolved;
}
''',
  'deferred_library.dart': '''
class DeferredClass {
}

get getter => 0;
set setter(_) {}
get property => 0;
set property(_) {}
''',
  'library.dart': '''
class Type {}
''',
};

main(List<String> arguments) {
  // Ensure that we can print out constant expressions.
  DEBUG_MODE = true;

  Uri entryPoint;
  String outPath;
  bool prettyPrint = false;
  for (String arg in arguments) {
    if (arg.startsWith('--')) {
      if (arg.startsWith('--out=')) {
        outPath = arg.substring('--out='.length);
      } else if (arg == '--pretty-print') {
        prettyPrint = true;
      } else {
        print("Unknown option $arg");
      }
    } else {
      if (entryPoint != null) {
        print("Multiple entrypoints is not supported.");
      }
      entryPoint = Uri.base.resolve(nativeToUriPath(arg));
    }
  }
  Map<String, String> sourceFiles = const <String, String>{};
  if (entryPoint == null) {
    entryPoint = Uri.parse('memory:main.dart');
    sourceFiles = TEST_SOURCES;
  }
  asyncTest(() async {
    CompilationResult result = await runCompiler(
        memorySourceFiles: sourceFiles,
        entryPoint: entryPoint,
        options: [Flags.analyzeAll, Flags.genericMethodSyntax]);
    Compiler compiler = result.compiler;
    testSerialization(compiler.libraryLoader.libraries, compiler.reporter,
        compiler.resolution, compiler.libraryLoader,
        outPath: outPath, prettyPrint: prettyPrint);
    Expect.isFalse(
        compiler.reporter.hasReportedError, "Unexpected errors occured.");
  });
}

void testSerialization(
    Iterable<LibraryElement> libraries1,
    DiagnosticReporter reporter,
    Resolution resolution,
    LibraryProvider libraryProvider,
    {String outPath,
    bool prettyPrint}) {
  Serializer serializer = new Serializer();
  for (LibraryElement library1 in libraries1) {
    serializer.serialize(library1);
  }
  String text = serializer.toText(const JsonSerializationEncoder());
  String outText = text;
  if (prettyPrint) {
    outText = serializer.prettyPrint();
  }
  if (outPath != null) {
    new File(outPath).writeAsStringSync(outText);
  } else if (prettyPrint) {
    print(outText);
  }

  Deserializer deserializer = new Deserializer.fromText(
      new DeserializationContext(reporter, resolution, libraryProvider),
      Uri.parse('out1.data'),
      text,
      const JsonSerializationDecoder());
  List<LibraryElement> libraries2 = <LibraryElement>[];
  for (LibraryElement library1 in libraries1) {
    LibraryElement library2 = deserializer.lookupLibrary(library1.canonicalUri);
    if (library2 == null) {
      throw new ArgumentError('No library ${library1.canonicalUri} found.');
    }
    checkLibraryContent('library1', 'library2', 'library', library1, library2);
    libraries2.add(library2);
  }

  Serializer serializer2 = new Serializer();
  for (LibraryElement library2 in libraries2) {
    serializer2.serialize(library2);
  }
  String text2 = serializer2.toText(const JsonSerializationEncoder());

  Deserializer deserializer3 = new Deserializer.fromText(
      new DeserializationContext(reporter, resolution, libraryProvider),
      Uri.parse('out2.data'),
      text2,
      const JsonSerializationDecoder());
  for (LibraryElement library1 in libraries1) {
    LibraryElement library2 = deserializer.lookupLibrary(library1.canonicalUri);
    if (library2 == null) {
      throw new ArgumentError('No library ${library1.canonicalUri} found.');
    }
    LibraryElement library3 =
        deserializer3.lookupLibrary(library1.canonicalUri);
    if (library3 == null) {
      throw new ArgumentError('No library ${library1.canonicalUri} found.');
    }
    checkLibraryContent('library1', 'library3', 'library', library1, library3);
    checkLibraryContent('library2', 'library3', 'library', library2, library3);
  }
}

/// Check the equivalence of [library1] and [library2] and their content.
///
/// Uses [object1], [object2] and [property] to provide context for failures.
checkLibraryContent(Object object1, object2, String property,
    LibraryElement library1, LibraryElement library2) {
  checkElementProperties(object1, object2, property, library1, library2);
}

/// Check the equivalence of [element1] and [element2] and their properties.
///
/// Uses [object1], [object2] and [property] to provide context for failures.
checkElementProperties(Object object1, object2, String property,
    Element element1, Element element2) {
  currentCheck =
      new Check(currentCheck, object1, object2, property, element1, element2);
  const ElementPropertyEquivalence().visit(element1, element2);
  currentCheck = currentCheck.parent;
}

/// Checks the equivalence of [constructor1] and [constructor2].
void constantConstructorEquivalence(
    ConstantConstructor constructor1, ConstantConstructor constructor2) {
  const ConstantConstructorEquivalence().visit(constructor1, constructor2);
}

/// Visitor that checks the equivalence of [ConstantConstructor]s.
class ConstantConstructorEquivalence
    extends ConstantConstructorVisitor<dynamic, ConstantConstructor> {
  const ConstantConstructorEquivalence();

  @override
  void visit(
      ConstantConstructor constructor1, ConstantConstructor constructor2) {
    if (identical(constructor1, constructor2)) return;
    check(constructor1, constructor2, 'kind', constructor1.kind,
        constructor2.kind);
    constructor1.accept(this, constructor2);
  }

  @override
  visitGenerative(GenerativeConstantConstructor constructor1,
      GenerativeConstantConstructor constructor2) {
    ResolutionInterfaceType type1 = constructor1.type;
    ResolutionInterfaceType type2 = constructor2.type;
    checkTypes(constructor1, constructor2, 'type', type1, type2);
    check(constructor1, constructor2, 'defaultValues.length',
        constructor1.defaultValues.length, constructor2.defaultValues.length);
    constructor1.defaultValues.forEach((k, v) {
      checkConstants(constructor1, constructor2, 'defaultValue[$k]', v,
          constructor2.defaultValues[k]);
    });
    check(constructor1, constructor2, 'fieldMap.length',
        constructor1.fieldMap.length, constructor2.fieldMap.length);
    constructor1.fieldMap.forEach((k1, v1) {
      bool matched = false;
      constructor2.fieldMap.forEach((k2, v2) {
        if (k1.name == k2.name &&
            k1.library.canonicalUri == k2.library.canonicalUri) {
          checkElementIdentities(
              constructor1, constructor2, 'fieldMap[${k1.name}].key', k1, k2);
          checkConstants(
              constructor1, constructor2, 'fieldMap[${k1.name}].value', v1, v2);
          matched = true;
        }
      });
      if (!matched) {
        throw 'Unmatched field $k1 = $v1';
      }
    });
    checkConstants(
        constructor1,
        constructor2,
        'superConstructorInvocation',
        constructor1.superConstructorInvocation,
        constructor2.superConstructorInvocation);
  }

  @override
  visitRedirectingFactory(RedirectingFactoryConstantConstructor constructor1,
      RedirectingFactoryConstantConstructor constructor2) {
    checkConstants(
        constructor1,
        constructor2,
        'targetConstructorInvocation',
        constructor1.targetConstructorInvocation,
        constructor2.targetConstructorInvocation);
  }

  @override
  visitRedirectingGenerative(
      RedirectingGenerativeConstantConstructor constructor1,
      RedirectingGenerativeConstantConstructor constructor2) {
    check(constructor1, constructor2, 'defaultValues.length',
        constructor1.defaultValues.length, constructor2.defaultValues.length);
    constructor1.defaultValues.forEach((k, v) {
      checkConstants(constructor1, constructor2, 'defaultValue[$k]', v,
          constructor2.defaultValues[k]);
    });
    checkConstants(
        constructor1,
        constructor2,
        'thisConstructorInvocation',
        constructor1.thisConstructorInvocation,
        constructor2.thisConstructorInvocation);
  }

  @override
  visitErroneous(ErroneousConstantConstructor constructor1,
      ErroneousConstantConstructor constructor2) {
    throw new UnsupportedError("ConstantConstructorEquivalence.visitErroneous");
  }
}

/// Check the equivalence of the two lists of elements, [list1] and [list2].
///
/// Uses [object1], [object2] and [property] to provide context for failures.
checkElementLists(Object object1, Object object2, String property,
    Iterable<Element> list1, Iterable<Element> list2) {
  checkListEquivalence(
      object1, object2, property, list1, list2, checkElementProperties);
}

/// Check the equivalence of the two metadata annotations, [metadata1] and
/// [metadata2].
///
/// Uses [object1], [object2] and [property] to provide context for failures.
checkMetadata(Object object1, Object object2, String property,
    MetadataAnnotation metadata1, MetadataAnnotation metadata2) {
  check(object1, object2, property, metadata1, metadata2,
      areMetadataAnnotationsEquivalent);
}

/// Visitor that checks for equivalence of [Element] properties.
class ElementPropertyEquivalence extends BaseElementVisitor<dynamic, Element> {
  const ElementPropertyEquivalence();

  void visit(Element element1, Element element2) {
    if (element1 == null && element2 == null) return;
    if (element1 == null || element2 == null) {
      throw currentCheck;
    }
    element1 = element1.declaration;
    element2 = element2.declaration;
    if (element1 == element2) return;
    check(element1, element2, 'kind', element1.kind, element2.kind);
    element1.accept(this, element2);
    check(element1, element2, 'isSynthesized', element1.isSynthesized,
        element2.isSynthesized);
    check(element1, element2, 'isLocal', element1.isLocal, element2.isLocal);
    check(element1, element2, 'isFinal', element1.isFinal, element2.isFinal);
    check(element1, element2, 'isConst', element1.isConst, element2.isConst);
    check(element1, element2, 'isAbstract', element1.isAbstract,
        element2.isAbstract);
    check(element1, element2, 'isStatic', element1.isStatic, element2.isStatic);
    check(element1, element2, 'isTopLevel', element1.isTopLevel,
        element2.isTopLevel);
    check(element1, element2, 'isClassMember', element1.isClassMember,
        element2.isClassMember);
    check(element1, element2, 'isInstanceMember', element1.isInstanceMember,
        element2.isInstanceMember);
    List<MetadataAnnotation> metadata1 = <MetadataAnnotation>[];
    metadata1.addAll(element1.metadata);
    if (element1.isPatched) {
      metadata1.addAll(element1.implementation.metadata);
    }
    List<MetadataAnnotation> metadata2 = <MetadataAnnotation>[];
    metadata2.addAll(element2.metadata);
    if (element2.isPatched) {
      metadata2.addAll(element2.implementation.metadata);
    }
    checkListEquivalence(
        element1, element2, 'metadata', metadata1, metadata2, checkMetadata);
  }

  @override
  void visitElement(Element e, Element arg) {
    throw new UnsupportedError("Unsupported element $e");
  }

  @override
  void visitLibraryElement(LibraryElement element1, LibraryElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    check(element1, element2, 'name', element1.name, element2.name);
    check(element1, element2, 'libraryName', element1.libraryName,
        element2.libraryName);
    visitMembers(element1, element2);
    visit(element1.entryCompilationUnit, element2.entryCompilationUnit);

    checkElementLists(
        element1,
        element2,
        'compilationUnits',
        LibrarySerializer.getCompilationUnits(element1),
        LibrarySerializer.getCompilationUnits(element2));

    checkElementLists(
        element1,
        element2,
        'imports',
        LibrarySerializer.getImports(element1),
        LibrarySerializer.getImports(element2));
    checkElementLists(
        element1, element2, 'exports', element1.exports, element2.exports);

    List<Element> imported1 = LibrarySerializer.getImportedElements(element1);
    List<Element> imported2 = LibrarySerializer.getImportedElements(element2);
    checkElementListIdentities(
        element1, element2, 'importScope', imported1, imported2);

    checkElementListIdentities(
        element1,
        element2,
        'exportScope',
        LibrarySerializer.getExportedElements(element1),
        LibrarySerializer.getExportedElements(element2));

    for (int index = 0; index < imported1.length; index++) {
      checkImportsFor(element1, element2, imported1[index], imported2[index]);
    }
  }

  void checkImportsFor(
      Element element1, Element element2, Element import1, Element import2) {
    List<ImportElement> imports1 = element1.library.getImportsFor(import1);
    List<ImportElement> imports2 = element2.library.getImportsFor(import2);
    checkElementListIdentities(element1, element2,
        'importsFor($import1/$import2)', imports1, imports2);
  }

  @override
  void visitCompilationUnitElement(
      CompilationUnitElement element1, CompilationUnitElement element2) {
    checkElementIdentities(
        element1, element2, 'library', element1.library, element2.library);
    check(element1, element2, 'script.resourceUri', element1.script.resourceUri,
        element2.script.resourceUri);
    List<Element> members1 = <Element>[];
    List<Element> members2 = <Element>[];
    element1.forEachLocalMember((Element member) {
      members1.add(member);
    });
    element2.forEachLocalMember((Element member) {
      members2.add(member);
    });
    checkElementListIdentities(
        element1, element2, 'localMembers', members1, members2);
  }

  void visitMembers(
      ScopeContainerElement element1, ScopeContainerElement element2) {
    Set<String> names = new Set<String>();
    Iterable<Element> members1 = element1.isLibrary
        ? LibrarySerializer.getMembers(element1)
        : ClassSerializer.getMembers(element1);
    Iterable<Element> members2 = element2.isLibrary
        ? LibrarySerializer.getMembers(element2)
        : ClassSerializer.getMembers(element2);
    for (Element member in members1) {
      names.add(member.name);
    }
    for (Element member in members2) {
      names.add(member.name);
    }
    element1 = element1.implementation;
    element2 = element2.implementation;
    for (String name in names) {
      Element member1 = element1.localLookup(name);
      Element member2 = element2.localLookup(name);
      if (member1 == null) {
        String message =
            'Missing member for $member2 in\n ${members1.join('\n ')}';
        if (member2.isAbstractField) {
          // TODO(johnniwinther): Ensure abstract fields are handled correctly.
          //print(message);
          continue;
        } else {
          throw message;
        }
      }
      if (member2 == null) {
        String message =
            'Missing member for $member1 in\n ${members2.join('\n ')}';
        if (member1.isAbstractField) {
          // TODO(johnniwinther): Ensure abstract fields are handled correctly.
          //print(message);
          continue;
        } else {
          throw message;
        }
      }
      currentCheck = new Check(
          currentCheck, element1, element2, 'member:$name', member1, member2);
      visit(member1, member2);
      currentCheck = currentCheck.parent;
    }
  }

  @override
  void visitClassElement(ClassElement element1, ClassElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    check(element1, element2, 'name', element1.name, element2.name);
    if (!element1.isUnnamedMixinApplication) {
      check(element1, element2, 'sourcePosition', element1.sourcePosition,
          element2.sourcePosition);
    } else {
      check(element1, element2, 'sourcePosition.uri',
          element1.sourcePosition.uri, element2.sourcePosition.uri);
      MixinApplicationElement mixin1 = element1;
      MixinApplicationElement mixin2 = element2;
      checkElementIdentities(
          mixin1, mixin2, 'subclass', mixin1.subclass, mixin2.subclass);
      checkTypes(
          mixin1, mixin2, 'mixinType', mixin1.mixinType, mixin2.mixinType);
    }
    checkElementIdentities(
        element1, element2, 'library', element1.library, element2.library);
    checkElementIdentities(element1, element2, 'compilationUnit',
        element1.compilationUnit, element2.compilationUnit);
    checkTypeLists(element1, element2, 'typeVariables', element1.typeVariables,
        element2.typeVariables);
    checkTypes(
        element1, element2, 'thisType', element1.thisType, element2.thisType);
    checkTypes(
        element1, element2, 'rawType', element1.rawType, element2.rawType);
    check(element1, element2, 'isObject', element1.isObject, element2.isObject);
    checkTypeLists(element1, element2, 'typeVariables', element1.typeVariables,
        element2.typeVariables);
    check(element1, element2, 'isAbstract', element1.isAbstract,
        element2.isAbstract);
    check(element1, element2, 'isUnnamedMixinApplication',
        element1.isUnnamedMixinApplication, element2.isUnnamedMixinApplication);
    check(element1, element2, 'isProxy', element1.isProxy, element2.isProxy);
    check(element1, element2, 'isInjected', element1.isInjected,
        element2.isInjected);
    check(element1, element2, 'isEnumClass', element1.isEnumClass,
        element2.isEnumClass);
    if (element1.isEnumClass) {
      EnumClassElement enum1 = element1;
      EnumClassElement enum2 = element2;
      checkElementLists(
          enum1, enum2, 'enumValues', enum1.enumValues, enum2.enumValues);
    }
    if (!element1.isObject) {
      checkTypes(element1, element2, 'supertype', element1.supertype,
          element2.supertype);
    }
    check(element1, element2, 'hierarchyDepth', element1.hierarchyDepth,
        element2.hierarchyDepth);
    checkTypeLists(element1, element2, 'allSupertypes',
        element1.allSupertypes.toList(), element2.allSupertypes.toList());
    OrderedTypeSet typeSet1 = element1.allSupertypesAndSelf;
    OrderedTypeSet typeSet2 = element2.allSupertypesAndSelf;
    checkListEquivalence(element1, element2, 'allSupertypes',
        typeSet1.levelOffsets, typeSet2.levelOffsets, check);
    check(element1, element2, 'allSupertypesAndSelf.levels', typeSet1.levels,
        typeSet2.levels);
    checkTypeLists(element1, element2, 'supertypes',
        typeSet1.supertypes.toList(), typeSet2.supertypes.toList());
    checkTypeLists(element1, element2, 'types', typeSet1.types.toList(),
        typeSet2.types.toList());

    checkTypeLists(element1, element2, 'interfaces',
        element1.interfaces.toList(), element2.interfaces.toList());

    List<ConstructorElement> getConstructors(ClassElement cls) {
      return cls.implementation.constructors.map((c) => c.declaration).toList();
    }

    checkElementLists(element1, element2, 'constructors',
        getConstructors(element1), getConstructors(element2));

    checkElementIdentities(
        element1,
        element2,
        'defaultConstructor',
        element1.lookupDefaultConstructor(),
        element2.lookupDefaultConstructor());

    visitMembers(element1, element2);

    ClassElement superclass1 = element1.superclass;
    ClassElement superclass2 = element2.superclass;
    while (superclass1 != null && superclass1.isMixinApplication) {
      checkElementProperties(
          element1, element2, 'supermixin', superclass1, superclass2);
      superclass1 = superclass1.superclass;
      superclass2 = superclass2.superclass;
    }
  }

  @override
  void visitFieldElement(FieldElement element1, FieldElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    check(element1, element2, 'name', element1.name, element2.name);
    check(element1, element2, 'sourcePosition', element1.sourcePosition,
        element2.sourcePosition);
    checkTypes(element1, element2, 'type', element1.type, element2.type);
    checkConstants(
        element1, element2, 'constant', element1.constant, element2.constant);
    check(element1, element2, 'isTopLevel', element1.isTopLevel,
        element2.isTopLevel);
    check(element1, element2, 'isStatic', element1.isStatic, element2.isStatic);
    check(element1, element2, 'isInstanceMember', element1.isInstanceMember,
        element2.isInstanceMember);
    check(element1, element2, 'isInjected', element1.isInjected,
        element2.isInjected);

    checkElementIdentities(
        element1, element2, 'library', element1.library, element2.library);
    checkElementIdentities(element1, element2, 'compilationUnit',
        element1.compilationUnit, element2.compilationUnit);
    checkElementIdentities(element1, element2, 'enclosingClass',
        element1.enclosingClass, element2.enclosingClass);
  }

  @override
  void visitFunctionElement(
      FunctionElement element1, FunctionElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    check(element1, element2, 'name', element1.name, element2.name);
    check(element1, element2, 'sourcePosition', element1.sourcePosition,
        element2.sourcePosition);
    checkTypes(element1, element2, 'type', element1.type, element2.type);
    checkListEquivalence(element1, element2, 'parameters', element1.parameters,
        element2.parameters, checkElementProperties);
    check(element1, element2, 'isOperator', element1.isOperator,
        element2.isOperator);
    check(element1, element2, 'asyncMarker', element1.asyncMarker,
        element2.asyncMarker);
    check(element1, element2, 'isInjected', element1.isInjected,
        element2.isInjected);

    checkElementIdentities(
        element1, element2, 'library', element1.library, element2.library);
    checkElementIdentities(element1, element2, 'compilationUnit',
        element1.compilationUnit, element2.compilationUnit);
    checkElementIdentities(element1, element2, 'enclosingClass',
        element1.enclosingClass, element2.enclosingClass);

    check(
        element1,
        element2,
        'functionSignature.type',
        element1.functionSignature.type,
        element2.functionSignature.type,
        areTypesEquivalent);
    checkElementLists(
        element1,
        element2,
        'functionSignature.requiredParameters',
        element1.functionSignature.requiredParameters,
        element2.functionSignature.requiredParameters);
    checkElementLists(
        element1,
        element2,
        'functionSignature.optionalParameters',
        element1.functionSignature.optionalParameters,
        element2.functionSignature.optionalParameters);
    check(
        element1,
        element2,
        'functionSignature.requiredParameterCount',
        element1.functionSignature.requiredParameterCount,
        element2.functionSignature.requiredParameterCount);
    check(
        element1,
        element2,
        'functionSignature.optionalParameterCount',
        element1.functionSignature.optionalParameterCount,
        element2.functionSignature.optionalParameterCount);
    check(
        element1,
        element2,
        'functionSignature.optionalParametersAreNamed',
        element1.functionSignature.optionalParametersAreNamed,
        element2.functionSignature.optionalParametersAreNamed);
    check(
        element1,
        element2,
        'functionSignature.hasOptionalParameters',
        element1.functionSignature.hasOptionalParameters,
        element2.functionSignature.hasOptionalParameters);
    check(
        element1,
        element2,
        'functionSignature.parameterCount',
        element1.functionSignature.parameterCount,
        element2.functionSignature.parameterCount);
    checkElementLists(
        element1,
        element2,
        'functionSignature.orderedOptionalParameters',
        element1.functionSignature.orderedOptionalParameters,
        element2.functionSignature.orderedOptionalParameters);
    checkTypeLists(element1, element2, 'typeVariables', element1.typeVariables,
        element2.typeVariables);
  }

  @override
  void visitConstructorElement(
      ConstructorElement element1, ConstructorElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    checkElementIdentities(element1, element2, 'enclosingClass',
        element1.enclosingClass, element2.enclosingClass);
    check(element1, element2, 'name', element1.name, element2.name);
    if (!element1.isSynthesized) {
      check(element1, element2, 'sourcePosition', element1.sourcePosition,
          element2.sourcePosition);
    } else {
      check(element1, element2, 'sourcePosition.uri',
          element1.sourcePosition.uri, element2.sourcePosition.uri);
    }
    checkListEquivalence(element1, element2, 'parameters', element1.parameters,
        element2.parameters, checkElementProperties);
    checkTypes(element1, element2, 'type', element1.type, element2.type);
    check(element1, element2, 'isExternal', element1.isExternal,
        element2.isExternal);
    if (element1.isConst && !element1.isExternal) {
      constantConstructorEquivalence(
          element1.constantConstructor, element2.constantConstructor);
    }
    check(element1, element2, 'isRedirectingGenerative',
        element1.isRedirectingGenerative, element2.isRedirectingGenerative);
    check(element1, element2, 'isRedirectingFactory',
        element1.isRedirectingFactory, element2.isRedirectingFactory);
    checkElementIdentities(element1, element2, 'effectiveTarget',
        element1.effectiveTarget, element2.effectiveTarget);
    if (element1.isRedirectingFactory) {
      checkElementIdentities(
          element1,
          element2,
          'immediateRedirectionTarget',
          element1.immediateRedirectionTarget,
          element2.immediateRedirectionTarget);
      checkElementIdentities(
          element1,
          element2,
          'redirectionDeferredPrefix',
          element1.redirectionDeferredPrefix,
          element2.redirectionDeferredPrefix);
      check(
          element1,
          element2,
          'isEffectiveTargetMalformed',
          element1.isEffectiveTargetMalformed,
          element2.isEffectiveTargetMalformed);
    }
    checkElementIdentities(element1, element2, 'definingConstructor',
        element1.definingConstructor, element2.definingConstructor);
    check(
        element1,
        element2,
        'effectiveTargetType',
        element1.computeEffectiveTargetType(element1.enclosingClass.thisType),
        element2.computeEffectiveTargetType(element2.enclosingClass.thisType),
        areTypesEquivalent);
    check(
        element1,
        element2,
        'effectiveTargetType.raw',
        element1.computeEffectiveTargetType(element1.enclosingClass.rawType),
        element2.computeEffectiveTargetType(element2.enclosingClass.rawType),
        areTypesEquivalent);
    checkElementIdentities(
        element1,
        element2,
        'immediateRedirectionTarget',
        element1.immediateRedirectionTarget,
        element2.immediateRedirectionTarget);
    checkElementIdentities(element1, element2, 'redirectionDeferredPrefix',
        element1.redirectionDeferredPrefix, element2.redirectionDeferredPrefix);
    check(element1, element2, 'isInjected', element1.isInjected,
        element2.isInjected);
  }

  @override
  void visitAbstractFieldElement(
      AbstractFieldElement element1, AbstractFieldElement element2) {
    visit(element1.getter, element2.getter);
    visit(element1.setter, element2.setter);
  }

  @override
  void visitTypeVariableElement(
      TypeVariableElement element1, TypeVariableElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    check(element1, element2, 'name', element1.name, element2.name);
    check(element1, element2, 'sourcePosition', element1.sourcePosition,
        element2.sourcePosition);
    check(element1, element2, 'index', element1.index, element2.index);
    checkTypes(element1, element2, 'type', element1.type, element2.type);
    checkTypes(element1, element2, 'bound', element1.bound, element2.bound);
  }

  @override
  void visitTypedefElement(TypedefElement element1, TypedefElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    check(element1, element2, 'name', element1.name, element2.name);
    check(element1, element2, 'sourcePosition', element1.sourcePosition,
        element2.sourcePosition);
    checkTypes(element1, element2, 'alias', element1.alias, element2.alias);
    checkTypeLists(element1, element2, 'typeVariables', element1.typeVariables,
        element2.typeVariables);
    checkElementIdentities(
        element1, element2, 'library', element1.library, element2.library);
    checkElementIdentities(element1, element2, 'compilationUnit',
        element1.compilationUnit, element2.compilationUnit);
    // TODO(johnniwinther): Check the equivalence of typedef parameters.
  }

  @override
  void visitParameterElement(
      ParameterElement element1, ParameterElement element2) {
    checkElementIdentities(null, null, null, element1, element2);
    checkElementIdentities(element1, element2, 'functionDeclaration',
        element1.functionDeclaration, element2.functionDeclaration);
    check(element1, element2, 'name', element1.name, element2.name);
    check(element1, element2, 'sourcePosition', element1.sourcePosition,
        element2.sourcePosition);
    checkTypes(element1, element2, 'type', element1.type, element2.type);
    check(element1, element2, 'isOptional', element1.isOptional,
        element2.isOptional);
    check(element1, element2, 'isNamed', element1.isNamed, element2.isNamed);
    check(element1, element2, 'name', element1.name, element2.name);
    if (element1.isOptional) {
      checkConstants(
          element1, element2, 'constant', element1.constant, element2.constant);
    }
    checkElementIdentities(element1, element2, 'compilationUnit',
        element1.compilationUnit, element2.compilationUnit);
  }

  @override
  void visitFieldParameterElement(
      InitializingFormalElement element1, InitializingFormalElement element2) {
    visitParameterElement(element1, element2);
    checkElementIdentities(element1, element2, 'fieldElement',
        element1.fieldElement, element2.fieldElement);
  }

  @override
  void visitImportElement(ImportElement element1, ImportElement element2) {
    check(element1, element2, 'uri', element1.uri, element2.uri);
    check(element1, element2, 'isDeferred', element1.isDeferred,
        element2.isDeferred);
    checkElementProperties(
        element1, element2, 'prefix', element1.prefix, element2.prefix);
    checkElementIdentities(element1, element2, 'importedLibrary',
        element1.importedLibrary, element2.importedLibrary);
  }

  @override
  void visitExportElement(ExportElement element1, ExportElement element2) {
    check(element1, element2, 'uri', element1.uri, element2.uri);
    checkElementIdentities(element1, element2, 'importedLibrary',
        element1.exportedLibrary, element2.exportedLibrary);
  }

  @override
  void visitPrefixElement(PrefixElement element1, PrefixElement element2) {
    check(element1, element2, 'isDeferred', element1.isDeferred,
        element2.isDeferred);
    checkElementIdentities(element1, element2, 'deferredImport',
        element1.deferredImport, element2.deferredImport);
    if (element1.isDeferred) {
      checkElementProperties(element1, element2, 'loadLibrary',
          element1.loadLibrary, element2.loadLibrary);
    }
    element1.forEachLocalMember((Element member1) {
      String name = member1.name;
      Element member2 = element2.lookupLocalMember(name);
      checkElementIdentities(
          element1, element2, 'lookupLocalMember:$name', member1, member2);
      checkImportsFor(element1, element2, member1, member2);
    });
  }

  @override
  void visitErroneousElement(
      ErroneousElement element1, ErroneousElement element2) {
    check(element1, element2, 'messageKind', element1.messageKind,
        element2.messageKind);
  }
}