Implement `.instanceMembers`.

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 32 matching lines @@
     reflectors
         .forEach((ReflectorDomain reflector) => reflector.computeNames(namer));
   }
 }
 
 /// Information about the program parts that can be reflected by a given
 /// Reflector.
 class ReflectorDomain {
   final ClassElement reflector;
   final List<ClassDomain> annotatedClasses;
+  final Map<ClassElement, ClassDomain> classMap =
+      new Map<ClassElement, ClassDomain>();
   final Capabilities capabilities;
 
   /// Libraries that must be imported to `reflector.library`.
   final Set<LibraryElement> missingImports = new Set<LibraryElement>();
 
-  ReflectorDomain(this.reflector, this.annotatedClasses, this.capabilities);
+  ReflectorDomain(this.reflector, this.annotatedClasses, this.capabilities) {
+    for (ClassDomain classDomain in annotatedClasses) {
+      classMap[classDomain.classElement] = classDomain;
+    }
+  }
 
   void computeNames(Namer namer) {
     annotatedClasses
         .forEach((ClassDomain classDomain) => classDomain.computeNames(namer));
   }
+
+  Map<ClassElement, Map<String, ExecutableElement>> _instanceMemberCache =
+      new Map<ClassElement, Map<String, ExecutableElement>>();

[eernst, 2015/06/18 12:21:12]

Do we need an more global mechanism to guide the extent to which caching is
used? Presumably we only cache results about statically detectable entities
(that is, source code related entities like classes and methods, and const
instances like metadata). Maybe we can simply rely on large caches to be aligned
with large applications, concluding that it is never an issue?

[sigurdm, 2015/06/18 14:22:27]

I am not sure - will leave a todo.

 }
 
 /// Information about reflectability for a given class.
 class ClassDomain {
   final ClassElement classElement;
-  final Iterable<MethodElement> invokableMethods;
   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);
+
   String staticClassMirrorName;
   String staticInstanceMirrorName;
   String get baseName => classElement.name;
 
-  ClassDomain(this.classElement, this.invokableMethods, this.declaredMethods,
-      this.reflectorDomain);
+  ClassDomain(this.classElement, this.declaredMethods,
+      this.declaredAccessors, this.constructors, this.reflectorDomain);
 
   Iterable<ExecutableElement> get declarations {
-    // TODO(sigurdm): Include constructors.
     // TODO(sigurdm): Include fields.
-    // TODO(sigurdm): Include getters and setters.
     // TODO(sigurdm): Include type variables (if we decide to keep them).
-    return [declaredMethods].expand((x) => x);
+    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;
+        }
+      }
+      if (classElement.supertype != null) {
+        helper(classElement.supertype.element).forEach(
+            (String name, ExecutableElement member) {
+          addIfCapable(member);
+        });
+      }
+      for (InterfaceType mixin in classElement.mixins) {
+        helper(mixin.element).forEach((String name, ExecutableElement member) {
+          addIfCapable(member);
+        });
+      }
+      for (MethodElement member in classElement.methods) {
+        if (member.isAbstract || member.isStatic) continue;
+        addIfCapable(member);
+      }
+      for (PropertyAccessorElement member in classElement.accessors) {
+        if (member.isAbstract || member.isStatic) continue;
+        addIfCapable(member);
+      }
+      for (FieldElement field in classElement.fields) {
+        if (field.isStatic) continue;
+        if (field.isSynthetic) continue;
+        addIfCapable(field.getter);
+        if (!field.isFinal) {
+          addIfCapable(field.setter);
+        }
+      }
+      return result;
+    }
+    return helper(classElement).values;
   }
 
   /// Returns an integer encoding the kind and attributes of the given
   /// method/constructor/getter/setter.
   int _declarationDescriptor(ExecutableElement element) {
     int result;
     if (element is PropertyAccessorElement) {
       result = element.isGetter ? constants.getter : constants.setter;
     } else if (element is ConstructorElement) {
       if (element.isFactory) {
         result = constants.factoryConstructor;
-      } else if (element.redirectedConstructor != null) {
-        result = constants.redirectingConstructor;
       } else {
         result = constants.generativeConstructor;
       }
       if (element.isConst) {
         result += constants.constAttribute;
       }
+      if (element.redirectedConstructor != null) {
+        result += constants.redirectingConstructor;
+      }
     } else {
       result = constants.method;
     }
     if (element.isPrivate) {
       result += constants.privateAttribute;
     }
-    if (element.isAbstract) {
-      result += constants.abstractAttribute;
-    }
+    assert(!element.isAbstract);
     if (element.isStatic) {
       result += constants.staticAttribute;
     }
+    if (element.isSynthetic) {
+      result += constants.syntheticAttribute;
+    }
     return result;
   }
 
+  String nameOfDeclaration(ExecutableElement element) {
+    if (element is ConstructorElement) {
+      return element.name == ""
+          ? classElement.name
+          : "${classElement.name}.${element.name}";
+    }
+    return element.name;
+  }
+
   /// Returns a String with the textual representation of the declarations-map.
   String get declarationsString {
     Iterable<String> declarationParts = declarations.map(
-        (ExecutableElement instanceMember) {
-      return '"${instanceMember.name}": '
-          'new MethodMirrorImpl("${instanceMember.name}", '
-          '${_declarationDescriptor(instanceMember)}, this)';
+        (ExecutableElement declaration) {
+      return '"${nameOfDeclaration(declaration)}": '
+          'new MethodMirrorImpl("${declaration.name}", '
+          '${_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)}": '
+          'new MethodMirrorImpl("${declaration.name}", '
+          '${_declarationDescriptor(declaration)}, null)';
+        });
+    return "{${instanceMemberParts.join(", ")}}";
+  }
+
   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 235 matching lines @@
     // have no effect; it might be better to emit a diagnostic message (a
     // hint?) in order to notify the programmer that "it does not work".
     // The trade-off is that such constructs may have been written by
     // 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;
   }
 
-  /// Finds all the methods in the class and all super-classes.
-  Iterable<MethodElement> allMethods(ClassElement classElement) {
-    List<MethodElement> result = new List<MethodElement>();
-    result.addAll(classElement.methods);
-    classElement.allSupertypes.forEach((InterfaceType superType) {
-      result.addAll(superType.methods);
-    });
-    return result;
-  }
-
   Iterable<MethodElement> declaredMethods(
       ClassElement classElement, Capabilities capabilities) {
     return classElement.methods.where((MethodElement method) {
+      if (method.isAbstract) return false;
       if (method.isStatic) {
-        // TODO(sigurdm): Ask capability about support.
+        // TODO(sigurdm): Ask capabilities about support.
         return true;
       } else {
         return capabilities.supportsInstanceInvoke(method.name);
       }
     });
   }
 
-  Iterable<MethodElement> invocableInstanceMethods(
+  Iterable<PropertyAccessorElement> declaredAccessors(
       ClassElement classElement, Capabilities capabilities) {
-    return allMethods(classElement).where((MethodElement method) {
-      MethodDeclaration methodDeclaration = method.node;
-      // TODO(eernst): We currently ignore method declarations when
-      // they are operators. One issue is generation of code (which
-      // does not work if we go ahead naively).
-      if (methodDeclaration.isOperator) return false;
-      String methodName = methodDeclaration.name.name;
-      return capabilities.supportsInstanceInvoke(methodName);
+    return classElement.accessors.where((PropertyAccessorElement accessor) {
+      if (accessor.isAbstract) return false;
+      if (accessor.isStatic) {
+        // TODO(sigurdm): Ask capabilities about support.
+        return true;
+      } else {
+        return capabilities.supportsInstanceInvoke(accessor.name);
+      }
     });
   }
 
+  Iterable<ConstructorElement> declaredConstructors(
+      ClassElement classElement, Capabilities capabilities) {
+    return classElement.constructors.where((ConstructorElement constructor) {
+      // TODO(sigurdm): Ask capabilities about support.
+      return true;
+    });
+  }
+
   /// Returns a [ReflectionWorld] instantiated with all the reflectors seen by
   /// [resolver] and all classes annotated by them.
   ///
   /// TODO(eernst): Make sure it works also when other packages are being
   /// used by the target program which have already been transformed by
   /// this transformer (e.g., there would be a clash on the use of
   /// reflectableClassId with values near 1000 for more than one class).
   ReflectionWorld _computeWorld(LibraryElement reflectableLibrary) {
     ReflectionWorld world = new ReflectionWorld(reflectableLibrary);
     Map<ClassElement, ReflectorDomain> domains =
@@ skipping 29 matching lines @@
           for (ElementAnnotation metadatum in type.metadata) {
             ClassElement reflector =
                 _getReflectableAnnotation(metadatum, focusClass);
             if (reflector == null) continue;
             ReflectorDomain domain = domains.putIfAbsent(reflector, () {
               Capabilities capabilities =
                   _capabilitiesOf(capabilityLibrary, reflector);
               return new ReflectorDomain(
                   reflector, new List<ClassDomain>(), capabilities);
             });
-            List<MethodElement> instanceMethods =
-                invocableInstanceMethods(type, domain.capabilities).toList();
             List<MethodElement> declaredMethodsOfClass =
                 declaredMethods(type, domain.capabilities).toList();
-            domain.annotatedClasses.add(new ClassDomain(
-                type, instanceMethods, declaredMethodsOfClass, domain));
+            List<PropertyAccessorElement> declaredAccessorsOfClass =
+                declaredAccessors(type, domain.capabilities).toList();
+            List<ConstructorElement> declaredConstructorsOfClass =
+                declaredConstructors(type, domain.capabilities).toList();
+            domain.annotatedClasses.add(new ClassDomain(type,
+                declaredMethodsOfClass, declaredAccessorsOfClass,
+                declaredConstructorsOfClass, domain));
           }
         }
       }
     }
     domains.values.forEach(_collectMissingImports);
 
     world.reflectors.addAll(domains.values.toList());
     world.computeNames(namer);
     return world;
   }
@@ skipping 278 matching lines @@
   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;
     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;
+  }
+
 }
 """;
   }
 
   /// 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 142 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) {
-      String methodName = methodElement.name;
-      methodCases.add("if (memberName == '$methodName') {"
-          "method = reflectee.$methodName; }");
+      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); }");
     // Handle the cases where permission is given even though there is
     // no corresponding method. One case is where _all_ methods can be
     // invoked. Another case is when the user has specified a name
     // `"foo"` and a reflector `@reflector` allowing for invocation
@@ skipping 255 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);
 }