ClassMirror.mixin

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.
 
 import "dart:collection";
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
@@ skipping 356 matching lines @@
         super(reflectee);
 
   final Type _reflectedType;
   final bool _isGeneric;
 
   Symbol _simpleName;
   Symbol get simpleName {
     // dynamic, void and the function types have their names set eagerly in the
     // constructor.
     if(_simpleName == null) {
-      _simpleName = _s(_name(_reflectee));
+      var simpleString = _name(_reflectee);
+      if (simpleString.contains('&')) {
+        _simpleName = this._computeMixinApplicationName;
+      } else {
+        _simpleName = _s(simpleString);
+      }
     }
     return _simpleName;
   }
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
@@ skipping 22 matching lines @@
   ClassMirror get defaultFactory => null;
 
   ClassMirror _superclass;
   ClassMirror get superclass {
     if (_superclass == null) {
       Type supertype = _supertype(_reflectee);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
-      _superclass = reflectClass(supertype);
+      _superclass = _Mirrors._reflectType(supertype);
     }
     return _superclass;
   }
 
   var _superinterfaces;
   List<ClassMirror> get superinterfaces {
     if (_superinterfaces == null) {
       _superinterfaces = _interfaces(_reflectee)
-          .map((i) => reflectClass(i)).toList(growable:false);
+          .map((i) => _Mirrors._reflectType(i)).toList(growable:false);
     }
     return _superinterfaces;
   }
 
+  get _computeMixinApplicationName {
+    var mixins = new List<ClassMirror>();
+    var klass = this;
+    while (_computeMixin(klass._reflectee) != null) {
+      mixins.add(klass.mixin);
+      klass = klass.superclass;
+    }
+    return _s(
+      _n(klass.qualifiedName) 
+      + ' with '
+      + mixins.reversed.map((m)=>_n(m.qualifiedName)).join(', '));
+  }
+
+  var _mixin;
+  ClassMirror get mixin {
+    if (_mixin == null) {
+      var mixinType = _computeMixin(_reflectee);
+      if (mixinType == null) {
+        // The reflectee is not a mixin application.
+        _mixin = this;
+      } else {
+        _mixin = _Mirrors._reflectType(mixinType);
+      }
+    }
+    return _mixin;
+  }
+
   Map<Symbol, Mirror> _members;
 
   Map<Symbol, Mirror> get members {
     if (_members == null) {
-      _members = _makeMemberMap(_computeMembers(_reflectee));
+      _members = _makeMemberMap(mixin._computeMembers(_reflectee));
     }
     return _members;
   }
 
   Map<Symbol, MethodMirror> _methods = null;
   Map<Symbol, MethodMirror> _getters = null;
   Map<Symbol, MethodMirror> _setters = null;
   Map<Symbol, VariableMirror> _variables = null;
 
   Map<Symbol, MethodMirror> get methods {
@@ skipping 29 matching lines @@
           members,
           (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
   Map<Symbol, MethodMirror> _constructors;
 
   Map<Symbol, MethodMirror> get constructors {
     if (_constructors == null) {
-      _constructors = _makeMemberMap(_computeConstructors(_reflectee));
+      var constructorsList = _computeConstructors(_reflectee);
+      var stringName = _n(simpleName);
+      constructorsList.forEach((c) => c._patchConstructorName(stringName));
+      _constructors = _makeMemberMap(constructorsList);
     }
     return _constructors;
   }
 
   Map<Symbol, TypeVariableMirror> _typeVariables = null;
 
   Map<Symbol, TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       List params = _ClassMirror_type_variables(_reflectee);
       _typeVariables = new LinkedHashMap<Symbol, TypeVariableMirror>();
@@ skipping 87 matching lines @@
 
   static _library(reflectee)
       native "ClassMirror_library";
 
   static _supertype(reflectee)
       native "ClassMirror_supertype";
 
   static _interfaces(reflectee)
       native "ClassMirror_interfaces";
 
+  static _computeMixin(reflectee)
+      native "ClassMirror_mixin";
+
   _computeMembers(reflectee)
       native "ClassMirror_members";
   
   _computeConstructors(reflectee)
       native "ClassMirror_constructors";
 
   _invoke(reflectee, memberName, positionalArguments)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
@@ skipping 62 matching lines @@
 
   static Type _FunctionTypeMirror_return_type(reflectee)
       native "FunctionTypeMirror_return_type";
 
   List<ParameterMirror> _FunctionTypeMirror_parameters(reflectee)
       native "FunctionTypeMirror_parameters";
 }
 
 abstract class _LocalDeclarationMirrorImpl extends _LocalMirrorImpl
     implements DeclarationMirror {
-  _LocalDeclarationMirrorImpl(this._reflectee, this.simpleName);
+  _LocalDeclarationMirrorImpl(this._reflectee, this._simpleName);
 
   final _reflectee;
 
-  final Symbol simpleName;
+  Symbol _simpleName;
+  Symbol get simpleName => _simpleName;
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
   List<InstanceMirror> get metadata {
@@ skipping 307 matching lines @@
         } else if (parts.length == 2) {
           _constructorName = _s(parts[1]);
         } else {
           _constructorName = _s('');
         }
       }
     }
     return _constructorName;
   }
 
+  void _patchConstructorName(ownerName) {
+    var cn = _n(constructorName);
+    if(cn == ''){
+      _simpleName = _s(ownerName);
+    } else {
+      _simpleName = _s(ownerName + "." + cn);
+    }
+  }
+
   String toString() => "MethodMirror on '${_n(simpleName)}'";
 
   static dynamic _MethodMirror_owner(reflectee)
       native "MethodMirror_owner";
 
   static dynamic _MethodMirror_return_type(reflectee)
       native "MethodMirror_return_type";
 
   List<ParameterMirror> _MethodMirror_parameters(reflectee)
       native "MethodMirror_parameters";
@@ skipping 190 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }