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 {
+    // TODO(eernst, sigurdm, #8): Recreate the default values faithfully.
+    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 positionalCount = type.normalParameterTypes.length;

[eernst, 2015/06/19 09:22:21]

I suspect that `normalParameterTypes` delivers information about the required
positional parameters (which is the phrase used by the spec), so maybe we should
use that terminology in order to disambiguate; maybe it's worth paying the
verbosity cost of something like `requiredPositionalCount` to make that
explicit?

[sigurdm, 2015/06/19 10:52:00]

Done.

+      int optionalCount = type.optionalParameterTypes.length;

[eernst, 2015/06/19 09:22:21]

Similarly, since both named parameters and (some) positional parameters can be
optional, we might help readers of this code by using `optionalPositionalCount`
here.

[sigurdm, 2015/06/19 10:52:00]

Done.

+      List<String> argumentNames = type.namedParameterTypes.keys.toList();
+      String positionals =
+          new Iterable.generate(positionalCount, (int i) => name(i)).join(", ");
+      String optionalsWithDefaults = new Iterable.generate(optionalCount,
+          (int i) {
+        String defaultValueCode =
+            constructor.parameters[positionalCount + i].defaultValueCode;
+        String defaultValueString =
+            defaultValueCode == null ? "" : " = $defaultValueCode";

[eernst, 2015/06/19 09:22:21]

Wouldn't it be better to have the '.. faithfully' TODO right here, such that
future maintainers wouldn't have to recover the info about where the crucial
point is? Or do we have any other location where it is necessary to ensure that
a piece of code related to this issue will actually have the intended semantics
when inserted into a generated context?

Maybe one simple step we could take already would be to recognize some "typical"
literals (integers, strings, maybe also lists/maps of same); do we have
information which makes it easy to spot them? We could then throw a
`UnimplementedError` or a warning for everything else.

[sigurdm, 2015/06/19 10:52:00]

Done
Added TODO for this.

+        return "${name(i + positionalCount)}$defaultValueString";
+      }).join(", ");
+      String namedWithDefaults = new Iterable.generate(argumentNames.length,
+          (int i) {
+        String defaultValueCode =
+            constructor.parameters[positionalCount + i].defaultValueCode;
+        String defaultValueString =
+            defaultValueCode == null ? "" : ": $defaultValueCode";
+        return "${argumentNames[i]}$defaultValueString";
+      }).join(", ");
+
+      String optionalArguments = new Iterable.generate(
+          optionalCount, (int i) => name(i + positionalCount)).join(", ");
+      String namedArguments =
+          argumentNames.map((String name) => "$name: $name").join(", ");
+      List<String> parameterParts = new List<String>();
+      List<String> argumentParts = new List<String>();
+      if (positionalCount != 0) {
+        parameterParts.add(positionals);
+        argumentParts.add(positionals);
+      }
+      if (optionalCount != 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 236 matching lines @@
     // programmers who are doing something else, intentionally.  To emit a
     // diagnostic message, we must check whether there is a Reflectable
     // somewhere inside this syntactic construct, and then emit the message
     // in cases that we "consider likely to be misunderstood".
     return null;
   }
 
   Iterable<MethodElement> declaredMethods(
       ClassElement classElement, Capabilities capabilities) {
     return classElement.methods.where((MethodElement method) {
+      if (method.isAbstract) return false;

[eernst, 2015/06/19 09:22:21]

Maybe this one was reintroduced spuriously by git?

[sigurdm, 2015/06/19 10:52:00]

Done.

       if (method.isStatic) {
         // TODO(sigurdm): Ask capabilities about support.
         return true;
       } else {
         return capabilities.supportsInstanceInvoke(method.name);
       }
     });
   }
 
   Iterable<PropertyAccessorElement> declaredAccessors(
@@ skipping 395 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);
+    }

[eernst, 2015/06/19 09:22:21]

Maybe this one was reintroduced spuriously by git?

[sigurdm, 2015/06/19 10:52:00]

No this one is good. We do not want to be able to invoke constructors on
abstract classes.

 
     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);
 }