Full typedef support in dartdoc.

pkg/dartdoc/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('../../../lib/compiler/compiler.dart', prefix: 'diagnostics');
 #import('../../../lib/compiler/implementation/elements/elements.dart');
 #import('../../../lib/compiler/implementation/apiimpl.dart', prefix: 'api');
 #import('../../../lib/compiler/implementation/scanner/scannerlib.dart');
@@ skipping 576 matching lines @@
     : super(system, element);
 
   VariableElement get _variableElement() => _element;
 
   String get canonicalName() => simpleName;
 
   String get qualifiedName() => '${_method.qualifiedName}#${simpleName}';
 
   TypeMirror get type() => _convertTypeToTypeMirror(system,
       _variableElement.computeType(system.compiler),
-      system.compiler.dynamicClass.computeType(system.compiler),
+      system.compiler.types.dynamicType,
       _variableElement.variables.functionSignature);
 
   String get defaultValue() {
     if (hasDefaultValue) {
       SendSet expression = _variableElement.cachedNode.asSendSet();
       return expression.arguments.head.unparse();
     }
     return null;
   }
   bool get hasDefaultValue() {
@@ skipping 15 matching lines @@
       : super._normal(system, method, element, isOptional);
 
   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.dynamicClass.computeType(system.compiler),
+      system.compiler.types.dynamicType,
       _variableElement.variables.functionSignature);
   }
 
   bool get isInitializingFormal() => true;
 
   FieldMirror get initializedField() => new Dart2JsFieldMirror(
       _method.surroundingDeclaration, _fieldParameterElement.fieldElement);
 }
 
 //------------------------------------------------------------------------------
@@ skipping 68 matching lines @@
       return new Dart2JsInterfaceTypeMirror(system, _class.supertype);
     }
     return null;
   }
 
   Map<Object, InterfaceMirror> get interfaces() {
     var map = new Map<String, InterfaceMirror>();
     Link<Type> link = _class.interfaces;
     while (!link.isEmpty()) {
       var type = _convertTypeToTypeMirror(system, link.head,
-          system.compiler.dynamicClass.computeType(system.compiler));
+                                          system.compiler.types.dynamicType);
       map[type.canonicalName] = type;
       link = link.tail;
     }
     return new ImmutableMapWrapper<Object, InterfaceMirror>(map);
   }
 
   bool get isClass() => !_class.isInterface();
 
   bool get isInterface() => _class.isInterface();
 
@@ skipping 97 matching lines @@
   bool get isFunction() => false;
 
   List<TypeMirror> get typeArguments() {
     throw new UnsupportedOperationException(
         'Declarations do not have type arguments');
   }
 
   List<TypeVariableMirror> get typeVariables() {
     if (_typeVariables == null) {
       _typeVariables = <TypeVariableMirror>[];
-      // TODO(johnniwinther): Equip [Typedef] with a [typeParameters] map, just
-      // like [ClassElement].
+      for (TypeVariableType typeVariable in _typedef.typeArguments) {
+        _typeVariables.add(
+            new Dart2JsTypeVariableMirror(system, typeVariable));
+      }
     }
     return _typeVariables;
   }
 
   TypeMirror get definition() {
     if (_definition === null) {
-      // TODO(johnniwinther): Provide access to the functionSignature of the
-      // aliased function definition.
+      // TODO(johnniwinther): Should be [ensureResolved].
+      system.compiler.resolveTypedef(_typedef.element);
+      _definition = _convertTypeToTypeMirror(
+          system,
+          _typedef.element.alias,
+          system.compiler.types.dynamicType,
+          _typedef.element.functionSignature);
     }
     return _definition;
   }
 
   Map<Object, MemberMirror> get declaredMembers() =>
       const <String, MemberMirror>{};
 
   InterfaceMirror get declaration() => this;
 
   // TODO(johnniwinther): How should a typedef respond to these?
@@ skipping 150 matching lines @@
   bool get isPrivate() => declaration.isPrivate;
 
   bool get isDeclaration() => false;
 
   List<TypeMirror> get typeArguments() {
     if (_typeArguments == null) {
       _typeArguments = <TypeMirror>[];
       Link<Type> type = _interfaceType.arguments;
       while (type != null && type.head != null) {
         _typeArguments.add(_convertTypeToTypeMirror(system, type.head,
-            system.compiler.dynamicClass.computeType(system.compiler)));
+            system.compiler.types.dynamicType));
         type = type.tail;
       }
     }
     return _typeArguments;
   }
 
   List<TypeVariableMirror> get typeVariables() => declaration.typeVariables;
 
   // TODO(johnniwinther): Substitute type arguments for type variables.
   Map<Object, MethodMirror> get constructors() => declaration.constructors;
@@ skipping 93 matching lines @@
 
   List<TypeVariableMirror> get typeVariables() => declaration.typeVariables;
 
   Map<Object, MethodMirror> get constructors() =>
       <String, MethodMirror>{};
 
   InterfaceMirror get defaultType() => null;
 
   TypeMirror get returnType() {
     return _convertTypeToTypeMirror(system, _functionType.returnType,
-        system.compiler.dynamicClass.computeType(system.compiler));
+                                    system.compiler.types.dynamicType);
   }
 
   List<ParameterMirror> get parameters() {
     if (_parameters === null) {
       _parameters = _parametersFromFunctionSignature(system, callMethod,
                                                      _functionSignature);
     }
     return _parameters;
   }
 }
@@ skipping 134 matching lines @@
   bool get isStatic() =>
       _function.modifiers !== null && _function.modifiers.isStatic();
 
   List<ParameterMirror> get parameters() {
     return _parametersFromFunctionSignature(system, this,
         _function.computeSignature(system.compiler));
   }
 
   TypeMirror get returnType() => _convertTypeToTypeMirror(
       system, _function.computeSignature(system.compiler).returnType,
-      system.compiler.dynamicClass.computeType(system.compiler));
+      system.compiler.types.dynamicType);
 
   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;
@@ skipping 46 matching lines @@
   bool get isMethod() => false;
 
   bool get isPrivate() => _isPrivate(simpleName);
 
   bool get isStatic() => _variable.modifiers.isStatic();
 
   bool get isFinal() => _variable.modifiers.isFinal();
 
   TypeMirror get type() => _convertTypeToTypeMirror(system,
       _variable.computeType(system.compiler),
-      system.compiler.dynamicClass.computeType(system.compiler));
+      system.compiler.types.dynamicType);
 
   Location get location() {
     var script = _variable.getCompilationUnit().script;
     var node = _variable.variables.parseNode(_diagnosticListener);
     if (node !== null) {
       var span = system.compiler.spanFromNode(node, script.uri);
       return new Dart2JsLocation(script, span);
     } else {
       var span = system.compiler.spanFromElement(_variable);
       return new Dart2JsLocation(script, span);
     }
   }
 }