Implement newInstance in the transformer.

reflectable/lib/src/transformer_implementation.dart

 // (c) 2015, the Dart Team. All rights reserved. Use of this
 // source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
 library reflectable.src.transformer_implementation;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math' show max;
@@ skipping 221 matching lines @@
       if (elementAnnotation.element is ConstructorElement) {
         // If this is a constructor call, add the otherwise implicit 'const'.
         metadataParts.add("const $source");
       } else {
         metadataParts.add(source);
       }
     }
     return "new UnmodifiableListView([${metadataParts.join(", ")}])";
   }
 
+  String get newInstanceString {
+    List<String> constructorLines = new List<String>();
+
+    String name(int i) {
+      String alphabet = "abcdefghijklmnopqrstuvwxyz";
+      int alphabetLength = alphabet.length;
+      if (i < alphabetLength) {
+        return "_${alphabet[i]}";
+      }
+      return "_${alphabet[i % alphabetLength]}${i ~/ alphabetLength}";
+    }
+    for (ConstructorElement constructor in constructors) {
+      FunctionType type = constructor.type;
+      int requiredPositionalCount = type.normalParameterTypes.length;
+      int optionalPositionalCount = type.optionalParameterTypes.length;
+      List<String> argumentNames = type.namedParameterTypes.keys.toList();
+      String positionals = new Iterable.generate(
+          requiredPositionalCount, (int i) => name(i)).join(", ");
+      String optionalsWithDefaults = new Iterable.generate(
+          optionalPositionalCount, (int i) {
+        String defaultValueCode = constructor.parameters[
+            requiredPositionalCount + i].defaultValueCode;
+        String defaultValueString =
+            defaultValueCode == null ? "" : " = $defaultValueCode";
+        return "${name(i + requiredPositionalCount)}$defaultValueString";
+      }).join(", ");
+      String namedWithDefaults = new Iterable.generate(argumentNames.length,
+          (int i) {
+        // TODO(eernst, sigurdm, #8): Recreate the default values faithfully.
+        // TODO(eernst, sigurdm, #8): Until that is done, recognize unhandled
+        // cases, and emit error/warning.
+        String defaultValueCode = constructor.parameters[
+            requiredPositionalCount + i].defaultValueCode;
+        String defaultValueString =
+            defaultValueCode == null ? "" : ": $defaultValueCode";
+        return "${argumentNames[i]}$defaultValueString";
+      }).join(", ");
+
+      String optionalArguments = new Iterable.generate(optionalPositionalCount,
+          (int i) => name(i + requiredPositionalCount)).join(", ");
+      String namedArguments =
+          argumentNames.map((String name) => "$name: $name").join(", ");
+      List<String> parameterParts = new List<String>();
+      List<String> argumentParts = new List<String>();
+      if (requiredPositionalCount != 0) {
+        parameterParts.add(positionals);
+        argumentParts.add(positionals);
+      }
+      if (optionalPositionalCount != 0) {
+        parameterParts.add("[$optionalsWithDefaults]");
+        argumentParts.add(optionalArguments);
+      }
+      if (argumentNames.isNotEmpty) {
+        parameterParts.add("{${namedWithDefaults}}");
+        argumentParts.add(namedArguments);
+      }
+      constructorLines.add('case "${constructor.name}": '
+          'c = (${parameterParts.join(', ')}) => '
+          'new ${nameOfDeclaration(constructor)}'
+          '(${argumentParts.join(", ")});');
+      constructorLines.add('  break;');
+    }
+    return """newInstance(String constructorName, List positionalArguments,
+      [Map<Symbol, dynamic> namedArguments]) {
+    Function c;
+    switch (constructorName) {
+      ${constructorLines.join("\n      ")}
+      default: throw new NoSuchInvokeCapabilityError(${classElement.name},
+          constructorName, positionalArguments, namedArguments);
+    }
+    return Function.apply(c, positionalArguments, namedArguments);
+  }""";
+  }
+
   void computeNames(Namer namer) {
     staticClassMirrorName = namer.freshName("Static_${baseName}_ClassMirror");
     staticInstanceMirrorName =
         namer.freshName("Static_${baseName}_InstanceMirror");
   }
 }
 
 /// A wrapper around a list of Capabilities.
 /// Supports queries about the methods supported by the set of capabilities.
 class Capabilities {
@@ skipping 651 matching lines @@
   Map<String, MethodMirror> get instanceMembers {
     if (_instanceMembersCache == null) {
       _instanceMembersCache = new UnmodifiableMapView($instanceMembersString);
     }
     return _instanceMembersCache;
   }""");
     if (classDomain.reflectorDomain.capabilities.supportsMetadata) {
       implementedMembers
           .add("List<Object> metadata = ${classDomain.metadataString};");
     }
+    if (!classDomain.classElement.isAbstract) {
+      implementedMembers.add(classDomain.newInstanceString);
+    }
 
     return """
 class ${classDomain.staticClassMirrorName} extends ClassMirrorUnimpl {
   ${implementedMembers.join("\n\n  ")}
 }
 """;
   }
 
   /// Perform some very simple steps that are consistent with Dart
   /// semantics for the evaluation of constant expressions, such that
@@ skipping 559 matching lines @@
   TransformLogger get logger => _aggregateTransform.logger;
   Future<Asset> getInput(AssetId id) => _aggregateTransform.getInput(id);
   Future<String> readInputAsString(AssetId id, {Encoding encoding}) {
     return _aggregateTransform.readInputAsString(id, encoding: encoding);
   }
   Stream<List<int>> readInput(AssetId id) => _aggregateTransform.readInput(id);
   Future<bool> hasInput(AssetId id) => _aggregateTransform.hasInput(id);
   void addOutput(Asset output) => _aggregateTransform.addOutput(output);
   void consumePrimary() => _aggregateTransform.consumePrimary(primaryInput.id);
 }