Serialize ParameterElement.node and ParameterElement.initializer for type inference

pkg/compiler/lib/src/serialization/equivalence.dart

 // Copyright (c) 2016, 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.
 
 /// Functions for asserting equivalence across serialization.
 
 library dart2js.serialization.equivalence;
 
 import '../common.dart';
 import '../common/resolution.dart';
@@ skipping 258 matching lines @@
           areTypesEquivalent(ad.semantics.type, bd.semantics.type) &&
           areSelectorsEquivalent(ad.selector, bd.selector);
     case NewStructureKind.CONST_INVOKE:
       return ad.constantInvokeKind == bd.constantInvokeKind &&
           areConstantsEquivalent(ad.constant, bd.constant);
     case NewStructureKind.LATE_CONST:
       throw new UnsupportedError('Unsupported NewStructure kind ${a.kind}.');
   }
 }
 
+/// Returns `true` if nodes [a] and [b] are equivalent.
+bool areNodesEquivalent(Node node1, Node node2) {
+  if (identical(node1, node2)) return true;
+  if (node1 == null || node2 == null) return false;
+  return node1.accept1(const NodeEquivalenceVisitor(), node2);
+}
+
 /// Strategy for testing equivalence.
 ///
 /// Use this strategy to determine equivalence without failing on inequivalence.
 class TestStrategy {
   const TestStrategy();
 
   bool test(var object1, var object2, String property, var value1, var value2,
       [bool equivalence(a, b) = equality]) {
     return equivalence(value1, value2);
   }
@@ skipping 27 matching lines @@
 
   bool testTypeLists(Object object1, Object object2, String property,
       List<DartType> list1, List<DartType> list2) {
     return areTypeListsEquivalent(list1, list2);
   }
 
   bool testConstantLists(Object object1, Object object2, String property,
       List<ConstantExpression> list1, List<ConstantExpression> list2) {
     return areConstantListsEquivalent(list1, list2);
   }
+
+  bool testNodes(
+      Object object1, Object object2, String property, Node node1, Node node2) {
+    return areNodesEquivalent(node1, node2);
+  }
 }
 
 /// Visitor that checks for equivalence of [Element]s.
 class ElementIdentityEquivalence extends BaseElementVisitor<bool, Element> {
   final TestStrategy strategy;
 
   const ElementIdentityEquivalence([this.strategy = const TestStrategy()]);
 
   bool visit(Element element1, Element element2) {
     if (element1 == null && element2 == null) {
@@ skipping 422 matching lines @@
     ResolvedAst resolvedAst1, ResolvedAst resolvedAst2,
     [TestStrategy strategy = const TestStrategy()]) {
   if (!strategy.test(resolvedAst1, resolvedAst1, 'kind', resolvedAst1.kind,
       resolvedAst2.kind)) {
     return false;
   }
   if (resolvedAst1.kind != ResolvedAstKind.PARSED) {
     // Nothing more to check.
     return true;
   }
-  return strategy.testElements(resolvedAst1, resolvedAst2, 'element',
+  bool result = strategy.testElements(resolvedAst1, resolvedAst2, 'element',
           resolvedAst1.element, resolvedAst2.element) &&
-      new NodeEquivalenceVisitor(strategy).testNodes(resolvedAst1, resolvedAst2,
-          'node', resolvedAst1.node, resolvedAst2.node) &&
-      new NodeEquivalenceVisitor(strategy).testNodes(resolvedAst1, resolvedAst2,
-          'body', resolvedAst1.body, resolvedAst2.body) &&
+      strategy.testNodes(resolvedAst1, resolvedAst2, 'node', resolvedAst1.node,
+          resolvedAst2.node) &&
+      strategy.testNodes(resolvedAst1, resolvedAst2, 'body', resolvedAst1.body,
+          resolvedAst2.body) &&
       testTreeElementsEquivalence(resolvedAst1, resolvedAst2, strategy) &&
       strategy.test(resolvedAst1, resolvedAst2, 'sourceUri',
           resolvedAst1.sourceUri, resolvedAst2.sourceUri);
+  if (resolvedAst1.element is FunctionElement) {
+    FunctionElement element1 = resolvedAst1.element;
+    FunctionElement element2 = resolvedAst2.element;
+    for (int index = 0; index < element1.parameters.length; index++) {
+      var parameter1 = element1.parameters[index];
+      var parameter2 = element2.parameters[index];
+      result = result &&
+          strategy.testNodes(parameter1, parameter2, 'node',
+              parameter1.implementation.node, parameter2.implementation.node) &&
+          strategy.testNodes(
+              parameter1,
+              parameter2,
+              'initializer',
+              parameter1.implementation.initializer,
+              parameter2.implementation.initializer);
+    }
+  }
+  return result;
 }
 
 /// Tests the equivalence of the data stored in the [TreeElements] of
 /// [resolvedAst1] and [resolvedAst2] using [strategy].
 bool testTreeElementsEquivalence(
     ResolvedAst resolvedAst1, ResolvedAst resolvedAst2,
     [TestStrategy strategy = const TestStrategy()]) {
   AstIndexComputer indices1 = new AstIndexComputer();
   resolvedAst1.node.accept(indices1);
   AstIndexComputer indices2 = new AstIndexComputer();
@@ skipping 970 matching lines @@
   @override
   bool visitStatement(Statement node1, Statement node2) {
     throw new UnsupportedError('Unexpected nodes: $node1 <> $node2');
   }
 
   @override
   bool visitStringNode(StringNode node1, StringNode node2) {
     throw new UnsupportedError('Unexpected nodes: $node1 <> $node2');
   }
 }