Align source mirrors with runtime mirrors.

sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.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.
 
 library mirrors_util;
 
 import 'dart:collection' show Queue, IterableBase;
 
-// TODO(rnystrom): Use "package:" URL (#4968).
-import 'mirrors.dart';
+import 'source_mirrors.dart';
 
 //------------------------------------------------------------------------------
 // Utility functions for using the Mirror API
 //------------------------------------------------------------------------------
 
+String nameOf(DeclarationMirror mirror) =>
+    MirrorSystem.getName(mirror.simpleName);
+
+String qualifiedNameOf(DeclarationMirror mirror) =>
+    MirrorSystem.getName(mirror.qualifiedName);
+
+// TODO(johnniwinther): Handle private names.
+Symbol symbolOf(String name, LibraryMirror library) => new Symbol(name);
 
 /**
  * Return the display name for [mirror].
  *
  * The display name is the normal representation of the entity name. In most
  * cases the display name is the simple name, but for a setter 'foo=' the
  * display name is simply 'foo' and for the unary minus operator the display
  * name is 'operator -'. For 'dart:' libraries the display name is the URI and
  * not the library name, for instance 'dart:core' instead of 'dart.core'.
  *
  * The display name is not unique.
  */
 String displayName(DeclarationMirror mirror) {
   if (mirror is LibraryMirror) {
     LibraryMirror library = mirror;
     if (library.uri.scheme == 'dart') {
       return library.uri.toString();
     }
   } else if (mirror is MethodMirror) {
-    MethodMirror methodMirror = mirror;
-    String simpleName = methodMirror.simpleName;
-    if (methodMirror.isSetter) {
+    String simpleName = nameOf(mirror);
+    if (mirror.isSetter) {
       // Remove trailing '='.
       return simpleName.substring(0, simpleName.length-1);
-    } else if (methodMirror.isOperator) {
-      return 'operator ${operatorName(methodMirror)}';
-    } else if (methodMirror.isConstructor) {
-      String className = displayName(methodMirror.owner);
+    } else if (mirror.isOperator) {
+      return 'operator ${operatorName(mirror)}';
+    } else if (mirror.isConstructor) {
+      String className = displayName(mirror.owner);
       if (simpleName == '') {
         return className;
       } else {
         return '$className.$simpleName';
       }
     }
   }
-  return mirror.simpleName;
+  return MirrorSystem.getName(mirror.simpleName);
 }
 
 /**
  * Returns the operator name if [methodMirror] is an operator method,
  * for instance [:'<':] for [:operator <:] and [:'-':] for the unary minus
  * operator. Return [:null:] if [methodMirror] is not an operator method.
  */
 String operatorName(MethodMirror methodMirror) {
-  String simpleName = methodMirror.simpleName;
   if (methodMirror.isOperator) {
-    if (simpleName == Mirror.UNARY_MINUS) {
+    if (methodMirror.simpleName == const Symbol('unary-')) {
       return '-';
     } else {
-      return simpleName;
+      return nameOf(methodMirror);
     }
   }
   return null;
 }
 
 /**
  * Returns an iterable over the type declarations directly inheriting from
- * the declaration of this type.
+ * the declaration of [type] within [mirrors].
  */
-Iterable<ClassMirror> computeSubdeclarations(ClassMirror type) {
+Iterable<ClassMirror> computeSubdeclarations(MirrorSystem mirrors,
+                                             ClassMirror type) {
   type = type.originalDeclaration;
   var subtypes = <ClassMirror>[];
-  type.mirrors.libraries.forEach((_, library) {
-    for (ClassMirror otherType in library.classes.values) {
+  mirrors.libraries.forEach((_, library) {
+    library.declarations.values
+        .where((mirror) => mirror is ClassMirror)
+        .forEach((ClassMirror otherType) {
       var superClass = otherType.superclass;
       if (superClass != null) {
         superClass = superClass.originalDeclaration;
-        if (type.library == superClass.library) {
-          if (superClass == type) {
-             subtypes.add(otherType);
-          }
+        if (superClass == type) {
+          subtypes.add(otherType);
         }
       }
       final superInterfaces = otherType.superinterfaces;
       for (ClassMirror superInterface in superInterfaces) {
         superInterface = superInterface.originalDeclaration;
-        if (type.library == superInterface.library) {
-          if (superInterface == type) {
-            subtypes.add(otherType);
-          }
+        if (superInterface == type) {
+          subtypes.add(otherType);
         }
       }
-    }
+    });
   });
   return subtypes;
 }
 
-LibraryMirror findLibrary(MemberMirror member) {
-  DeclarationMirror owner = member.owner;
-  if (owner is LibraryMirror) {
-    return owner;
-  } else if (owner is TypeMirror) {
-    TypeMirror mirror = owner;
-    return mirror.library;
-  }
-  throw new Exception('Unexpected owner: ${owner}');
-}
-
 class HierarchyIterable extends IterableBase<ClassMirror> {
   final bool includeType;
   final ClassMirror type;
 
   HierarchyIterable(this.type, {bool includeType})
       : this.includeType = includeType;
 
   Iterator<ClassMirror> get iterator =>
       new HierarchyIterator(type, includeType: includeType);
 }
@@ skipping 15 matching lines @@
   HierarchyIterator(ClassMirror type, {bool includeType}) {
     if (includeType) {
       queue.add(type);
     } else {
       push(type);
     }
   }
 
   ClassMirror push(ClassMirror type) {
     if (type.superclass != null) {
-      if (type.superclass.isObject) {
+      if (isObject(type.superclass)) {
         object = type.superclass;
       } else {
         queue.addFirst(type.superclass);
       }
     }
     queue.addAll(type.superinterfaces);
     return type;
   }
 
   ClassMirror get current => _current;
 
   bool moveNext() {
     _current = null;
     if (queue.isEmpty) {
       if (object == null) return false;
       _current = object;
       object = null;
       return true;
     } else {
       _current = push(queue.removeFirst());
       return true;
     }
   }
 }
 
+LibraryMirror getLibrary(DeclarationMirror declaration) {
+  while (declaration != null && declaration is! LibraryMirror) {
+    declaration = declaration.owner;
+  }
+  return declaration;
+}
+
+Iterable<DeclarationMirror> membersOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where(
+      (mirror) => mirror is MethodMirror || mirror is VariableMirror);
+}
+
+Iterable<TypeMirror> classesOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where((mirror) => mirror is ClassMirror);
+}
+
+Iterable<TypeMirror> typesOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where((mirror) => mirror is TypeMirror);
+}
+
+Iterable<MethodMirror> methodsOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where(
+      (mirror) => mirror is MethodMirror && mirror.isRegularMethod);
+}
+
+Iterable<MethodMirror> constructorsOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where(
+      (mirror) => mirror is MethodMirror && mirror.isConstructor);
+}
+
+Iterable<MethodMirror> settersOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where(
+      (mirror) => mirror is MethodMirror && mirror.isSetter);
+}
+
+Iterable<MethodMirror> gettersOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where(
+      (mirror) => mirror is MethodMirror && mirror.isGetter);
+}
+
+Iterable<VariableMirror> variablesOf(
+    Map<Symbol, DeclarationMirror> declarations) {
+  return declarations.values.where((mirror) => mirror is VariableMirror);
+}
+
+
+
+bool isObject(TypeMirror mirror) =>
+    mirror is ClassMirror && mirror.superclass == null;
+
 bool isMixinApplication(Mirror mirror) {
   return mirror is ClassMirror && mirror.mixin != mirror;
 }
 
 /**
  * Returns the superclass of [cls] skipping unnamed mixin applications.
  *
  * For instance, for all of the following definitions this method returns [:B:].
  *
  *     class A extends B {}
  *     class A extends B with C1, C2 {}
  *     class A extends B implements D1, D2 {}
  *     class A extends B with C1, C2 implements D1, D2 {}
  *     class A = B with C1, C2;
  *     abstract class A = B with C1, C2 implements D1, D2;
  */
-ClassMirror getSuperclass(ClassMirror cls) {
-  ClassMirror superclass = cls.superclass;
+ClassSourceMirror getSuperclass(ClassSourceMirror cls) {
+  ClassSourceMirror superclass = cls.superclass;
   while (isMixinApplication(superclass) && superclass.isNameSynthetic) {
     superclass = superclass.superclass;
   }
   return superclass;
 }
 
 /**
  * Returns the mixins directly applied to [cls].
  *
  * For instance, for all of the following definitions this method returns
  * [:C1, C2:].
  *
  *     class A extends B with C1, C2 {}
  *     class A extends B with C1, C2 implements D1, D2 {}
  *     class A = B with C1, C2;
  *     abstract class A = B with C1, C2 implements D1, D2;
  */
-Iterable<ClassMirror> getAppliedMixins(ClassMirror cls) {
-  List<ClassMirror> mixins = <ClassMirror>[];
-  ClassMirror superclass = cls.superclass;
+Iterable<ClassSourceMirror> getAppliedMixins(ClassSourceMirror cls) {
+  List<ClassSourceMirror> mixins = <ClassSourceMirror>[];
+  ClassSourceMirror superclass = cls.superclass;
   while (isMixinApplication(superclass) && superclass.isNameSynthetic) {
     mixins.add(superclass.mixin);
     superclass = superclass.superclass;
   }
   if (mixins.length > 1) {
-    mixins = new List<ClassMirror>.from(mixins.reversed);
+    mixins = new List<ClassSourceMirror>.from(mixins.reversed);
   }
   if (isMixinApplication(cls)) {
     mixins.add(cls.mixin);
   }
   return mixins;
 }
 
 /**
  * Returns the superinterfaces directly and explicitly implemented by [cls].
  *
@@ skipping 70 matching lines @@
  * If [name] is of the form 'a.b.c', 'a' is looked up in the scope of
  * [declaration] and if unresolved 'a.b' is looked in the scope of
  * [declaration]. Each identifier of the remaining suffix, 'c' or 'b.c', is
  * then looked up in the local scope of the previous result.
  *
  * For instance, assumming that [:Iterable:] is imported into the scope of
  * [declaration] via the prefix 'col', 'col.Iterable.E' finds the type
  * variable of [:Iterable:] and 'col.Iterable.contains.element' finds the
  * [:element:] parameter of the [:contains:] method on [:Iterable:].
  */
-DeclarationMirror lookupQualifiedInScope(DeclarationMirror declaration,
+DeclarationMirror lookupQualifiedInScope(DeclarationSourceMirror declaration,
                                          String name) {
   // TODO(11653): Support lookup of constructors using the [:new Foo:]
   // syntax.
   int offset = 1;
   List<String> parts = name.split('.');
   DeclarationMirror result = declaration.lookupInScope(parts[0]);
   if (result == null && parts.length > 1) {
     // Try lookup of `prefix.id`.
     result = declaration.lookupInScope('${parts[0]}.${parts[1]}');
     offset = 2;
   }
   if (result == null) return null;
+  LibraryMirror library = getLibrary(result);
   while (result != null && offset < parts.length) {
-    result = _lookupLocal(result, parts[offset++]);
+    result = _lookupLocal(result, symbolOf(parts[offset++], library));
   }
   return result;
 }
 
-DeclarationMirror _lookupLocal(Mirror mirror, String id) {
+DeclarationMirror _lookupLocal(Mirror mirror, Symbol id) {
   DeclarationMirror result;
-  if (mirror is ContainerMirror) {
-    ContainerMirror containerMirror = mirror;
+  if (mirror is LibraryMirror) {
     // Try member lookup.
-    result = containerMirror.members[id];
-  }
-  if (result != null) return result;
-  if (mirror is ClassMirror) {
-    ClassMirror classMirror = mirror;
+    result = mirror.declarations[id];

[floitsch, 2014/01/28 19:21:53]

You are already returning from the middle of the second if-block.
Make it more explicit that you don't expect to reach the bottom of the function
by returning immediately here too.

if (mirror is LibraryMirror) return mirror.declarations[id];
if (mirror is MethodMirror) {
  return mirror.parameters.firstWhere(...);
}
// Try member lookup.
...

+  } else if (mirror is ClassMirror) {
+    // Try member lookup.
+    result = mirror.declarations[id];
+    if (result != null) return result;
     // Try type variables.
-    result = classMirror.typeVariables.firstWhere(
+    result = mirror.typeVariables.firstWhere(
         (TypeVariableMirror v) => v.simpleName == id, orElse: () => null);
   } else if (mirror is MethodMirror) {
-    MethodMirror methodMirror = mirror;
-    result = methodMirror.parameters.firstWhere(
+    result = mirror.parameters.firstWhere(
         (ParameterMirror p) => p.simpleName == id, orElse: () => null);
   }
   return result;
 
 }