Function type aliases 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';
@@ skipping 87 matching lines @@
   visitBlockFunctionBody(BlockFunctionBody node) {
     // ignore bodies
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     String name = node.name.name;
     ClassElement element = _findElement(_enclosingUnit.types, name);
     _enclosingClass = element;
     _processElement(element);
+    _assertSameTypeParameters(node.typeParameters, element.typeParameters);
     // check for missing clauses
     if (node.extendsClause == null) {
       _assertTrue(element.supertype.name == 'Object');
     }
     if (node.implementsClause == null) {
       _assertTrue(element.interfaces.isEmpty);
     }
     if (node.withClause == null) {
       _assertTrue(element.mixins.isEmpty);
     }
     // process clauses and members
     _hasConstructor = false;
     super.visitClassDeclaration(node);
     // process default constructor
     if (!_hasConstructor) {
       ConstructorElement constructor = element.unnamedConstructor;
       _processElement(constructor);
       if (!constructor.isSynthetic) {
         _assertEquals(constructor.parameters.length, 0);
       }
     }
   }
 
   @override
   visitClassTypeAlias(ClassTypeAlias node) {
     String name = node.name.name;
     ClassElement element = _findElement(_enclosingUnit.types, name);
     _enclosingClass = element;
     _processElement(element);
+    _assertSameTypeParameters(node.typeParameters, element.typeParameters);
     _processElement(element.unnamedConstructor);
     super.visitClassTypeAlias(node);
   }
 
   @override
   visitCompilationUnit(CompilationUnit node) {
     _processElement(_enclosingUnit);
     super.visitCompilationUnit(node);
   }
 
@@ skipping 78 matching lines @@
     node.functionExpression.element = element;
     _assertFalse(element.isSynthetic);
     _assertSameType(node.returnType, element.returnType);
     _assertCompatibleParameters(
         node.functionExpression.parameters,
         element.parameters);
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
-    FunctionTypeAliasElement outerAlias = _enclosingAlias;
-    try {
-      SimpleIdentifier aliasName = node.name;
-      _enclosingAlias =
-          _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
-      _processElement(_enclosingAlias);
-      super.visitFunctionTypeAlias(node);
-    } finally {
-      _enclosingAlias = outerAlias;
-    }
+    String name = node.name.name;
+    FunctionTypeAliasElement element =
+        _findElement(_enclosingUnit.functionTypeAliases, name);
+    _processElement(element);
+    _assertSameTypeParameters(node.typeParameters, element.typeParameters);
+    _assertSameType(node.returnType, element.returnType);
+    _assertCompatibleParameters(node.parameters, element.parameters);
   }
 
   @override
   visitImplementsClause(ImplementsClause node) {
     List<TypeName> nodes = node.interfaces;
     List<InterfaceType> types = _enclosingClass.interfaces;
     _assertSameTypes(nodes, types);
   }
 
   @override
@@ skipping 56 matching lines @@
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _inTopLevelVariableDeclaration = true;
     try {
       super.visitTopLevelVariableDeclaration(node);
     } finally {
       _inTopLevelVariableDeclaration = false;
     }
   }
 
   @override
-  visitTypeParameter(TypeParameter node) {
-    String name = node.name.name;
-    TypeParameterElement element = null;
-    if (_enclosingClass != null) {
-      element = _findElement(_enclosingClass.typeParameters, name);
-    } else if (_enclosingAlias != null) {
-      element = _findElement(_enclosingAlias.typeParameters, name);
-    }
-    _processElement(element);
-    _assertSameType(node.bound, element.bound);
-  }
-
-  @override
   visitVariableDeclaration(VariableDeclaration node) {
     // prepare variable
     String name = node.name.name;
     PropertyInducingElement element;
     if (_inTopLevelVariableDeclaration) {
       element = _findElement(_enclosingUnit.topLevelVariables, name);
     } else {
       element = _findElement(_enclosingClass.fields, name);
     }
     // verify
@@ skipping 135 matching lines @@
       _assertEquals(nodeName, '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 _assertSameTypeParameter(TypeParameter node,
+      TypeParameterElement element) {
+    _assertSameType(node.bound, element.bound);
+  }
+
+  void _assertSameTypeParameters(TypeParameterList nodesList,
+      List<TypeParameterElement> elements) {
+    if (nodesList == null) {
+      return _assertEquals(elements.length, 0);
+    }
+    List<TypeParameter> nodes = nodesList.typeParameters;
+    int length = nodes.length;
+    _assertEquals(length, elements.length);
+    for (int i = 0; i < length; i++) {
+      _assertSameTypeParameter(nodes[i], elements[i]);
+    }
+  }
+
   void _assertSameTypes(List<TypeName> nodes, List<DartType> types) {
     int length = nodes.length;
     _assertEquals(length, types.length);
     for (int i = 0; i < length; i++) {
       _assertSameType(nodes[i], types[i]);
     }
   }
 
   void _assertTrue(bool condition) {
     if (!condition) {
@@ skipping 22 matching lines @@
         }
       } else if (parent is ParameterElement) {
         if (_enclosingParameter == null) {
           _enclosingParameter = parent as ParameterElement;
         }
       }
       parent = parent.enclosingElement;
     }
   }
 
-  /**
-   * Return the [Element] in [elements] with the given [name].
-   */
-  Element _findElement(List<Element> elements, String name) {
-    for (Element element in elements) {
-      if (element.name == name) {
-        return element;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Return the element in the given array of elements that was created for the declaration with the
-   * given name.
-   *
-   * @param elements the elements of the appropriate kind that exist in the current context
-   * @param identifier the name node in the declaration of the element to be returned
-   * @return the element created for the declaration with the given name
-   */
-  Element _findIdentifier(List<Element> elements,
-      SimpleIdentifier identifier) =>
-      _findWithNameAndOffset(elements, identifier.name, identifier.offset);
-
-  /**
-   * Return the element in the given array of elements that was created for the declaration with the
-   * given name at the given offset.
-   *
-   * @param elements the elements of the appropriate kind that exist in the current context
-   * @param name the name of the element to be returned
-   * @param offset the offset of the name of the element to be returned
-   * @return the element with the given name and offset
-   */
-  Element _findWithNameAndOffset(List<Element> elements, String name,
-      int offset) {
-    for (Element element in elements) {
-      if (element.displayName == name && element.nameOffset == offset) {
-        return element;
-      }
-    }
-    return null;
-  }
-
   void _gatherElements(Element element) {
     _ElementsGatherer gatherer = new _ElementsGatherer(this);
     element.accept(gatherer);
     // TODO(scheglov) what if a change in a directive?
     if (identical(element, _enclosingLibrary.definingCompilationUnit)) {
       gatherer.addElements(_enclosingLibrary.imports);
       gatherer.addElements(_enclosingLibrary.exports);
       gatherer.addElements(_enclosingLibrary.parts);
     }
   }
 
-  /**
-   * Return the value of the given string literal, or `null` if the string is not a constant
-   * string without any string interpolation.
-   *
-   * @param literal the string literal whose value is to be returned
-   * @return the value of the given string literal
-   */
-  String _getStringValue(StringLiteral literal) {
-    if (literal is StringInterpolation) {
-      return null;
-    }
-    return literal.stringValue;
-  }
-
   void _processElement(Element element) {
     _assertNotNull(element);
     if (!_allElements.contains(element)) {
       throw new _DeclarationMismatchException();
     }
     _unmatchedElements.remove(element);
   }
 
   /**
+   * Return the [Element] in [elements] with the given [name].
+   */
+  static Element _findElement(List<Element> elements, String name) {
+    for (Element element in elements) {
+      if (element.name == name) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  /**
    * Return the [UriReferencedElement] from [elements] with the given [uri], or
    * `null` if there is no such element.
    */
   static UriReferencedElement
       _findUriReferencedElement(List<UriReferencedElement> elements, String uri) {
     for (UriReferencedElement element in elements) {
       if (element.uri == uri) {
         return element;
       }
     }
     return null;
   }
+
+  /**
+   * Return the value of [literal], or `null` if the string is not a constant
+   * string without any string interpolation.
+   */
+  static String _getStringValue(StringLiteral literal) {
+    if (literal is StringInterpolation) {
+      return null;
+    }
+    return literal.stringValue;
+  }
 }
 
 
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The object used to access the types from the core library.
@@ skipping 687 matching lines @@
     _addElement(element);
     super.visitElement(element);
   }
 
   @override
   visitExecutableElement(ExecutableElement element) {
     _addElement(element);
   }
 
   @override
+  visitParameterElement(ParameterElement element) {
+  }
+
+  @override
   visitPropertyAccessorElement(PropertyAccessorElement element) {
     if (!element.isSynthetic) {
       _addElement(element);
     }
     // Don't visit children (such as synthetic setter parameters).
   }
 
   @override
   visitPropertyInducingElement(PropertyInducingElement element) {
     if (!element.isSynthetic) {
       _addElement(element);
     }
     // Don't visit children (such as property accessors).
   }
 
+  @override
+  visitTypeParameterElement(TypeParameterElement element) {
+  }
+
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._unmatchedElements.add(element);
     }
   }
 }
 
 
 /**
@@ skipping 45 matching lines @@
     _elements[node] = node.staticElement;
   }
 }
 
 
 class _TokenPair {
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.oldToken, this.newToken);
 }