Add import/export declaration AST node boilerplate to kernel.

pkg/kernel/lib/ast.dart

 // Copyright (c) 2016, 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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 246 matching lines @@
   ///
   /// Classes of an external library are loaded at one of the [ClassLevel]s
   /// other than [ClassLevel.Body].  Members in an external library have no
   /// body, but have their typed interface present.
   ///
   /// If the libary is non-external, then its classes are at [ClassLevel.Body]
   /// and all members are loaded.
   bool isExternal;
 
   String name;
-  final List<DeferredImport> deferredImports;
+  final List<LibraryDependency> dependencies;
   final List<Typedef> typedefs;
   final List<Class> classes;
   final List<Procedure> procedures;
   final List<Field> fields;
 
   Library(this.importUri,
       {this.name,
       this.isExternal: false,
-      List<DeferredImport> imports,
+      List<LibraryDependency> dependencies,
       List<Typedef> typedefs,
       List<Class> classes,
       List<Procedure> procedures,
       List<Field> fields,
       this.fileUri,
       Reference reference})
-      : this.deferredImports = imports ?? <DeferredImport>[],
+      : this.dependencies = dependencies ?? <LibraryDependency>[],
         this.typedefs = typedefs ?? <Typedef>[],
         this.classes = classes ?? <Class>[],
         this.procedures = procedures ?? <Procedure>[],
         this.fields = fields ?? <Field>[],
         super(reference) {
-    setParents(this.deferredImports, this);
+    setParents(this.dependencies, this);
     setParents(this.typedefs, this);
     setParents(this.classes, this);
     setParents(this.procedures, this);
     setParents(this.fields, this);
   }
 
   /// Returns the top-level fields and procedures defined in this library.
   ///
   /// This getter is for convenience, not efficiency.  Consider manually
   /// iterating the members to speed up code in production.
@@ skipping 31 matching lines @@
     }
     for (var member in procedures) {
       canonicalName.getChildFromMember(member).bindTo(member.reference);
     }
     for (var class_ in classes) {
       canonicalName.getChild(class_.name).bindTo(class_.reference);
       class_.computeCanonicalNames();
     }
   }
 
+  void addDependency(LibraryDependency node) {
+    dependencies.add(node..parent = this);
+  }
+
   accept(TreeVisitor v) => v.visitLibrary(this);
 
   visitChildren(Visitor v) {
-    visitList(deferredImports, v);
+    visitList(dependencies, v);
     visitList(typedefs, v);
     visitList(classes, v);
     visitList(procedures, v);
     visitList(fields, v);
   }
 
   transformChildren(Transformer v) {
-    transformList(deferredImports, v, this);
+    transformList(dependencies, v, this);
     transformList(typedefs, v, this);
     transformList(classes, v, this);
     transformList(procedures, v, this);
     transformList(fields, v, this);
   }
 
   static int _libraryIdCounter = 0;
   int _libraryId = ++_libraryIdCounter;
 
   int compareTo(Library other) => _libraryId - other._libraryId;
 
   /// Returns a possibly synthesized name for this library, consistent with
   /// the names across all [toString] calls.
   String toString() => debugLibraryName(this);
 
   Location _getLocationInEnclosingFile(int offset) {
     return enclosingProgram.getLocation(fileUri, offset);
   }
 }
 
-/// An import of form: `import <url> deferred as <name>;`.
-class DeferredImport extends TreeNode {
+/// An import or export declaration in a library.
+///
+/// It can represent any of the following forms,
+///
+///     import <url>;
+///     import <url> as <name>;
+///     import <url> deferred as <name>;
+///     export <url>;
+///
+/// optionally with metadata and [Combinators].
+class LibraryDependency extends TreeNode {
+  int flags;
+
+  final List<Expression> annotations;
+
   Reference importedLibraryReference;
+
+  /// The name of the import prefix, if any, or `null` if this is not an import
+  /// with a prefix.
+  ///
+  /// Must be non-null for deferred imports, and must be null for exports.
   String name;
 
-  DeferredImport(Library importedLibrary, String name)
-      : this.byReference(importedLibrary.reference, name);
+  final List<Combinator> combinators;
 
-  DeferredImport.byReference(this.importedLibraryReference, this.name);
+  LibraryDependency(int flags, List<Expression> annotations,
+      Library importedLibrary, String name, List<Combinator> combinators)
+      : this.byReference(
+            flags, annotations, importedLibrary.reference, name, combinators);
+
+  LibraryDependency.deferredImport(Library importedLibrary, String name,
+      {List<Combinator> combinators, List<Expression> annotations})
+      : this.byReference(DeferredFlag, annotations ?? <Expression>[],
+            importedLibrary.reference, name, combinators ?? <Combinator>[]);
+
+  LibraryDependency.import(Library importedLibrary,
+      {String name, List<Combinator> combinators, List<Expression> annotations})
+      : this.byReference(0, annotations ?? <Expression>[],
+            importedLibrary.reference, name, combinators ?? <Combinator>[]);
+
+  LibraryDependency.export(Library importedLibrary,
+      {List<Combinator> combinators, List<Expression> annotations})
+      : this.byReference(ExportFlag, annotations ?? <Expression>[],
+            importedLibrary.reference, null, combinators ?? <Combinator>[]);
+
+  LibraryDependency.byReference(this.flags, this.annotations,
+      this.importedLibraryReference, this.name, this.combinators) {
+    setParents(annotations, this);
+    setParents(combinators, this);
+  }
 
   Library get enclosingLibrary => parent;
-  Library get importedLibrary => importedLibraryReference.asLibrary;
+  Library get targetLibrary => importedLibraryReference.asLibrary;
 
-  accept(TreeVisitor v) => v.visitDeferredImport(this);
+  static const int ExportFlag = 1 << 0;
+  static const int DeferredFlag = 1 << 1;
 
+  bool get isExport => flags & ExportFlag != 0;
+  bool get isImport => !isExport;
+  bool get isDeferred => flags & DeferredFlag != 0;
+
+  void addAnnotation(Expression annotation) {
+    annotations.add(annotation..parent = this);
+  }
+
+  accept(TreeVisitor v) => v.visitLibraryDependency(this);
+
+  visitChildren(Visitor v) {
+    visitList(annotations, v);
+    visitList(combinators, v);
+  }
+
+  transformChildren(Transformer v) {
+    transformList(annotations, v, this);
+    transformList(combinators, v, this);
+  }
+}
+
+/// A `show` or `hide` clause for an import or export.
+class Combinator extends TreeNode {
+  bool isShow;
+  final List<String> names;
+
+  LibraryDependency get dependency => parent;
+
+  Combinator(this.isShow, this.names);
+  Combinator.show(this.names) : isShow = true;
+  Combinator.hide(this.names) : isShow = false;
+
+  bool get isHide => !isShow;
+
+  @override
+  accept(TreeVisitor v) => v.visitCombinator(this);
+
+  @override
   visitChildren(Visitor v) {}
 
+  @override
   transformChildren(Transformer v) {}
 }
 
 /// Declaration of a type alias.
 class Typedef extends NamedNode {
   /// The uri of the source file that contains the declaration of this typedef.
   String fileUri;
   List<Expression> annotations = const <Expression>[];
   String name;
   final List<TypeParameter> typeParameters;
@@ skipping 2386 matching lines @@
 /// - keeping track of whether the library code has already been downloaded
 /// - actually downloading and linking the library
 ///
 /// Should return a future.  The value in this future will be the same value
 /// seen by callers of `loadLibrary` functions.
 ///
 /// On backends that link the entire program eagerly, this instruction needs
 /// to mark the deferred import as 'loaded' and return a future.
 class LoadLibrary extends Expression {
   /// Reference to a deferred import in the enclosing library.
-  DeferredImport import;
+  LibraryDependency import;
 
   LoadLibrary(this.import);
 
   DartType getStaticType(TypeEnvironment types) {
     return types.futureType(const DynamicType());
   }
 
   accept(ExpressionVisitor v) => v.visitLoadLibrary(this);
   accept1(ExpressionVisitor1 v, arg) => v.visitLoadLibrary(this, arg);
 
   visitChildren(Visitor v) {}
   transformChildren(Transformer v) {}
 }
 
 /// Checks that the given deferred import has been marked as 'loaded'.
 class CheckLibraryIsLoaded extends Expression {
   /// Reference to a deferred import in the enclosing library.
-  DeferredImport import;
+  LibraryDependency import;
 
   CheckLibraryIsLoaded(this.import);
 
   DartType getStaticType(TypeEnvironment types) {
     return types.objectType;
   }
 
   accept(ExpressionVisitor v) => v.visitCheckLibraryIsLoaded(this);
   accept1(ExpressionVisitor1 v, arg) => v.visitCheckLibraryIsLoaded(this, arg);
 
@@ skipping 1686 matching lines @@
 /// typedef has not been assigned a canonical name yet.
 ///
 /// Returns `null` if the typedef is `null`.
 CanonicalName getCanonicalNameOfTypedef(Typedef typedef_) {
   if (typedef_ == null) return null;
   if (typedef_.canonicalName == null) {
     throw '$typedef_ has no canonical name';
   }
   return typedef_.canonicalName;
 }