OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2016, 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 import 'dart:async'; |
| 6 import 'package:async_helper/async_helper.dart'; |
| 7 import 'package:expect/expect.dart'; |
| 8 import 'package:compiler/src/common.dart'; |
| 9 import 'package:compiler/src/elements/elements.dart' |
| 10 show Element, ClassElement, PublicName; |
| 11 import 'package:compiler/src/universe/call_structure.dart'; |
| 12 import 'package:compiler/src/universe/selector.dart'; |
| 13 import 'package:compiler/src/world.dart' show ClosedWorld, ClassQuery; |
| 14 import 'type_test_helper.dart'; |
| 15 |
| 16 void main() { |
| 17 asyncTest(() async { |
| 18 await testClassSets(); |
| 19 }); |
| 20 } |
| 21 |
| 22 const String CLASSES = r""" |
| 23 class Superclass { |
| 24 foo() {} |
| 25 } |
| 26 class Subclass extends Superclass { |
| 27 bar() {} |
| 28 } |
| 29 class Subtype implements Superclass { |
| 30 bar() {} |
| 31 } |
| 32 """; |
| 33 |
| 34 testClassSets() async { |
| 35 Selector foo, bar, baz; |
| 36 ClosedWorld closedWorld; |
| 37 ClassElement superclass, subclass, subtype; |
| 38 |
| 39 Future run(List<String> instantiated) async { |
| 40 StringBuffer main = new StringBuffer(); |
| 41 main.write('main() {'); |
| 42 for (String cls in instantiated) { |
| 43 main.write('new $cls();'); |
| 44 } |
| 45 main.write('}'); |
| 46 |
| 47 var env = await TypeEnvironment.create(CLASSES, |
| 48 mainSource: main.toString(), useMockCompiler: false); |
| 49 foo = new Selector.call(const PublicName('foo'), CallStructure.NO_ARGS); |
| 50 bar = new Selector.call(const PublicName('bar'), CallStructure.NO_ARGS); |
| 51 baz = new Selector.call(const PublicName('baz'), CallStructure.NO_ARGS); |
| 52 |
| 53 closedWorld = env.compiler.closedWorld; |
| 54 superclass = env.getElement('Superclass'); |
| 55 subclass = env.getElement('Subclass'); |
| 56 subtype = env.getElement('Subtype'); |
| 57 } |
| 58 |
| 59 void check(ClassElement cls, ClassQuery query, Selector selector, |
| 60 bool expectedResult) { |
| 61 bool result = closedWorld.needsNoSuchMethod(cls, selector, query); |
| 62 Expect.equals(expectedResult, result, |
| 63 'Unexpected result for $selector in $cls ($query)'); |
| 64 } |
| 65 |
| 66 await run([]); |
| 67 |
| 68 Expect.isFalse(closedWorld.isDirectlyInstantiated(superclass)); |
| 69 Expect.isFalse(closedWorld.isIndirectlyInstantiated(superclass)); |
| 70 Expect.isFalse(closedWorld.isImplemented(superclass)); |
| 71 |
| 72 Expect.isFalse(closedWorld.isDirectlyInstantiated(subclass)); |
| 73 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subclass)); |
| 74 Expect.isFalse(closedWorld.isImplemented(subclass)); |
| 75 |
| 76 Expect.isFalse(closedWorld.isDirectlyInstantiated(subtype)); |
| 77 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subtype)); |
| 78 Expect.isFalse(closedWorld.isImplemented(subtype)); |
| 79 |
| 80 check(superclass, ClassQuery.EXACT, foo, false); |
| 81 check(superclass, ClassQuery.EXACT, bar, false); |
| 82 check(superclass, ClassQuery.EXACT, baz, false); |
| 83 check(superclass, ClassQuery.SUBCLASS, foo, false); |
| 84 check(superclass, ClassQuery.SUBCLASS, bar, false); |
| 85 check(superclass, ClassQuery.SUBCLASS, baz, false); |
| 86 check(superclass, ClassQuery.SUBTYPE, foo, false); |
| 87 check(superclass, ClassQuery.SUBTYPE, bar, false); |
| 88 check(superclass, ClassQuery.SUBTYPE, baz, false); |
| 89 |
| 90 check(subclass, ClassQuery.EXACT, foo, false); |
| 91 check(subclass, ClassQuery.EXACT, bar, false); |
| 92 check(subclass, ClassQuery.EXACT, baz, false); |
| 93 check(subclass, ClassQuery.SUBCLASS, foo, false); |
| 94 check(subclass, ClassQuery.SUBCLASS, bar, false); |
| 95 check(subclass, ClassQuery.SUBCLASS, baz, false); |
| 96 check(subclass, ClassQuery.SUBTYPE, foo, false); |
| 97 check(subclass, ClassQuery.SUBTYPE, bar, false); |
| 98 check(subclass, ClassQuery.SUBTYPE, baz, false); |
| 99 |
| 100 check(subtype, ClassQuery.EXACT, foo, false); |
| 101 check(subtype, ClassQuery.EXACT, bar, false); |
| 102 check(subtype, ClassQuery.EXACT, baz, false); |
| 103 check(subtype, ClassQuery.SUBCLASS, foo, false); |
| 104 check(subtype, ClassQuery.SUBCLASS, bar, false); |
| 105 check(subtype, ClassQuery.SUBCLASS, baz, false); |
| 106 check(subtype, ClassQuery.SUBTYPE, foo, false); |
| 107 check(subtype, ClassQuery.SUBTYPE, bar, false); |
| 108 check(subtype, ClassQuery.SUBTYPE, baz, false); |
| 109 |
| 110 await run(['Superclass']); |
| 111 |
| 112 Expect.isTrue(closedWorld.isDirectlyInstantiated(superclass)); |
| 113 Expect.isFalse(closedWorld.isIndirectlyInstantiated(superclass)); |
| 114 Expect.isTrue(closedWorld.isImplemented(superclass)); |
| 115 |
| 116 Expect.isFalse(closedWorld.isDirectlyInstantiated(subclass)); |
| 117 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subclass)); |
| 118 Expect.isFalse(closedWorld.isImplemented(subclass)); |
| 119 |
| 120 Expect.isFalse(closedWorld.isDirectlyInstantiated(subtype)); |
| 121 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subtype)); |
| 122 Expect.isFalse(closedWorld.isImplemented(subtype)); |
| 123 |
| 124 check(superclass, ClassQuery.EXACT, foo, false); |
| 125 check(superclass, ClassQuery.EXACT, bar, true); |
| 126 check(superclass, ClassQuery.EXACT, baz, true); |
| 127 check(superclass, ClassQuery.SUBCLASS, foo, false); |
| 128 check(superclass, ClassQuery.SUBCLASS, bar, true); |
| 129 check(superclass, ClassQuery.SUBCLASS, baz, true); |
| 130 check(superclass, ClassQuery.SUBTYPE, foo, false); |
| 131 check(superclass, ClassQuery.SUBTYPE, bar, true); |
| 132 check(superclass, ClassQuery.SUBTYPE, baz, true); |
| 133 |
| 134 check(subclass, ClassQuery.EXACT, foo, false); |
| 135 check(subclass, ClassQuery.EXACT, bar, false); |
| 136 check(subclass, ClassQuery.EXACT, baz, false); |
| 137 check(subclass, ClassQuery.SUBCLASS, foo, false); |
| 138 check(subclass, ClassQuery.SUBCLASS, bar, false); |
| 139 check(subclass, ClassQuery.SUBCLASS, baz, false); |
| 140 check(subclass, ClassQuery.SUBTYPE, foo, false); |
| 141 check(subclass, ClassQuery.SUBTYPE, bar, false); |
| 142 check(subclass, ClassQuery.SUBTYPE, baz, false); |
| 143 |
| 144 check(subtype, ClassQuery.EXACT, foo, false); |
| 145 check(subtype, ClassQuery.EXACT, bar, false); |
| 146 check(subtype, ClassQuery.EXACT, baz, false); |
| 147 check(subtype, ClassQuery.SUBCLASS, foo, false); |
| 148 check(subtype, ClassQuery.SUBCLASS, bar, false); |
| 149 check(subtype, ClassQuery.SUBCLASS, baz, false); |
| 150 check(subtype, ClassQuery.SUBTYPE, foo, false); |
| 151 check(subtype, ClassQuery.SUBTYPE, bar, false); |
| 152 check(subtype, ClassQuery.SUBTYPE, baz, false); |
| 153 |
| 154 await run(['Subclass']); |
| 155 |
| 156 Expect.isFalse(closedWorld.isDirectlyInstantiated(superclass)); |
| 157 Expect.isTrue(closedWorld.isIndirectlyInstantiated(superclass)); |
| 158 Expect.isTrue(closedWorld.isImplemented(superclass)); |
| 159 |
| 160 Expect.isTrue(closedWorld.isDirectlyInstantiated(subclass)); |
| 161 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subclass)); |
| 162 Expect.isTrue(closedWorld.isImplemented(subclass)); |
| 163 |
| 164 Expect.isFalse(closedWorld.isDirectlyInstantiated(subtype)); |
| 165 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subtype)); |
| 166 Expect.isFalse(closedWorld.isImplemented(subtype)); |
| 167 |
| 168 check(superclass, ClassQuery.EXACT, foo, false); |
| 169 // Should be false since the class is not directly instantiated: |
| 170 check(superclass, ClassQuery.EXACT, bar, true); |
| 171 // Should be false since the class is not directly instantiated: |
| 172 check(superclass, ClassQuery.EXACT, baz, true); |
| 173 check(superclass, ClassQuery.SUBCLASS, foo, false); |
| 174 // Should be false since all live subclasses have a concrete implementation: |
| 175 check(superclass, ClassQuery.SUBCLASS, bar, true); |
| 176 check(superclass, ClassQuery.SUBCLASS, baz, true); |
| 177 check(superclass, ClassQuery.SUBTYPE, foo, false); |
| 178 // Should be false since all live subtypes have a concrete implementation: |
| 179 check(superclass, ClassQuery.SUBTYPE, bar, true); |
| 180 check(superclass, ClassQuery.SUBTYPE, baz, true); |
| 181 |
| 182 check(subclass, ClassQuery.EXACT, foo, false); |
| 183 check(subclass, ClassQuery.EXACT, bar, false); |
| 184 check(subclass, ClassQuery.EXACT, baz, true); |
| 185 check(subclass, ClassQuery.SUBCLASS, foo, false); |
| 186 check(subclass, ClassQuery.SUBCLASS, bar, false); |
| 187 check(subclass, ClassQuery.SUBCLASS, baz, true); |
| 188 check(subclass, ClassQuery.SUBTYPE, foo, false); |
| 189 check(subclass, ClassQuery.SUBTYPE, bar, false); |
| 190 check(subclass, ClassQuery.SUBTYPE, baz, true); |
| 191 |
| 192 check(subtype, ClassQuery.EXACT, foo, false); |
| 193 check(subtype, ClassQuery.EXACT, bar, false); |
| 194 check(subtype, ClassQuery.EXACT, baz, false); |
| 195 check(subtype, ClassQuery.SUBCLASS, foo, false); |
| 196 check(subtype, ClassQuery.SUBCLASS, bar, false); |
| 197 check(subtype, ClassQuery.SUBCLASS, baz, false); |
| 198 check(subtype, ClassQuery.SUBTYPE, foo, false); |
| 199 check(subtype, ClassQuery.SUBTYPE, bar, false); |
| 200 check(subtype, ClassQuery.SUBTYPE, baz, false); |
| 201 |
| 202 await run(['Subtype']); |
| 203 |
| 204 Expect.isFalse(closedWorld.isDirectlyInstantiated(superclass)); |
| 205 Expect.isFalse(closedWorld.isIndirectlyInstantiated(superclass)); |
| 206 Expect.isTrue(closedWorld.isImplemented(superclass)); |
| 207 |
| 208 Expect.isFalse(closedWorld.isDirectlyInstantiated(subclass)); |
| 209 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subclass)); |
| 210 Expect.isFalse(closedWorld.isImplemented(subclass)); |
| 211 |
| 212 Expect.isTrue(closedWorld.isDirectlyInstantiated(subtype)); |
| 213 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subtype)); |
| 214 Expect.isTrue(closedWorld.isImplemented(subtype)); |
| 215 |
| 216 check(superclass, ClassQuery.EXACT, foo, false); |
| 217 check(superclass, ClassQuery.EXACT, bar, false); |
| 218 check(superclass, ClassQuery.EXACT, baz, false); |
| 219 check(superclass, ClassQuery.SUBCLASS, foo, false); |
| 220 check(superclass, ClassQuery.SUBCLASS, bar, false); |
| 221 check(superclass, ClassQuery.SUBCLASS, baz, false); |
| 222 check(superclass, ClassQuery.SUBTYPE, foo, true); |
| 223 check(superclass, ClassQuery.SUBTYPE, bar, false); |
| 224 check(superclass, ClassQuery.SUBTYPE, baz, true); |
| 225 |
| 226 check(subclass, ClassQuery.EXACT, foo, false); |
| 227 check(subclass, ClassQuery.EXACT, bar, false); |
| 228 check(subclass, ClassQuery.EXACT, baz, false); |
| 229 check(subclass, ClassQuery.SUBCLASS, foo, false); |
| 230 check(subclass, ClassQuery.SUBCLASS, bar, false); |
| 231 check(subclass, ClassQuery.SUBCLASS, baz, false); |
| 232 check(subclass, ClassQuery.SUBTYPE, foo, false); |
| 233 check(subclass, ClassQuery.SUBTYPE, bar, false); |
| 234 check(subclass, ClassQuery.SUBTYPE, baz, false); |
| 235 |
| 236 check(subtype, ClassQuery.EXACT, foo, true); |
| 237 check(subtype, ClassQuery.EXACT, bar, false); |
| 238 check(subtype, ClassQuery.EXACT, baz, true); |
| 239 check(subtype, ClassQuery.SUBCLASS, foo, true); |
| 240 check(subtype, ClassQuery.SUBCLASS, bar, false); |
| 241 check(subtype, ClassQuery.SUBCLASS, baz, true); |
| 242 check(subtype, ClassQuery.SUBTYPE, foo, true); |
| 243 check(subtype, ClassQuery.SUBTYPE, bar, false); |
| 244 check(subtype, ClassQuery.SUBTYPE, baz, true); |
| 245 |
| 246 await run(['Subclass', 'Subtype']); |
| 247 |
| 248 Expect.isFalse(closedWorld.isDirectlyInstantiated(superclass)); |
| 249 Expect.isTrue(closedWorld.isIndirectlyInstantiated(superclass)); |
| 250 Expect.isTrue(closedWorld.isImplemented(superclass)); |
| 251 |
| 252 Expect.isTrue(closedWorld.isDirectlyInstantiated(subclass)); |
| 253 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subclass)); |
| 254 Expect.isTrue(closedWorld.isImplemented(subclass)); |
| 255 |
| 256 Expect.isTrue(closedWorld.isDirectlyInstantiated(subtype)); |
| 257 Expect.isFalse(closedWorld.isIndirectlyInstantiated(subtype)); |
| 258 Expect.isTrue(closedWorld.isImplemented(subtype)); |
| 259 |
| 260 check(superclass, ClassQuery.EXACT, foo, false); |
| 261 // Should be false since the class is not directly instantiated: |
| 262 check(superclass, ClassQuery.EXACT, bar, true); |
| 263 // Should be false since the class is not directly instantiated: |
| 264 check(superclass, ClassQuery.EXACT, baz, true); |
| 265 check(superclass, ClassQuery.SUBCLASS, foo, false); |
| 266 // Should be false since all live subclasses have a concrete implementation: |
| 267 check(superclass, ClassQuery.SUBCLASS, bar, true); |
| 268 check(superclass, ClassQuery.SUBCLASS, baz, true); |
| 269 check(superclass, ClassQuery.SUBTYPE, foo, true); |
| 270 // Should be false since all live subtypes have a concrete implementation: |
| 271 check(superclass, ClassQuery.SUBTYPE, bar, true); |
| 272 check(superclass, ClassQuery.SUBTYPE, baz, true); |
| 273 |
| 274 check(subclass, ClassQuery.EXACT, foo, false); |
| 275 check(subclass, ClassQuery.EXACT, bar, false); |
| 276 check(subclass, ClassQuery.EXACT, baz, true); |
| 277 check(subclass, ClassQuery.SUBCLASS, foo, false); |
| 278 check(subclass, ClassQuery.SUBCLASS, bar, false); |
| 279 check(subclass, ClassQuery.SUBCLASS, baz, true); |
| 280 check(subclass, ClassQuery.SUBTYPE, foo, false); |
| 281 check(subclass, ClassQuery.SUBTYPE, bar, false); |
| 282 check(subclass, ClassQuery.SUBTYPE, baz, true); |
| 283 |
| 284 check(subtype, ClassQuery.EXACT, foo, true); |
| 285 check(subtype, ClassQuery.EXACT, bar, false); |
| 286 check(subtype, ClassQuery.EXACT, baz, true); |
| 287 check(subtype, ClassQuery.SUBCLASS, foo, true); |
| 288 check(subtype, ClassQuery.SUBCLASS, bar, false); |
| 289 check(subtype, ClassQuery.SUBCLASS, baz, true); |
| 290 check(subtype, ClassQuery.SUBTYPE, foo, true); |
| 291 check(subtype, ClassQuery.SUBTYPE, bar, false); |
| 292 check(subtype, ClassQuery.SUBTYPE, baz, true); |
| 293 } |
OLD | NEW |