Reapply "Substitute types in generic superclasses and interfaces." .

sdk/lib/_internal/lib/js_mirrors.dart

 // Copyright (c) 2013, 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 dart._js_mirrors;
 
 import 'dart:async';
 import 'dart:collection' show UnmodifiableListView;
 import 'dart:mirrors';
 
@@ skipping 189 matching lines @@
     code ^= 17 * simpleName.hashCode;
     code ^= 19 * owner.hashCode;
     return code;
   }
 
   String get _prettyName => 'TypeVariableMirror';
 
   TypeMirror get upperBound {
     if (_cachedUpperBound != null) return _cachedUpperBound;
     return _cachedUpperBound = typeMirrorFromRuntimeTypeRepresentation(
-        JS('', 'init.metadata[#]', _typeVariable.bound));
+        owner, getMetadata(_typeVariable.bound));
   }
 }
 
 class JsTypeMirror extends JsDeclarationMirror implements TypeMirror {
   JsTypeMirror(Symbol simpleName)
       : super(simpleName);
 
   String get _prettyName => 'TypeMirror';
 
   DeclarationMirror get owner => null;
@@ skipping 274 matching lines @@
         // Remove the angle brackets enclosing the type arguments.
         mangledName.substring(typeArgIndex + 1, mangledName.length - 1));
     JsCache.update(classMirrors, mangledName, mirror);
     return mirror;
   }
   var constructorOrInterceptor =
       Primitives.getConstructorOrInterceptor(mangledName);
   if (constructorOrInterceptor == null) {
     int index = JS('int|Null', 'init.functionAliases[#]', mangledName);
     if (index != null) {
-      mirror = new JsTypedefMirror(
-          symbol, mangledName, JS('=Object', 'init.metadata[#]', index));
+      mirror = new JsTypedefMirror(symbol, mangledName, getMetadata(index));
       JsCache.update(classMirrors, mangledName, mirror);
       return mirror;
     }
     // Probably an intercepted class.
     // TODO(ahe): How to handle intercepted classes?
     throw new UnsupportedError('Cannot find class for: ${n(symbol)}');
   }
   var constructor = (constructorOrInterceptor is Interceptor)
       ? JS('', '#.constructor', constructorOrInterceptor)
       : constructorOrInterceptor;
@@ skipping 224 matching lines @@
       String mangledName =
           JS('String|Null', '#[#]', methodsWithOptionalArguments, '*$name');
       if (mangledName == null) {
         // TODO(ahe): Invoke noSuchMethod.
         throw new UnimplementedNoSuchMethodError(
             'Invoking noSuchMethod with named arguments not implemented');
       }
       var defaultValueIndices =
           JS('List|Null', '#[#].\$defaultValues', reflectee, mangledName);
       var defaultValues =
-          defaultValueIndices.map((int i) => JS('', 'init.metadata[#]', i))
+          defaultValueIndices.map((int i) => getMetadata(i))
           .iterator;
       var defaultArguments = new Map();
       reflectiveName = mangledNames[mangledName];
       var reflectiveNames = reflectiveName.split(':');
       int requiredPositionalArgumentCount =
           int.parse(reflectiveNames.elementAt(1));
       positionalArguments = new List.from(positionalArguments);
       // Check the number of positional arguments is valid.
       if (requiredPositionalArgumentCount != positionalArguments.length) {
         // TODO(ahe): Invoke noSuchMethod.
@@ skipping 113 matching lines @@
  * to JsCLassMirror that returns an empty list since it represents original
  * declarations and classes that are not generic.
  */
 class JsTypeBoundClassMirror extends JsDeclarationMirror implements ClassMirror {
   final JsClassMirror _class;
 
   /**
    * When instantiated this field will hold a string representing the list of
    * type arguments for the class, i.e. what is inside the outermost angle
    * brackets. Then, when get typeArguments is called the first time, the string
-   * is parsed into the actual list of TypeMirrors, and the field is overridden
-   * with this value.
+   * is parsed into the actual list of TypeMirrors, and stored in
+   * [_cachedTypeArguments]. Due to type substitution of for instance
+   * superclasses the mangled name of the class and hence this string is needed
+   * after [_cachedTypeArguments] has been computed.
    *
    * If an integer is encountered as a type argument, it represents the type
    * variable at the corresponding entry in [emitter.globalMetadata].
    */
-  var _typeArguments;
+  String _typeArguments;
 
+  UnmodifiableListView<TypeMirror> _cachedTypeArguments;
   Map<Symbol, VariableMirror> _cachedVariables;
   Map<Symbol, MethodMirror> _cachedGetters;
   Map<Symbol, MethodMirror> _cachedSetters;
   Map<Symbol, MethodMirror> _cachedMethodsMap;
   List<JsMethodMirror> _cachedMethods;
+  ClassMirror _superclass;
+  List<ClassMirror> _cachedSuperinterfaces;
 
   JsTypeBoundClassMirror(JsClassMirror originalDeclaration, this._typeArguments)
-      : _class = originalDeclaration, 
+      : _class = originalDeclaration,
         super(originalDeclaration.simpleName);
 
   String get _prettyName => 'ClassMirror';
-  
+  String get _mangledName => '${_class._mangledName}<$_typeArguments>';
+
   List<TypeVariableMirror> get typeVariables => _class.typeVariables;
 
   List<TypeMirror> get typeArguments {
-    if (_typeArguments is! String) return _typeArguments;
+    if (_cachedTypeArguments != null) return _cachedTypeArguments;
     List result = new List();
 
     addTypeArgument(String typeArgument) {
       int parsedIndex = int.parse(typeArgument, onError: (_) => -1);
       if (parsedIndex == -1) {
         result.add(reflectClassByMangledName(typeArgument.trim()));
       } else {
-        TypeVariable typeVariable = JS('', 'init.metadata[#]', parsedIndex);
+        TypeVariable typeVariable = getMetadata(parsedIndex);
         TypeMirror owner = reflectClass(typeVariable.owner);
         TypeVariableMirror typeMirror =
             new JsTypeVariableMirror(typeVariable, owner);
         result.add(typeMirror);
       }
     }
 
     if (_typeArguments.indexOf('<') == -1) {
       _typeArguments.split(',').forEach((t) => addTypeArgument(t));
     } else {
@@ skipping 16 matching lines @@
           } else {
             addTypeArgument(currentTypeArgument);
             currentTypeArgument = '';
           }
         } else {
           currentTypeArgument += character;
         }
       }
       addTypeArgument(currentTypeArgument);
     }
-    return _typeArguments = new UnmodifiableListView(result);
+    return _cachedTypeArguments = new UnmodifiableListView(result);
   }
 
   Map<Symbol, MethodMirror> get constructors => _class.constructors;
 
   List<JsMethodMirror> get _methods {
     if (_cachedMethods != null) return _cachedMethods;
     return _cachedMethods =_class._getMethodsWithOwner(this);
   }
 
   Map<Symbol, MethodMirror> get methods {
@@ skipping 46 matching lines @@
       [Map<Symbol, dynamic> namedArguments]) {
     return _class.newInstanceAsync(constructorName,
                                    positionalArguments,
                                    namedArguments);
   }
 
   JsLibraryMirror get owner => _class.owner;
 
   List<InstanceMirror> get metadata => _class.metadata;
 
-  ClassMirror get superclass => _class.superclass;
+  ClassMirror get superclass {
+    if (_superclass != null) return _superclass;
+
+    List<int> typeInformation =
+        JS('List|Null', 'init.typeInformation[#]', _class._mangledName);
+    assert(typeInformation != null);
+    var type = getMetadata(typeInformation[0]);
+    return _superclass = typeMirrorFromRuntimeTypeRepresentation(this, type);
+  }
 
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol,dynamic> namedArguments]) {
     return _class.invoke(memberName, positionalArguments, namedArguments);
   }
 
   bool get isOriginalDeclaration => false;
 
   ClassMirror get originalDeclaration => _class;
 
-  List<ClassMirror> get superinterfaces => _class.superinterfaces;
+  List<ClassMirror> get superinterfaces {
+    if (_cachedSuperinterfaces != null) return _cachedSuperinterfaces;
+    return _cachedSuperinterfaces = _class._getSuperinterfacesWithOwner(this);
+  }
 
   Future<InstanceMirror> getFieldAsync(Symbol fieldName) {
     return _class.getFieldAsync(fieldName);
   }
 
   bool get hasReflectedType => _class.hasReflectedType;
 
   Future<InstanceMirror> invokeAsync(Symbol memberName,
                                      List positionalArguments,
                                      [Map<Symbol, dynamic> namedArguments]) {
@@ skipping 307 matching lines @@
     if (_cachedMetadata != null) return _cachedMetadata;
     if (_metadata == null) {
       _metadata = extractMetadata(JS('', '#.prototype', _jsConstructor));
     }
     return _cachedMetadata =
         new UnmodifiableListView<InstanceMirror>(_metadata.map(reflect));
   }
 
   ClassMirror get superclass {
     if (_superclass == null) {
-      var superclassName = _fieldsDescriptor.split(';')[0];
-      var mixins = superclassName.split('+');
-      if (mixins.length > 1) {
-        if (mixins.length != 2) {
-          throw new RuntimeError('Strange mixin: $_fieldsDescriptor');
+      List<int> typeInformation =
+          JS('List|Null', 'init.typeInformation[#]', _mangledName);
+      if (typeInformation != null) {
+        var type = getMetadata(typeInformation[0]);
+        _superclass = typeMirrorFromRuntimeTypeRepresentation(this, type);
+      } else {
+        var superclassName = _fieldsDescriptor.split(';')[0];
+        // TODO(zarah): Remove special handing of mixins.
+        var mixins = superclassName.split('+');
+        if (mixins.length > 1) {
+          if (mixins.length != 2) {
+            throw new RuntimeError('Strange mixin: $_fieldsDescriptor');
+          }
+          _superclass = reflectClassByMangledName(mixins[0]);
+        } else {
+          // Use _superclass == this to represent class with no superclass
+          // (Object).
+          _superclass = (superclassName == '')
+              ? this : reflectClassByMangledName(superclassName);
+          }
         }
-        _superclass = reflectClassByMangledName(mixins[0]);
-      } else {
-        // Use _superclass == this to represent class with no superclass (Object).
-        _superclass = (superclassName == '')
-            ? this : reflectClassByMangledName(superclassName);
       }
-    }
     return _superclass == this ? null : _superclass;
   }
 
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol,dynamic> namedArguments]) {
     // Mirror API gotcha: Calling [invoke] on a ClassMirror means invoke a
     // static method.
 
     if (namedArguments != null && !namedArguments.isEmpty) {
       throw new UnsupportedError('Named arguments are not implemented.');
     }
     JsMethodMirror mirror = methods[memberName];
     if (mirror == null || !mirror.isStatic) {
       // TODO(ahe): What receiver to use?
       throw new NoSuchMethodError(
           this, memberName, positionalArguments, namedArguments);
     }
     if (!mirror.canInvokeReflectively()) {
       throwInvalidReflectionError(n(memberName));
     }
     return reflect(mirror._invoke(positionalArguments, namedArguments));
   }
 
   bool get isOriginalDeclaration => true;
 
   ClassMirror get originalDeclaration => this;
 
+  List<ClassMirror> _getSuperinterfacesWithOwner(DeclarationMirror owner) {
+    List<int> typeInformation =
+        JS('List|Null', 'init.typeInformation[#]', _mangledName);
+    List<ClassMirror> result = const <ClassMirror>[];
+    if (typeInformation != null) {
+      ClassMirror lookupType(int i) {
+        var type = getMetadata(i);
+        return typeMirrorFromRuntimeTypeRepresentation(owner, type);
+      }
+
+      //We skip the first since it is the supertype.
+      result = typeInformation.skip(1).map(lookupType).toList();
+    }
+
+    return new UnmodifiableListView<ClassMirror>(result);
+  }
+
   List<ClassMirror> get superinterfaces {
     if (_cachedSuperinterfaces != null) return _cachedSuperinterfaces;
-    List<int> interfaces = JS('List|Null', 'init.interfaces[#]', _mangledName);
-    var result = const [];
-    if (interfaces != null) {
-      ClassMirror lookupType(int i) {
-        var type = JS('=Object', 'init.metadata[#]', i);
-        return typeMirrorFromRuntimeTypeRepresentation(type);
-      }
-      result = interfaces.map(lookupType).toList();
-    }
-    return _cachedSuperinterfaces =
-        new UnmodifiableListView<ClassMirror>(result);
+    return _cachedSuperinterfaces = _getSuperinterfacesWithOwner(this);
   }
 
   List<TypeVariableMirror> get typeVariables {
    if (_cachedTypeVariables != null) return _cachedTypeVariables;
    List result = new List();
    List typeVariables =
         JS('JSExtendableArray|Null', '#.prototype["<>"]', _jsConstructor);
     if (typeVariables == null) return result;
     for (int i = 0; i < typeVariables.length; i++) {
-      TypeVariable typeVariable = JS('', 'init.metadata[#]', typeVariables[i]);
+      TypeVariable typeVariable = getMetadata(typeVariables[i]);
       result.add(new JsTypeVariableMirror(typeVariable, this));
     }
     return _cachedTypeVariables = new UnmodifiableListView(result);
   }
 
   List<TypeMirror> get typeArguments => const <TypeMirror>[];
 }
 
 class JsVariableMirror extends JsDeclarationMirror implements VariableMirror {
   static final int REFLECTION_MARKER = 45;
@@ skipping 222 matching lines @@
   }
 
   bool canInvokeReflectively() {
     return hasReflectableProperty(_jsFunction);
   }
 
   DeclarationMirror get owner => _owner;
 
   TypeMirror get returnType {
     metadata; // Compute _returnType as a side-effect of extracting metadata.
-    return computeTypeMirror(owner, _returnType);
+    return typeMirrorFromRuntimeTypeRepresentation(owner, _returnType);
   }
 
   List<InstanceMirror> get metadata {
     if (_metadata == null) {
       var raw = extractMetadata(_jsFunction);
       var formals = new List(_parameterCount);
       if (!raw.isEmpty) {
         _returnType = raw[0];
         int parameterLength = 1 + _parameterCount * 2;
         int formalsCount = 0;
@@ skipping 78 matching lines @@
   final DeclarationMirror owner;
   // A JS object representing the type.
   final _type;
 
   JsParameterMirror(String unmangledName, this.owner, this._type)
       : super(s(unmangledName));
 
   String get _prettyName => 'ParameterMirror';
 
   TypeMirror get type {
-    return computeTypeMirror(owner, _type);
+    return typeMirrorFromRuntimeTypeRepresentation(owner, _type);
   }
 
   // Only true for static fields, never for a parameter.
   bool get isStatic => false;
 
   // TODO(ahe): Implement this.
   bool get isFinal => false;
 
   // TODO(ahe): Implement this.
   bool get isOptional => false;
@@ skipping 40 matching lines @@
   bool get _isVoid => JS('bool', '!!#.void', _typeData);
 
   bool get _hasArguments => JS('bool', '"args" in #', _typeData);
   List get _arguments => JS('JSExtendableArray', '#.args', _typeData);
 
   bool get _hasOptionalArguments => JS('bool', '"opt" in #', _typeData);
   List get _optionalArguments => JS('JSExtendableArray', '#.opt', _typeData);
 
   bool get _hasNamedArguments => JS('bool', '"named" in #', _typeData);
   get _namedArguments => JS('=Object', '#.named', _typeData);
+  bool get isOriginalDeclaration => true;
 
   TypeMirror get returnType {
     if (_cachedReturnType != null) return _cachedReturnType;
     if (_isVoid) return _cachedReturnType = JsMirrorSystem._voidType;
     if (!_hasReturnType) return _cachedReturnType = JsMirrorSystem._dynamicType;
     return _cachedReturnType =
-        typeMirrorFromRuntimeTypeRepresentation(_returnType);
+          typeMirrorFromRuntimeTypeRepresentation(this, _returnType);
   }
 
   List<ParameterMirror> get parameters {
     if (_cachedParameters != null) return _cachedParameters;
     List result = [];
     int parameterCount = 0;
     if (_hasArguments) {
       for (var type in _arguments) {
         result.add(
             new JsParameterMirror('argument${parameterCount++}', this, type));
@@ skipping 52 matching lines @@
       s += 'void';
     } else if (_hasReturnType) {
       s += runtimeTypeToString(_returnType);
     } else {
       s += 'dynamic';
     }
     return _cachedToString = "$s'";
   }
 }
 
-TypeMirror typeMirrorFromRuntimeTypeRepresentation(type) {
-  if (type == null) return JsMirrorSystem._dynamicType;
-  String representation = runtimeTypeToString(type);
-  if (representation == null) return reflectClass(Function);
-  return reflectType(createRuntimeType(representation));
+int findTypeVariableIndex(List<TypeVariableMirror> typeVariables, String name) {
+  for (int i = 0; i < typeVariables.length; i++) {
+    if (typeVariables[i].simpleName == s(name)) {
+      return i;
+    }
+  }
+  throw new ArgumentError('Type variable not present in list.');
 }
 
-TypeMirror computeTypeMirror(DeclarationMirror owner, var type) {
-  if (type is! int) {
-    return typeMirrorFromRuntimeTypeRepresentation(type);
-  }
-  
+getMetadata(int index) => JS('', 'init.metadata[#]', index);
+
+TypeMirror typeMirrorFromRuntimeTypeRepresentation(
+    DeclarationMirror owner,
+    var /*int|List|JsFunction*/ type) {
   ClassMirror ownerClass;
   DeclarationMirror context = owner;
     while(context != null) {
     if (context is ClassMirror) {
       ownerClass = context;
       break;
     }
     context = context.owner;
   }
- 
-  TypeVariable typeVariable = JS('', 'init.metadata[#]', type);
-  Symbol name = new Symbol(typeVariable.name);
-  List<TypeVariableMirror> typeVariables = ownerClass.typeVariables;
-  for (int i = 0; i < typeVariables.length; i++) {
-    if (typeVariables[i].simpleName == name) {
-      if (ownerClass.isOriginalDeclaration) {
-        return typeVariables[i];
-      } else {
-        return ownerClass.typeArguments[i];
-      }
+
+  String representation;
+  if (type == null){
+    return JsMirrorSystem._dynamicType;
+  } else if (ownerClass == null) {
+    representation = runtimeTypeToString(type);
+  } else if (ownerClass.isOriginalDeclaration) {
+    if (type is int) {
+      // [type] represents a type variable so in the context of an original
+      // declaration the corresponding type variable should be returned.
+      TypeVariable typeVariable = getMetadata(type);
+      List<TypeVariableMirror> typeVariables = ownerClass.typeVariables;
+      int index = findTypeVariableIndex(typeVariables, typeVariable.name);
+      return typeVariables[index];
+    } else {
+      // Nested type variables will be retrieved lazily (the integer
+      // representation is kept in the string) so they are not processed here.
+      representation = runtimeTypeToString(type);
     }
+  } else {
+    String substituteTypeVariable(int index) {
+      TypeVariable typeVariable = getMetadata(index);
+      int variableIndex =
+          findTypeVariableIndex(ownerClass.typeVariables, typeVariable.name);
+      var typeArgument = ownerClass.typeArguments[variableIndex];
+      assert(typeArgument is JsClassMirror ||
+             typeArgument is JsTypeBoundClassMirror);
+      return typeArgument._mangledName;
+    }
+    representation =
+        runtimeTypeToString(type, onTypeVariable: substituteTypeVariable);
   }
+  if (representation != null) {
+    return reflectType(createRuntimeType(representation));
+  }
+  return reflectClass(Function);
 }
 
 Symbol computeQualifiedName(DeclarationMirror owner, Symbol simpleName) {
   if (owner == null) return simpleName;
   String ownerName = n(owner.qualifiedName);
   return s('$ownerName.${n(simpleName)}');
 }
 
 List extractMetadata(victim) {
   preserveMetadata();
   var metadataFunction = JS('', '#["@"]', victim);
   if (metadataFunction != null) return JS('', '#()', metadataFunction);
   if (JS('String', 'typeof #', victim) != 'function') return const [];
   String source = JS('String', 'Function.prototype.toString.call(#)', victim);
   int index = source.lastIndexOf(new RegExp('"[0-9,]*";?[ \n\r]*}'));
   if (index == -1) return const [];
   index++;
   int endQuote = source.indexOf('"', index);
   return source.substring(index, endQuote).split(',').map(int.parse).map(
-      (int i) => JS('', 'init.metadata[#]', i)).toList();
+      (int i) => getMetadata(i)).toList();
 }
 
 List<JsVariableMirror> parseCompactFieldSpecification(
     JsDeclarationMirror owner,
     fieldSpecification,
     bool isStatic,
     List<Mirror> result) {
   List fieldsMetadata = null;
   List<String> fieldNames;
   if (fieldSpecification is List) {
@@ skipping 101 matching lines @@
 
 // TODO(ahe): Remove this class and call noSuchMethod instead.
 class UnimplementedNoSuchMethodError extends Error
     implements NoSuchMethodError {
   final String _message;
 
   UnimplementedNoSuchMethodError(this._message);
 
   String toString() => "Unsupported operation: $_message";
 }