Appearance
| 1 | namespace Syntax is | |
| 2 | use System.NotImplementedException; | |
| 3 | ||
| 4 | use IO.Std; | |
| 5 | ||
| 6 | use Trees; | |
| 7 | ||
| 8 | class Visitor abstract is | |
| 9 | init() is | |
| 10 | super.init(); | |
| 11 | si | |
| 12 | ||
| 13 | throw_not_implemented(name: string, node: Node) => | |
| 14 | throw NotImplementedException( | |
| 15 | "Visitor {self} does not define a visit method for {name} {node.get_type()} and/or this node does not accept this visitor" | |
| 16 | ); | |
| 17 | ||
| 18 | // Generic walk hooks called by container walks around each | |
| 19 | // child. Subclasses override to maintain ambient state keyed | |
| 20 | // on the child being entered (e.g. pushing the child's | |
| 21 | // source location onto the workspace LOCATION_STACK so IR | |
| 22 | // Values constructed during the walk inherit it). | |
| 23 | enter_node(node: Node) is si | |
| 24 | leave_node(node: Node) is si | |
| 25 | ||
| 26 | pre(node: Node) -> bool => false; | |
| 27 | ||
| 28 | visit(node: Node) is | |
| 29 | si | |
| 30 | ||
| 31 | post(node: Node) is | |
| 32 | si | |
| 33 | ||
| 34 | pre(identifier: Identifiers.Identifier) -> bool => false; | |
| 35 | ||
| 36 | visit(identifier: Identifiers.Identifier) is | |
| 37 | si | |
| 38 | ||
| 39 | post(identifier: Identifiers.Identifier) is | |
| 40 | si | |
| 41 | ||
| 42 | pre(identifier: Identifiers.QUALIFIED) -> bool => false; | |
| 43 | ||
| 44 | visit(identifier: Identifiers.QUALIFIED) is | |
| 45 | si | |
| 46 | ||
| 47 | pre(modifier: Modifiers.Modifier) -> bool => false; | |
| 48 | ||
| 49 | visit(modifier: Modifiers.Modifier) is | |
| 50 | si | |
| 51 | ||
| 52 | pre(modifiers: Modifiers.LIST) -> bool => false; | |
| 53 | ||
| 54 | visit(modifiers: Modifiers.LIST) is | |
| 55 | si | |
| 56 | ||
| 57 | pre(pragma: Pragmas.PRAGMA) -> bool => false; | |
| 58 | ||
| 59 | visit(pragma: Pragmas.PRAGMA) is | |
| 60 | si | |
| 61 | ||
| 62 | pre(definition: Definitions.Definition) -> bool => false; | |
| 63 | ||
| 64 | visit(definition: Definitions.Definition) is | |
| 65 | si | |
| 66 | ||
| 67 | pre(definitions: Definitions.LIST) -> bool => false; | |
| 68 | ||
| 69 | visit(definitions: Definitions.LIST) is | |
| 70 | si | |
| 71 | ||
| 72 | pre(pragma: Definitions.PRAGMA) -> bool => false; | |
| 73 | ||
| 74 | visit(pragma: Definitions.PRAGMA) is | |
| 75 | si | |
| 76 | ||
| 77 | pre(`namespace: Definitions.NAMESPACE) -> bool => false; | |
| 78 | ||
| 79 | visit(`namespace: Definitions.NAMESPACE) is | |
| 80 | si | |
| 81 | ||
| 82 | pre(`use: Definitions.USE) -> bool => false; | |
| 83 | ||
| 84 | visit(`use: Definitions.USE) is | |
| 85 | si | |
| 86 | ||
| 87 | pre(super_call: Definitions.SUPER_CALL) -> bool => false; | |
| 88 | ||
| 89 | visit(super_call: Definitions.SUPER_CALL) is | |
| 90 | si | |
| 91 | ||
| 92 | pre(`class: Definitions.CLASS) -> bool => false; | |
| 93 | ||
| 94 | visit(`class: Definitions.CLASS) is | |
| 95 | si | |
| 96 | ||
| 97 | pre(`trait: Definitions.TRAIT) -> bool => false; | |
| 98 | ||
| 99 | visit(`trait: Definitions.TRAIT) is | |
| 100 | si | |
| 101 | ||
| 102 | pre(`struct: Definitions.STRUCT) -> bool => false; | |
| 103 | ||
| 104 | visit(`struct: Definitions.STRUCT) is | |
| 105 | si | |
| 106 | ||
| 107 | pre(`partial: Definitions.PARTIAL) -> bool => false; | |
| 108 | ||
| 109 | visit(`partial: Definitions.PARTIAL) is | |
| 110 | si | |
| 111 | ||
| 112 | pre(`impl: Definitions.IMPL) -> bool => false; | |
| 113 | ||
| 114 | visit(`impl: Definitions.IMPL) is | |
| 115 | si | |
| 116 | ||
| 117 | pre(`union: Definitions.UNION) -> bool => false; | |
| 118 | ||
| 119 | visit(`union: Definitions.UNION) is | |
| 120 | si | |
| 121 | ||
| 122 | pre(variant: Definitions.VARIANT) -> bool => false; | |
| 123 | ||
| 124 | visit(variant: Definitions.VARIANT) is | |
| 125 | si | |
| 126 | ||
| 127 | pre(`enum: Definitions.ENUM) -> bool => false; | |
| 128 | ||
| 129 | visit(`enum: Definitions.ENUM) is | |
| 130 | si | |
| 131 | ||
| 132 | pre(enum_member: Definitions.ENUM_MEMBER) -> bool => false; | |
| 133 | ||
| 134 | visit(enum_member: Definitions.ENUM_MEMBER) is | |
| 135 | si | |
| 136 | ||
| 137 | pre(function: Definitions.FUNCTION) -> bool => false; | |
| 138 | ||
| 139 | visit(function: Definitions.FUNCTION) is | |
| 140 | si | |
| 141 | ||
| 142 | pre(functions: Definitions.FUNCTION_GROUP) -> bool => false; | |
| 143 | ||
| 144 | visit(functions: Definitions.FUNCTION_GROUP) is | |
| 145 | si | |
| 146 | ||
| 147 | pre(property: Definitions.PROPERTY) -> bool => false; | |
| 148 | ||
| 149 | visit(property: Definitions.PROPERTY) is | |
| 150 | si | |
| 151 | ||
| 152 | pre(indexer: Definitions.INDEXER) -> bool => false; | |
| 153 | ||
| 154 | visit(indexer: Definitions.INDEXER) is | |
| 155 | si | |
| 156 | ||
| 157 | pre(variable: Variables.VARIABLE) -> bool => false; | |
| 158 | ||
| 159 | visit(variable: Variables.VARIABLE) is | |
| 160 | si | |
| 161 | ||
| 162 | pre(variables: Variables.LIST) -> bool => false; | |
| 163 | ||
| 164 | visit(variables: Variables.LIST) is | |
| 165 | si | |
| 166 | ||
| 167 | pre(left: Trees.Variables.SIMPLE_VARIABLE_LEFT) -> bool => false; | |
| 168 | ||
| 169 | visit(left: Trees.Variables.SIMPLE_VARIABLE_LEFT) is | |
| 170 | si | |
| 171 | ||
| 172 | pre(destructure_left: Trees.Variables.DESTRUCTURING_VARIABLE_LEFT) -> bool => false; | |
| 173 | ||
| 174 | visit(destructure_left: Trees.Variables.DESTRUCTURING_VARIABLE_LEFT) is | |
| 175 | si | |
| 176 | ||
| 177 | pre(left: Trees.Variables.LITERAL_VARIABLE_LEFT) -> bool => false; | |
| 178 | ||
| 179 | visit(left: Trees.Variables.LITERAL_VARIABLE_LEFT) is | |
| 180 | si | |
| 181 | ||
| 182 | pre(type_expression: TypeExpressions.TypeExpression) -> bool => false; | |
| 183 | ||
| 184 | visit(type_expression: TypeExpressions.TypeExpression) is | |
| 185 | si | |
| 186 | ||
| 187 | pre(infer: TypeExpressions.INFER) -> bool => false; | |
| 188 | ||
| 189 | visit(type_expression: TypeExpressions.INFER) is | |
| 190 | si | |
| 191 | ||
| 192 | pre(structured: TypeExpressions.Structured) -> bool => false; | |
| 193 | ||
| 194 | visit(structured: TypeExpressions.Structured) is | |
| 195 | si | |
| 196 | ||
| 197 | pre(array: TypeExpressions.ARRAY_) -> bool => false; | |
| 198 | ||
| 199 | visit(array: TypeExpressions.ARRAY_) is | |
| 200 | si | |
| 201 | ||
| 202 | pre(pointer: TypeExpressions.POINTER) -> bool => false; | |
| 203 | ||
| 204 | visit(pointer: TypeExpressions.POINTER) is | |
| 205 | si | |
| 206 | ||
| 207 | pre(optional: TypeExpressions.OPTIONAL) -> bool => false; | |
| 208 | ||
| 209 | visit(optional: TypeExpressions.OPTIONAL) is | |
| 210 | si | |
| 211 | ||
| 212 | pre(reference: TypeExpressions.REFERENCE) -> bool => false; | |
| 213 | ||
| 214 | visit(reference: TypeExpressions.REFERENCE) is | |
| 215 | si | |
| 216 | ||
| 217 | pre(member: TypeExpressions.MEMBER) -> bool => false; | |
| 218 | ||
| 219 | visit(member: TypeExpressions.MEMBER) is | |
| 220 | si | |
| 221 | ||
| 222 | pre(named: TypeExpressions.NAMED) -> bool => false; | |
| 223 | ||
| 224 | visit(named: TypeExpressions.NAMED) is | |
| 225 | si | |
| 226 | ||
| 227 | pre(types: TypeExpressions.LIST) -> bool => false; | |
| 228 | ||
| 229 | visit(types: TypeExpressions.LIST) is | |
| 230 | si | |
| 231 | ||
| 232 | pre(generic: TypeExpressions.GENERIC) -> bool => false; | |
| 233 | ||
| 234 | visit(generic: TypeExpressions.GENERIC) is | |
| 235 | si | |
| 236 | ||
| 237 | pre(function: TypeExpressions.FUNCTION) -> bool => false; | |
| 238 | ||
| 239 | visit(function: TypeExpressions.FUNCTION) is | |
| 240 | si | |
| 241 | ||
| 242 | pre(functions: TypeExpressions.FUNCTION_GROUP) -> bool => false; | |
| 243 | ||
| 244 | visit(functions: TypeExpressions.FUNCTION_GROUP) is | |
| 245 | si | |
| 246 | ||
| 247 | pre(tuple: TypeExpressions.TUPLE) -> bool => false; | |
| 248 | ||
| 249 | visit(tuple: TypeExpressions.TUPLE) is | |
| 250 | si | |
| 251 | ||
| 252 | pre(element: TypeExpressions.NAMED_TUPLE_ELEMENT) -> bool => false; | |
| 253 | ||
| 254 | visit(element: TypeExpressions.NAMED_TUPLE_ELEMENT) is | |
| 255 | si | |
| 256 | ||
| 257 | pre(element: TypeExpressions.UNDEFINED) -> bool => false; | |
| 258 | ||
| 259 | visit(element: TypeExpressions.UNDEFINED) is | |
| 260 | si | |
| 261 | ||
| 262 | pre(constraint: TypeExpressions.TYPE_PARAMETER_CONSTRAINT) -> bool => false; | |
| 263 | ||
| 264 | visit(constraint: TypeExpressions.TYPE_PARAMETER_CONSTRAINT) is | |
| 265 | si | |
| 266 | ||
| 267 | pre(expression: Expressions.Expression) -> bool => false; | |
| 268 | ||
| 269 | visit(expression: Expressions.Expression) is | |
| 270 | si | |
| 271 | ||
| 272 | pre(identifier: Expressions.IDENTIFIER) -> bool => false; | |
| 273 | ||
| 274 | visit(identifier: Expressions.IDENTIFIER) is | |
| 275 | si | |
| 276 | ||
| 277 | pre(literal: Expressions.Literals.Literal) -> bool => false; | |
| 278 | ||
| 279 | visit(literal: Expressions.Literals.Literal) is | |
| 280 | si | |
| 281 | ||
| 282 | pre(`string: Expressions.Literals.STRING) -> bool => false; | |
| 283 | ||
| 284 | visit(`string: Expressions.Literals.STRING) is | |
| 285 | si | |
| 286 | ||
| 287 | pre(interpolation: Expressions.STRING_INTERPOLATION) -> bool => false; | |
| 288 | ||
| 289 | visit(interpolation: Expressions.STRING_INTERPOLATION) is | |
| 290 | si | |
| 291 | ||
| 292 | pre(integer: Expressions.Literals.INTEGER) -> bool => false; | |
| 293 | ||
| 294 | visit(integer: Expressions.Literals.INTEGER) is | |
| 295 | si | |
| 296 | ||
| 297 | pre(float: Expressions.Literals.FLOAT) -> bool => false; | |
| 298 | ||
| 299 | visit(float: Expressions.Literals.FLOAT) is | |
| 300 | si | |
| 301 | ||
| 302 | pre(character: Expressions.Literals.CHARACTER) -> bool => false; | |
| 303 | ||
| 304 | visit(character: Expressions.Literals.CHARACTER) is | |
| 305 | si | |
| 306 | ||
| 307 | pre(boolean: Expressions.Literals.BOOLEAN) -> bool => false; | |
| 308 | ||
| 309 | visit(boolean: Expressions.Literals.BOOLEAN) is | |
| 310 | si | |
| 311 | ||
| 312 | pre(variable: Expressions.VARIABLE) -> bool => false; | |
| 313 | ||
| 314 | visit(variable: Expressions.VARIABLE) is | |
| 315 | si | |
| 316 | ||
| 317 | pre(variable: Expressions.TUPLE_ELEMENT) -> bool => false; | |
| 318 | ||
| 319 | visit(variable: Expressions.TUPLE_ELEMENT) is | |
| 320 | si | |
| 321 | ||
| 322 | pre(none: Expressions.Literals.NONE) -> bool => false; | |
| 323 | ||
| 324 | visit(none: Expressions.Literals.NONE) is | |
| 325 | si | |
| 326 | ||
| 327 | pre(`null: Expressions.NULL) -> bool => false; | |
| 328 | ||
| 329 | visit(`null: Expressions.NULL) is | |
| 330 | si | |
| 331 | ||
| 332 | pre(`self: Expressions.SELF) -> bool => false; | |
| 333 | ||
| 334 | visit(`self: Expressions.SELF) is | |
| 335 | si | |
| 336 | ||
| 337 | pre(`super: Expressions.SUPER) -> bool => false; | |
| 338 | ||
| 339 | visit(`super: Expressions.SUPER) is | |
| 340 | si | |
| 341 | ||
| 342 | pre(`new: Expressions.NEW) -> bool => false; | |
| 343 | ||
| 344 | visit(`new: Expressions.NEW) is | |
| 345 | si | |
| 346 | ||
| 347 | pre(`cast: Expressions.CAST) -> bool => false; | |
| 348 | ||
| 349 | visit(`cast: Expressions.CAST) is | |
| 350 | si | |
| 351 | ||
| 352 | pre(`await: Expressions.AWAIT) -> bool => false; | |
| 353 | ||
| 354 | visit(`await: Expressions.AWAIT) is | |
| 355 | si | |
| 356 | ||
| 357 | pre(spill: Expressions.SPILL) -> bool => false; | |
| 358 | ||
| 359 | visit(spill: Expressions.SPILL) is | |
| 360 | si | |
| 361 | ||
| 362 | pre(`isa: Expressions.ISA) -> bool => false; | |
| 363 | ||
| 364 | visit(`isa: Expressions.ISA) is | |
| 365 | si | |
| 366 | ||
| 367 | pre(`isa: Expressions.TYPEOF) -> bool => false; | |
| 368 | ||
| 369 | visit(`isa: Expressions.TYPEOF) is | |
| 370 | si | |
| 371 | ||
| 372 | pre(`default: Expressions.DEFAULT) -> bool => false; | |
| 373 | ||
| 374 | visit(`default: Expressions.DEFAULT) is | |
| 375 | si | |
| 376 | ||
| 377 | pre(function: Expressions.FUNCTION) -> bool => false; | |
| 378 | ||
| 379 | visit(function: Expressions.FUNCTION) is | |
| 380 | si | |
| 381 | ||
| 382 | pre(recurse: Expressions.RECURSE) -> bool => false; | |
| 383 | ||
| 384 | visit(recurse: Expressions.RECURSE) is | |
| 385 | si | |
| 386 | ||
| 387 | pre(tuple: Expressions.TUPLE) -> bool => false; | |
| 388 | ||
| 389 | visit(tuple: Expressions.TUPLE) is | |
| 390 | si | |
| 391 | ||
| 392 | pre(sequence: Expressions.SEQUENCE) -> bool => false; | |
| 393 | ||
| 394 | visit(sequence: Expressions.SEQUENCE) is | |
| 395 | si | |
| 396 | ||
| 397 | pre(list: Expressions.LIST) -> bool => false; | |
| 398 | ||
| 399 | visit(list: Expressions.LIST) is | |
| 400 | si | |
| 401 | ||
| 402 | pre(call: Expressions.CALL) -> bool => false; | |
| 403 | ||
| 404 | visit(call: Expressions.CALL) is | |
| 405 | si | |
| 406 | ||
| 407 | pre(member: Expressions.MEMBER) -> bool => false; | |
| 408 | ||
| 409 | visit(member: Expressions.MEMBER) is | |
| 410 | si | |
| 411 | ||
| 412 | pre(member: Expressions.EXPLICIT_SPECIALIZATION) -> bool => false; | |
| 413 | ||
| 414 | visit(member: Expressions.EXPLICIT_SPECIALIZATION) is | |
| 415 | si | |
| 416 | ||
| 417 | pre(ambiguous_expression: Expressions.AMBIGUOUS_EXPRESSION) -> bool => false; | |
| 418 | ||
| 419 | visit(ambiguous_expression: Expressions.AMBIGUOUS_EXPRESSION) is | |
| 420 | si | |
| 421 | ||
| 422 | pre(ambiguous_expression: Expressions.GENERIC_APPLICATION) -> bool => false; | |
| 423 | ||
| 424 | visit(ambiguous_expression: Expressions.GENERIC_APPLICATION) is | |
| 425 | si | |
| 426 | ||
| 427 | pre(index: Expressions.INDEX) -> bool => false; | |
| 428 | ||
| 429 | visit(index: Expressions.INDEX) is | |
| 430 | si | |
| 431 | ||
| 432 | pre(has_value: Expressions.HAS_VALUE) -> bool => false; | |
| 433 | ||
| 434 | visit(has_value: Expressions.HAS_VALUE) is | |
| 435 | si | |
| 436 | ||
| 437 | pre(unwrap: Expressions.UNWRAP) -> bool => false; | |
| 438 | ||
| 439 | visit(unwrap: Expressions.UNWRAP) is | |
| 440 | si | |
| 441 | ||
| 442 | pre(reference: Expressions.REFERENCE) -> bool => false; | |
| 443 | ||
| 444 | visit(reference: Expressions.REFERENCE) is | |
| 445 | si | |
| 446 | ||
| 447 | pre(unary: Expressions.UNARY) -> bool => false; | |
| 448 | ||
| 449 | visit(unary: Expressions.UNARY) is | |
| 450 | si | |
| 451 | ||
| 452 | pre(binary: Expressions.BINARY) -> bool => false; | |
| 453 | ||
| 454 | visit(binary: Expressions.BINARY) is | |
| 455 | si | |
| 456 | ||
| 457 | pre(statement: Expressions.STATEMENT) -> bool => false; | |
| 458 | ||
| 459 | visit(statement: Expressions.STATEMENT) is | |
| 460 | si | |
| 461 | ||
| 462 | pre(statement: Expressions.LET_IN) -> bool => false; | |
| 463 | ||
| 464 | visit(statement: Expressions.LET_IN) is | |
| 465 | si | |
| 466 | ||
| 467 | pre(block: Expressions.VAL_BLOCK) -> bool => false; | |
| 468 | ||
| 469 | visit(block: Expressions.VAL_BLOCK) is | |
| 470 | si | |
| 471 | ||
| 472 | pre(assert_in: Expressions.ASSERT_IN) -> bool => false; | |
| 473 | ||
| 474 | visit(assert_in: Expressions.ASSERT_IN) is | |
| 475 | si | |
| 476 | ||
| 477 | pre(statement: Statements.Statement) -> bool => false; | |
| 478 | ||
| 479 | visit(statement: Statements.Statement) is | |
| 480 | si | |
| 481 | ||
| 482 | pre(statements: Statements.LIST) -> bool => false; | |
| 483 | ||
| 484 | visit(statements: Statements.LIST) is | |
| 485 | si | |
| 486 | ||
| 487 | pre(left: Trees.Expressions.SIMPLE_LEFT_EXPRESSION) -> bool => false; | |
| 488 | ||
| 489 | visit(left: Trees.Expressions.SIMPLE_LEFT_EXPRESSION) is | |
| 490 | si | |
| 491 | ||
| 492 | pre(destructure_left: Trees.Expressions.DESTRUCTURING_LEFT_EXPRESSION) -> bool => false; | |
| 493 | ||
| 494 | visit(destructure_left: Trees.Expressions.DESTRUCTURING_LEFT_EXPRESSION) is | |
| 495 | si | |
| 496 | ||
| 497 | pre(l: Statements.LET) -> bool => false; | |
| 498 | ||
| 499 | visit(l: Statements.LET) is | |
| 500 | si | |
| 501 | ||
| 502 | pre(assign: Statements.ASSIGNMENT) -> bool => false; | |
| 503 | ||
| 504 | visit(assign: Statements.ASSIGNMENT) is | |
| 505 | si | |
| 506 | ||
| 507 | pre(expression: Statements.EXPRESSION) -> bool => false; | |
| 508 | ||
| 509 | visit(expression: Statements.EXPRESSION) is | |
| 510 | si | |
| 511 | ||
| 512 | pre(`return: Statements.RETURN) -> bool => false; | |
| 513 | ||
| 514 | visit(`return: Statements.RETURN) is | |
| 515 | si | |
| 516 | ||
| 517 | pre(`throw: Statements.THROW) -> bool => false; | |
| 518 | ||
| 519 | visit(`throw: Statements.THROW) is | |
| 520 | si | |
| 521 | ||
| 522 | pre(`yield: Statements.YIELD) -> bool => false; | |
| 523 | ||
| 524 | visit(`yield: Statements.YIELD) is | |
| 525 | si | |
| 526 | ||
| 527 | pre(assert__: Statements.ASSERT) -> bool => false; | |
| 528 | ||
| 529 | visit(assert__: Statements.ASSERT) is | |
| 530 | si | |
| 531 | ||
| 532 | pre(`if: Statements.IF) -> bool => false; | |
| 533 | ||
| 534 | visit(`if: Statements.IF) is | |
| 535 | si | |
| 536 | ||
| 537 | pre(if_branch: Statements.IF_BRANCH) -> bool => false; | |
| 538 | ||
| 539 | visit(if_branch: Statements.IF_BRANCH) is | |
| 540 | si | |
| 541 | ||
| 542 | pre(rb: Statements.REFUTABLE_BINDING) -> bool => false; | |
| 543 | ||
| 544 | visit(rb: Statements.REFUTABLE_BINDING) is | |
| 545 | si | |
| 546 | ||
| 547 | pre(`case: Statements.CASE) -> bool => false; | |
| 548 | ||
| 549 | visit(`case: Statements.CASE) is | |
| 550 | si | |
| 551 | ||
| 552 | pre(case_match: Statements.CASE_MATCH) -> bool => false; | |
| 553 | ||
| 554 | visit(case_match: Statements.CASE_MATCH) is | |
| 555 | si | |
| 556 | ||
| 557 | pre(`try: Statements.TRY) -> bool => false; | |
| 558 | ||
| 559 | visit(`try: Statements.TRY) is | |
| 560 | si | |
| 561 | ||
| 562 | pre(`catch: Statements.CATCH) -> bool => false; | |
| 563 | ||
| 564 | visit(`catch: Statements.CATCH) is | |
| 565 | si | |
| 566 | ||
| 567 | pre(`do: Statements.DO) -> bool => false; | |
| 568 | ||
| 569 | visit(`do: Statements.DO) is | |
| 570 | si | |
| 571 | ||
| 572 | pre(`for: Statements.FOR) -> bool => false; | |
| 573 | ||
| 574 | visit(`for: Statements.FOR) is | |
| 575 | si | |
| 576 | ||
| 577 | pre(labelled: Statements.LABELLED) -> bool => false; | |
| 578 | ||
| 579 | visit(labelled: Statements.LABELLED) is | |
| 580 | si | |
| 581 | ||
| 582 | pre(`break: Statements.BREAK) -> bool => false; | |
| 583 | ||
| 584 | visit(`break: Statements.BREAK) is | |
| 585 | si | |
| 586 | ||
| 587 | pre(`continue: Statements.CONTINUE) -> bool => false; | |
| 588 | ||
| 589 | visit(`continue: Statements.CONTINUE) is | |
| 590 | si | |
| 591 | ||
| 592 | pre(pragma: Statements.PRAGMA) -> bool => false; | |
| 593 | ||
| 594 | visit(pragma: Statements.PRAGMA) is | |
| 595 | si | |
| 596 | ||
| 597 | pre(expression: Bodies.EXPRESSION) -> bool => false; | |
| 598 | ||
| 599 | visit(expression: Bodies.EXPRESSION) is | |
| 600 | si | |
| 601 | ||
| 602 | pre(block: Bodies.BLOCK) -> bool => false; | |
| 603 | ||
| 604 | visit(block: Bodies.BLOCK) is | |
| 605 | si | |
| 606 | ||
| 607 | pre(block: Bodies.NULL) -> bool => false; | |
| 608 | ||
| 609 | visit(block: Bodies.NULL) is | |
| 610 | si | |
| 611 | ||
| 612 | pre(block: Bodies.INNATE) -> bool => false; | |
| 613 | ||
| 614 | visit(block: Bodies.INNATE) is | |
| 615 | si | |
| 616 | si | |
| 617 | si |