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

reflectable/lib/src/mirrors_unimpl.dart

 // Copyright (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.mirrors_unimpl;
 
 import 'dart:collection' show UnmodifiableMapView, UnmodifiableListView;
 
 import '../capability.dart';
 import '../mirrors.dart';
@@ skipping 163 matching lines @@
       setterName += "=";
     }
     Function setter = _data.setters[setterName];
     if (setter != null) {
       return setter(reflectee, value);
     }
     throw new NoSuchInvokeCapabilityError(reflectee, setterName, [value], {});
   }
 }
 
-int _variableToImplicitAccessorAttributes(VariableMirror variableMirror) {
-  int attributes = 0;
-  if (variableMirror.isPrivate) attributes |= constants.privateAttribute;
-  if (variableMirror.isStatic) attributes |= constants.staticAttribute;
-  attributes |= constants.syntheticAttribute;
-  return attributes;
-}
-
-MethodMirror _variableToGetterMirror(VariableMirrorImpl variableMirror) {
-  int descriptor = constants.getter;
-  descriptor |= _variableToImplicitAccessorAttributes(variableMirror);
-  // TODO(eernst) clarify: Make sure it is the right `ownerIndex`: Write a test
-  // that compares owners in pre/post-transform code.
-  return new MethodMirrorImpl(variableMirror.simpleName, descriptor,
-      variableMirror._ownerIndex, [], variableMirror._reflector, []);
-}
-
-// TODO(eernst) implement: Make this method take an `index` parameter which
-// will be the index of the returned `MethodMirror`, such that the enclosed
-// parameter mirror can get the right ownerIndex.
-MethodMirror _variableToSetterMirror(VariableMirrorImpl variableMirror) {
-  int descriptor = constants.setter | constants.syntheticAttribute;
-  descriptor |= _variableToImplicitAccessorAttributes(variableMirror);
-  int parameterDescriptor = constants.parameter | constants.syntheticAttribute;
-  String name = variableMirror.simpleName + "=";
-  return new MethodMirrorImpl(
-      name,
-      descriptor,
-      variableMirror._ownerIndex,
-      [
-        // TODO(eernst) clarify: Make sure it is the right `ownerIndex`: Write a
-        // test that compares owners in pre/post-transform code.
-        new ParameterMirrorImpl(
-            name,
-            parameterDescriptor,
-            variableMirror._ownerIndex,
-            variableMirror._reflector,
-            -1,
-            variableMirror.metadata,
-            null)
-      ],
-      variableMirror._reflector,
-      []);
-}
-
 class ClassMirrorImpl extends _DataCaching implements ClassMirror {
   /// The reflector which represents the mirror system that this
   /// mirror belongs to.
   final ReflectableImpl _reflector;
 
   /// The index of this mirror in the [ReflectorData.classMirrors] table.
   /// Also this is the index of the Type of the reflected class in
   /// [ReflectorData.types].
   final int _classIndex;
 
   /// A list of the indices in [ReflectorData.memberMirrors] of the
   /// declarations of the reflected class. This includes method mirrors
   /// and variable mirrors and it directly corresponds to `declarations`.
   /// Exception: When the given `_reflector.capabilities` do not support
   /// the operation `declarations`, this will be `<int>[-1]`. It is enough
   /// to check that the list is non-empty and first element is -1 to
   /// detect this situation, because -1 will otherwise never occur.
   final List<int> _declarationIndices;
 
   /// A list of the indices in [ReflectorData.memberMirrors] of the
   /// instance members of the reflected class, except that it includes
   /// variable mirrors describing fields which must be converted to
   /// implicit getters and possibly implicit setters in order to
   /// obtain the correct result for `instanceMembers`.
   final List<int> _instanceMemberIndices;
 
+  /// A list of the indices in [ReflectorData.memberMirrors] of the
+  /// static members of the reflected class, except that it includes
+  /// variable mirrors describing static fields nwhich must be converted
+  /// to implicit getters and possibly implicit setters in order to
+  /// obtain the correct result for `staticMembers`.
+  final List<int> _staticMemberIndices;
+
   /// The index of the mirror of the superclass in the
   /// [ReflectorData.classMirrors] table.
   final int _superclassIndex;
 
   final String simpleName;
   final String qualifiedName;
   final List<Object> _metadata;
   final Map<String, _StaticGetter> getters;
   final Map<String, _StaticSetter> setters;
   final Map<String, Function> constructors;
 
   ClassMirrorImpl(
       this.simpleName,
       this.qualifiedName,
       this._classIndex,
       this._reflector,
       this._declarationIndices,
       this._instanceMemberIndices,
+      this._staticMemberIndices,
       this._superclassIndex,
       this.getters,
       this.setters,
       this.constructors,
       metadata)
       : _metadata =
             (metadata == null) ? null : new UnmodifiableListView(metadata);
 
   ClassMirror get superclass {
     if (_superclassIndex == null) return null;
@@ skipping 35 matching lines @@
   }
 
   Map<String, MethodMirror> _instanceMembers;
 
   Map<String, MethodMirror> get instanceMembers {
     if (_instanceMembers == null) {
       Map<String, MethodMirror> result = new Map<String, MethodMirror>();
       for (int instanceMemberIndex in _instanceMemberIndices) {
         DeclarationMirror declarationMirror =
             _data.memberMirrors[instanceMemberIndex];
-        if (declarationMirror is MethodMirror) {
-          result[declarationMirror.simpleName] = declarationMirror;
-        } else {
-          assert(declarationMirror is VariableMirror);
-          // Need declaration because `assert` provides no type propagation.
-          VariableMirror variableMirror = declarationMirror;
-          result[variableMirror.simpleName] =
-              _variableToGetterMirror(variableMirror);
-          if (!variableMirror.isFinal) {
-            result[variableMirror.simpleName + "="] =
-                _variableToSetterMirror(variableMirror);
-          }
-        }
+        assert(declarationMirror is MethodMirror);
+        result[declarationMirror.simpleName] = declarationMirror;
       }
       _instanceMembers = new UnmodifiableMapView<String, MethodMirror>(result);
     }
     return _instanceMembers;
   }
 
-  Map<String, MethodMirror> get staticMembers => _unsupported();
+  Map<String, MethodMirror> _staticMembers;
+
+  Map<String, MethodMirror> get staticMembers {
+    if (_staticMembers == null) {
+      Map<String, MethodMirror> result = new Map<String, MethodMirror>();
+      for (int staticMemberIndex in _staticMemberIndices) {
+        DeclarationMirror declarationMirror =
+            _data.memberMirrors[staticMemberIndex];
+        assert(declarationMirror is MethodMirror);
+        result[declarationMirror.simpleName] = declarationMirror;
+      }
+      _staticMembers = new UnmodifiableMapView<String, MethodMirror>(result);
+    }
+    return _staticMembers;
+  }
 
   ClassMirror get mixin => _unsupported();
 
   Object newInstance(String constructorName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     return Function.apply(
         constructors["$constructorName"], positionalArguments, namedArguments);
   }
 
   bool isSubclassOf(ClassMirror other) {
@@ skipping 110 matching lines @@
 class MethodMirrorImpl extends _DataCaching implements MethodMirror {
   /// An encoding of the attributes and kind of this mirror.
   final int _descriptor;
 
   /// The name of this method. Setters names will end in '='.
   final String _name;
 
   /// The index of the [ClassMirror] of the owner of this method,
   final int _ownerIndex;
 
+  /// The index of the return type of this method.
+  final int _returnTypeIndex;
+
   /// The indices of the [ParameterMirror]s describing the formal parameters
   /// of this method.
   final List<int> _parameterIndices;
 
   /// The [Reflectable] associated with this mirror.
   final ReflectableImpl _reflector;
 
   /// A cache of the metadata of the mirrored method. The empty list means
   /// no metadata, null means that [_reflector] does not have
   /// [metadataCapability].
   final List<Object> _metadata;
 
-  MethodMirrorImpl(this._name, this._descriptor, this._ownerIndex,
-      this._parameterIndices, this._reflector, List<Object> metadata)
+  MethodMirrorImpl(
+      this._name,
+      this._descriptor,
+      this._ownerIndex,
+      this._returnTypeIndex,
+      this._parameterIndices,
+      this._reflector,
+      List<Object> metadata)
       : _metadata =
             (metadata == null) ? null : new UnmodifiableListView(metadata);
 
   int get kind => constants.kindFromEncoding(_descriptor);
 
   ClassMirror get owner => _data.classMirrors[_ownerIndex];
 
   @override
-  String get constructorName => _name;
+  String get constructorName => isConstructor ? _name : "";
 
   @override
   bool get isAbstract => (_descriptor & constants.abstractAttribute != 0);
 
   @override
   bool get isConstConstructor => (_descriptor & constants.constAttribute != 0);
 
   @override
   bool get isConstructor => isFactoryConstructor || isGenerativeConstructor;
 
@@ skipping 48 matching lines @@
   @override
   List<ParameterMirror> get parameters {
     return _parameterIndices
         .map((int parameterIndex) => _data.parameterMirrors[parameterIndex])
         .toList();
   }
 
   @override
   String get qualifiedName => "${owner.qualifiedName}.$_name";
 
-  // TODO(sigurdm) feature: suport `returnType`.
   @override
-  TypeMirror get returnType => throw new UnimplementedError();
+  TypeMirror get returnType {
+    if (_returnTypeIndex == -1) {
+      _unsupported();
+    }
+    return _data.classMirrors[_returnTypeIndex];
+  }
 
   @override
   String get simpleName => isConstructor
       ? (_name == '' ? "${owner.simpleName}" : "${owner.simpleName}.$_name")
       : _name;
 
   @override
   String get source => null;
 
   @override
-  String toString() => "MethodMirror($_name)";
+  String toString() => "MethodMirrorImpl($qualifiedName)";
+}
+
+abstract class ImplicitAccessorMirrorImpl extends _DataCaching
+    implements MethodMirror {
+  final ReflectableImpl _reflector;
+  final int _variableMirrorIndex;
+
+  /// Index of this [ImplicitAccessorMirrorImpl] in `_data.memberMirrors`.
+  final int _selfIndex;
+
+  VariableMirrorImpl get _variableMirror =>
+      _data.memberMirrors[_variableMirrorIndex];
+
+  ImplicitAccessorMirrorImpl(
+      this._reflector, this._variableMirrorIndex, this._selfIndex);
+
+  int get kind => constants.kindFromEncoding(_variableMirror._descriptor);
+
+  ClassMirror get owner => _variableMirror.owner;
+
+  @override
+  String get constructorName => "";
+
+  @override
+  bool get isAbstract => false;
+
+  @override
+  bool get isConstConstructor => false;
+
+  @override
+  bool get isConstructor => false;
+
+  @override
+  bool get isFactoryConstructor => false;
+
+  @override
+  bool get isGenerativeConstructor => false;
+
+  @override
+  bool get isOperator => false;
+
+  @override
+  bool get isPrivate => _variableMirror.isPrivate;
+
+  @override
+  bool get isRedirectingConstructor => false;
+
+  @override
+  bool get isRegularMethod => false;
+
+  @override
+  bool get isStatic => _variableMirror.isStatic;
+
+  @override
+  bool get isSynthetic => true;
+
+  @override
+  bool get isTopLevel => false;
+
+  // It is allowed to return null.
+  @override
+  SourceLocation get location => null;
+
+  @override
+  List<Object> get metadata => <Object>[];
+
+  @override
+  TypeMirror get returnType => _variableMirror.type;
+
+  @override
+  String get source => null;
+}
+
+class ImplicitGetterMirrorImpl extends ImplicitAccessorMirrorImpl {
+  ImplicitGetterMirrorImpl(
+      ReflectableImpl reflector, int variableMirrorIndex, int selfIndex)
+      : super(reflector, variableMirrorIndex, selfIndex);
+
+  @override
+  bool get isGetter => true;
+
+  @override
+  bool get isSetter => false;
+
+  @override
+  List<ParameterMirror> get parameters => <ParameterMirror>[];
+
+  @override
+  String get qualifiedName => _variableMirror.qualifiedName;
+
+  @override
+  String get simpleName => _variableMirror.simpleName;
+
+  @override
+  String toString() => "ImplicitGetterMirrorImpl($qualifiedName)";
+}
+
+class ImplicitSetterMirrorImpl extends ImplicitAccessorMirrorImpl {
+  ImplicitSetterMirrorImpl(
+      ReflectableImpl reflector, int variableMirrorIndex, int selfIndex)
+      : super(reflector, variableMirrorIndex, selfIndex);
+
+  @override
+  bool get isGetter => false;
+
+  @override
+  bool get isSetter => true;
+
+  int get _parameterDescriptor {
+    int descriptor = constants.parameter;
+    if (_variableMirror.isStatic) descriptor |= constants.staticAttribute;
+    if (_variableMirror.isPrivate) descriptor |= constants.privateAttribute;
+    descriptor |= constants.syntheticAttribute;
+    if (_variableMirror._isDynamic) descriptor |= constants.dynamicAttribute;
+    if (_variableMirror._isClassType) descriptor |=
+        constants.classTypeAttribute;
+    return descriptor;
+  }
+
+  @override
+  List<ParameterMirror> get parameters {
+    return <ParameterMirror>[
+      new ParameterMirrorImpl(
+          _variableMirror.simpleName,
+          _parameterDescriptor,
+          _selfIndex,
+          _variableMirror._reflector,
+          _variableMirror._classMirrorIndex,
+          <Object>[],
+          null)
+    ];
+  }
+
+  @override
+  String get qualifiedName => "${_variableMirror.qualifiedName}=";
+
+  @override
+  String get simpleName => "${_variableMirror.simpleName}=";
+
+  @override
+  String toString() => "ImplicitSetterMirrorImpl($qualifiedName)";
 }
 
 abstract class VariableMirrorBase extends _DataCaching
     implements VariableMirror {
   final String _name;
   final int _descriptor;
   final int _ownerIndex;
   final ReflectableImpl _reflector;
   final _classMirrorIndex;
   final List<Object> _metadata;
@@ skipping 219 matching lines @@
   LibraryMirror findLibrary(String library) => _unsupported();
 
   @override
   Map<Uri, LibraryMirror> get libraries => _unsupported();
 
   @override
   Iterable<ClassMirror> get annotatedClasses {
     return new UnmodifiableListView<ClassMirror>(data[this].classMirrors);
   }
 }