Use URIs rather than paths in front end API.

pkg/front_end/test/memory_file_system_test.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.
 // SharedOptions=--supermixin
 
 library front_end.test.memory_file_system_test;
 
 import 'dart:convert';
 import 'dart:io' as io;
 
@@ skipping 12 matching lines @@
 }
 
 @reflectiveTest
 class FileTest extends _BaseTestNative {
   String path;
   MemoryFileSystemEntity file;
 
   setUp() {
     super.setUp();
     path = join(tempPath, 'file.txt');
-    file = fileSystem.entityForPath(path);
+    file = entityForPath(path);
   }
 
   test_equals_differentPaths() {
-    expect(
-        file == fileSystem.entityForPath(join(tempPath, 'file2.txt')), isFalse);
+    expect(file == entityForPath(join(tempPath, 'file2.txt')), isFalse);
   }
 
   test_equals_samePath() {
-    expect(
-        file == fileSystem.entityForPath(join(tempPath, 'file.txt')), isTrue);
+    expect(file == entityForPath(join(tempPath, 'file.txt')), isTrue);
   }
 
   test_hashCode_samePath() {
-    expect(file.hashCode,
-        fileSystem.entityForPath(join(tempPath, 'file.txt')).hashCode);
+    expect(file.hashCode, entityForPath(join(tempPath, 'file.txt')).hashCode);
   }
 
   test_path() {
-    expect(file.path, path);
+    expect(file.uri, fileSystem.context.toUri(path));
   }
 
   test_readAsBytes_badUtf8() async {
     // A file containing invalid UTF-8 can still be read as raw bytes.
     List<int> bytes = [0xc0, 0x40]; // Invalid UTF-8
     file.writeAsBytesSync(bytes);
     expect(await file.readAsBytes(), bytes);
   }
 
   test_readAsBytes_doesNotExist() {
@@ skipping 58 matching lines @@
 }
 
 abstract class MemoryFileSystemTestMixin extends _BaseTest {
   Uri tempUri;
 
   setUp() {
     super.setUp();
     tempUri = fileSystem.context.toUri(tempPath);
   }
 
-  test_entityForPath() {
-    var path = join(tempPath, 'file.txt');
-    expect(fileSystem.entityForPath(path).path, path);
+  test_currentDirectory_trailingSlash() {
+    // The currentDirectory should already end in a trailing slash.
+    expect(fileSystem.currentDirectory.path, endsWith('/'));
+    // A trailing slash should automatically be appended when creating a
+    // MemoryFileSystem.
+    var path = fileSystem.currentDirectory.path;
+    var currentDirectoryWithoutSlash = fileSystem.currentDirectory
+        .replace(path: path.substring(0, path.length - 1));
+    expect(
+        new MemoryFileSystem(fileSystem.context, currentDirectoryWithoutSlash)
+            .currentDirectory,
+        fileSystem.currentDirectory);
+    // If the currentDirectory supplied to the MemoryFileSystem constructor
+    // already has a trailing slash, no further trailing slash should be added.
+    expect(
+        new MemoryFileSystem(fileSystem.context, fileSystem.currentDirectory)
+            .currentDirectory,
+        fileSystem.currentDirectory);
   }
 
   test_entityForPath_absolutize() {
-    expect(fileSystem.entityForPath('file.txt').path,
-        join(fileSystem.currentDirectory, 'file.txt'));
+    expect(entityForPath('file.txt').uri,
+        fileSystem.currentDirectory.resolve('file.txt'));
   }
 
   test_entityForPath_normalize_dot() {
-    expect(fileSystem.entityForPath(join(tempPath, '.', 'file.txt')).path,
-        join(tempPath, 'file.txt'));
+    expect(entityForPath(join(tempPath, '.', 'file.txt')).uri,
+        Uri.parse('$tempUri/file.txt'));
   }
 
   test_entityForPath_normalize_dotDot() {
-    expect(
-        fileSystem.entityForPath(join(tempPath, 'foo', '..', 'file.txt')).path,
-        join(tempPath, 'file.txt'));
+    expect(entityForPath(join(tempPath, 'foo', '..', 'file.txt')).uri,
+        Uri.parse('$tempUri/file.txt'));
   }
 
   test_entityForUri() {
-    expect(fileSystem.entityForUri(Uri.parse('$tempUri/file.txt')).path,
-        join(tempPath, 'file.txt'));
-  }
-
-  test_entityForUri_bareUri_absolute() {
-    expect(() => fileSystem.entityForUri(Uri.parse('/file.txt')),
-        throwsA(new isInstanceOf<Error>()));
-  }
-
-  test_entityForUri_bareUri_relative() {
-    expect(() => fileSystem.entityForUri(Uri.parse('file.txt')),
-        throwsA(new isInstanceOf<Error>()));
+    expect(fileSystem.entityForUri(Uri.parse('$tempUri/file.txt')).uri,
+        Uri.parse('$tempUri/file.txt'));
   }
 
   test_entityForUri_fileUri_relative() {
     // A weird quirk of the Uri class is that it doesn't seem possible to create
     // a `file:` uri with a relative path, no matter how many slashes you use or
     // if you populate the fields directly.  But just to be certain, try to do
     // so, and make that `file:` uris with relative paths are rejected.
     for (var uri in <Uri>[
       new Uri(scheme: 'file', path: 'file.txt'),
       Uri.parse('file:file.txt'),
       Uri.parse('file:/file.txt'),
       Uri.parse('file://file.txt'),
       Uri.parse('file:///file.txt')
     ]) {
       if (!uri.path.startsWith('/')) {
         expect(() => fileSystem.entityForUri(uri),
             throwsA(new isInstanceOf<Error>()));
       }
     }
   }
 
   test_entityForUri_nonFileUri() {
-    expect(() => fileSystem.entityForUri(Uri.parse('package:foo/bar.dart')),
-        throwsA(new isInstanceOf<Error>()));
+    var uri = Uri.parse('package:foo/bar.dart');
+    expect(fileSystem.entityForUri(uri).uri, uri);
   }
 
   test_entityForUri_normalize_dot() {
-    expect(fileSystem.entityForUri(Uri.parse('$tempUri/./file.txt')).path,
-        join(tempPath, 'file.txt'));
+    expect(fileSystem.entityForUri(Uri.parse('$tempUri/./file.txt')).uri,
+        Uri.parse('$tempUri/file.txt'));
   }
 
   test_entityForUri_normalize_dotDot() {
-    expect(fileSystem.entityForUri(Uri.parse('$tempUri/foo/../file.txt')).path,
-        join(tempPath, 'file.txt'));
+    expect(fileSystem.entityForUri(Uri.parse('$tempUri/foo/../file.txt')).uri,
+        Uri.parse('$tempUri/file.txt'));
   }
 }
 
 @reflectiveTest
 class MemoryFileSystemTestNative extends _BaseTestNative
     with MemoryFileSystemTestMixin {}
 
 @reflectiveTest
 class MemoryFileSystemTestPosix extends _BaseTestPosix
     with MemoryFileSystemTestMixin {}
 
 @reflectiveTest
 class MemoryFileSystemTestWindows extends _BaseTestWindows
     with MemoryFileSystemTestMixin {}
 
 abstract class _BaseTest {
   MemoryFileSystem get fileSystem;
+
   String get tempPath;
+
+  MemoryFileSystemEntity entityForPath(String path) =>
+      fileSystem.entityForUri(fileSystem.context.toUri(path));
+
   String join(String path1, String path2, [String path3, String path4]);
+
   void setUp();
 }
 
 class _BaseTestNative extends _BaseTest {
   MemoryFileSystem fileSystem;
   String tempPath;
 
   String join(String path1, String path2, [String path3, String path4]) =>
       pathos.join(path1, path2, path3, path4);
 
   setUp() {
     tempPath = pathos.join(io.Directory.systemTemp.path, 'test_file_system');
-    fileSystem =
-        new MemoryFileSystem(pathos.context, io.Directory.current.path);
+    fileSystem = new MemoryFileSystem(
+        pathos.context, pathos.toUri(io.Directory.current.path));
   }
 }
 
 class _BaseTestPosix extends _BaseTest {
   MemoryFileSystem fileSystem;
   String tempPath;
 
   String join(String path1, String path2, [String path3, String path4]) =>
       pathos.posix.join(path1, path2, path3, path4);
 
   void setUp() {
     tempPath = '/test_file_system';
-    fileSystem = new MemoryFileSystem(pathos.posix, '/cwd');
+    fileSystem = new MemoryFileSystem(pathos.posix, Uri.parse('file:///cwd'));
   }
 }
 
 class _BaseTestWindows extends _BaseTest {
   MemoryFileSystem fileSystem;
   String tempPath;
 
   String join(String path1, String path2, [String path3, String path4]) =>
       pathos.windows.join(path1, path2, path3, path4);
 
   void setUp() {
     tempPath = r'c:\test_file_system';
-    fileSystem = new MemoryFileSystem(pathos.windows, r'c:\cwd');
+    fileSystem =
+        new MemoryFileSystem(pathos.windows, Uri.parse('file:///c:/cwd'));
   }
 }