Generate typedef node from the element.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.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 backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 266 matching lines @@
         }
       }
 
       // Add constant declarations.
       List<VariableDeclaration> constants = <VariableDeclaration>[];
       for (ConstDeclaration constDecl in definition.localConstants) {
         if (!context.constantNames.containsKey(constDecl.element)) {
           continue; // Discard unused constants declarations.
         }
         String name = context.getConstantName(constDecl.element);
-        Expression value = emitConstant(constDecl.expression, context);
+        Expression value =
+            ConstantEmitter.createExpression(constDecl.expression, context);
         VariableDeclaration decl = new VariableDeclaration(name, value);
         decl.element = constDecl.element;
         constants.add(decl);
       }
 
       List<Statement> bodyParts = [];
       if (constants.length > 0) {
         bodyParts.add(new VariableDeclarations(constants, isConst: true));
       }
       if (context.variables.length > 0) {
         bodyParts.add(new VariableDeclarations(context.variables));
       }
       bodyParts.addAll(context.statements);
 
       body = new Block(bodyParts);
     }
     FunctionType functionType = context.currentElement.type;
 
     return new FunctionExpression(
         parameters,
         body,
         name: context.currentElement.name,
-        returnType: emitOptionalType(functionType.returnType),
+        returnType: TypeGenerator.createOptionalType(functionType.returnType),
         isGetter: context.currentElement.isGetter,
         isSetter: context.currentElement.isSetter)
         ..element = context.currentElement;
   }
 
-  /// TODO(johnniwinther): Remove this when issue 21283 has been resolved.
-  int pseudoNameCounter = 0;
-
-  Parameter emitParameter(DartType type,
-                          BuilderContext<Statement> context,
-                          {String name,
-                           Element element,
-                           ConstantExpression defaultValue}) {
-    if (name == null && element != null) {
-      name = element.name;
-    }
-    if (name == null) {
-      name = '_${pseudoNameCounter++}';
-    }
-    Parameter parameter;
-    if (type.isFunctionType) {
-      FunctionType functionType = type;
-      TypeAnnotation returnType = emitOptionalType(functionType.returnType);
-      Parameters innerParameters =
-          emitParametersFromType(functionType, context);
-      parameter = new Parameter.function(name, returnType, innerParameters);
-    } else {
-      TypeAnnotation typeAnnotation = emitOptionalType(type);
-      parameter = new Parameter(name, type: typeAnnotation);
-    }
-    parameter.element = element;
-    if (defaultValue != null && !defaultValue.value.isNull) {
-      parameter.defaultValue = emitConstant(defaultValue, context);
-    }
-    return parameter;
-  }
-
-  Parameters emitParametersFromType(FunctionType functionType,
-                                    BuilderContext<Statement> context) {
-    if (functionType.namedParameters.isEmpty) {
-      return new Parameters(
-          emitParameters(functionType.parameterTypes, context),
-          emitParameters(functionType.optionalParameterTypes, context),
-          false);
-    } else {
-      return new Parameters(
-          emitParameters(functionType.parameterTypes, context),
-          emitParameters(functionType.namedParameterTypes, context,
-                         names: functionType.namedParameters),
-          true);
-    }
-  }
-
-  List<Parameter> emitParameters(
-      Iterable<DartType> parameterTypes,
-      BuilderContext<Statement> context,
-      {Iterable<String> names: const <String>[],
-       Iterable<ConstantExpression> defaultValues: const <ConstantExpression>[],
-       Iterable<Element> elements: const <Element>[]}) {
-    Iterator<String> name = names.iterator;
-    Iterator<ConstantExpression> defaultValue = defaultValues.iterator;
-    Iterator<Element> element = elements.iterator;
-    return parameterTypes.map((DartType type) {
-      name.moveNext();
-      defaultValue.moveNext();
-      element.moveNext();
-      return emitParameter(type, context,
-                           name: name.current,
-                           defaultValue: defaultValue.current,
-                           element: element.current);
-    }).toList();
-  }
-
   /// Emits parameters that are not nested inside other parameters.
   /// Root parameters can have default values, while inner parameters cannot.
   Parameters emitRootParameters(tree.FunctionDefinition function,
                                 BuilderContext<Statement> context) {
     FunctionType functionType = function.element.type;
-    List<Parameter> required = emitParameters(
-        functionType.parameterTypes, context,
+    List<Parameter> required = TypeGenerator.createParameters(
+        functionType.parameterTypes,
+        context: context,
         elements: function.parameters.map((p) => p.element));
     bool optionalParametersAreNamed = !functionType.namedParameters.isEmpty;
-    List<Parameter> optional = emitParameters(
+    List<Parameter> optional = TypeGenerator.createParameters(
         optionalParametersAreNamed
             ? functionType.namedParameterTypes
             : functionType.optionalParameterTypes,
-        context,
+        context: context,
         defaultValues: function.defaultParameterValues,
         elements: function.parameters.skip(required.length)
             .map((p) => p.element));
     return new Parameters(required, optional, optionalParametersAreNamed);
   }
 
   /// True if the two expressions are a reference to the same variable.
   bool isSameVariable(Receiver e1, Receiver e2) {
     return e1 is Identifier &&
            e2 is Identifier &&
@@ skipping 185 matching lines @@
     Block body = visitInSubContext(stmt.body, context, fallthrough: stmt);
     Statement statement = new While(condition, body);
     addLabeledStatement(stmt.label, statement, context);
 
     visitStatement(stmt.next, context);
   }
 
   @override
   Expression visitConstant(tree.Constant exp,
                            BuilderContext<Statement> context) {
-    return emitConstant(exp.expression, context);
+    return ConstantEmitter.createExpression(exp.expression, context);
   }
 
   @override
   Expression visitThis(tree.This exp,
                        BuilderContext<Statement> context) {
     return new This();
   }
 
   @override
   Expression visitReifyTypeVar(tree.ReifyTypeVar exp,
                                BuilderContext<Statement> context) {
     return new ReifyTypeVar(exp.typeVariable.name)
                ..element = exp.typeVariable;
   }
 
   List<Expression> visitExpressions(List<tree.Expression> expressions,
                                     BuilderContext<Statement> context) {
     return expressions.map((expression) => visitExpression(expression, context))
         .toList(growable: false);
   }
 
   @override
   Expression visitLiteralList(tree.LiteralList exp,
                               BuilderContext<Statement> context) {
     return new LiteralList(visitExpressions(exp.values, context),
-        typeArgument: emitOptionalType(exp.type.typeArguments.single));
+        typeArgument:
+            TypeGenerator.createOptionalType(exp.type.typeArguments.single));
   }
 
   @override
   Expression visitLiteralMap(tree.LiteralMap exp,
                              BuilderContext<Statement> context) {
     List<LiteralMapEntry> entries = new List<LiteralMapEntry>.generate(
         exp.entries.length,
-        (i) => new LiteralMapEntry(visitExpression(exp.entries[i].key, context),
-                                   visitExpression(exp.entries[i].value, context)));
+        (i) => new LiteralMapEntry(
+            visitExpression(exp.entries[i].key, context),
+            visitExpression(exp.entries[i].value, context)));
     List<TypeAnnotation> typeArguments = exp.type.treatAsRaw
         ? null
-        : exp.type.typeArguments.map(createTypeAnnotation)
+        : exp.type.typeArguments.map(TypeGenerator.createType)
              .toList(growable: false);
     return new LiteralMap(entries, typeArguments: typeArguments);
   }
 
   @override
   Expression visitTypeOperator(tree.TypeOperator exp,
                                BuilderContext<Statement> context) {
     return new TypeOperator(visitExpression(exp.receiver, context),
                             exp.operator,
-                            createTypeAnnotation(exp.type));
+                            TypeGenerator.createType(exp.type));
   }
 
   List<Argument> emitArguments(tree.Invoke exp,
                                BuilderContext<Statement> context) {
     List<tree.Expression> args = exp.arguments;
     int positionalArgumentCount = exp.selector.positionalArgumentCount;
     List<Argument> result = new List<Argument>.generate(positionalArgumentCount,
         (i) => visitExpression(exp.arguments[i], context));
     for (int i = 0; i < exp.selector.namedArgumentCount; ++i) {
       result.add(new NamedArgument(exp.selector.namedArguments[i],
-          visitExpression(exp.arguments[positionalArgumentCount + i], context)));
+          visitExpression(

[sigurdm, 2014/12/08 13:02:30]

Is there trailing whitespace here? It looks like that in the review tool.

[Johnni Winther, 2014/12/10 08:47:54]

No. It's clean.

+              exp.arguments[positionalArgumentCount + i], context)));
     }
     return result;
   }
 
   @override
   Expression visitInvokeStatic(tree.InvokeStatic exp,
                                BuilderContext<Statement> context) {
     switch (exp.selector.kind) {
       case SelectorKind.GETTER:
         return new Identifier(exp.target.name)..element = exp.target;
@@ skipping 66 matching lines @@
                                     BuilderContext<Statement> context) {
     return emitMethodCall(exp, new SuperReceiver(), context);
   }
 
   @override
   Expression visitInvokeConstructor(tree.InvokeConstructor exp,
                                     BuilderContext<Statement> context) {
     List args = emitArguments(exp, context);
     FunctionElement constructor = exp.target;
     String name = constructor.name.isEmpty ? null : constructor.name;
-    return new CallNew(createTypeAnnotation(exp.type),
+    return new CallNew(TypeGenerator.createType(exp.type),
                        args,
                        constructorName: name,
                        isConst: exp.constant != null)
                ..constructor = constructor
                ..dartType = exp.type;
   }
 
   @override
   Expression visitConcatenateStrings(tree.ConcatenateStrings exp,
                                      BuilderContext<Statement> context) {
@@ skipping 46 matching lines @@
                                 BuilderContext<Statement> context) {
     assert(context.variableNames[node.variable] == null);
     String name = context.getVariableName(node.variable);
     FunctionExpression inner = makeSubFunction(node.definition, context);
     inner.name = name;
     FunctionDeclaration decl = new FunctionDeclaration(inner);
     context.declaredVariables.add(node.variable);
     context.addStatement(decl);
     visitStatement(node.next, context);
   }
-
-  Expression emitConstant(ConstantExpression exp,
-                          BuilderContext<Statement> context) {
-    return const ConstantEmitter().visit(exp, context);
-  }
 }
 
-/// Like [createTypeAnnotation] except the dynamic type is converted to null.
-TypeAnnotation emitOptionalType(DartType type) {
-  if (type.treatAsDynamic) {
-    return null;
-  } else {
-    return createTypeAnnotation(type);
+class TypeGenerator {

[sigurdm, 2014/12/08 13:02:29]

All the methods are static. Do we need the class at all?

[Johnni Winther, 2014/12/10 08:47:54]

We don't need it but I wanted to group all methods for creating types so that
dependency (from backend->frontend ast) clearly shows its use. The functionality
might become part of the ASTEmitter, once we don't convert to frontend ast.

+
+  /// TODO(johnniwinther): Remove this when issue 21283 has been resolved.
+  static int pseudoNameCounter = 0;
+
+  static Parameter emitParameter(DartType type,
+                                 BuilderContext<Statement> context,
+                                 {String name,
+                                  Element element,
+                                  ConstantExpression defaultValue}) {
+    if (name == null && element != null) {
+      name = element.name;
+    }
+    if (name == null) {
+      name = '_${pseudoNameCounter++}';
+    }
+    Parameter parameter;
+    if (type.isFunctionType) {
+      FunctionType functionType = type;
+      TypeAnnotation returnType = createOptionalType(functionType.returnType);
+      Parameters innerParameters =
+          createParametersFromType(functionType);
+      parameter = new Parameter.function(name, returnType, innerParameters);
+    } else {
+      TypeAnnotation typeAnnotation = createOptionalType(type);
+      parameter = new Parameter(name, type: typeAnnotation);
+    }
+    parameter.element = element;
+    if (defaultValue != null && !defaultValue.value.isNull) {
+      parameter.defaultValue =
+          ConstantEmitter.createExpression(defaultValue, context);
+    }
+    return parameter;
   }
+
+  static Parameters createParametersFromType(FunctionType functionType) {
+    pseudoNameCounter = 0;
+    if (functionType.namedParameters.isEmpty) {
+      return new Parameters(
+          createParameters(functionType.parameterTypes),
+          createParameters(functionType.optionalParameterTypes),
+          false);
+    } else {
+      return new Parameters(
+          createParameters(functionType.parameterTypes),
+          createParameters(functionType.namedParameterTypes,
+                         names: functionType.namedParameters),
+          true);
+    }
+  }
+
+  static List<Parameter> createParameters(
+      Iterable<DartType> parameterTypes,
+      {BuilderContext<Statement> context,
+       Iterable<String> names: const <String>[],
+       Iterable<ConstantExpression> defaultValues: const <ConstantExpression>[],
+       Iterable<Element> elements: const <Element>[]}) {
+    Iterator<String> name = names.iterator;
+    Iterator<ConstantExpression> defaultValue = defaultValues.iterator;
+    Iterator<Element> element = elements.iterator;
+    return parameterTypes.map((DartType type) {
+      name.moveNext();
+      defaultValue.moveNext();
+      element.moveNext();
+      return emitParameter(type, context,
+                           name: name.current,
+                           defaultValue: defaultValue.current,
+                           element: element.current);
+    }).toList();
+  }
+
+  /// Like [createTypeAnnotation] except the dynamic type is converted to null.
+  static TypeAnnotation createOptionalType(DartType type) {
+    if (type.treatAsDynamic) {
+      return null;
+    } else {
+      return createType(type);
+    }
+  }
+
+  /// Creates the [TypeAnnotation] for a [type] that is not function type.
+  static TypeAnnotation createType(DartType type) {
+    if (type is GenericType) {
+      if (type.treatAsRaw) {
+        return new TypeAnnotation(type.element.name)..dartType = type;
+      }
+      return new TypeAnnotation(
+          type.element.name,
+          type.typeArguments.map(createType).toList(growable:false))
+          ..dartType = type;
+    } else if (type is VoidType) {
+      return new TypeAnnotation('void')
+          ..dartType = type;
+    } else if (type is TypeVariableType) {
+      return new TypeAnnotation(type.name)
+          ..dartType = type;
+    } else if (type is DynamicType) {
+      return new TypeAnnotation("dynamic")
+          ..dartType = type;
+    } else if (type is MalformedType) {
+      return new TypeAnnotation(type.name)
+          ..dartType = type;
+    } else {
+      throw "Unsupported type annotation: $type";
+    }
+  }
+
 }
 
-TypeAnnotation createTypeAnnotation(DartType type) {
-  if (type is GenericType) {
-    if (type.treatAsRaw) {
-      return new TypeAnnotation(type.element.name)..dartType = type;
-    }
-    return new TypeAnnotation(
-        type.element.name,
-        type.typeArguments.map(createTypeAnnotation).toList(growable:false))
-        ..dartType = type;
-  } else if (type is VoidType) {
-    return new TypeAnnotation('void')
-        ..dartType = type;
-  } else if (type is TypeVariableType) {
-    return new TypeAnnotation(type.name)
-        ..dartType = type;
-  } else if (type is DynamicType) {
-    return new TypeAnnotation("dynamic")
-        ..dartType = type;
-  } else if (type is MalformedType) {
-    return new TypeAnnotation(type.name)
-        ..dartType = type;
-  } else {
-    throw "Unsupported type annotation: $type";
-  }
-}
 
 class ConstantEmitter
     extends ConstantExpressionVisitor<BuilderContext<Statement>, Expression> {
   const ConstantEmitter();
 
+  /// Creates the [Expression] for the constant [exp].
+  static Expression createExpression(ConstantExpression exp,
+                                     BuilderContext<Statement> context) {
+    return const ConstantEmitter().visit(exp, context);
+  }
+
   Expression handlePrimitiveConstant(PrimitiveConstantValue value) {
     // Num constants may be negative, while literals must be non-negative:
     // Literals are non-negative in the specification, and a negated literal
     // parses as a call to unary `-`. The AST unparser assumes literals are
     // non-negative and relies on this to avoid incorrectly generating `--`,
     // the predecrement operator.
     // Translate such constants into their positive value wrapped by
     // the unary minus operator.
     if (value.isNum) {
       NumConstantValue numConstant = value;
@@ skipping 30 matching lines @@
     }
     return new UnaryOperator('-', new Literal(positiveConstant));
   }
 
   @override
   Expression visitList(ListConstantExpression exp,
                        BuilderContext<Statement> context) {
     return new LiteralList(
         visitExpressions(exp.values, context),
         isConst: true,
-        typeArgument: emitOptionalType(exp.type.typeArguments.single));
+        typeArgument:
+            TypeGenerator.createOptionalType(exp.type.typeArguments.single));
   }
 
   @override
   Expression visitMap(MapConstantExpression exp,
                       BuilderContext<Statement> context) {
     List<LiteralMapEntry> entries = new List<LiteralMapEntry>.generate(
         exp.values.length,
         (i) => new LiteralMapEntry(visit(exp.keys[i], context),
                                    visit(exp.values[i], context)));
     List<TypeAnnotation> typeArguments = exp.type.treatAsRaw
         ? null
-        : exp.type.typeArguments.map(createTypeAnnotation).toList();
+        : exp.type.typeArguments.map(TypeGenerator.createType).toList();
     return new LiteralMap(entries, isConst: true, typeArguments: typeArguments);
   }
 
   @override
   Expression visitConstructed(ConstructedConstantExpresssion exp,
                               BuilderContext<Statement> context) {
     int positionalArgumentCount = exp.selector.positionalArgumentCount;
     List<Argument> args = new List<Argument>.generate(
         positionalArgumentCount,
         (i) => visit(exp.arguments[i], context));
     for (int i = 0; i < exp.selector.namedArgumentCount; ++i) {
       args.add(new NamedArgument(exp.selector.namedArguments[i],
           visit(exp.arguments[positionalArgumentCount + i], context)));
     }
 
     FunctionElement constructor = exp.target;
     String name = constructor.name.isEmpty ? null : constructor.name;
-    return new CallNew(createTypeAnnotation(exp.type),
+    return new CallNew(TypeGenerator.createType(exp.type),
                        args,
                        constructorName: name,
                        isConst: true)
                ..constructor = constructor
                ..dartType = exp.type;
   }
 
   @override
   Expression visitConcatenate(ConcatenateConstantExpression exp,
                               BuilderContext<Statement> context) {
@@ skipping 125 matching lines @@
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }