Update charted to 0.4.8 and roll

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/src/generated/ast.dart';
-import 'package:analyzer/src/generated/element.dart';
+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';
 import 'package:initialize/transformer.dart';
 import 'package:path/path.dart' as path;
 
 /// A plug which allows an initializer to write out an [InitEntry] given some
 /// [InitializerData] from an annotation that was found.
 abstract class InitializerPlugin {
   /// Whether or not this plugin should be applied to an [Initializer] given
   /// some [InitializerData]. If [true] is returned then this plugin will take
@@ skipping 33 matching lines @@
   String apply(InitializerPluginData pluginData) {
     var target = buildTarget(pluginData);
     var meta = buildMeta(pluginData);
     return 'new InitEntry($meta, $target)';
   }
 
   /// Builds a [String] representing the meta of an [InitEntry] given an
   /// [ElementAnnotation] that was found.
   String buildMeta(InitializerPluginData pluginData) {
     var logger = pluginData.logger;
-    var element = pluginData.initializer.targetElement;
     var elementAnnotation = pluginData.initializer.annotationElement;
     var elementAnnotationElement = elementAnnotation.element;
-    var libraryPrefixes = pluginData.libraryPrefixes;
     if (elementAnnotationElement is ConstructorElement) {
       return buildConstructorMeta(elementAnnotation, pluginData);
     } else if (elementAnnotationElement is PropertyAccessorElement) {
       return buildPropertyMeta(elementAnnotation, pluginData);
     } else {
       logger.error('Unsupported annotation type. Only constructors and '
           'properties are supported as initializers.');
     }
     return null;
   }
@@ skipping 182 matching lines @@
     } 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 = result.value.value;
+
+    var value = _getValue(result.value);
+
     if (value == null) {
       logger.error('Unsupported expression in initializer, found '
           '$expression. Please file a bug at '
           'https://github.com/dart-lang/initialize/issues');
-      return null;
     }
 
     if (value is String) value = _stringValue(value);
+
     return value;
   }
 
   // Returns an expression for a string value. Wraps it in single quotes and
   // escapes existing single quotes and escapes.
   _stringValue(String value) {
     value = value.replaceAll(r'\', r'\\').replaceAll(r"'", r"\'");
     return "'$value'";
   }
+
+  // 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();
+      }
+      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;
+  }
 }