Finish parameters matching.

pkg/analyzer/lib/src/generated/incremental_resolver.dart

 // Copyright (c) 2014, 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 engine.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/generated/error_verifier.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
 
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart';
 import 'error.dart';
 import 'java_engine.dart';
 import 'parser.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
@@ skipping 353 matching lines @@
           _assertTrue(hideNames.remove(name));
         }
       }
     }
     _assertTrue(showNames.isEmpty);
     _assertTrue(hideNames.isEmpty);
   }
 
   void _assertCompatibleParameter(FormalParameter node,
       ParameterElement element) {
+    _assertEquals(node.kind, element.parameterKind);
+    if (node.kind == ParameterKind.NAMED) {
+      _assertEquals(node.identifier.name, element.name);
+    }
+    // check parameter type specific properties
     if (node is DefaultFormalParameter) {
-      _assertTrue(element.isInitializingFormal);
-      // TODO(scheglov) check default value
+      Expression nodeDefault = node.defaultValue;
+      if (nodeDefault == null) {
+        _assertNull(element.defaultValueCode);
+      } else {
+        _assertEquals(nodeDefault.toSource(), element.defaultValueCode);
+      }
     } else if (node is FieldFormalParameter) {
       _assertTrue(element.isInitializingFormal);
+    } else if (node is FunctionTypedFormalParameter) {
+      _assertTrue(element.type is FunctionType);
+      FunctionType elementType = element.type;
+      _assertCompatibleParameters(node.parameters, element.parameters);
+      _assertSameType(node.returnType, elementType.returnType);
     } else if (node is SimpleFormalParameter) {
       _assertSameType(node.type, element.type);
       node.identifier.staticElement = element;
       (element as ElementImpl).nameOffset = node.identifier.offset;
       (element as ElementImpl).name = node.identifier.name;
-    } else {
-      // TODO(scheglov) support other parameter types
-//      print('node: $node  element: $element  ${element.runtimeType}');
-      _assertTrue(false);
     }
-    // TODO(scheglov) check names of named parameters
   }
 
   void _assertCompatibleParameters(FormalParameterList nodes,
       List<ParameterElement> elements) {
     if (nodes == null) {
       return _assertEquals(elements.length, 0);
     }
     List<FormalParameter> parameters = nodes.parameters;
     int length = parameters.length;
     _assertEquals(length, elements.length);
     for (int i = 0; i < length; i++) {
       _assertCompatibleParameter(parameters[i], elements[i]);
     }
   }
 
   void _assertEquals(Object a, Object b) {
     if (a != b) {
       throw new _DeclarationMismatchException();
     }
   }
 
   void _assertFalse(bool condition) {
     if (condition) {
       throw new _DeclarationMismatchException();
     }
   }
 
-  void _assertNotNull(Element element) {
-    if (element == null) {
+  void _assertNotNull(Object object) {
+    if (object == null) {
       throw new _DeclarationMismatchException();
     }
   }
 
-  void _assertNull(Element element) {
-    if (element != null) {
+  void _assertNull(Object object) {
+    if (object != null) {
       throw new _DeclarationMismatchException();
     }
   }
 
   void _assertSameType(TypeName node, DartType type) {
     // no return type == dynamic
     if (node == null) {
       return _assertTrue(type == null || type.isDynamic);
     }
     if (type == null) {
@@ skipping 982 matching lines @@
     _elements[node] = node.staticElement;
   }
 }
 
 
 class _TokenPair {
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.oldToken, this.newToken);
 }