OLD | NEW |
---|---|
1 // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2017, 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 /// This file declares a "shadow hierarchy" of concrete classes which extend | 5 /// This file declares a "shadow hierarchy" of concrete classes which extend |
6 /// the kernel class hierarchy, adding methods and fields needed by the | 6 /// the kernel class hierarchy, adding methods and fields needed by the |
7 /// BodyBuilder. | 7 /// BodyBuilder. |
8 /// | 8 /// |
9 /// Instances of these classes may be created using the factory methods in | 9 /// Instances of these classes may be created using the factory methods in |
10 /// `ast_factory.dart`. | 10 /// `ast_factory.dart`. |
11 /// | 11 /// |
12 /// Note that these classes represent the Dart language prior to desugaring. | 12 /// Note that these classes represent the Dart language prior to desugaring. |
13 /// When a single Dart construct desugars to a tree containing multiple kernel | 13 /// When a single Dart construct desugars to a tree containing multiple kernel |
14 /// AST nodes, the shadow class extends the kernel object at the top of the | 14 /// AST nodes, the shadow class extends the kernel object at the top of the |
15 /// desugared tree. | 15 /// desugared tree. |
16 /// | 16 /// |
17 /// This means that in some cases multiple shadow classes may extend the same | 17 /// This means that in some cases multiple shadow classes may extend the same |
18 /// kernel class, because multiple constructs in Dart may desugar to a tree | 18 /// kernel class, because multiple constructs in Dart may desugar to a tree |
19 /// with the same kind of root node. | 19 /// with the same kind of root node. |
20 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'; | |
ahe
2017/04/18 15:49:59
Relative?
| |
20 import 'package:kernel/ast.dart'; | 21 import 'package:kernel/ast.dart'; |
22 import 'package:kernel/class_hierarchy.dart'; | |
23 import 'package:kernel/core_types.dart'; | |
21 | 24 |
22 /// Concrete shadow object representing a statement block in kernel form. | 25 /// Concrete shadow object representing a statement block in kernel form. |
23 class KernelBlock extends Block implements KernelStatement { | 26 class KernelBlock extends Block implements KernelStatement { |
24 KernelBlock(List<KernelStatement> statements) : super(statements); | 27 KernelBlock(List<KernelStatement> statements) : super(statements); |
28 | |
29 @override | |
30 void _inferStatement(KernelTypeInferrer inferrer) { | |
31 // TODO(paulberry): implement. | |
32 } | |
25 } | 33 } |
26 | 34 |
27 /// Common base class for shadow objects representing expressions in kernel | 35 /// Common base class for shadow objects representing expressions in kernel |
28 /// form. | 36 /// form. |
29 abstract class KernelExpression implements Expression {} | 37 abstract class KernelExpression implements Expression { |
38 /// Calls back to [inferrer] to perform type inference for whatever concrete | |
scheglov
2017/04/18 20:09:48
The reference [inferrer] is not resolved here.
Paul Berry
2017/04/18 22:49:13
Good catch, thanks. I meant the signature to be:
| |
39 /// type of [KernelExpression] this is. | |
40 DartType _inferExpression(DartType typeContext, bool typeNeeded); | |
41 } | |
30 | 42 |
31 /// Concrete shadow object representing a function expression in kernel form. | 43 /// Concrete shadow object representing a function expression in kernel form. |
32 class KernelFunctionExpression extends FunctionExpression | 44 class KernelFunctionExpression extends FunctionExpression |
33 implements KernelExpression { | 45 implements KernelExpression { |
34 KernelFunctionExpression(FunctionNode function) : super(function); | 46 KernelFunctionExpression(FunctionNode function) : super(function); |
47 | |
48 @override | |
49 DartType _inferExpression(DartType typeContext, bool typeNeeded) { | |
50 // TODO(paulberry): implement. | |
51 return typeNeeded ? const DynamicType() : null; | |
52 } | |
35 } | 53 } |
36 | 54 |
37 /// Concrete shadow object representing an integer literal in kernel form. | 55 /// Concrete shadow object representing an integer literal in kernel form. |
38 class KernelIntLiteral extends IntLiteral implements KernelExpression { | 56 class KernelIntLiteral extends IntLiteral implements KernelExpression { |
39 KernelIntLiteral(int value) : super(value); | 57 KernelIntLiteral(int value) : super(value); |
58 | |
59 @override | |
60 DartType _inferExpression(DartType typeContext, bool typeNeeded) { | |
61 // TODO(paulberry): implement. | |
62 return typeNeeded ? const DynamicType() : null; | |
63 } | |
40 } | 64 } |
41 | 65 |
42 /// Concrete shadow object representing a list literal in kernel form. | 66 /// Concrete shadow object representing a list literal in kernel form. |
43 class KernelListLiteral extends ListLiteral implements KernelExpression { | 67 class KernelListLiteral extends ListLiteral implements KernelExpression { |
44 KernelListLiteral(List<KernelExpression> expressions, | 68 KernelListLiteral(List<KernelExpression> expressions, |
45 {DartType typeArgument, bool isConst: false}) | 69 {DartType typeArgument, bool isConst: false}) |
46 : super(expressions, typeArgument: typeArgument, isConst: isConst); | 70 : super(expressions, typeArgument: typeArgument, isConst: isConst); |
71 | |
72 @override | |
73 DartType _inferExpression(DartType typeContext, bool typeNeeded) { | |
74 // TODO(paulberry): implement. | |
75 return typeNeeded ? const DynamicType() : null; | |
76 } | |
47 } | 77 } |
48 | 78 |
49 /// Concrete shadow object representing a null literal in kernel form. | 79 /// Concrete shadow object representing a null literal in kernel form. |
50 class KernelNullLiteral extends NullLiteral implements KernelExpression {} | 80 class KernelNullLiteral extends NullLiteral implements KernelExpression { |
81 @override | |
82 DartType _inferExpression(DartType typeContext, bool typeNeeded) { | |
83 // TODO(paulberry): implement. | |
84 return typeNeeded ? const DynamicType() : null; | |
85 } | |
86 } | |
51 | 87 |
52 /// Concrete shadow object representing a return statement in kernel form. | 88 /// Concrete shadow object representing a return statement in kernel form. |
53 class KernelReturnStatement extends ReturnStatement implements KernelStatement { | 89 class KernelReturnStatement extends ReturnStatement implements KernelStatement { |
54 KernelReturnStatement([KernelExpression expression]) : super(expression); | 90 KernelReturnStatement([KernelExpression expression]) : super(expression); |
91 | |
92 @override | |
93 void _inferStatement(KernelTypeInferrer inferrer) { | |
94 // TODO(paulberry): implement. | |
95 } | |
55 } | 96 } |
56 | 97 |
57 /// Common base class for shadow objects representing statements in kernel | 98 /// Common base class for shadow objects representing statements in kernel |
58 /// form. | 99 /// form. |
59 abstract class KernelStatement extends Statement {} | 100 abstract class KernelStatement extends Statement { |
101 /// Calls back to [inferrer] to perform type inference for whatever concrete | |
102 /// type of [KernelStatement] this is. | |
103 void _inferStatement(KernelTypeInferrer inferrer); | |
104 } | |
105 | |
106 /// Concrete implementation of [TypeInferrer] specialized to work with kernel | |
107 /// objects. | |
108 class KernelTypeInferrer extends TypeInferrer<Statement, Expression, | |
109 KernelVariableDeclaration, Field> { | |
110 KernelTypeInferrer(CoreTypes coreTypes, ClassHierarchy classHierarchy) | |
111 : super(coreTypes, classHierarchy); | |
112 | |
113 @override | |
114 DartType inferExpression( | |
115 Expression expression, DartType typeContext, bool typeNeeded) { | |
116 if (expression is KernelExpression) { | |
117 // Use polymorphic dispatch on [KernelExpression] to perform whatever kind | |
118 // of type inference is correct for this kind of statement. | |
119 // TODO(paulberry): experiment to see if dynamic dispatch would be better, | |
120 // so that the type hierarchy will be simpler (which may speed up "is" | |
121 // checks). | |
122 return expression._inferExpression(typeContext, typeNeeded); | |
123 } else { | |
124 // Encountered an expression type for which type inference is not yet | |
125 // implemented, so just infer dynamic for now. | |
126 // TODO(paulberry): once the BodyBuilder uses shadow classes for | |
127 // everything, this case should no longer be needed. | |
128 return typeNeeded ? const DynamicType() : null; | |
129 } | |
130 } | |
131 | |
132 @override | |
133 void inferStatement(Statement statement) { | |
134 if (statement is KernelStatement) { | |
135 // Use polymorphic dispatch on [KernelStatement] to perform whatever kind | |
136 // of type inference is correct for this kind of statement. | |
137 // TODO(paulberry): experiment to see if dynamic dispatch would be better, | |
138 // so that the type hierarchy will be simpler (which may speed up "is" | |
139 // checks). | |
140 return statement._inferStatement(this); | |
141 } else { | |
142 // Encountered a statement type for which type inference is not yet | |
143 // implemented, so just skip it for now. | |
144 // TODO(paulberry): once the BodyBuilder uses shadow classes for | |
145 // everything, this case should no longer be needed. | |
146 } | |
147 } | |
148 } | |
60 | 149 |
61 /// Concrete shadow object representing a variable declaration in kernel form. | 150 /// Concrete shadow object representing a variable declaration in kernel form. |
62 class KernelVariableDeclaration extends VariableDeclaration | 151 class KernelVariableDeclaration extends VariableDeclaration |
63 implements KernelStatement { | 152 implements KernelStatement { |
64 KernelVariableDeclaration(String name, | 153 KernelVariableDeclaration(String name, |
65 {KernelExpression initializer, | 154 {KernelExpression initializer, |
66 DartType type, | 155 DartType type, |
67 bool isFinal: false, | 156 bool isFinal: false, |
68 bool isConst: false}) | 157 bool isConst: false}) |
69 : super(name, | 158 : super(name, |
70 initializer: initializer, | 159 initializer: initializer, |
71 type: type, | 160 type: type, |
72 isFinal: isFinal, | 161 isFinal: isFinal, |
73 isConst: isConst); | 162 isConst: isConst); |
163 | |
164 @override | |
165 void _inferStatement(KernelTypeInferrer inferrer) { | |
166 // TODO(paulberry): implement. | |
167 } | |
74 } | 168 } |
75 | 169 |
76 /// Concrete shadow object representing a read from a variable in kernel form. | 170 /// Concrete shadow object representing a read from a variable in kernel form. |
77 class KernelVariableGet extends VariableGet implements KernelExpression { | 171 class KernelVariableGet extends VariableGet implements KernelExpression { |
78 KernelVariableGet(VariableDeclaration variable, [DartType promotedType]) | 172 KernelVariableGet(VariableDeclaration variable, [DartType promotedType]) |
79 : super(variable, promotedType); | 173 : super(variable, promotedType); |
174 | |
175 @override | |
176 DartType _inferExpression(DartType typeContext, bool typeNeeded) { | |
177 // TODO(paulberry): implement. | |
178 return typeNeeded ? const DynamicType() : null; | |
179 } | |
80 } | 180 } |
OLD | NEW |