fix #626, add AMD module format and make it default

test/codegen_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.
 
 /// 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;
 
 // TODO(rnystrom): This doesn't actually run any tests any more. It just
 // compiles stuff. This should be changed to not use unittest and just be a
 // regular program that outputs files.
 
-import 'dart:convert' show JSON;
 import 'dart:io' show Directory, File, Platform;
-import 'package:args/args.dart' show ArgParser, ArgResults;
-import 'package:path/path.dart' as path;
-import 'package:test/test.dart' show test;
-
 import 'package:analyzer/analyzer.dart'
     show
         ExportDirective,
         ImportDirective,
         StringLiteral,
         UriBasedDirective,
         parseDirectives;
 import 'package:analyzer/src/generated/source.dart' show Source;
+import 'package:args/args.dart' show ArgParser, ArgResults;
 import 'package:dev_compiler/src/analyzer/context.dart' show AnalyzerOptions;
 import 'package:dev_compiler/src/compiler/compiler.dart'
-    show BuildUnit, CompilerOptions, ModuleCompiler;
+    show BuildUnit, CompilerOptions, JSModuleFile, ModuleCompiler;
+import 'package:dev_compiler/src/compiler/module_builder.dart'
+    show
+        ModuleFormat,
+        addModuleFormatOptions,
+        parseModuleFormatOption,
+        pathToJSIdentifier;
+import 'package:path/path.dart' as path;
+import 'package:test/test.dart' show expect, isFalse, isTrue, test;
+
+import '../tool/build_sdk.dart' as build_sdk;
 import 'testing.dart' show repoDirectory, testDirectory;
 import 'multitest.dart' show extractTestsFromMultitest, isMultiTest;
-import '../tool/build_sdk.dart' as build_sdk;
-import 'package:dev_compiler/src/compiler/compiler.dart';
+import 'not_yet_strong_tests.dart';
 
 final ArgParser argParser = new ArgParser()
   ..addOption('dart-sdk', help: 'Dart SDK Path', defaultsTo: null);
 
 /// The `test/codegen` directory.
 final codegenDir = path.join(testDirectory, 'codegen');
 
 /// The `test/codegen/expect` directory.
 final codegenExpectDir = path.join(testDirectory, 'codegen_expected');
 
@@ skipping 14 matching lines @@
 
 RegExp filePattern;
 
 main(List<String> arguments) {
   if (arguments == null) arguments = [];
   ArgResults args = argParser.parse(arguments);
   filePattern = new RegExp(args.rest.length > 0 ? args.rest[0] : '.');
 
   var sdkDir = path.join(repoDirectory, 'gen', 'patched_sdk');
   var sdkSummaryFile =
-      path.join(testDirectory, '..', 'lib', 'runtime', 'dart_sdk.sum');
+      path.join(testDirectory, '..', 'lib', 'js', 'amd', 'dart_sdk.sum');
 
   var summaryPaths = new Directory(path.join(codegenOutputDir, 'pkg'))
       .listSync()
       .map((e) => e.path)
       .where((p) => p.endsWith('.sum'))
       .toList();
 
   var analyzerOptions = new AnalyzerOptions(
       dartSdkSummaryPath: sdkSummaryFile, summaryPaths: summaryPaths);
   var compiler = new ModuleCompiler(analyzerOptions);
 
   var testDirs = [
     'language',
     'corelib',
     path.join('lib', 'convert'),
     path.join('lib', 'html'),
     path.join('lib', 'math'),
     path.join('lib', 'mirrors'),
     path.join('lib', 'typed_data'),
   ];
 
   // Copy all of the test files and expanded multitest files to
   // gen/codegen_tests. We'll compile from there.
   var testFiles = _setUpTests(testDirs);
 
   // Our default compiler options. Individual tests can override these.
   var defaultOptions = ['--no-source-map', '--no-summarize'];
   var compilerArgParser = new ArgParser();
   CompilerOptions.addArguments(compilerArgParser);
+  addModuleFormatOptions(compilerArgParser);
 
   // Compile each test file to JS and put the result in gen/codegen_output.
   for (var testFile in testFiles) {
     var relativePath = path.relative(testFile, from: codegenTestDir);
 
     // Only compile the top-level files for generating coverage.
     bool isTopLevelTest = path.dirname(relativePath) == ".";
     if (codeCoverage && !isTopLevelTest) continue;
 
     var name = path.withoutExtension(relativePath);
     test('dartdevc $name', () {
       // Check if we need to use special compile options.
       var contents = new File(testFile).readAsStringSync();
       var match =
           new RegExp(r'// compile options: (.*)').matchAsPrefix(contents);
 
       var args = defaultOptions.toList();
       if (match != null) {
         args.addAll(match.group(1).split(' '));
       }
-      var options =
-          new CompilerOptions.fromArguments(compilerArgParser.parse(args));
+
+      var argResults = compilerArgParser.parse(args);
+      var options = new CompilerOptions.fromArguments(argResults);
+      var moduleFormat = parseModuleFormatOption(argResults).first;
 
       // Collect any other files we've imported.
       var files = new Set<String>();
       _collectTransitiveImports(contents, files, from: testFile);
       var unit = new BuildUnit(
           name, path.dirname(testFile), files.toList(), _moduleForLibrary);
       var module = compiler.compile(unit, options);
-      _writeModule(path.join(codegenOutputDir, name),
-          isTopLevelTest ? path.join(codegenExpectDir, name) : null, module);
+
+      bool notStrong = notYetStrongTests.contains(name);
+      if (module.isValid) {
+        _writeModule(
+            path.join(codegenOutputDir, name),
+            isTopLevelTest ? path.join(codegenExpectDir, name) : null,
+            moduleFormat,
+            module);
+
+        expect(notStrong, isFalse,
+            reason: "test $name expected strong mode errors, but compiled.");
+      } else {
+        expect(notStrong, isTrue,

[vsm, 2016/08/25 12:19:24]

Perhaps we should clear any file at the output path to remove stale output
(e.g., if a test becomes not-strong).

[Jennifer Messerly, 2016/08/25 16:21:39]

It's not needed. test.sh does this at the start.

The reason you saw js_test is an artifact of my local iteration, and previous
states of this file. Now, if a codegen_expect thing stopped compiling, you would
see that as a test failure. Currently js_test is the only one that we can't
compile. (a very limited number of things are in codegen_expect)

+            reason: "test $name failed to compile due to strong mode errors:"
+                "\n\n${module.errors.join('\n')}.");
+      }
     });
   }
 
   if (filePattern.hasMatch('sunflower')) {
-    _buildSunflower(compiler, codegenOutputDir, codegenExpectDir);
+    test('sunflower', () {
+      _buildSunflower(compiler, codegenOutputDir, codegenExpectDir);
+    });
   }
 
   if (codeCoverage) {
     test('build_sdk code coverage', () {
       return build_sdk.main(['--dart-sdk', sdkDir, '-o', codegenOutputDir]);
     });
   }
 }
 
-void _writeModule(String outPath, String expectPath, JSModuleFile result) {
+void _writeModule(String outPath, String expectPath, ModuleFormat format,
+    JSModuleFile result) {
   _ensureDirectory(path.dirname(outPath));
 
   String errors = result.errors.join('\n');
   if (errors.isNotEmpty && !errors.endsWith('\n')) errors += '\n';
   new File(outPath + '.txt').writeAsStringSync(errors);
 
-  var jsFile = new File(outPath + '.js');
-  var summaryFile = new File(outPath + '.sum');
-  var errorFile = new File(outPath + '.err');
+  result.writeCodeSync(format, outPath + '.js');
 
-  if (result.isValid) {
-    jsFile.writeAsStringSync(result.code);
-    if (result.summaryBytes != null) {
-      summaryFile.writeAsBytesSync(result.summaryBytes);
-    }
-    if (result.sourceMap != null) {
-      var mapPath = outPath + '.js.map';
-      new File(mapPath)
-          .writeAsStringSync(JSON.encode(result.placeSourceMap(mapPath)));
-    }
-
-    // There are no errors, so delete any stale ".err" file.
-    if (errorFile.existsSync()) {
-      errorFile.deleteSync();
-    }
-  } else {
-    // Also write the errors to a '.err' file for easy counting.
-    var moduleName = result.name;
-    var libraryName = path.split(moduleName).last;
-    var count = "[error]".allMatches(errors).length;
-    var text = '''
-dart_library.library('$moduleName', null, [
-  'dart_sdk',
-  'expect'
-], function(exports, dart_sdk, expect) {
-  const message = `DDC Compilation Error: $moduleName has $count errors`;
-  const error = new Error(message);
-  exports.$libraryName = Object.create(null);
-  exports.$libraryName.main = function() {
-    throw error;
-  }
-});
-    ''';
-    errorFile.writeAsStringSync(text);
-
-    // There are errors, so delete any stale ".js" file.
-    if (jsFile.existsSync()) {
-      jsFile.deleteSync();
-    }
+  if (result.summaryBytes != null) {
+    new File(outPath + '.sum').writeAsBytesSync(result.summaryBytes);
   }
 
   // Write the expectation file if needed.
   // Generally speaking we try to avoid these tests, but they are occasionally
   // useful.
   if (expectPath != null) {
     _ensureDirectory(path.dirname(expectPath));
 
     var expectFile = new File(expectPath + '.js');
     if (result.isValid) {
-      expectFile.writeAsStringSync(result.code);
+      result.writeCodeSync(format, expectFile.path);
     } else {
-      // There are errors, so delete any stale expect ".js" file.
-      if (expectFile.existsSync()) {
-        expectFile.deleteSync();
-      }
       expectFile.writeAsStringSync("//FAILED TO COMPILE");
     }
   }
 }
 
 void _buildSunflower(
     ModuleCompiler compiler, String outputDir, String expectDir) {
   var baseDir = path.join(codegenDir, 'sunflower');
   var files = ['sunflower', 'circle', 'painter']
       .map((f) => path.join(baseDir, '$f.dart'))
       .toList();
   var input = new BuildUnit('sunflower', baseDir, files, _moduleForLibrary);
   var options = new CompilerOptions(summarizeApi: false);
 
   var built = compiler.compile(input, options);
   _writeModule(path.join(outputDir, 'sunflower', 'sunflower'),
-      path.join(expectDir, 'sunflower', 'sunflower'), built);
+      path.join(expectDir, 'sunflower', 'sunflower'), ModuleFormat.amd, built);
 }
 
 String _moduleForLibrary(Source source) {
   var scheme = source.uri.scheme;
   if (scheme == 'package') {
     return source.uri.pathSegments.first;
   }
   throw new Exception('Module not found for library "${source.fullName}"');
 }
 
@@ skipping 105 matching lines @@
 /// Simplified from ParseDartTask.resolveDirective.
 String _resolveDirective(UriBasedDirective directive) {
   StringLiteral uriLiteral = directive.uri;
   String uriContent = uriLiteral.stringValue;
   if (uriContent != null) {
     uriContent = uriContent.trim();
     directive.uriContent = uriContent;
   }
   return directive.validate() == null ? uriContent : null;
 }