Use Posix style for memory resources.

pkg/analysis_server/lib/src/resource.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 resource;
 
 import 'dart:io' as io;
 
 import 'package:analyzer/src/generated/engine.dart' show TimestampedData;
 import 'package:analyzer/src/generated/java_io.dart';
@@ skipping 82 matching lines @@
   @override
   bool get exists => _provider._pathToResource.containsKey(_path);
 
   @override
   String get fullName => _path;
 
   @override
   get hashCode => _path.hashCode;
 
   @override
-  String get shortName => basename(_path);
+  String get shortName => (posix as Context).basename(_path);

[karlklose, 2014/05/27 07:57:20]

Consider adding a getter
   Context get context => posix;
to avoid the casts here and below.

 
   @override
   String toString() => fullName;
 }
 
 
 /**
  * An in-memory implementation of [File].
  */
 class _MemoryFile extends _MemoryResource implements File {
@@ skipping 60 matching lines @@
   String get fullName => _file.fullName;
 
   @override
   bool get isInSystemLibrary => false;
 
   @override
   int get modificationStamp => _file._timestamp;
 
   @override
   Source resolveRelative(Uri relativeUri) {
-    String relativePath = fromUri(relativeUri);
-    String folderPath = dirname(_file._path);
-    String path = join(folderPath, relativePath);
-    path = normalize(path);
+    String relativePath = (posix as Context).fromUri(relativeUri);
+    String folderPath = (posix as Context).dirname(_file._path);
+    String path = (posix as Context).join(folderPath, relativePath);
+    path = (posix as Context).normalize(path);
     _MemoryFile file = new _MemoryFile(_file._provider, path);
     return new _MemoryFileSource(file, uriKind);
   }
 
   @override
   String get shortName => _file.shortName;
 }
 
 
 /**
  * An in-memory implementation of [Folder].
  */
 class _MemoryFolder extends _MemoryResource implements Folder {
   _MemoryFolder(MemoryResourceProvider provider, String path) :
       super(provider, path);
   @override
   Resource getChild(String relPath) {
-    relPath = normalize(relPath);
-    String childPath = join(_path, relPath);
-    childPath = normalize(childPath);
+    relPath = (posix as Context).normalize(relPath);
+    String childPath = (posix as Context).join(_path, relPath);
+    childPath = (posix as Context).normalize(childPath);
     _MemoryResource resource = _provider._pathToResource[childPath];
     if (resource == null) {
       resource = new _MemoryFile(_provider, childPath);
     }
     return resource;
   }
 
   @override
   List<Resource> getChildren() {
     List<Resource> children = <Resource>[];
     _provider._pathToResource.forEach((path, resource) {
-      if (dirname(path) == _path) {
+      if ((posix as Context).dirname(path) == _path) {
         children.add(resource);
       }
     });
     return children;
   }
 }
 
 
 /**
  * An in-memory implementation of [ResourceProvider].
  * Use `/` as a path separator.
  */
 class MemoryResourceProvider implements ResourceProvider {
   final Map<String, _MemoryResource> _pathToResource = <String, _MemoryResource>{};
   final Map<String, String> _pathToContent = <String, String>{};
   final Map<String, int> _pathToTimestamp = <String, int>{};
   int nextStamp = 0;
 
   @override
   Resource getResource(String path) {
-    path = normalize(path);
+    path = (posix as Context).normalize(path);
     Resource resource = _pathToResource[path];
     if (resource == null) {
       resource = new _MemoryFile(this, path);
     }
     return resource;
   }
 
   Folder newFolder(String path) {
-    path = normalize(path);
+    path = (posix as Context).normalize(path);
     if (path.isEmpty) {
       throw new ArgumentError('Empty paths are not supported');
     }
     if (!path.startsWith('/')) {
       throw new ArgumentError("Path must start with '/'");
     }
     _MemoryFolder folder = null;
     String partialPath = "";
     for (String pathPart in path.split('/')) {
       if (pathPart.isEmpty) {
@@ skipping 11 matching lines @@
         String message = 'Folder expected at '
                          "'$partialPath'"
                          'but ${resource.runtimeType} found';
         throw new ArgumentError(message);
       }
     }
     return folder;
   }
 
   File newFile(String path, String content) {
-    path = normalize(path);
-    newFolder(dirname(path));
+    path = (posix as Context).normalize(path);
+    newFolder((posix as Context).dirname(path));
     _MemoryFile file = new _MemoryFile(this, path);
     _pathToResource[path] = file;
     _pathToContent[path] = content;
     _pathToTimestamp[path] = nextStamp++;
     return file;
   }
 }
 
 
 /**
@@ skipping 79 matching lines @@
   Resource getResource(String path) {
     if (io.FileSystemEntity.isDirectorySync(path)) {
       io.Directory directory = new io.Directory(path);
       return new _PhysicalFolder(directory);
     } else {
       io.File file = new io.File(path);
       return new _PhysicalFile(file);
     }
   }
 }