Don't serialize elements of top-level function/constructor/method bodies.

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 46 matching lines @@
     // Annotations can only contain elements in certain erroneous situations,
     // 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 visitBlockFunctionBody(BlockFunctionBody node) {
+    if (_isBodyToCreateElementsFor(node)) {
+      _walker.consumeLocalElements();
+      node.accept(_walker.elementBuilder);
+      return null;
+    } else {
+      return super.visitBlockFunctionBody(node);
+    }
+  }
+
+  @override
   Object visitCatchClause(CatchClause node) {
     _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);
@@ skipping 65 matching lines @@
 
   @override
   Object visitExportDirective(ExportDirective node) {
     super.visitExportDirective(node);
     _resolveAnnotations(
         node, node.metadata, _enclosingUnit.getAnnotations(node.offset));
     return null;
   }
 
   @override
+  Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
+    if (_isBodyToCreateElementsFor(node)) {
+      _walker.consumeLocalElements();
+      node.accept(_walker.elementBuilder);
+      return null;
+    } else {
+      return super.visitExpressionFunctionBody(node);
+    }
+  }
+
+  @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     super.visitFieldDeclaration(node);
     _resolveMetadata(node, node.metadata, node.fields.variables[0].element);
     return null;
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       ParameterElement element =
@@ skipping 20 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;
+    _walker._elementHolder?.addFunction(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;
+      _walker._elementHolder.addFunction(element);

[Brian Wilkerson, 2016/11/08 21:12:08]

Is it true that the holder can't be null here but can be null on line 214?

[scheglov, 2016/11/09 03:11:35]

Yes, I think so.
We create ElementHolder only when we visit an ExecutableElement.
And FunctionExpression(s) can only be used where Expression(s) can be used - in
method bodies or variable initializers.

       _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
         super.visitFunctionExpression(node);
       });
       return null;
     } else {
       return super.visitFunctionExpression(node);
     }
   }
 
   @override
@@ skipping 239 matching lines @@
    * uses [ElementWalker.validate] to verify that all expected elements have
    * been matched.
    */
   void _walk(ElementWalker walker, void callback()) {
     ElementWalker outerWalker = _walker;
     _walker = walker;
     callback();
     walker.validate();
     _walker = outerWalker;
   }
+
+  static bool _isBodyToCreateElementsFor(FunctionBody node) {
+    AstNode parent = node.parent;
+    return parent is ConstructorDeclaration ||
+        parent is MethodDeclaration ||
+        parent.parent is FunctionDeclaration &&
+            parent.parent.parent is CompilationUnit;
+  }
 }
 
 /**
  * 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.
    */
@@ skipping 88 matching lines @@
   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;
 
+  void consumeLocalElements() {
+    _functionIndex = _functions.length;
+  }
+
   /**
    * 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 60 matching lines @@
     check(_classes, _classIndex);
     check(_constructors, _constructorIndex);
     check(_enums, _enumIndex);
     check(_functions, _functionIndex);
     check(_parameters, _parameterIndex);
     check(_typedefs, _typedefIndex);
     check(_typeParameters, _typeParameterIndex);
     check(_variables, _variableIndex);
     Element element = this.element;
     if (element is ExecutableElementImpl) {
+      element.functions = _elementHolder.functions;
       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);
 }