Deferred (aka lazy) loading of static functions.

dart/sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'dart:uri';
+import 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
 
 import '../dart2jslib.dart' show invariant,
                                  InterfaceType,
                                  DartType,
@@ skipping 539 matching lines @@
   /**
    * Link for elements exported either through export declarations or through
    * declaration. This field should not be accessed directly but instead through
    * the [exports] getter.
    *
    * [LibraryDependencyHandler] sets this field through [setExports] when the
    * library is loaded.
    */
   Link<Element> slotForExports;
 
+  final Map<LibraryDependency, LibraryElement> tagMapping =
+      new LinkedHashMap<LibraryDependency, LibraryElement>();
+
   LibraryElementX(Script script, [Uri canonicalUri, LibraryElement this.origin])
     : this.canonicalUri = ((canonicalUri == null) ? script.uri : canonicalUri),
       importScope = new Map<SourceString, Element>(),
       super(new SourceString(script.name), ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElementX(script, this);
     if (isPatch) {
       origin.patch = this;
     }
   }
 
   bool get isPatched => patch != null;
   bool get isPatch => origin != null;
 
   LibraryElement get declaration => super.declaration;
   LibraryElement get implementation => super.implementation;
 
   CompilationUnitElement getCompilationUnit() => entryCompilationUnit;
 
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(LibraryTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
+  void resolvedTag(LibraryDependency tag, LibraryElement library) {
+    assert(tagMapping[tag] == null);
+    tagMapping[tag] = library;
+  }
+
+  LibraryElement getDependency(LibraryDependency tag) => tagMapping[tag];
+
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for the
    * detection of ambiguous uses of imported names.
    */
   void addImport(Element element, DiagnosticListener listener) {
     Element existing = importScope[element.name];
     if (existing != null) {
@@ skipping 1366 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }