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;
@@ skipping 23 matching lines @@
     show BuildUnit, CompilerOptions, JSModuleFile, ModuleFormat;
 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;
+    show
+        CommonJSModuleBuilder,
+        RequireJSModuleBuilder,

[nweiz, 2016/08/16 22:14:53]

For what it's worth, despite their names, CommonJS and RequireJS aren't actually
the same type of thing. CommonJS is a standard, whereas RequireJS is an
implementation of a standard (namely, Asynchronous Module Definition). So it
might be better to call this AmdModuleBuilder and so on.

[Jennifer Messerly, 2016/08/24 22:39:51]

yeah, I was kind of going back and forth there, as various terminology seems to
be used out there and it's shifted a bit over time. I'm happy to go with AMD
though, that's the term I'm more familiar with :)

+        LegacyModuleBuilder,
+        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;
@@ skipping 228 matching lines @@
     // 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.commonjs:
+        return new CommonJSModuleBuilder().build(module);
+      case ModuleFormat.requirejs:
+        return new RequireJSModuleBuilder().build(module);
       case ModuleFormat.es6:
         return module;
     }
     return null; // unreachable. It is here to suppress a bogus Analyzer message
   }
 
   List<String> _getJSName(Element e) {
     if (findAnnotation(e.library, isPublicJSAnnotation) == null) {
       return null;
     }
@@ skipping 1438 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 1479 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 517 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 198 matching lines @@
       // 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.
   static Map<String, List<String>> _uncheckedWhitelist = {
-    'dom_renderer.dart': ['moveNodesAfterSibling',],
+    'dom_renderer.dart': [
+      'moveNodesAfterSibling',

[nweiz, 2016/08/16 22:14:53]

Nittiest of nits: for consistency, either remove the trailing comma here or add
one to the other similar lists.

[Jennifer Messerly, 2016/08/24 22:39:51]

definitely. Yeah I honestly have no idea what this code is for, certainly isn't
mine as I wouldn't have used a trailing comma in a 1 element list, nor would I
have LGTM'd a hard coded list of methods =(

I'm going to add some TODO's because this thing is terrible.

+    ],
     '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 76 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';