Added support for exports and re-exports.

lib/compiler/implementation/elements/elements.dart

 // Copyright (c) 2012, 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');
 
 #import('dart:uri');
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 #import('../../compiler.dart', prefix: 'api_e');
@@ skipping 86 matching lines @@
   static const ElementKind TYPEDEF =
     const ElementKind('typedef', ElementCategory.ALIAS);
 
   static const ElementKind STATEMENT =
     const ElementKind('statement', ElementCategory.NONE);
   static const ElementKind LABEL =
     const ElementKind('label', ElementCategory.NONE);
   static const ElementKind VOID =
     const ElementKind('void', ElementCategory.NONE);
 
+  static const ElementKind ERROR =
+      const ElementKind('error', ElementCategory.NONE);
+
   toString() => id;
 }
 
 class Element implements Spannable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Link<MetadataAnnotation> metadata = const EmptyLink<MetadataAnnotation>();
 
   Element(this.name, this.kind, this.enclosingElement) {
@@ skipping 234 matching lines @@
  * to check for unresolvable elements instead of
  *   [: element == null :].
  */
 class ErroneousElement extends Element {
   final MessageKind messageKind;
   final List messageArguments;
   final SourceString targetName;
 
   ErroneousElement(this.messageKind, this.messageArguments,
                    this.targetName, Element enclosing)
-      : super(const SourceString('erroneous element'), null, enclosing);

[ahe, 2012/10/09 13:07:50]

Good catch!

+      : super(const SourceString('erroneous element'),
+              ElementKind.ERROR, enclosing);
 
   isErroneous() => true;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   SourceString get name => unsupported();
-  ElementKind get kind => unsupported();
   Link<MetadataAnnotation> get metadata => unsupported();
 
   getLibrary() => enclosingElement.getLibrary();
 }
 
 class ErroneousFunctionElement extends ErroneousElement
                                implements FunctionElement {
   ErroneousFunctionElement(MessageKind messageKind, List messageArguments,
                            SourceString targetName, Element enclosing)
       : super(messageKind, messageArguments, targetName, enclosing);
@@ skipping 229 matching lines @@
   }
 
   /**
    * 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.putIfAbsent(element.name, () => element);
-    if (existing !== element && existing !== null) {
+    Element existing = importScope[element.name];
+    importScope.putIfAbsent(element.name, () => element);

[ahe, 2012/10/09 13:07:50]

This should be:

Element existing = importScope.putIfAbsent(element.name, () => element);

[Johnni Winther, 2012/10/09 13:50:07]

Changed to not use [putIfAbsent].

+    if (existing !== null) {
       if (!existing.isErroneous()) {
         // TODO(johnniwinther): Provide access to both the new and existing
         // elements.
         importScope[element.name] = new ErroneousElement(
             MessageKind.DUPLICATE_IMPORT,
             [element.name], element.name, this);
       }
     }
   }
 
+  bool get exportsHandled => _exports !== null;

[ahe, 2012/10/09 13:07:50]

What is the purpose of this method?

[Johnni Winther, 2012/10/09 13:50:07]

To test whether the export scope has been computed for this library.

+
+  /**
+   * Link for elements exported either through export declarations or through
+   * declaration.
+   *
+   * [ImportExportHandler] sets this map when the library is loaded.
+   */
+  Link<Element> _exports;

[ahe, 2012/10/09 13:07:50]

Why is this private, and why is it not with all the other fields?

[Johnni Winther, 2012/10/09 13:50:07]

It is private so that setExports can ensure that it is only set once. It should
be with the other fields.

[ahe, 2012/10/09 14:41:33]

How does privacy ensure that it can only be set once?

[Johnni Winther, 2012/10/10 09:20:59]

It doesn't. Renamed to [slotForExports] and comment expanded to tell that this
field should be not be accessed by other methods that the getter and setExports.

+
+  Link<Element> get exports {
+    assert(invariant(this, exportsHandled,
+                     message: 'Exports not handled on $this'));
+    return _exports;
+  }
+
+  void setExports(Iterable<Element> iterable) {

[ahe, 2012/10/09 13:07:50]

Why is this not a setter?

[Johnni Winther, 2012/10/09 13:50:07]

Because it is not symmetric to the getter. It has a different type and must only
be called once.

[Bob Nystrom, 2012/10/09 16:20:37]

I agree with Johnni, I wouldn't make this a setter either. Setters should have
"field-like" semantics and one thing that implies (to me at least) is that you
can invoke them repeatedly.

My personal convention for methods like this is to call them "bind___". "bind"
as opposed to "set" to me implies more of a one-time occurrence. (Although it
might be confusing here since "bind" is already meaningful in the context of a
compiler.)

+    assert(invariant(this, !exportsHandled,
+                     message: 'Exports already set to $_exports on $this'));
+    assert(invariant(this, iterable !== null));
+    var builder = new LinkBuilder<Element>();
+    for (Element export in iterable) {
+      builder.addLast(export);
+    }
+    _exports = builder.toLink();
+  }
+
   LibraryElement getLibrary() => isPatch ? origin : this;
 
   /**
    * Look up a top-level element in this library. The element could
    * potentially have been imported from another library. Returns
    * null if no such element exist and an [ErroneousElement] if multiple
    * elements have been imported.
    */
   Element find(SourceString elementName) {
     Element result = localScope[elementName];
     if (result === null) {
       result = importScope[elementName];
     }
     return result;
   }
 
   /** Look up a top-level element in this library, but only look for
     * non-imported elements. Returns null if no such element exist. */
   Element findLocal(SourceString elementName) {
     // TODO(johnniwinther): How to handle injected elements in the patch
     // library?
     Element result = localScope[elementName];
     if (result === null || result.getLibrary() != this) return null;
     return result;
   }
 
   void forEachExport(f(Element element)) {
-    localScope.forEach((_, Element e) {
-      if (this === e.getLibrary()
-          && e.kind !== ElementKind.PREFIX
-          && e.kind !== ElementKind.FOREIGN
-          && !e.name.isPrivate()) {
-        f(e);
-      }
-    });
+    exports.forEach((Element e) => f(e));
   }
 
   void forEachLocalMember(f(Element element)) {
     if (isPatch) {
       // Patch libraries traverse both origin and injected members.
       origin.localMembers.forEach(f);
 
       void filterPatch(Element element) {
         if (!element.isPatch) {
           // Do not traverse the patch members.
@@ skipping 1236 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }