Make ClassMirror.typeVariables lazy and convert dependencies to native code.

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) {
   return (value == null || value is num || value is String || value is bool);
 }
 
 Map _filterMap(Map<Symbol, dynamic> old_map, bool filter(Symbol key, value)) {
   Map new_map = new Map<Symbol, dynamic>();
   old_map.forEach((key, value) {
     if (filter(key, value)) {
       new_map[key] = value;
@@ skipping 372 matching lines @@
     return resolved;
   }
 
   final String libraryUrl;
   final Symbol typeName;
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
-                        String simpleName,
-                        Map<String, Mirror> typeVariables)
+                        String simpleName)
       : this._simpleName = _s(simpleName),
-        this.typeVariables = _convertStringToSymbolMap(typeVariables),
         super(reflectee);
 
   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));
     }
     return _simpleName;
@@ skipping 106 matching lines @@
 
   Map<Symbol, MethodMirror> _constructors;
 
   Map<Symbol, MethodMirror> get constructors {
     if (_constructors == null) {
       _constructors = _makeMemberMap(_computeConstructors(_reflectee));
     }
     return _constructors;
   }
 
-  Map<Symbol, TypeVariableMirror> typeVariables;
+  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) {
+        mirror = new _LocalTypeVariableMirrorImpl(
+            params[i + 1], params[i], this);
+        _typeVariables[mirror.simpleName] = mirror;
+      }
+    }
+    return _typeVariables;
+  }
 
   Map<Symbol, TypeMirror> get typeArguments {
     throw new UnimplementedError(
         'ClassMirror.typeArguments is not implemented');
   }
 
   bool get isOriginalDeclaration {
     throw new UnimplementedError(
         'ClassMirror.isOriginalDeclaration is not implemented');
   }
@@ skipping 65 matching lines @@
       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";
 }
 
 class _LazyFunctionTypeMirror {
   _LazyFunctionTypeMirror(this.reflectee, this.returnType, this.parameters) {}
 
   ClassMirror resolve(MirrorSystem mirrors) {
     return mirrors._lookupFunctionTypeMirror(reflectee,
                                              returnType.resolve(mirrors),
                                              parameters);
   }
 
   final reflectee;
   final returnType;
   final List<ParameterMirror> parameters;
 }
 
 class _LocalFunctionTypeMirrorImpl extends _LocalClassMirrorImpl
     implements FunctionTypeMirror {
   _LocalFunctionTypeMirrorImpl(reflectee,
                                simpleName,
                                this._returnType,
                                this.parameters)
       : super(reflectee,
-              simpleName,
-              const {});
+              simpleName);
 
   Map<Symbol, Mirror> get members => new Map<Symbol,Mirror>();
   Map<Symbol, MethodMirror> get constructors => new Map<Symbol,MethodMirror>();
 
   var _returnType;
   TypeMirror get returnType {
     if (_returnType is! Mirror) {
       _returnType = _returnType.resolve(mirrors);
     }
     return _returnType;
   }
 
   final List<ParameterMirror> parameters;
+  final Map<Symbol, TypeVariableMirror> typeVariables = const {};
 
   String toString() => "FunctionTypeMirror on '${_n(simpleName)}'";
 }
 
 abstract class _LocalDeclarationMirrorImpl extends _LocalMirrorImpl
     implements DeclarationMirror {
     _LocalDeclarationMirrorImpl(this._reflectee);
-    final _MirrorReference _reflectee;
+    final _reflectee;
 
     List<InstanceMirror> get metadata {
       // Get the metadata objects, convert them into InstanceMirrors using
       // reflect() and then make them into a Dart list.
       return _metadata(_reflectee).map(reflect).toList(growable:false);
     }
 }
 
 class _LazyTypeVariableMirror {
   _LazyTypeVariableMirror(String variableName, this._owner)
       : this._variableName = _s(variableName);
 
   TypeVariableMirror resolve(MirrorSystem mirrors) {
     ClassMirror owner = _owner.resolve(mirrors);
     return owner.typeVariables[_variableName];
   }
 
   final Symbol _variableName;
   final _LazyTypeMirror _owner;
 }
 
 class _LocalTypeVariableMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypeVariableMirror {
   _LocalTypeVariableMirrorImpl(reflectee,
                                String simpleName,
-                               this._owner,
-                               this._upperBound)
+                               this._owner)
       : this.simpleName = _s(simpleName),
         super(reflectee);
 
   final Symbol simpleName;
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
   var _owner;
   DeclarationMirror get owner {
+    if (_owner == null) {
+      _owner = _LocalTypeVariableMirror_owner(_reflectee);
+    }
+    // TODO(11897): This will go away, as soon as lazy mirrors go away.
     if (_owner is! Mirror) {
       _owner = _owner.resolve(mirrors);
     }
     return _owner;
   }
 
   bool get isPrivate => false;
 
   final bool isTopLevel = false;
 
   SourceLocation get location {
     throw new UnimplementedError(
         'TypeVariableMirror.location is not implemented');
   }
 
-  var _upperBound;
+  TypeMirror _upperBound = null;
   TypeMirror get upperBound {
-    if (_upperBound is! Mirror) {
-      _upperBound = _upperBound.resolve(mirrors);
+    if (_upperBound == null) {
+      _upperBound = _LocalTypeVariableMirror_upper_bound(_reflectee);
     }
     return _upperBound;
   }
 
   List<InstanceMirror> get metadata {
     throw new UnimplementedError(
         'TypeVariableMirror.metadata is not implemented');
   }
 
   String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
+
+  static DeclarationMirror _LocalTypeVariableMirror_owner(reflectee)
+      native "LocalTypeVariableMirror_owner";
+
+  static TypeMirror _LocalTypeVariableMirror_upper_bound(reflectee)
+      native "LocalTypeVariableMirror_upper_bound";
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalDeclarationMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(reflectee,
                           String simpleName,
                           this._owner,
                           this._referent)
       : this.simpleName = _s(simpleName),
@@ skipping 472 matching lines @@
   static Expando<ClassMirror> _classMirrorCache = new Expando("ClassMirror");
   static ClassMirror reflectClass(Type key) {
     var classMirror = _classMirrorCache[key];
     if (classMirror == null) {
       classMirror = makeLocalClassMirror(key);
       _classMirrorCache[key] = classMirror;
     }
     return classMirror;
   }
 }