Fresh drop of analyzer-experimental.

pkg/analyzer-experimental/lib/src/generated/sdk.dart

Index: pkg/analyzer-experimental/lib/src/generated/sdk.dart
===================================================================
--- pkg/analyzer-experimental/lib/src/generated/sdk.dart	(revision 0)
+++ pkg/analyzer-experimental/lib/src/generated/sdk.dart	(revision 0)
@@ -0,0 +1,662 @@
+// 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.sdk;
+
+import 'dart:io';
+import 'dart:uri';
+import 'java_core.dart';
+import 'java_engine.dart';
+import 'package:analyzer-experimental/src/generated/source.dart';
+import 'package:analyzer-experimental/src/generated/error.dart';
+import 'package:analyzer-experimental/src/generated/scanner.dart';
+import 'package:analyzer-experimental/src/generated/parser.dart';
+import 'package:analyzer-experimental/src/generated/ast.dart';
+import 'package:analyzer-experimental/src/generated/engine.dart' show AnalysisEngine;
+
+/**
+ * Represents a single library in the SDK
+ */
+abstract class SdkLibrary {
+  /**
+   * Return the name of the category containing the library.
+   * @return the name of the category containing the library
+   */
+  String get category;
+  /**
+   * Return the path to the file defining the library. The path is relative to the {@code lib}directory within the SDK.
+   * @return the path to the file defining the library
+   */
+  String get path;
+  /**
+   * Return the short name of the library. This is the name used after {@code dart:} in a URI.
+   * @return the short name of the library
+   */
+  String get shortName;
+  /**
+   * Return {@code true} if this library can be compiled to JavaScript by dart2js.
+   * @return {@code true} if this library can be compiled to JavaScript by dart2js
+   */
+  bool isDart2JsLibrary();
+  /**
+   * Return {@code true} if the library is documented.
+   * @return {@code true} if the library is documented
+   */
+  bool isDocumented();
+  /**
+   * Return {@code true} if the library is an implementation library.
+   * @return {@code true} if the library is an implementation library
+   */
+  bool isImplementation();
+  /**
+   * Return {@code true} if library can be used for both client and server.
+   * @return {@code true} if this library can be used for both client and server.
+   */
+  bool isShared();
+  /**
+   * Return {@code true} if this library can be run on the VM.
+   * @return {@code true} if this library can be run on the VM
+   */
+  bool isVmLibrary();
+}
+/**
+ * Instances of the class {@code LibraryMap} map Dart library URI's to the {@link SdkLibraryImpllibrary}.
+ */
+class LibraryMap {
+  /**
+   * A table mapping Dart library URI's to the library.
+   */
+  Map<String, SdkLibraryImpl> _libraryMap = new Map<String, SdkLibraryImpl>();
+  /**
+   * Initialize a newly created library map to be empty.
+   */
+  LibraryMap() : super() {
+  }
+  /**
+   * Return the library with the given URI, or {@code null} if the URI does not map to a library.
+   * @param dartUri the URI of the library to be returned
+   * @return the library with the given URI
+   */
+  SdkLibrary getLibrary(String dartUri) => _libraryMap[dartUri];
+  /**
+   * Return an array containing all the sdk libraries {@link SdkLibraryImpl} in the mapping
+   * @return the sdk libraries in the mapping
+   */
+  List<SdkLibrary> get sdkLibraries => new List.from(_libraryMap.values);
+  /**
+   * Return an array containing the library URI's for which a mapping is available.
+   * @return the library URI's for which a mapping is available
+   */
+  List<String> get uris => new List.from(_libraryMap.keys.toSet());
+  /**
+   * Return the library with the given URI, or {@code null} if the URI does not map to a library.
+   * @param dartUri the URI of the library to be returned
+   * @param library the library with the given URI
+   */
+  void setLibrary(String dartUri, SdkLibraryImpl library) {
+    _libraryMap[dartUri] = library;
+  }
+  /**
+   * Return the number of library URI's for which a mapping is available.
+   * @return the number of library URI's for which a mapping is available
+   */
+  int size() => _libraryMap.length;
+}
+/**
+ * Instances of the class {@code DartSdk} represent a Dart SDK installed in a specified location.
+ */
+class DartSdk {
+  /**
+   * The short name of the dart SDK html library.
+   */
+  static String DART_HTML = "dart:html";
+  /**
+   * The directory containing the SDK.
+   */
+  File _sdkDirectory;
+  /**
+   * The revision number of this SDK, or {@code "0"} if the revision number cannot be discovered.
+   */
+  String _sdkVersion;
+  /**
+   * The file containing the Dartium executable.
+   */
+  File _dartiumExecutable;
+  /**
+   * The file containing the VM executable.
+   */
+  File _vmExecutable;
+  /**
+   * A mapping from Dart library URI's to the library represented by that URI.
+   */
+  LibraryMap _libraryMap;
+  /**
+   * The name of the directory within the SDK directory that contains executables.
+   */
+  static String _BIN_DIRECTORY_NAME = "bin";
+  /**
+   * The name of the directory within the SDK directory that contains Chromium.
+   */
+  static String _CHROMIUM_DIRECTORY_NAME = "chromium";
+  /**
+   * The name of the environment variable whose value is the path to the default Dart SDK directory.
+   */
+  static String _DART_SDK_ENVIRONMENT_VARIABLE_NAME = "DART_SDK";
+  /**
+   * The name of the file containing the Dartium executable on Linux.
+   */
+  static String _DARTIUM_EXECUTABLE_NAME_LINUX = "chromium/chrome";
+  /**
+   * The name of the file containing the Dartium executable on Macintosh.
+   */
+  static String _DARTIUM_EXECUTABLE_NAME_MAC = "Chromium.app/Contents/MacOS/Chromium";
+  /**
+   * The name of the file containing the Dartium executable on Windows.
+   */
+  static String _DARTIUM_EXECUTABLE_NAME_WIN = "chromium/Chrome.exe";
+  /**
+   * The name of the {@link System} property whose value is the path to the default Dart SDK
+   * directory.
+   */
+  static String _DEFAULT_DIRECTORY_PROPERTY_NAME = "com.google.dart.sdk";
+  /**
+   * The version number that is returned when the real version number could not be determined.
+   */
+  static String _DEFAULT_VERSION = "0";
+  /**
+   * The name of the directory within the SDK directory that contains documentation for the
+   * libraries.
+   */
+  static String _DOCS_DIRECTORY_NAME = "docs";
+  /**
+   * The suffix added to the name of a library to derive the name of the file containing the
+   * documentation for that library.
+   */
+  static String _DOC_FILE_SUFFIX = "_api.json";
+  /**
+   * The name of the directory within the SDK directory that contains the libraries file.
+   */
+  static String _INTERNAL_DIR = "_internal";
+  /**
+   * The name of the directory within the SDK directory that contains the libraries.
+   */
+  static String _LIB_DIRECTORY_NAME = "lib";
+  /**
+   * The name of the libraries file.
+   */
+  static String _LIBRARIES_FILE = "libraries.dart";
+  /**
+   * The name of the directory within the SDK directory that contains the packages.
+   */
+  static String _PKG_DIRECTORY_NAME = "pkg";
+  /**
+   * The name of the file within the SDK directory that contains the revision number of the SDK.
+   */
+  static String _REVISION_FILE_NAME = "revision";
+  /**
+   * The name of the file containing the VM executable on the Windows operating system.
+   */
+  static String _VM_EXECUTABLE_NAME_WIN = "dart.exe";
+  /**
+   * The name of the file containing the VM executable on non-Windows operating systems.
+   */
+  static String _VM_EXECUTABLE_NAME = "dart";
+  /**
+   * Return the default Dart SDK, or {@code null} if the directory containing the default SDK cannot
+   * be determined (or does not exist).
+   * @return the default Dart SDK
+   */
+  static DartSdk get defaultSdk {
+    File sdkDirectory = defaultSdkDirectory;
+    if (sdkDirectory == null) {
+      return null;
+    }
+    return new DartSdk(sdkDirectory);
+  }
+  /**
+   * Return the default directory for the Dart SDK, or {@code null} if the directory cannot be
+   * determined (or does not exist). The default directory is provided by a {@link System} property
+   * named {@code com.google.dart.sdk}, or, if the property is not defined, an environment variable
+   * named {@code DART_SDK}.
+   * @return the default directory for the Dart SDK
+   */
+  static File get defaultSdkDirectory {
+    String sdkProperty = System.getProperty(_DEFAULT_DIRECTORY_PROPERTY_NAME);
+    if (sdkProperty == null) {
+      sdkProperty = System.getenv(_DART_SDK_ENVIRONMENT_VARIABLE_NAME);
+      if (sdkProperty == null) {
+        return null;
+      }
+    }
+    File sdkDirectory = new File(sdkProperty);
+    if (!sdkDirectory.existsSync()) {
+      return null;
+    }
+    return sdkDirectory;
+  }
+  /**
+   * Initialize a newly created SDK to represent the Dart SDK installed in the given directory.
+   * @param sdkDirectory the directory containing the SDK
+   */
+  DartSdk(File sdkDirectory) {
+    this._sdkDirectory = getAbsoluteFile(sdkDirectory);
+    initializeSdk();
+    initializeLibraryMap();
+  }
+  /**
+   * Return the file containing the Dartium executable, or {@code null} if it does not exist.
+   * @return the file containing the Dartium executable
+   */
+  File get dartiumExecutable {
+    {
+      if (_dartiumExecutable == null) {
+        File file = newRelativeFile(_sdkDirectory, dartiumBinaryName);
+        if (file.existsSync()) {
+          _dartiumExecutable = file;
+        }
+      }
+    }
+    return _dartiumExecutable;
+  }
+  /**
+   * Return the directory where dartium can be found in the Dart SDK (the directory that will be the
+   * working directory is Dartium is invoked without changing the default).
+   * @return the directory where dartium can be found
+   */
+  File get dartiumWorkingDirectory {
+    if (OSUtilities.isWindows() || OSUtilities.isMac()) {
+      return _sdkDirectory;
+    } else {
+      return newRelativeFile(_sdkDirectory, _CHROMIUM_DIRECTORY_NAME);
+    }
+  }
+  /**
+   * Return the directory containing the SDK.
+   * @return the directory containing the SDK
+   */
+  File get directory => _sdkDirectory;
+  /**
+   * Return the directory containing documentation for the SDK.
+   * @return the SDK's documentation directory
+   */
+  File get docDirectory => newRelativeFile(_sdkDirectory, _DOCS_DIRECTORY_NAME);
+  /**
+   * Return the auxiliary documentation file for the given library, or {@code null} if no such file
+   * exists.
+   * @param libraryName the name of the library associated with the documentation file to be
+   * returned
+   * @return the auxiliary documentation file for the library
+   */
+  File getDocFileFor(String libraryName) {
+    File dir = docDirectory;
+    if (!dir.existsSync()) {
+      return null;
+    }
+    File libDir = newRelativeFile(dir, libraryName);
+    File docFile = newRelativeFile(libDir, "${libraryName}${_DOC_FILE_SUFFIX}");
+    if (docFile.existsSync()) {
+      return docFile;
+    }
+    return null;
+  }
+  /**
+   * Return the directory within the SDK directory that contains the libraries.
+   * @return the directory that contains the libraries
+   */
+  File get libraryDirectory => newRelativeFile(_sdkDirectory, _LIB_DIRECTORY_NAME);
+  /**
+   * Return the directory within the SDK directory that contains the packages.
+   * @return the directory that contains the packages
+   */
+  File get packageDirectory => newRelativeFile(directory, _PKG_DIRECTORY_NAME);
+  /**
+   * Return an array containing all of the libraries defined in this SDK.
+   * @return the libraries defined in this SDK
+   */
+  List<SdkLibrary> get sdkLibraries => _libraryMap.sdkLibraries;
+  /**
+   * Return the revision number of this SDK, or {@code "0"} if the revision number cannot be
+   * discovered.
+   * @return the revision number of this SDK
+   */
+  String get sdkVersion {
+    {
+      if (_sdkVersion == null) {
+        _sdkVersion = _DEFAULT_VERSION;
+        File revisionFile = newRelativeFile(_sdkDirectory, _REVISION_FILE_NAME);
+        try {
+          String revision = revisionFile.readAsStringSync();
+          if (revision != null) {
+            _sdkVersion = revision;
+          }
+        } on IOException catch (exception) {
+        }
+      }
+    }
+    return _sdkVersion;
+  }
+  /**
+   * Return an array containing the library URI's for the libraries defined in this SDK.
+   * @return the library URI's for the libraries defined in this SDK
+   */
+  List<String> get uris => _libraryMap.uris;
+  /**
+   * Return the file containing the VM executable, or {@code null} if it does not exist.
+   * @return the file containing the VM executable
+   */
+  File get vmExecutable {
+    {
+      if (_vmExecutable == null) {
+        File file = newRelativeFile(newRelativeFile(_sdkDirectory, _BIN_DIRECTORY_NAME), binaryName);
+        if (file.existsSync()) {
+          _vmExecutable = file;
+        }
+      }
+    }
+    return _vmExecutable;
+  }
+  /**
+   * Return {@code true} if this SDK includes documentation.
+   * @return {@code true} if this installation of the SDK has documentation
+   */
+  bool hasDocumentation() => docDirectory.existsSync();
+  /**
+   * Return {@code true} if the Dartium binary is available.
+   * @return {@code true} if the Dartium binary is available
+   */
+  bool isDartiumInstalled() => dartiumExecutable != null;
+  /**
+   * Return the file representing the library with the given {@code dart:} URI, or {@code null} if
+   * the given URI does not denote a library in this SDK.
+   * @param dartUri the URI of the library to be returned
+   * @return the file representing the specified library
+   */
+  File mapDartUri(String dartUri) {
+    SdkLibrary library = _libraryMap.getLibrary(dartUri);
+    if (library == null) {
+      return null;
+    }
+    return newRelativeFile(libraryDirectory, library.path);
+  }
+  /**
+   * Ensure that the dart VM is executable. If it is not, make it executable and log that it was
+   * necessary for us to do so.
+   */
+  void ensureVmIsExecutable() {
+  }
+  /**
+   * Return the name of the file containing the VM executable.
+   * @return the name of the file containing the VM executable
+   */
+  String get binaryName {
+    if (OSUtilities.isWindows()) {
+      return _VM_EXECUTABLE_NAME_WIN;
+    } else {
+      return _VM_EXECUTABLE_NAME;
+    }
+  }
+  /**
+   * Return the name of the file containing the Dartium executable.
+   * @return the name of the file containing the Dartium executable
+   */
+  String get dartiumBinaryName {
+    if (OSUtilities.isWindows()) {
+      return _DARTIUM_EXECUTABLE_NAME_WIN;
+    } else if (OSUtilities.isMac()) {
+      return _DARTIUM_EXECUTABLE_NAME_MAC;
+    } else {
+      return _DARTIUM_EXECUTABLE_NAME_LINUX;
+    }
+  }
+  /**
+   * Read all of the configuration files to initialize the library maps.
+   */
+  void initializeLibraryMap() {
+    try {
+      File librariesFile = newRelativeFile(newRelativeFile(libraryDirectory, _INTERNAL_DIR), _LIBRARIES_FILE);
+      String contents = librariesFile.readAsStringSync();
+      _libraryMap = new SdkLibrariesReader().readFrom(librariesFile, contents);
+    } on JavaException catch (exception) {
+      AnalysisEngine.instance.logger.logError3(exception);
+      _libraryMap = new LibraryMap();
+    }
+  }
+  /**
+   * Initialize the state of the SDK.
+   */
+  void initializeSdk() {
+    if (!OSUtilities.isWindows()) {
+      ensureVmIsExecutable();
+    }
+  }
+}
+/**
+ * Instances of the class {@code SdkLibrariesReader} read and parse the libraries file
+ * (dart-sdk/lib/_internal/libraries.dart) for information about the libraries in an SDK. The
+ * library information is represented as a Dart file containing a single top-level variable whose
+ * value is a const map. The keys of the map are the names of libraries defined in the SDK and the
+ * values in the map are info objects defining the library. For example, a subset of a typical SDK
+ * might have a libraries file that looks like the following:
+ * <pre>
+ * final Map&lt;String, LibraryInfo&gt; LIBRARIES = const &lt;LibraryInfo&gt; {
+ * // Used by VM applications
+ * "builtin" : const LibraryInfo(
+ * "builtin/builtin_runtime.dart",
+ * category: "Server",
+ * platforms: VM_PLATFORM),
+ * "compiler" : const LibraryInfo(
+ * "compiler/compiler.dart",
+ * category: "Tools",
+ * platforms: 0),
+ * };
+ * </pre>
+ */
+class SdkLibrariesReader {
+  /**
+   * Return the library map read from the given source.
+   * @return the library map read from the given source
+   */
+  LibraryMap readFrom(File librariesFile, String libraryFileContents) {
+    List<bool> foundError = [false];
+    AnalysisErrorListener errorListener = new AnalysisErrorListener_3(foundError);
+    Source source = new FileBasedSource.con2(null, librariesFile, false);
+    StringScanner scanner = new StringScanner(source, libraryFileContents, errorListener);
+    Parser parser = new Parser(source, errorListener);
+    CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
+    SdkLibrariesReader_LibraryBuilder libraryBuilder = new SdkLibrariesReader_LibraryBuilder();
+    if (!foundError[0]) {
+      unit.accept(libraryBuilder);
+    }
+    return libraryBuilder.librariesMap;
+  }
+}
+class SdkLibrariesReader_LibraryBuilder extends RecursiveASTVisitor<Object> {
+  /**
+   * The prefix added to the name of a library to form the URI used in code to reference the
+   * library.
+   */
+  static String _LIBRARY_PREFIX = "dart:";
+  /**
+   * The name of the optional parameter used to indicate whether the library is an implementation
+   * library.
+   */
+  static String _IMPLEMENTATION = "implementation";
+  /**
+   * The name of the optional parameter used to indicate whether the library is documented.
+   */
+  static String _DOCUMENTED = "documented";
+  /**
+   * The name of the optional parameter used to specify the category of the library.
+   */
+  static String _CATEGORY = "category";
+  /**
+   * The name of the optional parameter used to specify the platforms on which the library can be
+   * used.
+   */
+  static String _PLATFORMS = "platforms";
+  /**
+   * The value of the {@link #PLATFORMS platforms} parameter used to specify that the library can
+   * be used on the VM.
+   */
+  static String _VM_PLATFORM = "VM_PLATFORM";
+  /**
+   * The library map that is populated by visiting the AST structure parsed from the contents of
+   * the libraries file.
+   */
+  LibraryMap _librariesMap = new LibraryMap();
+  /**
+   * Return the library map that was populated by visiting the AST structure parsed from the
+   * contents of the libraries file.
+   * @return the library map describing the contents of the SDK
+   */
+  LibraryMap get librariesMap => _librariesMap;
+  Object visitMapLiteralEntry(MapLiteralEntry node) {
+    String libraryName = null;
+    Expression key3 = node.key;
+    if (key3 is SimpleStringLiteral) {
+      libraryName = "${_LIBRARY_PREFIX}${((key3 as SimpleStringLiteral)).value}";
+    }
+    Expression value8 = node.value;
+    if (value8 is InstanceCreationExpression) {
+      SdkLibraryImpl library = new SdkLibraryImpl(libraryName);
+      List<Expression> arguments6 = ((value8 as InstanceCreationExpression)).argumentList.arguments;
+      for (Expression argument in arguments6) {
+        if (argument is SimpleStringLiteral) {
+          library.path = ((argument as SimpleStringLiteral)).value;
+        } else if (argument is NamedExpression) {
+          String name18 = ((argument as NamedExpression)).name.label.name;
+          Expression expression15 = ((argument as NamedExpression)).expression;
+          if (name18 == _CATEGORY) {
+            library.category = ((expression15 as SimpleStringLiteral)).value;
+          } else if (name18 == _IMPLEMENTATION) {
+            library.implementation = ((expression15 as BooleanLiteral)).value;
+          } else if (name18 == _DOCUMENTED) {
+            library.documented = ((expression15 as BooleanLiteral)).value;
+          } else if (name18 == _PLATFORMS) {
+            if (expression15 is SimpleIdentifier) {
+              String identifier = ((expression15 as SimpleIdentifier)).name;
+              if (identifier == _VM_PLATFORM) {
+                library.setVmLibrary();
+              } else {
+                library.setDart2JsLibrary();
+              }
+            }
+          }
+        }
+      }
+      _librariesMap.setLibrary(libraryName, library);
+    }
+    return null;
+  }
+}
+class AnalysisErrorListener_3 implements AnalysisErrorListener {
+  List<bool> foundError;
+  AnalysisErrorListener_3(this.foundError);
+  void onError(AnalysisError error) {
+    foundError[0] = true;
+  }
+}
+/**
+ * Instances of the class {@code SdkLibrary} represent the information known about a single library
+ * within the SDK.
+ */
+class SdkLibraryImpl implements SdkLibrary {
+  /**
+   * The short name of the library. This is the name used after {@code dart:} in a URI.
+   */
+  String _shortName = null;
+  /**
+   * The path to the file defining the library. The path is relative to the {@code lib} directory
+   * within the SDK.
+   */
+  String _path = null;
+  /**
+   * The name of the category containing the library. Unless otherwise specified in the libraries
+   * file all libraries are assumed to be shared between server and client.
+   */
+  String _category = "Shared";
+  /**
+   * A flag indicating whether the library is documented.
+   */
+  bool _documented = true;
+  /**
+   * A flag indicating whether the library is an implementation library.
+   */
+  bool _implementation = false;
+  /**
+   * An encoding of which platforms this library is intended to work on.
+   */
+  int _platforms = 0;
+  /**
+   * The bit mask used to access the bit representing the flag indicating whether a library is
+   * intended to work on the dart2js platform.
+   */
+  static int DART2JS_PLATFORM = 1;
+  /**
+   * The bit mask used to access the bit representing the flag indicating whether a library is
+   * intended to work on the VM platform.
+   */
+  static int VM_PLATFORM = 2;
+  /**
+   * Initialize a newly created library to represent the library with the given name.
+   * @param name the short name of the library
+   */
+  SdkLibraryImpl(String name) {
+    this._shortName = name;
+  }
+  String get category => _category;
+  String get path => _path;
+  String get shortName => _shortName;
+  bool isDart2JsLibrary() => (_platforms & DART2JS_PLATFORM) != 0;
+  bool isDocumented() => _documented;
+  bool isImplementation() => _implementation;
+  /**
+   * Return {@code true} if library can be used for both client and server
+   */
+  bool isShared() => _category == "Shared";
+  /**
+   * Return {@code true} if this library can be run on the VM.
+   * @return {@code true} if this library can be run on the VM
+   */
+  bool isVmLibrary() => (_platforms & VM_PLATFORM) != 0;
+  /**
+   * Set the name of the category containing the library to the given name.
+   * @param category the name of the category containing the library
+   */
+  void set category(String category2) {
+    this._category = category2;
+  }
+  /**
+   * Record that this library can be compiled to JavaScript by dart2js.
+   */
+  void setDart2JsLibrary() {
+    _platforms |= DART2JS_PLATFORM;
+  }
+  /**
+   * Set whether the library is documented to match the given value.
+   * @param documented {@code true} if the library is documented
+   */
+  void set documented(bool documented2) {
+    this._documented = documented2;
+  }
+  /**
+   * Set whether the library is an implementation library to match the given value.
+   * @param implementation {@code true} if the library is an implementation library
+   */
+  void set implementation(bool implementation2) {
+    this._implementation = implementation2;
+  }
+  /**
+   * Set the path to the file defining the library to the given path. The path is relative to the{@code lib} directory within the SDK.
+   * @param path the path to the file defining the library
+   */
+  void set path(String path2) {
+    this._path = path2;
+  }
+  /**
+   * Record that this library can be run on the VM.
+   */
+  void setVmLibrary() {
+    _platforms |= VM_PLATFORM;
+  }
+}