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 #ifndef VM_KERNEL_H_ |
| 6 #define VM_KERNEL_H_ |
| 7 |
| 8 #include "platform/assert.h" |
| 9 #include "vm/allocation.h" |
| 10 #include "vm/globals.h" |
| 11 |
| 12 #define KERNEL_NODES_DO(M) \ |
| 13 M(Name) \ |
| 14 M(InferredValue) \ |
| 15 M(DartType) \ |
| 16 M(InvalidType) \ |
| 17 M(DynamicType) \ |
| 18 M(VoidType) \ |
| 19 M(InterfaceType) \ |
| 20 M(FunctionType) \ |
| 21 M(TypeParameterType) |
| 22 |
| 23 #define KERNEL_TREE_NODES_DO(M) \ |
| 24 M(Library) \ |
| 25 M(Class) \ |
| 26 M(NormalClass) \ |
| 27 M(MixinClass) \ |
| 28 M(Member) \ |
| 29 M(Field) \ |
| 30 M(Constructor) \ |
| 31 M(Procedure) \ |
| 32 M(Initializer) \ |
| 33 M(InvalidInitializer) \ |
| 34 M(FieldInitializer) \ |
| 35 M(SuperInitializer) \ |
| 36 M(RedirectingInitializer) \ |
| 37 M(LocalInitializer) \ |
| 38 M(FunctionNode) \ |
| 39 M(Expression) \ |
| 40 M(InvalidExpression) \ |
| 41 M(VariableGet) \ |
| 42 M(VariableSet) \ |
| 43 M(PropertyGet) \ |
| 44 M(PropertySet) \ |
| 45 M(DirectPropertyGet) \ |
| 46 M(DirectPropertySet) \ |
| 47 M(StaticGet) \ |
| 48 M(StaticSet) \ |
| 49 M(Arguments) \ |
| 50 M(NamedExpression) \ |
| 51 M(MethodInvocation) \ |
| 52 M(DirectMethodInvocation) \ |
| 53 M(StaticInvocation) \ |
| 54 M(ConstructorInvocation) \ |
| 55 M(Not) \ |
| 56 M(LogicalExpression) \ |
| 57 M(ConditionalExpression) \ |
| 58 M(StringConcatenation) \ |
| 59 M(IsExpression) \ |
| 60 M(AsExpression) \ |
| 61 M(BasicLiteral) \ |
| 62 M(StringLiteral) \ |
| 63 M(BigintLiteral) \ |
| 64 M(IntLiteral) \ |
| 65 M(DoubleLiteral) \ |
| 66 M(BoolLiteral) \ |
| 67 M(NullLiteral) \ |
| 68 M(SymbolLiteral) \ |
| 69 M(TypeLiteral) \ |
| 70 M(ThisExpression) \ |
| 71 M(Rethrow) \ |
| 72 M(Throw) \ |
| 73 M(ListLiteral) \ |
| 74 M(MapLiteral) \ |
| 75 M(MapEntry) \ |
| 76 M(AwaitExpression) \ |
| 77 M(FunctionExpression) \ |
| 78 M(Let) \ |
| 79 M(BlockExpression) \ |
| 80 M(Statement) \ |
| 81 M(InvalidStatement) \ |
| 82 M(ExpressionStatement) \ |
| 83 M(Block) \ |
| 84 M(EmptyStatement) \ |
| 85 M(AssertStatement) \ |
| 86 M(LabeledStatement) \ |
| 87 M(BreakStatement) \ |
| 88 M(WhileStatement) \ |
| 89 M(DoStatement) \ |
| 90 M(ForStatement) \ |
| 91 M(ForInStatement) \ |
| 92 M(SwitchStatement) \ |
| 93 M(SwitchCase) \ |
| 94 M(ContinueSwitchStatement) \ |
| 95 M(IfStatement) \ |
| 96 M(ReturnStatement) \ |
| 97 M(TryCatch) \ |
| 98 M(Catch) \ |
| 99 M(TryFinally) \ |
| 100 M(YieldStatement) \ |
| 101 M(VariableDeclaration) \ |
| 102 M(FunctionDeclaration) \ |
| 103 M(TypeParameter) \ |
| 104 M(Program) |
| 105 |
| 106 #define KERNEL_ALL_NODES_DO(M) \ |
| 107 M(Node) \ |
| 108 KERNEL_NODES_DO(M) \ |
| 109 M(TreeNode) \ |
| 110 KERNEL_TREE_NODES_DO(M) |
| 111 |
| 112 #define KERNEL_VISITORS_DO(M) \ |
| 113 M(ExpressionVisitor) \ |
| 114 M(StatementVisitor) \ |
| 115 M(MemberVisitor) \ |
| 116 M(ClassVisitor) \ |
| 117 M(InitializerVisitor) \ |
| 118 M(DartTypeVisitor) \ |
| 119 M(ClassReferenceVisitor) \ |
| 120 M(MemberReferenceVisitor) \ |
| 121 M(TreeVisitor) \ |
| 122 M(Visitor) |
| 123 |
| 124 namespace dart { |
| 125 |
| 126 namespace kernel { |
| 127 |
| 128 |
| 129 class Reader; |
| 130 class TreeNode; |
| 131 class TypeParameter; |
| 132 class Writer; |
| 133 |
| 134 // Boxes a value of type `T*` and `delete`s it on destruction. |
| 135 template <typename T> |
| 136 class Child { |
| 137 public: |
| 138 Child() : pointer_(NULL) {} |
| 139 explicit Child(T* value) : pointer_(value) {} |
| 140 |
| 141 ~Child() { delete pointer_; } |
| 142 |
| 143 // Support `Child<T> box = T* obj`. |
| 144 T*& operator=(T* value) { |
| 145 ASSERT(pointer_ == NULL); |
| 146 return pointer_ = value; |
| 147 } |
| 148 |
| 149 // Implicitly convert `Child<T>` to `T*`. |
| 150 operator T*&() { return pointer_; } |
| 151 |
| 152 T* operator->() { return pointer_; } |
| 153 |
| 154 private: |
| 155 T* pointer_; |
| 156 }; |
| 157 |
| 158 // Boxes a value of type `T*` (only used to mark a member as a weak reference). |
| 159 template <typename T> |
| 160 class Ref { |
| 161 public: |
| 162 Ref() : pointer_(NULL) {} |
| 163 explicit Ref(T* value) : pointer_(value) {} |
| 164 |
| 165 // Support `Ref<T> box = T* obj`. |
| 166 T*& operator=(T* value) { |
| 167 ASSERT(pointer_ == NULL); |
| 168 return pointer_ = value; |
| 169 } |
| 170 |
| 171 // Implicitly convert `Ref<T>` to `T*`. |
| 172 operator T*&() { return pointer_; } |
| 173 |
| 174 T* operator->() { return pointer_; } |
| 175 |
| 176 private: |
| 177 T* pointer_; |
| 178 }; |
| 179 |
| 180 |
| 181 template <typename T> |
| 182 class List { |
| 183 public: |
| 184 List() : array_(NULL), length_(0) {} |
| 185 ~List(); |
| 186 |
| 187 template <typename IT> |
| 188 void ReadFrom(Reader* reader); |
| 189 |
| 190 template <typename IT> |
| 191 void ReadFrom(Reader* reader, TreeNode* parent); |
| 192 |
| 193 template <typename IT> |
| 194 void ReadFromStatic(Reader* reader); |
| 195 |
| 196 void WriteTo(Writer* writer); |
| 197 |
| 198 template <typename IT> |
| 199 void WriteToStatic(Writer* writer); |
| 200 |
| 201 // Extends the array to at least be able to hold [length] elements. |
| 202 // |
| 203 // Free places will be filled with `NULL` values. |
| 204 void EnsureInitialized(int length); |
| 205 |
| 206 // Returns element at [index]. |
| 207 // |
| 208 // If the array is not big enough, it will be grown via `EnsureInitialized`. |
| 209 // If the element doesn't exist, it will be created via `new IT()`. |
| 210 template <typename IT> |
| 211 IT* GetOrCreate(int index); |
| 212 |
| 213 template <typename IT, typename PT> |
| 214 IT* GetOrCreate(int index, PT* parent); |
| 215 |
| 216 // Returns element at [index]. |
| 217 T*& operator[](int index) { |
| 218 ASSERT(index < length_); |
| 219 return array_[index]; |
| 220 } |
| 221 |
| 222 int length() { return length_; } |
| 223 |
| 224 T** raw_array() { return array_; } |
| 225 |
| 226 private: |
| 227 T** array_; |
| 228 int length_; |
| 229 |
| 230 DISALLOW_COPY_AND_ASSIGN(List); |
| 231 }; |
| 232 |
| 233 |
| 234 class TypeParameterList : public List<TypeParameter> { |
| 235 public: |
| 236 void ReadFrom(Reader* reader); |
| 237 void WriteTo(Writer* writer); |
| 238 }; |
| 239 |
| 240 |
| 241 template <typename A, typename B> |
| 242 class Tuple { |
| 243 public: |
| 244 static Tuple<A, B>* ReadFrom(Reader* reader); |
| 245 void WriteTo(Writer* writer); |
| 246 |
| 247 Tuple(A* a, B* b) : first_(a), second_(b) {} |
| 248 |
| 249 A* first() { return first_; } |
| 250 B* second() { return second_; } |
| 251 |
| 252 private: |
| 253 Tuple() {} |
| 254 |
| 255 Ref<A> first_; |
| 256 Child<B> second_; |
| 257 |
| 258 DISALLOW_COPY_AND_ASSIGN(Tuple); |
| 259 }; |
| 260 |
| 261 |
| 262 class String { |
| 263 public: |
| 264 static String* ReadFrom(Reader* reader); |
| 265 static String* ReadFromImpl(Reader* reader); |
| 266 void WriteTo(Writer* writer); |
| 267 void WriteToImpl(Writer* writer); |
| 268 |
| 269 String(const uint8_t* utf8, int length) { |
| 270 buffer_ = new uint8_t[length]; |
| 271 size_ = length; |
| 272 memmove(buffer_, utf8, length); |
| 273 } |
| 274 ~String() { delete[] buffer_; } |
| 275 |
| 276 uint8_t* buffer() { return buffer_; } |
| 277 int size() { return size_; } |
| 278 |
| 279 bool is_empty() { return size_ == 0; } |
| 280 |
| 281 private: |
| 282 uint8_t* buffer_; |
| 283 int size_; |
| 284 |
| 285 DISALLOW_COPY_AND_ASSIGN(String); |
| 286 }; |
| 287 |
| 288 |
| 289 class StringTable { |
| 290 public: |
| 291 void ReadFrom(Reader* reader); |
| 292 void WriteTo(Writer* writer); |
| 293 |
| 294 List<String>& strings() { return strings_; } |
| 295 |
| 296 private: |
| 297 StringTable() {} |
| 298 |
| 299 friend class Program; |
| 300 |
| 301 List<String> strings_; |
| 302 |
| 303 DISALLOW_COPY_AND_ASSIGN(StringTable); |
| 304 }; |
| 305 |
| 306 |
| 307 class LineStartingTable { |
| 308 public: |
| 309 void ReadFrom(Reader* reader, intptr_t length); |
| 310 void WriteTo(Writer* writer); |
| 311 ~LineStartingTable() { |
| 312 for (intptr_t i = 0; i < size_; ++i) { |
| 313 delete[] values_[i]; |
| 314 } |
| 315 delete[] values_; |
| 316 } |
| 317 |
| 318 intptr_t size() { return size_; } |
| 319 intptr_t* valuesFor(int i) { return values_[i]; } |
| 320 |
| 321 private: |
| 322 LineStartingTable() : values_(NULL), size_(0) {} |
| 323 |
| 324 friend class Program; |
| 325 |
| 326 intptr_t** values_; |
| 327 intptr_t size_; |
| 328 |
| 329 DISALLOW_COPY_AND_ASSIGN(LineStartingTable); |
| 330 }; |
| 331 |
| 332 // Forward declare all classes. |
| 333 #define DO(name) class name; |
| 334 KERNEL_ALL_NODES_DO(DO) |
| 335 KERNEL_VISITORS_DO(DO) |
| 336 #undef DO |
| 337 |
| 338 |
| 339 #define DEFINE_CASTING_OPERATIONS(klass) \ |
| 340 virtual bool Is##klass() { return true; } \ |
| 341 \ |
| 342 static klass* Cast(Node* node) { \ |
| 343 ASSERT(node == NULL || node->Is##klass()); \ |
| 344 return static_cast<klass*>(node); \ |
| 345 } \ |
| 346 \ |
| 347 virtual Node::NodeType Type() { return Node::kType##klass; } |
| 348 |
| 349 #define DEFINE_IS_OPERATION(klass) \ |
| 350 virtual bool Is##klass() { return false; } |
| 351 |
| 352 #define DEFINE_ALL_IS_OPERATIONS() \ |
| 353 KERNEL_NODES_DO(DEFINE_IS_OPERATION) \ |
| 354 DEFINE_IS_OPERATION(TreeNode) \ |
| 355 KERNEL_TREE_NODES_DO(DEFINE_IS_OPERATION) |
| 356 |
| 357 |
| 358 class Node { |
| 359 public: |
| 360 virtual ~Node(); |
| 361 |
| 362 enum NodeType { |
| 363 #define DO(name) kType##name, |
| 364 KERNEL_ALL_NODES_DO(DO) |
| 365 #undef DO |
| 366 |
| 367 kNumTypes |
| 368 }; |
| 369 |
| 370 DEFINE_ALL_IS_OPERATIONS(); |
| 371 DEFINE_CASTING_OPERATIONS(Node); |
| 372 |
| 373 virtual void AcceptVisitor(Visitor* visitor) = 0; |
| 374 virtual void VisitChildren(Visitor* visitor) = 0; |
| 375 |
| 376 protected: |
| 377 Node() { } |
| 378 |
| 379 private: |
| 380 DISALLOW_COPY_AND_ASSIGN(Node); |
| 381 }; |
| 382 |
| 383 |
| 384 class TreeNode : public Node { |
| 385 public: |
| 386 virtual ~TreeNode(); |
| 387 |
| 388 DEFINE_CASTING_OPERATIONS(TreeNode); |
| 389 |
| 390 virtual void AcceptVisitor(Visitor* visitor); |
| 391 virtual void AcceptTreeVisitor(TreeVisitor* visitor) = 0; |
| 392 |
| 393 protected: |
| 394 TreeNode() {} |
| 395 |
| 396 private: |
| 397 DISALLOW_COPY_AND_ASSIGN(TreeNode); |
| 398 }; |
| 399 |
| 400 |
| 401 class Library : public TreeNode { |
| 402 public: |
| 403 Library* ReadFrom(Reader* reader); |
| 404 void WriteTo(Writer* writer); |
| 405 |
| 406 virtual ~Library(); |
| 407 |
| 408 DEFINE_CASTING_OPERATIONS(Library); |
| 409 |
| 410 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 411 virtual void VisitChildren(Visitor* visitor); |
| 412 |
| 413 String* import_uri() { return import_uri_; } |
| 414 String* name() { return name_; } |
| 415 List<Class>& classes() { return classes_; } |
| 416 List<Field>& fields() { return fields_; } |
| 417 List<Procedure>& procedures() { return procedures_; } |
| 418 |
| 419 bool IsCorelibrary() { |
| 420 static const char* dart_library = "dart:"; |
| 421 static intptr_t dart_library_length = strlen(dart_library); |
| 422 static const char* patch_library = "dart:_patch"; |
| 423 static intptr_t patch_library_length = strlen(patch_library); |
| 424 |
| 425 if (name_->size() < 5) return false; |
| 426 |
| 427 // Check for dart: prefix. |
| 428 char* buffer = reinterpret_cast<char*>(import_uri_->buffer()); |
| 429 if (strncmp(buffer, dart_library, dart_library_length) != 0) { |
| 430 return false; |
| 431 } |
| 432 |
| 433 // Rasta emits dart:_patch and we should treat it as a user library. |
| 434 if (name_->size() == patch_library_length && |
| 435 strncmp(buffer, patch_library, patch_library_length) == 0) { |
| 436 return false; |
| 437 } |
| 438 return true; |
| 439 } |
| 440 |
| 441 private: |
| 442 Library() : name_(NULL) {} |
| 443 |
| 444 template <typename T> |
| 445 friend class List; |
| 446 |
| 447 Ref<String> name_; |
| 448 Ref<String> import_uri_; |
| 449 List<Class> classes_; |
| 450 List<Field> fields_; |
| 451 List<Procedure> procedures_; |
| 452 |
| 453 DISALLOW_COPY_AND_ASSIGN(Library); |
| 454 }; |
| 455 |
| 456 |
| 457 class Class : public TreeNode { |
| 458 public: |
| 459 Class* ReadFrom(Reader* reader); |
| 460 void WriteTo(Writer* writer); |
| 461 |
| 462 virtual ~Class(); |
| 463 |
| 464 DEFINE_CASTING_OPERATIONS(Class); |
| 465 |
| 466 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 467 virtual void AcceptClassVisitor(ClassVisitor* visitor) = 0; |
| 468 virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor) = 0; |
| 469 |
| 470 Library* parent() { return parent_; } |
| 471 String* name() { return name_; } |
| 472 bool is_abstract() { return is_abstract_; } |
| 473 List<Expression>& annotations() { return annotations_; } |
| 474 |
| 475 virtual List<TypeParameter>& type_parameters() = 0; |
| 476 virtual List<InterfaceType>& implemented_classes() = 0; |
| 477 virtual List<Field>& fields() = 0; |
| 478 virtual List<Constructor>& constructors() = 0; |
| 479 virtual List<Procedure>& procedures() = 0; |
| 480 |
| 481 protected: |
| 482 Class() : is_abstract_(false) {} |
| 483 |
| 484 private: |
| 485 template <typename T> |
| 486 friend class List; |
| 487 |
| 488 Ref<Library> parent_; |
| 489 Ref<String> name_; |
| 490 bool is_abstract_; |
| 491 List<Expression> annotations_; |
| 492 |
| 493 DISALLOW_COPY_AND_ASSIGN(Class); |
| 494 }; |
| 495 |
| 496 |
| 497 class NormalClass : public Class { |
| 498 public: |
| 499 NormalClass* ReadFrom(Reader* reader); |
| 500 void WriteTo(Writer* writer); |
| 501 |
| 502 virtual ~NormalClass(); |
| 503 |
| 504 DEFINE_CASTING_OPERATIONS(NormalClass); |
| 505 |
| 506 virtual void AcceptClassVisitor(ClassVisitor* visitor); |
| 507 virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor); |
| 508 virtual void VisitChildren(Visitor* visitor); |
| 509 |
| 510 virtual TypeParameterList& type_parameters() { return type_parameters_; } |
| 511 InterfaceType* super_class() { return super_class_; } |
| 512 virtual List<InterfaceType>& implemented_classes() { |
| 513 return implemented_classes_; |
| 514 } |
| 515 virtual List<Constructor>& constructors() { return constructors_; } |
| 516 virtual List<Procedure>& procedures() { return procedures_; } |
| 517 virtual List<Field>& fields() { return fields_; } |
| 518 |
| 519 private: |
| 520 NormalClass() {} |
| 521 |
| 522 template <typename T> |
| 523 friend class List; |
| 524 |
| 525 TypeParameterList type_parameters_; |
| 526 Child<InterfaceType> super_class_; |
| 527 List<InterfaceType> implemented_classes_; |
| 528 List<Constructor> constructors_; |
| 529 List<Procedure> procedures_; |
| 530 List<Field> fields_; |
| 531 |
| 532 DISALLOW_COPY_AND_ASSIGN(NormalClass); |
| 533 }; |
| 534 |
| 535 |
| 536 class MixinClass : public Class { |
| 537 public: |
| 538 MixinClass* ReadFrom(Reader* reader); |
| 539 void WriteTo(Writer* writer); |
| 540 |
| 541 virtual ~MixinClass(); |
| 542 |
| 543 DEFINE_CASTING_OPERATIONS(MixinClass); |
| 544 |
| 545 virtual void AcceptClassVisitor(ClassVisitor* visitor); |
| 546 virtual void AcceptReferenceVisitor(ClassReferenceVisitor* visitor); |
| 547 virtual void VisitChildren(Visitor* visitor); |
| 548 |
| 549 virtual TypeParameterList& type_parameters() { return type_parameters_; } |
| 550 InterfaceType* first() { return first_; } |
| 551 InterfaceType* second() { return second_; } |
| 552 virtual List<InterfaceType>& implemented_classes() { |
| 553 return implemented_classes_; |
| 554 } |
| 555 virtual List<Constructor>& constructors() { return constructors_; } |
| 556 virtual List<Field>& fields() { return fields_; } |
| 557 virtual List<Procedure>& procedures() { return procedures_; } |
| 558 |
| 559 private: |
| 560 MixinClass() {} |
| 561 |
| 562 template <typename T> |
| 563 friend class List; |
| 564 |
| 565 TypeParameterList type_parameters_; |
| 566 Child<InterfaceType> first_; |
| 567 Child<InterfaceType> second_; |
| 568 List<InterfaceType> implemented_classes_; |
| 569 List<Constructor> constructors_; |
| 570 |
| 571 // Dummy instances which are empty lists. |
| 572 List<Field> fields_; |
| 573 List<Procedure> procedures_; |
| 574 |
| 575 DISALLOW_COPY_AND_ASSIGN(MixinClass); |
| 576 }; |
| 577 |
| 578 |
| 579 class Member : public TreeNode { |
| 580 public: |
| 581 virtual ~Member(); |
| 582 |
| 583 DEFINE_CASTING_OPERATIONS(Member); |
| 584 |
| 585 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 586 virtual void AcceptMemberVisitor(MemberVisitor* visitor) = 0; |
| 587 virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor) = 0; |
| 588 |
| 589 TreeNode* parent() { return parent_; } |
| 590 Name* name() { return name_; } |
| 591 List<Expression>& annotations() { return annotations_; } |
| 592 |
| 593 protected: |
| 594 Member() { } |
| 595 |
| 596 template <typename T> |
| 597 friend class List; |
| 598 |
| 599 Ref<TreeNode> parent_; |
| 600 Child<Name> name_; |
| 601 List<Expression> annotations_; |
| 602 |
| 603 private: |
| 604 DISALLOW_COPY_AND_ASSIGN(Member); |
| 605 }; |
| 606 |
| 607 |
| 608 class Field : public Member { |
| 609 public: |
| 610 enum Flags { |
| 611 kFlagFinal = 1 << 0, |
| 612 kFlagConst = 1 << 1, |
| 613 kFlagStatic = 1 << 2, |
| 614 }; |
| 615 |
| 616 Field* ReadFrom(Reader* reader); |
| 617 void WriteTo(Writer* writer); |
| 618 |
| 619 virtual ~Field(); |
| 620 |
| 621 DEFINE_CASTING_OPERATIONS(Field); |
| 622 |
| 623 virtual void AcceptMemberVisitor(MemberVisitor* visitor); |
| 624 virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor); |
| 625 virtual void VisitChildren(Visitor* visitor); |
| 626 |
| 627 bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; } |
| 628 bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; } |
| 629 bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; } |
| 630 |
| 631 DartType* type() { return type_; } |
| 632 InferredValue* inferred_value() { return inferred_value_; } |
| 633 Expression* initializer() { return initializer_; } |
| 634 |
| 635 private: |
| 636 Field() {} |
| 637 |
| 638 template <typename T> |
| 639 friend class List; |
| 640 |
| 641 word flags_; |
| 642 Child<DartType> type_; |
| 643 Child<InferredValue> inferred_value_; |
| 644 Child<Expression> initializer_; |
| 645 |
| 646 DISALLOW_COPY_AND_ASSIGN(Field); |
| 647 }; |
| 648 |
| 649 |
| 650 class Constructor : public Member { |
| 651 public: |
| 652 enum Flags { |
| 653 kFlagConst = 1 << 0, |
| 654 kFlagExternal = 1 << 1, |
| 655 }; |
| 656 |
| 657 Constructor* ReadFrom(Reader* reader); |
| 658 void WriteTo(Writer* writer); |
| 659 |
| 660 virtual ~Constructor(); |
| 661 |
| 662 DEFINE_CASTING_OPERATIONS(Constructor); |
| 663 |
| 664 virtual void AcceptMemberVisitor(MemberVisitor* visitor); |
| 665 virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor); |
| 666 virtual void VisitChildren(Visitor* visitor); |
| 667 |
| 668 bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; } |
| 669 bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; } |
| 670 |
| 671 FunctionNode* function() { return function_; } |
| 672 List<Initializer>& initializers() { return initializers_; } |
| 673 |
| 674 private: |
| 675 template <typename T> |
| 676 friend class List; |
| 677 |
| 678 Constructor() {} |
| 679 |
| 680 uint8_t flags_; |
| 681 Child<FunctionNode> function_; |
| 682 List<Initializer> initializers_; |
| 683 |
| 684 DISALLOW_COPY_AND_ASSIGN(Constructor); |
| 685 }; |
| 686 |
| 687 |
| 688 class Procedure : public Member { |
| 689 public: |
| 690 enum Flags { |
| 691 kFlagStatic = 1 << 0, |
| 692 kFlagAbstract = 1 << 1, |
| 693 kFlagExternal = 1 << 2, |
| 694 kFlagConst = 1 << 3, // Only for external const factories. |
| 695 }; |
| 696 |
| 697 // Keep in sync with package:dynamo/lib/ast.dart:ProcedureKind |
| 698 enum ProcedureKind { |
| 699 kMethod, |
| 700 kGetter, |
| 701 kSetter, |
| 702 kOperator, |
| 703 kFactory, |
| 704 |
| 705 kIncompleteProcedure = 255 |
| 706 }; |
| 707 |
| 708 Procedure* ReadFrom(Reader* reader); |
| 709 void WriteTo(Writer* writer); |
| 710 |
| 711 virtual ~Procedure(); |
| 712 |
| 713 DEFINE_CASTING_OPERATIONS(Procedure); |
| 714 |
| 715 virtual void AcceptMemberVisitor(MemberVisitor* visitor); |
| 716 virtual void AcceptReferenceVisitor(MemberReferenceVisitor* visitor); |
| 717 virtual void VisitChildren(Visitor* visitor); |
| 718 |
| 719 ProcedureKind kind() { return kind_; } |
| 720 FunctionNode* function() { return function_; } |
| 721 |
| 722 bool IsStatic() { return (flags_ & kFlagStatic) == kFlagStatic; } |
| 723 bool IsAbstract() { return (flags_ & kFlagAbstract) == kFlagAbstract; } |
| 724 bool IsExternal() { return (flags_ & kFlagExternal) == kFlagExternal; } |
| 725 bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; } |
| 726 |
| 727 private: |
| 728 Procedure() : kind_(kIncompleteProcedure), flags_(0), function_(NULL) {} |
| 729 |
| 730 template <typename T> |
| 731 friend class List; |
| 732 |
| 733 ProcedureKind kind_; |
| 734 word flags_; |
| 735 Child<FunctionNode> function_; |
| 736 |
| 737 DISALLOW_COPY_AND_ASSIGN(Procedure); |
| 738 }; |
| 739 |
| 740 |
| 741 class Initializer : public TreeNode { |
| 742 public: |
| 743 static Initializer* ReadFrom(Reader* reader); |
| 744 virtual void WriteTo(Writer* writer) = 0; |
| 745 |
| 746 virtual ~Initializer(); |
| 747 |
| 748 DEFINE_CASTING_OPERATIONS(Initializer); |
| 749 |
| 750 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 751 virtual void AcceptInitializerVisitor(InitializerVisitor* visitor) = 0; |
| 752 |
| 753 protected: |
| 754 Initializer() { } |
| 755 |
| 756 private: |
| 757 DISALLOW_COPY_AND_ASSIGN(Initializer); |
| 758 }; |
| 759 |
| 760 |
| 761 class InvalidInitializer : public Initializer { |
| 762 public: |
| 763 static InvalidInitializer* ReadFromImpl(Reader* reader); |
| 764 virtual void WriteTo(Writer* writer); |
| 765 |
| 766 virtual ~InvalidInitializer(); |
| 767 |
| 768 DEFINE_CASTING_OPERATIONS(InvalidInitializer); |
| 769 virtual void AcceptInitializerVisitor(InitializerVisitor* visitor); |
| 770 virtual void VisitChildren(Visitor* visitor); |
| 771 |
| 772 private: |
| 773 InvalidInitializer() { } |
| 774 |
| 775 DISALLOW_COPY_AND_ASSIGN(InvalidInitializer); |
| 776 }; |
| 777 |
| 778 |
| 779 class FieldInitializer : public Initializer { |
| 780 public: |
| 781 static FieldInitializer* ReadFromImpl(Reader* reader); |
| 782 virtual void WriteTo(Writer* writer); |
| 783 |
| 784 virtual ~FieldInitializer(); |
| 785 |
| 786 DEFINE_CASTING_OPERATIONS(FieldInitializer); |
| 787 |
| 788 virtual void AcceptInitializerVisitor(InitializerVisitor* visitor); |
| 789 virtual void VisitChildren(Visitor* visitor); |
| 790 |
| 791 Field* field() { return field_; } |
| 792 Expression* value() { return value_; } |
| 793 |
| 794 private: |
| 795 FieldInitializer() {} |
| 796 |
| 797 Ref<Field> field_; |
| 798 Child<Expression> value_; |
| 799 |
| 800 DISALLOW_COPY_AND_ASSIGN(FieldInitializer); |
| 801 }; |
| 802 |
| 803 |
| 804 class SuperInitializer : public Initializer { |
| 805 public: |
| 806 static SuperInitializer* ReadFromImpl(Reader* reader); |
| 807 virtual void WriteTo(Writer* writer); |
| 808 |
| 809 virtual ~SuperInitializer(); |
| 810 |
| 811 DEFINE_CASTING_OPERATIONS(SuperInitializer); |
| 812 |
| 813 virtual void AcceptInitializerVisitor(InitializerVisitor* visitor); |
| 814 virtual void VisitChildren(Visitor* visitor); |
| 815 |
| 816 Constructor* target() { return target_; } |
| 817 Arguments* arguments() { return arguments_; } |
| 818 |
| 819 private: |
| 820 SuperInitializer() {} |
| 821 |
| 822 Ref<Constructor> target_; |
| 823 Child<Arguments> arguments_; |
| 824 |
| 825 DISALLOW_COPY_AND_ASSIGN(SuperInitializer); |
| 826 }; |
| 827 |
| 828 |
| 829 class RedirectingInitializer : public Initializer { |
| 830 public: |
| 831 static RedirectingInitializer* ReadFromImpl(Reader* reader); |
| 832 virtual void WriteTo(Writer* writer); |
| 833 |
| 834 virtual ~RedirectingInitializer(); |
| 835 |
| 836 DEFINE_CASTING_OPERATIONS(RedirectingInitializer); |
| 837 |
| 838 virtual void AcceptInitializerVisitor(InitializerVisitor* visitor); |
| 839 virtual void VisitChildren(Visitor* visitor); |
| 840 |
| 841 Constructor* target() { return target_; } |
| 842 Arguments* arguments() { return arguments_; } |
| 843 |
| 844 private: |
| 845 RedirectingInitializer() {} |
| 846 |
| 847 Ref<Constructor> target_; |
| 848 Child<Arguments> arguments_; |
| 849 |
| 850 DISALLOW_COPY_AND_ASSIGN(RedirectingInitializer); |
| 851 }; |
| 852 |
| 853 |
| 854 class LocalInitializer : public Initializer { |
| 855 public: |
| 856 static LocalInitializer* ReadFromImpl(Reader* reader); |
| 857 virtual void WriteTo(Writer* writer); |
| 858 |
| 859 virtual ~LocalInitializer(); |
| 860 |
| 861 DEFINE_CASTING_OPERATIONS(LocalInitializer); |
| 862 |
| 863 virtual void AcceptInitializerVisitor(InitializerVisitor* visitor); |
| 864 virtual void VisitChildren(Visitor* visitor); |
| 865 |
| 866 VariableDeclaration* variable() { return variable_; } |
| 867 |
| 868 private: |
| 869 LocalInitializer() {} |
| 870 |
| 871 Child<VariableDeclaration> variable_; |
| 872 |
| 873 DISALLOW_COPY_AND_ASSIGN(LocalInitializer); |
| 874 }; |
| 875 |
| 876 |
| 877 class FunctionNode : public TreeNode { |
| 878 public: |
| 879 enum AsyncMarker { |
| 880 kSync = 0, |
| 881 kSyncStar = 1, |
| 882 kAsync = 2, |
| 883 kAsyncStar = 3, |
| 884 kSyncYielding = 4, |
| 885 }; |
| 886 |
| 887 static FunctionNode* ReadFrom(Reader* reader); |
| 888 void WriteTo(Writer* writer); |
| 889 |
| 890 virtual ~FunctionNode(); |
| 891 |
| 892 DEFINE_CASTING_OPERATIONS(FunctionNode); |
| 893 |
| 894 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 895 virtual void VisitChildren(Visitor* visitor); |
| 896 |
| 897 AsyncMarker async_marker() { return async_marker_; } |
| 898 TypeParameterList& type_parameters() { return type_parameters_; } |
| 899 int required_parameter_count() { return required_parameter_count_; } |
| 900 List<VariableDeclaration>& positional_parameters() { |
| 901 return positional_parameters_; |
| 902 } |
| 903 List<VariableDeclaration>& named_parameters() { return named_parameters_; } |
| 904 DartType* return_type() { return return_type_; } |
| 905 InferredValue* inferred_return_value() { return inferred_return_value_; } |
| 906 Statement* body() { return body_; } |
| 907 |
| 908 private: |
| 909 FunctionNode() {} |
| 910 |
| 911 AsyncMarker async_marker_; |
| 912 TypeParameterList type_parameters_; |
| 913 int required_parameter_count_; |
| 914 List<VariableDeclaration> positional_parameters_; |
| 915 List<VariableDeclaration> named_parameters_; |
| 916 Child<DartType> return_type_; |
| 917 Child<InferredValue> inferred_return_value_; |
| 918 Child<Statement> body_; |
| 919 |
| 920 DISALLOW_COPY_AND_ASSIGN(FunctionNode); |
| 921 }; |
| 922 |
| 923 |
| 924 class Expression : public TreeNode { |
| 925 public: |
| 926 static Expression* ReadFrom(Reader* reader); |
| 927 virtual void WriteTo(Writer* writer) = 0; |
| 928 |
| 929 virtual ~Expression(); |
| 930 |
| 931 DEFINE_CASTING_OPERATIONS(Expression); |
| 932 |
| 933 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 934 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor) = 0; |
| 935 |
| 936 protected: |
| 937 Expression() { } |
| 938 |
| 939 private: |
| 940 DISALLOW_COPY_AND_ASSIGN(Expression); |
| 941 }; |
| 942 |
| 943 |
| 944 class InvalidExpression : public Expression { |
| 945 public: |
| 946 static InvalidExpression* ReadFrom(Reader* reader); |
| 947 virtual void WriteTo(Writer* writer); |
| 948 |
| 949 virtual ~InvalidExpression(); |
| 950 virtual void VisitChildren(Visitor* visitor); |
| 951 |
| 952 DEFINE_CASTING_OPERATIONS(InvalidExpression); |
| 953 |
| 954 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 955 |
| 956 private: |
| 957 InvalidExpression() { } |
| 958 |
| 959 DISALLOW_COPY_AND_ASSIGN(InvalidExpression); |
| 960 }; |
| 961 |
| 962 |
| 963 class VariableGet : public Expression { |
| 964 public: |
| 965 static VariableGet* ReadFrom(Reader* reader); |
| 966 static VariableGet* ReadFrom(Reader* reader, uint8_t payload); |
| 967 virtual void WriteTo(Writer* writer); |
| 968 |
| 969 virtual ~VariableGet(); |
| 970 |
| 971 DEFINE_CASTING_OPERATIONS(VariableGet); |
| 972 |
| 973 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 974 virtual void VisitChildren(Visitor* visitor); |
| 975 |
| 976 VariableDeclaration* variable() { return variable_; } |
| 977 |
| 978 private: |
| 979 VariableGet() {} |
| 980 |
| 981 Ref<VariableDeclaration> variable_; |
| 982 |
| 983 DISALLOW_COPY_AND_ASSIGN(VariableGet); |
| 984 }; |
| 985 |
| 986 |
| 987 class VariableSet : public Expression { |
| 988 public: |
| 989 static VariableSet* ReadFrom(Reader* reader); |
| 990 static VariableSet* ReadFrom(Reader* reader, uint8_t payload); |
| 991 virtual void WriteTo(Writer* writer); |
| 992 |
| 993 virtual ~VariableSet(); |
| 994 |
| 995 DEFINE_CASTING_OPERATIONS(VariableSet); |
| 996 |
| 997 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 998 virtual void VisitChildren(Visitor* visitor); |
| 999 |
| 1000 VariableDeclaration* variable() { return variable_; } |
| 1001 Expression* expression() { return expression_; } |
| 1002 |
| 1003 private: |
| 1004 VariableSet() {} |
| 1005 |
| 1006 Ref<VariableDeclaration> variable_; |
| 1007 Child<Expression> expression_; |
| 1008 |
| 1009 DISALLOW_COPY_AND_ASSIGN(VariableSet); |
| 1010 }; |
| 1011 |
| 1012 |
| 1013 class PropertyGet : public Expression { |
| 1014 public: |
| 1015 static PropertyGet* ReadFrom(Reader* reader); |
| 1016 virtual void WriteTo(Writer* writer); |
| 1017 |
| 1018 virtual ~PropertyGet(); |
| 1019 |
| 1020 DEFINE_CASTING_OPERATIONS(PropertyGet); |
| 1021 |
| 1022 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1023 virtual void VisitChildren(Visitor* visitor); |
| 1024 |
| 1025 Expression* receiver() { return receiver_; } |
| 1026 Name* name() { return name_; } |
| 1027 |
| 1028 private: |
| 1029 PropertyGet() {} |
| 1030 |
| 1031 Child<Expression> receiver_; |
| 1032 Child<Name> name_; |
| 1033 Ref<Member> interfaceTarget_; |
| 1034 |
| 1035 DISALLOW_COPY_AND_ASSIGN(PropertyGet); |
| 1036 }; |
| 1037 |
| 1038 |
| 1039 class PropertySet : public Expression { |
| 1040 public: |
| 1041 static PropertySet* ReadFrom(Reader* reader); |
| 1042 virtual void WriteTo(Writer* writer); |
| 1043 |
| 1044 virtual ~PropertySet(); |
| 1045 |
| 1046 DEFINE_CASTING_OPERATIONS(PropertySet); |
| 1047 |
| 1048 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1049 virtual void VisitChildren(Visitor* visitor); |
| 1050 |
| 1051 Expression* receiver() { return receiver_; } |
| 1052 Name* name() { return name_; } |
| 1053 Expression* value() { return value_; } |
| 1054 |
| 1055 private: |
| 1056 PropertySet() {} |
| 1057 |
| 1058 Child<Expression> receiver_; |
| 1059 Child<Name> name_; |
| 1060 Child<Expression> value_; |
| 1061 Ref<Member> interfaceTarget_; |
| 1062 |
| 1063 DISALLOW_COPY_AND_ASSIGN(PropertySet); |
| 1064 }; |
| 1065 |
| 1066 |
| 1067 class DirectPropertyGet : public Expression { |
| 1068 public: |
| 1069 static DirectPropertyGet* ReadFrom(Reader* reader); |
| 1070 virtual void WriteTo(Writer* writer); |
| 1071 |
| 1072 virtual ~DirectPropertyGet(); |
| 1073 |
| 1074 DEFINE_CASTING_OPERATIONS(DirectPropertyGet); |
| 1075 |
| 1076 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1077 virtual void VisitChildren(Visitor* visitor); |
| 1078 |
| 1079 Expression* receiver() { return receiver_; } |
| 1080 Member* target() { return target_; } |
| 1081 |
| 1082 private: |
| 1083 DirectPropertyGet() {} |
| 1084 |
| 1085 Child<Expression> receiver_; |
| 1086 Ref<Member> target_; |
| 1087 |
| 1088 DISALLOW_COPY_AND_ASSIGN(DirectPropertyGet); |
| 1089 }; |
| 1090 |
| 1091 |
| 1092 class DirectPropertySet : public Expression { |
| 1093 public: |
| 1094 static DirectPropertySet* ReadFrom(Reader* reader); |
| 1095 virtual void WriteTo(Writer* writer); |
| 1096 |
| 1097 virtual ~DirectPropertySet(); |
| 1098 |
| 1099 DEFINE_CASTING_OPERATIONS(DirectPropertySet); |
| 1100 |
| 1101 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1102 virtual void VisitChildren(Visitor* visitor); |
| 1103 |
| 1104 Expression* receiver() { return receiver_; } |
| 1105 Member* target() { return target_; } |
| 1106 Expression* value() { return value_; } |
| 1107 |
| 1108 private: |
| 1109 DirectPropertySet() {} |
| 1110 |
| 1111 Child<Expression> receiver_; |
| 1112 Ref<Member> target_; |
| 1113 Child<Expression> value_; |
| 1114 |
| 1115 DISALLOW_COPY_AND_ASSIGN(DirectPropertySet); |
| 1116 }; |
| 1117 |
| 1118 |
| 1119 class StaticGet : public Expression { |
| 1120 public: |
| 1121 static StaticGet* ReadFrom(Reader* reader); |
| 1122 virtual void WriteTo(Writer* writer); |
| 1123 |
| 1124 virtual ~StaticGet(); |
| 1125 |
| 1126 DEFINE_CASTING_OPERATIONS(StaticGet); |
| 1127 |
| 1128 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1129 virtual void VisitChildren(Visitor* visitor); |
| 1130 |
| 1131 Member* target() { return target_; } |
| 1132 |
| 1133 private: |
| 1134 StaticGet() {} |
| 1135 |
| 1136 Ref<Member> target_; |
| 1137 |
| 1138 DISALLOW_COPY_AND_ASSIGN(StaticGet); |
| 1139 }; |
| 1140 |
| 1141 |
| 1142 class StaticSet : public Expression { |
| 1143 public: |
| 1144 static StaticSet* ReadFrom(Reader* reader); |
| 1145 virtual void WriteTo(Writer* writer); |
| 1146 |
| 1147 virtual ~StaticSet(); |
| 1148 |
| 1149 DEFINE_CASTING_OPERATIONS(StaticSet); |
| 1150 |
| 1151 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1152 virtual void VisitChildren(Visitor* visitor); |
| 1153 |
| 1154 Member* target() { return target_; } |
| 1155 Expression* expression() { return expression_; } |
| 1156 |
| 1157 private: |
| 1158 StaticSet() {} |
| 1159 |
| 1160 Ref<Member> target_; |
| 1161 Child<Expression> expression_; |
| 1162 |
| 1163 DISALLOW_COPY_AND_ASSIGN(StaticSet); |
| 1164 }; |
| 1165 |
| 1166 |
| 1167 class Arguments : public TreeNode { |
| 1168 public: |
| 1169 static Arguments* ReadFrom(Reader* reader); |
| 1170 virtual void WriteTo(Writer* writer); |
| 1171 |
| 1172 virtual ~Arguments(); |
| 1173 |
| 1174 DEFINE_CASTING_OPERATIONS(Arguments); |
| 1175 |
| 1176 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 1177 virtual void VisitChildren(Visitor* visitor); |
| 1178 |
| 1179 List<DartType>& types() { return types_; } |
| 1180 List<Expression>& positional() { return positional_; } |
| 1181 List<NamedExpression>& named() { return named_; } |
| 1182 |
| 1183 int count() { return positional_.length() + named_.length(); } |
| 1184 |
| 1185 private: |
| 1186 Arguments() {} |
| 1187 |
| 1188 List<DartType> types_; |
| 1189 List<Expression> positional_; |
| 1190 List<NamedExpression> named_; |
| 1191 |
| 1192 DISALLOW_COPY_AND_ASSIGN(Arguments); |
| 1193 }; |
| 1194 |
| 1195 |
| 1196 class NamedExpression : public TreeNode { |
| 1197 public: |
| 1198 static NamedExpression* ReadFrom(Reader* reader); |
| 1199 virtual void WriteTo(Writer* writer); |
| 1200 |
| 1201 NamedExpression(String* name, Expression* expr) |
| 1202 : name_(name), expression_(expr) {} |
| 1203 virtual ~NamedExpression(); |
| 1204 |
| 1205 DEFINE_CASTING_OPERATIONS(NamedExpression); |
| 1206 |
| 1207 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 1208 virtual void VisitChildren(Visitor* visitor); |
| 1209 |
| 1210 String* name() { return name_; } |
| 1211 Expression* expression() { return expression_; } |
| 1212 |
| 1213 private: |
| 1214 NamedExpression() {} |
| 1215 |
| 1216 Ref<String> name_; |
| 1217 Child<Expression> expression_; |
| 1218 |
| 1219 DISALLOW_COPY_AND_ASSIGN(NamedExpression); |
| 1220 }; |
| 1221 |
| 1222 |
| 1223 class MethodInvocation : public Expression { |
| 1224 public: |
| 1225 static MethodInvocation* ReadFrom(Reader* reader); |
| 1226 virtual void WriteTo(Writer* writer); |
| 1227 |
| 1228 virtual ~MethodInvocation(); |
| 1229 |
| 1230 DEFINE_CASTING_OPERATIONS(MethodInvocation); |
| 1231 |
| 1232 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1233 virtual void VisitChildren(Visitor* visitor); |
| 1234 |
| 1235 Expression* receiver() { return receiver_; } |
| 1236 Name* name() { return name_; } |
| 1237 Arguments* arguments() { return arguments_; } |
| 1238 |
| 1239 private: |
| 1240 MethodInvocation() {} |
| 1241 |
| 1242 Child<Expression> receiver_; |
| 1243 Child<Name> name_; |
| 1244 Child<Arguments> arguments_; |
| 1245 Ref<Member> interfaceTarget_; |
| 1246 |
| 1247 DISALLOW_COPY_AND_ASSIGN(MethodInvocation); |
| 1248 }; |
| 1249 |
| 1250 |
| 1251 class DirectMethodInvocation : public Expression { |
| 1252 public: |
| 1253 static DirectMethodInvocation* ReadFrom(Reader* reader); |
| 1254 virtual void WriteTo(Writer* writer); |
| 1255 |
| 1256 virtual ~DirectMethodInvocation(); |
| 1257 |
| 1258 DEFINE_CASTING_OPERATIONS(DirectMethodInvocation); |
| 1259 |
| 1260 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1261 virtual void VisitChildren(Visitor* visitor); |
| 1262 |
| 1263 Expression* receiver() { return receiver_; } |
| 1264 Procedure* target() { return target_; } |
| 1265 Arguments* arguments() { return arguments_; } |
| 1266 |
| 1267 private: |
| 1268 DirectMethodInvocation() {} |
| 1269 |
| 1270 Child<Expression> receiver_; |
| 1271 Ref<Procedure> target_; |
| 1272 Child<Arguments> arguments_; |
| 1273 |
| 1274 DISALLOW_COPY_AND_ASSIGN(DirectMethodInvocation); |
| 1275 }; |
| 1276 |
| 1277 |
| 1278 class StaticInvocation : public Expression { |
| 1279 public: |
| 1280 static StaticInvocation* ReadFrom(Reader* reader, bool is_const); |
| 1281 virtual void WriteTo(Writer* writer); |
| 1282 |
| 1283 explicit StaticInvocation(Procedure* procedure, Arguments* args, |
| 1284 bool is_const) |
| 1285 : procedure_(procedure), arguments_(args), is_const_(is_const) {} |
| 1286 ~StaticInvocation(); |
| 1287 |
| 1288 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1289 virtual void VisitChildren(Visitor* visitor); |
| 1290 |
| 1291 Procedure* procedure() { return procedure_; } |
| 1292 Arguments* arguments() { return arguments_; } |
| 1293 bool is_const() { return is_const_; } |
| 1294 |
| 1295 private: |
| 1296 StaticInvocation() {} |
| 1297 |
| 1298 Ref<Procedure> procedure_; |
| 1299 Child<Arguments> arguments_; |
| 1300 bool is_const_; |
| 1301 |
| 1302 DISALLOW_COPY_AND_ASSIGN(StaticInvocation); |
| 1303 }; |
| 1304 |
| 1305 |
| 1306 class ConstructorInvocation : public Expression { |
| 1307 public: |
| 1308 static ConstructorInvocation* ReadFrom(Reader* reader, bool is_const); |
| 1309 virtual void WriteTo(Writer* writer); |
| 1310 |
| 1311 virtual ~ConstructorInvocation(); |
| 1312 |
| 1313 DEFINE_CASTING_OPERATIONS(ConstructorInvocation); |
| 1314 |
| 1315 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1316 virtual void VisitChildren(Visitor* visitor); |
| 1317 |
| 1318 bool is_const() { return is_const_; } |
| 1319 Constructor* target() { return target_; } |
| 1320 Arguments* arguments() { return arguments_; } |
| 1321 |
| 1322 private: |
| 1323 ConstructorInvocation() {} |
| 1324 |
| 1325 bool is_const_; |
| 1326 Ref<Constructor> target_; |
| 1327 Child<Arguments> arguments_; |
| 1328 |
| 1329 DISALLOW_COPY_AND_ASSIGN(ConstructorInvocation); |
| 1330 }; |
| 1331 |
| 1332 |
| 1333 class Not : public Expression { |
| 1334 public: |
| 1335 static Not* ReadFrom(Reader* reader); |
| 1336 virtual void WriteTo(Writer* writer); |
| 1337 |
| 1338 virtual ~Not(); |
| 1339 |
| 1340 DEFINE_CASTING_OPERATIONS(Not); |
| 1341 |
| 1342 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1343 virtual void VisitChildren(Visitor* visitor); |
| 1344 |
| 1345 Expression* expression() { return expression_; } |
| 1346 |
| 1347 private: |
| 1348 Not() {} |
| 1349 |
| 1350 Child<Expression> expression_; |
| 1351 |
| 1352 DISALLOW_COPY_AND_ASSIGN(Not); |
| 1353 }; |
| 1354 |
| 1355 |
| 1356 class LogicalExpression : public Expression { |
| 1357 public: |
| 1358 enum Operator { kAnd, kOr }; |
| 1359 |
| 1360 static LogicalExpression* ReadFrom(Reader* reader); |
| 1361 virtual void WriteTo(Writer* writer); |
| 1362 |
| 1363 virtual ~LogicalExpression(); |
| 1364 |
| 1365 DEFINE_CASTING_OPERATIONS(LogicalExpression); |
| 1366 |
| 1367 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1368 virtual void VisitChildren(Visitor* visitor); |
| 1369 |
| 1370 Expression* left() { return left_; } |
| 1371 Operator op() { return operator_; } |
| 1372 Expression* right() { return right_; } |
| 1373 |
| 1374 private: |
| 1375 LogicalExpression() {} |
| 1376 |
| 1377 Child<Expression> left_; |
| 1378 Operator operator_; |
| 1379 Child<Expression> right_; |
| 1380 |
| 1381 DISALLOW_COPY_AND_ASSIGN(LogicalExpression); |
| 1382 }; |
| 1383 |
| 1384 |
| 1385 class ConditionalExpression : public Expression { |
| 1386 public: |
| 1387 static ConditionalExpression* ReadFrom(Reader* reader); |
| 1388 virtual void WriteTo(Writer* writer); |
| 1389 |
| 1390 virtual ~ConditionalExpression(); |
| 1391 |
| 1392 DEFINE_CASTING_OPERATIONS(ConditionalExpression); |
| 1393 |
| 1394 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1395 virtual void VisitChildren(Visitor* visitor); |
| 1396 |
| 1397 Expression* condition() { return condition_; } |
| 1398 Expression* then() { return then_; } |
| 1399 Expression* otherwise() { return otherwise_; } |
| 1400 |
| 1401 private: |
| 1402 ConditionalExpression() {} |
| 1403 |
| 1404 Child<Expression> condition_; |
| 1405 Child<Expression> then_; |
| 1406 Child<Expression> otherwise_; |
| 1407 |
| 1408 DISALLOW_COPY_AND_ASSIGN(ConditionalExpression); |
| 1409 }; |
| 1410 |
| 1411 |
| 1412 class StringConcatenation : public Expression { |
| 1413 public: |
| 1414 static StringConcatenation* ReadFrom(Reader* reader); |
| 1415 virtual void WriteTo(Writer* writer); |
| 1416 |
| 1417 virtual ~StringConcatenation(); |
| 1418 |
| 1419 DEFINE_CASTING_OPERATIONS(StringConcatenation); |
| 1420 |
| 1421 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1422 virtual void VisitChildren(Visitor* visitor); |
| 1423 |
| 1424 List<Expression>& expressions() { return expressions_; } |
| 1425 |
| 1426 private: |
| 1427 StringConcatenation() {} |
| 1428 |
| 1429 List<Expression> expressions_; |
| 1430 |
| 1431 DISALLOW_COPY_AND_ASSIGN(StringConcatenation); |
| 1432 }; |
| 1433 |
| 1434 |
| 1435 class IsExpression : public Expression { |
| 1436 public: |
| 1437 static IsExpression* ReadFrom(Reader* reader); |
| 1438 virtual void WriteTo(Writer* writer); |
| 1439 |
| 1440 virtual ~IsExpression(); |
| 1441 |
| 1442 DEFINE_CASTING_OPERATIONS(IsExpression); |
| 1443 |
| 1444 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1445 virtual void VisitChildren(Visitor* visitor); |
| 1446 |
| 1447 Expression* operand() { return operand_; } |
| 1448 DartType* type() { return type_; } |
| 1449 |
| 1450 private: |
| 1451 IsExpression() {} |
| 1452 |
| 1453 Child<Expression> operand_; |
| 1454 Child<DartType> type_; |
| 1455 |
| 1456 DISALLOW_COPY_AND_ASSIGN(IsExpression); |
| 1457 }; |
| 1458 |
| 1459 |
| 1460 class AsExpression : public Expression { |
| 1461 public: |
| 1462 static AsExpression* ReadFrom(Reader* reader); |
| 1463 virtual void WriteTo(Writer* writer); |
| 1464 |
| 1465 virtual ~AsExpression(); |
| 1466 |
| 1467 DEFINE_CASTING_OPERATIONS(AsExpression); |
| 1468 |
| 1469 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1470 virtual void VisitChildren(Visitor* visitor); |
| 1471 |
| 1472 Expression* operand() { return operand_; } |
| 1473 DartType* type() { return type_; } |
| 1474 |
| 1475 private: |
| 1476 AsExpression() {} |
| 1477 |
| 1478 Child<Expression> operand_; |
| 1479 Child<DartType> type_; |
| 1480 |
| 1481 DISALLOW_COPY_AND_ASSIGN(AsExpression); |
| 1482 }; |
| 1483 |
| 1484 |
| 1485 class BasicLiteral : public Expression { |
| 1486 public: |
| 1487 virtual ~BasicLiteral(); |
| 1488 |
| 1489 DEFINE_CASTING_OPERATIONS(BasicLiteral); |
| 1490 |
| 1491 virtual void VisitChildren(Visitor* visitor); |
| 1492 }; |
| 1493 |
| 1494 |
| 1495 class StringLiteral : public BasicLiteral { |
| 1496 public: |
| 1497 static StringLiteral* ReadFrom(Reader* reader); |
| 1498 virtual void WriteTo(Writer* writer); |
| 1499 |
| 1500 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1501 |
| 1502 explicit StringLiteral(String* string) : value_(string) {} |
| 1503 virtual ~StringLiteral(); |
| 1504 |
| 1505 DEFINE_CASTING_OPERATIONS(StringLiteral); |
| 1506 |
| 1507 String* value() { return value_; } |
| 1508 |
| 1509 protected: |
| 1510 StringLiteral() {} |
| 1511 |
| 1512 Ref<String> value_; |
| 1513 |
| 1514 private: |
| 1515 DISALLOW_COPY_AND_ASSIGN(StringLiteral); |
| 1516 }; |
| 1517 |
| 1518 |
| 1519 class BigintLiteral : public StringLiteral { |
| 1520 public: |
| 1521 static BigintLiteral* ReadFrom(Reader* reader); |
| 1522 virtual void WriteTo(Writer* writer); |
| 1523 |
| 1524 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1525 |
| 1526 explicit BigintLiteral(String* string) : StringLiteral(string) {} |
| 1527 virtual ~BigintLiteral(); |
| 1528 |
| 1529 DEFINE_CASTING_OPERATIONS(BigintLiteral); |
| 1530 |
| 1531 private: |
| 1532 BigintLiteral() {} |
| 1533 |
| 1534 DISALLOW_COPY_AND_ASSIGN(BigintLiteral); |
| 1535 }; |
| 1536 |
| 1537 |
| 1538 class IntLiteral : public BasicLiteral { |
| 1539 public: |
| 1540 static IntLiteral* ReadFrom(Reader* reader, bool is_negative); |
| 1541 static IntLiteral* ReadFrom(Reader* reader, uint8_t payload); |
| 1542 virtual void WriteTo(Writer* writer); |
| 1543 |
| 1544 virtual ~IntLiteral(); |
| 1545 |
| 1546 DEFINE_CASTING_OPERATIONS(IntLiteral); |
| 1547 |
| 1548 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1549 |
| 1550 int64_t value() { return value_; } |
| 1551 |
| 1552 private: |
| 1553 IntLiteral() {} |
| 1554 |
| 1555 int64_t value_; |
| 1556 |
| 1557 DISALLOW_COPY_AND_ASSIGN(IntLiteral); |
| 1558 }; |
| 1559 |
| 1560 |
| 1561 class DoubleLiteral : public BasicLiteral { |
| 1562 public: |
| 1563 static DoubleLiteral* ReadFrom(Reader* reader); |
| 1564 virtual void WriteTo(Writer* writer); |
| 1565 |
| 1566 virtual ~DoubleLiteral(); |
| 1567 |
| 1568 DEFINE_CASTING_OPERATIONS(DoubleLiteral); |
| 1569 |
| 1570 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1571 |
| 1572 String* value() { return value_; } |
| 1573 |
| 1574 private: |
| 1575 DoubleLiteral() {} |
| 1576 |
| 1577 Ref<String> value_; |
| 1578 |
| 1579 DISALLOW_COPY_AND_ASSIGN(DoubleLiteral); |
| 1580 }; |
| 1581 |
| 1582 |
| 1583 class BoolLiteral : public BasicLiteral { |
| 1584 public: |
| 1585 static BoolLiteral* ReadFrom(Reader* reader, bool value); |
| 1586 virtual void WriteTo(Writer* writer); |
| 1587 |
| 1588 virtual ~BoolLiteral(); |
| 1589 |
| 1590 DEFINE_CASTING_OPERATIONS(BoolLiteral); |
| 1591 |
| 1592 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1593 |
| 1594 bool value() { return value_; } |
| 1595 |
| 1596 private: |
| 1597 BoolLiteral() {} |
| 1598 |
| 1599 bool value_; |
| 1600 |
| 1601 DISALLOW_COPY_AND_ASSIGN(BoolLiteral); |
| 1602 }; |
| 1603 |
| 1604 |
| 1605 class NullLiteral : public BasicLiteral { |
| 1606 public: |
| 1607 static NullLiteral* ReadFrom(Reader* reader); |
| 1608 virtual void WriteTo(Writer* writer); |
| 1609 |
| 1610 virtual ~NullLiteral(); |
| 1611 |
| 1612 DEFINE_CASTING_OPERATIONS(NullLiteral); |
| 1613 |
| 1614 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1615 |
| 1616 private: |
| 1617 NullLiteral() { } |
| 1618 |
| 1619 DISALLOW_COPY_AND_ASSIGN(NullLiteral); |
| 1620 }; |
| 1621 |
| 1622 |
| 1623 class SymbolLiteral : public Expression { |
| 1624 public: |
| 1625 static SymbolLiteral* ReadFrom(Reader* reader); |
| 1626 virtual void WriteTo(Writer* writer); |
| 1627 |
| 1628 virtual ~SymbolLiteral(); |
| 1629 |
| 1630 DEFINE_CASTING_OPERATIONS(SymbolLiteral); |
| 1631 |
| 1632 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1633 virtual void VisitChildren(Visitor* visitor); |
| 1634 |
| 1635 String* value() { return value_; } |
| 1636 |
| 1637 private: |
| 1638 SymbolLiteral() {} |
| 1639 |
| 1640 Ref<String> value_; |
| 1641 |
| 1642 DISALLOW_COPY_AND_ASSIGN(SymbolLiteral); |
| 1643 }; |
| 1644 |
| 1645 |
| 1646 class TypeLiteral : public Expression { |
| 1647 public: |
| 1648 static TypeLiteral* ReadFrom(Reader* reader); |
| 1649 virtual void WriteTo(Writer* writer); |
| 1650 |
| 1651 virtual ~TypeLiteral(); |
| 1652 |
| 1653 DEFINE_CASTING_OPERATIONS(TypeLiteral); |
| 1654 |
| 1655 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1656 virtual void VisitChildren(Visitor* visitor); |
| 1657 |
| 1658 DartType* type() { return type_; } |
| 1659 |
| 1660 private: |
| 1661 TypeLiteral() {} |
| 1662 |
| 1663 Child<DartType> type_; |
| 1664 |
| 1665 DISALLOW_COPY_AND_ASSIGN(TypeLiteral); |
| 1666 }; |
| 1667 |
| 1668 |
| 1669 class ThisExpression : public Expression { |
| 1670 public: |
| 1671 static ThisExpression* ReadFrom(Reader* reader); |
| 1672 virtual void WriteTo(Writer* writer); |
| 1673 |
| 1674 virtual ~ThisExpression(); |
| 1675 |
| 1676 DEFINE_CASTING_OPERATIONS(ThisExpression); |
| 1677 |
| 1678 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1679 virtual void VisitChildren(Visitor* visitor); |
| 1680 |
| 1681 private: |
| 1682 ThisExpression() { } |
| 1683 |
| 1684 DISALLOW_COPY_AND_ASSIGN(ThisExpression); |
| 1685 }; |
| 1686 |
| 1687 |
| 1688 class Rethrow : public Expression { |
| 1689 public: |
| 1690 static Rethrow* ReadFrom(Reader* reader); |
| 1691 virtual void WriteTo(Writer* writer); |
| 1692 |
| 1693 virtual ~Rethrow(); |
| 1694 |
| 1695 DEFINE_CASTING_OPERATIONS(Rethrow); |
| 1696 |
| 1697 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1698 virtual void VisitChildren(Visitor* visitor); |
| 1699 |
| 1700 private: |
| 1701 Rethrow() { } |
| 1702 |
| 1703 DISALLOW_COPY_AND_ASSIGN(Rethrow); |
| 1704 }; |
| 1705 |
| 1706 |
| 1707 class Throw : public Expression { |
| 1708 public: |
| 1709 static Throw* ReadFrom(Reader* reader); |
| 1710 virtual void WriteTo(Writer* writer); |
| 1711 |
| 1712 virtual ~Throw(); |
| 1713 |
| 1714 DEFINE_CASTING_OPERATIONS(Throw); |
| 1715 |
| 1716 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1717 virtual void VisitChildren(Visitor* visitor); |
| 1718 |
| 1719 Expression* expression() { return expression_; } |
| 1720 |
| 1721 private: |
| 1722 Throw() {} |
| 1723 |
| 1724 Child<Expression> expression_; |
| 1725 |
| 1726 DISALLOW_COPY_AND_ASSIGN(Throw); |
| 1727 }; |
| 1728 |
| 1729 |
| 1730 class ListLiteral : public Expression { |
| 1731 public: |
| 1732 static ListLiteral* ReadFrom(Reader* reader, bool is_const); |
| 1733 virtual void WriteTo(Writer* writer); |
| 1734 |
| 1735 virtual ~ListLiteral(); |
| 1736 |
| 1737 DEFINE_CASTING_OPERATIONS(ListLiteral); |
| 1738 |
| 1739 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1740 virtual void VisitChildren(Visitor* visitor); |
| 1741 |
| 1742 bool is_const() { return is_const_; } |
| 1743 DartType* type() { return type_; } |
| 1744 List<Expression>& expressions() { return expressions_; } |
| 1745 |
| 1746 private: |
| 1747 ListLiteral() {} |
| 1748 |
| 1749 bool is_const_; |
| 1750 Child<DartType> type_; |
| 1751 List<Expression> expressions_; |
| 1752 |
| 1753 DISALLOW_COPY_AND_ASSIGN(ListLiteral); |
| 1754 }; |
| 1755 |
| 1756 |
| 1757 class MapLiteral : public Expression { |
| 1758 public: |
| 1759 static MapLiteral* ReadFrom(Reader* reader, bool is_const); |
| 1760 virtual void WriteTo(Writer* writer); |
| 1761 |
| 1762 virtual ~MapLiteral(); |
| 1763 |
| 1764 DEFINE_CASTING_OPERATIONS(MapLiteral); |
| 1765 |
| 1766 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1767 virtual void VisitChildren(Visitor* visitor); |
| 1768 |
| 1769 bool is_const() { return is_const_; } |
| 1770 DartType* key_type() { return key_type_; } |
| 1771 DartType* value_type() { return value_type_; } |
| 1772 List<MapEntry>& entries() { return entries_; } |
| 1773 |
| 1774 private: |
| 1775 MapLiteral() {} |
| 1776 |
| 1777 bool is_const_; |
| 1778 Child<DartType> key_type_; |
| 1779 Child<DartType> value_type_; |
| 1780 List<MapEntry> entries_; |
| 1781 |
| 1782 DISALLOW_COPY_AND_ASSIGN(MapLiteral); |
| 1783 }; |
| 1784 |
| 1785 |
| 1786 class MapEntry : public TreeNode { |
| 1787 public: |
| 1788 static MapEntry* ReadFrom(Reader* reader); |
| 1789 virtual void WriteTo(Writer* writer); |
| 1790 |
| 1791 virtual ~MapEntry(); |
| 1792 |
| 1793 DEFINE_CASTING_OPERATIONS(MapEntry); |
| 1794 |
| 1795 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 1796 virtual void VisitChildren(Visitor* visitor); |
| 1797 |
| 1798 Expression* key() { return key_; } |
| 1799 Expression* value() { return value_; } |
| 1800 |
| 1801 private: |
| 1802 MapEntry() {} |
| 1803 |
| 1804 template <typename T> |
| 1805 friend class List; |
| 1806 |
| 1807 Child<Expression> key_; |
| 1808 Child<Expression> value_; |
| 1809 |
| 1810 DISALLOW_COPY_AND_ASSIGN(MapEntry); |
| 1811 }; |
| 1812 |
| 1813 |
| 1814 class AwaitExpression : public Expression { |
| 1815 public: |
| 1816 static AwaitExpression* ReadFrom(Reader* reader); |
| 1817 virtual void WriteTo(Writer* writer); |
| 1818 |
| 1819 virtual ~AwaitExpression(); |
| 1820 |
| 1821 DEFINE_CASTING_OPERATIONS(AwaitExpression); |
| 1822 |
| 1823 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1824 virtual void VisitChildren(Visitor* visitor); |
| 1825 |
| 1826 Expression* operand() { return operand_; } |
| 1827 |
| 1828 private: |
| 1829 AwaitExpression() {} |
| 1830 |
| 1831 Child<Expression> operand_; |
| 1832 |
| 1833 DISALLOW_COPY_AND_ASSIGN(AwaitExpression); |
| 1834 }; |
| 1835 |
| 1836 |
| 1837 class FunctionExpression : public Expression { |
| 1838 public: |
| 1839 static FunctionExpression* ReadFrom(Reader* reader); |
| 1840 virtual void WriteTo(Writer* writer); |
| 1841 |
| 1842 virtual ~FunctionExpression(); |
| 1843 |
| 1844 DEFINE_CASTING_OPERATIONS(FunctionExpression); |
| 1845 |
| 1846 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1847 virtual void VisitChildren(Visitor* visitor); |
| 1848 |
| 1849 FunctionNode* function() { return function_; } |
| 1850 |
| 1851 private: |
| 1852 FunctionExpression() {} |
| 1853 |
| 1854 Child<FunctionNode> function_; |
| 1855 |
| 1856 DISALLOW_COPY_AND_ASSIGN(FunctionExpression); |
| 1857 }; |
| 1858 |
| 1859 |
| 1860 class Let : public Expression { |
| 1861 public: |
| 1862 static Let* ReadFrom(Reader* reader); |
| 1863 virtual void WriteTo(Writer* writer); |
| 1864 |
| 1865 virtual ~Let(); |
| 1866 |
| 1867 DEFINE_CASTING_OPERATIONS(Let); |
| 1868 |
| 1869 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1870 virtual void VisitChildren(Visitor* visitor); |
| 1871 |
| 1872 VariableDeclaration* variable() { return variable_; } |
| 1873 Expression* body() { return body_; } |
| 1874 |
| 1875 private: |
| 1876 Let() {} |
| 1877 |
| 1878 Child<VariableDeclaration> variable_; |
| 1879 Child<Expression> body_; |
| 1880 |
| 1881 DISALLOW_COPY_AND_ASSIGN(Let); |
| 1882 }; |
| 1883 |
| 1884 |
| 1885 class BlockExpression : public Expression { |
| 1886 public: |
| 1887 static BlockExpression* ReadFrom(Reader* reader); |
| 1888 virtual void WriteTo(Writer* writer); |
| 1889 |
| 1890 virtual ~BlockExpression(); |
| 1891 |
| 1892 DEFINE_CASTING_OPERATIONS(BlockExpression); |
| 1893 |
| 1894 virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor); |
| 1895 virtual void VisitChildren(Visitor* visitor); |
| 1896 |
| 1897 Block* body() { return body_; } |
| 1898 Expression* value() { return value_; } |
| 1899 |
| 1900 private: |
| 1901 BlockExpression() {} |
| 1902 |
| 1903 Child<Block> body_; |
| 1904 Child<Expression> value_; |
| 1905 |
| 1906 DISALLOW_COPY_AND_ASSIGN(BlockExpression); |
| 1907 }; |
| 1908 |
| 1909 |
| 1910 class Statement : public TreeNode { |
| 1911 public: |
| 1912 static Statement* ReadFrom(Reader* reader); |
| 1913 virtual void WriteTo(Writer* writer) = 0; |
| 1914 |
| 1915 virtual ~Statement(); |
| 1916 |
| 1917 DEFINE_CASTING_OPERATIONS(Statement); |
| 1918 |
| 1919 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 1920 virtual void AcceptStatementVisitor(StatementVisitor* visitor) = 0; |
| 1921 |
| 1922 protected: |
| 1923 Statement() { } |
| 1924 |
| 1925 private: |
| 1926 DISALLOW_COPY_AND_ASSIGN(Statement); |
| 1927 }; |
| 1928 |
| 1929 |
| 1930 class InvalidStatement : public Statement { |
| 1931 public: |
| 1932 static InvalidStatement* ReadFrom(Reader* reader); |
| 1933 virtual void WriteTo(Writer* writer); |
| 1934 |
| 1935 virtual ~InvalidStatement(); |
| 1936 |
| 1937 DEFINE_CASTING_OPERATIONS(InvalidStatement); |
| 1938 |
| 1939 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 1940 virtual void VisitChildren(Visitor* visitor); |
| 1941 |
| 1942 private: |
| 1943 InvalidStatement() { } |
| 1944 |
| 1945 DISALLOW_COPY_AND_ASSIGN(InvalidStatement); |
| 1946 }; |
| 1947 |
| 1948 |
| 1949 class ExpressionStatement : public Statement { |
| 1950 public: |
| 1951 static ExpressionStatement* ReadFrom(Reader* reader); |
| 1952 virtual void WriteTo(Writer* writer); |
| 1953 |
| 1954 explicit ExpressionStatement(Expression* exp) : expression_(exp) {} |
| 1955 virtual ~ExpressionStatement(); |
| 1956 |
| 1957 DEFINE_CASTING_OPERATIONS(ExpressionStatement); |
| 1958 |
| 1959 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 1960 virtual void VisitChildren(Visitor* visitor); |
| 1961 |
| 1962 Expression* expression() { return expression_; } |
| 1963 |
| 1964 private: |
| 1965 ExpressionStatement() {} |
| 1966 |
| 1967 Child<Expression> expression_; |
| 1968 |
| 1969 DISALLOW_COPY_AND_ASSIGN(ExpressionStatement); |
| 1970 }; |
| 1971 |
| 1972 |
| 1973 class Block : public Statement { |
| 1974 public: |
| 1975 static Block* ReadFromImpl(Reader* reader); |
| 1976 virtual void WriteTo(Writer* writer); |
| 1977 void WriteToImpl(Writer* writer); |
| 1978 |
| 1979 virtual ~Block(); |
| 1980 |
| 1981 DEFINE_CASTING_OPERATIONS(Block); |
| 1982 |
| 1983 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 1984 virtual void VisitChildren(Visitor* visitor); |
| 1985 |
| 1986 List<Statement>& statements() { return statements_; } |
| 1987 |
| 1988 private: |
| 1989 Block() {} |
| 1990 |
| 1991 List<Statement> statements_; |
| 1992 |
| 1993 DISALLOW_COPY_AND_ASSIGN(Block); |
| 1994 }; |
| 1995 |
| 1996 |
| 1997 class EmptyStatement : public Statement { |
| 1998 public: |
| 1999 static EmptyStatement* ReadFrom(Reader* reader); |
| 2000 virtual void WriteTo(Writer* writer); |
| 2001 |
| 2002 virtual ~EmptyStatement(); |
| 2003 |
| 2004 DEFINE_CASTING_OPERATIONS(EmptyStatement); |
| 2005 |
| 2006 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2007 virtual void VisitChildren(Visitor* visitor); |
| 2008 |
| 2009 private: |
| 2010 EmptyStatement() { } |
| 2011 |
| 2012 DISALLOW_COPY_AND_ASSIGN(EmptyStatement); |
| 2013 }; |
| 2014 |
| 2015 |
| 2016 class AssertStatement : public Statement { |
| 2017 public: |
| 2018 static AssertStatement* ReadFrom(Reader* reader); |
| 2019 virtual void WriteTo(Writer* writer); |
| 2020 |
| 2021 virtual ~AssertStatement(); |
| 2022 |
| 2023 DEFINE_CASTING_OPERATIONS(AssertStatement); |
| 2024 |
| 2025 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2026 virtual void VisitChildren(Visitor* visitor); |
| 2027 |
| 2028 Expression* condition() { return condition_; } |
| 2029 Expression* message() { return message_; } |
| 2030 |
| 2031 private: |
| 2032 AssertStatement() {} |
| 2033 |
| 2034 Child<Expression> condition_; |
| 2035 Child<Expression> message_; |
| 2036 |
| 2037 DISALLOW_COPY_AND_ASSIGN(AssertStatement); |
| 2038 }; |
| 2039 |
| 2040 |
| 2041 class LabeledStatement : public Statement { |
| 2042 public: |
| 2043 static LabeledStatement* ReadFrom(Reader* reader); |
| 2044 virtual void WriteTo(Writer* writer); |
| 2045 |
| 2046 virtual ~LabeledStatement(); |
| 2047 |
| 2048 DEFINE_CASTING_OPERATIONS(LabeledStatement); |
| 2049 |
| 2050 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2051 virtual void VisitChildren(Visitor* visitor); |
| 2052 |
| 2053 Statement* body() { return body_; } |
| 2054 |
| 2055 private: |
| 2056 LabeledStatement() {} |
| 2057 |
| 2058 Child<Statement> body_; |
| 2059 |
| 2060 DISALLOW_COPY_AND_ASSIGN(LabeledStatement); |
| 2061 }; |
| 2062 |
| 2063 |
| 2064 class BreakStatement : public Statement { |
| 2065 public: |
| 2066 static BreakStatement* ReadFrom(Reader* reader); |
| 2067 virtual void WriteTo(Writer* writer); |
| 2068 |
| 2069 virtual ~BreakStatement(); |
| 2070 |
| 2071 DEFINE_CASTING_OPERATIONS(BreakStatement); |
| 2072 |
| 2073 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2074 virtual void VisitChildren(Visitor* visitor); |
| 2075 |
| 2076 LabeledStatement* target() { return target_; } |
| 2077 |
| 2078 private: |
| 2079 BreakStatement() {} |
| 2080 |
| 2081 Ref<LabeledStatement> target_; |
| 2082 |
| 2083 DISALLOW_COPY_AND_ASSIGN(BreakStatement); |
| 2084 }; |
| 2085 |
| 2086 |
| 2087 class WhileStatement : public Statement { |
| 2088 public: |
| 2089 static WhileStatement* ReadFrom(Reader* reader); |
| 2090 virtual void WriteTo(Writer* writer); |
| 2091 |
| 2092 virtual ~WhileStatement(); |
| 2093 |
| 2094 DEFINE_CASTING_OPERATIONS(WhileStatement); |
| 2095 |
| 2096 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2097 virtual void VisitChildren(Visitor* visitor); |
| 2098 |
| 2099 Expression* condition() { return condition_; } |
| 2100 Statement* body() { return body_; } |
| 2101 |
| 2102 private: |
| 2103 WhileStatement() {} |
| 2104 |
| 2105 Child<Expression> condition_; |
| 2106 Child<Statement> body_; |
| 2107 |
| 2108 DISALLOW_COPY_AND_ASSIGN(WhileStatement); |
| 2109 }; |
| 2110 |
| 2111 |
| 2112 class DoStatement : public Statement { |
| 2113 public: |
| 2114 static DoStatement* ReadFrom(Reader* reader); |
| 2115 virtual void WriteTo(Writer* writer); |
| 2116 |
| 2117 virtual ~DoStatement(); |
| 2118 |
| 2119 DEFINE_CASTING_OPERATIONS(DoStatement); |
| 2120 |
| 2121 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2122 virtual void VisitChildren(Visitor* visitor); |
| 2123 |
| 2124 Expression* condition() { return condition_; } |
| 2125 Statement* body() { return body_; } |
| 2126 |
| 2127 private: |
| 2128 DoStatement() {} |
| 2129 |
| 2130 Child<Expression> condition_; |
| 2131 Child<Statement> body_; |
| 2132 |
| 2133 DISALLOW_COPY_AND_ASSIGN(DoStatement); |
| 2134 }; |
| 2135 |
| 2136 |
| 2137 class ForStatement : public Statement { |
| 2138 public: |
| 2139 static ForStatement* ReadFrom(Reader* reader); |
| 2140 virtual void WriteTo(Writer* writer); |
| 2141 |
| 2142 virtual ~ForStatement(); |
| 2143 |
| 2144 DEFINE_CASTING_OPERATIONS(ForStatement); |
| 2145 |
| 2146 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2147 virtual void VisitChildren(Visitor* visitor); |
| 2148 |
| 2149 List<VariableDeclaration>& variables() { return variables_; } |
| 2150 Expression* condition() { return condition_; } |
| 2151 List<Expression>& updates() { return updates_; } |
| 2152 Statement* body() { return body_; } |
| 2153 |
| 2154 private: |
| 2155 ForStatement() {} |
| 2156 |
| 2157 List<VariableDeclaration> variables_; |
| 2158 Child<Expression> condition_; |
| 2159 List<Expression> updates_; |
| 2160 Child<Statement> body_; |
| 2161 |
| 2162 DISALLOW_COPY_AND_ASSIGN(ForStatement); |
| 2163 }; |
| 2164 |
| 2165 |
| 2166 class ForInStatement : public Statement { |
| 2167 public: |
| 2168 static ForInStatement* ReadFrom(Reader* reader, bool is_async); |
| 2169 virtual void WriteTo(Writer* writer); |
| 2170 |
| 2171 virtual ~ForInStatement(); |
| 2172 |
| 2173 DEFINE_CASTING_OPERATIONS(ForInStatement); |
| 2174 |
| 2175 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2176 virtual void VisitChildren(Visitor* visitor); |
| 2177 |
| 2178 VariableDeclaration* variable() { return variable_; } |
| 2179 Expression* iterable() { return iterable_; } |
| 2180 Statement* body() { return body_; } |
| 2181 bool is_async() { return is_async_; } |
| 2182 |
| 2183 private: |
| 2184 ForInStatement() {} |
| 2185 |
| 2186 Child<VariableDeclaration> variable_; |
| 2187 Child<Expression> iterable_; |
| 2188 Child<Statement> body_; |
| 2189 bool is_async_; |
| 2190 |
| 2191 DISALLOW_COPY_AND_ASSIGN(ForInStatement); |
| 2192 }; |
| 2193 |
| 2194 |
| 2195 class SwitchStatement : public Statement { |
| 2196 public: |
| 2197 static SwitchStatement* ReadFrom(Reader* reader); |
| 2198 virtual void WriteTo(Writer* writer); |
| 2199 |
| 2200 virtual ~SwitchStatement(); |
| 2201 |
| 2202 DEFINE_CASTING_OPERATIONS(SwitchStatement); |
| 2203 |
| 2204 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2205 virtual void VisitChildren(Visitor* visitor); |
| 2206 |
| 2207 Expression* condition() { return condition_; } |
| 2208 List<SwitchCase>& cases() { return cases_; } |
| 2209 |
| 2210 private: |
| 2211 SwitchStatement() {} |
| 2212 |
| 2213 Child<Expression> condition_; |
| 2214 List<SwitchCase> cases_; |
| 2215 |
| 2216 DISALLOW_COPY_AND_ASSIGN(SwitchStatement); |
| 2217 }; |
| 2218 |
| 2219 |
| 2220 class SwitchCase : public TreeNode { |
| 2221 public: |
| 2222 SwitchCase* ReadFrom(Reader* reader); |
| 2223 void WriteTo(Writer* writer); |
| 2224 |
| 2225 virtual ~SwitchCase(); |
| 2226 |
| 2227 DEFINE_CASTING_OPERATIONS(SwitchCase); |
| 2228 |
| 2229 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 2230 virtual void VisitChildren(Visitor* visitor); |
| 2231 |
| 2232 List<Expression>& expressions() { return expressions_; } |
| 2233 bool is_default() { return is_default_; } |
| 2234 Statement* body() { return body_; } |
| 2235 |
| 2236 private: |
| 2237 SwitchCase() {} |
| 2238 |
| 2239 template <typename T> |
| 2240 friend class List; |
| 2241 |
| 2242 List<Expression> expressions_; |
| 2243 bool is_default_; |
| 2244 Child<Statement> body_; |
| 2245 |
| 2246 DISALLOW_COPY_AND_ASSIGN(SwitchCase); |
| 2247 }; |
| 2248 |
| 2249 |
| 2250 class ContinueSwitchStatement : public Statement { |
| 2251 public: |
| 2252 static ContinueSwitchStatement* ReadFrom(Reader* reader); |
| 2253 virtual void WriteTo(Writer* writer); |
| 2254 |
| 2255 virtual ~ContinueSwitchStatement(); |
| 2256 |
| 2257 DEFINE_CASTING_OPERATIONS(ContinueSwitchStatement); |
| 2258 |
| 2259 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2260 virtual void VisitChildren(Visitor* visitor); |
| 2261 |
| 2262 SwitchCase* target() { return target_; } |
| 2263 |
| 2264 private: |
| 2265 ContinueSwitchStatement() {} |
| 2266 |
| 2267 Ref<SwitchCase> target_; |
| 2268 |
| 2269 DISALLOW_COPY_AND_ASSIGN(ContinueSwitchStatement); |
| 2270 }; |
| 2271 |
| 2272 |
| 2273 class IfStatement : public Statement { |
| 2274 public: |
| 2275 static IfStatement* ReadFrom(Reader* reader); |
| 2276 virtual void WriteTo(Writer* writer); |
| 2277 |
| 2278 virtual ~IfStatement(); |
| 2279 |
| 2280 DEFINE_CASTING_OPERATIONS(IfStatement); |
| 2281 |
| 2282 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2283 virtual void VisitChildren(Visitor* visitor); |
| 2284 |
| 2285 Expression* condition() { return condition_; } |
| 2286 Statement* then() { return then_; } |
| 2287 Statement* otherwise() { return otherwise_; } |
| 2288 |
| 2289 private: |
| 2290 IfStatement() {} |
| 2291 |
| 2292 Child<Expression> condition_; |
| 2293 Child<Statement> then_; |
| 2294 Child<Statement> otherwise_; |
| 2295 |
| 2296 DISALLOW_COPY_AND_ASSIGN(IfStatement); |
| 2297 }; |
| 2298 |
| 2299 |
| 2300 class ReturnStatement : public Statement { |
| 2301 public: |
| 2302 static ReturnStatement* ReadFrom(Reader* reader); |
| 2303 virtual void WriteTo(Writer* writer); |
| 2304 |
| 2305 virtual ~ReturnStatement(); |
| 2306 |
| 2307 DEFINE_CASTING_OPERATIONS(ReturnStatement); |
| 2308 |
| 2309 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2310 virtual void VisitChildren(Visitor* visitor); |
| 2311 |
| 2312 Expression* expression() { return expression_; } |
| 2313 |
| 2314 private: |
| 2315 ReturnStatement() {} |
| 2316 |
| 2317 Child<Expression> expression_; |
| 2318 |
| 2319 DISALLOW_COPY_AND_ASSIGN(ReturnStatement); |
| 2320 }; |
| 2321 |
| 2322 |
| 2323 class TryCatch : public Statement { |
| 2324 public: |
| 2325 static TryCatch* ReadFrom(Reader* reader); |
| 2326 virtual void WriteTo(Writer* writer); |
| 2327 |
| 2328 virtual ~TryCatch(); |
| 2329 |
| 2330 DEFINE_CASTING_OPERATIONS(TryCatch); |
| 2331 |
| 2332 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2333 virtual void VisitChildren(Visitor* visitor); |
| 2334 |
| 2335 Statement* body() { return body_; } |
| 2336 List<Catch>& catches() { return catches_; } |
| 2337 |
| 2338 private: |
| 2339 TryCatch() {} |
| 2340 |
| 2341 Child<Statement> body_; |
| 2342 List<Catch> catches_; |
| 2343 |
| 2344 DISALLOW_COPY_AND_ASSIGN(TryCatch); |
| 2345 }; |
| 2346 |
| 2347 |
| 2348 class Catch : public TreeNode { |
| 2349 public: |
| 2350 static Catch* ReadFrom(Reader* reader); |
| 2351 void WriteTo(Writer* writer); |
| 2352 |
| 2353 virtual ~Catch(); |
| 2354 |
| 2355 DEFINE_CASTING_OPERATIONS(Catch); |
| 2356 |
| 2357 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 2358 virtual void VisitChildren(Visitor* visitor); |
| 2359 |
| 2360 DartType* guard() { return guard_; } |
| 2361 VariableDeclaration* exception() { return exception_; } |
| 2362 VariableDeclaration* stack_trace() { return stack_trace_; } |
| 2363 Statement* body() { return body_; } |
| 2364 |
| 2365 private: |
| 2366 Catch() {} |
| 2367 |
| 2368 template <typename T> |
| 2369 friend class List; |
| 2370 |
| 2371 Child<DartType> guard_; |
| 2372 Child<VariableDeclaration> exception_; |
| 2373 Child<VariableDeclaration> stack_trace_; |
| 2374 Child<Statement> body_; |
| 2375 |
| 2376 DISALLOW_COPY_AND_ASSIGN(Catch); |
| 2377 }; |
| 2378 |
| 2379 |
| 2380 class TryFinally : public Statement { |
| 2381 public: |
| 2382 static TryFinally* ReadFrom(Reader* reader); |
| 2383 virtual void WriteTo(Writer* writer); |
| 2384 |
| 2385 virtual ~TryFinally(); |
| 2386 |
| 2387 DEFINE_CASTING_OPERATIONS(TryFinally); |
| 2388 |
| 2389 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2390 virtual void VisitChildren(Visitor* visitor); |
| 2391 |
| 2392 Statement* body() { return body_; } |
| 2393 Statement* finalizer() { return finalizer_; } |
| 2394 |
| 2395 private: |
| 2396 TryFinally() {} |
| 2397 |
| 2398 Child<Statement> body_; |
| 2399 Child<Statement> finalizer_; |
| 2400 |
| 2401 DISALLOW_COPY_AND_ASSIGN(TryFinally); |
| 2402 }; |
| 2403 |
| 2404 |
| 2405 class YieldStatement : public Statement { |
| 2406 public: |
| 2407 enum { |
| 2408 kFlagYieldStar = 1 << 0, |
| 2409 kFlagNative = 1 << 1, |
| 2410 }; |
| 2411 static YieldStatement* ReadFrom(Reader* reader); |
| 2412 virtual void WriteTo(Writer* writer); |
| 2413 |
| 2414 virtual ~YieldStatement(); |
| 2415 |
| 2416 DEFINE_CASTING_OPERATIONS(YieldStatement); |
| 2417 |
| 2418 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2419 virtual void VisitChildren(Visitor* visitor); |
| 2420 |
| 2421 bool is_yield_start() { return (flags_ & kFlagYieldStar) == kFlagYieldStar; } |
| 2422 bool is_native() { return (flags_ & kFlagNative) == kFlagNative; } |
| 2423 Expression* expression() { return expression_; } |
| 2424 |
| 2425 private: |
| 2426 YieldStatement() {} |
| 2427 |
| 2428 word flags_; |
| 2429 Child<Expression> expression_; |
| 2430 |
| 2431 DISALLOW_COPY_AND_ASSIGN(YieldStatement); |
| 2432 }; |
| 2433 |
| 2434 |
| 2435 class VariableDeclaration : public Statement { |
| 2436 public: |
| 2437 enum Flags { |
| 2438 kFlagFinal = 1 << 0, |
| 2439 kFlagConst = 1 << 1, |
| 2440 }; |
| 2441 |
| 2442 static VariableDeclaration* ReadFrom(Reader* reader); |
| 2443 static VariableDeclaration* ReadFromImpl(Reader* reader); |
| 2444 virtual void WriteTo(Writer* writer); |
| 2445 void WriteToImpl(Writer* writer); |
| 2446 |
| 2447 virtual ~VariableDeclaration(); |
| 2448 |
| 2449 DEFINE_CASTING_OPERATIONS(VariableDeclaration); |
| 2450 |
| 2451 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2452 virtual void VisitChildren(Visitor* visitor); |
| 2453 |
| 2454 bool IsConst() { return (flags_ & kFlagConst) == kFlagConst; } |
| 2455 bool IsFinal() { return (flags_ & kFlagFinal) == kFlagFinal; } |
| 2456 |
| 2457 String* name() { return name_; } |
| 2458 DartType* type() { return type_; } |
| 2459 InferredValue* inferred_value() { return inferred_value_; } |
| 2460 Expression* initializer() { return initializer_; } |
| 2461 |
| 2462 private: |
| 2463 VariableDeclaration() {} |
| 2464 |
| 2465 template <typename T> |
| 2466 friend class List; |
| 2467 |
| 2468 word flags_; |
| 2469 Ref<String> name_; |
| 2470 Child<DartType> type_; |
| 2471 Child<InferredValue> inferred_value_; |
| 2472 Child<Expression> initializer_; |
| 2473 |
| 2474 DISALLOW_COPY_AND_ASSIGN(VariableDeclaration); |
| 2475 }; |
| 2476 |
| 2477 |
| 2478 class FunctionDeclaration : public Statement { |
| 2479 public: |
| 2480 static FunctionDeclaration* ReadFrom(Reader* reader); |
| 2481 virtual void WriteTo(Writer* writer); |
| 2482 |
| 2483 virtual ~FunctionDeclaration(); |
| 2484 |
| 2485 DEFINE_CASTING_OPERATIONS(FunctionDeclaration); |
| 2486 |
| 2487 virtual void AcceptStatementVisitor(StatementVisitor* visitor); |
| 2488 virtual void VisitChildren(Visitor* visitor); |
| 2489 |
| 2490 VariableDeclaration* variable() { return variable_; } |
| 2491 FunctionNode* function() { return function_; } |
| 2492 |
| 2493 private: |
| 2494 FunctionDeclaration() {} |
| 2495 |
| 2496 Child<VariableDeclaration> variable_; |
| 2497 Child<FunctionNode> function_; |
| 2498 |
| 2499 DISALLOW_COPY_AND_ASSIGN(FunctionDeclaration); |
| 2500 }; |
| 2501 |
| 2502 |
| 2503 class Name : public Node { |
| 2504 public: |
| 2505 static Name* ReadFrom(Reader* reader); |
| 2506 void WriteTo(Writer* writer); |
| 2507 |
| 2508 virtual ~Name(); |
| 2509 |
| 2510 DEFINE_CASTING_OPERATIONS(Name); |
| 2511 |
| 2512 virtual void AcceptVisitor(Visitor* visitor); |
| 2513 virtual void VisitChildren(Visitor* visitor); |
| 2514 |
| 2515 String* string() { return string_; } |
| 2516 Library* library() { return library_; } |
| 2517 |
| 2518 private: |
| 2519 Name(String* string, Library* library) : string_(string), library_(library) {} |
| 2520 |
| 2521 Ref<String> string_; |
| 2522 Ref<Library> library_; |
| 2523 |
| 2524 DISALLOW_COPY_AND_ASSIGN(Name); |
| 2525 }; |
| 2526 |
| 2527 |
| 2528 class InferredValue : public Node { |
| 2529 public: |
| 2530 static const uint8_t kNull = 1 << 0; |
| 2531 static const uint8_t kInteger = 1 << 1; |
| 2532 static const uint8_t kDouble = 1 << 2; |
| 2533 static const uint8_t kString = 1 << 3; |
| 2534 static const uint8_t kOther = 1 << 4; |
| 2535 |
| 2536 enum BaseClassKind { |
| 2537 kNone, |
| 2538 kExact, |
| 2539 kSubclass, |
| 2540 kSubtype, |
| 2541 }; |
| 2542 |
| 2543 static InferredValue* ReadFrom(Reader* reader); |
| 2544 void WriteTo(Writer* writer); |
| 2545 |
| 2546 virtual ~InferredValue(); |
| 2547 |
| 2548 DEFINE_CASTING_OPERATIONS(InferredValue); |
| 2549 |
| 2550 virtual void AcceptVisitor(Visitor* visitor); |
| 2551 virtual void VisitChildren(Visitor* visitor); |
| 2552 |
| 2553 bool IsInterfaceType() { return kind_ == kSubtype; } |
| 2554 bool IsExactClass() { return kind_ == kExact; } |
| 2555 bool IsSubclass() { return kind_ == kSubclass; } |
| 2556 |
| 2557 bool CanBeNull() { return (value_bits_ & kNull) != 0; } |
| 2558 bool CanBeInteger() { return (value_bits_ & kInteger) != 0; } |
| 2559 bool CanBeDouble() { return (value_bits_ & kDouble) != 0; } |
| 2560 bool CanBeString() { return (value_bits_ & kString) != 0; } |
| 2561 |
| 2562 bool IsAlwaysNull() { return value_bits_ == kNull; } |
| 2563 bool IsAlwaysInteger() { return value_bits_ == kInteger; } |
| 2564 bool IsAlwaysDouble() { return value_bits_ == kDouble; } |
| 2565 bool IsAlwaysString() { return value_bits_ == kString; } |
| 2566 |
| 2567 Class* klass() { return klass_; } |
| 2568 BaseClassKind kind() { return kind_; } |
| 2569 uint8_t value_bits() { return value_bits_; } |
| 2570 |
| 2571 private: |
| 2572 InferredValue() { } |
| 2573 |
| 2574 Ref<Class> klass_; |
| 2575 BaseClassKind kind_; |
| 2576 uint8_t value_bits_; |
| 2577 |
| 2578 DISALLOW_COPY_AND_ASSIGN(InferredValue); |
| 2579 }; |
| 2580 |
| 2581 |
| 2582 class DartType : public Node { |
| 2583 public: |
| 2584 static DartType* ReadFrom(Reader* reader); |
| 2585 virtual void WriteTo(Writer* writer) = 0; |
| 2586 |
| 2587 virtual ~DartType(); |
| 2588 |
| 2589 DEFINE_CASTING_OPERATIONS(DartType); |
| 2590 |
| 2591 virtual void AcceptVisitor(Visitor* visitor); |
| 2592 virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor) = 0; |
| 2593 |
| 2594 protected: |
| 2595 DartType() { } |
| 2596 |
| 2597 private: |
| 2598 DISALLOW_COPY_AND_ASSIGN(DartType); |
| 2599 }; |
| 2600 |
| 2601 |
| 2602 class InvalidType : public DartType { |
| 2603 public: |
| 2604 static InvalidType* ReadFrom(Reader* reader); |
| 2605 void WriteTo(Writer* writer); |
| 2606 |
| 2607 virtual ~InvalidType(); |
| 2608 |
| 2609 DEFINE_CASTING_OPERATIONS(InvalidType); |
| 2610 |
| 2611 virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor); |
| 2612 virtual void VisitChildren(Visitor* visitor); |
| 2613 |
| 2614 private: |
| 2615 InvalidType() { } |
| 2616 |
| 2617 DISALLOW_COPY_AND_ASSIGN(InvalidType); |
| 2618 }; |
| 2619 |
| 2620 |
| 2621 class DynamicType : public DartType { |
| 2622 public: |
| 2623 static DynamicType* ReadFrom(Reader* reader); |
| 2624 void WriteTo(Writer* writer); |
| 2625 |
| 2626 virtual ~DynamicType(); |
| 2627 |
| 2628 DEFINE_CASTING_OPERATIONS(DynamicType); |
| 2629 |
| 2630 virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor); |
| 2631 virtual void VisitChildren(Visitor* visitor); |
| 2632 |
| 2633 private: |
| 2634 DynamicType() { } |
| 2635 |
| 2636 DISALLOW_COPY_AND_ASSIGN(DynamicType); |
| 2637 }; |
| 2638 |
| 2639 |
| 2640 class VoidType : public DartType { |
| 2641 public: |
| 2642 static VoidType* ReadFrom(Reader* reader); |
| 2643 void WriteTo(Writer* writer); |
| 2644 |
| 2645 virtual ~VoidType(); |
| 2646 |
| 2647 DEFINE_CASTING_OPERATIONS(VoidType); |
| 2648 |
| 2649 virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor); |
| 2650 virtual void VisitChildren(Visitor* visitor); |
| 2651 |
| 2652 private: |
| 2653 VoidType() { } |
| 2654 |
| 2655 DISALLOW_COPY_AND_ASSIGN(VoidType); |
| 2656 }; |
| 2657 |
| 2658 |
| 2659 class InterfaceType : public DartType { |
| 2660 public: |
| 2661 static InterfaceType* ReadFrom(Reader* reader); |
| 2662 static InterfaceType* ReadFrom(Reader* reader, bool _without_type_arguments_); |
| 2663 void WriteTo(Writer* writer); |
| 2664 |
| 2665 explicit InterfaceType(Class* klass) : klass_(klass) {} |
| 2666 virtual ~InterfaceType(); |
| 2667 |
| 2668 DEFINE_CASTING_OPERATIONS(InterfaceType); |
| 2669 |
| 2670 virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor); |
| 2671 virtual void VisitChildren(Visitor* visitor); |
| 2672 |
| 2673 Class* klass() { return klass_; } |
| 2674 List<DartType>& type_arguments() { return type_arguments_; } |
| 2675 |
| 2676 private: |
| 2677 InterfaceType() {} |
| 2678 |
| 2679 Ref<Class> klass_; |
| 2680 List<DartType> type_arguments_; |
| 2681 |
| 2682 DISALLOW_COPY_AND_ASSIGN(InterfaceType); |
| 2683 }; |
| 2684 |
| 2685 |
| 2686 class FunctionType : public DartType { |
| 2687 public: |
| 2688 static FunctionType* ReadFrom(Reader* reader); |
| 2689 static FunctionType* ReadFrom(Reader* reader, bool _without_type_arguments_); |
| 2690 void WriteTo(Writer* writer); |
| 2691 |
| 2692 virtual ~FunctionType(); |
| 2693 |
| 2694 DEFINE_CASTING_OPERATIONS(FunctionType); |
| 2695 |
| 2696 virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor); |
| 2697 virtual void VisitChildren(Visitor* visitor); |
| 2698 |
| 2699 TypeParameterList& type_parameters() { return type_parameters_; } |
| 2700 int required_parameter_count() { return required_parameter_count_; } |
| 2701 List<DartType>& positional_parameters() { return positional_parameters_; } |
| 2702 List<Tuple<String, DartType> >& named_parameters() { |
| 2703 return named_parameters_; |
| 2704 } |
| 2705 DartType* return_type() { return return_type_; } |
| 2706 |
| 2707 private: |
| 2708 FunctionType() {} |
| 2709 |
| 2710 TypeParameterList type_parameters_; |
| 2711 int required_parameter_count_; |
| 2712 List<DartType> positional_parameters_; |
| 2713 List<Tuple<String, DartType> > named_parameters_; |
| 2714 Child<DartType> return_type_; |
| 2715 |
| 2716 DISALLOW_COPY_AND_ASSIGN(FunctionType); |
| 2717 }; |
| 2718 |
| 2719 |
| 2720 class TypeParameterType : public DartType { |
| 2721 public: |
| 2722 static TypeParameterType* ReadFrom(Reader* reader); |
| 2723 void WriteTo(Writer* writer); |
| 2724 |
| 2725 virtual ~TypeParameterType(); |
| 2726 |
| 2727 DEFINE_CASTING_OPERATIONS(TypeParameterType); |
| 2728 |
| 2729 virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor); |
| 2730 virtual void VisitChildren(Visitor* visitor); |
| 2731 |
| 2732 TypeParameter* parameter() { return parameter_; } |
| 2733 |
| 2734 private: |
| 2735 TypeParameterType() {} |
| 2736 |
| 2737 Ref<TypeParameter> parameter_; |
| 2738 |
| 2739 DISALLOW_COPY_AND_ASSIGN(TypeParameterType); |
| 2740 }; |
| 2741 |
| 2742 |
| 2743 class TypeParameter : public TreeNode { |
| 2744 public: |
| 2745 TypeParameter* ReadFrom(Reader* reader); |
| 2746 void WriteTo(Writer* writer); |
| 2747 |
| 2748 virtual ~TypeParameter(); |
| 2749 |
| 2750 DEFINE_CASTING_OPERATIONS(TypeParameter); |
| 2751 |
| 2752 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 2753 virtual void VisitChildren(Visitor* visitor); |
| 2754 |
| 2755 String* name() { return name_; } |
| 2756 DartType* bound() { return bound_; } |
| 2757 |
| 2758 private: |
| 2759 TypeParameter() {} |
| 2760 |
| 2761 template <typename T> |
| 2762 friend class List; |
| 2763 friend class TypeParameterList; |
| 2764 |
| 2765 Ref<String> name_; |
| 2766 Child<DartType> bound_; |
| 2767 |
| 2768 DISALLOW_COPY_AND_ASSIGN(TypeParameter); |
| 2769 }; |
| 2770 |
| 2771 |
| 2772 class Program : public TreeNode { |
| 2773 public: |
| 2774 static Program* ReadFrom(Reader* reader); |
| 2775 void WriteTo(Writer* writer); |
| 2776 |
| 2777 virtual ~Program(); |
| 2778 |
| 2779 DEFINE_CASTING_OPERATIONS(Program); |
| 2780 |
| 2781 virtual void AcceptTreeVisitor(TreeVisitor* visitor); |
| 2782 virtual void VisitChildren(Visitor* visitor); |
| 2783 |
| 2784 StringTable& string_table() { return string_table_; } |
| 2785 List<Library>& libraries() { return libraries_; } |
| 2786 Procedure* main_method() { return main_method_; } |
| 2787 |
| 2788 private: |
| 2789 Program() {} |
| 2790 |
| 2791 List<Library> libraries_; |
| 2792 Ref<Procedure> main_method_; |
| 2793 StringTable string_table_; |
| 2794 |
| 2795 DISALLOW_COPY_AND_ASSIGN(Program); |
| 2796 }; |
| 2797 |
| 2798 |
| 2799 class Reference : public AllStatic { |
| 2800 public: |
| 2801 static Member* ReadMemberFrom(Reader* reader, bool allow_null = false); |
| 2802 static void WriteMemberTo(Writer* writer, Member* member, |
| 2803 bool allow_null = false); |
| 2804 |
| 2805 static Class* ReadClassFrom(Reader* reader, bool allow_null = false); |
| 2806 static void WriteClassTo(Writer* writer, Class* klass, |
| 2807 bool allow_null = false); |
| 2808 |
| 2809 static String* ReadStringFrom(Reader* reader); |
| 2810 static void WriteStringTo(Writer* writer, String* string); // NOLINT |
| 2811 }; |
| 2812 |
| 2813 |
| 2814 class ExpressionVisitor { |
| 2815 public: |
| 2816 virtual ~ExpressionVisitor() {} |
| 2817 |
| 2818 virtual void VisitDefaultExpression(Expression* node) = 0; |
| 2819 virtual void VisitDefaultBasicLiteral(BasicLiteral* node) { |
| 2820 VisitDefaultExpression(node); |
| 2821 } |
| 2822 virtual void VisitInvalidExpression(InvalidExpression* node) { |
| 2823 VisitDefaultExpression(node); |
| 2824 } |
| 2825 virtual void VisitVariableGet(VariableGet* node) { |
| 2826 VisitDefaultExpression(node); |
| 2827 } |
| 2828 virtual void VisitVariableSet(VariableSet* node) { |
| 2829 VisitDefaultExpression(node); |
| 2830 } |
| 2831 virtual void VisitPropertyGet(PropertyGet* node) { |
| 2832 VisitDefaultExpression(node); |
| 2833 } |
| 2834 virtual void VisitPropertySet(PropertySet* node) { |
| 2835 VisitDefaultExpression(node); |
| 2836 } |
| 2837 virtual void VisitDirectPropertyGet(DirectPropertyGet* node) { |
| 2838 VisitDefaultExpression(node); |
| 2839 } |
| 2840 virtual void VisitDirectPropertySet(DirectPropertySet* node) { |
| 2841 VisitDefaultExpression(node); |
| 2842 } |
| 2843 virtual void VisitStaticGet(StaticGet* node) { VisitDefaultExpression(node); } |
| 2844 virtual void VisitStaticSet(StaticSet* node) { VisitDefaultExpression(node); } |
| 2845 virtual void VisitMethodInvocation(MethodInvocation* node) { |
| 2846 VisitDefaultExpression(node); |
| 2847 } |
| 2848 virtual void VisitDirectMethodInvocation(DirectMethodInvocation* node) { |
| 2849 VisitDefaultExpression(node); |
| 2850 } |
| 2851 virtual void VisitStaticInvocation(StaticInvocation* node) { |
| 2852 VisitDefaultExpression(node); |
| 2853 } |
| 2854 virtual void VisitConstructorInvocation(ConstructorInvocation* node) { |
| 2855 VisitDefaultExpression(node); |
| 2856 } |
| 2857 virtual void VisitNot(Not* node) { VisitDefaultExpression(node); } |
| 2858 virtual void VisitLogicalExpression(LogicalExpression* node) { |
| 2859 VisitDefaultExpression(node); |
| 2860 } |
| 2861 virtual void VisitConditionalExpression(ConditionalExpression* node) { |
| 2862 VisitDefaultExpression(node); |
| 2863 } |
| 2864 virtual void VisitStringConcatenation(StringConcatenation* node) { |
| 2865 VisitDefaultExpression(node); |
| 2866 } |
| 2867 virtual void VisitIsExpression(IsExpression* node) { |
| 2868 VisitDefaultExpression(node); |
| 2869 } |
| 2870 virtual void VisitAsExpression(AsExpression* node) { |
| 2871 VisitDefaultExpression(node); |
| 2872 } |
| 2873 virtual void VisitSymbolLiteral(SymbolLiteral* node) { |
| 2874 VisitDefaultExpression(node); |
| 2875 } |
| 2876 virtual void VisitTypeLiteral(TypeLiteral* node) { |
| 2877 VisitDefaultExpression(node); |
| 2878 } |
| 2879 virtual void VisitThisExpression(ThisExpression* node) { |
| 2880 VisitDefaultExpression(node); |
| 2881 } |
| 2882 virtual void VisitRethrow(Rethrow* node) { VisitDefaultExpression(node); } |
| 2883 virtual void VisitThrow(Throw* node) { VisitDefaultExpression(node); } |
| 2884 virtual void VisitListLiteral(ListLiteral* node) { |
| 2885 VisitDefaultExpression(node); |
| 2886 } |
| 2887 virtual void VisitMapLiteral(MapLiteral* node) { |
| 2888 VisitDefaultExpression(node); |
| 2889 } |
| 2890 virtual void VisitAwaitExpression(AwaitExpression* node) { |
| 2891 VisitDefaultExpression(node); |
| 2892 } |
| 2893 virtual void VisitFunctionExpression(FunctionExpression* node) { |
| 2894 VisitDefaultExpression(node); |
| 2895 } |
| 2896 virtual void VisitStringLiteral(StringLiteral* node) { |
| 2897 VisitDefaultBasicLiteral(node); |
| 2898 } |
| 2899 virtual void VisitBigintLiteral(BigintLiteral* node) { |
| 2900 VisitDefaultBasicLiteral(node); |
| 2901 } |
| 2902 virtual void VisitIntLiteral(IntLiteral* node) { |
| 2903 VisitDefaultBasicLiteral(node); |
| 2904 } |
| 2905 virtual void VisitDoubleLiteral(DoubleLiteral* node) { |
| 2906 VisitDefaultBasicLiteral(node); |
| 2907 } |
| 2908 virtual void VisitBoolLiteral(BoolLiteral* node) { |
| 2909 VisitDefaultBasicLiteral(node); |
| 2910 } |
| 2911 virtual void VisitNullLiteral(NullLiteral* node) { |
| 2912 VisitDefaultBasicLiteral(node); |
| 2913 } |
| 2914 virtual void VisitLet(Let* node) { VisitDefaultExpression(node); } |
| 2915 virtual void VisitBlockExpression(BlockExpression* node) { |
| 2916 VisitDefaultExpression(node); |
| 2917 } |
| 2918 }; |
| 2919 |
| 2920 |
| 2921 class StatementVisitor { |
| 2922 public: |
| 2923 virtual ~StatementVisitor() {} |
| 2924 |
| 2925 virtual void VisitDefaultStatement(Statement* node) = 0; |
| 2926 virtual void VisitInvalidStatement(InvalidStatement* node) { |
| 2927 VisitDefaultStatement(node); |
| 2928 } |
| 2929 virtual void VisitExpressionStatement(ExpressionStatement* node) { |
| 2930 VisitDefaultStatement(node); |
| 2931 } |
| 2932 virtual void VisitBlock(Block* node) { VisitDefaultStatement(node); } |
| 2933 virtual void VisitEmptyStatement(EmptyStatement* node) { |
| 2934 VisitDefaultStatement(node); |
| 2935 } |
| 2936 virtual void VisitAssertStatement(AssertStatement* node) { |
| 2937 VisitDefaultStatement(node); |
| 2938 } |
| 2939 virtual void VisitLabeledStatement(LabeledStatement* node) { |
| 2940 VisitDefaultStatement(node); |
| 2941 } |
| 2942 virtual void VisitBreakStatement(BreakStatement* node) { |
| 2943 VisitDefaultStatement(node); |
| 2944 } |
| 2945 virtual void VisitWhileStatement(WhileStatement* node) { |
| 2946 VisitDefaultStatement(node); |
| 2947 } |
| 2948 virtual void VisitDoStatement(DoStatement* node) { |
| 2949 VisitDefaultStatement(node); |
| 2950 } |
| 2951 virtual void VisitForStatement(ForStatement* node) { |
| 2952 VisitDefaultStatement(node); |
| 2953 } |
| 2954 virtual void VisitForInStatement(ForInStatement* node) { |
| 2955 VisitDefaultStatement(node); |
| 2956 } |
| 2957 virtual void VisitSwitchStatement(SwitchStatement* node) { |
| 2958 VisitDefaultStatement(node); |
| 2959 } |
| 2960 virtual void VisitContinueSwitchStatement(ContinueSwitchStatement* node) { |
| 2961 VisitDefaultStatement(node); |
| 2962 } |
| 2963 virtual void VisitIfStatement(IfStatement* node) { |
| 2964 VisitDefaultStatement(node); |
| 2965 } |
| 2966 virtual void VisitReturnStatement(ReturnStatement* node) { |
| 2967 VisitDefaultStatement(node); |
| 2968 } |
| 2969 virtual void VisitTryCatch(TryCatch* node) { VisitDefaultStatement(node); } |
| 2970 virtual void VisitTryFinally(TryFinally* node) { |
| 2971 VisitDefaultStatement(node); |
| 2972 } |
| 2973 virtual void VisitYieldStatement(YieldStatement* node) { |
| 2974 VisitDefaultStatement(node); |
| 2975 } |
| 2976 virtual void VisitVariableDeclaration(VariableDeclaration* node) { |
| 2977 VisitDefaultStatement(node); |
| 2978 } |
| 2979 virtual void VisitFunctionDeclaration(FunctionDeclaration* node) { |
| 2980 VisitDefaultStatement(node); |
| 2981 } |
| 2982 }; |
| 2983 |
| 2984 |
| 2985 class MemberVisitor { |
| 2986 public: |
| 2987 virtual ~MemberVisitor() {} |
| 2988 |
| 2989 virtual void VisitDefaultMember(Member* node) = 0; |
| 2990 virtual void VisitConstructor(Constructor* node) { VisitDefaultMember(node); } |
| 2991 virtual void VisitProcedure(Procedure* node) { VisitDefaultMember(node); } |
| 2992 virtual void VisitField(Field* node) { VisitDefaultMember(node); } |
| 2993 }; |
| 2994 |
| 2995 |
| 2996 class ClassVisitor { |
| 2997 public: |
| 2998 virtual ~ClassVisitor() {} |
| 2999 |
| 3000 virtual void VisitDefaultClass(Class* node) = 0; |
| 3001 virtual void VisitNormalClass(NormalClass* node) { VisitDefaultClass(node); } |
| 3002 virtual void VisitMixinClass(MixinClass* node) { VisitDefaultClass(node); } |
| 3003 }; |
| 3004 |
| 3005 |
| 3006 class InitializerVisitor { |
| 3007 public: |
| 3008 virtual ~InitializerVisitor() {} |
| 3009 |
| 3010 virtual void VisitDefaultInitializer(Initializer* node) = 0; |
| 3011 virtual void VisitInvalidInitializer(InvalidInitializer* node) { |
| 3012 VisitDefaultInitializer(node); |
| 3013 } |
| 3014 virtual void VisitFieldInitializer(FieldInitializer* node) { |
| 3015 VisitDefaultInitializer(node); |
| 3016 } |
| 3017 virtual void VisitSuperInitializer(SuperInitializer* node) { |
| 3018 VisitDefaultInitializer(node); |
| 3019 } |
| 3020 virtual void VisitRedirectingInitializer(RedirectingInitializer* node) { |
| 3021 VisitDefaultInitializer(node); |
| 3022 } |
| 3023 virtual void VisitLocalInitializer(LocalInitializer* node) { |
| 3024 VisitDefaultInitializer(node); |
| 3025 } |
| 3026 }; |
| 3027 |
| 3028 |
| 3029 class DartTypeVisitor { |
| 3030 public: |
| 3031 virtual ~DartTypeVisitor() {} |
| 3032 |
| 3033 virtual void VisitDefaultDartType(DartType* node) = 0; |
| 3034 virtual void VisitInvalidType(InvalidType* node) { |
| 3035 VisitDefaultDartType(node); |
| 3036 } |
| 3037 virtual void VisitDynamicType(DynamicType* node) { |
| 3038 VisitDefaultDartType(node); |
| 3039 } |
| 3040 virtual void VisitVoidType(VoidType* node) { VisitDefaultDartType(node); } |
| 3041 virtual void VisitInterfaceType(InterfaceType* node) { |
| 3042 VisitDefaultDartType(node); |
| 3043 } |
| 3044 virtual void VisitFunctionType(FunctionType* node) { |
| 3045 VisitDefaultDartType(node); |
| 3046 } |
| 3047 virtual void VisitTypeParameterType(TypeParameterType* node) { |
| 3048 VisitDefaultDartType(node); |
| 3049 } |
| 3050 }; |
| 3051 |
| 3052 |
| 3053 class ClassReferenceVisitor { |
| 3054 public: |
| 3055 virtual ~ClassReferenceVisitor() {} |
| 3056 |
| 3057 virtual void VisitDefaultClassReference(Class* node) = 0; |
| 3058 virtual void VisitNormalClassReference(NormalClass* node) { |
| 3059 VisitDefaultClassReference(node); |
| 3060 } |
| 3061 virtual void VisitMixinClassReference(MixinClass* node) { |
| 3062 VisitDefaultClassReference(node); |
| 3063 } |
| 3064 }; |
| 3065 |
| 3066 |
| 3067 class MemberReferenceVisitor { |
| 3068 public: |
| 3069 virtual ~MemberReferenceVisitor() {} |
| 3070 |
| 3071 virtual void VisitDefaultMemberReference(Member* node) = 0; |
| 3072 virtual void VisitFieldReference(Field* node) { |
| 3073 VisitDefaultMemberReference(node); |
| 3074 } |
| 3075 virtual void VisitConstructorReference(Constructor* node) { |
| 3076 VisitDefaultMemberReference(node); |
| 3077 } |
| 3078 virtual void VisitProcedureReference(Procedure* node) { |
| 3079 VisitDefaultMemberReference(node); |
| 3080 } |
| 3081 }; |
| 3082 |
| 3083 |
| 3084 class TreeVisitor : public ExpressionVisitor, |
| 3085 public StatementVisitor, |
| 3086 public MemberVisitor, |
| 3087 public ClassVisitor, |
| 3088 public InitializerVisitor { |
| 3089 public: |
| 3090 virtual ~TreeVisitor() {} |
| 3091 |
| 3092 virtual void VisitDefaultTreeNode(TreeNode* node) = 0; |
| 3093 virtual void VisitDefaultStatement(Statement* node) { |
| 3094 VisitDefaultTreeNode(node); |
| 3095 } |
| 3096 virtual void VisitDefaultExpression(Expression* node) { |
| 3097 VisitDefaultTreeNode(node); |
| 3098 } |
| 3099 virtual void VisitDefaultMember(Member* node) { VisitDefaultTreeNode(node); } |
| 3100 virtual void VisitDefaultClass(Class* node) { VisitDefaultTreeNode(node); } |
| 3101 virtual void VisitDefaultInitializer(Initializer* node) { |
| 3102 VisitDefaultTreeNode(node); |
| 3103 } |
| 3104 |
| 3105 virtual void VisitLibrary(Library* node) { VisitDefaultTreeNode(node); } |
| 3106 virtual void VisitTypeParameter(TypeParameter* node) { |
| 3107 VisitDefaultTreeNode(node); |
| 3108 } |
| 3109 virtual void VisitFunctionNode(FunctionNode* node) { |
| 3110 VisitDefaultTreeNode(node); |
| 3111 } |
| 3112 virtual void VisitArguments(Arguments* node) { VisitDefaultTreeNode(node); } |
| 3113 virtual void VisitNamedExpression(NamedExpression* node) { |
| 3114 VisitDefaultTreeNode(node); |
| 3115 } |
| 3116 virtual void VisitSwitchCase(SwitchCase* node) { VisitDefaultTreeNode(node); } |
| 3117 virtual void VisitCatch(Catch* node) { VisitDefaultTreeNode(node); } |
| 3118 virtual void VisitMapEntry(MapEntry* node) { VisitDefaultTreeNode(node); } |
| 3119 virtual void VisitProgram(Program* node) { VisitDefaultTreeNode(node); } |
| 3120 }; |
| 3121 |
| 3122 |
| 3123 class Visitor : public TreeVisitor, |
| 3124 public DartTypeVisitor, |
| 3125 public ClassReferenceVisitor, |
| 3126 public MemberReferenceVisitor { |
| 3127 public: |
| 3128 virtual ~Visitor() {} |
| 3129 |
| 3130 virtual void VisitDefaultNode(Node* node) = 0; |
| 3131 virtual void VisitInferredValue(InferredValue* node) { |
| 3132 VisitDefaultNode(node); |
| 3133 } |
| 3134 virtual void VisitDefaultTreeNode(TreeNode* node) { VisitDefaultNode(node); } |
| 3135 virtual void VisitDefaultDartType(DartType* node) { VisitDefaultNode(node); } |
| 3136 virtual void VisitName(Name* node) { VisitDefaultNode(node); } |
| 3137 virtual void VisitDefaultClassReference(Class* node) { |
| 3138 VisitDefaultNode(node); |
| 3139 } |
| 3140 virtual void VisitDefaultMemberReference(Member* node) { |
| 3141 VisitDefaultNode(node); |
| 3142 } |
| 3143 }; |
| 3144 |
| 3145 |
| 3146 class RecursiveVisitor : public Visitor { |
| 3147 public: |
| 3148 virtual ~RecursiveVisitor() {} |
| 3149 |
| 3150 virtual void VisitDefaultNode(Node* node) { node->VisitChildren(this); } |
| 3151 |
| 3152 virtual void VisitDefaultClassReference(Class* node) {} |
| 3153 virtual void VisitDefaultMemberReference(Member* node) {} |
| 3154 }; |
| 3155 |
| 3156 |
| 3157 template <typename T> |
| 3158 List<T>::~List() { |
| 3159 for (int i = 0; i < length_; i++) { |
| 3160 delete array_[i]; |
| 3161 } |
| 3162 delete[] array_; |
| 3163 } |
| 3164 |
| 3165 |
| 3166 template <typename T> |
| 3167 void List<T>::EnsureInitialized(int length) { |
| 3168 if (length < length_) return; |
| 3169 |
| 3170 T** old_array = array_; |
| 3171 int old_length = length_; |
| 3172 |
| 3173 // TODO(27590) Maybe we should use double-growth instead to avoid running |
| 3174 // into the quadratic case. |
| 3175 length_ = length; |
| 3176 array_ = new T*[length_]; |
| 3177 |
| 3178 // Move old elements at the start (if necessary). |
| 3179 int offset = 0; |
| 3180 if (old_array != NULL) { |
| 3181 for (; offset < old_length; offset++) { |
| 3182 array_[offset] = old_array[offset]; |
| 3183 } |
| 3184 } |
| 3185 |
| 3186 // Set the rest to NULL. |
| 3187 for (; offset < length_; offset++) { |
| 3188 array_[offset] = NULL; |
| 3189 } |
| 3190 |
| 3191 delete[] old_array; |
| 3192 } |
| 3193 |
| 3194 |
| 3195 template <typename T> |
| 3196 template <typename IT> |
| 3197 IT* List<T>::GetOrCreate(int index) { |
| 3198 EnsureInitialized(index + 1); |
| 3199 |
| 3200 T* member = array_[index]; |
| 3201 if (member == NULL) { |
| 3202 member = array_[index] = new IT(); |
| 3203 } |
| 3204 return IT::Cast(member); |
| 3205 } |
| 3206 |
| 3207 |
| 3208 template <typename T> |
| 3209 template <typename IT, typename PT> |
| 3210 IT* List<T>::GetOrCreate(int index, PT* parent) { |
| 3211 EnsureInitialized(index + 1); |
| 3212 |
| 3213 T* member = array_[index]; |
| 3214 if (member == NULL) { |
| 3215 member = array_[index] = new IT(); |
| 3216 member->parent_ = parent; |
| 3217 } else { |
| 3218 ASSERT(member->parent_ == parent); |
| 3219 } |
| 3220 return IT::Cast(member); |
| 3221 } |
| 3222 |
| 3223 } // namespace kernel |
| 3224 |
| 3225 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer, |
| 3226 intptr_t buffer_length); |
| 3227 |
| 3228 class ByteWriter { |
| 3229 public: |
| 3230 virtual ~ByteWriter(); |
| 3231 |
| 3232 virtual void WriteByte(uint8_t byte) = 0; |
| 3233 |
| 3234 virtual void WriteBytes(uint8_t* buffer, int count) = 0; |
| 3235 }; |
| 3236 |
| 3237 |
| 3238 void WritePrecompiledKernel(ByteWriter* out, kernel::Program* program); |
| 3239 |
| 3240 |
| 3241 } // namespace dart |
| 3242 |
| 3243 #endif // VM_KERNEL_H_ |
OLD | NEW |