OLD | NEW |
| (Empty) |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 | |
5 library backend_ast_emitter; | |
6 | |
7 import 'backend_ast_nodes.dart'; | |
8 import '../dart_types.dart'; | |
9 import '../elements/elements.dart'; | |
10 | |
11 class TypeGenerator { | |
12 /// TODO(johnniwinther): Remove this when issue 21283 has been resolved. | |
13 static int pseudoNameCounter = 0; | |
14 | |
15 static Parameter emitParameter(DartType type, | |
16 {String name, Element element}) { | |
17 if (name == null && element != null) { | |
18 name = element.name; | |
19 } | |
20 if (name == null) { | |
21 name = '_${pseudoNameCounter++}'; | |
22 } | |
23 Parameter parameter; | |
24 if (type.isFunctionType) { | |
25 FunctionType functionType = type; | |
26 TypeAnnotation returnType = createOptionalType(functionType.returnType); | |
27 Parameters innerParameters = createParametersFromType(functionType); | |
28 parameter = new Parameter.function(name, returnType, innerParameters); | |
29 } else { | |
30 TypeAnnotation typeAnnotation = createOptionalType(type); | |
31 parameter = new Parameter(name, type: typeAnnotation); | |
32 } | |
33 parameter.element = element; | |
34 return parameter; | |
35 } | |
36 | |
37 static Parameters createParametersFromType(FunctionType functionType) { | |
38 pseudoNameCounter = 0; | |
39 if (functionType.namedParameters.isEmpty) { | |
40 return new Parameters(createParameters(functionType.parameterTypes), | |
41 createParameters(functionType.optionalParameterTypes), false); | |
42 } else { | |
43 return new Parameters( | |
44 createParameters(functionType.parameterTypes), | |
45 createParameters(functionType.namedParameterTypes, | |
46 names: functionType.namedParameters), | |
47 true); | |
48 } | |
49 } | |
50 | |
51 static List<Parameter> createParameters(Iterable<DartType> parameterTypes, | |
52 {Iterable<String> names: const <String>[], | |
53 Iterable<Element> elements: const <Element>[]}) { | |
54 Iterator<String> name = names.iterator; | |
55 Iterator<Element> element = elements.iterator; | |
56 return parameterTypes.map((DartType type) { | |
57 name.moveNext(); | |
58 element.moveNext(); | |
59 return emitParameter(type, name: name.current, element: element.current); | |
60 }).toList(); | |
61 } | |
62 | |
63 /// Like [createTypeAnnotation] except the dynamic type is converted to null. | |
64 static TypeAnnotation createOptionalType(DartType type) { | |
65 if (type.treatAsDynamic) { | |
66 return null; | |
67 } else { | |
68 return createType(type); | |
69 } | |
70 } | |
71 | |
72 /// Creates the [TypeAnnotation] for a [type] that is not function type. | |
73 static TypeAnnotation createType(DartType type) { | |
74 if (type is GenericType) { | |
75 if (type.treatAsRaw) { | |
76 return new TypeAnnotation(type.element.name)..dartType = type; | |
77 } | |
78 return new TypeAnnotation(type.element.name, | |
79 type.typeArguments.map(createType).toList(growable: false)) | |
80 ..dartType = type; | |
81 } else if (type is VoidType) { | |
82 return new TypeAnnotation('void')..dartType = type; | |
83 } else if (type is TypeVariableType) { | |
84 return new TypeAnnotation(type.name)..dartType = type; | |
85 } else if (type is DynamicType) { | |
86 return new TypeAnnotation("dynamic")..dartType = type; | |
87 } else if (type is MalformedType) { | |
88 return new TypeAnnotation(type.name)..dartType = type; | |
89 } else { | |
90 throw "Unsupported type annotation: $type"; | |
91 } | |
92 } | |
93 } | |
OLD | NEW |