Serialize and process patch metadata

tests/compiler/dart2js/serialization/model_test.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 dart2js.serialization_model_test;
+
 import 'dart:async';
 import 'dart:io';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/closure.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/filenames.dart';
+import 'package:compiler/src/js_backend/js_backend.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/tree/nodes.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import '../memory_compiler.dart';
 import 'helper.dart';
 import 'test_data.dart';
 import 'test_helper.dart';
 
 main(List<String> args) {
   asyncTest(() async {
@@ skipping 83 matching lines @@
       verbose: verbose);
 
   checkClassHierarchyNodes(
       compilerNormal,
       compilerDeserialized,
       compilerNormal.world.getClassHierarchyNode(
           compilerNormal.coreClasses.objectClass),
       compilerDeserialized.world.getClassHierarchyNode(
           compilerDeserialized.coreClasses.objectClass),
       verbose: verbose);
+
+  Expect.equals(compilerNormal.enabledInvokeOn,
+      compilerDeserialized.enabledInvokeOn,
+      "Compiler.enabledInvokeOn mismatch");
+  Expect.equals(compilerNormal.enabledFunctionApply,
+      compilerDeserialized.enabledFunctionApply,
+      "Compiler.enabledFunctionApply mismatch");
+  Expect.equals(compilerNormal.enabledRuntimeType,
+      compilerDeserialized.enabledRuntimeType,
+      "Compiler.enabledRuntimeType mismatch");
+  Expect.equals(compilerNormal.hasIsolateSupport,
+      compilerDeserialized.hasIsolateSupport,
+      "Compiler.hasIsolateSupport mismatch");
 }
 
 void checkElements(
     Compiler compiler1, Compiler compiler2,
     Element element1, Element element2,
     {bool verbose: false}) {
   if (element1.isFunction ||
       element1.isConstructor ||
       (element1.isField && element1.isInstanceMember)) {
     AstElement astElement1 = element1;
     AstElement astElement2 = element2;
     ClosureClassMap closureData1 =
-    compiler1.closureToClassMapper.computeClosureToClassMapping(
-        astElement1.resolvedAst);
+        compiler1.closureToClassMapper.computeClosureToClassMapping(
+            astElement1.resolvedAst);
     ClosureClassMap closureData2 =
-    compiler2.closureToClassMapper.computeClosureToClassMapping(
-        astElement2.resolvedAst);
+        compiler2.closureToClassMapper.computeClosureToClassMapping(
+            astElement2.resolvedAst);
 
     checkElementIdentities(closureData1, closureData2,
         '$element1.closureElement',
         closureData1.closureElement, closureData2.closureElement);
     checkElementIdentities(closureData1, closureData2,
         '$element1.closureClassElement',
         closureData1.closureClassElement, closureData2.closureClassElement);
     checkElementIdentities(closureData1, closureData2,
         '$element1.callElement',
         closureData1.callElement, closureData2.callElement);
@@ skipping 16 matching lines @@
         areClosureScopesEquivalent,
         verbose: verbose,
         keyToString: nodeToString);
     checkSets(
         closureData1.variablesUsedInTryOrGenerator,
         closureData2.variablesUsedInTryOrGenerator,
         "$element1.variablesUsedInTryOrGenerator",
         areLocalsEquivalent,
         verbose: verbose);
   }
+  JavaScriptBackend backend1 = compiler1.backend;
+  JavaScriptBackend backend2 = compiler2.backend;
+  Expect.equals(
+      backend1.inlineCache.getCurrentCacheDecisionForTesting(element1),
+      backend2.inlineCache.getCurrentCacheDecisionForTesting(element2),
+      "Inline cache decision mismatch for $element1 vs $element2");
 }
 
 void checkMixinUses(
     Compiler compiler1, Compiler compiler2,
     ClassElement class1, ClassElement class2,
     {bool verbose: false}) {
 
   checkSets(
       compiler1.world.mixinUsesOf(class1),
       compiler2.world.mixinUsesOf(class2),
@@ skipping 94 matching lines @@
   return true;
 }
 
 String nodeToString(Node node) {
   String text = '$node';
   if (text.length > 40) {
     return '(${node.runtimeType}) ${text.substring(0, 37)}...';
   }
   return '(${node.runtimeType}) $text';
 }