Check emitter constants and fix tearOffName for JConstructorBody

tests/compiler/dart2js/equivalence/check_functions.dart

 // Copyright (c) 2017, 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.
 
 /// Equivalence test functions for data objects.
 
 library dart2js.equivalence.functions;
 
 import 'package:expect/expect.dart';
 import 'package:compiler/src/common/resolution.dart';
@@ skipping 785 matching lines @@
   checkMaps(
       worldBuilder1.instanceMemberUsageForTesting,
       worldBuilder2.instanceMemberUsageForTesting,
       'instanceMemberUsageForTesting',
       elementEquivalence,
       areAbstractUsagesEquivalent,
       verbose: verbose);
 }
 
 // TODO(johnniwinther): Check all emitter properties.
-void checkEmitters(CodeEmitterTask emitter1, CodeEmitterTask emitter2,
+void checkEmitters(
+    CodeEmitterTask emitter1, CodeEmitterTask emitter2, TestStrategy strategy,
     {bool elementEquivalence(Entity a, Entity b): _areEntitiesEquivalent,
     bool typeEquivalence(DartType a, DartType b): areTypesEquivalent,
     bool elementFilter(Element element),
     bool verbose: false}) {
-  checkEmitterPrograms(
-      emitter1.emitter.programForTesting, emitter2.emitter.programForTesting);
+  checkEmitterPrograms(emitter1.emitter.programForTesting,
+      emitter2.emitter.programForTesting, strategy);
 
   checkSets(
       emitter1.typeTestRegistry.rtiNeededClasses,
       emitter2.typeTestRegistry.rtiNeededClasses,
       "TypeTestRegistry rti needed classes mismatch",
-      elementEquivalence,
+      strategy.elementEquivalence,
       verbose: verbose);
 
   checkSets(
       emitter1.typeTestRegistry.checkedFunctionTypes,
       emitter2.typeTestRegistry.checkedFunctionTypes,
       "TypeTestRegistry checked function types mismatch",
-      typeEquivalence,
+      strategy.typeEquivalence,
       verbose: verbose);
 
   checkSets(
       emitter1.typeTestRegistry.checkedClasses,
       emitter2.typeTestRegistry.checkedClasses,
       "TypeTestRegistry checked classes mismatch",
-      elementEquivalence,
+      strategy.elementEquivalence,
       verbose: verbose);
 }
 
-void checkEmitterPrograms(Program program1, Program program2) {
+void checkEmitterPrograms(
+    Program program1, Program program2, TestStrategy strategy) {
   checkLists(program1.fragments, program2.fragments, 'fragments',
       (a, b) => a.outputFileName == b.outputFileName,
-      onSameElement: checkEmitterFragments);
+      onSameElement: (a, b) => checkEmitterFragments(a, b, strategy));
   checkLists(
       program1.holders, program2.holders, 'holders', (a, b) => a.name == b.name,
       onSameElement: checkEmitterHolders);
   check(program1, program2, 'outputContainsConstantList',
       program1.outputContainsConstantList, program2.outputContainsConstantList);
   check(program1, program2, 'needsNativeSupport', program1.needsNativeSupport,
       program2.needsNativeSupport);
   check(program1, program2, 'hasIsolateSupport', program1.hasIsolateSupport,
       program2.hasIsolateSupport);
   check(program1, program2, 'hasSoftDeferredClasses',
@@ skipping 12 matching lines @@
       program1,
       program2,
       'typeToInterceptorMap',
       program1.typeToInterceptorMap,
       program2.typeToInterceptorMap,
       areJsNodesEquivalent);
   check(program1, program2, 'metadata', program1.metadata, program2.metadata,
       areJsNodesEquivalent);
 }
 
-void checkEmitterFragments(Fragment fragment1, Fragment fragment2) {
+void checkEmitterFragments(
+    Fragment fragment1, Fragment fragment2, TestStrategy strategy) {
   // TODO(johnniwinther): Check outputUnit.
   checkLists(fragment1.libraries, fragment2.libraries, 'libraries',
       (a, b) => a.element.canonicalUri == b.element.canonicalUri,
-      onSameElement: checkEmitterLibraries);
+      onSameElement: (a, b) => checkEmitterLibraries(a, b, strategy));
   checkLists(fragment1.constants, fragment2.constants, 'constants',
       (a, b) => a.name.key == b.name.key,
-      onSameElement: checkEmitterConstants);
+      onSameElement: (a, b) => checkEmitterConstants(a, b, strategy));
   checkLists(fragment1.staticNonFinalFields, fragment2.staticNonFinalFields,
       'staticNonFinalFields', (a, b) => a.name.key == b.name.key,
       onSameElement: checkEmitterStaticFields);
   checkLists(
       fragment1.staticLazilyInitializedFields,
       fragment2.staticLazilyInitializedFields,
       'staticLazilyInitializedFields',
       (a, b) => a.name.key == b.name.key,
       onSameElement: checkEmitterStaticFields);
   check(fragment1, fragment2, 'isMainFragment', fragment1.isMainFragment,
       fragment2.isMainFragment);
   if (fragment1 is MainFragment && fragment2 is MainFragment) {
     check(fragment1, fragment2, 'invokeMain', fragment1.invokeMain,
         fragment2.invokeMain, areJsNodesEquivalent);
   }
 }
 
-void checkEmitterLibraries(Library library1, Library library2) {
+void checkEmitterLibraries(
+    Library library1, Library library2, TestStrategy strategy) {
   check(library1, library2, 'uri', library1.uri, library2.uri);
   checkLists(library1.classes, library2.classes, 'classes',
       (a, b) => a.element.name == b.element.name,
-      onSameElement: checkEmitterClasses);
+      onSameElement: (a, b) => checkEmitterClasses(a, b, strategy));
   checkLists(library1.statics, library2.statics, 'statics',
       (a, b) => a.name.key == b.name.key,
-      onSameElement: checkEmitterMethods);
+      onSameElement: (a, b) => checkEmitterMethods(a, b, strategy));
   checkLists(
       library1.staticFieldsForReflection,
       library2.staticFieldsForReflection,
       'staticFieldsForReflection',
       (a, b) => a.name.key == b.name.key,
       onSameElement: checkEmitterFields);
 }
 
-void checkEmitterClasses(Class class1, Class class2) {
+void checkEmitterClasses(Class class1, Class class2, TestStrategy strategy) {
   checkLists(class1.methods, class2.methods, 'methods',
       (a, b) => a.name.key == b.name.key,
-      onSameElement: checkEmitterMethods);
+      onSameElement: (a, b) => checkEmitterMethods(a, b, strategy));
   checkLists(class1.fields, class2.fields, 'fields',
       (a, b) => a.name.key == b.name.key,
       onSameElement: checkEmitterFields);
   checkLists(class1.isChecks, class2.isChecks, 'isChecks',
       (a, b) => a.name.key == b.name.key,
-      onSameElement: checkEmitterMethods);
+      onSameElement: (a, b) => checkEmitterMethods(a, b, strategy));
   checkLists(class1.checkedSetters, class2.checkedSetters, 'checkedSetters',
       (a, b) => a.name.key == b.name.key,
-      onSameElement: checkEmitterMethods);
+      onSameElement: (a, b) => checkEmitterMethods(a, b, strategy));
   checkLists(class1.callStubs, class2.callStubs, 'callStubs',
       (a, b) => a.name.key == b.name.key,
-      onSameElement: checkEmitterMethods);
+      onSameElement: (a, b) => checkEmitterMethods(a, b, strategy));
   checkLists(class1.noSuchMethodStubs, class2.noSuchMethodStubs,
       'noSuchMethodStubs', (a, b) => a.name.key == b.name.key,
-      onSameElement: checkEmitterMethods);
+      onSameElement: (a, b) => checkEmitterMethods(a, b, strategy));
   checkLists(class1.staticFieldsForReflection, class2.staticFieldsForReflection,
       'staticFieldsForReflection', (a, b) => a.name.key == b.name.key,
       onSameElement: checkEmitterFields);
 
   check(class1, class2, 'superclassName', class1.superclassName?.key,
       class2.superclassName?.key);
   check(class1, class2, 'isMixinApplication', class1.isMixinApplication,
       class2.isMixinApplication);
   check(class1, class2, 'hasRtiField', class1.hasRtiField, class2.hasRtiField);
   check(class1, class2, 'onlyForRti', class1.onlyForRti, class2.onlyForRti);
   check(class1, class2, 'isDirectlyInstantiated', class1.isDirectlyInstantiated,
       class2.isDirectlyInstantiated);
   check(class1, class2, 'isNative', class1.isNative, class2.isNative);
   check(class1, class2, 'isClosureBaseClass', class1.isClosureBaseClass,
       class2.isClosureBaseClass);
   check(class1, class2, 'isSoftDeferred', class1.isSoftDeferred,
       class2.isSoftDeferred);
   check(class1, class2, 'isEager', class1.isEager, class2.isEager);
   checkEmitterHolders(class1.holder, class2.holder);
 }
 
-void checkEmitterMethods(Method method1, Method method2) {
+void checkEmitterMethods(
+    Method method1, Method method2, TestStrategy strategy) {
   check(method1, method2, 'code', method1.code, method2.code,
       areJsNodesEquivalent);
   check(method1, method2, 'is ParameterStubMethod',
       method1 is ParameterStubMethod, method2 is ParameterStubMethod);
   if (method1 is ParameterStubMethod && method2 is ParameterStubMethod) {
     check(method1, method2, 'callName', method1.callName?.key,
         method2.callName?.key);
   }
   check(method1, method2, 'is DartMethod', method1 is DartMethod,
       method2 is DartMethod);
   if (method1 is DartMethod && method2 is DartMethod) {
     check(method1, method2, 'callName', method1.callName?.key,
         method2.callName?.key);
     check(method1, method2, 'needsTearOff', method1.needsTearOff,
         method2.needsTearOff);
-    // TODO(johnniwinther): Fix teadOffName mismatch.
-    //check(method1, method2, 'tearOffName',
-    //     method1.tearOffName?.key, method2.tearOffName?.key);
+    check(method1, method2, 'tearOffName', method1.tearOffName?.key,
+        method2.tearOffName?.key);
     checkLists(method1.parameterStubs, method2.parameterStubs, 'parameterStubs',
         (a, b) => a.name.key == b.name.key,
-        onSameElement: checkEmitterMethods);
+        onSameElement: (a, b) => checkEmitterMethods(a, b, strategy));
     check(method1, method2, 'canBeApplied', method1.canBeApplied,
         method2.canBeApplied);
     check(method1, method2, 'canBeReflected', method1.canBeReflected,
         method2.canBeReflected);
     check(method1, method2, 'functionType', method1.functionType,
         method2.functionType, areJsNodesEquivalent);
     check(method1, method2, 'requiredParameterCount',
         method1.requiredParameterCount, method2.requiredParameterCount);
-    // TODO(johnniwinther): Check optionalParameterDefaultValues.
+    if (method1.optionalParameterDefaultValues == null &&
+        method2.optionalParameterDefaultValues == null) {
+      // Nothing to test.
+    } else if (method1.optionalParameterDefaultValues is List &&
+        method2.optionalParameterDefaultValues is List) {
+      checkLists(
+          method1.optionalParameterDefaultValues,
+          method2.optionalParameterDefaultValues,
+          'optionalParameterDefaultValues',
+          strategy.constantValueEquivalence);
+    } else if (method1.optionalParameterDefaultValues is Map &&
+        method2.optionalParameterDefaultValues is Map) {
+      checkMaps(
+          method1.optionalParameterDefaultValues,
+          method2.optionalParameterDefaultValues,
+          'optionalParameterDefaultValues',
+          equality,
+          strategy.constantValueEquivalence);
+    } else {
+      check(
+          method1,
+          method2,
+          'optionalParameterDefaultValues',
+          method1.optionalParameterDefaultValues,
+          method2.optionalParameterDefaultValues);
+    }
   }
 }
 
 void checkEmitterFields(Field field1, Field field2) {
   check(field1, field2, 'accessorName', field1.accessorName?.key,
       field2.accessorName?.key);
   check(field1, field2, 'getterFlags', field1.getterFlags, field2.getterFlags);
   check(field1, field2, 'setterFlags', field1.setterFlags, field2.setterFlags);
   check(field1, field2, 'needsCheckedSetter', field1.needsCheckedSetter,
       field2.needsCheckedSetter);
 }
 
-void checkEmitterConstants(Constant constant1, Constant constant2) {
-  // TODO(johnniwinther): Check value.
+void checkEmitterConstants(
+    Constant constant1, Constant constant2, TestStrategy strategy) {
   checkEmitterHolders(constant1.holder, constant2.holder);
+  check(constant1, constant2, 'value', constant1.value, constant2.value,
+      strategy.constantValueEquivalence);
 }
 
 void checkEmitterStaticFields(StaticField field1, StaticField field2) {
   check(field1, field2, 'code', field1.code, field2.code, areJsNodesEquivalent);
   check(field1, field2, 'isFinal', field1.isFinal, field2.isFinal);
   check(field1, field2, 'isLazy', field1.isLazy, field2.isLazy);
   checkEmitterHolders(field1.holder, field2.holder);
 }
 
 void checkEmitterHolders(Holder holder1, Holder holder2) {
@@ skipping 54 matching lines @@
         print('  ${js.nodeToString(node1)}');
         print('  ${js.nodeToString(node2)}');
       }
       return expectedValue == label2;
     } else {
       labelsMap[label1] = label2;
       return true;
     }
   }
 }