More improvements to DeclarationResolver.

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

 // Copyright (c) 2016, 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 analyzer.src.generated.declaration_resolver;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 47 matching lines @@
     // in which case the elements are disconnected from the rest of the element
     // model, thus we can't reconnect to them.  To avoid crashes, just create
     // fresh elements.
     ElementHolder elementHolder = new ElementHolder();
     new ElementBuilder(elementHolder, _enclosingUnit).visitAnnotation(node);
     return null;
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
-    SimpleIdentifier exceptionParameter = node.exceptionParameter;
-    if (exceptionParameter != null) {
-      _match(exceptionParameter, _walker.getVariable());
-      SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
-      if (stackTraceParameter != null) {
-        _match(stackTraceParameter, _walker.getVariable());
-      }
-    }
+    _walker.elementBuilder.buildCatchVariableElements(node);
     return super.visitCatchClause(node);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement element = _match(node.name, _walker.getClass());
     _walk(new ElementWalker.forClass(element), () {
       super.visitClassDeclaration(node);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = _match(node.name, _walker.getClass());
     _walk(new ElementWalker.forClass(element), () {
       super.visitClassTypeAlias(node);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
-    ConstructorElement element = _match(node.name, _walker.getConstructor());
-    _walk(new ElementWalker.forExecutable(element), () {
+    ConstructorElement element = _match(node.name, _walker.getConstructor(),
+        offset: node.name?.offset ?? node.returnType.offset);
+    _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
       node.element = element;
       super.visitConstructorDeclaration(node);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
-    VariableElement element = _match(node.identifier, _walker.getVariable());
-    super.visitDeclaredIdentifier(node);
-    _resolveMetadata(node, node.metadata, element);
+    // Declared identifiers can only occur inside executable elements.
+    _walker.elementBuilder.visitDeclaredIdentifier(node);
     return null;
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     ParameterElement element =
         _match(node.parameter.identifier, _walker.getParameter());
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
-      _walk(new ElementWalker.forExecutable(element.initializer), () {
+      _walk(
+          new ElementWalker.forExecutable(element.initializer, _enclosingUnit),
+          () {
         defaultValue.accept(this);
       });
     }
     _walk(new ElementWalker.forParameter(element), () {
       node.parameter.accept(this);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
@@ skipping 52 matching lines @@
         element = _match(functionName, _walker.getFunction());
       } else if (property.keyword == Keyword.GET) {
         element = _match(functionName, _walker.getAccessor());
       } else {
         assert(property.keyword == Keyword.SET);
         element = _match(functionName, _walker.getAccessor(),
             elementName: functionName.name + '=');
       }
     }
     node.functionExpression.element = element;
-    _walk(new ElementWalker.forExecutable(element), () {
+    _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
       super.visitFunctionDeclaration(node);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       FunctionElement element = _walker.getFunction();
+      _matchOffset(element, node.offset);
       node.element = element;
-      _walk(new ElementWalker.forExecutable(element), () {
+      _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
         super.visitFunctionExpression(node);
       });
       return null;
     } else {
       return super.visitFunctionExpression(node);
     }
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
@@ skipping 23 matching lines @@
   @override
   Object visitImportDirective(ImportDirective node) {
     super.visitImportDirective(node);
     _resolveAnnotations(
         node, node.metadata, _enclosingUnit.getAnnotations(node.offset));
     return null;
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
-    for (Label label in node.labels) {
-      _match(label.label, _walker.getLabel());
-    }
+    bool onSwitchStatement = node.statement is SwitchStatement;
+    _walker.elementBuilder
+        .buildLabelElements(node.labels, onSwitchStatement, false);
     return super.visitLabeledStatement(node);
   }
 
   @override
   Object visitLibraryDirective(LibraryDirective node) {
     super.visitLibraryDirective(node);
     _resolveAnnotations(
         node, node.metadata, _enclosingUnit.getAnnotations(node.offset));
     return null;
   }
@@ skipping 14 matching lines @@
           _match(methodName, _walker.getFunction(), elementName: elementName);
     } else {
       if (property.keyword == Keyword.GET) {
         element = _match(methodName, _walker.getAccessor());
       } else {
         assert(property.keyword == Keyword.SET);
         element = _match(methodName, _walker.getAccessor(),
             elementName: nameOfMethod + '=');
       }
     }
-    _walk(new ElementWalker.forExecutable(element), () {
+    _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
       super.visitMethodDeclaration(node);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     super.visitPartDirective(node);
     _resolveAnnotations(
@@ skipping 17 matching lines @@
       });
       _resolveMetadata(node, node.metadata, element);
       return null;
     } else {
       return super.visitSimpleFormalParameter(node);
     }
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
-    for (Label label in node.labels) {
-      _match(label.label, _walker.getLabel());
-    }
+    _walker.elementBuilder.buildLabelElements(node.labels, false, true);
     return super.visitSwitchCase(node);
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
-    for (Label label in node.labels) {
-      _match(label.label, _walker.getLabel());
-    }
+    _walker.elementBuilder.buildLabelElements(node.labels, false, true);
     return super.visitSwitchDefault(node);
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     super.visitTopLevelVariableDeclaration(node);
     _resolveMetadata(node, node.metadata, node.variables.variables[0].element);
     return null;
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     Element element = _match(node.name, _walker.getTypeParameter());
     super.visitTypeParameter(node);
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = _match(node.name, _walker.getVariable());
     Expression initializer = node.initializer;
     if (initializer != null) {
-      _walk(new ElementWalker.forExecutable(element.initializer), () {
+      _walk(
+          new ElementWalker.forExecutable(element.initializer, _enclosingUnit),
+          () {
         super.visitVariableDeclaration(node);
       });
       return null;
     } else {
       return super.visitVariableDeclaration(node);
     }
   }
 
   @override
   Object visitVariableDeclarationList(VariableDeclarationList node) {
-    super.visitVariableDeclarationList(node);
-    if (node.parent is! FieldDeclaration &&
-        node.parent is! TopLevelVariableDeclaration) {
-      _resolveMetadata(node, node.metadata, node.variables[0].element);
+    if (_walker.elementBuilder != null) {
+      return _walker.elementBuilder.visitVariableDeclarationList(node);
+    } else {
+      super.visitVariableDeclarationList(node);
+      if (node.parent is! FieldDeclaration &&
+          node.parent is! TopLevelVariableDeclaration) {
+        _resolveMetadata(node, node.metadata, node.variables[0].element);
+      }
+      return null;
     }
-    return null;
   }
 
   /**
    * Updates [identifier] to point to [element], after ensuring that the
    * element has the expected name.
    *
    * If no [elementName] is given, it defaults to the name of the [identifier]
    * (or the empty string if [identifier] is `null`).
    *
    * If [identifier] is `null`, nothing is updated, but the element name is
    * still checked.
    */
   Element/*=E*/ _match/*<E extends Element>*/(
       SimpleIdentifier identifier, Element/*=E*/ element,
-      {String elementName}) {
+      {String elementName, int offset}) {
     elementName ??= identifier?.name ?? '';
+    offset ??= identifier.offset;
     if (element.name != elementName) {
       throw new StateError(
           'Expected an element matching `$elementName`, got `${element.name}`');
     }
     identifier?.staticElement = element;
+    _matchOffset(element, offset);
     return element;
   }
 
+  void _matchOffset(Element element, int offset) {
+    if (element.nameOffset != 0 && element.nameOffset != offset) {
+      throw new StateError('Element offset mismatch');
+    } else {
+      (element as ElementImpl).nameOffset = offset;
+    }
+  }
+
   /**
    * Associate each of the annotation [nodes] with the corresponding
    * [ElementAnnotation] in [annotations]. If there is a problem, report it
    * against the given [parent] node.
    */
   void _resolveAnnotations(AstNode parent, NodeList<Annotation> nodes,
       List<ElementAnnotation> annotations) {
     int nodeCount = nodes.length;
     if (nodeCount != annotations.length) {
       throw new StateError('Found $nodeCount annotation nodes and '
@@ skipping 41 matching lines @@
 /**
  * Keeps track of the set of non-synthetic child elements of an element,
  * yielding them one at a time in response to "get" method calls.
  */
 class ElementWalker {
   /**
    * The element whose child elements are being walked.
    */
   final Element element;
 
+  /**
+   * If [element] is an executable element, an element builder which is
+   * accumulating the executable element's local variables and labels.
+   * Otherwise `null`.
+   */
+  LocalElementBuilder elementBuilder;
+
+  /**
+   * If [element] is an executable element, the element holder associated with
+   * [elementBuilder].  Otherwise `null`.
+   */
+  ElementHolder _elementHolder;
+
   List<PropertyAccessorElement> _accessors;
   int _accessorIndex = 0;
   List<ClassElement> _classes;
   int _classIndex = 0;
   List<ConstructorElement> _constructors;
   int _constructorIndex = 0;
   List<ClassElement> _enums;
   int _enumIndex = 0;
   List<ExecutableElement> _functions;
   int _functionIndex = 0;
-  List<LabelElement> _labels;
-  int _labelIndex = 0;
   List<ParameterElement> _parameters;
   int _parameterIndex = 0;
   List<FunctionTypeAliasElement> _typedefs;
   int _typedefIndex = 0;
   List<TypeParameterElement> _typeParameters;
   int _typeParameterIndex = 0;
   List<VariableElement> _variables;
   int _variableIndex = 0;
 
   /**
@@ skipping 21 matching lines @@
         _enums = compilationUnit.enums,
         _functions = compilationUnit.functions,
         _typedefs = compilationUnit.functionTypeAliases,
         _variables =
             compilationUnit.topLevelVariables.where(_isNotSynthetic).toList();
 
   /**
    * Creates an [ElementWalker] which walks the child elements of a compilation
    * unit element.
    */
-  ElementWalker.forExecutable(ExecutableElement element)
-      : element = element,
-        _functions = element.functions,
-        _labels = element.labels,
-        _parameters = element.parameters,
-        _typeParameters = element.typeParameters,
-        _variables = element.localVariables;
+  ElementWalker.forExecutable(
+      ExecutableElement element, CompilationUnitElement compilationUnit)
+      : this._forExecutable(element, compilationUnit, new ElementHolder());
 
   /**
    * Creates an [ElementWalker] which walks the child elements of a parameter
    * element.
    */
   ElementWalker.forParameter(ParameterElement element)
       : element = element,
         _parameters = element.parameters,
         _typeParameters = element.typeParameters;
 
   /**
    * Creates an [ElementWalker] which walks the child elements of a typedef
    * element.
    */
   ElementWalker.forTypedef(FunctionTypeAliasElement element)
       : element = element,
         _parameters = element.parameters,
         _typeParameters = element.typeParameters;
 
+  ElementWalker._forExecutable(ExecutableElement element,
+      CompilationUnitElement compilationUnit, ElementHolder elementHolder)
+      : element = element,
+        elementBuilder =
+            new LocalElementBuilder(elementHolder, compilationUnit),
+        _elementHolder = elementHolder,
+        _functions = element.functions,
+        _parameters = element.parameters,
+        _typeParameters = element.typeParameters;
+
   /**
    * Returns the next non-synthetic child of [element] which is an accessor;
    * throws an [IndexError] if there are no more.
    */
   PropertyAccessorElement getAccessor() => _accessors[_accessorIndex++];
 
   /**
    * Returns the next non-synthetic child of [element] which is a class; throws
    * an [IndexError] if there are no more.
    */
@@ skipping 12 matching lines @@
   ClassElement getEnum() => _enums[_enumIndex++];
 
   /**
    * Returns the next non-synthetic child of [element] which is a top level
    * function, method, or local function; throws an [IndexError] if there are no
    * more.
    */
   ExecutableElement getFunction() => _functions[_functionIndex++];
 
   /**
-   * Returns the next non-synthetic child of [element] which is a label; throws
-   * an [IndexError] if there are no more.
-   */
-  LabelElement getLabel() => _labels[_labelIndex++];
-
-  /**
    * Returns the next non-synthetic child of [element] which is a parameter;
    * throws an [IndexError] if there are no more.
    */
   ParameterElement getParameter() => _parameters[_parameterIndex++];
 
   /**
    * Returns the next non-synthetic child of [element] which is a typedef;
    * throws an [IndexError] if there are no more.
    */
   FunctionTypeAliasElement getTypedef() => _typedefs[_typedefIndex++];
@@ skipping 22 matching lines @@
         throw new StateError(
             'Unmatched ${elements[index].runtimeType} ${elements[index]}');
       }
     }
 
     check(_accessors, _accessorIndex);
     check(_classes, _classIndex);
     check(_constructors, _constructorIndex);
     check(_enums, _enumIndex);
     check(_functions, _functionIndex);
-    check(_labels, _labelIndex);
     check(_parameters, _parameterIndex);
     check(_typedefs, _typedefIndex);
     check(_typeParameters, _typeParameterIndex);
     check(_variables, _variableIndex);
+    Element element = this.element;
+    if (element is ExecutableElementImpl) {
+      element.labels = _elementHolder.labels;
+      element.localVariables = _elementHolder.localVariables;
+    }
   }
 
   static bool _isNotSynthetic(Element e) => !e.isSynthetic;
 }
 
 class _ElementMismatchException extends AnalysisException {
   /**
    * Creates an exception to refer to the given [compilationUnit], [element],
    * and [cause].
    */
   _ElementMismatchException(
       CompilationUnitElement compilationUnit, Element element,
       [CaughtException cause = null])
       : super('Element mismatch in $compilationUnit at $element', cause);
 }