Removed fixed dependencies

packages/analyzer/lib/src/generated/sdk_io.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.
 
-library engine.sdk.io;
-
+@deprecated
+library analyzer.src.generated.sdk_io;
+
+import 'dart:collection';
 import 'dart:io';
 
-import 'package:analyzer/src/context/context.dart' as newContext;
-import 'package:analyzer/src/generated/java_engine.dart';
-
-import 'ast.dart';
-import 'engine.dart';
-import 'error.dart';
-import 'java_core.dart';
-import 'java_engine_io.dart';
-import 'java_io.dart';
-import 'parser.dart';
-import 'scanner.dart';
-import 'sdk.dart';
-import 'source_io.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/context/context.dart';
+import 'package:analyzer/src/dart/scanner/reader.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/error.dart';
+import 'package:analyzer/src/generated/java_engine_io.dart';
+import 'package:analyzer/src/generated/java_io.dart';
+import 'package:analyzer/src/generated/parser.dart';
+import 'package:analyzer/src/generated/sdk.dart';
+import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/summary/idl.dart' show PackageBundle;
+import 'package:analyzer/src/summary/summary_sdk.dart';
+import 'package:path/path.dart' as pathos;
+
+/**
+ * An abstract implementation of a Dart SDK in which the available libraries are
+ * stored in a library map. Subclasses are responsible for populating the
+ * library map.
+ */
+@deprecated
+abstract class AbstractDartSdk implements DartSdk {
+  /**
+   * A mapping from Dart library URI's to the library represented by that URI.
+   */
+  LibraryMap libraryMap = new LibraryMap();
+
+  /**
+   * The [AnalysisOptions] to use to create the [context].
+   */
+  AnalysisOptions _analysisOptions;
+
+  /**
+   * The flag that specifies whether an SDK summary should be used. This is a
+   * temporary flag until summaries are enabled by default.
+   */
+  bool _useSummary = false;
+
+  /**
+   * The [AnalysisContext] which is used for all of the sources in this SDK.
+   */
+  InternalAnalysisContext _analysisContext;
+
+  /**
+   * The mapping from Dart URI's to the corresponding sources.
+   */
+  Map<String, Source> _uriToSourceMap = new HashMap<String, Source>();
+
+  /**
+   * Set the [options] for this SDK analysis context.  Throw [StateError] if the
+   * context has been already created.
+   */
+  void set analysisOptions(AnalysisOptions options) {
+    if (_analysisContext != null) {
+      throw new StateError(
+          'Analysis options cannot be changed after context creation.');
+    }
+    _analysisOptions = options;
+  }
+
+  @override
+  AnalysisContext get context {
+    if (_analysisContext == null) {
+      _analysisContext = new SdkAnalysisContext(_analysisOptions);
+      SourceFactory factory = new SourceFactory([new DartUriResolver(this)]);
+      _analysisContext.sourceFactory = factory;
+      if (_useSummary) {
+        bool strongMode = _analysisOptions?.strongMode ?? false;
+        PackageBundle sdkBundle = getSummarySdkBundle(strongMode);
+        if (sdkBundle != null) {
+          _analysisContext.resultProvider = new SdkSummaryResultProvider(
+              _analysisContext, sdkBundle, strongMode);
+        }
+      }
+    }
+    return _analysisContext;
+  }
+
+  @override
+  List<SdkLibrary> get sdkLibraries => libraryMap.sdkLibraries;
+
+  @override
+  List<String> get uris => libraryMap.uris;
+
+  /**
+   * Return `true` if the SDK summary will be used when available.
+   */
+  bool get useSummary => _useSummary;
+
+  /**
+   * Specify whether SDK summary should be used.
+   */
+  void set useSummary(bool use) {
+    if (_analysisContext != null) {
+      throw new StateError(
+          'The "useSummary" flag cannot be changed after context creation.');
+    }
+    _useSummary = use;
+  }
+
+  /**
+   * Add the extensions from one or more sdk extension files to this sdk. The
+   * [extensions] should be a table mapping the names of extensions to the paths
+   * where those extensions can be found.
+   */
+  void addExtensions(Map<String, String> extensions) {
+    extensions.forEach((String uri, String path) {
+      String shortName = uri.substring(uri.indexOf(':') + 1);
+      SdkLibraryImpl library = new SdkLibraryImpl(shortName);
+      library.path = path;
+      libraryMap.setLibrary(uri, library);
+    });
+  }
+
+  @override
+  Source fromFileUri(Uri uri) {
+    JavaFile file = new JavaFile.fromUri(uri);
+
+    String path = _getPath(file);
+    if (path == null) {
+      return null;
+    }
+    try {
+      return new FileBasedSource(file, Uri.parse(path));
+    } on FormatException catch (exception, stackTrace) {
+      AnalysisEngine.instance.logger.logInformation(
+          "Failed to create URI: $path",
+          new CaughtException(exception, stackTrace));
+    }
+    return null;
+  }
+
+  String getRelativePathFromFile(JavaFile file);
+
+  @override
+  SdkLibrary getSdkLibrary(String dartUri) => libraryMap.getLibrary(dartUri);
+
+  /**
+   * Return the [PackageBundle] for this SDK, if it exists, or `null` otherwise.
+   * This method should not be used outside of `analyzer` and `analyzer_cli`
+   * packages.
+   */
+  PackageBundle getSummarySdkBundle(bool strongMode);
+
+  FileBasedSource internalMapDartUri(String dartUri) {
+    // TODO(brianwilkerson) Figure out how to unify the implementations in the
+    // two subclasses.
+    String libraryName;
+    String relativePath;
+    int index = dartUri.indexOf('/');
+    if (index >= 0) {
+      libraryName = dartUri.substring(0, index);
+      relativePath = dartUri.substring(index + 1);
+    } else {
+      libraryName = dartUri;
+      relativePath = "";
+    }
+    SdkLibrary library = getSdkLibrary(libraryName);
+    if (library == null) {
+      return null;
+    }
+    String srcPath;
+    if (relativePath.isEmpty) {
+      srcPath = library.path;
+    } else {
+      String libraryPath = library.path;
+      int index = libraryPath.lastIndexOf(JavaFile.separator);
+      if (index == -1) {
+        index = libraryPath.lastIndexOf('/');
+        if (index == -1) {
+          return null;
+        }
+      }
+      String prefix = libraryPath.substring(0, index + 1);
+      srcPath = '$prefix$relativePath';
+    }
+    String filePath = srcPath.replaceAll('/', JavaFile.separator);
+    try {
+      JavaFile file = new JavaFile(filePath);
+      return new FileBasedSource(file, Uri.parse(dartUri));
+    } on FormatException {
+      return null;
+    }
+  }
+
+  @override
+  Source mapDartUri(String dartUri) {
+    Source source = _uriToSourceMap[dartUri];
+    if (source == null) {
+      source = internalMapDartUri(dartUri);
+      _uriToSourceMap[dartUri] = source;
+    }
+    return source;
+  }
+
+  String _getPath(JavaFile file) {
+    List<SdkLibrary> libraries = libraryMap.sdkLibraries;
+    int length = libraries.length;
+    List<String> paths = new List(length);
+    String filePath = getRelativePathFromFile(file);
+    if (filePath == null) {
+      return null;
+    }
+    for (int i = 0; i < length; i++) {
+      SdkLibrary library = libraries[i];
+      String libraryPath = library.path.replaceAll('/', JavaFile.separator);
+      if (filePath == libraryPath) {
+        return library.shortName;
+      }
+      paths[i] = libraryPath;
+    }
+    for (int i = 0; i < length; i++) {
+      SdkLibrary library = libraries[i];
+      String libraryPath = paths[i];
+      int index = libraryPath.lastIndexOf(JavaFile.separator);
+      if (index >= 0) {
+        String prefix = libraryPath.substring(0, index + 1);
+        if (filePath.startsWith(prefix)) {
+          String relPath = filePath
+              .substring(prefix.length)
+              .replaceAll(JavaFile.separator, '/');
+          return '${library.shortName}/$relPath';
+        }
+      }
+    }
+    return null;
+  }
+}
 
 /**
  * A Dart SDK installed in a specified directory. Typical Dart SDK layout is
  * something like...
  *
  *     dart-sdk/
  *        bin/
  *           dart[.exe]  <-- VM
  *        lib/
  *           core/
  *              core.dart
  *              ... other core library files ...
  *           ... other libraries ...
  *        util/
  *           ... Dart utilities ...
  *     Chromium/   <-- Dartium typically exists in a sibling directory
+ *
+ * This class is deprecated. Please use FolderBasedDartSdk instead.
  */
-class DirectoryBasedDartSdk implements DartSdk {
+@deprecated
+class DirectoryBasedDartSdk extends AbstractDartSdk {
   /**
    * The default SDK, or `null` if the default SDK either has not yet been
    * created or cannot be created for some reason.
    */
   static DirectoryBasedDartSdk _DEFAULT_SDK;
 
   /**
    * The name of the directory within the SDK directory that contains
    * executables.
    */
@@ skipping 132 matching lines @@
       return null;
     }
     JavaFile sdkDirectory = new JavaFile(sdkProperty);
     if (!sdkDirectory.exists()) {
       return null;
     }
     return sdkDirectory;
   }
 
   /**
-   * The [AnalysisContext] which is used for all of the sources in this sdk.
-   */
-  InternalAnalysisContext _analysisContext;
-
-  /**
    * The directory containing the SDK.
    */
   JavaFile _sdkDirectory;
 
   /**
+   * The directory within the SDK directory that contains the libraries.
+   */
+  JavaFile _libraryDirectory;
+
+  /**
    * The revision number of this SDK, or `"0"` if the revision number cannot be
    * discovered.
    */
   String _sdkVersion;
 
   /**
    * The file containing the dart2js executable.
    */
   JavaFile _dart2jsExecutable;
 
   /**
    * The file containing the Dartium executable.
    */
   JavaFile _dartiumExecutable;
 
   /**
    * The file containing the pub executable.
    */
   JavaFile _pubExecutable;
 
   /**
    * The file containing the VM executable.
    */
   JavaFile _vmExecutable;
 
   /**
-   * A mapping from Dart library URI's to the library represented by that URI.
-   */
-  LibraryMap _libraryMap;
-
-  /**
    * Initialize a newly created SDK to represent the Dart SDK installed in the
    * [sdkDirectory]. The flag [useDart2jsPaths] is `true` if the dart2js path
    * should be used when it is available
    */
   DirectoryBasedDartSdk(JavaFile sdkDirectory, [bool useDart2jsPaths = false]) {
     this._sdkDirectory = sdkDirectory.getAbsoluteFile();
-    _libraryMap = initialLibraryMap(useDart2jsPaths);
-  }
-
-  @override
-  AnalysisContext get context {
-    if (_analysisContext == null) {
-      if (AnalysisEngine.instance.useTaskModel) {
-        _analysisContext = new newContext.SdkAnalysisContext();
-      } else {
-        _analysisContext = new SdkAnalysisContext();
-      }
-      SourceFactory factory = new SourceFactory([new DartUriResolver(this)]);
-      _analysisContext.sourceFactory = factory;
-      List<String> uris = this.uris;
-      ChangeSet changeSet = new ChangeSet();
-      for (String uri in uris) {
-        changeSet.addedSource(factory.forUri(uri));
-      }
-      _analysisContext.applyChanges(changeSet);
-    }
-    return _analysisContext;
+    libraryMap = initialLibraryMap(useDart2jsPaths);
   }
 
   /**
    * Return the file containing the dart2js executable, or `null` if it does not
    * exist.
    */
   JavaFile get dart2JsExecutable {
     if (_dart2jsExecutable == null) {
       _dart2jsExecutable = _verifyExecutable(new JavaFile.relative(
           new JavaFile.relative(_sdkDirectory, _BIN_DIRECTORY_NAME),
@@ skipping 53 matching lines @@
   bool get hasDocumentation => docDirectory.exists();
 
   /**
    * Return `true` if the Dartium binary is available.
    */
   bool get isDartiumInstalled => dartiumExecutable != null;
 
   /**
    * Return the directory within the SDK directory that contains the libraries.
    */
-  JavaFile get libraryDirectory =>
-      new JavaFile.relative(_sdkDirectory, _LIB_DIRECTORY_NAME);
+  JavaFile get libraryDirectory {
+    if (_libraryDirectory == null) {
+      _libraryDirectory =
+          new JavaFile.relative(_sdkDirectory, _LIB_DIRECTORY_NAME);
+    }
+    return _libraryDirectory;
+  }
 
   /**
    * Return the file containing the Pub executable, or `null` if it does not exist.
    */
   JavaFile get pubExecutable {
     if (_pubExecutable == null) {
       _pubExecutable = _verifyExecutable(new JavaFile.relative(
           new JavaFile.relative(_sdkDirectory, _BIN_DIRECTORY_NAME),
           OSUtilities.isWindows()
               ? _PUB_EXECUTABLE_NAME_WIN
               : _PUB_EXECUTABLE_NAME));
     }
     return _pubExecutable;
   }
 
-  @override
-  List<SdkLibrary> get sdkLibraries => _libraryMap.sdkLibraries;
-
   /**
    * Return the revision number of this SDK, or `"0"` if the revision number
    * cannot be discovered.
    */
   @override
   String get sdkVersion {
     if (_sdkVersion == null) {
       _sdkVersion = DartSdk.DEFAULT_VERSION;
       JavaFile revisionFile =
           new JavaFile.relative(_sdkDirectory, _VERSION_FILE_NAME);
       try {
         String revision = revisionFile.readAsStringSync();
         if (revision != null) {
           _sdkVersion = revision.trim();
         }
       } on FileSystemException {
         // Fall through to return the default.
       }
     }
     return _sdkVersion;
   }
 
-  @override
-  List<String> get uris => _libraryMap.uris;
-
   /**
    * Return the name of the file containing the VM executable.
    */
   String get vmBinaryName {
     if (OSUtilities.isWindows()) {
       return _VM_EXECUTABLE_NAME_WIN;
     } else {
       return _VM_EXECUTABLE_NAME;
     }
   }
@@ skipping 20 matching lines @@
             new JavaFile.relative(
                 new JavaFile.relative(libraryDirectory, _INTERNAL_DIR),
                 _SDK_LIBRARY_METADATA_DIR),
             _SDK_LIBRARY_METADATA_LIB_DIR),
         _LIBRARIES_FILE);
     yield new JavaFile.relative(
         new JavaFile.relative(libraryDirectory, _INTERNAL_DIR),
         _LIBRARIES_FILE);
   }
 
-  @override
-  Source fromFileUri(Uri uri) {
-    JavaFile file = new JavaFile.fromUri(uri);
-    String filePath = file.getAbsolutePath();
-    String libPath = libraryDirectory.getAbsolutePath();
-    if (!filePath.startsWith("$libPath${JavaFile.separator}")) {
-      return null;
-    }
-    filePath = filePath.substring(libPath.length + 1);
-    for (SdkLibrary library in _libraryMap.sdkLibraries) {
-      String libraryPath = library.path;
-      if (filePath.replaceAll('\\', '/') == libraryPath) {
-        String path = library.shortName;
-        try {
-          return new FileBasedSource(file, parseUriWithException(path));
-        } on URISyntaxException catch (exception, stackTrace) {
-          AnalysisEngine.instance.logger.logInformation(
-              "Failed to create URI: $path",
-              new CaughtException(exception, stackTrace));
-          return null;
-        }
-      }
-      libraryPath = new JavaFile(libraryPath).getParent();
-      if (filePath.startsWith("$libraryPath${JavaFile.separator}")) {
-        String path =
-            "${library.shortName}/${filePath.substring(libraryPath.length + 1)}";
-        try {
-          return new FileBasedSource(file, parseUriWithException(path));
-        } on URISyntaxException catch (exception, stackTrace) {
-          AnalysisEngine.instance.logger.logInformation(
-              "Failed to create URI: $path",
-              new CaughtException(exception, stackTrace));
-          return null;
-        }
-      }
-    }
-    return null;
-  }
-
   /**
    * Return the directory where dartium can be found (the directory that will be
    * the working directory if Dartium is invoked without changing the default),
    * assuming that the Editor was installed in the [installDir].
    */
   JavaFile getDartiumWorkingDirectory(JavaFile installDir) =>
       new JavaFile.relative(installDir, _DARTIUM_DIRECTORY_NAME);
 
   /**
    * Return the auxiliary documentation file for the library with the given
    * [libraryName], or `null` if no such file exists.
    */
   JavaFile getDocFileFor(String libraryName) {
     JavaFile dir = docDirectory;
     if (!dir.exists()) {
       return null;
     }
     JavaFile libDir = new JavaFile.relative(dir, libraryName);
     JavaFile docFile =
         new JavaFile.relative(libDir, "$libraryName$_DOC_FILE_SUFFIX");
     if (docFile.exists()) {
       return docFile;
     }
     return null;
   }
 
   @override
-  SdkLibrary getSdkLibrary(String dartUri) => _libraryMap.getLibrary(dartUri);
+  PackageBundle getLinkedBundle() => null;
+
+  @override
+  String getRelativePathFromFile(JavaFile file) {
+    String filePath = file.getAbsolutePath();
+    String libPath = libraryDirectory.getAbsolutePath();
+    if (!filePath.startsWith("$libPath${JavaFile.separator}")) {
+      return null;
+    }
+    return filePath.substring(libPath.length + 1);
+  }
+
+  /**
+   * Return the [PackageBundle] for this SDK, if it exists, or `null` otherwise.
+   * This method should not be used outside of `analyzer` and `analyzer_cli`
+   * packages.
+   */
+  PackageBundle getSummarySdkBundle(bool strongMode) {
+    String rootPath = directory.getAbsolutePath();
+    String name = strongMode ? 'strong.sum' : 'spec.sum';
+    String path = pathos.join(rootPath, 'lib', '_internal', name);
+    try {
+      File file = new File(path);
+      if (file.existsSync()) {
+        List<int> bytes = file.readAsBytesSync();
+        return new PackageBundle.fromBuffer(bytes);
+      }
+    } catch (exception, stackTrace) {
+      AnalysisEngine.instance.logger.logError(
+          'Failed to load SDK analysis summary from $path',
+          new CaughtException(exception, stackTrace));
+    }
+    return null;
+  }
 
   /**
    * Read all of the configuration files to initialize the library maps. The
    * flag [useDart2jsPaths] is `true` if the dart2js path should be used when it
    * is available. Return the initialized library map.
    */
   LibraryMap initialLibraryMap(bool useDart2jsPaths) {
     List<String> searchedPaths = <String>[];
     var lastStackTrace = null;
     var lastException = null;
     for (JavaFile librariesFile in _libraryMapLocations) {
       try {
         String contents = librariesFile.readAsStringSync();
         return new SdkLibrariesReader(useDart2jsPaths)
             .readFromFile(librariesFile, contents);
       } catch (exception, stackTrace) {
         searchedPaths.add(librariesFile.getAbsolutePath());
         lastException = exception;
         lastStackTrace = stackTrace;
       }
     }
     AnalysisEngine.instance.logger.logError(
         "Could not initialize the library map from $searchedPaths",
         new CaughtException(lastException, lastStackTrace));
     return new LibraryMap();
   }
 
   @override
-  Source mapDartUri(String dartUri) {
+  FileBasedSource internalMapDartUri(String dartUri) {
     String libraryName;
     String relativePath;
     int index = dartUri.indexOf('/');
     if (index >= 0) {
       libraryName = dartUri.substring(0, index);
       relativePath = dartUri.substring(index + 1);
     } else {
       libraryName = dartUri;
       relativePath = "";
     }
     SdkLibrary library = getSdkLibrary(libraryName);
     if (library == null) {
       return null;
     }
     try {
       JavaFile file = new JavaFile.relative(libraryDirectory, library.path);
       if (!relativePath.isEmpty) {
         file = file.getParentFile();
         file = new JavaFile.relative(file, relativePath);
       }
-      return new FileBasedSource(file, parseUriWithException(dartUri));
-    } on URISyntaxException {
+      return new FileBasedSource(file, Uri.parse(dartUri));
+    } on FormatException {
       return null;
     }
   }
 
   /**
    * Return the given [file] if it exists and is executable, or `null` if it
    * does not exist or is not executable.
    */
   JavaFile _verifyExecutable(JavaFile file) =>
       file.isExecutable() ? file : null;
@@ skipping 15 matching lines @@
  *         "builtin/builtin_runtime.dart",
  *         category: "Server",
  *         platforms: VM_PLATFORM),
  *
  *       "compiler" : const LibraryInfo(
  *         "compiler/compiler.dart",
  *         category: "Tools",
  *         platforms: 0),
  *     };
  */
+@deprecated
 class SdkLibrariesReader {
   /**
    * A flag indicating whether the dart2js path should be used when it is
    * available.
    */
   final bool _useDart2jsPaths;
 
   /**
    * Initialize a newly created library reader to use the dart2js path if
    * [_useDart2jsPaths] is `true`.
@@ skipping 20 matching lines @@
     SdkLibrariesReader_LibraryBuilder libraryBuilder =
         new SdkLibrariesReader_LibraryBuilder(_useDart2jsPaths);
     // If any syntactic errors were found then don't try to visit the AST
     // structure.
     if (!errorListener.errorReported) {
       unit.accept(libraryBuilder);
     }
     return libraryBuilder.librariesMap;
   }
 }