Add compile_from_dill test

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';
 import 'package:compiler/src/common_elements.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/enqueue.dart';
 import 'package:compiler/src/js_backend/backend_usage.dart';
 import 'package:compiler/src/js_backend/native_data.dart';
 import 'package:compiler/src/js_backend/interceptor_data.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/universe/world_builder.dart';
 import 'package:compiler/src/world.dart';
 import 'check_helpers.dart';
 
 void checkClosedWorlds(ClosedWorld closedWorld1, ClosedWorld closedWorld2,
     {TestStrategy strategy: const TestStrategy(),
     bool allowExtra: false,
-    bool verbose: false}) {
+    bool verbose: false,
+    bool allowMissingClosureClasses: false}) {
   if (verbose) {
     print(closedWorld1.dump());
     print(closedWorld2.dump());
   }
   checkClassHierarchyNodes(
       closedWorld1,
       closedWorld2,
       closedWorld1
           .getClassHierarchyNode(closedWorld1.commonElements.objectClass),
       closedWorld2
           .getClassHierarchyNode(closedWorld2.commonElements.objectClass),
       strategy.elementEquivalence,
-      verbose: verbose);
+      verbose: verbose,
+      allowMissingClosureClasses: allowMissingClosureClasses);
 
   checkNativeData(closedWorld1.nativeData, closedWorld2.nativeData,
       strategy: strategy, allowExtra: allowExtra, verbose: verbose);
   checkInterceptorData(closedWorld1.interceptorData,
       closedWorld2.interceptorData, strategy.elementEquivalence,
       verbose: verbose);
 }
 
 void checkNativeData(NativeDataImpl data1, NativeDataImpl data2,
     {TestStrategy strategy: const TestStrategy(),
@@ skipping 92 matching lines @@
       data2.classesMixedIntoInterceptedClassesForTesting,
       elementEquivalence);
 }
 
 void checkClassHierarchyNodes(
     ClosedWorld closedWorld1,
     ClosedWorld closedWorld2,
     ClassHierarchyNode node1,
     ClassHierarchyNode node2,
     bool elementEquivalence(Entity a, Entity b),
-    {bool verbose: false}) {
+    {bool verbose: false,
+    bool allowMissingClosureClasses: false}) {
   if (verbose) {
     print('Checking $node1 vs $node2');
   }
   ClassEntity cls1 = node1.cls;
   ClassEntity cls2 = node2.cls;
   Expect.isTrue(elementEquivalence(cls1, cls2),
       "Element identity mismatch for ${cls1} vs ${cls2}.");
   Expect.equals(
       node1.isDirectlyInstantiated,
       node2.isDirectlyInstantiated,
       "Value mismatch for 'isDirectlyInstantiated' "
       "for ${cls1} vs ${cls2}.");
   Expect.equals(
       node1.isIndirectlyInstantiated,
       node2.isIndirectlyInstantiated,
       "Value mismatch for 'isIndirectlyInstantiated' "
       "for ${node1.cls} vs ${node2.cls}.");
   // TODO(johnniwinther): Enforce a canonical and stable order on direct
   // subclasses.
   for (ClassHierarchyNode child in node1.directSubclasses) {
     bool found = false;
     for (ClassHierarchyNode other in node2.directSubclasses) {
       ClassEntity child1 = child.cls;
       ClassEntity child2 = other.cls;
       if (elementEquivalence(child1, child2)) {
         checkClassHierarchyNodes(
             closedWorld1, closedWorld2, child, other, elementEquivalence,
-            verbose: verbose);
+            verbose: verbose,
+            allowMissingClosureClasses: allowMissingClosureClasses);
         found = true;
         break;
       }
     }
-    if (!found) {
+    if (!found && (!child.cls.isClosure || !allowMissingClosureClasses)) {
       if (child.isInstantiated) {
         print('Missing subclass ${child.cls} of ${node1.cls} '
             'in ${node2.directSubclasses}');
         print(closedWorld1.dump(
             verbose ? closedWorld1.commonElements.objectClass : node1.cls));
         print(closedWorld2.dump(
             verbose ? closedWorld2.commonElements.objectClass : node2.cls));
       }
       Expect.isFalse(
           child.isInstantiated,
@@ skipping 462 matching lines @@
       backendUsage1.isFunctionApplyUsed,
       backendUsage1.isFunctionApplyUsed,
       "JavaScriptBackend.hasFunctionApplySupport mismatch");
   Expect.equals(
       backendUsage1.isRuntimeTypeUsed,
       backendUsage2.isRuntimeTypeUsed,
       "JavaScriptBackend.hasRuntimeTypeSupport mismatch");
   Expect.equals(backendUsage1.isIsolateInUse, backendUsage2.isIsolateInUse,
       "JavaScriptBackend.hasIsolateSupport mismatch");
 }