Support for new 'export' directive in resolver

compiler/java/com/google/dart/compiler/ast/LibraryUnit.java

 // 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.
 
 package com.google.dart.compiler.ast;
 
 import com.google.common.base.Objects;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
@@ skipping 14 matching lines @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentSkipListMap;
 
 /**
  * Represents the parsed source from a {@link LibrarySource}.
  */
 public class LibraryUnit {
   private final LibrarySource libSource;
   private final LibraryNode selfSourcePath;
   private final List<LibraryNode> importPaths = Lists.newArrayList();
+  private final List<LibraryNode> exportPaths = Lists.newArrayList();
   private final List<LibraryNode> sourcePaths = Lists.newArrayList();
   private final List<LibraryNode> nativePaths = Lists.newArrayList();
 
   private final Map<String, DartUnit> units = new ConcurrentSkipListMap<String, DartUnit>();
   private final List<LibraryImport> imports = Lists.newArrayList();
+  private final List<LibraryExport> exports = Lists.newArrayList();
 
   private final LibraryElement element;
 
   private LibraryDeps deps;
 
   private LibraryNode entryNode;
   private DartUnit selfDartUnit;
 
   private String name;
 
@@ skipping 22 matching lines @@
     if ((lastSlash = self.lastIndexOf('/')) > -1) {
       self = self.substring(lastSlash + 1);
     }
     selfSourcePath = new LibraryNode(self);
   }
 
   public void addImportPath(LibraryNode path) {
     assert path != null;
     importPaths.add(path);
   }
+  
+  public void addExportPath(LibraryNode path) {
+    assert path != null;
+    exportPaths.add(path);
+  }
 
   public void addSourcePath(LibraryNode path) {
     assert path != null;
     sourcePaths.add(path);
     sourceCount++;
   }
 
   public int getSourceCount() {
     return sourceCount;
   }
 
   public void addNativePath(LibraryNode path) {
     assert path != null;
     nativePaths.add(path);
   }
 
   public void putUnit(DartUnit unit) {
     unit.setLibrary(this);
     units.put(unit.getSourceName(), unit);
   }
 
   public DartUnit getUnit(String sourceName) {
     return units.get(sourceName);
   }
 
   public void addImport(LibraryUnit unit, LibraryNode node) {
     if (unit != null) {
       if (node != null) {
-        imports.add(new LibraryImport(unit, node.getPrefix(), node.getCombinators(),
-            node.isExported()));
+        imports.add(new LibraryImport(unit, node.getPrefix(), node.getCombinators()));
       } else {
-        imports.add(new LibraryImport(unit, null, ImmutableList.<ImportCombinator> of(), false));
+        imports.add(new LibraryImport(unit, null, ImmutableList.<ImportCombinator> of()));
       }
     }
   }
+  
+  public void addExport(LibraryUnit unit, LibraryNode node) {
+    if (unit != null) {
+      if (node != null) {
+        exports.add(new LibraryExport(unit, node.getCombinators()));
+      }
+    }
+  }
 
   public Collection<LibraryUnit> getLibrariesWithPrefix(String prefixToMatch) {
     List<LibraryUnit> result = Lists.newArrayList();
     for (LibraryImport libraryImport : imports) {
       if (Objects.equal(libraryImport.getPrefix(), prefixToMatch)) {
         result.add(libraryImport.getLibrary());
       }
     }
     return result;
   }
 
   public LibraryElement getElement() {
     return element;
   }
 
   public Iterable<DartUnit> getUnits() {
     return units.values();
   }
 
   public Iterable<LibraryImport> getImports() {
     return imports;
   }
+  
+  public List<LibraryExport> getExports() {
+    return exports;
+  }
 
   public Iterable<LibraryUnit> getImportedLibraries() {
     Set<LibraryUnit> libraries = Sets.newHashSet();
     for (LibraryImport libraryImport : imports) {
       libraries.add(libraryImport.getLibrary());
     }
     return libraries;
   }
 
   public boolean hasImport(LibraryUnit unit) {
-    return imports.contains(new LibraryImport(unit, null, ImmutableList.<ImportCombinator> of(),
-        false));
+    return imports.contains(new LibraryImport(unit, null, ImmutableList.<ImportCombinator> of()));
   }
 
   public DartExpression getEntryPoint() {
     return entryPoint;
   }
 
   public void setEntryPoint(DartExpression entry) {
     this.entryPoint = entry;
   }
 
   public DartUnit getSelfDartUnit() {
     return this.selfDartUnit;
   }
 
   public void setSelfDartUnit(DartUnit unit) {
     this.selfDartUnit = unit;
   }
 
   /**
    * Return a collection of paths to {@link LibrarySource}s upon which this library or application
    * depends.
    * 
    * @return the paths (not <code>null</code>, contains no <code>null</code>)
    */
   public Iterable<LibraryNode> getImportPaths() {
     return importPaths;
   }
+  
+  public Iterable<LibraryNode> getExportPaths() {
+    return exportPaths;
+  }
 
   /**
    * Return all prefixes used by this library.
    */
   public Set<String> getPrefixes() {
     Set<String> result = Sets.newTreeSet();
     for (LibraryImport libraryImport : imports) {
       String prefix = libraryImport.getPrefix();
       if (prefix != null) {
         result.add(prefix);
@@ skipping 81 matching lines @@
 
   /**
    * Writes this library's associated dependencies.
    */
   public void writeDeps(DartCompilerContext context) throws IOException {
     Writer writer = context.getArtifactWriter(libSource, "", DartCompiler.EXTENSION_DEPS);
     deps.write(writer);
     writer.close();
   }
 }