support basic identifiers in constructors

lib/transformer.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.transformer;
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:barback/barback.dart';
@@ skipping 60 matching lines @@
   bool isPrimary(AssetId id) => _entryPoint == id.path;
 
   Future apply(Transform transform) {
     var newEntryPointId =
         new AssetId(transform.primaryInput.id.package, _newEntryPoint);
     return transform.hasInput(newEntryPointId).then((exists) {
       if (exists) {
         transform.logger
             .error('New entry point file $newEntryPointId already exists.');
       } else {
-        return _resolvers
-            .get(transform)
-            .then((resolver) => new _BootstrapFileBuilder(resolver, transform,
-                transform.primaryInput.id, newEntryPointId).run());
+        return _resolvers.get(transform).then((resolver) {
+          new _BootstrapFileBuilder(resolver, transform,
+              transform.primaryInput.id, newEntryPointId).run();
+          resolver.release();
+        });
       }
     });
   }
 }
 
 class _BootstrapFileBuilder {
   final Resolver _resolver;
   final Transform _transform;
   AssetId _entryPoint;
   AssetId _newEntryPoint;
@@ skipping 86 matching lines @@
   }
 
   String _buildNewEntryPoint(LibraryElement entryLib) {
     var importsBuffer = new StringBuffer();
     var initializersBuffer = new StringBuffer();
     var libraryPrefixes = new Map<LibraryElement, String>();
 
     // Import the static_loader and original entry point.
     importsBuffer
         .writeln("import 'package:initialize/src/static_loader.dart';");
-    _maybeWriteImport(entryLib, libraryPrefixes, importsBuffer);
+    libraryPrefixes[entryLib] = 'i0';
 
     initializersBuffer.writeln('  initializers.addAll([');
     while (_initQueue.isNotEmpty) {
       var next = _initQueue.removeFirst();
 
-      _maybeWriteImport(next.element.library, libraryPrefixes, importsBuffer);
-      _maybeWriteImport(
-          next.annotation.element.library, libraryPrefixes, importsBuffer);
+      libraryPrefixes.putIfAbsent(
+          next.element.library, () => 'i${libraryPrefixes.length}');
+      libraryPrefixes.putIfAbsent(
+          next.annotation.element.library, () => 'i${libraryPrefixes.length}');
 
       _writeInitializer(next, libraryPrefixes, initializersBuffer);
     }
     initializersBuffer.writeln('  ]);');
 
+    libraryPrefixes
+        .forEach((lib, prefix) => _writeImport(lib, prefix, importsBuffer));
+
     // TODO(jakemac): copyright and library declaration
     return '''
 $importsBuffer
 main() {
 $initializersBuffer
   i0.main();
 }
 ''';
   }
 
-  // Writes an import to library if it doesn't exist yet if libraries.
-  _maybeWriteImport(LibraryElement library,
-      Map<LibraryElement, String> libraries, StringBuffer buffer) {
-    if (libraries.containsKey(library)) return;
-    var prefix = 'i${libraries.length}';
-    libraries[library] = prefix;
-    _writeImport(library, prefix, buffer);
-  }
-
   _writeImport(LibraryElement lib, String prefix, StringBuffer buffer) {
     AssetId id = (lib.source as dynamic).assetId;
 
     if (id.path.startsWith('lib/')) {
       var packagePath = id.path.replaceFirst('lib/', '');
       buffer.write("import 'package:${id.package}/${packagePath}'");
     } else if (id.package != _newEntryPoint.package) {
       _logger.error("Can't import `${id}` from `${_newEntryPoint}`");
     } else if (path.url.split(id.path)[0] ==
         path.url.split(_newEntryPoint.path)[0]) {
@@ skipping 36 matching lines @@
             'and top level methods. Found $node.');
       }
       final annotation =
           astMeta.firstWhere((m) => m.elementAnnotation == data.annotation);
       final clazz = annotation.name;
       final constructor = annotation.constructorName == null
           ? ''
           : '.${annotation.constructorName}';
       // TODO(jakemac): Support more than raw values here
       // https://github.com/dart-lang/static_init/issues/5
-      final args = annotation.arguments;
+      final args = _buildArgsString(annotation.arguments, libraryPrefixes);
       buffer.write('''
     new InitEntry(const $metaPrefix.${clazz}$constructor$args, $elementString),
 ''');
     } else if (annotationElement is PropertyAccessorElement) {
       buffer.write('''
     new InitEntry($metaPrefix.${annotationElement.name}, $elementString),
 ''');
+    } else {
+      _logger.error('Unsupported annotation type. Only constructors and '
+          'properties are supported as initializers.');
     }
   }
 
+  String _buildArgsString(
+      ArgumentList args, Map<LibraryElement, String> libraryPrefixes) {
+    var buffer = new StringBuffer();
+    buffer.write('(');
+    var first = true;
+    for (var arg in args.arguments) {
+      if (!first) buffer.write(', ');
+      first = false;
+
+      Expression expression;
+      if (arg is NamedExpression) {
+        buffer.write('${arg.name.label.name}: ');
+        expression = arg.expression;
+      } else {
+        expression = arg;
+      }
+
+      buffer.write(_expressionString(expression, libraryPrefixes));
+    }
+    buffer.write(')');
+    return buffer.toString();
+  }
+
+  String _expressionString(Expression expression,
+                           Map<LibraryElement, String> 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'");
+    } else if (expression is BooleanLiteral ||
+        expression is DoubleLiteral ||
+        expression is IntegerLiteral) {
+      buffer.write((expression as dynamic).value.toString());

[Siggi Cherem (dart-lang), 2015/01/23 17:56:28]

nit: use the shorter '${e}' instead of e.toString() :-)

[jakemac, 2015/01/23 21:34:38]

Done.

+    } else if (expression is NullLiteral) {

[Siggi Cherem (dart-lang), 2015/01/23 17:56:28]

you can include this with boolean, double and int, in dart null.toString is
'null'

[jakemac, 2015/01/23 21:34:38]

Done, I originally had it because of the .value access above (NullLiteral
doesn't have a value) but it looks like I didn't need to access .value at all,
the regular toString of these literals just does the right thing.

[Siggi Cherem (dart-lang), 2015/01/23 21:44:23]

Ah, good point, I had not seen the .value. Glad it worked though :)

+      buffer.write('null');
+    } else if (expression is ListLiteral) {
+      var constKeyword = expression.constKeyword;
+      if (constKeyword != null) buffer.write('$constKeyword ');

[Siggi Cherem (dart-lang), 2015/01/23 17:56:28]

it should always be const. If it's not const, the analyzer will give an error
somewhere, we could also complain here if we want. I think it should be fine to
replace these two lines with just:

  buffer.write('const ');

[jakemac, 2015/01/23 21:34:38]

Done.

+      buffer.write('[');
+      var first = true;
+      for (Expression listExpression in expression.elements) {
+        if (!first) buffer.write(', ');
+        first = false;
+        buffer.write(_expressionString(listExpression, libraryPrefixes));
+      }
+      buffer.write(']');
+    } else if (expression is MapLiteral) {
+      var constKeyword = expression.constKeyword;
+      if (constKeyword != null) buffer.write('$constKeyword ');

[Siggi Cherem (dart-lang), 2015/01/23 17:56:28]

same here

[jakemac, 2015/01/23 21:34:38]

Done.

+      buffer.write('{');
+      var first = true;
+      for (MapLiteralEntry entry in expression.entries) {
+        if (!first) buffer.write(', ');
+        first = false;
+        buffer.write(_expressionString(entry.key, libraryPrefixes));
+        buffer.write(': ');
+        buffer.write(_expressionString(entry.value, libraryPrefixes));
+      }
+      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.');
+      }
+      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 {
+      _logger.error('Only literals and identifiers are allowed for initializer '
+          'expressions, found $expression.');
+    }
+    return buffer.toString();
+  }
+
   bool _isInitializer(InterfaceType type) {
     if (type == null) return false;
     if (type.element.type == _initializer.type) return true;
     if (_isInitializer(type.superclass)) return true;
     for (var interface in type.interfaces) {
       if (_isInitializer(interface)) return true;
     }
     return false;
   }
 
@@ skipping 73 matching lines @@
     })).map((import) => import.importedLibrary);
 }
 
 // Element/ElementAnnotation pair.
 class _InitializerData {
   final Element element;
   final ElementAnnotation annotation;
 
   _InitializerData(this.element, this.annotation);
 }