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);
+        accessors.addAll(_explicitTopLevelVariables.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;
-
   @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);
+        variables.addAll(_explicitTopLevelAccessors.implicitVariables);
+        // Ensure that getters and setters in different units use
+        // the same top-level variables.
+        (enclosingElement as LibraryElementImpl)
+            .resynthesizerContext
+            .patchTopLevelAccessors();
+        _variables = variables;
+        _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;
@@ skipping 25 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) {
+      // Getters and setter in different units should be patched to use the
+      // same variables before these variables were asked and returned.
+      assert(_variables == null);
+      _topLevelVariableReplaceMap ??=
+          <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;
   }
 }
 
 /**
+ * The context in which the library is resynthesized.
+ */
+abstract class LibraryResynthesizerContext {
+  /**
+   * Return the export namespace of the library.
+   */
+  Namespace buildExportNamespace();
+
+  /**
+   * Return the public namespace of the library.
+   */
+  Namespace buildPublicNamespace();
+
+  /**
+   * Find the entry point of the library.
+   */
+  FunctionElement findEntryPoint();
+
+  /**
+   * Ensure that getters and setters in different units use the same
+   * top-level variables.
+   */
+  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);
   }
 }