Add typedef AST node boilerplate.

pkg/kernel/lib/type_algebra.dart

 // Copyright (c) 2016, 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 kernel.type_algebra;
 
 import 'ast.dart';
 
 /// Returns a type where all occurrences of the given type parameters have been
 /// replaced with the corresponding types.
 ///
@@ skipping 155 matching lines @@
   }
 
   /// Substitutes the type parameters on the class of [type] with the
   /// type arguments provided in [type].
   static Substitution fromInterfaceType(InterfaceType type) {
     if (type.typeArguments.isEmpty) return _NullSubstitution.instance;
     return fromMap(new Map<TypeParameter, DartType>.fromIterables(
         type.classNode.typeParameters, type.typeArguments));
   }
 
+  /// Substitutes the type parameters on the typedef of [type] with the
+  /// type arguments provided in [type].
+  static Substitution fromTypedefType(TypedefType type) {
+    if (type.typeArguments.isEmpty) return _NullSubstitution.instance;
+    return fromMap(new Map<TypeParameter, DartType>.fromIterables(
+        type.typedefNode.typeParameters, type.typeArguments));
+  }
+
   /// Substitutes the Nth parameter in [parameters] with the Nth type in
   /// [types].
   static Substitution fromPairs(
       List<TypeParameter> parameters, List<DartType> types) {
     // TODO(asgerf): Investigate if it is more efficient to implement
     // substitution based on parallel pairwise lists instead of Maps.
     assert(parameters.length == types.length);
     if (parameters.isEmpty) return _NullSubstitution.instance;
     return fromMap(
         new Map<TypeParameter, DartType>.fromIterables(parameters, types));
@@ skipping 182 matching lines @@
   DartType visitVector(VectorType node) => node;
 
   DartType visitInterfaceType(InterfaceType node) {
     if (node.typeArguments.isEmpty) return node;
     int before = useCounter;
     var typeArguments = node.typeArguments.map(visit).toList();
     if (useCounter == before) return node;
     return new InterfaceType(node.classNode, typeArguments);
   }
 
+  DartType visitTypedefType(TypedefType node) {
+    if (node.typeArguments.isEmpty) return node;
+    int before = useCounter;
+    var typeArguments = node.typeArguments.map(visit).toList();
+    if (useCounter == before) return node;
+    return new TypedefType(node.typedefNode, typeArguments);
+  }
+
   List<TypeParameter> freshTypeParameters(List<TypeParameter> parameters) {
     if (parameters.isEmpty) return const <TypeParameter>[];
     return parameters.map(freshTypeParameter).toList();
   }
 
   TypeParameter freshTypeParameter(TypeParameter node);
 
   DartType visitFunctionType(FunctionType node) {
     // This is a bit tricky because we have to generate fresh type parameters
     // in order to change the bounds.  At the same time, if the function type
@@ skipping 260 matching lines @@
 
   bool visitInvalidType(InvalidType node) => false;
   bool visitDynamicType(DynamicType node) => false;
   bool visitVoidType(VoidType node) => false;
   bool visitVectorType(VectorType node) => false;
 
   bool visitInterfaceType(InterfaceType node) {
     return node.typeArguments.any(visit);
   }
 
+  bool visitTypedefType(TypedefType node) {
+    return node.typeArguments.any(visit);
+  }
+
   bool visitFunctionType(FunctionType node) {
     return node.typeParameters.any(handleTypeParameter) ||
         node.positionalParameters.any(visit) ||
         node.namedParameters.any(visitNamedType) ||
         visit(node.returnType);
   }
 
   bool visitTypeParameterType(TypeParameterType node) {
     return variables == null || variables.contains(node.parameter);
   }
 
   bool handleTypeParameter(TypeParameter node) {
     assert(!variables.contains(node));
     return node.bound.accept(this);
   }
 }