Appearance
| 1 | namespace Syntax.Process is | |
| 2 | use Logging | |
| 3 | use Trees | |
| 4 | ||
| 5 | // A ScopedVisitor that funnels every node kind the concrete | |
| 6 | // visitor does not explicitly override into a single default | |
| 7 | // hook. Deriving from this class inverts the visitor default: | |
| 8 | // where Visitor silently ignores unhandled node kinds, a | |
| 9 | // DefaultVisitor subclass opts each node kind *out* of | |
| 10 | // visit_default by overriding its visit method. Use it for | |
| 11 | // analyses that must make an explicit decision for every node | |
| 12 | // kind — e.g. conservative classifications where an unhandled | |
| 13 | // node has to be assumed to have worst-case behaviour. | |
| 14 | // | |
| 15 | // Scope-carrying nodes call visit_default first, while their | |
| 16 | // scope is still current, and then perform the ScopedVisitor | |
| 17 | // scope-leave. | |
| 18 | // | |
| 19 | // When a new AST node kind gains visit methods on Visitor, add a | |
| 20 | // matching forwarder here — otherwise the new kind inherits | |
| 21 | // Visitor's silent no-op and bypasses subclasses' defaults. | |
| 22 | class DefaultVisitor: ScopedVisitor abstract is | |
| 23 | init( | |
| 24 | logger: Logger, | |
| 25 | symbol_table: Semantic.SYMBOL_TABLE, | |
| 26 | namespaces: Semantic.NAMESPACES | |
| 27 | ) | |
| 28 | is | |
| 29 | super.init(logger, symbol_table, namespaces) | |
| 30 | si | |
| 31 | ||
| 32 | // Called for every node kind the concrete visitor does not | |
| 33 | // explicitly handle. | |
| 34 | visit_default(node: Trees.Node) | |
| 35 | ||
| 36 | visit(node: Node) is visit_default(node); si | |
| 37 | ||
| 38 | visit(identifier: Identifiers.Identifier) is visit_default(identifier); si | |
| 39 | visit(identifier: Identifiers.QUALIFIED) is visit_default(identifier); si | |
| 40 | ||
| 41 | visit(modifier: Modifiers.Modifier) is visit_default(modifier); si | |
| 42 | visit(modifiers: Modifiers.LIST) is visit_default(modifiers); si | |
| 43 | ||
| 44 | visit(pragma: Pragmas.PRAGMA) is visit_default(pragma); si | |
| 45 | ||
| 46 | visit(definition: Definitions.Definition) is visit_default(definition); si | |
| 47 | visit(definitions: Definitions.LIST) is visit_default(definitions); si | |
| 48 | visit(pragma: Definitions.PRAGMA) is visit_default(pragma); si | |
| 49 | ||
| 50 | visit(`namespace: Definitions.NAMESPACE) is | |
| 51 | visit_default(`namespace) | |
| 52 | super.visit(`namespace) | |
| 53 | si | |
| 54 | ||
| 55 | visit(`use: Definitions.USE) is visit_default(`use); si | |
| 56 | visit(super_call: Definitions.SUPER_CALL) is visit_default(super_call); si | |
| 57 | ||
| 58 | visit(`class: Definitions.CLASS) is | |
| 59 | visit_default(`class) | |
| 60 | super.visit(`class) | |
| 61 | si | |
| 62 | ||
| 63 | visit(`trait: Definitions.TRAIT) is | |
| 64 | visit_default(`trait) | |
| 65 | super.visit(`trait) | |
| 66 | si | |
| 67 | ||
| 68 | visit(`struct: Definitions.STRUCT) is | |
| 69 | visit_default(`struct) | |
| 70 | super.visit(`struct) | |
| 71 | si | |
| 72 | ||
| 73 | visit(`partial: Definitions.PARTIAL) is | |
| 74 | visit_default(`partial) | |
| 75 | super.visit(`partial) | |
| 76 | si | |
| 77 | ||
| 78 | visit(`impl: Definitions.IMPL) is | |
| 79 | visit_default(`impl) | |
| 80 | super.visit(`impl) | |
| 81 | si | |
| 82 | ||
| 83 | visit(`union: Definitions.UNION) is | |
| 84 | visit_default(`union) | |
| 85 | super.visit(`union) | |
| 86 | si | |
| 87 | ||
| 88 | visit(variant: Definitions.VARIANT) is | |
| 89 | visit_default(variant) | |
| 90 | super.visit(variant) | |
| 91 | si | |
| 92 | ||
| 93 | visit(`enum: Definitions.ENUM) is | |
| 94 | visit_default(`enum) | |
| 95 | super.visit(`enum) | |
| 96 | si | |
| 97 | ||
| 98 | visit(enum_member: Definitions.ENUM_MEMBER) is visit_default(enum_member); si | |
| 99 | ||
| 100 | visit(function: Definitions.FUNCTION) is | |
| 101 | visit_default(function) | |
| 102 | super.visit(function) | |
| 103 | si | |
| 104 | ||
| 105 | visit(functions: Definitions.FUNCTION_GROUP) is visit_default(functions); si | |
| 106 | visit(property: Definitions.PROPERTY) is visit_default(property); si | |
| 107 | visit(indexer: Definitions.INDEXER) is visit_default(indexer); si | |
| 108 | ||
| 109 | visit(variable: Variables.VARIABLE) is visit_default(variable); si | |
| 110 | visit(variables: Variables.LIST) is visit_default(variables); si | |
| 111 | visit(left: Trees.Variables.SIMPLE_VARIABLE_LEFT) is visit_default(left); si | |
| 112 | visit(destructure_left: Trees.Variables.DESTRUCTURING_VARIABLE_LEFT) is visit_default(destructure_left); si | |
| 113 | visit(left: Trees.Variables.LITERAL_VARIABLE_LEFT) is visit_default(left); si | |
| 114 | ||
| 115 | visit(type_expression: TypeExpressions.TypeExpression) is visit_default(type_expression); si | |
| 116 | visit(type_expression: TypeExpressions.INFER) is visit_default(type_expression); si | |
| 117 | visit(structured: TypeExpressions.Structured) is visit_default(structured); si | |
| 118 | visit(array: TypeExpressions.ARRAY_) is visit_default(array); si | |
| 119 | visit(pointer: TypeExpressions.POINTER) is visit_default(pointer); si | |
| 120 | visit(optional: TypeExpressions.OPTIONAL) is visit_default(optional); si | |
| 121 | visit(reference: TypeExpressions.REFERENCE) is visit_default(reference); si | |
| 122 | visit(member: TypeExpressions.MEMBER) is visit_default(member); si | |
| 123 | visit(named: TypeExpressions.NAMED) is visit_default(named); si | |
| 124 | visit(types: TypeExpressions.LIST) is visit_default(types); si | |
| 125 | visit(generic: TypeExpressions.GENERIC) is visit_default(generic); si | |
| 126 | visit(function: TypeExpressions.FUNCTION) is visit_default(function); si | |
| 127 | visit(functions: TypeExpressions.FUNCTION_GROUP) is visit_default(functions); si | |
| 128 | visit(tuple: TypeExpressions.TUPLE) is visit_default(tuple); si | |
| 129 | visit(element: TypeExpressions.NAMED_TUPLE_ELEMENT) is visit_default(element); si | |
| 130 | visit(element: TypeExpressions.UNDEFINED) is visit_default(element); si | |
| 131 | visit(constraint: TypeExpressions.TYPE_PARAMETER_CONSTRAINT) is visit_default(constraint); si | |
| 132 | ||
| 133 | visit(expression: Expressions.Expression) is visit_default(expression); si | |
| 134 | visit(identifier: Expressions.IDENTIFIER) is visit_default(identifier); si | |
| 135 | visit(literal: Expressions.Literals.Literal) is visit_default(literal); si | |
| 136 | visit(`string: Expressions.Literals.STRING) is visit_default(`string); si | |
| 137 | visit(interpolation: Expressions.STRING_INTERPOLATION) is visit_default(interpolation); si | |
| 138 | visit(integer: Expressions.Literals.INTEGER) is visit_default(integer); si | |
| 139 | visit(float: Expressions.Literals.FLOAT) is visit_default(float); si | |
| 140 | visit(character: Expressions.Literals.CHARACTER) is visit_default(character); si | |
| 141 | visit(boolean: Expressions.Literals.BOOLEAN) is visit_default(boolean); si | |
| 142 | visit(none: Expressions.Literals.NONE) is visit_default(none); si | |
| 143 | visit(variable: Expressions.VARIABLE) is visit_default(variable); si | |
| 144 | visit(variable: Expressions.TUPLE_ELEMENT) is visit_default(variable); si | |
| 145 | visit(`null: Expressions.NULL) is visit_default(`null); si | |
| 146 | visit(`self: Expressions.SELF) is visit_default(`self); si | |
| 147 | visit(`super: Expressions.SUPER) is visit_default(`super); si | |
| 148 | visit(construct: Expressions.CONSTRUCT) is visit_default(construct); si | |
| 149 | visit(`cast: Expressions.CAST) is visit_default(`cast); si | |
| 150 | visit(`await: Expressions.AWAIT) is visit_default(`await); si | |
| 151 | visit(spill: Expressions.SPILL) is visit_default(spill); si | |
| 152 | visit(`isa: Expressions.ISA) is visit_default(`isa); si | |
| 153 | ||
| 154 | visit(field_equals: Expressions.FIELD_EQUALS) is visit_default(field_equals); si | |
| 155 | visit(hash_operand: Expressions.HASH_OPERAND) is visit_default(hash_operand); si | |
| 156 | visit(memberwise_equals: Expressions.MEMBERWISE_EQUALS) is visit_default(memberwise_equals); si | |
| 157 | visit(memberwise_hash: Expressions.MEMBERWISE_HASH) is visit_default(memberwise_hash); si | |
| 158 | visit(`isa: Expressions.TYPEOF) is visit_default(`isa); si | |
| 159 | visit(`default: Expressions.DEFAULT) is visit_default(`default); si | |
| 160 | ||
| 161 | visit(function: Expressions.FUNCTION) is | |
| 162 | visit_default(function) | |
| 163 | super.visit(function) | |
| 164 | si | |
| 165 | ||
| 166 | visit(recurse: Expressions.RECURSE) is visit_default(recurse); si | |
| 167 | visit(tuple: Expressions.TUPLE) is visit_default(tuple); si | |
| 168 | visit(sequence: Expressions.SEQUENCE) is visit_default(sequence); si | |
| 169 | visit(list: Expressions.LIST) is visit_default(list); si | |
| 170 | visit(call: Expressions.CALL) is visit_default(call); si | |
| 171 | visit(member: Expressions.MEMBER) is visit_default(member); si | |
| 172 | visit(ambiguous_expression: Expressions.AMBIGUOUS_EXPRESSION) is visit_default(ambiguous_expression); si | |
| 173 | visit(ambiguous_expression: Expressions.GENERIC_APPLICATION) is visit_default(ambiguous_expression); si | |
| 174 | visit(index: Expressions.INDEX) is visit_default(index); si | |
| 175 | visit(has_value: Expressions.HAS_VALUE) is visit_default(has_value); si | |
| 176 | visit(unwrap: Expressions.UNWRAP) is visit_default(unwrap); si | |
| 177 | visit(reference: Expressions.REFERENCE) is visit_default(reference); si | |
| 178 | visit(unary: Expressions.UNARY) is visit_default(unary); si | |
| 179 | visit(binary: Expressions.BINARY) is visit_default(binary); si | |
| 180 | visit(statement: Expressions.STATEMENT) is visit_default(statement); si | |
| 181 | ||
| 182 | visit(statement: Expressions.LET_IN) is | |
| 183 | visit_default(statement) | |
| 184 | super.visit(statement) | |
| 185 | si | |
| 186 | ||
| 187 | visit(block: Expressions.VAL_BLOCK) is visit_default(block); si | |
| 188 | visit(assert_in: Expressions.ASSERT_IN) is visit_default(assert_in); si | |
| 189 | ||
| 190 | visit(left: Trees.Expressions.SIMPLE_LEFT_EXPRESSION) is visit_default(left); si | |
| 191 | visit(destructure_left: Trees.Expressions.DESTRUCTURING_LEFT_EXPRESSION) is visit_default(destructure_left); si | |
| 192 | ||
| 193 | visit(statement: Statements.Statement) is visit_default(statement); si | |
| 194 | visit(statements: Statements.LIST) is visit_default(statements); si | |
| 195 | visit(f: Statements.FUNCTION) is visit_default(f); si | |
| 196 | visit(l: Statements.LET) is visit_default(l); si | |
| 197 | visit(assign: Statements.ASSIGNMENT) is visit_default(assign); si | |
| 198 | visit(expression: Statements.EXPRESSION) is visit_default(expression); si | |
| 199 | visit(`return: Statements.RETURN) is visit_default(`return); si | |
| 200 | visit(`throw: Statements.THROW) is visit_default(`throw); si | |
| 201 | visit(`yield: Statements.YIELD) is visit_default(`yield); si | |
| 202 | visit(`yield: Statements.YIELD_ALL) is visit_default(`yield); si | |
| 203 | visit(`assert: Statements.ASSERT) is visit_default(`assert); si | |
| 204 | visit(`if: Statements.IF) is visit_default(`if); si | |
| 205 | ||
| 206 | visit(if_branch: Statements.IF_BRANCH) is | |
| 207 | visit_default(if_branch) | |
| 208 | super.visit(if_branch) | |
| 209 | si | |
| 210 | ||
| 211 | visit(rb: Statements.REFUTABLE_BINDING) is visit_default(rb); si | |
| 212 | ||
| 213 | visit(`case: Statements.CASE) is | |
| 214 | visit_default(`case) | |
| 215 | super.visit(`case) | |
| 216 | si | |
| 217 | ||
| 218 | visit(case_match: Statements.CASE_MATCH) is | |
| 219 | visit_default(case_match) | |
| 220 | super.visit(case_match) | |
| 221 | si | |
| 222 | ||
| 223 | visit(`try: Statements.TRY) is | |
| 224 | visit_default(`try) | |
| 225 | super.visit(`try) | |
| 226 | si | |
| 227 | ||
| 228 | visit(`catch: Statements.CATCH) is | |
| 229 | visit_default(`catch) | |
| 230 | super.visit(`catch) | |
| 231 | si | |
| 232 | ||
| 233 | visit(`do: Statements.DO) is | |
| 234 | visit_default(`do) | |
| 235 | super.visit(`do) | |
| 236 | si | |
| 237 | ||
| 238 | visit(`for: Statements.FOR) is | |
| 239 | visit_default(`for) | |
| 240 | super.visit(`for) | |
| 241 | si | |
| 242 | ||
| 243 | visit(labelled: Statements.LABELLED) is | |
| 244 | visit_default(labelled) | |
| 245 | super.visit(labelled) | |
| 246 | si | |
| 247 | ||
| 248 | visit(`break: Statements.BREAK) is visit_default(`break); si | |
| 249 | visit(`continue: Statements.CONTINUE) is visit_default(`continue); si | |
| 250 | visit(pragma: Statements.PRAGMA) is visit_default(pragma); si | |
| 251 | ||
| 252 | visit(expression: Bodies.EXPRESSION) is | |
| 253 | visit_default(expression) | |
| 254 | super.visit(expression) | |
| 255 | si | |
| 256 | ||
| 257 | visit(block: Bodies.BLOCK) is | |
| 258 | visit_default(block) | |
| 259 | super.visit(block) | |
| 260 | si | |
| 261 | ||
| 262 | visit(block: Bodies.NULL) is visit_default(block); si | |
| 263 | visit(block: Bodies.INNATE) is visit_default(block); si | |
| 264 | si | |
| 265 | si |