Update MirrorSystem

pkg/dartdoc/lib/src/mirrors/dart2js_mirror.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_dart2js;
 
 import 'dart:io';
 import 'dart:uri';
 
 import '../../../../../lib/compiler/compiler.dart' as diagnostics;
@@ skipping 364 matching lines @@
   Future<String> compileToJavaScript() =>
       new Future<String>.immediate(_compiler.assembledCode);
 }
 
 
 //------------------------------------------------------------------------------
 // Dart2Js specific extensions of mirror interfaces
 //------------------------------------------------------------------------------
 
 abstract class Dart2JsMirror implements Mirror {
-  Dart2JsMirrorSystem get system;
+  Dart2JsMirrorSystem get mirrors;
 }
 
 abstract class Dart2JsDeclarationMirror
     implements Dart2JsMirror, DeclarationMirror {
 
   bool get isTopLevel => owner != null && owner is LibraryMirror;
 
   bool get isPrivate => _isPrivate(simpleName);
 }
 
@@ skipping 11 matching lines @@
 
   bool get isStatic => false;
 }
 
 abstract class Dart2JsTypeMirror extends Dart2JsDeclarationMirror
     implements TypeMirror {
 
 }
 
 abstract class Dart2JsElementMirror extends Dart2JsDeclarationMirror {
-  final Dart2JsMirrorSystem system;
+  final Dart2JsMirrorSystem mirrors;
   final Element _element;
 
-  Dart2JsElementMirror(this.system, this._element) {
-    assert (system !== null);
+  Dart2JsElementMirror(this.mirrors, this._element) {
+    assert (mirrors !== null);
     assert (_element !== null);
   }
 
   String get simpleName => _element.name.slowToString();
 
   String get displayName => simpleName;
 
   SourceLocation get location => new Dart2JsLocation(
       _element.getCompilationUnit().script,
-      system.compiler.spanFromElement(_element));
+      mirrors.compiler.spanFromElement(_element));
 
   String toString() => _element.toString();
 
   int get hashCode => qualifiedName.hashCode;
 }
 
 abstract class Dart2JsProxyMirror extends Dart2JsDeclarationMirror {
-  final Dart2JsMirrorSystem system;
+  final Dart2JsMirrorSystem mirrors;
 
-  Dart2JsProxyMirror(this.system);
+  Dart2JsProxyMirror(this.mirrors);
 
   String get displayName => simpleName;
 
   int get hashCode => qualifiedName.hashCode;
 }
 
 //------------------------------------------------------------------------------
 // Mirror system implementation.
 //------------------------------------------------------------------------------
 
 class Dart2JsMirrorSystem implements MirrorSystem, Dart2JsMirror {
   final api.Compiler compiler;
   Map<String, Dart2JsLibraryMirror> _libraries;
   Map<LibraryElement, Dart2JsLibraryMirror> _libraryMap;
 
   Dart2JsMirrorSystem(this.compiler)
     : _libraryMap = new Map<LibraryElement, Dart2JsLibraryMirror>();
 
   void _ensureLibraries() {
     if (_libraries == null) {
       _libraries = <String, Dart2JsLibraryMirror>{};
       compiler.libraries.forEach((_, LibraryElement v) {
-        var mirror = new Dart2JsLibraryMirror(system, v);
+        var mirror = new Dart2JsLibraryMirror(mirrors, v);
         _libraries[mirror.simpleName] = mirror;
         _libraryMap[v] = mirror;
       });
     }
   }
 
   Map<String, LibraryMirror> get libraries {
     _ensureLibraries();
     return new ImmutableMapWrapper<String, LibraryMirror>(_libraries);
   }
 
-  Dart2JsLibraryMirror getLibrary(LibraryElement element) {
-    return _libraryMap[element];
-  }
+  Dart2JsLibraryMirror _getLibrary(LibraryElement element) =>
+      _libraryMap[element];
 
-  Dart2JsMirrorSystem get system => this;
+  Dart2JsMirrorSystem get mirrors => this;
 
-  String get simpleName => "mirror";
-  String get displayName => simpleName;
-  String get qualifiedName => simpleName;
+  TypeMirror get dynamicType =>
+      _convertTypeToTypeMirror(this, compiler.types.dynamicType, null);
 
-  // TODO(johnniwinther): Hack! Dart2JsMirrorSystem need not be a Mirror.
-  int get hashCode => qualifiedName.hashCode;
+  TypeMirror get voidType =>
+      _convertTypeToTypeMirror(this, compiler.types.voidType, null);
 }
 
 abstract class Dart2JsContainerMirror extends Dart2JsElementMirror
     implements ContainerMirror {
   Map<String, MemberMirror> _members;
 
   Dart2JsContainerMirror(Dart2JsMirrorSystem system, Element element)
       : super(system, element);
 
   abstract void _ensureMembers();
@@ skipping 73 matching lines @@
   }
 
   String get qualifiedName => simpleName;
 
   void _ensureClasses() {
     if (_classes == null) {
       _classes = <String, ClassMirror>{};
       _library.forEachLocalMember((Element e) {
         if (e.isClass()) {
           ClassElement classElement = e;
-          classElement.ensureResolved(system.compiler);
+          classElement.ensureResolved(mirrors.compiler);
           var type = new Dart2JsClassMirror.fromLibrary(this, classElement);
           assert(invariant(_library, !_classes.containsKey(type.simpleName),
               message: "Type name '${type.simpleName}' "
                        "is not unique in $_library."));
           _classes[type.simpleName] = type;
         } else if (e.isTypedef()) {
           var type = new Dart2JsTypedefMirror.fromLibrary(this,
-              e.computeType(system.compiler));
+              e.computeType(mirrors.compiler));
           assert(invariant(_library, !_classes.containsKey(type.simpleName),
               message: "Type name '${type.simpleName}' "
                        "is not unique in $_library."));
           _classes[type.simpleName] = type;
         }
       });
     }
   }
 
   void _ensureMembers() {
@@ skipping 73 matching lines @@
                          this.isOptional,
                          this.isNamed)
     : super(system, element);
 
   DeclarationMirror get owner => _method;
 
   VariableElement get _variableElement => _element;
 
   String get qualifiedName => '${_method.qualifiedName}#${simpleName}';
 
-  TypeMirror get type => _convertTypeToTypeMirror(system,
-      _variableElement.computeType(system.compiler),
-      system.compiler.types.dynamicType,
+  TypeMirror get type => _convertTypeToTypeMirror(mirrors,
+      _variableElement.computeType(mirrors.compiler),
+      mirrors.compiler.types.dynamicType,
       _variableElement.variables.functionSignature);
 
 
   bool get isFinal => false;
 
   bool get isConst => false;
 
   String get defaultValue {
     if (hasDefaultValue) {
       SendSet expression = _variableElement.cachedNode.asSendSet();
@@ skipping 20 matching lines @@
                               bool isOptional,
                               bool isNamed)
       : super._normal(system, method, element, isOptional, isNamed);
 
   FieldParameterElement get _fieldParameterElement => _element;
 
   TypeMirror get type {
     if (_fieldParameterElement.variables.cachedNode.type !== null) {
       return super.type;
     }
-    return _convertTypeToTypeMirror(system,
-      _fieldParameterElement.fieldElement.computeType(system.compiler),
-      system.compiler.types.dynamicType,
+    return _convertTypeToTypeMirror(mirrors,
+      _fieldParameterElement.fieldElement.computeType(mirrors.compiler),
+      mirrors.compiler.types.dynamicType,
       _variableElement.variables.functionSignature);
   }
 
   bool get isInitializingFormal => true;
 
   VariableMirror get initializedField => new Dart2JsFieldMirror(
       _method.owner, _fieldParameterElement.fieldElement);
 }
 
 //------------------------------------------------------------------------------
 // Declarations
 //------------------------------------------------------------------------------
 class Dart2JsClassMirror extends Dart2JsContainerMirror
     implements Dart2JsTypeMirror, ClassMirror {
   final Dart2JsLibraryMirror library;
   List<TypeVariableMirror> _typeVariables;
 
   Dart2JsClassMirror(Dart2JsMirrorSystem system, ClassElement _class)
-      : this.library = system.getLibrary(_class.getLibrary()),
+      : this.library = system._getLibrary(_class.getLibrary()),
         super(system, _class);
 
   ClassElement get _class => _element;
 
   Dart2JsClassMirror.fromLibrary(Dart2JsLibraryMirror library,
                                  ClassElement _class)
       : this.library = library,
-        super(library.system, _class);
+        super(library.mirrors, _class);
 
   DeclarationMirror get owner => library;
 
   String get qualifiedName => '${library.qualifiedName}.${simpleName}';
 
   SourceLocation get location {
     if (_class is PartialClassElement) {
-      var node = _class.parseNode(system.compiler);
+      var node = _class.parseNode(mirrors.compiler);
       if (node !== null) {
         var script = _class.getCompilationUnit().script;
-        var span = system.compiler.spanFromNode(node, script.uri);
+        var span = mirrors.compiler.spanFromNode(node, script.uri);
         return new Dart2JsLocation(script, span);
       }
     }
     return super.location;
   }
 
   void _ensureMembers() {
     if (_members == null) {
       _members = <String, Dart2JsMemberMirror>{};
       _class.forEachMember((_, e) {
         for (var member in _convertElementMemberToMemberMirrors(this, e)) {
           assert(!_members.containsKey(member.simpleName));
           _members[member.simpleName] = member;
         }
       });
     }
   }
 
   Map<String, MethodMirror> get methods => functions;
 
   Map<String, MethodMirror> get constructors {
     _ensureMembers();
     return new AsFilteredImmutableMap<String, MemberMirror, MethodMirror>(
         _members, (m) => m.isConstructor ? m : null);
   }
 
-  bool get isObject => _class == system.compiler.objectClass;
+  bool get isObject => _class == mirrors.compiler.objectClass;
 
   bool get isDynamic => false;
 
   bool get isVoid => false;
 
   bool get isTypeVariable => false;
 
   bool get isTypedef => false;
 
   bool get isFunction => false;
 
   ClassMirror get originalDeclaration => this;
 
   ClassMirror get superclass {
     if (_class.supertype != null) {
-      return new Dart2JsInterfaceTypeMirror(system, _class.supertype);
+      return new Dart2JsInterfaceTypeMirror(mirrors, _class.supertype);
     }
     return null;
   }
 
   List<ClassMirror> get superinterfaces {
     var list = <ClassMirror>[];
     Link<DartType> link = _class.interfaces;
     while (!link.isEmpty) {
-      var type = _convertTypeToTypeMirror(system, link.head,
-                                          system.compiler.types.dynamicType);
+      var type = _convertTypeToTypeMirror(mirrors, link.head,
+                                          mirrors.compiler.types.dynamicType);
       list.add(type);
       link = link.tail;
     }
     return list;
   }
 
   bool get isClass => !_class.isInterface();
 
   bool get isInterface => _class.isInterface();
 
   bool get isAbstract => _class.modifiers.isAbstract();
 
   bool get isOriginalDeclaration => true;
 
   List<TypeMirror> get typeArguments {
     throw new UnsupportedError(
         'Declarations do not have type arguments');
   }
 
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       _typeVariables = <TypeVariableMirror>[];
-      _class.ensureResolved(system.compiler);
+      _class.ensureResolved(mirrors.compiler);
       for (TypeVariableType typeVariable in _class.typeVariables) {
         _typeVariables.add(
-            new Dart2JsTypeVariableMirror(system, typeVariable));
+            new Dart2JsTypeVariableMirror(mirrors, typeVariable));
       }
     }
     return _typeVariables;
   }
 
   /**
    * Returns the default type for this interface.
    */
   ClassMirror get defaultFactory {
     if (_class.defaultClass != null) {
-      return new Dart2JsInterfaceTypeMirror(system, _class.defaultClass);
+      return new Dart2JsInterfaceTypeMirror(mirrors, _class.defaultClass);
     }
     return null;
   }
 
   bool operator ==(Object other) {
     if (this === other) {
       return true;
     }
     if (other is! ClassMirror) {
       return false;
     }
     if (library != other.library) {
       return false;
     }
     if (isOriginalDeclaration !== other.isOriginalDeclaration) {
       return false;
     }
     return qualifiedName == other.qualifiedName;
   }
 }
 
 class Dart2JsTypedefMirror extends Dart2JsTypeElementMirror
     implements Dart2JsTypeMirror, TypedefMirror {
   final Dart2JsLibraryMirror _library;
   List<TypeVariableMirror> _typeVariables;
   TypeMirror _definition;
 
   Dart2JsTypedefMirror(Dart2JsMirrorSystem system, TypedefType _typedef)
-      : this._library = system.getLibrary(_typedef.element.getLibrary()),
+      : this._library = system._getLibrary(_typedef.element.getLibrary()),
         super(system, _typedef);
 
   Dart2JsTypedefMirror.fromLibrary(Dart2JsLibraryMirror library,
                                    TypedefType _typedef)
       : this._library = library,
-        super(library.system, _typedef);
+        super(library.mirrors, _typedef);
 
   TypedefType get _typedef => _type;
 
   String get qualifiedName => '${library.qualifiedName}.${simpleName}';
 
   SourceLocation get location {
     var node = _typedef.element.parseNode(_diagnosticListener);
     if (node !== null) {
       var script = _typedef.element.getCompilationUnit().script;
-      var span = system.compiler.spanFromNode(node, script.uri);
+      var span = mirrors.compiler.spanFromNode(node, script.uri);
       return new Dart2JsLocation(script, span);
     }
     return super.location;
   }
 
   LibraryMirror get library => _library;
 
   bool get isTypedef => true;
 
   List<TypeMirror> get typeArguments {
     throw new UnsupportedError(
         'Declarations do not have type arguments');
   }
 
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       _typeVariables = <TypeVariableMirror>[];
       for (TypeVariableType typeVariable in _typedef.typeArguments) {
         _typeVariables.add(
-            new Dart2JsTypeVariableMirror(system, typeVariable));
+            new Dart2JsTypeVariableMirror(mirrors, typeVariable));
       }
     }
     return _typeVariables;
   }
 
   TypeMirror get value {
     if (_definition === null) {
       // TODO(johnniwinther): Should be [ensureResolved].
-      system.compiler.resolveTypedef(_typedef.element);
+      mirrors.compiler.resolveTypedef(_typedef.element);
       _definition = _convertTypeToTypeMirror(
-          system,
+          mirrors,
           _typedef.element.alias,
-          system.compiler.types.dynamicType,
+          mirrors.compiler.types.dynamicType,
           _typedef.element.functionSignature);
     }
     return _definition;
   }
 
   ClassMirror get originalDeclaration => this;
 
   // TODO(johnniwinther): How should a typedef respond to these?
   ClassMirror get superclass => null;
 
@@ skipping 19 matching lines @@
       super(system, typeVariableType) {
       assert(_typeVariableType !== null);
   }
 
 
   String get qualifiedName => '${declarer.qualifiedName}.${simpleName}';
 
   ClassMirror get declarer {
     if (_declarer === null) {
       if (_typeVariableType.element.enclosingElement.isClass()) {
-        _declarer = new Dart2JsClassMirror(system,
+        _declarer = new Dart2JsClassMirror(mirrors,
             _typeVariableType.element.enclosingElement);
       } else if (_typeVariableType.element.enclosingElement.isTypedef()) {
-        _declarer = new Dart2JsTypedefMirror(system,
+        _declarer = new Dart2JsTypedefMirror(mirrors,
             _typeVariableType.element.enclosingElement.computeType(
-                system.compiler));
+                mirrors.compiler));
       }
     }
     return _declarer;
   }
 
   LibraryMirror get library => declarer.library;
 
   DeclarationMirror get owner => declarer;
 
   bool get isTypeVariable => true;
 
   TypeMirror get upperBound => _convertTypeToTypeMirror(
-      system,
+      mirrors,
       _typeVariableType.element.bound,
-      system.compiler.objectClass.computeType(system.compiler));
+      mirrors.compiler.objectClass.computeType(mirrors.compiler));
 
   bool operator ==(Object other) {
     if (this === other) {
       return true;
     }
     if (other is! TypeVariableMirror) {
       return false;
     }
     if (declarer != other.declarer) {
       return false;
@@ skipping 12 matching lines @@
   final DartType _type;
 
   Dart2JsTypeElementMirror(Dart2JsMirrorSystem system, this._type)
     : super(system);
 
   String get simpleName => _type.name.slowToString();
 
   SourceLocation get location {
     var script = _type.element.getCompilationUnit().script;
     return new Dart2JsLocation(script,
-                               system.compiler.spanFromElement(_type.element));
+                               mirrors.compiler.spanFromElement(_type.element));
   }
 
   DeclarationMirror get owner => library;
 
   LibraryMirror get library {
-    return system.getLibrary(_type.element.getLibrary());
+    return mirrors._getLibrary(_type.element.getLibrary());
   }
 
   bool get isObject => false;
 
   bool get isVoid => false;
 
   bool get isDynamic => false;
 
   bool get isTypeVariable => false;
 
@@ skipping 26 matching lines @@
                              InterfaceType interfaceType)
       : super(system, interfaceType);
 
   InterfaceType get _interfaceType => _type;
 
   String get qualifiedName => originalDeclaration.qualifiedName;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   Map<String, MemberMirror> get members => originalDeclaration.members;
 
-  bool get isObject => system.compiler.objectClass == _type.element;
+  bool get isObject => mirrors.compiler.objectClass == _type.element;
 
-  bool get isDynamic => system.compiler.dynamicClass == _type.element;
+  bool get isDynamic => mirrors.compiler.dynamicClass == _type.element;
 
   ClassMirror get originalDeclaration
-      => new Dart2JsClassMirror(system, _type.element);
+      => new Dart2JsClassMirror(mirrors, _type.element);
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   ClassMirror get superclass => originalDeclaration.superclass;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   List<ClassMirror> get superinterfaces => originalDeclaration.superinterfaces;
 
   bool get isClass => originalDeclaration.isClass;
 
   bool get isInterface => originalDeclaration.isInterface;
 
   bool get isAbstract => originalDeclaration.isAbstract;
 
   bool get isPrivate => originalDeclaration.isPrivate;
 
   bool get isOriginalDeclaration => false;
 
   List<TypeMirror> get typeArguments {
     if (_typeArguments == null) {
       _typeArguments = <TypeMirror>[];
       Link<DartType> type = _interfaceType.arguments;
       while (type != null && type.head != null) {
-        _typeArguments.add(_convertTypeToTypeMirror(system, type.head,
-            system.compiler.types.dynamicType));
+        _typeArguments.add(_convertTypeToTypeMirror(mirrors, type.head,
+            mirrors.compiler.types.dynamicType));
         type = type.tail;
       }
     }
     return _typeArguments;
   }
 
   List<TypeVariableMirror> get typeVariables =>
       originalDeclaration.typeVariables;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
@@ skipping 66 matching lines @@
       assert(!map.containsKey(name));
       map[name] = method;
       return new ImmutableMapWrapper<String, MemberMirror>(map);
     }
     return originalDeclaration.members;
   }
 
   bool get isFunction => true;
 
   MethodMirror get callMethod => _convertElementMethodToMethodMirror(
-      system.getLibrary(_functionType.element.getLibrary()),
+      mirrors._getLibrary(_functionType.element.getLibrary()),
       _functionType.element);
 
   ClassMirror get originalDeclaration
-      => new Dart2JsClassMirror(system, system.compiler.functionClass);
+      => new Dart2JsClassMirror(mirrors, mirrors.compiler.functionClass);
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   ClassMirror get superclass => originalDeclaration.superclass;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   List<ClassMirror> get superinterfaces => originalDeclaration.superinterfaces;
 
   bool get isClass => originalDeclaration.isClass;
 
   bool get isInterface => originalDeclaration.isInterface;
 
   bool get isPrivate => originalDeclaration.isPrivate;
 
   bool get isOriginalDeclaration => false;
 
   bool get isAbstract => false;
 
   List<TypeMirror> get typeArguments => const <TypeMirror>[];
 
   List<TypeVariableMirror> get typeVariables =>
       originalDeclaration.typeVariables;
 
   TypeMirror get returnType {
-    return _convertTypeToTypeMirror(system, _functionType.returnType,
-                                    system.compiler.types.dynamicType);
+    return _convertTypeToTypeMirror(mirrors, _functionType.returnType,
+                                    mirrors.compiler.types.dynamicType);
   }
 
   List<ParameterMirror> get parameters {
     if (_parameters === null) {
-      _parameters = _parametersFromFunctionSignature(system, callMethod,
+      _parameters = _parametersFromFunctionSignature(mirrors, callMethod,
                                                      _functionSignature);
     }
     return _parameters;
   }
 }
 
 class Dart2JsVoidMirror extends Dart2JsTypeElementMirror {
 
   Dart2JsVoidMirror(Dart2JsMirrorSystem system, VoidType voidType)
       : super(system, voidType);
@@ skipping 66 matching lines @@
   final Dart2JsContainerMirror _objectMirror;
   String _simpleName;
   String _displayName;
   String _constructorName;
   String _operatorName;
   Dart2JsMethodKind _kind;
 
   Dart2JsMethodMirror(Dart2JsContainerMirror objectMirror,
                       FunctionElement function)
       : this._objectMirror = objectMirror,
-        super(objectMirror.system, function) {
+        super(objectMirror.mirrors, function) {
     _simpleName = _element.name.slowToString();
     if (_function.kind == ElementKind.GETTER) {
       _kind = Dart2JsMethodKind.GETTER;
       _displayName = _simpleName;
     } else if (_function.kind == ElementKind.SETTER) {
       _kind = Dart2JsMethodKind.SETTER;
       _displayName = _simpleName;
       _simpleName = '$_simpleName=';
     } else if (_function.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       _constructorName = '';
@@ skipping 62 matching lines @@
       => _kind == Dart2JsMethodKind.CONSTRUCTOR || isConst || isFactory;
 
   bool get isMethod => !isConstructor;
 
   bool get isPrivate =>
       isConstructor ? _isPrivate(constructorName) : _isPrivate(simpleName);
 
   bool get isStatic => _function.modifiers.isStatic();
 
   List<ParameterMirror> get parameters {
-    return _parametersFromFunctionSignature(system, this,
-        _function.computeSignature(system.compiler));
+    return _parametersFromFunctionSignature(mirrors, this,
+        _function.computeSignature(mirrors.compiler));
   }
 
   TypeMirror get returnType => _convertTypeToTypeMirror(
-      system, _function.computeSignature(system.compiler).returnType,
-      system.compiler.types.dynamicType);
+      mirrors, _function.computeSignature(mirrors.compiler).returnType,
+      mirrors.compiler.types.dynamicType);
 
   bool get isAbstract => _function.modifiers.isAbstract();
 
   bool get isConst => _kind == Dart2JsMethodKind.CONST;
 
   bool get isFactory => _kind == Dart2JsMethodKind.FACTORY;
 
   String get constructorName => _constructorName;
 
   bool get isGetter => _kind == Dart2JsMethodKind.GETTER;
 
   bool get isSetter => _kind == Dart2JsMethodKind.SETTER;
 
   bool get isOperator => _kind == Dart2JsMethodKind.OPERATOR;
 
   String get operatorName => _operatorName;
 
   SourceLocation get location {
     var node = _function.parseNode(_diagnosticListener);
     if (node !== null) {
       var script = _function.getCompilationUnit().script;
-      var span = system.compiler.spanFromNode(node, script.uri);
+      var span = mirrors.compiler.spanFromNode(node, script.uri);
       return new Dart2JsLocation(script, span);
     }
     return super.location;
   }
 
 }
 
 class Dart2JsFieldMirror extends Dart2JsMemberMirror implements VariableMirror {
   Dart2JsContainerMirror _objectMirror;
   VariableElement _variable;
 
   Dart2JsFieldMirror(Dart2JsContainerMirror objectMirror,
                      VariableElement variable)
       : this._objectMirror = objectMirror,
         this._variable = variable,
-        super(objectMirror.system, variable);
+        super(objectMirror.mirrors, variable);
 
   String get qualifiedName
       => '${owner.qualifiedName}.$simpleName';
 
   DeclarationMirror get owner => _objectMirror;
 
   bool get isTopLevel => _objectMirror is LibraryMirror;
 
   bool get isField => true;
 
   bool get isStatic => _variable.modifiers.isStatic();
 
   bool get isFinal => _variable.modifiers.isFinal();
 
   bool get isConst => _variable.modifiers.isConst();
 
-  TypeMirror get type => _convertTypeToTypeMirror(system,
-      _variable.computeType(system.compiler),
-      system.compiler.types.dynamicType);
+  TypeMirror get type => _convertTypeToTypeMirror(mirrors,
+      _variable.computeType(mirrors.compiler),
+      mirrors.compiler.types.dynamicType);
 
   SourceLocation get location {
     var script = _variable.getCompilationUnit().script;
     var node = _variable.variables.parseNode(_diagnosticListener);
     if (node !== null) {
-      var span = system.compiler.spanFromNode(node, script.uri);
+      var span = mirrors.compiler.spanFromNode(node, script.uri);
       return new Dart2JsLocation(script, span);
     } else {
-      var span = system.compiler.spanFromElement(_variable);
+      var span = mirrors.compiler.spanFromElement(_variable);
       return new Dart2JsLocation(script, span);
     }
   }
 }