fixes #183, remove our InMemory* in favor of analyzer's impl

lib/src/testing.dart

 // Copyright (c) 2015, 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 dev_compiler.src.testing;
 
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/engine.dart'
-    show AnalysisContext, TimestampedData;
-import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:logging/logging.dart';
-import 'package:path/path.dart' as path;
 import 'package:source_span/source_span.dart';
 import 'package:unittest/unittest.dart';
 
 import 'package:dev_compiler/src/checker/dart_sdk.dart'
     show mockSdkSources, dartSdkDirectory;
 import 'package:dev_compiler/src/checker/resolver.dart' show TypeResolver;
 import 'package:dev_compiler/src/utils.dart';
-import 'package:dev_compiler/src/in_memory.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/report.dart';
 import 'package:dev_compiler/config.dart';
 import 'package:dev_compiler/devc.dart' show Compiler;
 
 import 'dependency_graph.dart' show runtimeFilesForServerMode;
 
 /// Run the checker on a program with files contents as indicated in
 /// [testFiles].
@@ skipping 24 matching lines @@
     CheckerReporter createReporter(AnalysisContext context),
     covariantGenerics: true, relaxedCasts: true,
     inferDownwards: RulesOptions.inferDownwardsDefault,
     inferFromOverrides: ResolverOptions.inferFromOverridesDefault,
     inferTransitively: ResolverOptions.inferTransitivelyDefault,
     nonnullableTypes: TypeOptions.NONNULLABLE_TYPES,
     wrapClosures: RulesOptions.wrapClosuresDefault}) {
   expect(testFiles.containsKey('/main.dart'), isTrue,
       reason: '`/main.dart` is missing in testFiles');
 
-  // Create a resolver that can load test files from memory.
-  var testUriResolver = new InMemoryUriResolver(testFiles);
+  var provider = createTestResourceProvider(testFiles);
+  var uriResolver = new TestUriResolver(provider);
+
   var options = new CompilerOptions(
       allowConstCasts: allowConstCasts,
       covariantGenerics: covariantGenerics,
       relaxedCasts: relaxedCasts,
       inferDownwards: inferDownwards,
       inferFromOverrides: inferFromOverrides,
       inferTransitively: inferTransitively,
       nonnullableTypes: nonnullableTypes,
       wrapClosures: wrapClosures,
       useMockSdk: sdkDir == null,
       dartSdkPath: sdkDir,
       runtimeDir: '/dev_compiler_runtime/',
       entryPointFile: '/main.dart');
   var resolver = sdkDir == null
       ? new TypeResolver.fromMock(mockSdkSources, options,
-          otherResolvers: [testUriResolver])
+          otherResolvers: [uriResolver])
       : new TypeResolver.fromDir(sdkDir, options,
-          otherResolvers: [testUriResolver]);
+          otherResolvers: [uriResolver]);
   var context = resolver.context;
 
   // Run the checker on /main.dart.
   var mainFile = new Uri.file('/main.dart');
-  var checkExpectations = createReporter == null;
-  var reporter = (createReporter == null)
-      ? new TestReporter(context)
-      : createReporter(context);
+  TestReporter testReporter;
+  CheckerReporter reporter;
+  if (createReporter == null) {
+    reporter = testReporter = new TestReporter(context);
+  } else {
+    reporter = createReporter(context);
+  }
   var results =
       new Compiler(options, resolver: resolver, reporter: reporter).run();
 
   // Extract expectations from the comments in the test files.
   var expectedErrors = <AstNode, List<_ErrorExpectation>>{};
   var visitor = new _ErrorMarkerVisitor(expectedErrors);
   var initialLibrary =
-      resolver.context.getLibraryElement(testUriResolver.files[mainFile]);
+      resolver.context.getLibraryElement(uriResolver.resolveAbsolute(mainFile));
   for (var lib in reachableLibraries(initialLibrary)) {
     for (var unit in lib.units) {
       unit.unit.accept(visitor);
     }
   }
 
-  if (!checkExpectations) return results;
+  if (testReporter == null) return results;
 
   var total = expectedErrors.values.fold(0, (p, l) => p + l.length);
   // Check that all errors we emit are included in the expected map.
   for (var lib in results.libraries) {
     var uri = lib.library.source.uri;
-    (reporter as TestReporter).infoMap[uri].forEach((node, actual) {
+    testReporter.infoMap[uri].forEach((node, actual) {
       var expected = expectedErrors[node];
       var expectedTotal = expected == null ? 0 : expected.length;
       if (actual.length != expectedTotal) {
         expect(actual.length, expectedTotal,
             reason: 'The checker found ${actual.length} errors on the '
             'expression `$node`, but we expected $expectedTotal. These are the '
             'errors the checker found:\n\n ${_unexpectedErrors(node, actual)}');
       }
 
       for (int i = 0; i < expected.length; i++) {
@@ skipping 16 matching lines @@
       fail('Not all expected errors were reported by the checker. Only'
           ' ${total - newTotal} out of $total expected errors were reported.\n'
           'The following errors were not reported:\n'
           '${_unreportedErrors(expectedErrors)}');
     }
   }
 
   return results;
 }
 
+/// Creates a [MemoryResourceProvider] with test data
+MemoryResourceProvider createTestResourceProvider(
+    Map<String, String> testFiles) {
+  var provider = new MemoryResourceProvider();
+  runtimeFilesForServerMode.forEach((filepath) {
+    testFiles['/dev_compiler_runtime/$filepath'] =
+        '/* test contents of $filepath */';
+  });
+  testFiles.forEach((key, value) {
+    var scheme = 'package:';
+    if (key.startsWith(scheme)) {
+      key = '/packages/${key.substring(scheme.length)}';
+    }
+    provider.newFile(key, value);
+  });
+  return provider;
+}
+
+class TestUriResolver extends ResourceUriResolver {
+  final MemoryResourceProvider provider;
+  TestUriResolver(provider)
+      : provider = provider,
+        super(provider);
+  resolveAbsolute(Uri uri) {
+    if (uri.scheme == 'package') {
+      return (provider.getResource('/packages/' + uri.path) as File)
+          .createSource(uri);
+    }
+    return super.resolveAbsolute(uri);
+  }
+}
+
 class TestReporter extends SummaryReporter {
   Map<Uri, Map<AstNode, List<StaticInfo>>> infoMap = {};
-  Uri _current;
+  Map<AstNode, List<StaticInfo>> _current;
 
   TestReporter(AnalysisContext context) : super(context);
 
   void enterLibrary(Uri uri) {
     super.enterLibrary(uri);
-    infoMap[uri] = {};
-    _current = uri;
+    infoMap[uri] = _current = {};
   }
 
   void log(Message info) {
     super.log(info);
     if (info is StaticInfo) {
-      infoMap[_current].putIfAbsent(info.node, () => []).add(info);
+      _current.putIfAbsent(info.node, () => []).add(info);
     }
   }
 }
 
 /// Create an error explanation for errors that were not expected, but that the
 /// checker produced.
 String _unexpectedErrors(AstNode node, List errors) {
   final span = _spanFor(node);
   return errors.map((e) {
     var level = e.level.name.toLowerCase();
@@ skipping 13 matching lines @@
   return sb.toString();
 }
 
 String _messageWithSpan(StaticInfo info) {
   var span = _spanFor(info.node);
   var level = info.level.name.toLowerCase();
   return '$level: ${span.message(info.message, color: colorOf(level))}';
 }
 
 SourceSpan _spanFor(AstNode node) {
-  var root = node.root as CompilationUnit;
-  InMemorySource source = (root.element as CompilationUnitElementImpl).source;
-  return source.spanFor(node);
+  var unit = node.root as CompilationUnit;
+  var source = unit.element.source;
+  // This reads the file. Only safe in tests, because they use MemoryFileSystem.
+  var content = source.contents.data;
+  return createSpanHelper(unit, node.offset, node.end, source, content);
 }
 
 /// Visitor that extracts expected errors from comments.
 class _ErrorMarkerVisitor extends UnifyingAstVisitor {
   Map<AstNode, List<_ErrorExpectation>> expectedErrors;
 
   _ErrorMarkerVisitor(this.expectedErrors);
 
   visitNode(AstNode node) {
     var token = node.beginToken;
@@ skipping 59 matching lines @@
     expect(tokens[1], "should", reason: 'invalid error descriptor');
     expect(tokens[2], "be", reason: 'invalid error descriptor');
     if (tokens[0] == "pass") return null;
     // TODO(leafp) For now, we just use whatever the current expectation is,
     // eventually we could do more automated reporting here.
     return _parse(tokens[0]);
   }
 
   String toString() => '$level $type';
 }