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 64 matching lines @@
 /// Information about reflectability for a given class.
 class ClassDomain {
   final ClassElement classElement;
   final Iterable<MethodElement> declaredMethods;
   final Iterable<PropertyAccessorElement> declaredAccessors;
   final Iterable<ConstructorElement> constructors;
 
   ReflectorDomain reflectorDomain;
 
   Iterable<MethodElement> get invokableMethods => instanceMembers
-    .where((ExecutableElement element) => element is MethodElement);
+      .where((ExecutableElement element) => element is MethodElement);
 
   String staticClassMirrorName;
   String staticInstanceMirrorName;
   String get baseName => classElement.name;
 
-  ClassDomain(this.classElement, this.declaredMethods,
-      this.declaredAccessors, this.constructors, this.reflectorDomain);
+  ClassDomain(this.classElement, this.declaredMethods, this.declaredAccessors,
+      this.constructors, this.reflectorDomain);
 
   Iterable<ExecutableElement> get declarations {
     // TODO(sigurdm): Include fields.
     // TODO(sigurdm): Include type variables (if we decide to keep them).
     return [declaredMethods, declaredAccessors, constructors].expand((x) => x);
   }
 
   /// Finds all instance members by going through the class hierarchy.
   Iterable<ExecutableElement> get instanceMembers {
-
     Map<String, ExecutableElement> helper(ClassElement classElement) {
       if (reflectorDomain._instanceMemberCache[classElement] != null) {
         return reflectorDomain._instanceMemberCache[classElement];
       }
       Map<String, ExecutableElement> result =
           new Map<String, ExecutableElement>();
 
       void addIfCapable(ExecutableElement member) {
         if (reflectorDomain.capabilities.supportsInstanceInvoke(member.name)) {
           result[member.name] = member;
@@ skipping 83 matching lines @@
           '${_declarationDescriptor(declaration)}, this)';
     });
     return "{${declarationParts.join(", ")}}";
   }
 
   /// Returns a String with the textual representation of the
   /// instanceMembers-map.
   String get instanceMembersString {
     // TODO(sigurdm): Find out how to set the right owner.
     Iterable<String> instanceMemberParts = instanceMembers.map(
-            (ExecutableElement declaration) {
-          return '"${nameOfDeclaration(declaration)}": '
+        (ExecutableElement declaration) {
+      return '"${nameOfDeclaration(declaration)}": '
           'new MethodMirrorImpl("${declaration.name}", '
           '${_declarationDescriptor(declaration)}, null)';
-        });
+    });
     return "{${instanceMemberParts.join(", ")}}";
   }
 
+  String get newInstanceString {

[eernst, 2015/06/18 13:35:41]

I've been looking for a general hint (some DartDoc comment, presumably) about
the general idea behind xString for various x. Is it a factorization that
includes both (1) obtaining various data from the Element model about the shape
of the target program, and also (2) producing a string that represents the same
semantics in generated code? I guess these two elements were often inlined in
code for larger tasks, so the factorization looks fine in itself.

On the other hand, it does look somewhat "impure" that the data extraction and
the string construction are packaged together. Would it be a meaningless further
factorization to express them separately? (I realize that it may well be a bit
inconvenient, because the two are quite intertwined.)

Also, it is tempting to think that some of the string construction tasks can be
obtained by using some 'prettyprint' feature from the Element world, if there is
such a thing. (Copying an excerpt from the original source would surely not be a
safe bet, because that might be formatted in ways that make no sense when moved
into an entirely different context).

Is there a natural place where we can add a few lines of text explaining the
situation?

[sigurdm, 2015/06/19 07:50:54]

Your intuition is right. There is no exact defined semantics of the -String
methods, but something along those lines.
Because I am going to refactor how we represent the data - I will leave this
uncommented for now, and try to document better how the new approach works.

+    // 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;
+      int optionalCount = type.optionalParameterTypes.length;
+      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";
+        return "${name(i + positionalCount)}$defaultValueString";
+      }).join(", ");

[eernst, 2015/06/18 13:35:41]

    Maybe
  we can sell this style of
  indentation to the rest of the
world

rather
  than this boring
one?

[sigurdm, 2015/06/19 07:50:54]

?

+      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 624 matching lines @@
     insert("""
   Iterable<${prefix}ClassMirror> get annotatedClasses {
     return [${annotatedClassesStrings.join(", ")}];
   }""");
   }
 
   /// Returns the source code for the reflection free subclass of
   /// [ClassMirror] which is specialized for a `reflectedType` which
   /// is the class modeled by [classElement].
   String _staticClassMirrorCode(ClassDomain classDomain) {
+
     String declarationsString = classDomain.declarationsString;
     String instanceMembersString = classDomain.instanceMembersString;
+    List<String> memberStrings = new List<String>();
+    if (!classDomain.classElement.isAbstract) {
+      memberStrings.add(classDomain.newInstanceString);
+    }

[eernst, 2015/06/18 13:35:41]

This one would be new, but still related to the treatment of `abstract`
features.

But it's not obvious to me that `isAbstract` justifies omission.


An element.dart `ClassElement` represents a class C, so `newInstanceString`
would describe constructors producing instances of C, and this would make them
part of the "members strings" of the static mirror class under construction.

We should be able to obtain a class mirror for an abstract class, because users
can use reflectType to directly request such a mirror.

It is possible to invoke a constructor for an abstract class, but it's a runtime
error, Spec. 1.9, Sect. 16.12.1, so presumably it's OK to leave it as
'NoSuchCapability' rather than reproducing the original runtime error (didn't
check which one that is).

On the other hand, it would make sense to include constructors in abstract
classes for informational purposes (when using reflection to "browse the code"),
and such constructors are of course useful in general because they can factor
out common pieces of code which would otherwise occur in many duplicates in the
constructors of concrete subclasses.

Do we have a place where the constructors in abstract classes are available for
"browsing"? Would be ClassMirror.declarations (checking: yes, that's
_everything_, all regular (instance or static) methods, getters, setters,
fields, constructors, and even type variables).

OK: So we should actually drop constructors of abstract classes here.

[sigurdm, 2015/06/19 07:50:54]

You cannot invoke abstract cosntructors directly, therefore we do not generate a
custom newInstance method.

     return """
 class ${classDomain.staticClassMirrorName} extends ClassMirrorUnimpl {
   final String simpleName = "${classDomain.classElement.name}";
 
   Map<String, MethodMirror> _declarationsCache;
 
   Map<String, MethodMirror> get declarations {
     if (_declarationsCache == null) {
       _declarationsCache = new UnmodifiableMapView($declarationsString);
     }
     return _declarationsCache;
   }
 
   Map<String, MethodMirror> _instanceMembersCache;
 
   Map<String, MethodMirror> get instanceMembers {
     if (_instanceMembersCache == null) {
       _instanceMembersCache = new UnmodifiableMapView($instanceMembersString);
     }
     return _instanceMembersCache;
   }
 
+  ${memberStrings.join("\n\n  ")}
 }
 """;
   }
 
   /// Perform some very simple steps that are consistent with Dart
   /// semantics for the evaluation of constant expressions, such that
   /// information about the value of a given `const` variable can be
   /// obtained.  It is intended to help recognizing values of type
   /// [ReflectCapability], so we only cover cases needed for that.
   /// In particular, we cover lookup (e.g., with `const x = e` we can
@@ skipping 77 matching lines @@
       case "InvokeMembersWithMetadataCapability":
         throw new UnimplementedError("$classElement not yet supported");
       case "InvokeInstanceMembersUpToSuperCapability":
         throw new UnimplementedError("$classElement not yet supported");
       case "_InvokeStaticMembersCapability":
         return invokeStaticMembersCapability;
       case "InvokeInstanceMemberCapability":
         throw new UnimplementedError("$classElement not yet supported");
       case "InvokeStaticMemberCapability":
         throw new UnimplementedError("$classElement not yet supported");
+      case "_InvokeConstructorsCapability":
+        return invokeConstructorsCapability;

[eernst, 2015/06/18 13:35:41]

I believe this is the same thing as the capability
NewInstanceCapability([RegExp]) and the instance newInstanceCapability. So we
need to eliminate the one that we end up not using.

(PS: `newInstanceCapability` was named this way because it controls the
availability of `newInstance` on mirrors, just like `metadataCapability`
controls the avail. of `metadata`, etc., so `invokeConstructor` may be more
intuitive, but `newInstance` is probably more consistent.)

[sigurdm, 2015/06/19 07:50:54]

This was based on the previous incantation of capabilities. Should be updated in
the rebase.

       default:
         throw new UnimplementedError("Unexpected capability $classElement");
     }
   }
 
   /// Returns the list of Capabilities given given as a superinitializer by the
   /// reflector.
   Capabilities _capabilitiesOf(
       LibraryElement capabilityLibrary, ClassElement reflector) {
     List<ConstructorElement> constructors = reflector.constructors;
@@ skipping 45 matching lines @@
     ListLiteral listLiteral = arguments[0];
     NodeList<Expression> expressions = listLiteral.elements;
     return new Capabilities(expressions.map(capabilityOfExpression).toList());
   }
 
   /// Returns a [String] containing generated code for the `invoke`
   /// method of the static `InstanceMirror` class corresponding to
   /// the given [classElement], bounded by the permissions given
   /// in [capabilities].
   String _staticInstanceMirrorInvokeCode(ClassDomain classDomain) {
-
     String tearOff(MethodElement methodElement) {
       if (!methodElement.isOperator) return "reflectee.${methodElement.name}";
       if (methodElement.name == "[]=") return "(x, v) => reflectee[x] = v";
       if (methodElement.name == "[]") return "(x) => reflectee[x]";
       return "(x) => reflectee ${methodElement.name} x";
     }
 
-
     List<String> methodCases = new List<String>();
     for (MethodElement methodElement in classDomain.invokableMethods) {
       methodCases.add("if (memberName == '${methodElement.name}') {"
           "method = ${tearOff(methodElement)}; }");
     }
     // TODO(eernst, sigurdm): Create an instance of [Invocation] in user code.
     methodCases.add("if (instanceMethodFilter.hasMatch(memberName)) {"
         "throw new UnimplementedError('Should call noSuchMethod'); }");
     methodCases.add("{ throw new NoSuchInvokeCapabilityError("
         "reflectee, memberName, positionalArguments, namedArguments); }");
@@ skipping 259 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);
 }