Add support for getters, setters and constructors in declarations of classMirrors.

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 50 matching lines @@
     annotatedClasses
         .forEach((ClassDomain classDomain) => classDomain.computeNames(namer));
   }
 }
 
 /// 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;
   String staticClassMirrorName;
   String staticInstanceMirrorName;
   String get baseName => classElement.name;
 
   ClassDomain(this.classElement, this.invokableMethods, this.declaredMethods,
-      this.reflectorDomain);
+      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);
   }
 
   /// 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;
     }
     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 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(", ")}}";
   }
 
   void computeNames(Namer namer) {
     staticClassMirrorName = namer.freshName("Static_${baseName}_ClassMirror");
     staticInstanceMirrorName =
         namer.freshName("Static_${baseName}_InstanceMirror");
   }
 }
@@ skipping 245 matching lines @@
     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<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);
@@ skipping 46 matching lines @@
             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, instanceMethods,
+                declaredMethodsOfClass, declaredAccessorsOfClass,
+                declaredConstructorsOfClass, domain));
           }
         }
       }
     }
     domains.values.forEach(_collectMissingImports);
 
     world.reflectors.addAll(domains.values.toList());
     world.computeNames(namer);
     return world;
   }
@@ skipping 865 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);
 }