Remove in-bodies analysis from DeclarationMatcher.

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 72 matching lines @@
     _gatherElements(element);
     try {
       node.accept(this);
     } on _DeclarationMismatchException catch (exception) {
       return false;
     }
     return _unmatchedElements.isEmpty;
   }
 
   @override
-  visitCatchClause(CatchClause node) {
-    SimpleIdentifier exceptionParameter = node.exceptionParameter;
-    if (exceptionParameter != null) {
-      List<LocalVariableElement> localVariables =
-          _enclosingExecutable.localVariables;
-      LocalVariableElement exceptionElement =
-          _findIdentifier(localVariables, exceptionParameter);
-      _processElement(exceptionElement);
-      SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
-      if (stackTraceParameter != null) {
-        LocalVariableElement stackTraceElement =
-            _findIdentifier(localVariables, stackTraceParameter);
-        _processElement(stackTraceElement);
-      }
-    }
-    super.visitCatchClause(node);
+  visitBlockFunctionBody(BlockFunctionBody node) {
+    // ignore bodies
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     String name = node.name.name;
     ClassElement clazz = _findElement(_enclosingUnit.types, name);
     _enclosingClass = clazz;
     _processElement(clazz);
     // check for missing clauses
     if (node.extendsClause == null) {
@@ skipping 49 matching lines @@
             _enclosingClass.getNamedConstructor(constructorName.name);
       }
       _processElement(_enclosingExecutable);
       super.visitConstructorDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
-  visitDeclaredIdentifier(DeclaredIdentifier node) {
-    SimpleIdentifier variableName = node.identifier;
-    LocalVariableElement element =
-        _findIdentifier(_enclosingExecutable.localVariables, variableName);
-    _processElement(element);
-    super.visitDeclaredIdentifier(node);
-  }
-
-  @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 {
@@ skipping 35 matching lines @@
       LibraryElement library = _enclosingUnit.library;
       ExportElement exportElement = _findExport(
           library.exports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
       _processElement(exportElement);
     }
     super.visitExportDirective(node);
   }
 
   @override
+  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;
@@ skipping 32 matching lines @@
         _enclosingExecutable = accessor;
       }
       _processElement(_enclosingExecutable);
       super.visitFunctionDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
-  visitFunctionExpression(FunctionExpression node) {
-    if (node.parent is! FunctionDeclaration) {
-      FunctionElement element =
-          _findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
-      _processElement(element);
-    }
-    ExecutableElement outerExecutable = _enclosingExecutable;
-    try {
-      _enclosingExecutable = node.element;
-      _processElement(_enclosingExecutable);
-      super.visitFunctionExpression(node);
-    } finally {
-      _enclosingExecutable = outerExecutable;
-    }
-  }
-
-  @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;
@@ skipping 33 matching lines @@
       ImportElement importElement = _findImport(
           library.imports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri),
           node.prefix);
       _processElement(importElement);
     }
     super.visitImportDirective(node);
   }
 
   @override
-  visitLabeledStatement(LabeledStatement node) {
-    for (Label label in node.labels) {
-      SimpleIdentifier labelName = label.label;
-      LabelElement element =
-          _findIdentifier(_enclosingExecutable.labels, labelName);
-      _processElement(element);
-    }
-    super.visitLabeledStatement(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-";
       }
@@ skipping 44 matching lines @@
         super.visitSimpleFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
     }
     super.visitSimpleFormalParameter(node);
   }
 
   @override
-  visitSwitchCase(SwitchCase node) {
-    for (Label label in node.labels) {
-      SimpleIdentifier labelName = label.label;
-      LabelElement element =
-          _findIdentifier(_enclosingExecutable.labels, labelName);
-      _processElement(element);
-    }
-    super.visitSwitchCase(node);
-  }
-
-  @override
-  visitSwitchDefault(SwitchDefault node) {
-    for (Label label in node.labels) {
-      SimpleIdentifier labelName = label.label;
-      LabelElement element =
-          _findIdentifier(_enclosingExecutable.labels, labelName);
-      _processElement(element);
-    }
-    super.visitSwitchDefault(node);
-  }
-
-  @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _inTopLevelVariableDeclaration = true;
     try {
       super.visitTopLevelVariableDeclaration(node);
     } finally {
       _inTopLevelVariableDeclaration = false;
     }
   }
 
   @override
@@ skipping 120 matching lines @@
       } else if (parent is ParameterElement) {
         if (_enclosingParameter == null) {
           _enclosingParameter = parent as ParameterElement;
         }
       }
       parent = parent.enclosingElement;
     }
   }
 
   /**
-   * Return the element in the given array of elements that was created for the declaration at the
-   * given offset. This method should only be used when there is no name
-   *
-   * @param elements the elements of the appropriate kind that exist in the current context
-   * @param offset the offset of the name of the element to be returned
-   * @return the element at the given offset
-   */
-  Element _findAtOffset(List<Element> elements, int offset) =>
-      _findWithNameAndOffset(elements, "", offset);
-
-  /**
    * Return the [Element] in [elements] with the given [name].
    */
   Element _findElement(List<Element> elements, String name) {
     for (Element element in elements) {
       if (element.displayName == name) {
         return element;
       }
     }
     return null;
   }
@@ skipping 207 matching lines @@
    *
    * [node] - the root of the AST structure to be resolved.
    */
   void resolve(AstNode node) {
     AstNode rootNode = _findResolutionRoot(node);
     Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
     if (_elementModelChanged(rootNode.parent)) {
       throw new AnalysisException("Cannot resolve node: element model changed");
     }
     _definingUnit.accept(
-        new _ElementNameOffsetUpdater(_updateOffset, _updateNewLength - _updateOldLength));
+        new _ElementNameOffsetUpdater(
+            _updateOffset,
+            _updateNewLength - _updateOldLength));
     _resolveTypes(node, scope);
     _resolveVariables(node, scope);
     _resolveReferences(node, scope);
   }
 
   /**
    * Return `true` if the given node can be resolved independently of any other
    * nodes.
    *
    * *Note*: This method needs to be kept in sync with
@@ skipping 225 matching lines @@
 
 /**
  * Instances of the class [_DeclarationMismatchException] represent an exception
  * that is thrown when the element model defined by a given AST structure does
  * not match an existing element model.
  */
 class _DeclarationMismatchException {
 }
 
 
+class _ElementNameOffsetUpdater extends GeneralizingElementVisitor {
+  final int updateOffset;
+  final int updateDelta;
+
+  _ElementNameOffsetUpdater(this.updateOffset, this.updateDelta);
+
+  @override
+  visitElement(Element element) {
+    int nameOffset = element.nameOffset;
+    if (nameOffset >= updateOffset) {
+      (element as ElementImpl).nameOffset = nameOffset + updateDelta;
+    }
+    super.visitElement(element);
+  }
+}
+
+
 class _ElementsGatherer extends GeneralizingElementVisitor {
   final DeclarationMatcher matcher;
 
   _ElementsGatherer(this.matcher);
 
   @override
   visitElement(Element element) {
     _addElement(element);
     super.visitElement(element);
   }
@@ skipping 23 matching lines @@
     }
   }
 
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._unmatchedElements.add(element);
     }
   }
 }
-
-
-class _ElementNameOffsetUpdater extends GeneralizingElementVisitor {
-  final int updateOffset;
-  final int updateDelta;
-
-  _ElementNameOffsetUpdater(this.updateOffset, this.updateDelta);
-
-  @override
-  visitElement(Element element) {
-    int nameOffset = element.nameOffset;
-    if (nameOffset >= updateOffset) {
-      (element as ElementImpl).nameOffset = nameOffset + updateDelta;
-    }
-    super.visitElement(element);
-  }
-}