Generate typedef node from the element.

pkg/compiler/lib/src/dart_backend/backend_ast_to_frontend_ast.dart

 // Copyright (c) 2014, 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_tree_printer;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' as types;
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart' as elements;
 import '../tree/tree.dart' as tree;
 import '../scanner/scannerlib.dart';
 import '../util/util.dart';
 import 'backend_ast_nodes.dart';
-import 'backend_ast_emitter.dart' show createTypeAnnotation;
+import 'backend_ast_emitter.dart' show TypeGenerator;
 
 /// Translates the backend AST to Dart frontend AST.
 tree.Node emit(dart2js.TreeElementMapping treeElements,
                ExecutableDefinition definition) {
   return new TreePrinter(treeElements).makeDefinition(definition);
 }
 
 /// If true, the unparser will insert a coment in front of every function
 /// it emits. This helps indicate which functions were translated by the new
 /// backend.
@@ skipping 105 matching lines @@
   final Token tryToken = makeIdToken('try');
   final Token catchToken = makeIdToken('catch');
   final Token onToken = makeIdToken('on');
   final Token finallyToken = makeIdToken('finally');
   final Token getToken = makeIdToken('get');
   final Token setToken = makeIdToken('set');
   final Token classToken = makeIdToken('class');
   final Token extendsToken = makeIdToken('extends');
   final Token withToken = makeIdToken('with');
   final Token implementsToken = makeIdToken('implements');
+  final Token typedefToken = makeIdToken('typedef');
 
   static tree.Identifier makeIdentifier(String name) {
     return new tree.Identifier(
         new StringToken.fromString(IDENTIFIER_INFO, name, -1));
   }
 
   static tree.Operator makeOperator(String name) {
     return new tree.Operator(
         new StringToken.fromString(IDENTIFIER_INFO, name, -1));
   }
@@ skipping 861 matching lines @@
   }
 
   tree.Node makeNodeForClassElement(elements.ClassElement cls) {
     if (cls.isMixinApplication) {
       return makeNamedMixinApplication(cls);
     } else {
       return makeClassNode(cls);
     }
   }
 
+  tree.Typedef makeTypedef(elements.TypedefElement typdef) {
+    types.FunctionType functionType = typdef.alias;
+    final tree.TypeAnnotation returnType =
+        makeType(TypeGenerator.createType(functionType.returnType));
+
+    final tree.Identifier name = makeIdentifier(typdef.name);
+    final tree.NodeList typeParameters =
+        makeTypeParameters(typdef.typeVariables);
+    final tree.NodeList formals =
+        makeParameters(TypeGenerator.createParametersFromType(functionType));
+
+    final Token typedefKeyword = typedefToken;
+    final Token endToken = semicolon;
+
+    return new tree.Typedef(returnType, name, typeParameters, formals,
+          typedefKeyword, endToken);
+  }
+
   /// Create a [tree.NodeList] containing the type variable declarations in
   /// [typeVaraiables.
   tree.NodeList makeTypeParameters(List<types.DartType> typeVariables) {
     if (typeVariables.isEmpty) {
       return new tree.NodeList.empty();
     } else {
       List<tree.Node> typeVariableList = <tree.Node>[];
       for (types.TypeVariableType typeVariable in typeVariables) {
         tree.Node id = makeIdentifier(typeVariable.name);
         treeElements[id] = typeVariable.element;
         tree.Node bound;
         if (!typeVariable.element.bound.isObject) {
-          bound = makeType(createTypeAnnotation(typeVariable.element.bound));
+          bound =
+              makeType(TypeGenerator.createType(typeVariable.element.bound));
         }
         tree.TypeVariable node = new tree.TypeVariable(id, bound);
         treeElements.setType(node, typeVariable);
         typeVariableList.add(node);
       }
       return makeList(',', typeVariableList, open: lt, close: gt);
     }
   }
 
   /// Create a [tree.NodeList] containing the declared interfaces.
   ///
   /// [interfaces] is from [elements.ClassElement] in reverse declaration order
   /// and it contains mixins. To produce a list of the declared interfaces only,
   /// interfaces in [mixinTypes] are omitted.
   ///
   /// [forNamedMixinApplication] is because the structure of the [tree.NodeList]
   /// differs between [tree.NamedMixinApplication] and [tree.ClassNode].
   // TODO(johnniwinther): Normalize interfaces on[tree.NamedMixinApplication]
   // and [tree.ClassNode].
   tree.NodeList makeInterfaces(Link<types.DartType> interfaces,
                                Set<types.DartType> mixinTypes,
                                {bool forNamedMixinApplication: false}) {
     Link<tree.Node> typeAnnotations = const Link<tree.Node>();
     for (Link<types.DartType> link = interfaces;
          !link.isEmpty;
          link = link.tail) {
       types.DartType interface = link.head;
       if (!mixinTypes.contains(interface)) {
-        typeAnnotations =
-            typeAnnotations.prepend(makeType(createTypeAnnotation(interface)));
+        typeAnnotations = typeAnnotations.prepend(
+            makeType(TypeGenerator.createType(interface)));
       }
     }
     if (typeAnnotations.isEmpty) {
       return forNamedMixinApplication ? null : new tree.NodeList.empty();
     } else {
       return new tree.NodeList(
           forNamedMixinApplication ? null : implementsToken,
           typeAnnotations, null, ',');
     }
   }
 
   /// Creates a [tree.NamedMixinApplication] node for [cls].
   // TODO(johnniwinther): Unify creation of mixin lists between
   // [NamedMixinApplicationElement] and [ClassElement].
   tree.NamedMixinApplication makeNamedMixinApplication(
        elements.MixinApplicationElement cls) {
 
     assert(dart2js.invariant(cls, !cls.isUnnamedMixinApplication,
         message: "Cannot create ClassNode for unnamed mixin application "
                  "$cls."));
     tree.Modifiers modifiers = makeModifiers(isAbstract: cls.isAbstract);
     tree.Identifier name = makeIdentifier(cls.name);
     tree.NodeList typeParameters = makeTypeParameters(cls.typeVariables);
 
     Set<types.DartType> mixinTypes = new Set<types.DartType>();
     Link<tree.Node> mixins = const Link<tree.Node>();
 
     void addMixin(types.DartType mixinType) {
       mixinTypes.add(mixinType);
-      mixins = mixins.prepend(makeType(createTypeAnnotation(mixinType)));
+      mixins = mixins.prepend(makeType(TypeGenerator.createType(mixinType)));
     }
 
     addMixin(cls.mixinType);
 
     tree.Node superclass;
     types.InterfaceType supertype = cls.supertype;
     while (supertype.element.isUnnamedMixinApplication) {
       elements.MixinApplicationElement mixinApplication = supertype.element;
       addMixin(cls.asInstanceOf(mixinApplication.mixin));
       supertype = mixinApplication.supertype;
     }
     superclass =
-        makeType(createTypeAnnotation(cls.asInstanceOf(supertype.element)));
+        makeType(TypeGenerator.createType(cls.asInstanceOf(supertype.element)));
     tree.Node supernode = new tree.MixinApplication(
         superclass, new tree.NodeList(null, mixins, null, ','));
 
     tree.NodeList interfaces = makeInterfaces(
         cls.interfaces, mixinTypes, forNamedMixinApplication: true);
 
     return new tree.NamedMixinApplication(
         name, typeParameters, modifiers, supernode,
         interfaces, classToken, semicolon);
   }
 
   /// Creates a [tree.ClassNode] node for [cls].
   tree.ClassNode makeClassNode(elements.ClassElement cls) {
     assert(dart2js.invariant(cls, !cls.isUnnamedMixinApplication,
         message: "Cannot create ClassNode for unnamed mixin application "
                  "$cls."));
     tree.Modifiers modifiers = makeModifiers(isAbstract: cls.isAbstract);
     tree.Identifier name = makeIdentifier(cls.name);
     tree.NodeList typeParameters = makeTypeParameters(cls.typeVariables);
     tree.Node supernode;
     types.InterfaceType supertype = cls.supertype;
     Set<types.DartType> mixinTypes = new Set<types.DartType>();
     Link<tree.Node> mixins = const Link<tree.Node>();
 
     void addMixin(types.DartType mixinType) {
       mixinTypes.add(mixinType);
-      mixins = mixins.prepend(makeType(createTypeAnnotation(mixinType)));
+      mixins = mixins.prepend(makeType(TypeGenerator.createType(mixinType)));
     }
 
     if (supertype != null) {
       tree.Node superclass;
       if (supertype.element.isUnnamedMixinApplication) {
         while (supertype.element.isUnnamedMixinApplication) {
           elements.MixinApplicationElement mixinApplication = supertype.element;
           addMixin(cls.asInstanceOf(mixinApplication.mixin));
           supertype = mixinApplication.supertype;
         }
-        tree.Node superclass =
-            makeType(createTypeAnnotation(cls.asInstanceOf(supertype.element)));
+        tree.Node superclass = makeType(
+            TypeGenerator.createType(cls.asInstanceOf(supertype.element)));
         supernode = new tree.MixinApplication(
             superclass, new tree.NodeList(null, mixins, null, ','));
       } else if (!supertype.isObject) {
-        supernode = makeType(createTypeAnnotation(supertype));
+        supernode = makeType(TypeGenerator.createType(supertype));
       }
     }
     tree.NodeList interfaces = makeInterfaces(
         cls.interfaces, mixinTypes);
 
     Token extendsKeyword = supernode != null ? extendsToken : null;
     return new tree.ClassNode(
         modifiers, name, typeParameters, supernode,
         interfaces, openBrace, extendsKeyword,
         null, // No body.
@@ skipping 83 matching lines @@
             printStringChunk(chunk.previous),
             node);
       } else {
         return node;
       }
     }
     return printStringChunk(output.chunk);
   }
 
 }