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 344 matching lines @@
 
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
                         this._reflectedType,
                         String simpleName,
-                        this._isGeneric)
+                        this._isGeneric,
+                        this._isMixinTypedef)
       : this._simpleName = _s(simpleName),
         super(reflectee);
 
   final Type _reflectedType;
   final bool _isGeneric;
+  final bool _isMixinTypedef;
 
   bool get hasReflectedType => _reflectedType != null;
   Type get reflectedType {
     if (!hasReflectedType) {
       throw new UnsupportedError(
           "Declarations of generics have no reflected type");
     }
     return _reflectedType;
   }
 
   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 14 matching lines @@
   SourceLocation get location {
     throw new UnimplementedError(
         'ClassMirror.location is not implemented');
   }
 
   // TODO(rmacnak): Remove these left-overs from the days of separate interfaces
   // once we send out a breaking change.
   bool get isClass => true;
   ClassMirror get defaultFactory => null;
 
-  ClassMirror _superclass;
-  ClassMirror get superclass {
-    if (_superclass == null) {
+  ClassMirror _trueSuperclassField;
+  ClassMirror get _trueSuperclass {
+    if (_trueSuperclassField == null) {
       Type supertype = _supertype(_reflectee);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
-      _superclass = _Mirrors._reflectType(supertype);
+      _trueSuperclassField = _Mirrors._reflectType(supertype);
     }
-    return _superclass;
+    return _trueSuperclassField;
+  }
+  ClassMirror get superclass {
+    return _isMixinTypedef ? _trueSuperclass._trueSuperclass : _trueSuperclass;
   }
 
   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) {
+      if (_isMixinTypedef) {
+        _mixin = _trueSuperclass.mixin;
+      } else {
+        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));
+      var whoseMembers = _isMixinTypedef ? _trueSuperclass : this;
+      _members = _makeMemberMap(mixin._computeMembers(whoseMembers._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));
-    }
-    return _constructors;
+      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>();
       var mirror;
       for (var i = 0; i < params.length; i += 2) {
@@ skipping 85 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)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
 
   static _invokeConstructor(reflectee, constructorName, positionalArguments)
       native 'ClassMirror_invokeConstructor';
 
   static _ClassMirror_type_variables(reflectee)
       native "ClassMirror_type_variables";
 
   static _computeTypeArguments(reflectee)
       native "ClassMirror_type_arguments";
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
   _LocalFunctionTypeMirrorImpl(reflectee, reflectedType)
-      : super(reflectee, reflectedType, null, false);
+      : super(reflectee, reflectedType, null, false, false);
 
   // FunctionTypeMirrors have a simpleName generated from their signature.
   Symbol _simpleName = null;
   Symbol get simpleName {
     if (_simpleName == null) {
       _simpleName = _s(_makeSignatureString(returnType, parameters));
     }
     return _simpleName;
   }
 
@@ skipping 33 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;
   }
 }