Build top-level variables and property accessors 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 1067 matching lines @@
    * A table mapping the offset of a directive to the annotations associated
    * with that directive, or `null` if none of the annotations in the
    * compilation unit have annotations.
    */
   Map<int, List<ElementAnnotation>> annotationMap = null;
 
   /**
    * A list containing all of the top-level accessors (getters and setters)
    * contained in this compilation unit.
    */
-  List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
+  List<PropertyAccessorElement> _accessors;
 
   /**
    * A list containing all of the enums contained in this compilation unit.
    */
   List<ClassElement> _enums = ClassElement.EMPTY_LIST;
 
   /**
    * A list containing all of the top-level functions contained in this
    * compilation unit.
    */
   List<FunctionElement> _functions = FunctionElement.EMPTY_LIST;
 
   /**
    * A list containing all of the function type aliases contained in this
    * compilation unit.
    */
   List<FunctionTypeAliasElement> _typeAliases =
       FunctionTypeAliasElement.EMPTY_LIST;
 
   /**
    * A list containing all of the types contained in this compilation unit.
    */
   List<ClassElement> _types = ClassElement.EMPTY_LIST;
 
   /**
    * A list containing all of the variables contained in this compilation unit.
    */
-  List<TopLevelVariableElement> _variables = TopLevelVariableElement.EMPTY_LIST;
+  List<TopLevelVariableElement> _variables;
 
   /**
    * A map from offsets to elements of this unit at these offsets.
    */
   final Map<int, Element> _offsetToElementMap = new HashMap<int, Element>();
 
   /**
+   * Resynthesized explicit top-level property accessors.
+   */
+  UnitExplicitTopLevelAccessors _explicitTopLevelAccessors;
+
+  /**
+   * Resynthesized explicit top-level variables.
+   */
+  UnitExplicitTopLevelVariables _explicitTopLevelVariables;
+
+  /**
+   * Description of top-level variable replacements that should be applied
+   * to implicit top-level variables because of re-linking top-level property
+   * accessors between different unit of the same library.
+   */
+  Map<TopLevelVariableElement, TopLevelVariableElement>
+      _topLevelVariableReplaceMap;
+
+  /**
    * Initialize a newly created compilation unit element to have the given
    * [name].
    */
   CompilationUnitElementImpl(String name)
       : resynthesizerContext = null,
         _unlinkedUnit = null,
         _unlinkedPart = null,
         super(name, -1);
 
   /**
    * Initialize using the given serialized information.
    */
   CompilationUnitElementImpl.forSerialized(
       LibraryElementImpl enclosingLibrary,
       this.resynthesizerContext,
       this._unlinkedUnit,
       this._unlinkedPart,
       String name)
       : super.forSerialized(null) {
     _enclosingElement = enclosingLibrary;
     _name = name;
     _nameOffset = -1;
   }
 
   @override
-  List<PropertyAccessorElement> get accessors => _accessors;
+  List<PropertyAccessorElement> get accessors {
+    if (_unlinkedUnit != null) {
+      if (_accessors == null) {
+        _explicitTopLevelAccessors ??=
+            resynthesizerContext.buildTopLevelAccessors();
+        _explicitTopLevelVariables ??=
+            resynthesizerContext.buildTopLevelVariables();
+        List<PropertyAccessorElementImpl> accessors =
+            <PropertyAccessorElementImpl>[];
+        accessors.addAll(_explicitTopLevelAccessors.accessors);
+        for (TopLevelVariableElementImpl implicitVariable
+            in _explicitTopLevelAccessors.implicitVariables) {
+          implicitVariable.enclosingElement = this;
+        }
+        for (PropertyAccessorElementImpl implicitAccessors
+            in _explicitTopLevelVariables.implicitAccessors) {
+          implicitAccessors.enclosingElement = this;
+          accessors.add(implicitAccessors);
+        }
+        _accessors = accessors;
+      }
+    }
+    return _accessors ?? PropertyAccessorElement.EMPTY_LIST;
+  }
 
   /**
    * Set the top-level accessors (getters and setters) contained in this
    * compilation unit to the given [accessors].
    */
   void set accessors(List<PropertyAccessorElement> accessors) {
     for (PropertyAccessorElement accessor in accessors) {
       (accessor as PropertyAccessorElementImpl).enclosingElement = this;
     }
     this._accessors = accessors;
@@ skipping 62 matching lines @@
     for (int i = 0; i < _functions.length; i++) {
       if (_functions[i].name == FunctionElement.LOAD_LIBRARY_NAME) {
         return true;
       }
     }
     return false;
   }
 
   @override
   String get identifier => source.encoding;
-

[Paul Berry, 2016/05/19 11:27:29]

Nit: restore this blank line.

   @override
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
 
   @override
   List<ElementAnnotation> get metadata {
     if (_unlinkedPart != null) {
       CompilationUnitElementImpl definingUnit =
           library.definingCompilationUnit as CompilationUnitElementImpl;
       return _metadata ??= _unlinkedPart.annotations
           .map(definingUnit.resynthesizerContext.buildAnnotation)
           .toList();
     }
     return super.metadata;
   }
 
   @override
-  List<TopLevelVariableElement> get topLevelVariables => _variables;
+  List<TopLevelVariableElement> get topLevelVariables {
+    if (_unlinkedUnit != null) {
+      if (_variables == null) {
+        _explicitTopLevelAccessors ??=
+            resynthesizerContext.buildTopLevelAccessors();
+        _explicitTopLevelVariables ??=
+            resynthesizerContext.buildTopLevelVariables();
+        List<TopLevelVariableElementImpl> variables =
+            <TopLevelVariableElementImpl>[];
+        variables.addAll(_explicitTopLevelVariables.variables);
+        for (PropertyAccessorElementImpl implicitAccessor
+            in _explicitTopLevelVariables.implicitAccessors) {
+          implicitAccessor.enclosingElement = this;

[Paul Berry, 2016/05/19 11:27:30]

If `.accessors` is called and then `.topLevelVariables` is called, this code
will get unnecessarily executed twice.  Same goes for
`implicitVariable.enclosingElement = this;` on line 1305.

How about if instead we pass `this` to
`resynthesizerContext.buildTopLevelAccessors()` and
`resynthesizerContext.buildTopLevelVariables()`, so that they can set the
enclosing element properly when they create the elements?

[scheglov, 2016/05/19 16:54:57]

Done.

+        }
+        for (TopLevelVariableElementImpl implicitVariable
+            in _explicitTopLevelAccessors.implicitVariables) {
+          implicitVariable.enclosingElement = this;
+          variables.add(implicitVariable);
+        }
+        _variables = variables;
+      }
+      (enclosingElement as LibraryElementImpl)
+          .resynthesizerContext
+          .patchTopLevelAccessors();
+      _topLevelVariableReplaceMap?.forEach((from, to) {
+        int index = _variables.indexOf(from);
+        _variables[index] = to;
+      });
+      _topLevelVariableReplaceMap = null;
+    }
+    return _variables ?? TopLevelVariableElement.EMPTY_LIST;
+  }
 
   /**
    * Set the top-level variables contained in this compilation unit to the given
    * [variables].
    */
   void set topLevelVariables(List<TopLevelVariableElement> variables) {
+    assert(!isResynthesized);
     for (TopLevelVariableElement field in variables) {
       (field as TopLevelVariableElementImpl).enclosingElement = this;
     }
     this._variables = variables;
   }
 
   /**
    * Set the function type aliases contained in this compilation unit to the
    * given [typeAliases].
    */
@@ skipping 61 matching lines @@
     return annotationMap[offset] ?? const <ElementAnnotation>[];
   }
 
   @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have
     // thrown a CCE if any of the elements in the arrays were not of the
     // expected types.
     //
-    for (PropertyAccessorElement accessor in _accessors) {
+    for (PropertyAccessorElement accessor in accessors) {
       PropertyAccessorElementImpl accessorImpl = accessor;
       if (accessorImpl.identifier == identifier) {
         return accessorImpl;
       }
     }
-    for (TopLevelVariableElement variable in _variables) {
+    for (TopLevelVariableElement variable in topLevelVariables) {
       TopLevelVariableElementImpl variableImpl = variable;
       if (variableImpl.identifier == identifier) {
         return variableImpl;
       }
     }
     for (FunctionElement function in _functions) {
       FunctionElementImpl functionImpl = function;
       if (functionImpl.identifier == identifier) {
         return functionImpl;
       }
     }
     for (FunctionTypeAliasElement typeAlias in _typeAliases) {
       FunctionTypeAliasElementImpl typeAliasImpl = typeAlias;
       if (typeAliasImpl.identifier == identifier) {
         return typeAliasImpl;
       }
     }
     for (ClassElement type in _types) {
       ClassElementImpl typeImpl = type;
-      if (typeImpl.identifier == identifier) {
+      if (typeImpl.name == identifier) {
         return typeImpl;
       }
     }
     for (ClassElement type in _enums) {
       ClassElementImpl typeImpl = type;
       if (typeImpl.identifier == identifier) {
+        return typeImpl;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * TODO(scheglov) When `_DeferredClassElement` is replaced with

[Paul Berry, 2016/05/19 11:27:30]

In addition to the TODO, I would appreciate a longer documentation comment
explaining how this method differs from "getChild" and why one would want to
call one instead of the other (I had to do some digging before the reason was
clear to me).

Perhaps something like: "Equivalent to [getChild], but does not make the
assumption that the child implements [ElementImpl].  Intended as a temporary
measure while element model resynthesis is being made lazy."

[scheglov, 2016/05/19 16:54:57]

Done.

+   * [ClassElementImpl] remove this method.
+   */
+  Element getChildNotImpl(String identifier) {
+    //
+    // The casts in this method are safe because the set methods would have
+    // thrown a CCE if any of the elements in the arrays were not of the
+    // expected types.
+    //
+    for (PropertyAccessorElement accessor in accessors) {
+      PropertyAccessorElementImpl accessorImpl = accessor;
+      if (accessorImpl.identifier == identifier) {
+        return accessorImpl;
+      }
+    }
+    for (TopLevelVariableElement variable in topLevelVariables) {
+      TopLevelVariableElementImpl variableImpl = variable;
+      if (variableImpl.identifier == identifier) {
+        return variableImpl;
+      }
+    }
+    for (FunctionElement function in _functions) {
+      FunctionElementImpl functionImpl = function;
+      if (functionImpl.identifier == identifier) {
+        return functionImpl;
+      }
+    }
+    for (FunctionTypeAliasElement typeAlias in _typeAliases) {
+      FunctionTypeAliasElementImpl typeAliasImpl = typeAlias;
+      if (typeAliasImpl.identifier == identifier) {
+        return typeAliasImpl;
+      }
+    }
+    for (ClassElement type in _types) {
+      if (type.name == identifier) {
+        return type;
+      }
+    }
+    for (ClassElement type in _enums) {
+      ClassElementImpl typeImpl = type;
+      if (typeImpl.identifier == identifier) {
         return typeImpl;
       }
     }
     return null;
   }
 
   @override
   Element getElementAt(int offset) {
     if (_offsetToElementMap.isEmpty) {
       accept(new _BuildOffsetToElementMap(_offsetToElementMap));
@@ skipping 19 matching lines @@
       }
     }
     return null;
   }
 
   /**
    * Replace the given [from] top-level variable with [to] in this compilation unit.
    */
   void replaceTopLevelVariable(
       TopLevelVariableElement from, TopLevelVariableElement to) {
-    int index = _variables.indexOf(from);
-    _variables[index] = to;
+    if (_unlinkedUnit != null) {
+      _topLevelVariableReplaceMap ??=

[Paul Berry, 2016/05/19 11:27:29]

This will only have the desired effect if the `topLevelVariables` getter hasn't
been called yet.  Please add a comment to this effect and the assertion:

assert(_variables == null);

[scheglov, 2016/05/19 16:54:57]

Done.

+          <TopLevelVariableElement, TopLevelVariableElement>{};
+      _topLevelVariableReplaceMap[from] = to;
+    } else {
+      int index = _variables.indexOf(from);
+      _variables[index] = to;
+    }
   }
 
   /**
    * Set the annotations associated with the directive at the given [offset] to
    * the given list of [annotations].
    */
   void setAnnotations(int offset, List<ElementAnnotation> annotations) {
     annotationMap ??= new HashMap<int, List<ElementAnnotation>>();
     annotationMap[offset] = annotations;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
-    safelyVisitChildren(_accessors, visitor);
+    safelyVisitChildren(accessors, visitor);
     safelyVisitChildren(_enums, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
-    safelyVisitChildren(_variables, visitor);
+    safelyVisitChildren(topLevelVariables, visitor);
   }
 }
 
 /**
  * A [FieldElement] for a 'const' or 'final' field that has an initializer.
  *
  * TODO(paulberry): we should rename this class to reflect the fact that it's
  * used for both const and final fields.  However, we shouldn't do so until
  * we've created an API for reading the values of constants; until that API is
  * available, clients are likely to read constant values by casting to
@@ skipping 191 matching lines @@
    */
   ConstTopLevelVariableElementImpl(String name, int offset)
       : super(name, offset);
 
   /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
   ConstTopLevelVariableElementImpl.forNode(Identifier name)
       : super.forNode(name);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  ConstTopLevelVariableElementImpl.forSerialized(
+      UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
+      : super.forSerialized(unlinkedVariable, enclosingElement);
 }
 
 /**
  * Mixin used by elements that represent constant variables and have
  * initializers.
  *
  * Note that in correct Dart code, all constant variables must have
  * initializers.  However, analyzer also needs to handle incorrect Dart code,
  * in which case there might be some constant variables that lack initializers.
  * This interface is only used for constant variables that have initializers.
@@ skipping 1985 matching lines @@
 
 /**
  * A concrete implementation of a [LibraryElement].
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
   /**
    * The analysis context in which this library is defined.
    */
   final AnalysisContext context;
 
+  final LibraryResynthesizerContext resynthesizerContext;
+
+  final UnlinkedUnit _unlinkedDefiningUnit;
+
   /**
    * The compilation unit that defines this library.
    */
   CompilationUnitElement _definingCompilationUnit;
 
   /**
    * The entry point for this library, or `null` if this library does not have
    * an entry point.
    */
-  FunctionElement entryPoint;
+  FunctionElement _entryPoint;
 
   /**
    * A list containing specifications of all of the imports defined in this
    * library.
    */
   List<ImportElement> _imports = ImportElement.EMPTY_LIST;
 
   /**
    * A list containing specifications of all of the exports defined in this
    * library.
@@ skipping 21 matching lines @@
    */
   FunctionElement _loadLibraryFunction;
 
   @override
   final int nameLength;
 
   /**
    * The export [Namespace] of this library, `null` if it has not been
    * computed yet.
    */
-  @override
-  Namespace exportNamespace;
+  Namespace _exportNamespace;
 
   /**
    * The public [Namespace] of this library, `null` if it has not been
    * computed yet.
    */
-  @override
-  Namespace publicNamespace;
+  Namespace _publicNamespace;
 
   /**
    * Initialize a newly created library element in the given [context] to have
    * the given [name] and [offset].
    */
   LibraryElementImpl(this.context, String name, int offset, this.nameLength)
-      : super(name, offset);
+      : resynthesizerContext = null,
+        _unlinkedDefiningUnit = null,
+        super(name, offset);
 
   /**
    * Initialize a newly created library element in the given [context] to have
    * the given [name].
    */
   LibraryElementImpl.forNode(this.context, LibraryIdentifier name)
       : nameLength = name != null ? name.length : 0,
+        resynthesizerContext = null,
+        _unlinkedDefiningUnit = null,
         super.forNode(name);
 
+  /**
+   * Initialize using the given serialized information.
+   */
+  LibraryElementImpl.forSerialized(this.context, String name, int offset,
+      this.nameLength, this.resynthesizerContext, this._unlinkedDefiningUnit)
+      : super.forSerialized(null) {
+    _name = name;
+    _nameOffset = offset;
+  }
+
   @override
   int get codeLength {
     CompilationUnitElement unit = _definingCompilationUnit;
     if (unit is CompilationUnitElementImpl) {
       return unit.codeLength;
     }
     return null;
   }
 
   @override
@@ skipping 13 matching lines @@
    * Set the compilation unit that defines this library to the given compilation
    * [unit].
    */
   void set definingCompilationUnit(CompilationUnitElement unit) {
     assert((unit as CompilationUnitElementImpl).librarySource == unit.source);
     (unit as CompilationUnitElementImpl).enclosingElement = this;
     this._definingCompilationUnit = unit;
   }
 
   @override
+  SourceRange get docRange {
+    if (_unlinkedDefiningUnit != null) {
+      UnlinkedDocumentationComment comment =
+          _unlinkedDefiningUnit.libraryDocumentationComment;
+      return comment != null
+          ? new SourceRange(comment.offset, comment.length)
+          : null;
+    }
+    return super.docRange;
+  }
+
+  @override
+  String get documentationComment {
+    if (_unlinkedDefiningUnit != null) {
+      return _unlinkedDefiningUnit?.libraryDocumentationComment?.text;
+    }
+    return super.documentationComment;
+  }
+
+  FunctionElement get entryPoint {
+    if (resynthesizerContext != null) {
+      _entryPoint ??= resynthesizerContext.findEntryPoint();
+    }
+    return _entryPoint;
+  }
+
+  void set entryPoint(FunctionElement entryPoint) {
+    _entryPoint = entryPoint;
+  }
+
+  @override
   List<LibraryElement> get exportedLibraries {
     HashSet<LibraryElement> libraries = new HashSet<LibraryElement>();
     for (ExportElement element in _exports) {
       LibraryElement library = element.exportedLibrary;
       if (library != null) {
         libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
   @override
+  Namespace get exportNamespace {
+    if (resynthesizerContext != null) {
+      _exportNamespace ??= resynthesizerContext.buildExportNamespace();
+    }
+    return _exportNamespace;
+  }
+
+  void set exportNamespace(Namespace exportNamespace) {
+    _exportNamespace = exportNamespace;
+  }
+
+  @override
   List<ExportElement> get exports => _exports;
 
   /**
    * Set the specifications of all of the exports defined in this library to the
    * given list of [exports].
    */
   void set exports(List<ExportElement> exports) {
     for (ExportElement exportElement in exports) {
       (exportElement as ExportElementImpl).enclosingElement = this;
     }
@@ skipping 93 matching lines @@
         if (!visited.contains(exportedLibrary)) {
           visited.add(exportedLibrary);
         }
       }
     }
     return false;
   }
 
   @override
   bool get isResynthesized {
-    CompilationUnitElement definingUnit = _definingCompilationUnit;
-    return definingUnit is CompilationUnitElementImpl &&
-        definingUnit.resynthesizerContext != null;
+    return resynthesizerContext != null;
   }
 
   @override
   ElementKind get kind => ElementKind.LIBRARY;
 
   @override
   LibraryElement get library => this;
 
   @override
   List<LibraryElement> get libraryCycle {
@@ skipping 72 matching lines @@
     return _libraryCycle;
   }
 
   @override
   FunctionElement get loadLibraryFunction {
     assert(_loadLibraryFunction != null);
     return _loadLibraryFunction;
   }
 
   @override
+  List<ElementAnnotation> get metadata {
+    if (_unlinkedDefiningUnit != null) {
+      if (_metadata == null) {
+        CompilationUnitElementImpl definingUnit =
+            _definingCompilationUnit as CompilationUnitElementImpl;
+        _metadata ??= _unlinkedDefiningUnit.libraryAnnotations
+            .map(definingUnit.resynthesizerContext.buildAnnotation)
+            .toList();
+      }
+      return _metadata;
+    }
+    return super.metadata;
+  }
+
+  @override
   List<CompilationUnitElement> get parts => _parts;
 
   /**
    * Set the compilation units that are included in this library using a `part`
    * directive to the given list of [parts].
    */
   void set parts(List<CompilationUnitElement> parts) {
     for (CompilationUnitElement compilationUnit in parts) {
       assert((compilationUnit as CompilationUnitElementImpl).librarySource ==
           source);
       (compilationUnit as CompilationUnitElementImpl).enclosingElement = this;
     }
     this._parts = parts;
   }
 
   @override
   List<PrefixElement> get prefixes {
     HashSet<PrefixElement> prefixes = new HashSet<PrefixElement>();
     for (ImportElement element in _imports) {
       PrefixElement prefix = element.prefix;
       if (prefix != null) {
         prefixes.add(prefix);
       }
     }
     return new List.from(prefixes);
   }
 
   @override
+  Namespace get publicNamespace {
+    if (resynthesizerContext != null) {
+      _publicNamespace ??= resynthesizerContext.buildPublicNamespace();
+    }
+    return _publicNamespace;
+  }
+
+  void set publicNamespace(Namespace publicNamespace) {
+    _publicNamespace = publicNamespace;
+  }
+
+  @override
   Source get source {
     if (_definingCompilationUnit == null) {
       return null;
     }
     return _definingCompilationUnit.source;
   }
 
   @override
   List<CompilationUnitElement> get units {
     List<CompilationUnitElement> units = new List<CompilationUnitElement>();
@@ skipping 212 matching lines @@
         if (!_safeIsUpToDate(exportedLibrary, timeStamp, visitedLibraries)) {
           return false;
         }
       }
     }
     return true;
   }
 }
 
 /**
+ * TODO(scheglov) document

[Paul Berry, 2016/05/19 11:27:29]

Did you intend to address this before sending out for review?

[scheglov, 2016/05/19 16:54:57]

Done.

+ */
+abstract class LibraryResynthesizerContext {
+  Namespace buildExportNamespace();
+  Namespace buildPublicNamespace();
+  FunctionElement findEntryPoint();
+  void patchTopLevelAccessors();
+}
+
+/**
  * A concrete implementation of a [LocalVariableElement].
  */
 class LocalVariableElementImpl extends NonParameterVariableElementImpl
     implements LocalVariableElement {
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
@@ skipping 603 matching lines @@
     return super.codeOffset;
   }
 
   @override
   void set const3(bool isConst) {
     assert(_unlinkedVariable == null);
     super.const3 = isConst;
   }
 
   @override
+  SourceRange get docRange {
+    if (_unlinkedVariable != null) {
+      UnlinkedDocumentationComment comment =
+          _unlinkedVariable.documentationComment;
+      return comment != null
+          ? new SourceRange(comment.offset, comment.length)
+          : null;
+    }
+    return super.docRange;
+  }
+
+  @override
+  String get documentationComment {
+    if (_unlinkedVariable != null) {
+      return _unlinkedVariable?.documentationComment?.text;
+    }
+    return super.documentationComment;
+  }
+
+  @override
   void set final2(bool isFinal) {
     assert(_unlinkedVariable == null);
     super.final2 = isFinal;
   }
 
   @override
   bool get hasImplicitType {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.type == null;
     }
@@ skipping 614 matching lines @@
   /**
    * Initialize a newly created synthetic element to have the given [name] and
    * [offset].
    */
   PropertyInducingElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created element to have the given [name].
    */
   PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  PropertyInducingElementImpl.forSerialized(
+      UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
+      : super.forSerialized(unlinkedVariable, enclosingElement);
 }
 
 /**
  * The context in which elements are resynthesized.
  */
 abstract class ResynthesizerContext {
   /**
    * Build [ElementAnnotationImpl] for the given [UnlinkedConst].
    */
   ElementAnnotationImpl buildAnnotation(UnlinkedConst uc);
 
   /**
    * Build [Expression] for the given [UnlinkedConst].
    */
   Expression buildExpression(UnlinkedConst uc);
 
   /**
+   * Build explicit top-level property accessors.
+   */
+  UnitExplicitTopLevelAccessors buildTopLevelAccessors();
+
+  /**
+   * Build explicit top-level variables.
+   */
+  UnitExplicitTopLevelVariables buildTopLevelVariables();
+
+  /**
    * Resolve an [EntityRef] into a type.  If the reference is
    * unresolved, return [DynamicTypeImpl.instance].
    *
    * TODO(paulberry): or should we have a class representing an
    * unresolved type, for consistency with the full element model?
    */
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false, bool instantiateToBoundsAllowed: true});
 }
@@ skipping 44 matching lines @@
    * given [name] and [offset].
    */
   TopLevelVariableElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
   TopLevelVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
+  /**
+   * Initialize using the given serialized information.
+   */
+  TopLevelVariableElementImpl.forSerialized(
+      UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
+      : super.forSerialized(unlinkedVariable, enclosingElement);
+
   @override
   bool get isStatic => true;
 
   @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
 
   @override
@@ skipping 260 matching lines @@
     } else if (enclosingTypeParameterContext != null) {
       return enclosingTypeParameterContext
           .isTypeParameterInScope(typeParameter);
     } else {
       return false;
     }
   }
 }
 
 /**
+ * Container with information about explicit top-level property accessors and
+ * corresponding implicit top-level variables.
+ */
+class UnitExplicitTopLevelAccessors {
+  final List<PropertyAccessorElementImpl> accessors =
+      <PropertyAccessorElementImpl>[];
+  final List<TopLevelVariableElementImpl> implicitVariables =
+      <TopLevelVariableElementImpl>[];
+}
+
+/**
+ * Container with information about explicit top-level variables and
+ * corresponding implicit top-level property accessors.
+ */
+class UnitExplicitTopLevelVariables {
+  final List<TopLevelVariableElementImpl> variables =
+      <TopLevelVariableElementImpl>[];
+  final List<PropertyAccessorElementImpl> implicitAccessors =
+      <PropertyAccessorElementImpl>[];
+}
+
+/**
  * A concrete implementation of a [UriReferencedElement].
  */
 abstract class UriReferencedElementImpl extends ElementImpl
     implements UriReferencedElement {
   /**
    * The offset of the URI in the file, may be `-1` if synthetic.
    */
   int uriOffset = -1;
 
   /**
@@ skipping 173 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }