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

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
 import 'package:analyzer/src/dart/element/element.dart'
     show LocalVariableElementImpl;
 import 'package:analyzer/src/dart/element/type.dart' show DynamicTypeImpl;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, NamespaceBuilder;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     show PackageBundleAssembler;
 import 'package:analyzer/src/task/strong/ast_properties.dart'
     show isDynamicInvoke, setIsDynamicInvoke;
-import 'package:source_maps/source_maps.dart';
 import 'package:path/path.dart' show separator;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
 import 'ast_builder.dart' show AstBuilder;
 import 'compiler.dart'
-    show BuildUnit, CompilerOptions, JSModuleFile, ModuleFormat;
+    show BuildUnit, CompilerOptions, JSModuleFile;
 import 'element_helpers.dart';
 import 'element_loader.dart' show ElementLoader;
 import 'extension_types.dart' show ExtensionTypeSet;
 import 'js_field_storage.dart' show checkForPropertyOverride, getSuperclasses;
 import 'js_interop.dart';
 import 'js_metalet.dart' as JS;
 import 'js_names.dart' as JS;
 import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
-import 'module_builder.dart'
-    show LegacyModuleBuilder, NodeModuleBuilder, pathToJSIdentifier;
+import 'module_builder.dart' show pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
-import 'source_map_printer.dart' show SourceMapPrintingContext;
 import 'type_utilities.dart';
 
 class CodeGenerator extends GeneralizingAstVisitor
     with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
   final AnalysisContext context;
   final CompilerOptions options;
   final rules = new StrongTypeSystemImpl();
 
   /// The set of libraries we are currently compiling, and the temporaries used
   /// to refer to them.
@@ skipping 107 matching lines @@
   /// Takes the metadata for the build unit, as well as resolved trees and
   /// errors, and computes the output module code and optionally the source map.
   JSModuleFile compile(BuildUnit unit, List<CompilationUnit> compilationUnits,
       List<String> errors) {
     _buildUnit = unit;
     _libraryRoot = _buildUnit.libraryRoot;
     if (!_libraryRoot.endsWith(separator)) {
       _libraryRoot = '$_libraryRoot${separator}';
     }
 
-    var jsTree = _emitModule(compilationUnits);
-    var codeAndSourceMap = _writeJSText(unit, jsTree);
+    var module = _emitModule(compilationUnits);
+    var dartApiSummary = _summarizeModule(compilationUnits);
 
-    List<int> summary;
-    if (options.summarizeApi) {
-      var assembler = new PackageBundleAssembler();
-      compilationUnits
-          .map((u) => u.element.library)
-          .toSet()
-          .forEach(assembler.serializeLibraryElement);
-      summary = assembler.assemble().toBuffer();
-    }
-
-    return new JSModuleFile(
-        unit.name, errors, codeAndSourceMap.e0, codeAndSourceMap.e1, summary);
+    return new JSModuleFile(unit.name, errors, options, module, dartApiSummary);
   }
 
-  Tuple2<String, Map> _writeJSText(BuildUnit unit, JS.Program jsTree) {
-    var opts = new JS.JavaScriptPrintingOptions(
-        emitTypes: options.closure,
-        allowKeywordsInProperties: true,
-        allowSingleLineIfStatements: true);
-    JS.SimpleJavaScriptPrintingContext printer;
-    SourceMapBuilder sourceMap;
-    if (options.sourceMap) {
-      var sourceMapContext = new SourceMapPrintingContext();
-      sourceMap = sourceMapContext.sourceMap;
-      printer = sourceMapContext;
-    } else {
-      printer = new JS.SimpleJavaScriptPrintingContext();
-    }
+  List<int> _summarizeModule(List<CompilationUnit> compilationUnits) {
+    if (!options.summarizeApi) return null;
 
-    jsTree.accept(new JS.Printer(opts, printer,
-        localNamer: new JS.TemporaryNamer(jsTree)));
-
-    if (options.sourceMap && options.sourceMapComment) {
-      printer.emit('\n//# sourceMappingURL=${unit.name}.js.map\n');
-    }
-
-    return new Tuple2(printer.getText(), sourceMap?.build(unit.name + '.js'));
+    var assembler = new PackageBundleAssembler();
+    compilationUnits
+        .map((u) => u.element.library)
+        .toSet()
+        .forEach(assembler.serializeLibraryElement);
+    return assembler.assemble().toBuffer();
   }
 
   JS.Program _emitModule(List<CompilationUnit> compilationUnits) {
     if (_moduleItems.isNotEmpty) {
       throw new StateError('Can only call emitModule once.');
     }
 
     // Transform the AST to make coercions explicit.
     compilationUnits = CoercionReifier.reify(compilationUnits);
 
@@ skipping 51 matching lines @@
     _finishImports(items);
 
     // Discharge the type table cache variables and
     // hoisted definitions.
     items.addAll(_typeTable.discharge());
 
     // Add the module's code (produced by visiting compilation units, above)
     _copyAndFlattenBlocks(items, _moduleItems);
 
     // Build the module.
-    var module = new JS.Program(items, name: _buildUnit.name);
-
-    // Optional: lower module format. Otherwise just return it.
-    switch (options.moduleFormat) {
-      case ModuleFormat.legacy:
-        return new LegacyModuleBuilder().build(module);
-      case ModuleFormat.node:
-        return new NodeModuleBuilder().build(module);
-      case ModuleFormat.es6:
-        return module;
-    }
-    return null; // unreachable. It is here to suppress a bogus Analyzer message
+    return new JS.Program(items, name: _buildUnit.name);
   }
 
   List<String> _getJSName(Element e) {
     if (findAnnotation(e.library, isPublicJSAnnotation) == null) {
       return null;
     }
 
     var libraryJSName = getAnnotationName(e.library, isPublicJSAnnotation);
     var libraryPrefix = <String>[];
     if (libraryJSName != null && libraryJSName.isNotEmpty) {
@@ skipping 1434 matching lines @@
       var property = new JS.Property(memberName, type);
       tCtors.add(property);
     }
 
     JS.Property build(String name, List<JS.Property> elements) {
       var o =
           new JS.ObjectInitializer(elements, multiline: elements.length > 1);
       var e = js.call('() => #', o);
       return new JS.Property(_propertyName(name), e);
     }
+
     var sigFields = <JS.Property>[];
     if (!tCtors.isEmpty) sigFields.add(build('constructors', tCtors));
     if (!tMethods.isEmpty) sigFields.add(build('methods', tMethods));
     if (!tStatics.isEmpty) {
       assert(!sNames.isEmpty);
       var aNames = new JS.Property(
           _propertyName('names'), new JS.ArrayInitializer(sNames));
       sigFields.add(build('statics', tStatics));
       sigFields.add(aNames);
     }
@@ skipping 1492 matching lines @@
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     JS.Expression jsTarget = _visit(target);
     if (isDynamicInvoke(target) || isDynamicInvoke(node.methodName)) {
       if (_inWhitelistCode(target)) {
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var l = _visit(_bindValue(vars, 'l', target));
         jsTarget = new JS.MetaLet(vars, [
-          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #])',
-              [l, l, memberName, memberName,])
+          js.call('(#[(#[dart._extensionType]) ? dartx[#] : #])', [
+            l,
+            l,
+            memberName,
+            memberName,
+          ])
         ]);
         if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
         return new JS.Call(jsTarget, args);
       }
       if (typeArgs != null) {
         return js.call('dart.dgsend(#, #, #, #)',
             [jsTarget, new JS.ArrayInitializer(typeArgs), memberName, args]);
       } else {
         return js.call('dart.dsend(#, #, #)', [jsTarget, memberName, args]);
       }
@@ skipping 522 matching lines @@
         if (name != null) {
           ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
         }
       } else {
         ctor = _emitConstructorName(element, type, name);
         isFactory = element.isFactory;
       }
       var args = _visit(argumentList) as List<JS.Expression>;
       return isFactory ? new JS.Call(ctor, args) : new JS.New(ctor, args);
     }
+
     if (element != null && _isObjectLiteral(element.enclosingElement)) {
       return _emitObjectLiteral(argumentList);
     }
     if (isConst) return _emitConst(emitNew);
     return emitNew();
   }
 
   bool _isObjectLiteral(ClassElement classElem) {
     return findAnnotation(classElem, isPublicJSAnnotation) != null &&
         findAnnotation(classElem, isJSAnonymousAnnotation) != null;
@@ skipping 221 matching lines @@
     }
     int finishIdentifier(SimpleIdentifier identifier) {
       Element staticElement = identifier.staticElement;
       if (staticElement is PropertyAccessorElement && staticElement.isGetter) {
         PropertyInducingElement variable = staticElement.variable;
         int value = variable?.constantValue?.toIntValue();
         if (value != null && value >= low && value <= high) return value;
       }
       return null;
     }
+
     if (expr is SimpleIdentifier) {
       return finishIdentifier(expr);
     } else if (expr is PrefixedIdentifier && !expr.isDeferred) {
       return finishIdentifier(expr.identifier);
     }
     return null;
   }
 
   bool _isDefinitelyNonNegative(Expression expr) {
     expr = expr.unParenthesized;
@@ skipping 67 matching lines @@
             }
             return MAX;
           default:
             return MAX;
         }
       }
       int value = _asIntInRange(expr, 0, 0x7fffffff);
       if (value != null) return value.bitLength;
       return MAX;
     }
+
     return bitWidth(expr, 0) < 32;
   }
 
   /// If the type [t] is [int] or [double], or a type parameter
   /// bounded by [int], [double] or [num] returns [num].
   /// Otherwise returns [t].
   DartType _canonicalizeNumTypes(DartType t) {
     var numType = types.numType;
     if (rules.isSubtypeOf(t, numType)) return numType;
     return t;
@@ skipping 770 matching lines @@
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitSymbolLiteral(SymbolLiteral node) {
     JS.Expression emitSymbol() {
       // TODO(vsm): When we canonicalize, we need to treat private symbols
       // correctly.
       var name = js.string(node.components.join('.'), "'");
       return js.call('#.new(#)', [_emitType(types.symbolType), name]);
     }
+
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     var isConst = node.constKeyword != null;
     JS.Expression emitList() {
       JS.Expression list = new JS.ArrayInitializer(
           _visitList(node.elements) as List<JS.Expression>);
       ParameterizedType type = node.staticType;
       var elementType = type.typeArguments.single;
       // TODO(jmesserly): analyzer will usually infer `List<Object>` because
       // that is the least upper bound of the element types. So we rarely
       // generate a plain `List<dynamic>` anymore.
       if (!elementType.isDynamic || isConst) {
         // dart.list helper internally depends on _interceptors.JSArray.
         _declareBeforeUse(_jsArray);
         if (isConst) {
           var typeRep = _emitType(elementType);
           list = js.call('dart.constList(#, #)', [list, typeRep]);
         } else {
           // Call `new JSArray<E>.of(list)`
           var jsArrayType = _jsArray.type.instantiate(type.typeArguments);
           list = js.call('#.of(#)', [_emitType(jsArrayType), list]);
         }
       }
       return list;
     }
+
     if (isConst) return _cacheConst(emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     // TODO(jmesserly): we can likely make these faster.
     JS.Expression emitMap() {
       var entries = node.entries;
       var mapArguments = null;
@@ skipping 18 matching lines @@
           values.add(_visit(e.value));
         }
         mapArguments = new JS.ArrayInitializer(values);
       }
       var types = <JS.Expression>[];
       if (reifyTypeArgs) {
         types.addAll(typeArgs.map((e) => _emitType(e)));
       }
       return js.call('dart.map(#, #)', [mapArguments, types]);
     }
+
     if (node.constKeyword != null) return _emitConst(emitMap);
     return emitMap();
   }
 
   @override
   JS.LiteralString visitSimpleStringLiteral(SimpleStringLiteral node) =>
       js.escapedString(node.value, node.isSingleQuoted ? "'" : '"');
 
   @override
   JS.Expression visitAdjacentStrings(AdjacentStrings node) =>
@@ skipping 56 matching lines @@
 
   /// Generates an expression for a boolean conversion context (if, while, &&,
   /// etc.), where conversions and null checks are implemented via `dart.test`
   /// to give a more helpful message.
   // TODO(sra): When nullablility is available earlier, it would be cleaner to
   // build an input AST where the boolean conversion is a single AST node.
   JS.Expression _visitTest(Expression node) {
     JS.Expression finish(JS.Expression result) {
       return annotate(result, node);
     }
+
     if (node is PrefixExpression && node.operator.lexeme == '!') {
       return finish(js.call('!#', _visitTest(node.operand)));
     }
     if (node is ParenthesizedExpression) {
       return finish(_visitTest(node.expression));
     }
     if (node is BinaryExpression) {
       JS.Expression shortCircuit(String code) {
         return finish(js.call(code,
             [_visitTest(node.leftOperand), _visitTest(node.rightOperand)]));
       }
+
       var op = node.operator.type.lexeme;
       if (op == '&&') return shortCircuit('# && #');
       if (op == '||') return shortCircuit('# || #');
     }
     if (isReifiedCoercion(node)) {
       AsExpression asNode = node;
       assert(asNode.staticType == types.boolType);
       return js.call('dart.test(#)', _visit(asNode.expression));
     }
     JS.Expression result = _visit(node);
@@ skipping 44 matching lines @@
   /// They generate code like:
   ///
   ///     x['+'](y)
   ///
   /// There are three exceptions: [], []= and unary -.
   /// The indexing operators we use `get` and `set` instead:
   ///
   ///     x.get('hi')
   ///     x.set('hi', 123)
   ///
-  /// This follows the same pattern as EcmaScript 6 Map:
+  /// This follows the same pattern as ECMAScript 6 Map:
   /// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map>
   ///
   /// Unary minus looks like: `x['unary-']()`. Note that [unary] must be passed
   /// for this transformation to happen, otherwise binary minus is assumed.
   ///
   /// Equality is a bit special, it is generated via the Dart `equals` runtime
   /// helper, that checks for null. The user defined method is called '=='.
   ///
   JS.Expression _emitMemberName(String name,
       {DartType type,
@@ skipping 132 matching lines @@
       // TODO(leafp): The above only handles the case where the return type
       // is exactly Future/Stream/Iterable.  Handle the subtype case.
       return DynamicTypeImpl.instance;
     }
   }
 
   /// Maps whitelisted files to a list of whitelisted methods
   /// within the file.
   ///
   /// If the value is null, the entire file is whitelisted.
+  ///
+  // TODO(jmesserly): why is this here, and what can we do to remove it?
+  //
+  // Hard coded lists are completely unnecessary -- if a feature is needed,
+  // metadata, type system features, or command line options are the right way
+  // to express it.
+  //
+  // As it is this is completely unsound and unmaintainable.
   static Map<String, List<String>> _uncheckedWhitelist = {
-    'dom_renderer.dart': ['moveNodesAfterSibling',],
+    'dom_renderer.dart': ['moveNodesAfterSibling'],
     'template_ref.dart': ['createEmbeddedView'],
     'ng_class.dart': ['_applyIterableChanges'],
     'ng_for.dart': ['_bulkRemove', '_bulkInsert'],
     'view_container_ref.dart': ['createEmbeddedView'],
     'default_iterable_differ.dart': null,
   };
 
   static Set<String> _uncheckedWhitelistCalls = new Set()
     ..add('ng_zone_impl.dart')
     ..add('stack_zone_specification.dart')
@@ skipping 19 matching lines @@
     }
 
     // Dynamic calls are less risky so there is no need to whitelist at the
     // method level.
     if (isCall && _uncheckedWhitelistCalls.contains(filename)) return true;
 
     return path.endsWith(".template.dart");
   }
 }
 
-/// Choose a canonical name from the library element.
+/// Choose a canonical name from the [library] element.
+///
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(String libraryRoot, LibraryElement library) {
   var uri = library.source.uri;
   if (uri.scheme == 'dart') {
     return uri.path;
   }
   // TODO(vsm): This is not necessarily unique if '__' appears in a file name.
   var separator = '__';
   String qualifiedPath;
@@ skipping 36 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';