format with dart_style 0.2.0-rc.3

lib/src/codegen/js_codegen.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.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 164 matching lines @@
     for (var name in _exports) {
       _moduleItems.add(js.statement('#.# = #;', [_exportsVar, name, name]));
     }
 
     var jsPath = compiler.getModuleName(currentLibrary.source.uri);
 
     // TODO(jmesserly): it would be great to run the renamer on the body,
     // then figure out if we really need each of these parameters.
     // See ES6 modules: https://github.com/dart-lang/dev_compiler/issues/34
     var params = [_exportsVar, _runtimeLibVar];
-    var processImport = (LibraryElement library, JS.TemporaryId temp,
-        List list) {
+    var processImport =
+        (LibraryElement library, JS.TemporaryId temp, List list) {
       params.add(temp);
       list.add(js.string(compiler.getModuleName(library.source.uri), "'"));
     };
 
     var imports = <JS.Expression>[js.string('dart_runtime/dart')];
     _imports.forEach((library, temp) {
       if (_loader.libraryIsLoaded(library)) {
         processImport(library, temp, imports);
       }
     });
 
     var lazyImports = <JS.Expression>[];
     _imports.forEach((library, temp) {
       if (!_loader.libraryIsLoaded(library)) {
         processImport(library, temp, lazyImports);
       }
     });
 
     var dartxImport =
         js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
 
-    var module = js.call("function(#) { 'use strict'; #; #; }", [
-      params,
-      dartxImport,
-      _moduleItems
-    ]);
+    var module = js.call("function(#) { 'use strict'; #; #; }",
+        [params, dartxImport, _moduleItems]);
 
     var program = <JS.Statement>[
       js.statement("dart_library.library(#, #, #, #, #)", [
         js.string(jsPath, "'"),
         jsDefaultValue != null ? jsDefaultValue : new JS.LiteralNull(),
         js.commentExpression(
             "Imports", new JS.ArrayInitializer(imports, multiline: true)),
         js.commentExpression("Lazy imports",
             new JS.ArrayInitializer(lazyImports, multiline: true)),
         module
@@ skipping 46 matching lines @@
         return js.call('dart.notNull(#)', _visit(node.expression));
       } else {
         // A no-op in JavaScript.
         return _visit(node.expression);
       }
     }
 
     return _emitCast(node.expression, to);
   }
 
-  _emitCast(Expression node, DartType type) =>
-      js.call('dart.as(#)', [[_visit(node), _emitTypeName(type)]]);
+  _emitCast(Expression node, DartType type) => js.call('dart.as(#)', [
+        [_visit(node), _emitTypeName(type)]
+      ]);
 
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
     var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
     if (typeofName != null) {
       result = js.call('typeof # == #', [lhs, js.string(typeofName, "'")]);
@@ skipping 14 matching lines @@
     if (rules.isBoolType(t)) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     var element = node.element;
     var type = element.type;
     var name = element.name;
 
-    var fnType = js.statement('let # = dart.typedef(#, () => #);', [
-      name,
-      js.string(name, "'"),
-      _emitTypeName(type, lowerTypedef: true)
-    ]);
+    var fnType = js.statement('let # = dart.typedef(#, () => #);',
+        [name, js.string(name, "'"), _emitTypeName(type, lowerTypedef: true)]);
 
     return _finishClassDef(type, fnType);
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     var element = node.element;
@@ skipping 71 matching lines @@
       // the native JS type eagerly at this point.
       // If we wanted to support laziness, we could defer the hookup until
       // the end of the Dart library cycle load.
       assert(_loader.isLoaded(classElem));
 
       // TODO(jmesserly): this copies the dynamic members.
       // Probably fine for objects coming from JS, but not if we actually
       // want to support construction of instances with generic types other
       // than dynamic. See issue #154 for Array and List<E> related bug.
       var copyMembers = js.statement(
-          'dart.registerExtension(dart.global.#, #);', [
-        _propertyName(jsPeerName),
-        classElem.name
-      ]);
+          'dart.registerExtension(dart.global.#, #);',
+          [_propertyName(jsPeerName), classElem.name]);
       return _statement([result, copyMembers]);
     }
     return result;
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) {
     var element = node.element;
     var type = element.type;
     var name = js.string(type.name);
@@ skipping 18 matching lines @@
     var toStringF = new JS.Method(js.string('toString'),
         js.call('function() { return #[this.index]; }', nameMap) as JS.Fun);
 
     // Create enum class
     var classExpr = new JS.ClassExpression(
         id, _classHeritage(element), [constructor, toStringF]);
     var result = <JS.Statement>[js.statement('#', classExpr)];
 
     // Create static fields for each enum value
     for (var i = 0; i < fields.length; ++i) {
-      result.add(js.statement('#.# = dart.const(new #(#));', [
-        id,
-        fields[i].name,
-        id,
-        js.number(i)
-      ]));
+      result.add(js.statement('#.# = dart.const(new #(#));',
+          [id, fields[i].name, id, js.number(i)]));
     }
 
     // Create static values list
     var values = new JS.ArrayInitializer(new List<JS.Expression>.from(
         fields.map((f) => js.call('#.#', [id, f.name]))));
-    result.add(js.statement('#.values = dart.const(dart.list(#, #));', [
-      id,
-      values,
-      _emitTypeName(type)
-    ]));
+    result.add(js.statement('#.values = dart.const(dart.list(#, #));',
+        [id, values, _emitTypeName(type)]));
 
     return _statement(result);
   }
 
   /// Given a class element and body, complete the class declaration.
   /// This handles generic type parameters, laziness (in library-cycle cases),
   /// and ensuring dependencies are loaded first.
   JS.Statement _finishClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
 
     JS.Statement genericDef = null;
     if (type.typeParameters.isNotEmpty) {
       genericDef = _emitGenericClassDef(type, body);
     }
 
     // The base class and all mixins must be declared before this class.
     if (!_loader.isLoaded(type.element)) {
       // TODO(jmesserly): the lazy class def is a simple solution for now.
       // We may want to consider other options in the future.
 
       if (genericDef != null) {
         return js.statement(
-            '{ #; dart.defineLazyClassGeneric(#, #, { get: # }); }', [
-          genericDef,
-          _exportsVar,
-          _propertyName(name),
-          genericName
-        ]);
+            '{ #; dart.defineLazyClassGeneric(#, #, { get: # }); }',
+            [genericDef, _exportsVar, _propertyName(name), genericName]);
       }
 
       return js.statement(
-          'dart.defineLazyClass(#, { get #() { #; return #; } });', [
-        _exportsVar,
-        _propertyName(name),
-        body,
-        name
-      ]);
+          'dart.defineLazyClass(#, { get #() { #; return #; } });',
+          [_exportsVar, _propertyName(name), body, name]);
     }
 
     if (isPublic(name)) _addExport(name);
 
     if (genericDef != null) {
       var dynType = fillDynamicTypeArgs(type, types);
       var genericInst = _emitTypeName(dynType, lowerGeneric: true);
       return js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
     }
     return body;
   }
 
   JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
     var typeParams = type.typeParameters.map((p) => p.name);
     if (isPublic(name)) _exports.add(genericName);
-    return js.statement('let # = dart.generic(function(#) { #; return #; });', [
-      genericName,
-      typeParams,
-      body,
-      name
-    ]);
+    return js.statement('let # = dart.generic(function(#) { #; return #; });',
+        [genericName, typeParams, body, name]);
   }
 
   JS.Expression _classHeritage(ClassElement element) {
     var type = element.type;
     if (type.isObject) return null;
 
     // Assume we can load eagerly, until proven otherwise.
     _loader.startTopLevel(element);
 
     JS.Expression heritage = _emitTypeName(type.superclass);
@@ skipping 66 matching lines @@
     // If a parent had an `iterator` (concrete or abstract) or implements
     // Iterable, we know the adapter is already there, so we can skip it as a
     // simple code size optimization.
     var parent = t.lookUpGetterInSuperclass('iterator', t.element.library);
     if (parent != null) return null;
     var parentType = findSupertype(t, _implementsIterable);
     if (parentType != null) return null;
 
     // Otherwise, emit the adapter method, which wraps the Dart iterator in
     // an ES6 iterator.
-    return new JS.Method(js.call('$_SYMBOL.iterator'), js.call(
-        'function() { return new dart.JsIterator(this.#); }',
-        [_emitMemberName('iterator', type: t)]) as JS.Fun);
+    return new JS.Method(
+        js.call('$_SYMBOL.iterator'),
+        js.call('function() { return new dart.JsIterator(this.#); }',
+            [_emitMemberName('iterator', type: t)]) as JS.Fun);
   }
 
   JS.Expression _instantiateAnnotation(Annotation node) {
     var element = node.element;
     if (element is ConstructorElement) {
       return _emitInstanceCreationExpression(element, element.returnType,
           node.constructorName, node.arguments, true);
     } else {
       return _visit(node.name);
     }
   }
 
   /// Emit class members that need to come after the class declaration, such
   /// as static fields. See [_emitClassMethods] for things that are emitted
   /// inside the ES6 `class { ... }` node.
-  JS.Statement _finishClassMembers(ClassElement classElem,
-      JS.ClassExpression cls, List<ConstructorDeclaration> ctors,
-      List<FieldDeclaration> fields, List<MethodDeclaration> methods,
-      List<Annotation> metadata, String jsPeerName) {
+  JS.Statement _finishClassMembers(
+      ClassElement classElem,
+      JS.ClassExpression cls,
+      List<ConstructorDeclaration> ctors,
+      List<FieldDeclaration> fields,
+      List<MethodDeclaration> methods,
+      List<Annotation> metadata,
+      String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
 
     if (_extensionTypes.contains(classElem)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
 
     body.add(new JS.ClassDeclaration(cls));
 
     // TODO(jmesserly): we should really just extend native Array.
     if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
-      body.add(js.statement('dart.setBaseClass(#, dart.global.#);', [
-        classElem.name,
-        _propertyName(jsPeerName)
-      ]));
+      body.add(js.statement('dart.setBaseClass(#, dart.global.#);',
+          [classElem.name, _propertyName(jsPeerName)]));
     }
 
     // Interfaces
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         name,
         new JS.ArrayInitializer(new List<JS.Expression>.from(
             classElem.interfaces.map(_emitTypeName)))
       ]));
     }
 
     // Named constructors
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
-        body.add(js.statement('dart.defineNamedConstructor(#, #);', [
-          name,
-          _emitMemberName(member.name.name, isStatic: true)
-        ]));
+        body.add(js.statement('dart.defineNamedConstructor(#, #);',
+            [name, _emitMemberName(member.name.name, isStatic: true)]));
       }
     }
 
     // Instance fields, if they override getter/setter pairs
     for (FieldDeclaration member in fields) {
       for (VariableDeclaration fieldDecl in member.fields.variables) {
         var field = fieldDecl.element as FieldElement;
         if (_fieldsNeedingStorage.contains(field)) {
           body.add(_overrideField(field));
         }
@@ skipping 122 matching lines @@
       _collectExtensions(m, types);
     }
     for (var i in type.interfaces) {
       _collectExtensions(i, types);
     }
     _collectExtensions(type.superclass, types);
   }
 
   JS.Statement _overrideField(FieldElement e) {
     var cls = e.enclosingElement;
-    return js.statement('dart.virtualField(#, #)', [
-      cls.name,
-      _emitMemberName(e.name, type: cls.type)
-    ]);
+    return js.statement('dart.virtualField(#, #)',
+        [cls.name, _emitMemberName(e.name, type: cls.type)]);
   }
 
   /// Generates the implicit default constructor for class C of the form
   /// `C() : super() {}`.
   JS.Method _emitImplicitConstructor(
       ClassDeclaration node, List<FieldDeclaration> fields) {
     assert(_hasUnnamedConstructor(node.element) == fields.isNotEmpty);
 
     // If we don't have a method body, skip this.
     var superCall = _superConstructorCall(node.element);
     if (fields.isEmpty && superCall == null) return null;
 
     dynamic body = _initializeFields(node, fields);
-    if (superCall != null) body = [[body, superCall]];
+    if (superCall != null) body = [
+      [body, superCall]
+    ];
     var name = _constructorName(node.element.unnamedConstructor);
     return new JS.Method(name, js.call('function() { #; }', body) as JS.Fun);
   }
 
   JS.Method _emitConstructor(ConstructorDeclaration node, InterfaceType type,
       List<FieldDeclaration> fields, bool isObject) {
     if (_externalOrNative(node)) return null;
 
     var name = _constructorName(node.element);
 
     // Wacky factory redirecting constructors: factory Foo.q(x, y) = Bar.baz;
     var redirect = node.redirectedConstructor;
     if (redirect != null) {
       var newKeyword = redirect.staticElement.isFactory ? '' : 'new';
       // Pass along all arguments verbatim, and let the callee handle them.
       // TODO(jmesserly): we'll need something different once we have
       // rest/spread support, but this should work for now.
       var params = _visit(node.parameters);
-      var fun = js.call('function(#) { return $newKeyword #(#); }', [
-        params,
-        _visit(redirect),
-        params,
-      ]) as JS.Fun;
+      var fun = js.call('function(#) { return $newKeyword #(#); }',
+          [params, _visit(redirect), params,]) as JS.Fun;
       return new JS.Method(name, fun, isStatic: true)..sourceInformation = node;
     }
 
     // Factory constructors are essentially static methods.
     if (node.factoryKeyword != null) {
       var body = <JS.Statement>[];
       var init = _emitArgumentInitializers(node, constructor: true);
       if (init != null) body.add(init);
       body.add(_visit(node.body));
       var fun = new JS.Fun(
@@ skipping 63 matching lines @@
     // available for use by top-level constant initializers.
     ClassDeclaration cls = node.parent;
     if (node.constKeyword != null) _loader.startTopLevel(cls.element);
     var init = _emitArgumentInitializers(node, constructor: true);
     if (node.constKeyword != null) _loader.finishTopLevel(cls.element);
     if (init != null) body.add(init);
 
     // Redirecting constructors: these are not allowed to have initializers,
     // and the redirecting ctor invocation runs before field initializers.
     var redirectCall = node.initializers.firstWhere(
-        (i) => i is RedirectingConstructorInvocation, orElse: () => null);
+        (i) => i is RedirectingConstructorInvocation,
+        orElse: () => null);
 
     if (redirectCall != null) {
       body.add(_visit(redirectCall));
       return new JS.Block(body);
     }
 
     // Generate field initializers.
     // These are expanded into each non-redirecting constructor.
     // In the future we may want to create an initializer function if we have
     // multiple constructors, but it needs to be balanced against readability.
@@ skipping 166 matching lines @@
         body.add(js.statement('let # = # && # in # ? #.# : #;', [
           jsParam,
           _namedArgTemp,
           paramName,
           _namedArgTemp,
           _namedArgTemp,
           paramName,
           _defaultParamValue(param),
         ]));
       } else if (param.kind == ParameterKind.POSITIONAL) {
-        body.add(js.statement('if (# === void 0) # = #;', [
-          jsParam,
-          jsParam,
-          _defaultParamValue(param)
-        ]));
+        body.add(js.statement('if (# === void 0) # = #;',
+            [jsParam, jsParam, _defaultParamValue(param)]));
       }
 
       // TODO(jmesserly): various problems here, see:
       // https://github.com/dart-lang/dev_compiler/issues/161
       var paramType = param.element.type;
       if (!constructor && _hasTypeParameter(paramType)) {
         body.add(js.statement(
             'dart.as(#, #);', [jsParam, _emitTypeName(paramType)]));
       }
     }
@@ skipping 128 matching lines @@
         return _emitFunctionTagged(clos, type,
             topLevel: _executesAtTopLevel(node));
       }
       return clos;
     }
   }
 
   JS.Fun _emitFunctionBody(List<JS.Parameter> params, FunctionBody body) {
     // sync*, async, async*
     if (body.isAsynchronous || body.isGenerator) {
-      return new JS.Fun(params, js.statement(
-          '{ return #; }', [_emitGeneratorFunctionBody(params, body)]));
+      return new JS.Fun(
+          params,
+          js.statement(
+              '{ return #; }', [_emitGeneratorFunctionBody(params, body)]));
     }
     // normal function (sync)
     return new JS.Fun(params, _visit(body));
   }
 
   JS.Expression _emitGeneratorFunctionBody(
       List<JS.Parameter> params, FunctionBody body) {
     var kind = body.isSynchronous ? 'sync' : 'async';
     if (body.isGenerator) kind += 'Star';
 
@@ skipping 37 matching lines @@
       _asyncStarController = null;
       jsParams = params;
     }
     JS.Expression gen = new JS.Fun(jsParams, _visit(body), isGenerator: true);
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
     _asyncStarController = savedController;
 
     var T = _emitTypeName(rules.getExpectedReturnType(body));
-    return js.call('dart.#(#)', [kind, [gen, T]..addAll(params)]);
+    return js.call('dart.#(#)', [
+      kind,
+      [gen, T]..addAll(params)
+    ]);
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
 
@@ skipping 135 matching lines @@
   }
 
   /// Emits a Dart [type] into code.
   ///
   /// If [lowerTypedef] is set, a typedef will be expanded as if it were a
   /// function type. Similarly if [lowerGeneric] is set, the `List$()` form
   /// will be used instead of `List`. These flags are used when generating
   /// the definitions for typedefs and generic types, respectively.
   JS.Expression _emitTypeName(DartType type,
       {bool lowerTypedef: false, bool lowerGeneric: false}) {
-
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
       return js.call('dart.dynamic');
     } else if (type.isBottom) {
       return js.call('dart.bottom');
     }
 
     _loader.declareBeforeUse(type.element);
@@ skipping 152 matching lines @@
     if (DynamicInvoke.get(target)) {
       code = 'dart.$DSEND(#, #, #)';
     } else if (DynamicInvoke.get(node.methodName)) {
       // This is a dynamic call to a statically know target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
       code = 'dart.$DCALL(#.#, #)';
     } else if (_requiresStaticDispatch(target, name)) {
       assert(rules.objectMembers[name] is FunctionType);
       // Object methods require a helper for null checks.
-      return js.call('dart.#(#, #)', [
-        memberName,
-        _visit(target),
-        _visit(node.argumentList)
-      ]);
+      return js.call('dart.#(#, #)',
+          [memberName, _visit(target), _visit(node.argumentList)]);
     } else {
       code = '#.#(#)';
     }
 
     return js.call(
         code, [_visit(target), memberName, _visit(node.argumentList)]);
   }
 
   /// Emits code for the `JS(...)` builtin.
   _emitForeignJS(MethodInvocation node) {
@@ skipping 90 matching lines @@
       // becomes:
       //
       //     if (stream.add(e)) return;
       //     yield;
       //
       // `yield* e` becomes:
       //
       //     if (stream.addStream(e)) return;
       //     yield;
       var helperName = star ? 'addStream' : 'add';
-      return js.statement('{ if(#.#(#)) return; #; }', [
-        _asyncStarController,
-        helperName,
-        jsExpr,
-        new JS.Yield(null)
-      ]);
+      return js.statement('{ if(#.#(#)) return; #; }',
+          [_asyncStarController, helperName, jsExpr, new JS.Yield(null)]);
     }
     // A normal yield in a sync*
     return jsExpr.toYieldStatement(star: star);
   }
 
   @override
   JS.Expression visitAwaitExpression(AwaitExpression node) {
     return new JS.Yield(_visit(node.expression));
   }
 
@@ skipping 95 matching lines @@
     body.add(_emitLazyFields(_lazyFields));
     _lazyFields.clear();
   }
 
   JS.Statement _emitLazyFields(List<VariableDeclaration> fields) {
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       var element = node.element;
       var access = _emitMemberName(name, type: element.type, isStatic: true);
-      methods.add(new JS.Method(access, js.call(
-              'function() { return #; }', _visit(node.initializer)) as JS.Fun,
+      methods.add(new JS.Method(
+          access,
+          js.call('function() { return #; }', _visit(node.initializer))
+          as JS.Fun,
           isGetter: true));
 
       // TODO(jmesserly): use a dummy setter to indicate writable.
       if (!node.isFinal) {
         methods.add(new JS.Method(access, js.call('function(_) {}') as JS.Fun,
             isSetter: true));
       }
     }
 
     JS.Expression objExpr = _exportsVar;
     var target = _lazyFields[0].element.enclosingElement;
     if (target is ClassElement) {
       objExpr = new JS.Identifier(target.type.name);
     }
 
     return js.statement(
         'dart.defineLazyProperties(#, { # });', [objExpr, methods]);
   }
 
   void _flushLibraryProperties(List<JS.Statement> body) {
     if (_properties.isEmpty) return;
-    body.add(js.statement('dart.copyProperties(#, { # });', [
-      _exportsVar,
-      _properties.map(_emitTopLevelProperty)
-    ]));
+    body.add(js.statement('dart.copyProperties(#, { # });',
+        [_exportsVar, _properties.map(_emitTopLevelProperty)]));
     _properties.clear();
   }
 
   JS.Expression _emitConstructorName(
       ConstructorElement element, DartType type, SimpleIdentifier name) {
     var typeName = _emitTypeName(type);
     if (name != null || element.isFactory) {
       var namedCtor = _constructorName(element);
       return new JS.PropertyAccess(typeName, namedCtor);
     }
     return typeName;
   }
 
   @override
   visitConstructorName(ConstructorName node) {
     return _emitConstructorName(node.staticElement, node.type.type, node.name);
   }
 
-  JS.Expression _emitInstanceCreationExpression(ConstructorElement element,
-      DartType type, SimpleIdentifier name, ArgumentList argumentList,
+  JS.Expression _emitInstanceCreationExpression(
+      ConstructorElement element,
+      DartType type,
+      SimpleIdentifier name,
+      ArgumentList argumentList,
       bool isConst) {
     JS.Expression emitNew() {
       JS.Expression ctor;
       bool isFactory = false;
       // var element = node.staticElement;
       if (element == null) {
         // TODO(jmesserly): this only happens if we had a static error.
         // Should we generate a throw instead?
         ctor = _emitTypeName(type);
         if (name != null) {
@@ skipping 129 matching lines @@
         return _emitSend(left, op.lexeme, [right]);
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
         code = '${bang}dart.equals(#, #)';
       }
       return js.call(code, [_visit(left), _visit(right)]);
     }
 
     if (binaryOperationIsPrimitive(leftType, rightType) ||
         rules.isStringType(leftType) && op.type == TokenType.PLUS) {
-
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
       if (op.type == TokenType.TILDE_SLASH) {
         // `a ~/ b` is equivalent to `(a / b).truncate()`
         var div = AstBuilder.binaryExpression(left, '/', right)
           ..staticType = node.staticType;
         return _emitSend(div, 'truncate', []);
       } else {
@@ skipping 56 matching lines @@
   ///
   /// If the expression does not end up using `x1` or `x2` more than once, or
   /// if those expressions can be treated as stateless (e.g. they are
   /// non-mutated variables), then the resulting code will be simplified
   /// automatically.
   ///
   /// [scope] can be mutated to contain any new temporaries that were created,
   /// unless [expr] is a SimpleIdentifier, in which case a temporary is not
   /// needed.
   Expression _bindLeftHandSide(
-      Map<String, JS.Expression> scope, Expression expr, {Expression context}) {
+      Map<String, JS.Expression> scope, Expression expr,
+      {Expression context}) {
     Expression result;
     if (expr is IndexExpression) {
       IndexExpression index = expr;
       result = new IndexExpression.forTarget(
           _bindValue(scope, 'o', index.target, context: context),
           index.leftBracket,
           _bindValue(scope, 'i', index.index, context: context),
           index.rightBracket);
     } else if (expr is PropertyAccess) {
       PropertyAccess prop = expr;
       result = new PropertyAccess(
           _bindValue(scope, 'o', _getTarget(prop), context: context),
-          prop.operator, prop.propertyName);
+          prop.operator,
+          prop.propertyName);
     } else if (expr is PrefixedIdentifier) {
       PrefixedIdentifier ident = expr;
-      result = new PrefixedIdentifier(_bindValue(scope, 'o', ident.prefix,
-              context: context) as SimpleIdentifier, ident.period,
+      result = new PrefixedIdentifier(
+          _bindValue(scope, 'o', ident.prefix, context: context)
+          as SimpleIdentifier,
+          ident.period,
           ident.identifier);
     } else {
       return expr as SimpleIdentifier;
     }
     result.staticType = expr.staticType;
     DynamicInvoke.set(result, DynamicInvoke.get(expr));
     return result;
   }
 
   /// Creates a temporary to contain the value of [expr]. The temporary can be
@@ skipping 200 matching lines @@
       Expression target, String name, List<Expression> args) {
     var type = getStaticType(target);
     var memberName = _emitMemberName(name, unary: args.isEmpty, type: type);
     if (DynamicInvoke.get(target)) {
       // dynamic dispatch
       var dynamicHelper = const {'[]': DINDEX, '[]=': DSETINDEX}[name];
       if (dynamicHelper != null) {
         return js.call(
             'dart.$dynamicHelper(#, #)', [_visit(target), _visitList(args)]);
       }
-      return js.call('dart.$DSEND(#, #, #)', [
-        _visit(target),
-        memberName,
-        _visitList(args)
-      ]);
+      return js.call('dart.$DSEND(#, #, #)',
+          [_visit(target), memberName, _visitList(args)]);
     }
 
     // Generic dispatch to a statically known method.
     return js.call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
     if (_useNativeJsIndexer(target.staticType)) {
@@ skipping 100 matching lines @@
     // TODO(jmesserly): we may want a helper if these become common. For now the
     // full desugaring seems okay.
     var context = compiler.context;
     var dart_async = context
         .computeLibraryElement(context.sourceFactory.forUri('dart:async'));
     var T = node.loopVariable.element.type;
     var StreamIterator_T =
         dart_async.getType('StreamIterator').type.substitute4([T]);
 
     var createStreamIter = _emitInstanceCreationExpression(
-        StreamIterator_T.element.unnamedConstructor, StreamIterator_T, null,
-        AstBuilder.argumentList([node.iterable]), false);
+        StreamIterator_T.element.unnamedConstructor,
+        StreamIterator_T,
+        null,
+        AstBuilder.argumentList([node.iterable]),
+        false);
     var iter = _visit(_createTemporary('it', StreamIterator_T));
 
     var init = _visit(node.identifier);
     if (init == null) {
       init = js.call(
           'let # = #.current', [node.loopVariable.identifier.name, iter]);
     } else {
       init = js.call('# = #.current', [init, iter]);
     }
-    return js.statement('{'
+    return js.statement(
+        '{'
         '  let # = #;'
         '  try {'
         '    while (#) { #; #; }'
         '  } finally { #; }'
-        '}', [
+        '}',
+        [
       iter,
       createStreamIter,
       new JS.Yield(js.call('#.moveNext()', iter)),
       init,
       _visit(node.body),
       new JS.Yield(js.call('#.cancel()', iter))
     ]);
   }
 
   @override
@@ skipping 39 matching lines @@
   }
 
   JS.Statement _catchClauseGuard(CatchClause clause, JS.Statement otherwise) {
     var then = visitCatchClause(clause);
 
     // Discard following clauses, if any, as they are unreachable.
     if (clause.exceptionType == null) return then;
 
     // TODO(jmesserly): this is inconsistent with [visitIsExpression], which
     // has special case for typeof.
-    return new JS.If(js.call('dart.is(#, #)', [
-      _visit(_catchParameter),
-      _emitTypeName(clause.exceptionType.type),
-    ]), then, otherwise);
+    return new JS.If(
+        js.call('dart.is(#, #)', [
+          _visit(_catchParameter),
+          _emitTypeName(clause.exceptionType.type),
+        ]),
+        then,
+        otherwise);
   }
 
   JS.Statement _statement(List<JS.Statement> statements) {
     // TODO(jmesserly): empty block singleton?
     if (statements.length == 0) return new JS.Block([]);
     if (statements.length == 1) return statements[0];
     return new JS.Block(statements);
   }
 
   /// Visits the catch clause body. This skips the exception type guard, if any.
@@ skipping 247 matching lines @@
   ///
   /// 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, bool unary: false,
-      bool isStatic: false, bool allowExtensions: true}) {
-
+  JS.Expression _emitMemberName(String name,
+      {DartType type,
+      bool unary: false,
+      bool isStatic: false,
+      bool allowExtensions: true}) {
     // Static members skip the rename steps.
     if (isStatic) return _propertyName(name);
 
     if (name.startsWith('_')) {
       return _privateNames.putIfAbsent(
           name, () => _initSymbol(new JS.TemporaryId(name)) as JS.TemporaryId);
     }
 
     if (name == '[]') {
       name = 'get';
@@ skipping 93 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }