More analyzer updates, and handle negative_tests

test/codegen_test.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.
 
 /// Tests code generation.
 /// Runs Dart Dev Compiler on all input in the `codegen` directory and checks
 /// that the output is what we expected.
 library dev_compiler.test.codegen_test;
 
 import 'dart:io';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, Logger;
 import 'package:analyzer/src/generated/java_engine.dart' show CaughtException;
+import 'package:analyzer/src/generated/source_io.dart';
 import 'package:args/args.dart';
+import 'package:cli_util/cli_util.dart' show getSdkDir;
 import 'package:logging/logging.dart' show Level;
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
 
 import 'package:dev_compiler/devc.dart';
+import 'package:dev_compiler/src/analysis_context.dart';
 import 'package:dev_compiler/src/compiler.dart' show defaultRuntimeFiles;
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/report.dart' show LogReporter;
 
-import 'testing.dart' show realSdkContext, testDirectory;
+import 'testing.dart' show testDirectory;
 import 'multitest.dart';
 
 final ArgParser argParser = new ArgParser()
   ..addOption('dart-sdk', help: 'Dart SDK Path', defaultsTo: null);
 
 final inputDir = path.join(testDirectory, 'codegen');
 
 Iterable<String> _findTests(String dir, RegExp filePattern) {
   var files = new Directory(dir)
       .listSync()
@@ skipping 23 matching lines @@
 
   tearDown(() {
     if (loggerSub != null) {
       loggerSub.cancel();
       loggerSub = null;
     }
   });
 
   var expectDir = path.join(inputDir, 'expect');
 
-  BatchCompiler createCompiler(AnalysisContext context,
-      {bool checkSdk: false,
+  BatchCompiler createCompiler(DartUriResolver sdkResolver, {bool checkSdk: false,
       bool sourceMaps: false,
       bool destructureNamedParams: false,
       bool closure: false,
       ModuleFormat moduleFormat: ModuleFormat.legacy}) {
+
+    String _testCodegenPath(String p1, [String p2]) =>
+        path.join(testDirectory, 'codegen', p1, p2);
+
+    var context = createAnalysisContextWithSources(new SourceResolverOptions(
+        customUrlMappings: {
+          'package:expect/expect.dart': _testCodegenPath('expect.dart'),
+          'package:async_helper/async_helper.dart':
+          _testCodegenPath('async_helper.dart'),
+          'package:unittest/unittest.dart': _testCodegenPath('unittest.dart'),
+          'package:dom/dom.dart': _testCodegenPath('sunflower', 'dom.dart')
+        }), sdkResolver: sdkResolver);
+
     // TODO(jmesserly): add a way to specify flags in the test file, so
     // they're more self-contained.
     var runtimeDir = path.join(path.dirname(testDirectory), 'lib', 'runtime');
     var options = new CompilerOptions(
         codegenOptions: new CodegenOptions(
             outputDir: expectDir,
             emitSourceMaps: sourceMaps,
             closure: closure,
             destructureNamedParams: destructureNamedParams,
             forceCompile: checkSdk,
@@ skipping 46 matching lines @@
           var filename = path.basenameWithoutExtension(filePath);
           tests.forEach((name, contents) {
             new File(path.join(fullDir, '${filename}_${name}_multi.dart'))
                 .writeAsStringSync(contents);
           });
         }
       }
     }
   }
 
-  var batchCompiler = createCompiler(realSdkContext);
+  var realSdkResolver = createSdkPathResolver(getSdkDir().path);
+  var batchCompiler = createCompiler(realSdkResolver);
 
   var allDirs = [null];
   allDirs.addAll(testDirs);
   for (var dir in allDirs) {
     if (codeCoverage && dir != null) continue;
 
     group('dartdevc ' + path.join('test', 'codegen', dir), () {
       var outDir = new Directory(path.join(expectDir, dir));
       if (!outDir.existsSync()) outDir.createSync(recursive: true);
 
@@ skipping 16 matching lines @@
                   ? ModuleFormat.node
                   : ModuleFormat.legacy;
           var success;
           // TODO(vsm): Is it okay to reuse the same context here?  If there is
           // overlap between test files, we may need separate ones for each
           // compiler.
           var compiler = (sourceMaps ||
                   closure ||
                   destructureNamedParams ||
                   moduleFormat != ModuleFormat.legacy)
-              ? createCompiler(realSdkContext,
+              ? createCompiler(realSdkResolver,
                   sourceMaps: sourceMaps,
                   destructureNamedParams: destructureNamedParams,
                   closure: closure,
                   moduleFormat: moduleFormat)
               : batchCompiler;
           success = compile(compiler, filePath);
 
           var outFile = new File(path.join(outDir.path, '$filename.js'));
           expect(!success || outFile.existsSync(), true,
               reason: '${outFile.path} was created if compilation succeeds');
@@ skipping 12 matching lines @@
       var savedLogger;
       setUp(() {
         savedLogger = AnalysisEngine.instance.logger;
         AnalysisEngine.instance.logger = new PrintLogger();
       });
       tearDown(() {
         AnalysisEngine.instance.logger = savedLogger;
       });
 
       test('devc dart:core', () {
-        var testSdkContext = createAnalysisContextWithSources(
-            new SourceResolverOptions(dartSdkPath: path.join(
-                testDirectory, '..', 'tool', 'generated_sdk')));
+        var testSdkResolver = createSdkPathResolver(path.join(
+                testDirectory, '..', 'tool', 'generated_sdk'));
 
         // Get the test SDK. We use a checked in copy so test expectations can
         // be generated against a specific SDK version.
-        var compiler = createCompiler(testSdkContext, checkSdk: true);
+        var compiler = createCompiler(testSdkResolver, checkSdk: true);
         compile(compiler, 'dart:core');
         var outFile = new File(path.join(expectDir, 'dart/core.js'));
         expect(outFile.existsSync(), true,
             reason: '${outFile.path} was created for dart:core');
       });
     });
   }
 
   var expectedRuntime =
       defaultRuntimeFiles.map((f) => 'dev_compiler/runtime/$f');
@@ skipping 35 matching lines @@
 /// An implementation of analysis engine's [Logger] that prints.
 class PrintLogger implements Logger {
   @override
   void logError(String message, [CaughtException exception]) {
     print('[AnalysisEngine] error $message $exception');
   }
 
   void logInformation(String message, [CaughtException exception]) {}
   void logInformation2(String message, Object exception) {}
 }