Incremental improvements in parameters and types 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 'ast.dart';
 import 'element.dart';
 import 'error.dart';
 import 'java_engine.dart';
+import 'parser.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
-import 'parser.dart';
 
 
 /**
  * Attempts to update [oldUnit] to the state that would correspond to [newCode].
  * Returns `true` if success, or `false` otherwise.
  * The [oldUnit] might be damaged.
  */
 bool poorMansIncrementalResolution(TypeProvider typeProvider,
     CompilationUnit oldUnit, String newCode) {
   try {
@@ skipping 69 matching lines @@
       incrementalResolver.resolve(newNode);
       return true;
     }
   } catch (e) {
     // TODO(scheglov) find a way to log these exceptions
   }
   return false;
 }
 
 
-List<AstNode> _getParents(AstNode node) {
-  List<AstNode> parents = <AstNode>[];
-  while (node != null) {
-    parents.insert(0, node);
-    node = node.parent;
+bool _equalToken(Token oldToken, Token newToken, int delta) {
+  if (oldToken.type != newToken.type) {
+    return false;
   }
-  return parents;
-}
-
-AstNode _findNodeWithTokens(AstNode root, Token first, Token last) {
-  int offset = first.offset;
-  int end = last.end;
-  NodeLocator nodeLocator = new NodeLocator.con2(offset, end);
-  return nodeLocator.searchWithin(root);
+  if (newToken.offset - oldToken.offset != delta) {
+    return false;
+  }
+  return oldToken.lexeme == newToken.lexeme;
 }
 
 
-class _TokenPair {
-  final Token oldToken;
-  final Token newToken;
-  _TokenPair(this.oldToken, this.newToken);
-}
-
-
 _TokenPair _findFirstDifferentToken(Token oldToken, Token newToken) {
 //  print('first ------------');
   while (oldToken.type != TokenType.EOF && newToken.type != TokenType.EOF) {
 //    print('old: $oldToken @ ${oldToken.offset}');
 //    print('new: $newToken @ ${newToken.offset}');
     if (!_equalToken(oldToken, newToken, 0)) {
       return new _TokenPair(oldToken, newToken);
     }
     oldToken = oldToken.next;
     newToken = newToken.next;
@@ skipping 12 matching lines @@
       return new _TokenPair(oldToken.next, newToken.next);
     }
     oldToken.offset += delta;
     oldToken = oldToken.previous;
     newToken = newToken.previous;
   }
   return null;
 }
 
 
-bool _equalToken(Token a, Token b, int delta) {
-  if (a.type != b.type) {
-    return false;
-  }
-  if (b.offset - a.offset != delta) {
-    return false;
-  }
-  return a.lexeme == b.lexeme;
+AstNode _findNodeWithTokens(AstNode root, Token first, Token last) {
+  int offset = first.offset;
+  int end = last.end;
+  NodeLocator nodeLocator = new NodeLocator.con2(offset, end);
+  return nodeLocator.searchWithin(root);
 }
 
 
+List<AstNode> _getParents(AstNode node) {
+  List<AstNode> parents = <AstNode>[];
+  while (node != null) {
+    parents.insert(0, node);
+    node = node.parent;
+  }
+  return parents;
+}
+
+
 CompilationUnit _parseUnit(String code) {
   // TODO(scheglov) remember and update errors
   var errorListener = new BooleanErrorListener();
   var reader = new CharSequenceReader(code);
   var scanner = new Scanner(null, reader, errorListener);
   var token = scanner.tokenize();
   var parser = new Parser(null, errorListener);
   return parser.parseCompilationUnit(token);
 }
 
@@ skipping 363 matching lines @@
           _assertTrue(hideNames.remove(name));
         }
       }
     }
     _assertTrue(showNames.isEmpty);
     _assertTrue(hideNames.isEmpty);
   }
 
   void _assertCompatibleParameter(FormalParameter node,
       ParameterElement element) {
-    if (node is SimpleFormalParameter) {
+    if (node is DefaultFormalParameter) {
+      _assertTrue(element.isInitializingFormal);
+      // TODO(scheglov) check default value
+    } else if (node is FieldFormalParameter) {
+      _assertTrue(element.isInitializingFormal);
+    } 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);
     }
@@ skipping 27 matching lines @@
     if (element != 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) {
+      return _assertTrue(false);
+    }
     // check specific type kinds
     String nodeName = node.name.name;
     if (type is InterfaceType) {
       _assertEquals(nodeName, type.name);
       // check arguments
       TypeArgumentList nodeArgumentList = node.typeArguments;
       List<DartType> typeArguments = type.typeArguments;
       if (nodeArgumentList == null) {
-        _assertTrue(typeArguments.isEmpty);
+        // Node doesn't have type arguments, so all type argument of the
+        // element must be "dynamic".
+        for (DartType typeArgument in typeArguments) {
+          _assertTrue(typeArgument.isDynamic);
+        }
       } else {
         List<TypeName> nodeArguments = nodeArgumentList.arguments;
         _assertSameTypes(nodeArguments, typeArguments);
       }
     } else if (type is TypeParameterType) {
       _assertEquals(nodeName, type.name);
       // TODO(scheglov) it should be possible to rename type parameters
-    } else if (type is VoidType) {
+    } else if (type.isVoid) {
       _assertEquals(nodeName, 'void');
-      // TODO(scheglov) add test for "void"
+    } else if (type.isDynamic) {
+      _assertEquals(nodeName, 'dynamic');
     } else {
       // TODO(scheglov) support other types
 //      print('node: $node type: $type  type.type: ${type.runtimeType}');
       _assertTrue(false);
     }
   }
 
   void _assertSameTypes(List<TypeName> nodes, List<DartType> types) {
     int length = nodes.length;
     _assertEquals(length, types.length);
@@ skipping 613 matching lines @@
   visitFunctionExpression(FunctionExpression node) {
     _elements[node] = node.element;
     super.visitFunctionExpression(node);
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     _elements[node] = node.staticElement;
   }
 }
+
+
+class _TokenPair {
+  final Token oldToken;
+  final Token newToken;
+  _TokenPair(this.oldToken, this.newToken);
+}