Clarifies the status of implicit accessors; fixed several related bugs.

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 'package:analyzer/src/generated/ast.dart';
@@ skipping 83 matching lines @@
   /// Libraries that must be imported to `reflector.library`.
   final Set<LibraryElement> _missingImports = new Set<LibraryElement>();
 
   _ReflectorDomain(this._reflector, this._capabilities) {}
 
   // TODO(eernst) future: Perhaps reconsider what the best strategy
   // for caching is.
   Map<ClassElement, Map<String, ExecutableElement>> _instanceMemberCache =
       new Map<ClassElement, Map<String, ExecutableElement>>();
 
+  Map<ClassElement, Map<String, ExecutableElement>> _staticMemberCache =
+      new Map<ClassElement, Map<String, ExecutableElement>>();
+
   /// Returns a string that evaluates to a closure invoking [constructor] with
   /// the given arguments.
   /// [importCollector] is used to record all the imports needed to make the
   /// constant.
   /// This is to provide something that can be called with [Function.apply].
   ///
   /// For example for a constructor Foo(x, {y: 3}):
   /// returns "(x, {y: 3}) => new prefix1.Foo(x, y)", and records an import of
   /// the library of `Foo` associated with prefix1 in [importCollector].
   String _constructorCode(
@@ skipping 99 matching lines @@
       // Add all the formal parameters (as a single, global set) which
       // are declared by any of the methods in `classDomain._declarations`.
       classDomain._declaredParameters.forEach(parameters.add);
 
       // Gather the fields declared in the target class (not inherited
       // ones) in [fields], i.e., the elements missing from [members]
       // at this point, in order to support `declarations` in a
       // [ClassMirror].
       classDomain._declaredFields.forEach(fields.add);
 
-      // Gather all getters and setters based on [instanceMembers], including
-      // both explicitly declared ones, implicitly generated ones for fields,
-      // and the implicitly generated ones that correspond to method tear-offs.
+      // Gather all getter and setter names based on [instanceMembers],
+      // including both explicitly declared ones, implicitly generated ones
+      // for fields, and the implicitly generated ones that correspond to
+      // method tear-offs.
       classDomain._instanceMembers.forEach((ExecutableElement instanceMember) {
         if (instanceMember is PropertyAccessorElement) {
           // A getter or a setter, synthetic or declared.
           if (instanceMember.isGetter) {
             instanceGetterNames.add(instanceMember.name);
           } else {
             instanceSetterNames.add(instanceMember.name);
           }
         } else if (instanceMember is MethodElement) {
           instanceGetterNames.add(instanceMember.name);
@@ skipping 102 matching lines @@
     int classIndex = 0;
     String classMirrorsCode =
         _formatAsList(includedClasses.map((_ClassDomain classDomain) {
       // Fields go first in [memberMirrors], so they will get the
       // same index as in [fields].
       Iterable<int> fieldsIndices =
           classDomain._declaredFields.map((FieldElement element) {
         return fields.indexOf(element);
       });
 
-      int fieldsLength = fields.length;
-
       // All the elements in the behavioral interface go after the
       // fields in [memberMirrors], so they must get an offset of
       // `fields.length` on the index.
       Iterable<int> methodsIndices = classDomain._declarations
           .where(_executableIsntImplicitGetterOrSetter)
           .map((ExecutableElement element) {
         // TODO(eernst) implement: The "magic" default constructor in `Object`
         // (the one that ultimately allocates the memory for _every_ new object)
         // has no index, which creates the need to catch a `null` here.
         // Search for "magic" to find other occurrences of the same issue.
         // For now, we provide the index -1 for this declaration, because
         // it is not yet supported. Need to find the correct solution, though!
         int index = members.indexOf(element);
-        return index == null ? -1 : index + fieldsLength;
+        return index == null ? -1 : index + fields.length;
       });
 
       String declarationsCode = "<int>[-1]"; // Encodes no capability.
       if (_capabilities._impliesDeclarations) {
         List<int> declarationsIndices = <int>[]
           ..addAll(fieldsIndices)
           ..addAll(methodsIndices);
         declarationsCode = _formatAsList(declarationsIndices);
       }
 
       // All instance members belong to the behavioral interface, so they
       // also get an offset of `fields.length`.
       String instanceMembersCode = _formatAsList(
           classDomain._instanceMembers.map((ExecutableElement element) {
         // TODO(eernst) implement: The "magic" default constructor has
         // index: -1; adjust this when support for it has been implemented.
         int index = members.indexOf(element);
-        return index == null ? -1 : index + fieldsLength;
+        return index == null ? -1 : index + fields.length;
+      }));
+
+      // All static members belong to the behavioral interface, so they
+      // also get an offset of `fields.length`.
+      String staticMembersCode = _formatAsList(
+          classDomain._staticMembers.map((ExecutableElement element) {
+        int index = members.indexOf(element);
+        return index == null ? -1 : index + fields.length;
       }));
 
       InterfaceType superType = classDomain._classElement.supertype;
       ClassElement superclass = superType == null ? null : superType.element;
       String superclassIndex;
       if (superclass == null) {
         superclassIndex = null;
       } else {
         int index = classes.indexOf(superclass);
         if (index == null) {
@@ skipping 33 matching lines @@
           staticGettingClosure(classDomain._classElement, element.name)));
       String staticSettersCode = _formatAsMap(classDomain
           ._declaredAndImplicitAccessors
           .where((PropertyAccessorElement element) =>
               element.isStatic && element.isSetter)
           .map((PropertyAccessorElement element) =>
               _staticSettingClosure(classDomain._classElement, element.name)));
       String result = 'new r.ClassMirrorImpl(r"${classDomain._simpleName}", '
           'r"${classDomain._qualifiedName}", $classIndex, '
           '${_constConstructionCode(importCollector)}, '
-          '$declarationsCode, $instanceMembersCode, $superclassIndex, '
-          '$staticGettersCode, $staticSettersCode, $constructorsCode, '
-          '$classMetadataCode)';
+          '$declarationsCode, $instanceMembersCode, $staticMembersCode, '
+          '$superclassIndex, $staticGettersCode, $staticSettersCode, '
+          '$constructorsCode, $classMetadataCode)';
       classIndex++;
       return result;
     }));
 
     String gettersCode = _formatAsMap(instanceGetterNames.map(gettingClosure));
     String settersCode = _formatAsMap(instanceSetterNames.map(settingClosure));
 
     Iterable<String> methodsList =
         members.items.map((ExecutableElement element) {
-      int descriptor = _declarationDescriptor(element);
-      int ownerIndex = classes.indexOf(element.enclosingElement);
-      Iterable<int> parameterIndices =
-          element.parameters.map((ParameterElement parameterElement) {
-        return parameters.indexOf(parameterElement);
-      });
-      String parameterIndicesCode = _formatAsList(parameterIndices);
-      String metadataCode;
-      if (_capabilities._supportsMetadata) {
-        metadataCode = _extractMetadataCode(
-            element, resolver, importCollector, logger, dataId);
+      if (element is PropertyAccessorElement && element.isSynthetic) {
+        // There is no type propagation, so we declare an `accessorElement`.
+        PropertyAccessorElement accessorElement = element;
+        int variableMirrorIndex = fields.indexOf(accessorElement.variable);
+        // The `indexOf` is non-null: `accessorElement` came from `members`.
+        int selfIndex = members.indexOf(accessorElement) + fields.length;
+        if (accessorElement.isGetter) {
+          return 'new r.ImplicitGetterMirrorImpl('
+              '${_constConstructionCode(importCollector)}, '
+              '$variableMirrorIndex, $selfIndex)';
+        } else {
+          assert(accessorElement.isSetter);
+          return 'new r.ImplicitSetterMirrorImpl('
+              '${_constConstructionCode(importCollector)}, '
+              '$variableMirrorIndex, $selfIndex)';
+        }
       } else {
-        metadataCode = null;
+        int descriptor = _declarationDescriptor(element);
+        int returnTypeIndex = classes._contains(element.returnType.element)
+            ? classes.indexOf(element.returnType.element)
+            : -1;
+        int ownerIndex = classes.indexOf(element.enclosingElement);
+        String parameterIndicesCode = _formatAsList(
+            element.parameters.map((ParameterElement parameterElement) {
+          return parameters.indexOf(parameterElement);
+        }));
+        String metadataCode = _capabilities._supportsMetadata
+            ? _extractMetadataCode(
+                element, resolver, importCollector, logger, dataId)
+            : null;
+        return 'new r.MethodMirrorImpl(r"${element.name}", $descriptor, '
+            '$ownerIndex, $returnTypeIndex, $parameterIndicesCode, '
+            '${_constConstructionCode(importCollector)}, $metadataCode)';
       }
-      return 'new r.MethodMirrorImpl(r"${element.name}", $descriptor, '
-          '$ownerIndex, $parameterIndicesCode, '
-          '${_constConstructionCode(importCollector)}, $metadataCode)';
     });
 
     Iterable<String> fieldsList = fields.items.map((FieldElement element) {
       int descriptor = _fieldDescriptor(element);
       int ownerIndex = classes.indexOf(element.enclosingElement);
       int classMirrorIndex = classes._contains(element.type.element)
-                             ? classes.indexOf(element.type.element)
-                             : -1;
+          ? classes.indexOf(element.type.element)
+          : -1;
       String metadataCode;
       if (_capabilities._supportsMetadata) {
         metadataCode = _extractMetadataCode(
             element, resolver, importCollector, logger, dataId);
       } else {
         metadataCode = null;
       }
       return 'new r.VariableMirrorImpl(r"${element.name}", $descriptor, '
           '$ownerIndex, ${_constConstructionCode(importCollector)}, '
           '$classMirrorIndex, $metadataCode)';
@@ skipping 108 matching lines @@
         if (member.isPrivate) return;
         // If [member] is a synthetic accessor created from a field, search for
         // the metadata on the original field.
         List<ElementAnnotation> metadata = (member is PropertyAccessorElement &&
             member.isSynthetic) ? member.variable.metadata : member.metadata;
         if (_reflectorDomain._capabilities
             .supportsInstanceInvoke(member.name, metadata)) {
           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);
       }
       return result;
     }
+
     return helper(_classElement).values;
   }
 
+  /// Finds all static members.
+  Iterable<ExecutableElement> get _staticMembers {
+    Map<String, ExecutableElement> helper(ClassElement classElement) {
+      if (_reflectorDomain._staticMemberCache[classElement] != null) {
+        return _reflectorDomain._staticMemberCache[classElement];
+      }
+      Map<String, ExecutableElement> result =
+          new Map<String, ExecutableElement>();
+
+      void addIfCapable(ExecutableElement member) {
+        if (member.isPrivate) return;
+        // If [member] is a synthetic accessor created from a field, search for
+        // the metadata on the original field.
+        List<ElementAnnotation> metadata = (member is PropertyAccessorElement &&
+            member.isSynthetic) ? member.variable.metadata : member.metadata;
+        if (_reflectorDomain._capabilities
+            .supportsInstanceInvoke(member.name, metadata)) {
+          result[member.name] = 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);
+      }
+      return result;
+    }
+
+    return helper(_classElement).values;
+  }
+
   String toString() {
     return "ClassDomain($_classElement)";
   }
 
   bool operator ==(Object other) {
     if (other is _ClassDomain) {
       return _classElement == other._classElement &&
           _reflectorDomain == other._reflectorDomain;
     } else {
       return false;
@@ skipping 354 matching lines @@
     } else if (element is PropertyAccessorElement) {
       PropertyInducingElement variable = element.variable;
       // Surprisingly, we have to use [ConstTopLevelVariableElementImpl]
       // here (or a similar type).  This is because none of the "public name"
       // types (types whose name does not end in `..Impl`) declare the getter
       // `evaluationResult`.  Another possible choice of type would be
       // [VariableElementImpl], but with that one we would have to test
       // `isConst` as well.
       if (variable is ConstTopLevelVariableElementImpl) {
         EvaluationResultImpl result = variable.evaluationResult;
-        if (result.value == null) return null;  // Errors during evaluation.
+        if (result.value == null) return null; // Errors during evaluation.
         bool isOk = checkInheritance(result.value.type, focusClass.type);
         return isOk ? result.value.type.element : null;
       } else {
         // Not a const top level variable, not relevant.
         return null;
       }
     }
     // Otherwise [element] is some other construct which is not supported.
     //
     // TODO(eernst) clarify: We need to consider whether there could be some
@@ skipping 499 matching lines @@
 
       String originalEntryPointFilename =
           path.basename(originalEntryPointId.path);
 
       LibraryElement entryPointLibrary =
           _resolver.getLibrary(entryPointAsset.id);
 
       // Generate a new file with the name of the entry-point, whose main
       // initializes the reflection data, and calls the main from
       // [originalEntryPointId].
-      aggregateTransform.addOutput(new Asset.fromString(entryPointAsset.id,
+      aggregateTransform.addOutput(new Asset.fromString(
+          entryPointAsset.id,
           _generateNewEntryPoint(world, entryPointAsset.id,
               originalEntryPointFilename, entryPointLibrary)));
       _resolver.release();
     }
   }
 }
 
 /// Wrapper of `AggregateTransform` of type `Transform`, allowing us to
 /// get a `Resolver` for a given `AggregateTransform` with a given
 /// selection of a primary entry point.
@@ skipping 382 matching lines @@
   List<ConstructorElement> declaredConstructorsOfClass =
       _declaredConstructors(type, domain._capabilities).toList();
   return new _ClassDomain(
       type,
       declaredFieldsOfClass,
       declaredMethodsOfClass,
       declaredParametersOfClass,
       declaredAndImplicitAccessorsOfClass,
       declaredConstructorsOfClass,
       domain);
-}
+}