Resynthesize local functions lazily.

pkg/analyzer/lib/src/dart/element/element.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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 2839 matching lines @@
     implements ExecutableElement {
   /**
    * The unlinked representation of the executable in the summary.
    */
   final UnlinkedExecutable serializedExecutable;
 
   /**
    * A list containing all of the functions defined within this executable
    * element.
    */
-  List<FunctionElement> _functions = FunctionElement.EMPTY_LIST;
+  List<FunctionElement> _functions;
 
   /**
    * A list containing all of the labels defined within this executable element.
    */
   List<LabelElement> _labels;
 
   /**
    * A list containing all of the local variables defined within this executable
    * element.
    */
@@ skipping 96 matching lines @@
 
   /**
    * Set whether this executable element is external.
    */
   void set external(bool isExternal) {
     assert(serializedExecutable == null);
     setModifier(Modifier.EXTERNAL, isExternal);
   }
 
   @override
-  List<FunctionElement> get functions => _functions;
+  List<FunctionElement> get functions {
+    if (serializedExecutable != null) {
+      _functions ??= FunctionElementImpl.resynthesizeList(
+          this, serializedExecutable.localFunctions);
+    }
+    return _functions ?? const <FunctionElement>[];
+  }
 
   /**
    * Set the functions defined within this executable element to the given
    * [functions].
    */
   void set functions(List<FunctionElement> functions) {
+    assert(serializedExecutable == null);
     for (FunctionElement function in functions) {
       (function as FunctionElementImpl).enclosingElement = this;
     }
     this._functions = functions;
   }
 
   /**
    * Set whether this method's body is a generator.
    */
   void set generator(bool isGenerator) {
@@ skipping 667 matching lines @@
   }
 
   @override
   bool get isStatic => enclosingElement is CompilationUnitElement;
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   SourceRange get visibleRange {
+    if (serializedExecutable != null) {
+      if (serializedExecutable.visibleLength == 0) {
+        return null;
+      }
+      return new SourceRange(serializedExecutable.visibleOffset,
+          serializedExecutable.visibleLength);
+    }
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     String name = displayName;
     if (name != null) {
       buffer.write(name);
     }
     super.appendTo(buffer);
   }
 
   @override
   FunctionDeclaration computeNode() =>
       getNodeMatching((node) => node is FunctionDeclaration);
 
   /**
    * Set the visible range for this element to the range starting at the given
    * [offset] with the given [length].
    */
   void setVisibleRange(int offset, int length) {
+    assert(serializedExecutable == null);
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
   /**
    * Set the parameters defined by this type alias to the given [parameters]
    * without becoming the parent of the parameters. This should only be used by
    * the [TypeResolverVisitor] when creating a synthetic type alias.
    */
   void shareParameters(List<ParameterElement> parameters) {
     this._parameters = parameters;
   }
 
   /**
    * Set the type parameters defined by this type alias to the given
    * [parameters] without becoming the parent of the parameters. This should
    * only be used by the [TypeResolverVisitor] when creating a synthetic type
    * alias.
    */
   void shareTypeParameters(List<TypeParameterElement> typeParameters) {
     this._typeParameters = typeParameters;
   }
+
+  /**
+   * Create and return [FunctionElement]s for the given [unlinkedFunctions].
+   */
+  static List<FunctionElement> resynthesizeList(
+      ExecutableElementImpl executableElement,
+      List<UnlinkedExecutable> unlinkedFunctions) {
+    int length = unlinkedFunctions.length;
+    if (length != 0) {
+      List<FunctionElement> elements = new List<FunctionElement>(length);
+      for (int i = 0; i < length; i++) {
+        elements[i] = new FunctionElementImpl.forSerialized(
+            unlinkedFunctions[i], executableElement);
+      }
+      return elements;
+    } else {
+      return const <FunctionElement>[];
+    }
+  }
 }
 
 /**
  * Implementation of [FunctionElementImpl] for a function typed parameter.
  */
 class FunctionElementImpl_forFunctionTypedParameter
     extends FunctionElementImpl {
   @override
   final CompilationUnitElementImpl enclosingUnit;
 
@@ skipping 3932 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }