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