More mirrors changes to bring vm mirrors more in line with the

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 243 matching lines @@
 
 class _LocalClosureMirrorImpl extends _LocalInstanceMirrorImpl
     implements ClosureMirror {
   _LocalClosureMirrorImpl(ref,
                           klass,
                           reflectee) : super(ref, klass, reflectee) {}
 
   MethodMirror _function;
   MethodMirror function() => _function;
 
-  String source() {
-    throw new NotImplementedException('ClosureMirror.source() not implemented');
+  String get source() {
+    throw new NotImplementedException('ClosureMirror.source not implemented');
   }
 
   Future<ObjectMirror> apply(List<Object> positionalArguments,
                              [Map<String,Object> namedArguments]) {
     if (namedArguments !== null) {
       throw new NotImplementedException('named arguments not implemented');
     }
     // Walk the arguments and make sure they are legal.
     for (int i = 0; i < positionalArguments.length; i++) {
       var arg = positionalArguments[i];
@@ skipping 37 matching lines @@
 
   final String libraryName;
   final String interfaceName;
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(ref,
                         this.simpleName,
                         this.isClass,
-                        this._library,
+                        this._owner,
                         this._superclass,
                         this._superinterfaces,
                         this._defaultFactory,
                         this.members) : super(ref) {}
 
   final String simpleName;
+
+  String _qualifiedName = null;
+  String get qualifiedName() {
+    if (_qualifiedName === null) {
+      _qualifiedName = '${owner.qualifiedName}.${simpleName}';
+    }
+    return _qualifiedName;
+  }
+
+  var _owner;
+  DeclarationMirror get owner() {
+    if (_owner is! Mirror) {
+      _owner = _owner.resolve(mirrors);
+    }
+    return _owner;
+  }
+
+  bool get isPrivate() {
+    return simpleName.startsWith('_');
+  }
+
+  final bool isTopLevel = true;
+
+  SourceLocation get location() {
+    throw new NotImplementedException(
+        'ClassMirror.location not yet implemented');
+  }
+
   final bool isClass;
 
-  var _library;
-  LibraryMirror get library() {
-    if (_library is _LazyLibraryMirror) {
-      _library = _library.resolve(mirrors);
-    }
-    return _library;
-  }
-
   var _superclass;
   ClassMirror get superclass() {
     if (_superclass is _LazyClassMirror) {
       _superclass = _superclass.resolve(mirrors);
     }
     return _superclass;
   }
 
   var _superinterfaces;
   List<ClassMirror> get superinterfaces() {
     if (_superinterfaces.length > 0 &&
         _superinterfaces[0] is _LazyClassMirror) {
       List<ClassMirror> resolved = new List<ClassMirror>();
       for (int i = 0; i < _superinterfaces.length; i++) {
         resolved.add(_superinterfaces[i].resolve(mirrors));
       }
       _superinterfaces = resolved;
     }
     return _superinterfaces;
   }
 
   var _defaultFactory;
   ClassMirror get defaultFactory() {
     if (_defaultFactory is _LazyClassMirror) {
       _defaultFactory = _defaultFactory.resolve(mirrors);
     }
     return _defaultFactory;
   }
 
-  final Map<String, ClassMirror> members;
+  final Map<String, Mirror> members;
 
-  Map<String, ClassMirror> _methods = null;
-  Map<String, ClassMirror> _variables = null;
+  Map<String, MethodMirror> _methods = null;
+  Map<String, MethodMirror> _constructors = null;
+  Map<String, MethodMirror> _getters = null;
+  Map<String, MethodMirror> _setters = null;
+  Map<String, VariableMirror> _variables = null;
 
   Map<String, MethodMirror> get methods() {
     if (_methods == null) {
       _methods = filterMap(members,
                            (key, value) => (value is MethodMirror));
     }
     return _methods;
   }
 
+  Map<String, MethodMirror> get constructors() {
+    if (_constructors == null) {
+      _constructors = filterMap(methods,
+                                (key, value) => (value.isConstructor));
+    }
+    return _constructors;
+  }
+
+  Map<String, MethodMirror> get getters() {
+    if (_getters == null) {
+      _getters = filterMap(methods,
+                           (key, value) => (value.isGetter));
+    }
+    return _getters;
+  }
+
+  Map<String, MethodMirror> get setters() {
+    if (_setters == null) {
+      _setters = filterMap(methods,
+                           (key, value) => (value.isSetter));
+    }
+    return _setters;
+  }
+
   Map<String, VariableMirror> get variables() {
     if (_variables == null) {
       _variables = filterMap(members,
                              (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
+  List<TypeVariableMirror> get typeVariables() {
+    throw new NotImplementedException(
+        'ClassMirror.typeVariables not yet implemented');
+  }
+
+  List<TypeMirror> get typeArguments() {
+    throw new NotImplementedException(
+        'ClassMirror.typeArguments not yet implemented');
+  }
+
+  bool isUnboundType() {
+    throw new NotImplementedException(
+        'ClassMirror.isUnboundType not yet implemented');
+  }
+
+  ClassMirror unboundType() {
+    throw new NotImplementedException(
+        'ClassMirror.unboundType not yet implemented');
+  }
+
   String toString() {
     return "ClassMirror on '$simpleName'";
   }
 
   Future<InstanceMirror> newInstance(String constructorName,
-                                List positionalArguments,
-                                [Map<String,Dynamic> namedArguments]) {
+                                     List positionalArguments,
+                                     [Map<String,Dynamic> namedArguments]) {
     if (namedArguments !== null) {
       throw new NotImplementedException('named arguments not implemented');
     }
     // Walk the arguments and make sure they are legal.
     for (int i = 0; i < positionalArguments.length; i++) {
       var arg = positionalArguments[i];
       _LocalObjectMirrorImpl._validateArgument(i, arg);
     }
     Completer<InstanceMirror> completer = new Completer<InstanceMirror>();
     try {
@@ skipping 20 matching lines @@
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(ref,
                           this.simpleName,
                           this.url,
                           this.members) : super(ref) {}
 
   final String simpleName;
+
+  String get qualifiedName() {

[cshapiro, 2012/08/21 03:16:05]

  // The simple name and the qualified name are the same for a library.
  String get qualifiedName() => simpleName;

For consistency with the other accessors?

[turnidge, 2012/08/21 18:00:49]

Switched all short functions (that can fit on one line) to use the => format in
the file.

+    // The simple name and the qualified name are the same for a library.
+    return simpleName;
+  }
+
+  // Always null for libraries.
+  final DeclarationMirror owner = null;
+
+  // Always false for libraries.
+  final bool isPrivate = false;
+
+  // Always false for libraries.
+  final bool isTopLevel = false;
+
+  SourceLocation get location() {
+    throw new NotImplementedException(
+        'LibraryMirror.location not yet implemented');
+  }
+
   final String url;
-  final Map<String, ClassMirror> members;
+  final Map<String, Mirror> members;
 
   Map<String, ClassMirror> _classes = null;
-  Map<String, ClassMirror> _functions = null;
-  Map<String, ClassMirror> _variables = null;
+  Map<String, MethodMirror> _functions = null;
+  Map<String, MethodMirror> _getters = null;
+  Map<String, MethodMirror> _setters = null;
+  Map<String, VariableMirror> _variables = null;
 
   Map<String, ClassMirror> get classes() {
     if (_classes == null) {
       _classes = filterMap(members,
                            (key, value) => (value is ClassMirror));
     }
     return _classes;
   }
 
   Map<String, MethodMirror> get functions() {
     if (_functions == null) {
       _functions = filterMap(members,
                              (key, value) => (value is MethodMirror));
     }
     return _functions;
   }
 
+  Map<String, MethodMirror> get getters() {
+    if (_getters == null) {
+      _getters = filterMap(functions,
+                           (key, value) => (value.isGetter));
+    }
+    return _getters;
+  }
+
+  Map<String, MethodMirror> get setters() {
+    if (_setters == null) {
+      _setters = filterMap(functions,
+                           (key, value) => (value.isSetter));
+    }
+    return _setters;
+  }
+
   Map<String, VariableMirror> get variables() {
     if (_variables == null) {
       _variables = filterMap(members,
                              (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
   String toString() {
     return "LibraryMirror on '$simpleName'";
@@ skipping 10 matching lines @@
                          this.isGetter,
                          this.isSetter,
                          this.isConstructor,
                          this.isConstConstructor,
                          this.isGenerativeConstructor,
                          this.isRedirectingConstructor,
                          this.isFactoryConstructor) {}
 
   final String simpleName;
 
+  String _qualifiedName = null;
+  String get qualifiedName() {
+    if (_qualifiedName === null) {
+      _qualifiedName = '${owner.qualifiedName}.${simpleName}';
+    }
+    return _qualifiedName;
+  }
+
   var _owner;
-  Mirror get owner() {
+  DeclarationMirror get owner() {
     if (_owner is! Mirror) {
       _owner = _owner.resolve(mirrors);
     }
     return _owner;
   }
 
-  final List<ParameterMirror> parameters;
+  bool get isPrivate() {
+    return simpleName.startsWith('_') || constructorName.startsWith('_');
+  }
 
   bool get isTopLevel() {
     return owner is LibraryMirror;
   }
 
+  SourceLocation get location() {
+    throw new NotImplementedException(
+        'MethodMirror.location not yet implemented');
+  }
+
+  TypeMirror get returnType() {
+    throw new NotImplementedException(
+        'MethodMirror.returnType not yet implemented');
+  }
+
+  final List<ParameterMirror> parameters;
+
   final bool isStatic;
+  final bool isAbstract;
 
-  bool get isMethod() {
+  bool get isRegularMethod() {
     return !isGetter && !isSetter && !isConstructor;
   }
 
-  final bool isAbstract;
+  TypeMirror get isOperator() {
+    throw new NotImplementedException(
+        'MethodMirror.isOperator not yet implemented');
+  }
+
   final bool isGetter;
   final bool isSetter;
   final bool isConstructor;
 
+  var _constructorName = null;
+  String get constructorName() {
+    if (_constructorName === null) {
+      if (!isConstructor) {
+        _constructorName = '';
+      } else {
+        var parts = simpleName.split('.');
+        if (parts.length > 2) {
+          throw new MirrorException(
+              'Internal error in MethodMirror.constructorName: '
+              'malformed name <$simpleName>');
+        } else if (parts.length == 2) {
+          _constructorName = parts[1];
+        } else {
+          _constructorName = '';
+        }
+      }
+    }
+    return _constructorName;
+  }
+
   final bool isConstConstructor;
   final bool isGenerativeConstructor;
   final bool isRedirectingConstructor;
   final bool isFactoryConstructor;
 
   String toString() {
     return "MethodMirror on '$simpleName'";
   }
 }
 
-class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
-    implements ParameterMirror {
-  // TODO(rmacnak): Fill these mirrors will real information
-  _LocalParameterMirrorImpl(this.isOptional)
-    : super(null, null, false, false) {}
-
-  final bool isOptional;
-
-  TypeMirror get type() => null;
-  String get defaultValue() => null;
-  bool get hasDefaultValue() => null;
-}
-
 class _LocalVariableMirrorImpl extends _LocalMirrorImpl
     implements VariableMirror {
   _LocalVariableMirrorImpl(this.simpleName,
                            this._owner,
                            this.isStatic,
                            this.isFinal) {}
 
   final String simpleName;
 
+  String _qualifiedName = null;
+  String get qualifiedName() {
+    if (_qualifiedName === null) {
+      _qualifiedName = '${owner.qualifiedName}.${simpleName}';
+    }
+    return _qualifiedName;
+  }
+
   var _owner;
-  Mirror get owner() {
+  DeclarationMirror get owner() {
     if (_owner is! Mirror) {
       _owner = _owner.resolve(mirrors);
     }
     return _owner;
   }
 
+  bool get isPrivate() {
+    return simpleName.startsWith('_');
+  }
+
   bool get isTopLevel() {
     return owner is LibraryMirror;
   }
 
+  SourceLocation get location() {
+    throw new NotImplementedException(
+        'MethodMirror.location not yet implemented');
+  }
+
+  TypeMirror get returnType() {
+    throw new NotImplementedException(
+        'MethodMirror.returnType not yet implemented');
+  }
+
   final bool isStatic;
   final bool isFinal;
 
   String toString() {
     return "VariableMirror on '$simpleName'";
   }
 }
 
+class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
+    implements ParameterMirror {
+  // TODO(rmacnak): Fill these mirrors will real information

[cshapiro, 2012/08/21 03:16:05]

Still relevant?  Should this be a TODO(turnidge)?

[turnidge, 2012/08/21 18:00:49]

Will change these unimplemented accessors to throw NotImplemented and drop the
todo.

+  _LocalParameterMirrorImpl(this.isOptional)
+    : super(null, null, false, false) {}
+
+  final bool isOptional;
+
+  TypeMirror get type() => null;
+  String get defaultValue() => null;
+  bool get hasDefaultValue() => null;
+}
+
 class _Mirrors {
   // Does a port refer to our local isolate?
   static bool isLocalPort(SendPort port) native 'Mirrors_isLocalPort';
 
   static MirrorSystem _currentMirrorSystem = null;
 
   // Creates a new local MirrorSystem.
   static MirrorSystem makeLocalMirrorSystem()
       native 'Mirrors_makeLocalMirrorSystem';
 
@@ skipping 23 matching lines @@
 
   // Creates a new local InstanceMirror
   static InstanceMirror makeLocalInstanceMirror(Object reflectee)
       native 'Mirrors_makeLocalInstanceMirror';
 
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
     return makeLocalInstanceMirror(reflectee);
   }
 }