Roll to pickup pool changes

packages/initialize/lib/build/initializer_plugin.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 initialize.build.initializer_plugin;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/resolver.dart';
@@ skipping 217 matching lines @@
       buffer.write('}');
     } else if (expression is Identifier) {
       var element = expression.bestElement;
       if (element == null) {
         logger.error('Unable to get `bestElement` for expression: $expression');
       } else if (!element.isPublic) {
         // Inline the evaluated value of private identifiers.
         buffer.write(_evaluateExpression(expression, pluginData));
       } else {
         libraryPrefixes.putIfAbsent(
-          element.library, () => 'i${libraryPrefixes.length}');
+            element.library, () => 'i${libraryPrefixes.length}');
 
         buffer.write('${libraryPrefixes[element.library]}.');
         if (element is ClassElement) {
           buffer.write(element.name);
         } else if (element is PropertyAccessorElement) {
           var variable = element.variable;
           if (variable is FieldElement) {
             buffer.write('${variable.enclosingElement.name}.');
           }
           buffer.write('${variable.name}');
         } else {
           logger.error('Unsupported argument to initializer constructor.');
         }
       }
     } else if (expression is PropertyAccess) {
       buffer.write(buildExpression(expression.target, pluginData));
       buffer.write('.${expression.propertyName}');
     } else if (expression is InstanceCreationExpression) {
       logger.error('Unsupported expression in initializer, found $expression. '
           'Instance creation expressions are not supported (yet). Instead, '
           'please assign it to a const variable and use that instead.');
     } else {
       buffer.write(_evaluateExpression(expression, pluginData));
     }
     return buffer.toString();
   }
 
-  _evaluateExpression(
-      Expression expression, InitializerPluginData pluginData) {
+  _evaluateExpression(Expression expression, InitializerPluginData pluginData) {
     var logger = pluginData.logger;
     var result = pluginData.resolver.evaluateConstant(
         pluginData.initializer.targetElement.library, expression);
     if (!result.isValid) {
       logger.error('Invalid expression in initializer, found $expression. '
           'And got the following errors: ${result.errors}.');
       return null;
     }
 
     var value = _getValue(result.value);
@@ skipping 17 matching lines @@
   }
 
   // Gets an actual value for a [DartObject].
   _getValue(DartObject object) {
     if (object == null) return null;
     var value = object.toBoolValue() ??
         object.toDoubleValue() ??
         object.toIntValue() ??
         object.toStringValue();
     if (value == null) {
-      value = object.toListValue();
-      if (value != null) {
-        return value.map((DartObject element) => _getValue(element)).toList();
+      List list = object.toListValue();
+      if (list != null) {
+        return list.map((DartObject element) => _getValue(element)).toList();
       }
       Map<DartObject, DartObject> map = object.toMapValue();
       if (map != null) {
         Map result = {};
         map.forEach((DartObject key, DartObject value) {
           dynamic mappedKey = _getValue(key);
           if (mappedKey != null) {
             result[mappedKey] = _getValue(value);
           }
         });
         return result;
       }
     }
     return value;
   }
 }