Add public and export namespaces to LibraryElement.

pkg/analyzer/lib/src/generated/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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 6366 matching lines @@
     }
     InterfaceTypeImpl newType = new InterfaceTypeImpl.con1(element);
     newType.typeArguments = newTypeArguments;
     return newType;
   }
 
   @override
   InterfaceTypeImpl substitute4(List<DartType> argumentTypes) =>
       substitute2(argumentTypes, typeArguments);
 
+  /**
+   * Return `true` if the given element has an instance method named 'call'.
+   */
+  bool _hasCallMethod(ClassElement elementT) {
+    MethodElement method = elementT.lookUpMethod(
+        FunctionElement.CALL_METHOD_NAME, elementT.library);
+    return method != null && !method.isStatic;
+  }
+
   bool _isMoreSpecificThan(InterfaceType s,
       HashSet<ClassElement> visitedClasses, bool withDynamic,
       Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // A type T is more specific than a type S, written T << S,
     // if one of the following conditions is met:
     //
     // Reflexivity: T is S.
     //
     if (this == s) {
@@ skipping 111 matching lines @@
     for (InterfaceType mixinType in mixinTypes) {
       if ((mixinType as InterfaceTypeImpl)._isSubtypeOf(
           typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Return `true` if the given element has an instance method named 'call'.
-   */
-  bool _hasCallMethod(ClassElement elementT) {
-    MethodElement method = elementT.lookUpMethod(
-        FunctionElement.CALL_METHOD_NAME, elementT.library);
-    return method != null && !method.isStatic;
-  }
-
-  /**
    * Return the length of the longest inheritance path from the given [type] to
    * Object.
    *
    * See [InterfaceType.getLeastUpperBound].
    */
   static int computeLongestInheritancePathToObject(InterfaceType type) =>
       _computeLongestInheritancePathToObject(
           type, 0, new HashSet<ClassElement>());
 
   /**
@@ skipping 170 matching lines @@
    */
   FunctionElement get entryPoint;
 
   /**
    * Return a list containing all of the libraries that are exported from this
    * library.
    */
   List<LibraryElement> get exportedLibraries;
 
   /**
+   * The export [Namespace] of this library, `null` if it has not been
+   * computed yet.
+   */
+  Namespace get exportNamespace;
+
+  /**
    * Return a list containing all of the exports defined in this library.
    */
   List<ExportElement> get exports;
 
   /**
    * Return `true` if the defining compilation unit of this library contains at
    * least one import directive whose URI uses the "dart-ext" scheme.
    */
   bool get hasExtUri;
 
@@ skipping 47 matching lines @@
   List<CompilationUnitElement> get parts;
 
   /**
    * Return a list containing elements for each of the prefixes used to `import`
    * libraries into this library. Each prefix can be used in more than one
    * `import` directive.
    */
   List<PrefixElement> get prefixes;
 
   /**
+   * The public [Namespace] of this library, `null` if it has not been
+   * computed yet.
+   */
+  Namespace get publicNamespace;
+
+  /**
    * Return a list containing all of the compilation units this library consists
    * of. This includes the defining compilation unit and units included using
    * the `part` directive.
    */
   List<CompilationUnitElement> get units;
 
   /**
    * Return a list containing all directly and indirectly imported libraries.
    */
   List<LibraryElement> get visibleLibraries;
@@ skipping 61 matching lines @@
    */
   List<CompilationUnitElement> _parts = CompilationUnitElementImpl.EMPTY_ARRAY;
 
   /**
    * The element representing the synthetic function `loadLibrary` that is
    * defined for this library, or `null` if the element has not yet been created.
    */
   FunctionElement _loadLibraryFunction;
 
   /**
+   * The export [Namespace] of this library, `null` if it has not been
+   * computed yet.
+   */
+  @override
+  Namespace exportNamespace;
+
+  /**
+   * The public [Namespace] of this library, `null` if it has not been
+   * computed yet.
+   */
+  @override
+  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)
       : super(name, offset);
 
   /**
    * Initialize a newly created library element in the given [context] to have
    * the given [name].
    */
@@ skipping 3557 matching lines @@
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }