Matching fields, some parameters, ignore locals.

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 'ast.dart';
 import 'element.dart';
@@ skipping 20 matching lines @@
    */
   FunctionTypeAliasElement _enclosingAlias;
 
   /**
    * The class containing the AST nodes being visited, or `null` if we are not in the scope of
    * a class.
    */
   ClassElement _enclosingClass;
 
   /**
-   * The method or function containing the AST nodes being visited, or `null` if we are not in
-   * the scope of a method or function.
-   */
-  ExecutableElement _enclosingExecutable;
-
-  /**
    * The parameter containing the AST nodes being visited, or `null` if we are not in the
    * scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
+  FieldDeclaration _enclosingFieldNode = null;
   bool _inTopLevelVariableDeclaration = false;
 
   /**
    * Is `true` if the current class declaration has a constructor.
    */
   bool _hasConstructor = false;
 
   /**
    * A set containing all of the elements in the element model that were defined by the old AST node
    * corresponding to the AST node being visited.
@@ skipping 76 matching lines @@
 
   @override
   visitCompilationUnit(CompilationUnit node) {
     _processElement(_enclosingUnit);
     super.visitCompilationUnit(node);
   }
 
   @override
   visitConstructorDeclaration(ConstructorDeclaration node) {
     _hasConstructor = true;
-    ExecutableElement outerExecutable = _enclosingExecutable;
-    try {
-      SimpleIdentifier constructorName = node.name;
-      if (constructorName == null) {
-        _enclosingExecutable = _enclosingClass.unnamedConstructor;
-      } else {
-        _enclosingExecutable =
-            _enclosingClass.getNamedConstructor(constructorName.name);
-      }
-      _processElement(_enclosingExecutable);
-      super.visitConstructorDeclaration(node);
-    } finally {
-      _enclosingExecutable = outerExecutable;
-    }
+    SimpleIdentifier constructorName = node.name;
+    ConstructorElement element = constructorName == null ?
+        _enclosingClass.unnamedConstructor :
+        _enclosingClass.getNamedConstructor(constructorName.name);
+    _processElement(element);
+    _assertCompatibleParameters(node.parameters, element.parameters);
   }
 
   @override
-  visitDefaultFormalParameter(DefaultFormalParameter node) {
-    SimpleIdentifier parameterName = node.parameter.identifier;
-    ParameterElement element = _getElementForParameter(node, parameterName);
-    Expression defaultValue = node.defaultValue;
-    if (defaultValue != null) {
-      ExecutableElement outerExecutable = _enclosingExecutable;
-      try {
-        if (element == null) {
-          // TODO(brianwilkerson) Report this internal error.
-        } else {
-          _enclosingExecutable = element.initializer;
-        }
-        defaultValue.accept(this);
-      } finally {
-        _enclosingExecutable = outerExecutable;
-      }
-      _processElement(_enclosingExecutable);
-    }
-    ParameterElement outerParameter = _enclosingParameter;
-    try {
-      _enclosingParameter = element;
-      _processElement(_enclosingParameter);
-      super.visitDefaultFormalParameter(node);
-    } finally {
-      _enclosingParameter = outerParameter;
-    }
-  }
-
-  @override
   visitEnumDeclaration(EnumDeclaration node) {
     ClassElement enclosingEnum =
         _findIdentifier(_enclosingUnit.enums, node.name);
     _processElement(enclosingEnum);
     List<FieldElement> constants = enclosingEnum.fields;
     for (EnumConstantDeclaration constant in node.constants) {
       FieldElement constantElement = _findIdentifier(constants, constant.name);
       _processElement(constantElement);
     }
     super.visitEnumDeclaration(node);
@@ skipping 16 matching lines @@
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     // ignore bodies
   }
 
   @override
   visitExtendsClause(ExtendsClause node) {
     _assertSameType(node.superclass, _enclosingClass.supertype);
   }
 
   @override
-  visitFieldFormalParameter(FieldFormalParameter node) {
-    if (node.parent is! DefaultFormalParameter) {
-      SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = _getElementForParameter(node, parameterName);
-      ParameterElement outerParameter = _enclosingParameter;
-      try {
-        _enclosingParameter = element;
-        _processElement(_enclosingParameter);
-        super.visitFieldFormalParameter(node);
-      } finally {
-        _enclosingParameter = outerParameter;
-      }
-    } else {
-      super.visitFieldFormalParameter(node);
+  visitFieldDeclaration(FieldDeclaration node) {
+    _enclosingFieldNode = node;
+    try {
+      super.visitFieldDeclaration(node);
+    } finally {
+      _enclosingFieldNode = null;
     }
   }
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
-    ExecutableElement outerExecutable = _enclosingExecutable;
-    try {
-      SimpleIdentifier functionName = node.name;
-      Token property = node.propertyKeyword;
-      if (property == null) {
-        if (_enclosingExecutable != null) {
-          _enclosingExecutable =
-              _findIdentifier(_enclosingExecutable.functions, functionName);
-        } else {
-          _enclosingExecutable =
-              _findIdentifier(_enclosingUnit.functions, functionName);
-        }
-      } else {
-        PropertyAccessorElement accessor =
-            _findIdentifier(_enclosingUnit.accessors, functionName);
-        if ((property as KeywordToken).keyword == Keyword.SET) {
-          accessor = accessor.variable.setter;
-        }
-        _enclosingExecutable = accessor;
-      }
-      _processElement(_enclosingExecutable);
-      super.visitFunctionDeclaration(node);
-    } finally {
-      _enclosingExecutable = outerExecutable;
+    String name = node.name.name;
+    Token property = node.propertyKeyword;
+    ExecutableElement element;
+    if (property == null) {
+      element = _findElement(_enclosingUnit.functions, name);
+      _processElement(element);
+    } else {
+      PropertyAccessorElement accessor =
+          _findElement(_enclosingUnit.accessors, name);
+      _assertNotNull(accessor);
+      _assertFalse(element.isSynthetic);
+      _assertEquals(node.isGetter, accessor.isGetter);
+      _assertEquals(node.isSetter, accessor.isSetter);
+      element = accessor;
     }
+    _processElement(element);
+    // TODO(scheglov) test returnType
+    _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;
     }
   }
 
   @override
-  visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
-    if (node.parent is! DefaultFormalParameter) {
-      SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = _getElementForParameter(node, parameterName);
-      ParameterElement outerParameter = _enclosingParameter;
-      try {
-        _enclosingParameter = element;
-        _processElement(_enclosingParameter);
-        super.visitFunctionTypedFormalParameter(node);
-      } finally {
-        _enclosingParameter = outerParameter;
-      }
-    } else {
-      super.visitFunctionTypedFormalParameter(node);
-    }
-  }
-
-  @override
   visitImplementsClause(ImplementsClause node) {
     List<TypeName> nodes = node.interfaces;
     List<InterfaceType> types = _enclosingClass.interfaces;
     _assertSameTypes(nodes, types);
   }
 
   @override
   visitImportDirective(ImportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
       ImportElement importElement = _findImport(
           library.imports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri),
           node.prefix);
       _processElement(importElement);
     }
     super.visitImportDirective(node);
   }
 
   @override
   visitMethodDeclaration(MethodDeclaration node) {
-    ExecutableElement outerExecutable = _enclosingExecutable;
-    try {
-      Token property = node.propertyKeyword;
-      SimpleIdentifier methodName = node.name;
-      String nameOfMethod = methodName.name;
-      if (nameOfMethod == TokenType.MINUS.lexeme &&
-          node.parameters.parameters.length == 0) {
-        nameOfMethod = "unary-";
-      }
-      if (property == null) {
-        _enclosingExecutable = _findWithNameAndOffset(
-            _enclosingClass.methods,
-            nameOfMethod,
-            methodName.offset);
-        methodName.staticElement = _enclosingExecutable;
-      } else {
-        PropertyAccessorElement accessor =
-            _findIdentifier(_enclosingClass.accessors, methodName);
-        if ((property as KeywordToken).keyword == Keyword.SET) {
-          accessor = accessor.variable.setter;
-          methodName.staticElement = accessor;
-        }
-        _enclosingExecutable = accessor;
-      }
-      _processElement(_enclosingExecutable);
-      super.visitMethodDeclaration(node);
-    } finally {
-      _enclosingExecutable = outerExecutable;
+    // prepare element name
+    String name = node.name.name;
+    if (name == TokenType.MINUS.lexeme &&
+        node.parameters.parameters.length == 0) {
+      name = "unary-";
     }
+    // prepare element
+    Token property = node.propertyKeyword;
+    ExecutableElement element;
+    if (property == null) {
+      element = _findElement(_enclosingClass.methods, name);
+    } else {
+      PropertyAccessorElement accessor =
+          _findElement(_enclosingClass.accessors, name);
+      _assertNotNull(accessor);
+      _assertFalse(element.isSynthetic);
+      _assertEquals(node.isGetter, accessor.isGetter);
+      _assertEquals(node.isSetter, accessor.isSetter);
+      element = accessor;
+    }
+    // process element
+    _processElement(element);
+    // TODO(scheglov) test returnType
+    _assertSameType(node.returnType, element.returnType);
+    _assertCompatibleParameters(node.parameters, element.parameters);
   }
 
   @override
   visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       Source partSource =
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
       CompilationUnitElement element =
           _findPart(_enclosingUnit.library.parts, partSource);
       _processElement(element);
     }
     super.visitPartDirective(node);
   }
 
   @override
-  visitSimpleFormalParameter(SimpleFormalParameter node) {
-    if (node.parent is! DefaultFormalParameter) {
-      SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = _getElementForParameter(node, parameterName);
-      ParameterElement outerParameter = _enclosingParameter;
-      try {
-        _enclosingParameter = element;
-        _processElement(_enclosingParameter);
-        super.visitSimpleFormalParameter(node);
-      } finally {
-        _enclosingParameter = outerParameter;
-      }
-    } else {
-    }
-    super.visitSimpleFormalParameter(node);
-  }
-
-  @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _inTopLevelVariableDeclaration = true;
     try {
       super.visitTopLevelVariableDeclaration(node);
     } finally {
       _inTopLevelVariableDeclaration = false;
     }
   }
 
   @override
   visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeParameterElement element = null;
     if (_enclosingClass != null) {
       element = _findIdentifier(_enclosingClass.typeParameters, parameterName);
     } else if (_enclosingAlias != null) {
       element = _findIdentifier(_enclosingAlias.typeParameters, parameterName);
     }
     _processElement(element);
     super.visitTypeParameter(node);
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
+    // prepare variable
     String name = node.name.name;
+    PropertyInducingElement variable;
     if (_inTopLevelVariableDeclaration) {
-      TopLevelVariableElement variable =
-          _findElement(_enclosingUnit.topLevelVariables, name);
-      _assertNotNull(variable);
-      _assertFalse(variable.isSynthetic);
-      _assertEquals(node.isConst, variable.isConst);
-      _assertEquals(node.isFinal, variable.isFinal);
-      _assertSameType(
-          (node.parent as VariableDeclarationList).type,
-          variable.type);
-      _processElement(variable);
-      return;
+      variable = _findElement(_enclosingUnit.topLevelVariables, name);
+    } else {
+      variable = _findElement(_enclosingClass.fields, name);
     }
-    VariableElement element;
-    if (_enclosingExecutable != null) {
-      element = _findElement(_enclosingExecutable.localVariables, name);
+    // verify
+    _assertNotNull(variable);
+    _processElement(variable);
+    _assertEquals(node.isConst, variable.isConst);
+    _assertEquals(node.isFinal, variable.isFinal);
+    if (_enclosingFieldNode != null) {
+      _assertEquals(_enclosingFieldNode.isStatic, variable.isStatic);
     }
-    if (element == null && _enclosingClass != null) {
-      element = _findElement(_enclosingClass.fields, name);
-    }
-    super.visitVariableDeclaration(node);
+    _assertSameType(
+        (node.parent as VariableDeclarationList).type,
+        variable.type);
   }
 
   @override
   visitWithClause(WithClause node) {
     List<TypeName> nodes = node.mixinTypes;
     List<InterfaceType> types = _enclosingClass.mixins;
     _assertSameTypes(nodes, types);
   }
 
+  void _assertCompatibleParameter(FormalParameter node,
+      ParameterElement element) {
+    if (node is SimpleFormalParameter) {
+      _assertSameType(node.type, element.type);
+    } else {
+      // TODO(scheglov) support other parameter types
+      _assertTrue(false);
+    }
+    // TODO(scheglov) check names of named parameters
+  }
+
+  void _assertCompatibleParameters(FormalParameterList nodes,
+      List<ParameterElement> elements) {
+    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) {
       throw new _DeclarationMismatchException();
     }
   }
 
   void _assertSameType(TypeName node, DartType type) {
+    // no return type == dynamic
+    if (node == null) {
+      return _assertTrue(type.isDynamic);
+    }
+    // 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);
       } else {
         List<TypeName> nodeArguments = nodeArgumentList.arguments;
         _assertSameTypes(nodeArguments, typeArguments);
       }
     } else {
       // TODO(scheglov) support other types
       _assertTrue(false);
     }
   }
 
-  void _assertSameTypes(List<TypeName> nodes, List<DartType> type) {
+  void _assertSameTypes(List<TypeName> nodes, List<DartType> types) {
     int length = nodes.length;
-    _assertEquals(length, type.length);
+    _assertEquals(length, types.length);
     for (int i = 0; i < length; i++) {
-      _assertSameType(nodes[i], type[i]);
+      _assertSameType(nodes[i], types[i]);
     }
   }
 
   void _assertTrue(bool condition) {
     if (!condition) {
       throw new _DeclarationMismatchException();
     }
   }
 
   /**
    * Given that the comparison is to begin with the given element, capture the enclosing elements
    * that might be used while performing the comparison.
    *
    * @param element the element corresponding to the AST structure to be compared
    */
   void _captureEnclosingElements(Element element) {
     Element parent =
         element is CompilationUnitElement ? element : element.enclosingElement;
     while (parent != null) {
       if (parent is CompilationUnitElement) {
         _enclosingUnit = parent as CompilationUnitElement;
       } else if (parent is ClassElement) {
         if (_enclosingClass == null) {
           _enclosingClass = parent as ClassElement;
         }
       } else if (parent is FunctionTypeAliasElement) {
         if (_enclosingAlias == null) {
           _enclosingAlias = parent as FunctionTypeAliasElement;
         }
-      } else if (parent is ExecutableElement) {
-        if (_enclosingExecutable == null) {
-          _enclosingExecutable = parent as ExecutableElement;
-        }
       } else if (parent is ParameterElement) {
         if (_enclosingParameter == null) {
           _enclosingParameter = parent as ParameterElement;
         }
       }
       parent = parent.enclosingElement;
     }
   }
 
   /**
@@ skipping 103 matching lines @@
       }
     }
     return null;
   }
 
   void _gatherElements(Element element) {
     element.accept(new _ElementsGatherer(this));
   }
 
   /**
-   * Search the most closely enclosing list of parameters for a parameter with the given name.
-   *
-   * @param node the node defining the parameter with the given name
-   * @param parameterName the name of the parameter being searched for
-   * @return the element representing the parameter with that name
-   */
-  ParameterElement _getElementForParameter(FormalParameter node,
-      SimpleIdentifier parameterName) {
-    List<ParameterElement> parameters = null;
-    if (_enclosingParameter != null) {
-      parameters = _enclosingParameter.parameters;
-    }
-    if (parameters == null && _enclosingExecutable != null) {
-      parameters = _enclosingExecutable.parameters;
-    }
-    if (parameters == null && _enclosingAlias != null) {
-      parameters = _enclosingAlias.parameters;
-    }
-    return parameters == null ?
-        null :
-        _findIdentifier(parameters, parameterName);
-  }
-
-  /**
    * 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;
     }
@@ skipping 347 matching lines @@
 
   _ElementsGatherer(this.matcher);
 
   @override
   visitElement(Element element) {
     _addElement(element);
     super.visitElement(element);
   }
 
   @override
+  visitExecutableElement(ExecutableElement element) {
+    _addElement(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).
   }
 
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._unmatchedElements.add(element);
     }
   }
 }