Reformat

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;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:analyzer/src/task/dart.dart' show PublicNamespaceBuilder;
 
 import 'package:dev_compiler/src/codegen/ast_builder.dart' show AstBuilder;
 import 'package:dev_compiler/src/codegen/reify_coercions.dart'
     show CoercionReifier;
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart' as JS;
 import 'package:dev_compiler/src/js/js_ast.dart' show js;
 
-import 'package:dev_compiler/src/closure/closure_annotator.dart' show ClosureAnnotator;
+import 'package:dev_compiler/src/closure/closure_annotator.dart'
+    show ClosureAnnotator;
 import 'package:dev_compiler/src/compiler.dart' show AbstractCompiler;
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart' show CodegenOptions;
 import 'package:dev_compiler/src/utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
@@ skipping 323 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 = annotateTypeDef(js.statement('let # = dart.typedef(#, () => #);',
-        [name, js.string(name, "'"), _emitTypeName(type, lowerTypedef: true)]),
+    var fnType = annotateTypeDef(
+        js.statement('let # = dart.typedef(#, () => #);', [
+          name,
+          js.string(name, "'"),
+          _emitTypeName(type, lowerTypedef: true)
+        ]),
         node.element);
 
     return _finishClassDef(type, fnType);
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
@@ skipping 556 matching lines @@
         return result === void 0 ? this : result;
       }''') as JS.Block;
     } else {
       body = _emitConstructorBody(node, fields);
     }
 
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
     return annotate(
-        new JS.Method(
-            name, new JS.Fun(_visit(node.parameters) as List<JS.Parameter>, body))
-        ..sourceInformation = node,
+        new JS.Method(name,
+            new JS.Fun(_visit(node.parameters) as List<JS.Parameter>, body))
+          ..sourceInformation = node,
         node.element);
   }
 
   JS.Expression _constructorName(ConstructorElement ctor) {
     var name = ctor.name;
     if (name != '') {
       return _emitMemberName(name, isStatic: true);
     }
 
     // Factory default constructors use `new` as their name, for readability
@@ skipping 193 matching lines @@
     if (parameters == null) return null;
 
     var body = <JS.Statement>[];
     for (var param in parameters.parameters) {
       var jsParam = _visit(param.identifier);
 
       if (param.kind == ParameterKind.NAMED) {
         // Parameters will be passed using their real names, not the (possibly
         // renamed) local variable.
         var paramName = js.string(param.identifier.name, "'");
-        
+
         // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming
         // (either test if `obj.prop !== void 0`, or use JSCompiler_renameProperty).
         body.add(js.statement('let # = # && # in # ? #.# : #;', [
           jsParam,
           _namedArgTemp,
           paramName,
           _namedArgTemp,
           _namedArgTemp,
           paramName,
           _defaultParamValue(param),
@@ skipping 51 matching lines @@
       // Rewrite the function to include the return.
       fn = new JS.Fun(fn.params, new JS.Block([body, returnValue]))
         ..sourceInformation = fn.sourceInformation;
     }
 
     return annotate(
         new JS.Method(_elementMemberName(node.element), fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
-            node.element);
+        node.element);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
 
     if (node.isGetter || node.isSetter) {
       // Add these later so we can use getter/setter syntax.
@@ skipping 763 matching lines @@
       // anything they depend on first.
 
       if (isPublic(fieldName)) _addExport(fieldName);
       return annotateVariable(
           js.statement('let # = #;', [new JS.Identifier(fieldName), jsInit]),
           field.element);
     }
 
     if (eagerInit && !JS.invalidStaticFieldName(fieldName)) {
       return annotateVariable(
-          js.statement('# = #;', [_visit(field.name), jsInit]),
-          field.element);
+          js.statement('# = #;', [_visit(field.name), jsInit]), field.element);
     }
 
     var body = <JS.Statement>[];
     if (_lazyFields.isNotEmpty) {
       var existingTarget = _lazyFields[0].element.enclosingElement;
       if (existingTarget != element.enclosingElement) {
         _flushLazyFields(body);
       }
     }
 
@@ skipping 41 matching lines @@
     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]);
   }
 
-  PropertyAccessorElement _findAccessor(VariableElement element, {bool getter}) {
-    var parent = element.enclosingElement; 
+  PropertyAccessorElement _findAccessor(VariableElement element,
+      {bool getter}) {
+    var parent = element.enclosingElement;
     if (parent is ClassElement) {
-      return getter ? parent.getGetter(element.name) : parent.getSetter(element.name);
+      return getter
+          ? parent.getGetter(element.name)
+          : parent.getSetter(element.name);
     }
     return null;
   }
 
   void _flushLibraryProperties(List<JS.Statement> body) {
     if (_properties.isEmpty) return;
     body.add(js.statement('dart.copyProperties(#, { # });',
         [_exportsVar, _properties.map(_emitTopLevelProperty)]));
     _properties.clear();
   }
@@ skipping 1095 matching lines @@
   DartType getStaticType(Expression e) => rules.getStaticType(e);
 
   @override
   String getQualifiedName(TypeDefiningElement type) {
     JS.TemporaryId id = _imports[type.library];
     return id == null ? type.name : '${id.name}.${type.name}';
   }
 
   JS.Node annotate(JS.Node method, ExecutableElement e) =>
       options.closure && e != null
-          ? method.withClosureAnnotation(closureAnnotationFor(e, _namedArgTemp.name))
+          ? method.withClosureAnnotation(
+              closureAnnotationFor(e, _namedArgTemp.name))
           : method;
 
   JS.Node annotateDefaultConstructor(JS.Node method, ClassElement e) =>
       options.closure && e != null
-          ? method.withClosureAnnotation(closureAnnotationForDefaultConstructor(e))
+          ? method
+              .withClosureAnnotation(closureAnnotationForDefaultConstructor(e))
           : method;
 
   JS.Node annotateVariable(JS.Node node, VariableElement e) =>
       options.closure && e != null
           ? node.withClosureAnnotation(closureAnnotationForVariable(e))
           : node;
 
   JS.Node annotateTypeDef(JS.Node node, FunctionTypeAliasElement e) =>
       options.closure && e != null
           ? node.withClosureAnnotation(closureAnnotationForTypeDef(e))
@@ skipping 62 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);
 }