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 29 matching lines @@
 
   TypeMirror get voidType() {
     if (_voidType === null) {
       _voidType =
           new _LocalClassMirrorImpl(
               null, 'void', false, null, null, [], null, const {});
     }
     return _voidType;
   }
 
-  String toString() {
-    return "MirrorSystem for isolate '$debugName'";
-  }
+  String toString() => "MirrorSystem for isolate '$debugName'";
 }
 
 abstract class _LocalMirrorImpl implements Mirror {
   int hashCode() {
     throw new NotImplementedException('Mirror.hashCode() not yet implemented');
   }
 
   // Local mirrors always return the same MirrorSystem.  This field
   // is more interesting once we implement remote mirrors.
-  MirrorSystem get mirrors() { return _Mirrors.currentMirrorSystem(); }
+  MirrorSystem get mirrors() => _Mirrors.currentMirrorSystem();
 }
 
 class _LocalIsolateMirrorImpl extends _LocalMirrorImpl
     implements IsolateMirror {
   _LocalIsolateMirrorImpl(this.debugName, this._rootLibrary) {}
 
   final String debugName;
   final bool isCurrent = true;
 
   var _rootLibrary;
   LibraryMirror get rootLibrary() {
     if (_rootLibrary is _LazyLibraryMirror) {
       _rootLibrary = _rootLibrary.resolve(mirrors);
     }
     return _rootLibrary;
   }
 
-  String toString() {
-    return "IsolateMirror on '$debugName'";
-  }
+  String toString() => "IsolateMirror on '$debugName'";
 }
 
 // A VMReference is used to hold a reference to a VM-internal object,
 // which can include things like libraries, classes, etc.
 class VMReference extends NativeFieldWrapperClass1 {
 }
 
 abstract class _LocalVMObjectMirrorImpl extends _LocalMirrorImpl {
   _LocalVMObjectMirrorImpl(this._reference) {}
 
@@ skipping 72 matching lines @@
   static _getField(ref, fieldName)
       native 'LocalObjectMirrorImpl_getField';
 
   static _setField(ref, fieldName, value)
       native 'LocalObjectMirrorImpl_setField';
 }
 
 // Prints a string as it might appear in dart program text.
 // TODO(turnidge): Consider truncating.
 String _dartEscape(String str) {
-  bool isNice(int code) {
-    return (code >= 32 && code <= 126);
-  }
+  bool isNice(int code) => (code >= 32 && code <= 126);
 
   StringBuffer buf = new StringBuffer();
   for (int i = 0; i < str.length; i++) {
     var input = str[i];
     String output;
     switch (input) {
       case '\\' :
         output = @'\\';
         break;
       case "\'" :
@@ skipping 66 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() => 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;
   }
 
-  String toString() {
-    return "ClassMirror on '$simpleName'";
+  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 isGenericDeclaration() {
+    throw new NotImplementedException(
+        'ClassMirror.isGenericDeclaration not yet implemented');
+  }
+
+  ClassMirror genericDeclaration() {
+    throw new NotImplementedException(
+        'ClassMirror.genericDeclaration not yet implemented');
+  }
+
+  String toString() => "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;
+
+  // The simple name and the qualified name are the same for a library.
+  String get qualifiedName() => 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'";
-  }
+  String toString() => "LibraryMirror on '$simpleName'";
 }
 
 class _LocalMethodMirrorImpl extends _LocalMirrorImpl
     implements MethodMirror {
   _LocalMethodMirrorImpl(this.simpleName,
                          this._owner,
                          this.parameters,
                          this.isStatic,
                          this.isAbstract,
                          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;
   }
 
+  bool get isPrivate() {
+    return simpleName.startsWith('_') || constructorName.startsWith('_');
+  }
+
+  bool get isTopLevel() =>  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;
 
-  bool get isTopLevel() {
-    return owner is LibraryMirror;
+  final bool isStatic;
+  final bool isAbstract;
+
+  bool get isRegularMethod() => !isGetter && !isSetter && !isConstructor;
+
+  TypeMirror get isOperator() {
+    throw new NotImplementedException(
+        'MethodMirror.isOperator not yet implemented');
   }
 
-  final bool isStatic;
-
-  bool get isMethod() {
-    return !isGetter && !isSetter && !isConstructor;
-  }
-
-  final bool isAbstract;
   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;
+  String toString() => "MethodMirror on '$simpleName'";
 }
 
 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'";
+  String toString() => "VariableMirror 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()  {
+    throw new NotImplementedException(
+        'ParameterMirror.type not yet implemented');
+  }
+
+  String get defaultValue() {
+    throw new NotImplementedException(
+        'ParameterMirror.defaultValue not yet implemented');
+  }
+
+  bool get hasDefaultValue() {
+    throw new NotImplementedException(
+        'ParameterMirror.hasDefaultValue not yet implemented');
   }
 }
 
 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.
@@ skipping 26 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);
   }
 }