Update linked_list, queue, splay_tree

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 1118 matching lines @@
   void _emitClassSignature(
       List<MethodDeclaration> methods,
       ClassElement classElem,
       List<ConstructorDeclaration> ctors,
       List<ExecutableElement> extensions,
       JS.Expression className,
       List<JS.Statement> body) {
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         className,
-        new JS.ArrayInitializer(new List<JS.Expression>.from(
-            classElem.interfaces.map(_emitType)))
+        new JS.ArrayInitializer(
+            new List<JS.Expression>.from(classElem.interfaces.map(_emitType)))
       ]));
     }
 
     var tStatics = <JS.Property>[];
     var tMethods = <JS.Property>[];
     var sNames = <JS.Expression>[];
     for (MethodDeclaration node in methods) {
       if (!(node.isSetter || node.isGetter || node.isAbstract)) {
         var name = node.name.name;
         var element = node.element;
@@ skipping 450 matching lines @@
         } else if (param.kind == ParameterKind.POSITIONAL) {
           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 && _hasUnsoundTypeParameter(paramType)) {
-        body.add(js
-            .statement('dart.as(#, #);', [jsParam, _emitType(paramType)]));
+        body.add(
+            js.statement('dart.as(#, #);', [jsParam, _emitType(paramType)]));
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
   bool _isUnsoundTypeParameter(DartType t) =>
       t is TypeParameterType && t.element.enclosingElement is ClassElement;
 
   bool _hasUnsoundTypeParameter(DartType t) =>
       _isUnsoundTypeParameter(t) ||
@@ skipping 638 matching lines @@
     }
 
     if (type == subClass?.type) {
       return className;
     }
 
     if (type is ParameterizedType) {
       var args = type.typeArguments;
       Iterable jsArgs = null;
       if (args.any((a) => !a.isDynamic)) {
-        jsArgs = args.map(
-            (x) => _emitType(x, subClass: subClass, className: className));
+        jsArgs = args
+            .map((x) => _emitType(x, subClass: subClass, className: className));
       } else if (lowerGeneric) {
         jsArgs = [];
       }
       if (jsArgs != null) {
         var genericName = _emitTopLevelName(element, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
     return _emitTopLevelName(element);
@@ skipping 259 matching lines @@
   }
 
   /// If `g` is a generic function type, and `f` is an instantiation of it,
   /// then this will return the type arguments to apply, otherwise null.
   List<JS.Expression> _emitFunctionTypeArguments(DartType g, DartType f,
       [TypeArgumentList typeArgs]) {
     if (g is FunctionType &&
         g.typeFormals.isNotEmpty &&
         f is FunctionType &&
         f.typeFormals.isEmpty) {
-      return _recoverTypeArguments(g, f)
-          .map(_emitType)
-          .toList(growable: false);
+      return _recoverTypeArguments(g, f).map(_emitType).toList(growable: false);
     } else if (typeArgs != null) {
       // Dynamic calls may have type arguments, even though the function types
       // are not known.
       // TODO(jmesserly): seems to be mostly broken in Analyzer at the moment:
       // https://github.com/dart-lang/sdk/issues/26368
       return typeArgs.arguments.map(visitTypeName).toList(growable: false);
     }
     return null;
   }
 
@@ skipping 1370 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),
-          _emitType(clause.exceptionType.type),
-        ]),
+        js.call('dart.is(#, #)',
+            [_visit(_catchParameter), _emitType(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);
   }
@@ skipping 448 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';