Moved some MethodMirror properties from embedded API to native calls.

runtime/lib/mirrors_impl.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // VM-specific implementation of the dart:mirrors library.
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
   return (value == null || value is num || value is String || value is bool);
 }
@@ skipping 849 matching lines @@
 
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
 }
 
 class _LocalMethodMirrorImpl extends _LocalMirrorImpl
     implements MethodMirror {
   _LocalMethodMirrorImpl(this._reflectee,
                          this._owner,
                          this.parameters,
-                         this._returnType,
-                         this.isStatic,
-                         this.isAbstract,
-                         this.isGetter,
-                         this.isSetter,
-                         this.isConstructor,
-                         this.isConstConstructor,
-                         this.isGenerativeConstructor,
-                         this.isRedirectingConstructor,
-                         this.isFactoryConstructor);
+                         this._returnType);
 
   final _MirrorReference _reflectee;
 
+  // Keep in sync with MethodMirrorProperty in mirrors.cc.
+  static const int _propertyIsStatic = 0;
+  static const int _propertyIsAbstract = 1;
+  static const int _propertyIsGetter = 2;
+  static const int _propertyIsSetter = 3;
+  static const int _propertyIsConstructor = 4;
+
   Symbol _simpleName = null;
   Symbol get simpleName {
     if (_simpleName == null) {
       _simpleName = _s(_MethodMirror_name(_reflectee));
     }
     return _simpleName;
   }
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
@@ skipping 26 matching lines @@
   var _returnType;
   TypeMirror get returnType {
     if (_returnType is! Mirror) {
       _returnType = _returnType.resolve(mirrors);
     }
     return _returnType;
   }
 
   final List<ParameterMirror> parameters;
 
-  final bool isStatic;
-  final bool isAbstract;
+  bool _isStatic = null;
+  bool get isStatic {
+    if (_isStatic == null) {
+      _isStatic = _MethodMirror_get_property(_reflectee, _propertyIsStatic);
+    }
+    return _isStatic;
+  }
+
+  bool _isAbstract;
+  bool get isAbstract {
+    if (_isAbstract == null) {
+      _isAbstract = _MethodMirror_get_property(_reflectee, _propertyIsAbstract);
+    }
+    return _isAbstract;
+  }
 
   bool get isRegularMethod => !isGetter && !isSetter && !isConstructor;
 
   TypeMirror get isOperator {
     throw new UnimplementedError(
         'MethodMirror.isOperator is not implemented');
   }
 
-  final bool isGetter;
-  final bool isSetter;
-  final bool isConstructor;
+  bool _isGetter = null;
+  bool get isGetter {
+    if (_isGetter == null) {
+      _isGetter = _MethodMirror_get_property(_reflectee, _propertyIsGetter);
+    }
+    return _isGetter;
+  }
+
+  bool _isSetter = null;
+  bool get isSetter {
+    if (_isSetter == null) {
+      _isSetter = _MethodMirror_get_property(_reflectee, _propertyIsSetter);
+    }
+    return _isSetter;
+  }
+
+  bool _isConstructor = null;
+  bool get isConstructor {
+    if (_isConstructor == null) {
+      _isConstructor = _MethodMirror_get_property(_reflectee,
+                                                  _propertyIsConstructor);
+    }
+    return _isConstructor;
+  }
 
   Symbol _constructorName = null;
   Symbol get constructorName {
     if (_constructorName == null) {
       if (!isConstructor) {
         _constructorName = _s('');
       } else {
         var parts = _n(simpleName).split('.');
         if (parts.length > 2) {
           throw new MirrorException(
               'Internal error in MethodMirror.constructorName: '
               'malformed name <$simpleName>');
         } else if (parts.length == 2) {
           _constructorName = _s(parts[1]);
         } else {
           _constructorName = _s('');
         }
       }
     }
     return _constructorName;
   }
 
-  final bool isConstConstructor;
-  final bool isGenerativeConstructor;
-  final bool isRedirectingConstructor;
-  final bool isFactoryConstructor;
+  // TODO(mlippautz): Implement constructor kinds.
+  final bool isConstConstructor = false;
+  final bool isGenerativeConstructor = false;
+  final bool isRedirectingConstructor = false;
+  final bool isFactoryConstructor = false;
 
   List<InstanceMirror> get metadata {
     owner; // ensure owner is computed
     // get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list
     return _metadata(this).map(reflect).toList();
   }
 
   String toString() => "MethodMirror on '${_n(simpleName)}'";
 
   static String _MethodMirror_name(reflectee)
       native "MethodMirror_name";
+
+  static bool _MethodMirror_get_property(reflectee, property)
+      native "MethodMirror_get_property";
 }
 
 class _LocalVariableMirrorImpl extends _LocalMirrorImpl
     implements VariableMirror {
   _LocalVariableMirrorImpl(String simpleName,
                            this._owner,
                            this._type,
                            this.isStatic,
                            this.isFinal)
       : this.simpleName = _s(simpleName);
@@ skipping 136 matching lines @@
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static ClassMirror reflectClass(Type key) {
     return makeLocalClassMirror(key);
   }
 }