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 import 'dart:io'; | 5 import 'dart:io'; |
6 import 'package:async_helper/async_helper.dart'; | 6 import 'package:async_helper/async_helper.dart'; |
7 import 'package:compiler/src/common.dart'; | 7 import 'package:compiler/src/common.dart'; |
8 import 'package:compiler/src/compiler.dart'; | 8 import 'package:compiler/src/compiler.dart'; |
9 import 'package:compiler/src/diagnostics/diagnostic_listener.dart'; | 9 import 'package:compiler/src/diagnostics/diagnostic_listener.dart'; |
10 import 'package:compiler/src/elements/elements.dart'; | 10 import 'package:compiler/src/elements/elements.dart'; |
11 import 'package:compiler/src/elements/entities.dart'; | 11 import 'package:compiler/src/elements/entities.dart'; |
12 import 'package:compiler/src/kernel/element_map.dart'; | 12 import 'package:compiler/src/kernel/element_map.dart'; |
13 import 'package:compiler/src/kernel/kernel_backend_strategy.dart'; | 13 import 'package:compiler/src/kernel/kernel_backend_strategy.dart'; |
14 import 'package:compiler/src/resolution/access_semantics.dart'; | 14 import 'package:compiler/src/resolution/access_semantics.dart'; |
15 import 'package:compiler/src/resolution/send_structure.dart'; | 15 import 'package:compiler/src/resolution/send_structure.dart'; |
16 import 'package:compiler/src/tree/nodes.dart' as ast; | 16 import 'package:compiler/src/tree/nodes.dart' as ast; |
17 import 'package:expect/expect.dart'; | 17 import 'package:expect/expect.dart'; |
18 import 'package:kernel/ast.dart' as ir; | 18 import 'package:kernel/ast.dart' as ir; |
19 import '../equivalence/id_equivalence.dart'; | 19 import '../equivalence/id_equivalence.dart'; |
20 import '../equivalence/id_equivalence_helper.dart'; | 20 import '../equivalence/id_equivalence_helper.dart'; |
21 | 21 |
22 const List<String> dataDirectories = const <String>[ | 22 const List<String> dataDirectories = const <String>[ |
23 '../closure/data', | 23 '../closure/data', |
24 '../inference/data', | 24 '../inference/data', |
| 25 '../jumps/data', |
25 ]; | 26 ]; |
26 | 27 |
27 main() { | 28 main() { |
28 asyncTest(() async { | 29 asyncTest(() async { |
29 for (String path in dataDirectories) { | 30 for (String path in dataDirectories) { |
30 Directory dataDir = new Directory.fromUri(Platform.script.resolve(path)); | 31 Directory dataDir = new Directory.fromUri(Platform.script.resolve(path)); |
31 await for (FileSystemEntity entity in dataDir.list()) { | 32 await for (FileSystemEntity entity in dataDir.list()) { |
32 print('Checking ${entity.uri}'); | 33 print('Checking ${entity.uri}'); |
33 String annotatedCode = | 34 String annotatedCode = |
34 await new File.fromUri(entity.uri).readAsString(); | 35 await new File.fromUri(entity.uri).readAsString(); |
35 IdData data1 = await computeData( | 36 IdData data1 = await computeData( |
36 annotatedCode, computeAstMemberData, compileFromSource); | 37 annotatedCode, computeAstMemberData, compileFromSource); |
37 IdData data2 = await computeData( | 38 IdData data2 = await computeData( |
38 annotatedCode, computeIrMemberData, compileFromDill); | 39 annotatedCode, computeIrMemberData, compileFromDill); |
39 data1.actualMap.forEach((Id id, ActualData actualData1) { | 40 data1.actualMap.forEach((Id id, ActualData actualData1) { |
40 String value1 = actualData1.value; | 41 String value1 = actualData1.value; |
41 String value2 = data2.actualMap[id]?.value; | 42 String value2 = data2.actualMap[id]?.value; |
42 if (value1 != value2) { | 43 if (value1 != value2) { |
43 reportHere(data1.compiler.reporter, actualData1.sourceSpan, | 44 reportHere(data1.compiler.reporter, actualData1.sourceSpan, |
44 '$id: from source:${value1},from dill:${value2}'); | 45 '$id: from source:${value1},from dill:${value2}'); |
| 46 print('--annotations diff----------------------------------------'); |
| 47 print(data1.computeDiffCodeFor(data2)); |
| 48 print('----------------------------------------------------------'); |
45 } | 49 } |
46 Expect.equals(value1, value2, 'Value mismatch for $id'); | 50 Expect.equals(value1, value2, 'Value mismatch for $id'); |
47 }); | 51 }); |
48 data2.actualMap.forEach((Id id, ActualData actualData2) { | 52 data2.actualMap.forEach((Id id, ActualData actualData2) { |
49 String value2 = actualData2.value; | 53 String value2 = actualData2.value; |
50 String value1 = data1.actualMap[id]?.value; | 54 String value1 = data1.actualMap[id]?.value; |
51 if (value1 != value2) { | 55 if (value1 != value2) { |
52 reportHere(data2.compiler.reporter, actualData2.sourceSpan, | 56 reportHere(data2.compiler.reporter, actualData2.sourceSpan, |
53 '$id: from source:${value1},from dill:${value2}'); | 57 '$id: from source:${value1},from dill:${value2}'); |
| 58 print('--annotations diff----------------------------------------'); |
| 59 print(data1.computeDiffCodeFor(data2)); |
| 60 print('----------------------------------------------------------'); |
54 } | 61 } |
55 Expect.equals(value1, value2, 'Value mismatch for $id'); | 62 Expect.equals(value1, value2, 'Value mismatch for $id'); |
56 }); | 63 }); |
57 } | 64 } |
58 } | 65 } |
59 }); | 66 }); |
60 } | 67 } |
61 | 68 |
62 /// Compute a descriptive mapping of the [Id]s in [_member] as a | 69 /// Compute a descriptive mapping of the [Id]s in [_member] as a |
63 /// [MemberElement]. | 70 /// [MemberElement]. |
(...skipping 15 matching lines...) Expand all Loading... |
79 if (className != null) { | 86 if (className != null) { |
80 return 'member:$className.$memberName'; | 87 return 'member:$className.$memberName'; |
81 } | 88 } |
82 return 'member:$memberName'; | 89 return 'member:$memberName'; |
83 } | 90 } |
84 | 91 |
85 String computeLocalName(String localName) { | 92 String computeLocalName(String localName) { |
86 return 'local:$localName'; | 93 return 'local:$localName'; |
87 } | 94 } |
88 | 95 |
89 String computeDynamicGetName(String propertyName) { | 96 String computeGetName(String propertyName) { |
90 return 'dynamic-get:$propertyName'; | 97 return 'get:$propertyName'; |
91 } | 98 } |
92 | 99 |
93 String computeDynamicInvokeName(String propertyName) { | 100 String computeInvokeName(String propertyName) { |
94 return 'dynamic-invoke:$propertyName'; | 101 return 'invoke:$propertyName'; |
95 } | 102 } |
| 103 |
| 104 String get loopName => 'loop'; |
| 105 |
| 106 String get gotoName => 'goto'; |
96 } | 107 } |
97 | 108 |
98 /// AST visitor for computing a descriptive mapping of the [Id]s in a member. | 109 /// AST visitor for computing a descriptive mapping of the [Id]s in a member. |
99 class ResolvedAstComputer extends AbstractResolvedAstComputer | 110 class ResolvedAstComputer extends AstDataExtractor with ComputerMixin { |
100 with ComputerMixin { | |
101 ResolvedAstComputer(DiagnosticReporter reporter, | 111 ResolvedAstComputer(DiagnosticReporter reporter, |
102 Map<Id, ActualData> actualMap, ResolvedAst resolvedAst) | 112 Map<Id, ActualData> actualMap, ResolvedAst resolvedAst) |
103 : super(reporter, actualMap, resolvedAst); | 113 : super(reporter, actualMap, resolvedAst); |
104 | 114 |
105 @override | 115 @override |
106 String computeNodeValue(ast.Node node, AstElement element) { | 116 String computeNodeValue(ast.Node node, AstElement element) { |
107 if (element != null && element.isLocal) { | 117 if (element != null && element.isLocal) { |
108 return computeLocalName(element.name); | 118 return computeLocalName(element.name); |
109 } | 119 } |
| 120 if (node is ast.Loop) { |
| 121 return loopName; |
| 122 } else if (node is ast.GotoStatement) { |
| 123 return gotoName; |
| 124 } |
| 125 |
| 126 dynamic sendStructure; |
110 if (node is ast.Send) { | 127 if (node is ast.Send) { |
111 dynamic sendStructure = elements.getSendStructure(node); | 128 sendStructure = elements.getSendStructure(node); |
112 if (sendStructure == null) return null; | 129 if (sendStructure == null) return null; |
113 | 130 |
114 String getDynamicName() { | 131 String getDynamicName() { |
115 switch (sendStructure.semantics.kind) { | 132 switch (sendStructure.semantics.kind) { |
| 133 case AccessKind.PARAMETER: |
| 134 case AccessKind.FINAL_PARAMETER: |
| 135 case AccessKind.LOCAL_VARIABLE: |
| 136 case AccessKind.FINAL_LOCAL_VARIABLE: |
| 137 case AccessKind.LOCAL_FUNCTION: |
| 138 return sendStructure.semantics.element.name; |
116 case AccessKind.DYNAMIC_PROPERTY: | 139 case AccessKind.DYNAMIC_PROPERTY: |
117 DynamicAccess access = sendStructure.semantics; | 140 DynamicAccess access = sendStructure.semantics; |
118 return access.name.text; | 141 return access.name.text; |
119 default: | 142 default: |
120 return null; | 143 return null; |
121 } | 144 } |
122 } | 145 } |
123 | 146 |
124 switch (sendStructure.kind) { | 147 switch (sendStructure.kind) { |
125 case SendStructureKind.GET: | 148 case SendStructureKind.GET: |
126 String dynamicName = getDynamicName(); | 149 String dynamicName = getDynamicName(); |
127 if (dynamicName != null) return computeDynamicGetName(dynamicName); | 150 if (dynamicName != null) return computeGetName(dynamicName); |
128 break; | 151 break; |
| 152 case SendStructureKind.BINARY: |
| 153 return computeInvokeName(sendStructure.operator.selectorName); |
| 154 case SendStructureKind.EQUALS: |
| 155 return computeInvokeName('=='); |
| 156 case SendStructureKind.NOT_EQUALS: |
| 157 return computeInvokeName('!='); |
129 case SendStructureKind.INVOKE: | 158 case SendStructureKind.INVOKE: |
130 String dynamicName = getDynamicName(); | 159 String dynamicName = getDynamicName(); |
131 if (dynamicName != null) return computeDynamicInvokeName(dynamicName); | 160 if (dynamicName != null) return computeInvokeName(dynamicName); |
132 break; | 161 break; |
133 default: | 162 default: |
134 } | 163 } |
135 } | 164 } |
136 return '<unknown:$node>'; | 165 if (sendStructure != null) { |
| 166 return '<unknown:$node (${node.runtimeType}) $sendStructure>'; |
| 167 } |
| 168 return '<unknown:$node (${node.runtimeType})>'; |
137 } | 169 } |
138 | 170 |
139 @override | 171 @override |
140 String computeElementValue(AstElement element) { | 172 String computeElementValue(AstElement element) { |
141 return computeMemberName(element.enclosingClass?.name, element.name); | 173 return computeMemberName(element.enclosingClass?.name, element.name); |
142 } | 174 } |
143 } | 175 } |
144 | 176 |
145 /// Compute a descriptive mapping of the [Id]s in [member] as a kernel based | 177 /// Compute a descriptive mapping of the [Id]s in [member] as a kernel based |
146 /// member. | 178 /// member. |
147 /// | 179 /// |
148 /// Fills [actualMap] with the data and [sourceSpanMap] with the source spans | 180 /// Fills [actualMap] with the data and [sourceSpanMap] with the source spans |
149 /// for the data origin. | 181 /// for the data origin. |
150 void computeIrMemberData( | 182 void computeIrMemberData( |
151 Compiler compiler, MemberEntity member, Map<Id, ActualData> actualMap, | 183 Compiler compiler, MemberEntity member, Map<Id, ActualData> actualMap, |
152 {bool verbose: false}) { | 184 {bool verbose: false}) { |
153 KernelBackendStrategy backendStrategy = compiler.backendStrategy; | 185 KernelBackendStrategy backendStrategy = compiler.backendStrategy; |
154 KernelToElementMapForBuilding elementMap = backendStrategy.elementMap; | 186 KernelToElementMapForBuilding elementMap = backendStrategy.elementMap; |
155 MemberDefinition definition = elementMap.getMemberDefinition(member); | 187 MemberDefinition definition = elementMap.getMemberDefinition(member); |
156 assert(definition.kind == MemberKind.regular, | 188 assert(definition.kind == MemberKind.regular, |
157 failedAt(member, "Unexpected member definition $definition")); | 189 failedAt(member, "Unexpected member definition $definition")); |
158 new IrComputer(actualMap).run(definition.node); | 190 new IrComputer(actualMap).run(definition.node); |
159 } | 191 } |
160 | 192 |
161 /// IR visitor for computing a descriptive mapping of the [Id]s in a member. | 193 /// IR visitor for computing a descriptive mapping of the [Id]s in a member. |
162 class IrComputer extends AbstractIrComputer with ComputerMixin { | 194 class IrComputer extends IrDataExtractor with ComputerMixin { |
163 IrComputer(Map<Id, ActualData> actualMap) : super(actualMap); | 195 IrComputer(Map<Id, ActualData> actualMap) : super(actualMap); |
164 | 196 |
165 @override | 197 @override |
166 String computeNodeValue(ir.TreeNode node) { | 198 String computeNodeValue(ir.TreeNode node) { |
167 if (node is ir.VariableDeclaration) { | 199 if (node is ir.VariableDeclaration) { |
168 return computeLocalName(node.name); | 200 return computeLocalName(node.name); |
169 } else if (node is ir.FunctionDeclaration) { | 201 } else if (node is ir.FunctionDeclaration) { |
170 return computeLocalName(node.variable.name); | 202 return computeLocalName(node.variable.name); |
171 } else if (node is ir.FunctionExpression) { | 203 } else if (node is ir.FunctionExpression) { |
172 return computeLocalName(''); | 204 return computeLocalName(''); |
173 } else if (node is ir.MethodInvocation) { | 205 } else if (node is ir.MethodInvocation) { |
174 return computeDynamicInvokeName(node.name.name); | 206 return computeInvokeName(node.name.name); |
175 } else if (node is ir.PropertyGet) { | 207 } else if (node is ir.PropertyGet) { |
176 return computeDynamicGetName(node.name.name); | 208 return computeGetName(node.name.name); |
| 209 } else if (node is ir.VariableGet) { |
| 210 return computeGetName(node.variable.name); |
| 211 } else if (node is ir.DoStatement) { |
| 212 return loopName; |
| 213 } else if (node is ir.ForStatement) { |
| 214 return loopName; |
| 215 } else if (node is ir.ForInStatement) { |
| 216 return loopName; |
| 217 } else if (node is ir.WhileStatement) { |
| 218 return loopName; |
| 219 } else if (node is ir.BreakStatement) { |
| 220 return gotoName; |
177 } | 221 } |
178 return '<unknown:$node>'; | 222 return '<unknown:$node (${node.runtimeType})>'; |
179 } | 223 } |
180 | 224 |
181 @override | 225 @override |
182 String computeMemberValue(ir.Member member) { | 226 String computeMemberValue(ir.Member member) { |
183 return computeMemberName(member.enclosingClass?.name, member.name.name); | 227 return computeMemberName(member.enclosingClass?.name, member.name.name); |
184 } | 228 } |
185 } | 229 } |
OLD | NEW |