| 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 library dart2js.serialization.util; |
| 6 |
| 7 import '../dart_types.dart'; |
| 8 import '../common/resolution.dart'; |
| 9 import '../constants/expressions.dart'; |
| 10 import '../elements/elements.dart'; |
| 11 import '../resolution/access_semantics.dart'; |
| 12 import '../resolution/operators.dart'; |
| 13 import '../resolution/send_structure.dart'; |
| 14 import '../universe/call_structure.dart'; |
| 15 import '../universe/selector.dart'; |
| 16 import '../universe/world_impact.dart'; |
| 17 import '../universe/use.dart'; |
| 18 import '../util/enumset.dart'; |
| 19 |
| 20 import 'keys.dart'; |
| 21 import 'serialization.dart'; |
| 22 |
| 23 /// Serialize [name] into [encoder]. |
| 24 void serializeName(Name name, ObjectEncoder encoder) { |
| 25 encoder.setString(Key.NAME, name.text); |
| 26 encoder.setBool(Key.IS_SETTER, name.isSetter); |
| 27 if (name.library != null) { |
| 28 encoder.setElement(Key.LIBRARY, name.library); |
| 29 } |
| 30 } |
| 31 |
| 32 /// Deserialize a [Name] from [decoder]. |
| 33 Name deserializeName(ObjectDecoder decoder) { |
| 34 String name = decoder.getString(Key.NAME); |
| 35 bool isSetter = decoder.getBool(Key.IS_SETTER); |
| 36 LibraryElement library = |
| 37 decoder.getElement(Key.LIBRARY, isOptional: true); |
| 38 return new Name(name, library, isSetter: isSetter); |
| 39 } |
| 40 |
| 41 |
| 42 /// Serialize [selector] into [encoder]. |
| 43 void serializeSelector(Selector selector, ObjectEncoder encoder) { |
| 44 encoder.setEnum(Key.KIND, selector.kind); |
| 45 |
| 46 encoder.setInt(Key.ARGUMENTS, |
| 47 selector.callStructure.argumentCount); |
| 48 encoder.setStrings(Key.NAMED_ARGUMENTS, |
| 49 selector.callStructure.namedArguments); |
| 50 serializeName(selector.memberName, encoder); |
| 51 } |
| 52 |
| 53 /// Deserialize a [Selector] from [decoder]. |
| 54 Selector deserializeSelector(ObjectDecoder decoder) { |
| 55 SelectorKind kind = decoder.getEnum(Key.KIND, SelectorKind.values); |
| 56 int argumentCount = decoder.getInt(Key.ARGUMENTS); |
| 57 List<String> namedArguments = |
| 58 decoder.getStrings(Key.NAMED_ARGUMENTS, isOptional: true); |
| 59 String name = decoder.getString(Key.NAME); |
| 60 bool isSetter = decoder.getBool(Key.IS_SETTER); |
| 61 LibraryElement library = |
| 62 decoder.getElement(Key.LIBRARY, isOptional: true); |
| 63 return new Selector( |
| 64 kind, |
| 65 deserializeName(decoder), |
| 66 new CallStructure(argumentCount, namedArguments)); |
| 67 } |
| 68 |
| 69 /// Serialize [sendStructure] into [encoder]. |
| 70 void serializeSendStructure( |
| 71 SendStructure sendStructure, |
| 72 ObjectEncoder encoder) { |
| 73 encoder.setEnum(Key.KIND, sendStructure.kind); |
| 74 switch (sendStructure.kind) { |
| 75 case SendStructureKind.IF_NULL: |
| 76 case SendStructureKind.LOGICAL_AND: |
| 77 case SendStructureKind.LOGICAL_OR: |
| 78 case SendStructureKind.NOT: |
| 79 case SendStructureKind.INVALID_UNARY: |
| 80 case SendStructureKind.INVALID_BINARY: |
| 81 // No additional properties. |
| 82 break; |
| 83 case SendStructureKind.IS: |
| 84 IsStructure structure = sendStructure; |
| 85 encoder.setType(Key.TYPE, structure.type); |
| 86 break; |
| 87 case SendStructureKind.IS_NOT: |
| 88 IsNotStructure structure = sendStructure; |
| 89 encoder.setType(Key.TYPE, structure.type); |
| 90 break; |
| 91 case SendStructureKind.AS: |
| 92 AsStructure structure = sendStructure; |
| 93 encoder.setType(Key.TYPE, structure.type); |
| 94 break; |
| 95 case SendStructureKind.INVOKE: |
| 96 InvokeStructure structure = sendStructure; |
| 97 serializeAccessSemantics( |
| 98 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 99 serializeSelector( |
| 100 structure.selector, encoder.createObject(Key.SELECTOR)); |
| 101 break; |
| 102 case SendStructureKind.INCOMPATIBLE_INVOKE: |
| 103 IncompatibleInvokeStructure structure = sendStructure; |
| 104 serializeAccessSemantics( |
| 105 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 106 serializeSelector( |
| 107 structure.selector, encoder.createObject(Key.SELECTOR)); |
| 108 break; |
| 109 case SendStructureKind.GET: |
| 110 GetStructure structure = sendStructure; |
| 111 serializeAccessSemantics( |
| 112 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 113 break; |
| 114 case SendStructureKind.SET: |
| 115 SetStructure structure = sendStructure; |
| 116 serializeAccessSemantics( |
| 117 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 118 break; |
| 119 case SendStructureKind.UNARY: |
| 120 UnaryStructure structure = sendStructure; |
| 121 serializeAccessSemantics( |
| 122 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 123 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 124 break; |
| 125 case SendStructureKind.INDEX: |
| 126 IndexStructure structure = sendStructure; |
| 127 serializeAccessSemantics( |
| 128 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 129 break; |
| 130 case SendStructureKind.EQUALS: |
| 131 EqualsStructure structure = sendStructure; |
| 132 serializeAccessSemantics( |
| 133 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 134 break; |
| 135 case SendStructureKind.NOT_EQUALS: |
| 136 NotEqualsStructure structure = sendStructure; |
| 137 serializeAccessSemantics( |
| 138 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 139 break; |
| 140 case SendStructureKind.BINARY: |
| 141 BinaryStructure structure = sendStructure; |
| 142 serializeAccessSemantics( |
| 143 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 144 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 145 break; |
| 146 case SendStructureKind.INDEX_SET: |
| 147 IndexSetStructure structure = sendStructure; |
| 148 serializeAccessSemantics( |
| 149 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 150 break; |
| 151 case SendStructureKind.INDEX_PREFIX: |
| 152 IndexPrefixStructure structure = sendStructure; |
| 153 serializeAccessSemantics( |
| 154 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 155 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 156 break; |
| 157 case SendStructureKind.INDEX_POSTFIX: |
| 158 IndexPostfixStructure structure = sendStructure; |
| 159 serializeAccessSemantics( |
| 160 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 161 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 162 break; |
| 163 case SendStructureKind.COMPOUND: |
| 164 CompoundStructure structure = sendStructure; |
| 165 serializeAccessSemantics( |
| 166 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 167 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 168 break; |
| 169 case SendStructureKind.SET_IF_NULL: |
| 170 SetIfNullStructure structure = sendStructure; |
| 171 serializeAccessSemantics( |
| 172 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 173 break; |
| 174 case SendStructureKind.COMPOUND_INDEX_SET: |
| 175 CompoundIndexSetStructure structure = sendStructure; |
| 176 serializeAccessSemantics( |
| 177 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 178 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 179 break; |
| 180 case SendStructureKind.INDEX_SET_IF_NULL: |
| 181 IndexSetIfNullStructure structure = sendStructure; |
| 182 serializeAccessSemantics( |
| 183 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 184 break; |
| 185 case SendStructureKind.PREFIX: |
| 186 PrefixStructure structure = sendStructure; |
| 187 serializeAccessSemantics( |
| 188 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 189 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 190 break; |
| 191 case SendStructureKind.POSTFIX: |
| 192 PostfixStructure structure = sendStructure; |
| 193 serializeAccessSemantics( |
| 194 structure.semantics, encoder.createObject(Key.SEMANTICS)); |
| 195 encoder.setEnum(Key.OPERATOR, structure.operator.kind); |
| 196 break; |
| 197 case SendStructureKind.DEFERRED_PREFIX: |
| 198 DeferredPrefixStructure structure = sendStructure; |
| 199 encoder.setElement(Key.PREFIX, structure.prefix); |
| 200 serializeSendStructure(structure.sendStructure, |
| 201 encoder.createObject(Key.SEND_STRUCTURE)); |
| 202 break; |
| 203 } |
| 204 } |
| 205 |
| 206 /// Deserialize a [SendStructure] from [decoder]. |
| 207 SendStructure deserializeSendStructure(ObjectDecoder decoder) { |
| 208 SendStructureKind kind = decoder.getEnum(Key.KIND, SendStructureKind.values); |
| 209 switch (kind) { |
| 210 case SendStructureKind.IF_NULL: |
| 211 return const IfNullStructure(); |
| 212 case SendStructureKind.LOGICAL_AND: |
| 213 return const LogicalAndStructure(); |
| 214 case SendStructureKind.LOGICAL_OR: |
| 215 return const LogicalOrStructure(); |
| 216 case SendStructureKind.IS: |
| 217 return new IsStructure(decoder.getType(Key.TYPE)); |
| 218 case SendStructureKind.IS_NOT: |
| 219 return new IsNotStructure(decoder.getType(Key.TYPE)); |
| 220 case SendStructureKind.AS: |
| 221 return new AsStructure(decoder.getType(Key.TYPE)); |
| 222 case SendStructureKind.INVOKE: |
| 223 AccessSemantics semantics = |
| 224 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 225 Selector selector = deserializeSelector(decoder.getObject(Key.SELECTOR)); |
| 226 return new InvokeStructure(semantics, selector); |
| 227 case SendStructureKind.INCOMPATIBLE_INVOKE: |
| 228 AccessSemantics semantics = |
| 229 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 230 Selector selector = |
| 231 deserializeSelector(decoder.getObject(Key.SELECTOR)); |
| 232 return new IncompatibleInvokeStructure(semantics, selector); |
| 233 case SendStructureKind.GET: |
| 234 AccessSemantics semantics = |
| 235 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 236 return new GetStructure(semantics); |
| 237 case SendStructureKind.SET: |
| 238 AccessSemantics semantics = |
| 239 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 240 return new SetStructure(semantics); |
| 241 case SendStructureKind.NOT: |
| 242 return const NotStructure(); |
| 243 case SendStructureKind.UNARY: |
| 244 AccessSemantics semantics = |
| 245 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 246 return new UnaryStructure(semantics, |
| 247 UnaryOperator.fromKind( |
| 248 decoder.getEnum(Key.OPERATOR, UnaryOperatorKind.values))); |
| 249 case SendStructureKind.INVALID_UNARY: |
| 250 return new InvalidUnaryStructure(); |
| 251 case SendStructureKind.INDEX: |
| 252 AccessSemantics semantics = |
| 253 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 254 return new IndexStructure(semantics); |
| 255 case SendStructureKind.EQUALS: |
| 256 AccessSemantics semantics = |
| 257 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 258 return new EqualsStructure(semantics); |
| 259 case SendStructureKind.NOT_EQUALS: |
| 260 AccessSemantics semantics = |
| 261 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 262 return new NotEqualsStructure(semantics); |
| 263 case SendStructureKind.BINARY: |
| 264 AccessSemantics semantics = |
| 265 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 266 return new BinaryStructure(semantics, |
| 267 BinaryOperator.fromKind( |
| 268 decoder.getEnum(Key.OPERATOR, BinaryOperatorKind.values))); |
| 269 case SendStructureKind.INVALID_BINARY: |
| 270 return const InvalidBinaryStructure(); |
| 271 case SendStructureKind.INDEX_SET: |
| 272 AccessSemantics semantics = |
| 273 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 274 return new IndexSetStructure(semantics); |
| 275 case SendStructureKind.INDEX_PREFIX: |
| 276 AccessSemantics semantics = |
| 277 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 278 return new IndexPrefixStructure(semantics, |
| 279 IncDecOperator.fromKind( |
| 280 decoder.getEnum(Key.OPERATOR, IncDecOperatorKind.values))); |
| 281 case SendStructureKind.INDEX_POSTFIX: |
| 282 AccessSemantics semantics = |
| 283 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 284 return new IndexPostfixStructure(semantics, |
| 285 IncDecOperator.fromKind( |
| 286 decoder.getEnum(Key.OPERATOR, IncDecOperatorKind.values))); |
| 287 case SendStructureKind.COMPOUND: |
| 288 AccessSemantics semantics = |
| 289 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 290 return new CompoundStructure(semantics, |
| 291 AssignmentOperator.fromKind( |
| 292 decoder.getEnum(Key.OPERATOR, AssignmentOperatorKind.values))); |
| 293 case SendStructureKind.SET_IF_NULL: |
| 294 AccessSemantics semantics = |
| 295 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 296 return new SetIfNullStructure(semantics); |
| 297 case SendStructureKind.COMPOUND_INDEX_SET: |
| 298 AccessSemantics semantics = |
| 299 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 300 return new CompoundIndexSetStructure(semantics, |
| 301 AssignmentOperator.fromKind( |
| 302 decoder.getEnum(Key.OPERATOR, AssignmentOperatorKind.values))); |
| 303 case SendStructureKind.INDEX_SET_IF_NULL: |
| 304 AccessSemantics semantics = |
| 305 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 306 return new IndexSetIfNullStructure(semantics); |
| 307 case SendStructureKind.PREFIX: |
| 308 AccessSemantics semantics = |
| 309 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 310 return new PrefixStructure(semantics, |
| 311 IncDecOperator.fromKind( |
| 312 decoder.getEnum(Key.OPERATOR, IncDecOperatorKind.values))); |
| 313 case SendStructureKind.POSTFIX: |
| 314 AccessSemantics semantics = |
| 315 deserializeAccessSemantics(decoder.getObject(Key.SEMANTICS)); |
| 316 return new PostfixStructure(semantics, |
| 317 IncDecOperator.fromKind( |
| 318 decoder.getEnum(Key.OPERATOR, IncDecOperatorKind.values))); |
| 319 case SendStructureKind.DEFERRED_PREFIX: |
| 320 PrefixElement prefix = decoder.getElement(Key.PREFIX); |
| 321 SendStructure sendStructure = |
| 322 deserializeSendStructure(decoder.getObject(Key.SEND_STRUCTURE)); |
| 323 return new DeferredPrefixStructure(prefix, sendStructure); |
| 324 } |
| 325 } |
| 326 |
| 327 /// Serialize [newStructure] into [encoder]. |
| 328 void serializeNewStructure(NewStructure newStructure, ObjectEncoder encoder) { |
| 329 encoder.setEnum(Key.KIND, newStructure.kind); |
| 330 switch (newStructure.kind) { |
| 331 case NewStructureKind.NEW_INVOKE: |
| 332 NewInvokeStructure structure = newStructure; |
| 333 encoder.setEnum(Key.SUB_KIND, structure.semantics.kind); |
| 334 encoder.setElement(Key.ELEMENT, structure.semantics.element); |
| 335 encoder.setType(Key.TYPE, structure.semantics.type); |
| 336 serializeSelector(structure.selector, |
| 337 encoder.createObject(Key.SELECTOR)); |
| 338 break; |
| 339 case NewStructureKind.CONST_INVOKE: |
| 340 ConstInvokeStructure structure = newStructure; |
| 341 encoder.setEnum(Key.SUB_KIND, structure.constantInvokeKind); |
| 342 encoder.setConstant(Key.CONSTANT, structure.constant); |
| 343 break; |
| 344 case NewStructureKind.LATE_CONST: |
| 345 throw new UnsupportedError( |
| 346 'Unsupported NewStructure kind ${newStructure.kind}.'); |
| 347 } |
| 348 } |
| 349 |
| 350 /// Deserialize a [NewStructure] from [decoder]. |
| 351 NewStructure deserializeNewStructure(ObjectDecoder decoder) { |
| 352 NewStructureKind kind = decoder.getEnum(Key.KIND, NewStructureKind.values); |
| 353 switch (kind) { |
| 354 case NewStructureKind.NEW_INVOKE: |
| 355 ConstructorAccessKind constructorAccessKind = |
| 356 decoder.getEnum(Key.SUB_KIND, ConstructorAccessKind.values); |
| 357 Element element = decoder.getElement(Key.ELEMENT); |
| 358 DartType type = decoder.getType(Key.TYPE); |
| 359 ConstructorAccessSemantics semantics = |
| 360 new ConstructorAccessSemantics(constructorAccessKind, element, type); |
| 361 Selector selector = deserializeSelector(decoder.getObject(Key.SELECTOR)); |
| 362 return new NewInvokeStructure(semantics, selector); |
| 363 |
| 364 case NewStructureKind.CONST_INVOKE: |
| 365 ConstantInvokeKind constantInvokeKind = |
| 366 decoder.getEnum(Key.SUB_KIND, ConstantInvokeKind.values); |
| 367 ConstantExpression constant = decoder.getConstant(Key.CONSTANT); |
| 368 return new ConstInvokeStructure(constantInvokeKind, constant); |
| 369 case NewStructureKind.LATE_CONST: |
| 370 throw new UnsupportedError('Unsupported NewStructure kind $kind.'); |
| 371 } |
| 372 } |
| 373 |
| 374 /// Serialize [semantics] into [encoder]. |
| 375 void serializeAccessSemantics( |
| 376 AccessSemantics semantics, ObjectEncoder encoder) { |
| 377 encoder.setEnum(Key.KIND, semantics.kind); |
| 378 switch (semantics.kind) { |
| 379 case AccessKind.EXPRESSION: |
| 380 case AccessKind.THIS: |
| 381 // No additional properties. |
| 382 break; |
| 383 case AccessKind.THIS_PROPERTY: |
| 384 case AccessKind.DYNAMIC_PROPERTY: |
| 385 case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY: |
| 386 serializeName(semantics.name, encoder); |
| 387 break; |
| 388 case AccessKind.CLASS_TYPE_LITERAL: |
| 389 case AccessKind.TYPEDEF_TYPE_LITERAL: |
| 390 case AccessKind.DYNAMIC_TYPE_LITERAL: |
| 391 encoder.setConstant(Key.CONSTANT, semantics.constant); |
| 392 break; |
| 393 case AccessKind.LOCAL_FUNCTION: |
| 394 case AccessKind.LOCAL_VARIABLE: |
| 395 case AccessKind.FINAL_LOCAL_VARIABLE: |
| 396 case AccessKind.PARAMETER: |
| 397 case AccessKind.FINAL_PARAMETER: |
| 398 case AccessKind.STATIC_FIELD: |
| 399 case AccessKind.FINAL_STATIC_FIELD: |
| 400 case AccessKind.STATIC_METHOD: |
| 401 case AccessKind.STATIC_GETTER: |
| 402 case AccessKind.STATIC_SETTER: |
| 403 case AccessKind.TOPLEVEL_FIELD: |
| 404 case AccessKind.FINAL_TOPLEVEL_FIELD: |
| 405 case AccessKind.TOPLEVEL_METHOD: |
| 406 case AccessKind.TOPLEVEL_GETTER: |
| 407 case AccessKind.TOPLEVEL_SETTER: |
| 408 case AccessKind.SUPER_FIELD: |
| 409 case AccessKind.SUPER_FINAL_FIELD: |
| 410 case AccessKind.SUPER_METHOD: |
| 411 case AccessKind.SUPER_GETTER: |
| 412 case AccessKind.SUPER_SETTER: |
| 413 case AccessKind.TYPE_PARAMETER_TYPE_LITERAL: |
| 414 case AccessKind.UNRESOLVED: |
| 415 case AccessKind.UNRESOLVED_SUPER: |
| 416 case AccessKind.INVALID: |
| 417 encoder.setElement(Key.ELEMENT, semantics.element); |
| 418 break; |
| 419 case AccessKind.COMPOUND: |
| 420 CompoundAccessSemantics compoundAccess = semantics; |
| 421 encoder.setEnum(Key.SUB_KIND, compoundAccess.compoundAccessKind); |
| 422 encoder.setElement(Key.GETTER, semantics.getter); |
| 423 encoder.setElement(Key.SETTER, semantics.setter); |
| 424 break; |
| 425 case AccessKind.CONSTANT: |
| 426 throw new UnsupportedError('Unsupported access kind: ${semantics.kind}'); |
| 427 } |
| 428 } |
| 429 |
| 430 |
| 431 /// Deserialize a [AccessSemantics] from [decoder]. |
| 432 AccessSemantics deserializeAccessSemantics(ObjectDecoder decoder) { |
| 433 AccessKind kind = decoder.getEnum(Key.KIND, AccessKind.values); |
| 434 switch (kind) { |
| 435 case AccessKind.EXPRESSION: |
| 436 return const DynamicAccess.expression(); |
| 437 case AccessKind.THIS: |
| 438 return const DynamicAccess.thisAccess(); |
| 439 case AccessKind.THIS_PROPERTY: |
| 440 return new DynamicAccess.thisProperty(deserializeName(decoder)); |
| 441 case AccessKind.DYNAMIC_PROPERTY: |
| 442 return new DynamicAccess.dynamicProperty(deserializeName(decoder)); |
| 443 case AccessKind.CONDITIONAL_DYNAMIC_PROPERTY: |
| 444 return new DynamicAccess.ifNotNullProperty(deserializeName(decoder)); |
| 445 case AccessKind.CLASS_TYPE_LITERAL: |
| 446 case AccessKind.TYPEDEF_TYPE_LITERAL: |
| 447 case AccessKind.DYNAMIC_TYPE_LITERAL: |
| 448 return new ConstantAccess(kind, decoder.getConstant(Key.CONSTANT)); |
| 449 |
| 450 case AccessKind.LOCAL_FUNCTION: |
| 451 case AccessKind.LOCAL_VARIABLE: |
| 452 case AccessKind.FINAL_LOCAL_VARIABLE: |
| 453 case AccessKind.PARAMETER: |
| 454 case AccessKind.FINAL_PARAMETER: |
| 455 case AccessKind.STATIC_FIELD: |
| 456 case AccessKind.FINAL_STATIC_FIELD: |
| 457 case AccessKind.STATIC_METHOD: |
| 458 case AccessKind.STATIC_GETTER: |
| 459 case AccessKind.STATIC_SETTER: |
| 460 case AccessKind.TOPLEVEL_FIELD: |
| 461 case AccessKind.FINAL_TOPLEVEL_FIELD: |
| 462 case AccessKind.TOPLEVEL_METHOD: |
| 463 case AccessKind.TOPLEVEL_GETTER: |
| 464 case AccessKind.TOPLEVEL_SETTER: |
| 465 case AccessKind.SUPER_FIELD: |
| 466 case AccessKind.SUPER_FINAL_FIELD: |
| 467 case AccessKind.SUPER_METHOD: |
| 468 case AccessKind.SUPER_GETTER: |
| 469 case AccessKind.SUPER_SETTER: |
| 470 case AccessKind.TYPE_PARAMETER_TYPE_LITERAL: |
| 471 case AccessKind.UNRESOLVED: |
| 472 case AccessKind.UNRESOLVED_SUPER: |
| 473 case AccessKind.INVALID: |
| 474 return new StaticAccess.internal(kind, decoder.getElement(Key.ELEMENT)); |
| 475 |
| 476 case AccessKind.COMPOUND: |
| 477 CompoundAccessKind compoundAccessKind = |
| 478 decoder.getEnum(Key.SUB_KIND, CompoundAccessKind.values); |
| 479 Element getter = decoder.getElement(Key.GETTER); |
| 480 Element setter = decoder.getElement(Key.SETTER); |
| 481 return new CompoundAccessSemantics(compoundAccessKind, getter, setter); |
| 482 case AccessKind.CONSTANT: |
| 483 throw new UnsupportedError('Unsupported access kind: $kind'); |
| 484 } |
| 485 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1873573004:
Serialize TreeElements (Closed)
Base URL: https://github.com/dart-lang/sdk.git@master