support more types of expressions

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:barback/barback.dart';
 import 'package:code_transformers/resolver.dart';
 import 'package:initialize/transformer.dart';
@@ skipping 74 matching lines @@
     var annotation = pluginData.initializer.annotationNode;
     if (annotation == null) {
       logger.error(
           'Initializer annotations are only supported on libraries, classes, '
           'and top level methods. Found $node.');
     }
     var clazz = annotation.name;
     var constructor = annotation.constructorName == null
         ? ''
         : '.${annotation.constructorName}';
-    // TODO(jakemac): Support more than raw values here
-    // https://github.com/dart-lang/static_init/issues/5
     var args = buildArgumentList(annotation.arguments, pluginData);
     return 'const $metaPrefix.${clazz}$constructor$args';
   }
 
   /// Builds a [String] representing the meta of an [InitEntry] given an
   /// [ElementAnnotation] whose element was a [PropertyAccessorElement].
   String buildPropertyMeta(
       ElementAnnotation annotation, InitializerPluginData pluginData) {
     var metaPrefix = pluginData.libraryPrefixes[annotation.element.library];
     return '$metaPrefix.${annotation.element.name}';
@@ skipping 88 matching lines @@
     return buffer.toString();
   }
 
   /// Builds a [String] representing [expression] taking into account the
   /// [libraryPrefixes] from [pluginData].
   String buildExpression(
       Expression expression, InitializerPluginData pluginData) {
     var logger = pluginData.logger;
     var libraryPrefixes = pluginData.libraryPrefixes;
     var buffer = new StringBuffer();
-    if (expression is StringLiteral) {
-      var value = expression.stringValue;
-      if (value == null) {
-        logger.error('Only const strings are allowed in initializer '
-            'expressions, found $expression');
-      }
-      value = value.replaceAll(r'\', r'\\').replaceAll(r"'", r"\'");
-      buffer.write("'$value'");
+    if (expression is StringLiteral && expression.stringValue != null) {
+      buffer.write(_stringValue(expression.stringValue));
     } else if (expression is BooleanLiteral ||
         expression is DoubleLiteral ||
         expression is IntegerLiteral ||
         expression is NullLiteral) {
       buffer.write('${expression}');
     } else if (expression is ListLiteral) {
       buffer.write('const [');
       var first = true;
       for (Expression listExpression in expression.elements) {
         if (!first) buffer.write(', ');
         first = false;
         buffer.write(buildExpression(listExpression, pluginData));
       }
       buffer.write(']');
     } else if (expression is MapLiteral) {
       buffer.write('const {');
       var first = true;
       for (MapLiteralEntry entry in expression.entries) {
         if (!first) buffer.write(', ');
         first = false;
         buffer.write(buildExpression(entry.key, pluginData));
         buffer.write(': ');
         buffer.write(buildExpression(entry.value, pluginData));
       }
       buffer.write('}');
     } else if (expression is Identifier) {
       var element = expression.bestElement;
       if (element == null || !element.isPublic) {
         logger.error('Private constants are not supported in intializer '
-            'constructors, found $element.');
+        'constructors, found $element.');
       }
       libraryPrefixes.putIfAbsent(
           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 {
-      logger.error('Only literals and identifiers are allowed for initializer '
-          'expressions, found $expression.');
+      // Try to evaluate the constant and use that.
+      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}.');
+      }
+      var value = result.value.value;
+      if (value == null) {
+        logger.error('Unsupported expression in initializer, found '
+            '$expression. Please file a bug at '
+            'https://github.com/dart-lang/initialize/issues');
+      }
+
+      if (value is String) value = _stringValue(value);
+      buffer.write(value);
     }
     return buffer.toString();
   }
+
+  // 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'";
+  }
 }