Removed fixed dependencies

packages/analyzer/lib/src/generated/source_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.source.io;
+library analyzer.src.generated.source_io;
 
 import 'dart:collection';
 
-import 'engine.dart';
-import 'java_core.dart';
-import 'java_engine.dart';
-import 'java_io.dart';
-import 'source.dart';
+import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/java_io.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:path/path.dart' as path;
 
-export 'source.dart';
+export 'package:analyzer/src/generated/source.dart';
 
 /**
  * Instances of the class [DirectoryBasedSourceContainer] represent a source container that
  * contains all sources within a given directory.
  */
+@deprecated
 class DirectoryBasedSourceContainer implements SourceContainer {
   /**
    * The container's path (not `null`).
    */
   String _path;
 
   /**
    * Construct a container representing the specified directory and containing any sources whose
    * [Source.fullName] starts with the directory's path. This is a convenience method,
    * fully equivalent to [DirectoryBasedSourceContainer.con2].
@@ skipping 44 matching lines @@
     if (path == null ||
         path.length <= 0 ||
         path.codeUnitAt(path.length - 1) == JavaFile.separatorChar) {
       return path;
     }
     return "$path${JavaFile.separator}";
   }
 }
 
 /**
+ * Instances of the class [ExplicitSourceResolver] map URIs to files on disk
+ * using a fixed mapping provided at construction time.
+ */
+@deprecated
+class ExplicitSourceResolver extends UriResolver {
+  final Map<Uri, JavaFile> uriToFileMap;
+  final Map<String, Uri> pathToUriMap;
+
+  /**
+   * Construct an [ExplicitSourceResolver] based on the given [uriToFileMap].
+   */
+  ExplicitSourceResolver(Map<Uri, JavaFile> uriToFileMap)
+      : uriToFileMap = uriToFileMap,
+        pathToUriMap = _computePathToUriMap(uriToFileMap);
+
+  @override
+  Source resolveAbsolute(Uri uri, [Uri actualUri]) {
+    JavaFile file = uriToFileMap[uri];
+    actualUri ??= uri;
+    if (file == null) {
+      return new NonExistingSource(
+          uri.toString(), actualUri, UriKind.fromScheme(actualUri.scheme));
+    } else {
+      return new FileBasedSource(file, actualUri);
+    }
+  }
+
+  @override
+  Uri restoreAbsolute(Source source) {
+    return pathToUriMap[source.fullName];
+  }
+
+  /**
+   * Build the inverse mapping of [uriToSourceMap].
+   */
+  static Map<String, Uri> _computePathToUriMap(
+      Map<Uri, JavaFile> uriToSourceMap) {
+    Map<String, Uri> pathToUriMap = <String, Uri>{};
+    uriToSourceMap.forEach((Uri uri, JavaFile file) {
+      pathToUriMap[file.getAbsolutePath()] = uri;
+    });
+    return pathToUriMap;
+  }
+}
+
+/**
  * Instances of the class `FileBasedSource` implement a source that represents a file.
  */
 class FileBasedSource extends Source {
   /**
    * A function that changes the way that files are read off of disk.
    */
   static Function fileReadMode = (String s) => s;
 
   /**
    * Map from encoded URI/filepath pair to a unique integer identifier.  This
    * identifier is used for equality tests and hash codes.
    *
    * The URI and filepath are joined into a pair by separating them with an '@'
    * character.
    */
   static final Map<String, int> _idTable = new HashMap<String, int>();
 
   /**
    * The URI from which this source was originally derived.
    */
+  @override
   final Uri uri;
 
   /**
    * The unique ID associated with this [FileBasedSource].
    */
   final int id;
 
   /**
    * The file represented by this source.
    */
   final JavaFile file;
 
   /**
    * The cached absolute path of this source.
    */
   String _absolutePath;
 
   /**
    * The cached encoding for this source.
    */
   String _encoding;
 
   /**
    * Initialize a newly created source object to represent the given [file]. If
    * a [uri] is given, then it will be used as the URI from which the source was
    * derived, otherwise a `file:` URI will be created based on the [file].
    */
   FileBasedSource(JavaFile file, [Uri uri])
-      : this.uri = (uri == null ? file.toURI() : uri),
+      : this.uri = uri ?? file.toURI(),
         this.file = file,
         id = _idTable.putIfAbsent(
-            '${uri == null ? file.toURI() : uri}@${file.getPath()}',
-            () => _idTable.length);
-
-  /**
-   * Initialize a newly created source object.
-   *
-   * @param file the file represented by this source
-   */
-  @deprecated // Use new FileBasedSource(file)
-  FileBasedSource.con1(JavaFile file) : this(file);
-
-  /**
-   * Initialize a newly created source object.
-   *
-   * @param file the file represented by this source
-   * @param uri the URI from which this source was originally derived
-   */
-  @deprecated // Use new FileBasedSource(file, uri)
-  FileBasedSource.con2(Uri uri, JavaFile file)
-      : uri = uri,
-        file = file,
-        id = _idTable.putIfAbsent(
-            '$uri@${file.getPath()}', () => _idTable.length);
+            '${uri ?? file.toURI()}@${file.getPath()}', () => _idTable.length);
 
   @override
   TimestampedData<String> get contents {
     return PerformanceStatistics.io.makeCurrentWhile(() {
       return contentsFromFile;
     });
   }
 
   /**
    * Get the contents and timestamp of the underlying file.
    *
-   * Clients should consider using the the method [AnalysisContext.getContents]
+   * Clients should consider using the method [AnalysisContext.getContents]
    * because contexts can have local overrides of the content of a source that the source is not
    * aware of.
    *
    * @return the contents of the source paired with the modification stamp of the source
    * @throws Exception if the contents of this source could not be accessed
    * See [contents].
    */
   TimestampedData<String> get contentsFromFile {
     return new TimestampedData<String>(
         file.lastModified(), fileReadMode(file.readAsStringSync()));
   }
 
   @override
   String get encoding {
     if (_encoding == null) {
       _encoding = uri.toString();
     }
     return _encoding;
   }
 
   @override
   String get fullName {
     if (_absolutePath == null) {
       _absolutePath = file.getAbsolutePath();
     }
     return _absolutePath;
   }
 
   @override
-  int get hashCode => id;
+  int get hashCode => uri.hashCode;
 
   @override
   bool get isInSystemLibrary => uri.scheme == DartUriResolver.DART_SCHEME;
 
   @override
   int get modificationStamp => file.lastModified();
 
   @override
   String get shortName => file.getName();
 
   @override
   UriKind get uriKind {
     String scheme = uri.scheme;
-    if (scheme == PackageUriResolver.PACKAGE_SCHEME) {
-      return UriKind.PACKAGE_URI;
-    } else if (scheme == DartUriResolver.DART_SCHEME) {
-      return UriKind.DART_URI;
-    } else if (scheme == FileUriResolver.FILE_SCHEME) {
-      return UriKind.FILE_URI;
-    }
-    return UriKind.FILE_URI;
+    return UriKind.fromScheme(scheme);
   }
 
   @override
-  bool operator ==(Object object) =>
-      object is FileBasedSource && id == object.id;
+  bool operator ==(Object object) {
+    if (object is FileBasedSource) {
+      return id == object.id;
+    } else if (object is Source) {
+      return uri == object.uri;
+    }
+    return false;
+  }
 
   @override
   bool exists() => file.isFile();
 
   @override
-  Uri resolveRelativeUri(Uri containedUri) {
-    try {
-      Uri baseUri = uri;
-      bool isOpaque = uri.isAbsolute && !uri.path.startsWith('/');
-      if (isOpaque) {
-        String scheme = uri.scheme;
-        String part = uri.path;
-        if (scheme == DartUriResolver.DART_SCHEME && part.indexOf('/') < 0) {
-          part = "$part/$part.dart";
-        }
-        baseUri = parseUriWithException("$scheme:/$part");
-      }
-      Uri result = baseUri.resolveUri(containedUri);
-      if (isOpaque) {
-        result = parseUriWithException(
-            "${result.scheme}:${result.path.substring(1)}");
-      }
-      return result;
-    } catch (exception, stackTrace) {
-      throw new AnalysisException(
-          "Could not resolve URI ($containedUri) relative to source ($uri)",
-          new CaughtException(exception, stackTrace));
-    }
-  }
-
-  @override
   String toString() {
     if (file == null) {
       return "<unknown source>";
     }
     return file.getAbsolutePath();
   }
 }
 
 /**
  * Instances of the class `FileUriResolver` resolve `file` URI's.
+ *
+ * This class is now deprecated, 'new FileUriResolver()' is equivalent to
+ * 'new ResourceUriResolver(PhysicalResourceProvider.INSTANCE)'.
  */
+@deprecated
 class FileUriResolver extends UriResolver {
   /**
    * The name of the `file` scheme.
    */
   static String FILE_SCHEME = "file";
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     if (!isFileUri(uri)) {
       return null;
     }
-    return new FileBasedSource(
-        new JavaFile.fromUri(uri), actualUri != null ? actualUri : uri);
+    return new FileBasedSource(new JavaFile.fromUri(uri), actualUri ?? uri);
   }
 
   @override
   Uri restoreAbsolute(Source source) {
     return new Uri.file(source.fullName);
   }
 
   /**
    * Return `true` if the given URI is a `file` URI.
    *
@@ skipping 50 matching lines @@
 }
 
 /**
  * Instances of the class `PackageUriResolver` resolve `package` URI's in the context of
  * an application.
  *
  * For the purposes of sharing analysis, the path to each package under the "packages" directory
  * should be canonicalized, but to preserve relative links within a package, the remainder of the
  * path from the package directory to the leaf should not.
  */
+@deprecated
 class PackageUriResolver extends UriResolver {
   /**
    * The name of the `package` scheme.
    */
   static String PACKAGE_SCHEME = "package";
 
   /**
    * Log exceptions thrown with the message "Required key not available" only once.
    */
   static bool _CanLogRequiredKeyIoException = true;
 
   /**
    * The package directories that `package` URI's are assumed to be relative to.
    */
   final List<JavaFile> _packagesDirectories;
 
   /**
    * Initialize a newly created resolver to resolve `package` URI's relative to the given
    * package directories.
    *
    * @param packagesDirectories the package directories that `package` URI's are assumed to be
    *          relative to
    */
   PackageUriResolver(this._packagesDirectories) {
     if (_packagesDirectories.length < 1) {
-      throw new IllegalArgumentException(
+      throw new ArgumentError(
           "At least one package directory must be provided");
     }
   }
 
   /**
    * If the list of package directories contains one element, return it.
    * Otherwise raise an exception.  Intended for testing.
    */
   String get packagesDirectory_forTesting {
     int length = _packagesDirectories.length;
@@ skipping 10 matching lines @@
    * @param pkgName the package name (not `null`, not empty)
    * @param relPath the path relative to the package directory (not `null`, no leading slash,
    *          but may be empty string)
    * @return the file (not `null`)
    */
   JavaFile getCanonicalFile(
       JavaFile packagesDirectory, String pkgName, String relPath) {
     JavaFile pkgDir = new JavaFile.relative(packagesDirectory, pkgName);
     try {
       pkgDir = pkgDir.getCanonicalFile();
-    } on JavaIOException catch (exception, stackTrace) {
+    } catch (exception, stackTrace) {
       if (!exception.toString().contains("Required key not available")) {
         AnalysisEngine.instance.logger.logError("Canonical failed: $pkgDir",
             new CaughtException(exception, stackTrace));
       } else if (_CanLogRequiredKeyIoException) {
         _CanLogRequiredKeyIoException = false;
         AnalysisEngine.instance.logger.logError("Canonical failed: $pkgDir",
             new CaughtException(exception, stackTrace));
       }
     }
     return new JavaFile.relative(
@@ skipping 27 matching lines @@
     } else {
       // <pkgName>/<relPath>
       pkgName = path.substring(0, index);
       relPath = path.substring(index + 1);
     }
     for (JavaFile packagesDirectory in _packagesDirectories) {
       JavaFile resolvedFile = new JavaFile.relative(packagesDirectory, path);
       if (resolvedFile.exists()) {
         JavaFile canonicalFile =
             getCanonicalFile(packagesDirectory, pkgName, relPath);
+        if (actualUri != null) {
+          return new FileBasedSource(canonicalFile, actualUri);
+        }
         if (_isSelfReference(packagesDirectory, canonicalFile)) {
           uri = canonicalFile.toURI();
         }
-        return new FileBasedSource(
-            canonicalFile, actualUri != null ? actualUri : uri);
+        return new FileBasedSource(canonicalFile, uri);
       }
     }
     return new FileBasedSource(
         getCanonicalFile(_packagesDirectories[0], pkgName, relPath),
-        actualUri != null ? actualUri : uri);
+        actualUri ?? uri);
   }
 
   @override
   Uri restoreAbsolute(Source source) {
-    String sourcePath = source.fullName;
+    String sourceUri = _toFileUri(source.fullName);
     for (JavaFile packagesDirectory in _packagesDirectories) {
       List<JavaFile> pkgFolders = packagesDirectory.listFiles();
       if (pkgFolders != null) {
         for (JavaFile pkgFolder in pkgFolders) {
           try {
-            String pkgCanonicalPath = pkgFolder.getCanonicalPath();
-            if (sourcePath.startsWith(pkgCanonicalPath)) {
-              String relPath = sourcePath.substring(pkgCanonicalPath.length);
-              return parseUriWithException(
-                  "$PACKAGE_SCHEME:${pkgFolder.getName()}$relPath");
+            String pkgCanonicalUri = _toFileUri(pkgFolder.getCanonicalPath());
+            if (sourceUri.startsWith(pkgCanonicalUri)) {
+              String relPath = sourceUri.substring(pkgCanonicalUri.length);
+              return Uri
+                  .parse("$PACKAGE_SCHEME:${pkgFolder.getName()}$relPath");
             }
           } catch (e) {}
         }
       }
     }
     return null;
   }
 
   /**
    * @return `true` if "file" was found in "packagesDir", and it is part of the "lib" folder
    *         of the application that contains in this "packagesDir".
    */
   bool _isSelfReference(JavaFile packagesDir, JavaFile file) {
     JavaFile rootDir = packagesDir.getParentFile();
     if (rootDir == null) {
       return false;
     }
     String rootPath = rootDir.getAbsolutePath();
     String filePath = file.getAbsolutePath();
     return filePath.startsWith("$rootPath/lib");
   }
 
   /**
+   * Convert the given file path to a "file:" URI.  On Windows, this transforms
+   * backslashes to forward slashes.
+   */
+  String _toFileUri(String filePath) => path.context.toUri(filePath).toString();
+
+  /**
    * Return `true` if the given URI is a `package` URI.
    *
    * @param uri the URI being tested
    * @return `true` if the given URI is a `package` URI
    */
   static bool isPackageUri(Uri uri) => PACKAGE_SCHEME == uri.scheme;
 }
 
 /**
  * Instances of the class `RelativeFileUriResolver` resolve `file` URI's.
+ *
+ * This class is now deprecated, file URI resolution should be done with
+ * ResourceUriResolver, i.e.
+ * 'new ResourceUriResolver(PhysicalResourceProvider.INSTANCE)'.
  */
+@deprecated
 class RelativeFileUriResolver extends UriResolver {
   /**
    * The name of the `file` scheme.
    */
   static String FILE_SCHEME = "file";
 
   /**
    * The directories for the relatvie URI's
    */
   final List<JavaFile> _relativeDirectories;
@@ skipping 12 matching lines @@
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     String rootPath = _rootDirectory.toURI().path;
     String uriPath = uri.path;
     if (uriPath != null && uriPath.startsWith(rootPath)) {
       String filePath = uri.path.substring(rootPath.length);
       for (JavaFile dir in _relativeDirectories) {
         JavaFile file = new JavaFile.relative(dir, filePath);
         if (file.exists()) {
-          return new FileBasedSource(file, actualUri != null ? actualUri : uri);
+          return new FileBasedSource(file, actualUri ?? uri);
         }
       }
     }
     return null;
   }
 
   /**
    * Return `true` if the given URI is a `file` URI.
    *
    * @param uri the URI being tested
    * @return `true` if the given URI is a `file` URI
    */
   static bool isFileUri(Uri uri) => uri.scheme == FILE_SCHEME;
 }