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));
   }
+
+  // TODO(eernst, sigurdm): Perhaps reconsider what the best strategy for
+  // caching is.
+  Map<ClassElement, Map<String, ExecutableElement>> _instanceMemberCache =
+      new Map<ClassElement, Map<String, ExecutableElement>>();
 }
 
 /// 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.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;
+        }
+      }
+      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 {
         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.isStatic) {
+      result += constants.staticAttribute;
+    }
+    if (element.isSynthetic) {
+      result += constants.syntheticAttribute;
+    }
     if (element.isAbstract) {
       result += constants.abstractAttribute;
     }
-    if (element.isStatic) {
-      result += constants.staticAttribute;
-    }
     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 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(", ")}}";
+  }
+
   /// Returns a String with the textual representations of the metadata list.
   // TODO(sigurdm, 17307): Make this less fragile when the analyzer's
   // element-model exposes the metadata in a more friendly way.
   String get metadataString {
     List<String> metadataParts = new List<String>();
     Iterator<Annotation> nodeIterator = classElement.node.metadata.iterator;
     Iterator<ElementAnnotation> elementIterator =
         classElement.metadata.iterator;
     while (nodeIterator.moveNext()) {
       bool r = elementIterator.moveNext();
@@ skipping 258 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 capabilities about support.
         return true;
       } else {
         return capabilities.supportsInstanceInvoke(method.name);
       }
     });
   }
 
   Iterable<PropertyAccessorElement> declaredAccessors(
       ClassElement classElement, Capabilities capabilities) {
     return classElement.accessors.where((PropertyAccessorElement accessor) {
       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;
     });
   }
 
-  Iterable<MethodElement> invocableInstanceMethods(
-      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);
-    });
-  }
-
   /// 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();
             List<PropertyAccessorElement> declaredAccessorsOfClass =
                 declaredAccessors(type, domain.capabilities).toList();
             List<ConstructorElement> declaredConstructorsOfClass =
                 declaredConstructors(type, domain.capabilities).toList();
-            domain.annotatedClasses.add(new ClassDomain(type, instanceMethods,
+            domain.annotatedClasses.add(new ClassDomain(type,
                 declaredMethodsOfClass, declaredAccessorsOfClass,
                 declaredConstructorsOfClass, domain));
           }
         }
       }
     }
     domains.values.forEach(_collectMissingImports);
 
     world.reflectors.addAll(domains.values.toList());
     world.computeNames(namer);
@@ skipping 281 matching lines @@
     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) {
     List<String> implementedMembers = new List<String>();
     String simpleName = classDomain.classElement.name;
-    implementedMembers
-        .add('final String simpleName = "$simpleName";');
+    implementedMembers.add('final String simpleName = "$simpleName";');
     // When/if we have library-mirrors there could be a generic implementation:
     // String get qualifiedName => "${owner.qualifiedName}.${simpleName}";
     String qualifiedName =
         "${classDomain.classElement.library.name}.$simpleName";
     implementedMembers.add('final String qualifiedName = "$qualifiedName";');
     String declarationsString = classDomain.declarationsString;
     implementedMembers.add("""
   Map<String, MethodMirror> _declarationsCache;
   Map<String, MethodMirror> get declarations {
     if (_declarationsCache == null) {
       _declarationsCache = new UnmodifiableMapView($declarationsString);
     }
     return _declarationsCache;
   }""");
+    String instanceMembersString = classDomain.instanceMembersString;
+    implementedMembers.add("""
+  Map<String, MethodMirror> _instanceMembersCache;
+
+  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};");
     }
 
     return """
 class ${classDomain.staticClassMirrorName} extends ClassMirrorUnimpl {
   ${implementedMembers.join("\n\n  ")}
 }
 """;
@@ skipping 275 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 257 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);
 }