Appearance
| 1 | namespace IoC is | |
| 2 | use IO.Std | |
| 3 | ||
| 4 | use Syntax | |
| 5 | use Parsers.LAZY_PARSER | |
| 6 | ||
| 7 | class CONTAINER is | |
| 8 | _instance: CONTAINER? static | |
| 9 | ||
| 10 | instance: CONTAINER static is | |
| 11 | let result = _instance ?? CONTAINER() | |
| 12 | ||
| 13 | _instance = result | |
| 14 | ||
| 15 | return result | |
| 16 | si | |
| 17 | ||
| 18 | logger: Logging.Logger | |
| 19 | logger_formatter: Logging.DiagnosticFormatter | |
| 20 | logger_writer: IO.TextWriter | |
| 21 | ||
| 22 | // Read off build_flags.target each time rather than fixed at | |
| 23 | // initialisation: the container is built before the command line is | |
| 24 | // parsed, so a profile fixed then would always be the default | |
| 25 | // target's. | |
| 26 | target_profile: Semantic.TargetProfile => | |
| 27 | Semantic.TARGET_PROFILES.for_target(build_flags.target) | |
| 28 | ||
| 29 | target_capabilities: Semantic.TargetCapabilities => | |
| 30 | target_profile.capabilities | |
| 31 | ||
| 32 | // Stateless, so constructing one per read costs nothing and always | |
| 33 | // carries the current target's capabilities. | |
| 34 | capability_checker: Semantic.CAPABILITY_CHECKER => | |
| 35 | Semantic.CAPABILITY_CHECKER(target_capabilities, logger) | |
| 36 | ||
| 37 | timers: Logging.TIMERS | |
| 38 | @IF.dotnet() | |
| 39 | watchdog: Analysis.WATCHDOG | |
| 40 | ||
| 41 | path_config: Driver.PATH_CONFIG | |
| 42 | build_flags: Compiler.GLOBAL_BUILD_FLAGS | |
| 43 | ||
| 44 | location_stack: Source.LOCATION_STACK | |
| 45 | ||
| 46 | precedence_map: Collections.MutableMap[string,Syntax.Parsers.Expressions.PRECEDENCE] | |
| 47 | pragma_precedence: Syntax.Parsers.Definitions.PRAGMA_PRECEDENCE | |
| 48 | identifier_parser: Syntax.Parsers.Parser[Trees.Identifiers.Identifier] | |
| 49 | identifier_qualified_parser: Syntax.Parsers.Parser[Trees.Identifiers.Identifier] | |
| 50 | identifier_function_name_parser: Syntax.Parsers.Parser[Trees.Identifiers.Identifier] | |
| 51 | modifier_parser: Syntax.Parsers.Parser[Trees.Modifiers.Modifier] | |
| 52 | type_parser: LAZY_PARSER[Trees.TypeExpressions.TypeExpression] | |
| 53 | type_list_parser: LAZY_PARSER[Trees.TypeExpressions.LIST] | |
| 54 | variable_parser: LAZY_PARSER[Trees.Variables.VARIABLE] | |
| 55 | variable_list_parser: LAZY_PARSER[Trees.Variables.LIST] | |
| 56 | variable_destructure_left_parser: LAZY_PARSER[Trees.Variables.DESTRUCTURING_VARIABLE_LEFT] | |
| 57 | modifier_list_parser: LAZY_PARSER[Trees.Modifiers.LIST] | |
| 58 | definition_parser: LAZY_PARSER[Trees.Definitions.Definition] | |
| 59 | definition_global_list_parser: LAZY_PARSER[Trees.Definitions.LIST] | |
| 60 | definition_member_list_parser: LAZY_PARSER[Trees.Definitions.LIST] | |
| 61 | definition_namespace_parser: LAZY_PARSER[Trees.Definitions.NAMESPACE] | |
| 62 | definition_class_parser: LAZY_PARSER[Trees.Definitions.CLASS] | |
| 63 | definition_use_parser: LAZY_PARSER[Trees.Definitions.USE] | |
| 64 | definition_trait_parser: LAZY_PARSER[Trees.Definitions.TRAIT] | |
| 65 | definition_struct_parser: LAZY_PARSER[Trees.Definitions.STRUCT] | |
| 66 | definition_partial_parser: LAZY_PARSER[Trees.Definitions.PARTIAL] | |
| 67 | definition_impl_parser: LAZY_PARSER[Trees.Definitions.IMPL] | |
| 68 | definition_union_parser: LAZY_PARSER[Trees.Definitions.UNION] | |
| 69 | definition_variant_parser: LAZY_PARSER[Trees.Definitions.VARIANT] | |
| 70 | definition_variant_list_parser: LAZY_PARSER[Trees.Definitions.LIST] | |
| 71 | definition_enum_parser: LAZY_PARSER[Trees.Definitions.ENUM] | |
| 72 | definition_member_parser: LAZY_PARSER[Trees.Definitions.Definition] | |
| 73 | definition_function_parser: LAZY_PARSER[Trees.Definitions.FUNCTION] | |
| 74 | definition_property_parser: LAZY_PARSER[Trees.Definitions.PROPERTY] | |
| 75 | definition_indexer_parser: LAZY_PARSER[Trees.Definitions.INDEXER] | |
| 76 | definition_pragma_parser: LAZY_PARSER[Trees.Definitions.PRAGMA] | |
| 77 | definition_super_call_parser: LAZY_PARSER[Trees.Definitions.SUPER_CALL] | |
| 78 | pragma_node_parser: LAZY_PARSER[Trees.Pragmas.PRAGMA] | |
| 79 | expression_parser: LAZY_PARSER[Trees.Expressions.Expression] | |
| 80 | expression_list_parser: LAZY_PARSER[Trees.Expressions.LIST] | |
| 81 | expression_primary_parser: LAZY_PARSER[Trees.Expressions.Expression] | |
| 82 | expression_secondary_parser: LAZY_PARSER[Trees.Expressions.Expression] | |
| 83 | expression_tertiary_parser: LAZY_PARSER[Trees.Expressions.Expression] | |
| 84 | expression_tuple_parser: LAZY_PARSER[Trees.Expressions.Expression] | |
| 85 | statement_parser: LAZY_PARSER[Trees.Statements.Statement] | |
| 86 | statement_list_parser: LAZY_PARSER[Trees.Statements.LIST] | |
| 87 | paren_statement_list_parser: LAZY_PARSER[Trees.Statements.LIST] | |
| 88 | statement_pragma_parser: LAZY_PARSER[Trees.Statements.PRAGMA] | |
| 89 | body_parser: LAZY_PARSER[Trees.Bodies.Body] | |
| 90 | ||
| 91 | @IF.dotnet() | |
| 92 | type_details_lookup: Semantic.DotNet.TYPE_DETAILS_LOOKUP | |
| 93 | ||
| 94 | @IF.dotnet() | |
| 95 | ghul_namespace_creator: Semantic.DotNet.GHUL_NAMESPACE_CREATOR | |
| 96 | @IF.dotnet() | |
| 97 | referenced_assemblies: Semantic.DotNet.REFERENCED_ASSEMBLIES | |
| 98 | @IF.dotnet() | |
| 99 | assembly_info: Semantic.DotNet.ASSEMBLY_INFO | |
| 100 | ||
| 101 | @IF.dotnet() | |
| 102 | dotnet_symbol_table: System.Lazy[Semantic.DotNet.SYMBOL_TABLE] | |
| 103 | @IF.dotnet() | |
| 104 | symbol_factory: Semantic.DotNet.SYMBOL_FACTORY | |
| 105 | @IF.dotnet() | |
| 106 | type_mapper: Semantic.DotNet.TYPE_MAPPER | |
| 107 | @IF.dotnet() | |
| 108 | type_name_map: Semantic.DotNet.TYPE_NAME_MAP | |
| 109 | @IF.dotnet() | |
| 110 | assemblies: Semantic.DotNet.ASSEMBLIES | |
| 111 | ||
| 112 | // Empty, and never added to, outside submission mode. | |
| 113 | complement_singletons: Semantic.Types.COMPLEMENT_SINGLETONS | |
| 114 | ||
| 115 | symbol_table: Semantic.SYMBOL_TABLE | |
| 116 | namespaces: Semantic.NAMESPACES | |
| 117 | symbol_loader: Semantic.SYMBOL_LOADER | |
| 118 | innate_symbol_lookup: Semantic.Lookups.InnateSymbolLookup | |
| 119 | function_caller: Semantic.FUNCTION_CALLER | |
| 120 | overload_resolver: Semantic.OVERLOAD_RESOLVER | |
| 121 | conversion_lookup: Semantic.USER_DEFINED_CONVERSION_LOOKUP | |
| 122 | type_caster: Semantic.TYPE_CASTER | |
| 123 | task_conversion: Semantic.TASK_CONVERSION | |
| 124 | ||
| 125 | symbol_use_locations: Semantic.SYMBOL_USE_LOCATIONS | |
| 126 | symbol_definition_locations: Semantic.SYMBOL_DEFINITION_LOCATIONS | |
| 127 | ||
| 128 | state_store_registry: Syntax.Process.STATE_STORE_REGISTRY | |
| 129 | variable_left_state: Syntax.Process.VARIABLE_LEFT_STATE_STORE | |
| 130 | composite_spill_state: Syntax.Process.COMPOSITE_SPILL_STORE | |
| 131 | ||
| 132 | value_boxer: IR.VALUE_BOXER | |
| 133 | value_converter: IR.VALUE_CONVERTER | |
| 134 | block_stack: IR.BLOCK_STACK | |
| 135 | entry_point: Compiler.ENTRY_POINT | |
| 136 | @IF.dotnet() | |
| 137 | cil_context: IR.Emitter.CIL_CONTEXT | |
| 138 | backend: IR.Backend | |
| 139 | innate_operation_generator: IR.INNATE_OPERATION_GENERATOR | |
| 140 | local_id_generator: IR.LOCAL_ID_GENERATOR | |
| 141 | ||
| 142 | name_display: Semantic.NAME_DISPLAY | |
| 143 | ||
| 144 | type_parameter_positions: Semantic.Symbols.TYPE_PARAMETER_POSITIONS | |
| 145 | ||
| 146 | conditional_compilation: Syntax.Process.CONDITIONAL_COMPILATION | |
| 147 | rewrite_primary_constructors: Syntax.Process.REWRITE_PRIMARY_CONSTRUCTORS | |
| 148 | synthesise_top_level_entry: Syntax.Process.SYNTHESISE_TOP_LEVEL_ENTRY | |
| 149 | synthesise_entry_environment_wrapper: Syntax.Process.SYNTHESISE_ENTRY_ENVIRONMENT_WRAPPER | |
| 150 | expand_namespaces: Syntax.Process.EXPAND_NAMESPACES | |
| 151 | add_accessors_for_properties: Syntax.Process.ADD_ACCESSORS_FOR_PROPERTIES | |
| 152 | spill_awaits: Syntax.Process.SPILL_AWAITS | |
| 153 | collect_suppress_pragmas: Syntax.Process.COLLECT_SUPPRESS_PRAGMAS | |
| 154 | collect_modifier_keyword_locations: Syntax.Process.COLLECT_MODIFIER_KEYWORD_LOCATIONS | |
| 155 | check_name_conventions: Syntax.Process.CHECK_NAME_CONVENTIONS | |
| 156 | definition_virtuality: Syntax.Process.DEFINITION_VIRTUALITY | |
| 157 | select_entry_point: Syntax.Process.SELECT_ENTRY_POINT | |
| 158 | declare_symbols: Syntax.Process.DECLARE_SYMBOLS | |
| 159 | declare_members: Syntax.Process.DECLARE_MEMBERS | |
| 160 | resolve_uses: Syntax.Process.RESOLVE_USES | |
| 161 | resolve_member_uses: Syntax.Process.RESOLVE_USES | |
| 162 | resolve_ancestors: Syntax.Process.RESOLVE_ANCESTORS | |
| 163 | resolve_type_expressions: Syntax.Process.RESOLVE_TYPE_EXPRESSIONS | |
| 164 | resolve_explicit_types: Syntax.Process.RESOLVE_EXPLICIT_TYPES | |
| 165 | synthesize_class_equality: Syntax.Process.SYNTHESIZE_CLASS_EQUALITY | |
| 166 | synthesize_iterator_reset: Syntax.Process.SYNTHESIZE_ITERATOR_RESET | |
| 167 | check_type_argument_bounds: Syntax.Process.CHECK_TYPE_ARGUMENT_BOUNDS | |
| 168 | compile_expressions: Syntax.Process.COMPILE_EXPRESSIONS | |
| 169 | resolve_overrides: Syntax.Process.RESOLVE_OVERRIDES | |
| 170 | infer_store_free: Syntax.Process.INFER_STORE_FREE | |
| 171 | check_pure_overrides: Syntax.Process.CHECK_PURE_OVERRIDES | |
| 172 | verify_compile_state: Syntax.Process.VERIFY_COMPILE_STATE | |
| 173 | register_source_intrinsics: Syntax.Process.REGISTER_SOURCE_INTRINSICS | |
| 174 | record_type_argument_uses: Syntax.Process.RECORD_TYPE_ARGUMENT_USES | |
| 175 | mark_boxed_locals: Syntax.Process.MARK_BOXED_LOCALS | |
| 176 | generate_il: Syntax.Process.GENERATE_IL | |
| 177 | ||
| 178 | ghul_printer: Syntax.Process.Printer.GHUL => Syntax.Process.Printer.GHUL() | |
| 179 | ||
| 180 | @IF.dotnet() | |
| 181 | completer: Syntax.Process.COMPLETER | |
| 182 | signature_help: Syntax.Process.SIGNATURE_HELP | |
| 183 | ||
| 184 | init() is | |
| 185 | Source.LOCATION.init_static() | |
| 186 | ||
| 187 | logger = Logging.DIAGNOSTICS_STORE() | |
| 188 | ||
| 189 | want_human_readable_logger(Std.error) | |
| 190 | ||
| 191 | timers = Logging.TIMERS() | |
| 192 | @IF.dotnet() | |
| 193 | watchdog = Analysis.WATCHDOG() | |
| 194 | ||
| 195 | path_config = Driver.PATH_CONFIG() | |
| 196 | build_flags = Compiler.GLOBAL_BUILD_FLAGS() | |
| 197 | build_flags.set_logger(logger) | |
| 198 | ||
| 199 | location_stack = Source.LOCATION_STACK() | |
| 200 | ||
| 201 | value_boxer = IR.VALUE_BOXER(logger) | |
| 202 | ||
| 203 | entry_point = Compiler.ENTRY_POINT("entry") | |
| 204 | @IF.dotnet() | |
| 205 | cil_context = IR.Emitter.CIL_CONTEXT(logger) | |
| 206 | let backends = Collections.MAP[Compiler.Target, IR.Backend]() | |
| 207 | ||
| 208 | @IF.dotnet() | |
| 209 | backends.add(Compiler.Target.DOTNET, IR.Emitter.CIL_BACKEND(cil_context)) | |
| 210 | ||
| 211 | backends.add(Compiler.Target.WASM, IR.WasmGC.WASMGC_BACKEND()) | |
| 212 | backends.add(Compiler.Target.LLVM, IR.LLVMTarget.LLVM_BACKEND()) | |
| 213 | ||
| 214 | backend = IR.TARGET_BACKEND(build_flags, backends) | |
| 215 | block_stack = IR.BLOCK_STACK() | |
| 216 | innate_operation_generator = IR.INNATE_OPERATION_GENERATOR(logger, value_boxer) | |
| 217 | local_id_generator = IR.LOCAL_ID_GENERATOR() | |
| 218 | ||
| 219 | name_display = Semantic.NAME_DISPLAY() | |
| 220 | ||
| 221 | type_parameter_positions = Semantic.Symbols.TYPE_PARAMETER_POSITIONS() | |
| 222 | ||
| 223 | precedence_map = Collections.MAP[string,Syntax.Parsers.Expressions.PRECEDENCE]() | |
| 224 | ||
| 225 | pragma_precedence = Parsers.Definitions.PRAGMA_PRECEDENCE() | |
| 226 | ||
| 227 | identifier_parser = Parsers.Identifiers.IDENTIFIER() | |
| 228 | identifier_qualified_parser = Parsers.Identifiers.QUALIFIED() | |
| 229 | identifier_function_name_parser = Parsers.Identifiers.FUNCTION_NAME() | |
| 230 | modifier_parser = Parsers.Modifiers.MODIFIER() | |
| 231 | type_parser = LAZY_PARSER() | |
| 232 | type_list_parser = LAZY_PARSER() | |
| 233 | variable_parser = LAZY_PARSER() | |
| 234 | variable_list_parser = LAZY_PARSER() | |
| 235 | variable_destructure_left_parser = LAZY_PARSER() | |
| 236 | modifier_list_parser = LAZY_PARSER() | |
| 237 | definition_parser = LAZY_PARSER() | |
| 238 | definition_global_list_parser = LAZY_PARSER() | |
| 239 | definition_member_list_parser = LAZY_PARSER() | |
| 240 | definition_namespace_parser = LAZY_PARSER() | |
| 241 | definition_use_parser = LAZY_PARSER() | |
| 242 | definition_class_parser = LAZY_PARSER() | |
| 243 | definition_trait_parser = LAZY_PARSER() | |
| 244 | definition_struct_parser = LAZY_PARSER() | |
| 245 | definition_partial_parser = LAZY_PARSER() | |
| 246 | definition_impl_parser = LAZY_PARSER() | |
| 247 | definition_union_parser = LAZY_PARSER() | |
| 248 | definition_variant_parser = LAZY_PARSER() | |
| 249 | definition_variant_list_parser = LAZY_PARSER() | |
| 250 | definition_enum_parser = LAZY_PARSER() | |
| 251 | definition_member_parser = LAZY_PARSER() | |
| 252 | definition_function_parser = LAZY_PARSER() | |
| 253 | definition_property_parser = LAZY_PARSER() | |
| 254 | definition_indexer_parser = LAZY_PARSER() | |
| 255 | definition_pragma_parser = LAZY_PARSER() | |
| 256 | definition_super_call_parser = LAZY_PARSER() | |
| 257 | pragma_node_parser = LAZY_PARSER() | |
| 258 | expression_parser = LAZY_PARSER() | |
| 259 | expression_list_parser = LAZY_PARSER() | |
| 260 | expression_primary_parser = LAZY_PARSER() | |
| 261 | expression_secondary_parser = LAZY_PARSER() | |
| 262 | expression_tertiary_parser = LAZY_PARSER() | |
| 263 | expression_tuple_parser = LAZY_PARSER() | |
| 264 | statement_parser = LAZY_PARSER() | |
| 265 | statement_list_parser = LAZY_PARSER() | |
| 266 | paren_statement_list_parser = LAZY_PARSER() | |
| 267 | statement_pragma_parser = LAZY_PARSER() | |
| 268 | body_parser = LAZY_PARSER() | |
| 269 | ||
| 270 | type_parser.create = () => | |
| 271 | Parsers.TypeExpressions.PRIMARY_TYPE_EXPRESSION(identifier_parser, identifier_qualified_parser, type_list_parser) | |
| 272 | ||
| 273 | type_list_parser.create = () => | |
| 274 | Parsers.TypeExpressions.LIST(type_parser) | |
| 275 | ||
| 276 | variable_parser.create = () => | |
| 277 | Parsers.Variables.VARIABLE( | |
| 278 | identifier_parser, | |
| 279 | variable_destructure_left_parser, | |
| 280 | type_parser, | |
| 281 | expression_parser, | |
| 282 | modifier_list_parser, | |
| 283 | pragma_node_parser) | |
| 284 | ||
| 285 | variable_list_parser.create = () => | |
| 286 | Parsers.Variables.LIST(variable_parser) | |
| 287 | ||
| 288 | variable_destructure_left_parser.create = () => | |
| 289 | Parsers.Variables.DESTRUCTURING_VARIABLE_LEFT(identifier_parser, identifier_qualified_parser, type_parser) | |
| 290 | ||
| 291 | modifier_list_parser.create = () => | |
| 292 | Parsers.Modifiers.LIST(modifier_parser) | |
| 293 | ||
| 294 | definition_parser.create = () => | |
| 295 | Parsers.Definitions.DEFINITION( | |
| 296 | definition_namespace_parser, | |
| 297 | definition_use_parser, | |
| 298 | definition_class_parser, | |
| 299 | definition_trait_parser, | |
| 300 | definition_struct_parser, | |
| 301 | definition_partial_parser, | |
| 302 | definition_impl_parser, | |
| 303 | definition_union_parser, | |
| 304 | definition_enum_parser, | |
| 305 | definition_member_parser, | |
| 306 | definition_pragma_parser | |
| 307 | ) | |
| 308 | ||
| 309 | definition_global_list_parser.create = () => | |
| 310 | Parsers.Definitions.GLOBAL_LIST(pragma_node_parser, definition_parser, statement_parser, precedence_map, pragma_precedence) | |
| 311 | ||
| 312 | definition_member_list_parser.create = () => | |
| 313 | Parsers.Definitions.MEMBER_LIST(definition_member_parser) | |
| 314 | ||
| 315 | definition_namespace_parser.create = () => | |
| 316 | Parsers.Definitions.NAMESPACE(identifier_qualified_parser, definition_global_list_parser) | |
| 317 | ||
| 318 | definition_use_parser.create = () => | |
| 319 | Parsers.Definitions.USE(identifier_qualified_parser, type_parser, type_list_parser) | |
| 320 | ||
| 321 | definition_class_parser.create = () => | |
| 322 | Parsers.Definitions.CLASS( | |
| 323 | identifier_parser, | |
| 324 | type_parser, | |
| 325 | type_list_parser, | |
| 326 | modifier_list_parser, | |
| 327 | variable_list_parser, | |
| 328 | definition_member_list_parser | |
| 329 | ) | |
| 330 | ||
| 331 | definition_trait_parser.create = () => | |
| 332 | Parsers.Definitions.TRAIT( | |
| 333 | identifier_parser, | |
| 334 | type_parser, | |
| 335 | type_list_parser, | |
| 336 | modifier_list_parser, | |
| 337 | definition_member_list_parser | |
| 338 | ) | |
| 339 | ||
| 340 | definition_partial_parser.create = () => | |
| 341 | Parsers.Definitions.PARTIAL( | |
| 342 | identifier_qualified_parser, | |
| 343 | type_list_parser, | |
| 344 | modifier_list_parser, | |
| 345 | definition_member_list_parser | |
| 346 | ) | |
| 347 | ||
| 348 | definition_impl_parser.create = () => | |
| 349 | Parsers.Definitions.IMPL( | |
| 350 | identifier_qualified_parser, | |
| 351 | type_parser, | |
| 352 | type_list_parser, | |
| 353 | modifier_list_parser, | |
| 354 | definition_member_list_parser | |
| 355 | ) | |
| 356 | ||
| 357 | definition_union_parser.create = () => | |
| 358 | Parsers.Definitions.UNION( | |
| 359 | identifier_parser, | |
| 360 | type_parser, | |
| 361 | type_list_parser, | |
| 362 | modifier_list_parser, | |
| 363 | variable_list_parser, | |
| 364 | definition_variant_list_parser | |
| 365 | ) | |
| 366 | ||
| 367 | definition_variant_parser.create = () => | |
| 368 | Parsers.Definitions.VARIANT( | |
| 369 | identifier_parser, | |
| 370 | variable_list_parser, | |
| 371 | modifier_list_parser | |
| 372 | ) | |
| 373 | ||
| 374 | definition_variant_list_parser.create = () => | |
| 375 | Parsers.Definitions.VARIANT_LIST(definition_variant_parser) | |
| 376 | ||
| 377 | definition_struct_parser.create = () => | |
| 378 | Parsers.Definitions.STRUCT( | |
| 379 | identifier_parser, | |
| 380 | type_parser, | |
| 381 | type_list_parser, | |
| 382 | modifier_list_parser, | |
| 383 | variable_list_parser, | |
| 384 | definition_member_list_parser | |
| 385 | ) | |
| 386 | ||
| 387 | definition_enum_parser.create = () => | |
| 388 | Parsers.Definitions.ENUM(identifier_parser, modifier_list_parser, expression_parser) | |
| 389 | ||
| 390 | definition_member_parser.create = () => | |
| 391 | Parsers.Definitions.MEMBER( | |
| 392 | definition_function_parser, | |
| 393 | definition_property_parser, | |
| 394 | definition_indexer_parser, | |
| 395 | definition_pragma_parser, | |
| 396 | definition_super_call_parser | |
| 397 | ) | |
| 398 | ||
| 399 | definition_super_call_parser.create = () => | |
| 400 | Parsers.Definitions.SUPER_CALL(expression_parser) | |
| 401 | ||
| 402 | definition_function_parser.create = () => | |
| 403 | Parsers.Definitions.FUNCTION( | |
| 404 | identifier_function_name_parser, | |
| 405 | type_parser, | |
| 406 | type_list_parser, | |
| 407 | modifier_list_parser, | |
| 408 | body_parser, | |
| 409 | variable_list_parser | |
| 410 | ) | |
| 411 | ||
| 412 | definition_property_parser.create = () => | |
| 413 | Parsers.Definitions.PROPERTY( | |
| 414 | identifier_parser, | |
| 415 | type_parser, | |
| 416 | modifier_list_parser, | |
| 417 | body_parser | |
| 418 | ) | |
| 419 | ||
| 420 | definition_indexer_parser.create = () => | |
| 421 | Parsers.Definitions.INDEXER( | |
| 422 | identifier_parser, | |
| 423 | type_parser, | |
| 424 | modifier_list_parser, | |
| 425 | variable_parser, | |
| 426 | body_parser | |
| 427 | ) | |
| 428 | ||
| 429 | definition_pragma_parser.create = () => | |
| 430 | Parsers.Definitions.PRAGMA(pragma_node_parser, definition_parser, precedence_map, pragma_precedence) | |
| 431 | ||
| 432 | pragma_node_parser.create = () => | |
| 433 | Parsers.Pragmas.PRAGMA(identifier_qualified_parser, expression_parser) | |
| 434 | ||
| 435 | expression_parser.create = () => | |
| 436 | Parsers.Expressions.EXPRESSION(expression_tertiary_parser, expression_secondary_parser, precedence_map) | |
| 437 | ||
| 438 | expression_list_parser.create = () => | |
| 439 | Parsers.Expressions.LIST(expression_parser) | |
| 440 | ||
| 441 | expression_primary_parser.create = () => | |
| 442 | Parsers.Expressions.PRIMARY( | |
| 443 | identifier_parser, | |
| 444 | type_parser, | |
| 445 | expression_parser, | |
| 446 | expression_list_parser, | |
| 447 | expression_tuple_parser, | |
| 448 | statement_parser, | |
| 449 | statement_list_parser, | |
| 450 | variable_list_parser, | |
| 451 | pragma_node_parser, | |
| 452 | variable_parser | |
| 453 | ) | |
| 454 | ||
| 455 | expression_secondary_parser.create = () => | |
| 456 | Parsers.Expressions.SECONDARY( | |
| 457 | identifier_parser, | |
| 458 | type_parser, | |
| 459 | type_list_parser, | |
| 460 | expression_parser, | |
| 461 | expression_primary_parser, | |
| 462 | expression_list_parser, | |
| 463 | body_parser | |
| 464 | ) | |
| 465 | ||
| 466 | expression_tertiary_parser.create = () => | |
| 467 | Parsers.Expressions.TERTIARY( | |
| 468 | expression_secondary_parser | |
| 469 | ) | |
| 470 | ||
| 471 | expression_tuple_parser.create = () => | |
| 472 | Parsers.Expressions.TUPLE( | |
| 473 | expression_list_parser, | |
| 474 | type_parser, | |
| 475 | expression_parser, | |
| 476 | paren_statement_list_parser | |
| 477 | ) | |
| 478 | ||
| 479 | paren_statement_list_parser.create = () => | |
| 480 | Parsers.Statements.LIST( | |
| 481 | Collections.LIST([ | |
| 482 | Lexical.TOKEN.PAREN_CLOSE, | |
| 483 | Lexical.TOKEN.ELSE, | |
| 484 | Lexical.TOKEN.ELIF, | |
| 485 | Lexical.TOKEN.FI, | |
| 486 | Lexical.TOKEN.OD, | |
| 487 | Lexical.TOKEN.CATCH, | |
| 488 | Lexical.TOKEN.FINALLY, | |
| 489 | Lexical.TOKEN.YRT, | |
| 490 | Lexical.TOKEN.WHEN, | |
| 491 | Lexical.TOKEN.ESAC, | |
| 492 | Lexical.TOKEN.LAV, | |
| 493 | Lexical.TOKEN.SI, | |
| 494 | Lexical.TOKEN.COMMA | |
| 495 | ]), | |
| 496 | statement_parser | |
| 497 | ) | |
| 498 | ||
| 499 | statement_parser.create = () => | |
| 500 | Parsers.Statements.STATEMENT( | |
| 501 | Collections.LIST([Lexical.TOKEN.FOR, Lexical.TOKEN.WHILE, Lexical.TOKEN.DO]), | |
| 502 | identifier_parser, | |
| 503 | expression_parser, | |
| 504 | expression_list_parser, | |
| 505 | variable_parser, | |
| 506 | variable_list_parser, | |
| 507 | statement_list_parser, | |
| 508 | statement_pragma_parser | |
| 509 | ) | |
| 510 | ||
| 511 | statement_list_parser.create = () => | |
| 512 | Parsers.Statements.LIST( | |
| 513 | Collections.LIST([ | |
| 514 | Lexical.TOKEN.ELSE, | |
| 515 | Lexical.TOKEN.ELIF, | |
| 516 | Lexical.TOKEN.FI, | |
| 517 | Lexical.TOKEN.OD, | |
| 518 | Lexical.TOKEN.CATCH, | |
| 519 | Lexical.TOKEN.FINALLY, | |
| 520 | Lexical.TOKEN.YRT, | |
| 521 | Lexical.TOKEN.WHEN, | |
| 522 | Lexical.TOKEN.ESAC, | |
| 523 | Lexical.TOKEN.LAV, | |
| 524 | Lexical.TOKEN.SI, | |
| 525 | Lexical.TOKEN.COMMA | |
| 526 | ]), | |
| 527 | statement_parser | |
| 528 | ) | |
| 529 | ||
| 530 | statement_pragma_parser.create = () => | |
| 531 | Parsers.Statements.PRAGMA(pragma_node_parser, statement_parser) | |
| 532 | ||
| 533 | body_parser.create = () => | |
| 534 | Parsers.Bodies.BODY( | |
| 535 | expression_parser, | |
| 536 | statement_parser, | |
| 537 | statement_list_parser, | |
| 538 | identifier_qualified_parser) | |
| 539 | ||
| 540 | @IF.dotnet() | |
| 541 | type_details_lookup = Semantic.DotNet.TYPE_DETAILS_LOOKUP() | |
| 542 | ||
| 543 | symbol_table = Semantic.SYMBOL_TABLE(logger) | |
| 544 | namespaces = Semantic.NAMESPACES(logger, symbol_table) | |
| 545 | ||
| 546 | @IF.dotnet() | |
| 547 | ghul_namespace_creator = Semantic.DotNet.GHUL_NAMESPACE_CREATOR(timers, symbol_table, namespaces, type_details_lookup) | |
| 548 | ||
| 549 | @IF.dotnet() | |
| 550 | dotnet_symbol_table = | |
| 551 | System.Lazy[Semantic.DotNet.SYMBOL_TABLE]( | |
| 552 | () => | |
| 553 | Semantic.DotNet.SYMBOL_TABLE(type_details_lookup, symbol_factory) | |
| 554 | ) | |
| 555 | ||
| 556 | @IF.dotnet() | |
| 557 | type_name_map = Semantic.DotNet.TYPE_NAME_MAP(build_flags, type_details_lookup) | |
| 558 | ||
| 559 | complement_singletons = Semantic.Types.COMPLEMENT_SINGLETONS() | |
| 560 | ||
| 561 | @IF.dotnet() | |
| 562 | assemblies = Semantic.DotNet.ASSEMBLIES( | |
| 563 | timers, | |
| 564 | build_flags, | |
| 565 | path_config, | |
| 566 | symbol_table, | |
| 567 | namespaces, | |
| 568 | type_name_map, | |
| 569 | type_details_lookup | |
| 570 | ) | |
| 571 | ||
| 572 | @IF.dotnet() | |
| 573 | referenced_assemblies = Semantic.DotNet.REFERENCED_ASSEMBLIES(name => assemblies.version_of(name), name => assemblies.public_key_token_of(name)) | |
| 574 | ||
| 575 | innate_symbol_lookup = Semantic.Lookups.LAZY_INNATE_SYMBOL_LOOKUP( | |
| 576 | () => | |
| 577 | if target_profile.has_source_core_library then | |
| 578 | Semantic.Lookups.CONSTRUCTED_INNATE_SYMBOL_LOOKUP( | |
| 579 | symbol_table, | |
| 580 | namespaces, | |
| 581 | Semantic.Lookups.GHUL_INNATE_TYPE_LOOKUP(symbol_table), | |
| 582 | logger) | |
| 583 | else | |
| 584 | _reflection_innate_symbol_lookup() | |
| 585 | fi | |
| 586 | ) | |
| 587 | ||
| 588 | @IF.dotnet() | |
| 589 | type_mapper = Semantic.DotNet.TYPE_MAPPER(dotnet_symbol_table, innate_symbol_lookup, type_name_map, assemblies) | |
| 590 | ||
| 591 | @IF.dotnet() | |
| 592 | symbol_factory = Semantic.DotNet.SYMBOL_FACTORY(namespaces, type_name_map, type_mapper, assemblies, type_details_lookup, logger) | |
| 593 | ||
| 594 | @IF.dotnet() | |
| 595 | assembly_info = Semantic.DotNet.ASSEMBLY_INFO() | |
| 596 | ||
| 597 | value_converter = IR.VALUE_CONVERTER(logger, innate_symbol_lookup) | |
| 598 | ||
| 599 | function_caller = Semantic.FUNCTION_CALLER(symbol_table, value_boxer) | |
| 600 | ||
| 601 | symbol_loader = | |
| 602 | Semantic.SYMBOL_LOADER( | |
| 603 | logger, | |
| 604 | symbol_table, | |
| 605 | function_caller, | |
| 606 | value_boxer, | |
| 607 | innate_symbol_lookup) | |
| 608 | ||
| 609 | function_caller.loader = symbol_loader | |
| 610 | ||
| 611 | overload_resolver = Semantic.OVERLOAD_RESOLVER(logger) | |
| 612 | ||
| 613 | conversion_lookup = Semantic.USER_DEFINED_CONVERSION_LOOKUP() | |
| 614 | ||
| 615 | type_caster = | |
| 616 | Semantic.TYPE_CASTER( | |
| 617 | block_stack, | |
| 618 | value_boxer, | |
| 619 | value_converter, | |
| 620 | innate_symbol_lookup, | |
| 621 | conversion_lookup, | |
| 622 | logger | |
| 623 | ) | |
| 624 | ||
| 625 | task_conversion = Semantic.TASK_CONVERSION(innate_symbol_lookup) | |
| 626 | ||
| 627 | symbol_use_locations = Semantic.SYMBOL_USE_LOCATIONS() | |
| 628 | ||
| 629 | symbol_definition_locations = Semantic.SYMBOL_DEFINITION_LOCATIONS(symbol_use_locations) | |
| 630 | ||
| 631 | state_store_registry = Syntax.Process.STATE_STORE_REGISTRY() | |
| 632 | variable_left_state = Syntax.Process.VARIABLE_LEFT_STATE_STORE(state_store_registry) | |
| 633 | composite_spill_state = Syntax.Process.COMPOSITE_SPILL_STORE(state_store_registry) | |
| 634 | ||
| 635 | conditional_compilation = Syntax.Process.CONDITIONAL_COMPILATION() | |
| 636 | ||
| 637 | rewrite_primary_constructors = Syntax.Process.REWRITE_PRIMARY_CONSTRUCTORS(logger) | |
| 638 | synthesise_top_level_entry = Syntax.Process.SYNTHESISE_TOP_LEVEL_ENTRY(entry_point, logger) | |
| 639 | synthesise_entry_environment_wrapper = Syntax.Process.SYNTHESISE_ENTRY_ENVIRONMENT_WRAPPER(entry_point) | |
| 640 | ||
| 641 | @IF.dotnet() | |
| 642 | expand_namespaces = Syntax.Process.EXPAND_NAMESPACES(System.IO.Abstractions.FileSystem()) | |
| 643 | ||
| 644 | @IF.not.dotnet() | |
| 645 | expand_namespaces = Syntax.Process.EXPAND_NAMESPACES(Syntax.Process.SOURCE_CORE_FILE_SYSTEM()) | |
| 646 | ||
| 647 | add_accessors_for_properties = Syntax.Process.ADD_ACCESSORS_FOR_PROPERTIES() | |
| 648 | ||
| 649 | spill_awaits = Syntax.Process.SPILL_AWAITS() | |
| 650 | ||
| 651 | collect_suppress_pragmas = Syntax.Process.COLLECT_SUPPRESS_PRAGMAS(logger) | |
| 652 | ||
| 653 | collect_modifier_keyword_locations = Syntax.Process.COLLECT_MODIFIER_KEYWORD_LOCATIONS() | |
| 654 | ||
| 655 | check_name_conventions = Syntax.Process.CHECK_NAME_CONVENTIONS(logger, symbol_table, innate_symbol_lookup) | |
| 656 | definition_virtuality = Syntax.Process.DEFINITION_VIRTUALITY(logger, symbol_table) | |
| 657 | select_entry_point = Syntax.Process.SELECT_ENTRY_POINT(logger, symbol_table, entry_point, build_flags) | |
| 658 | ||
| 659 | declare_symbols = | |
| 660 | Syntax.Process.DECLARE_SYMBOLS( | |
| 661 | logger, | |
| 662 | symbol_table, | |
| 663 | namespaces, | |
| 664 | symbol_definition_locations) | |
| 665 | ||
| 666 | declare_members = | |
| 667 | Syntax.Process.DECLARE_MEMBERS( | |
| 668 | logger, | |
| 669 | symbol_table, | |
| 670 | namespaces, | |
| 671 | symbol_definition_locations, | |
| 672 | symbol_use_locations, | |
| 673 | local_id_generator) | |
| 674 | ||
| 675 | resolve_uses = Syntax.Process.RESOLVE_USES(logger, symbol_table, namespaces, symbol_use_locations, false) | |
| 676 | resolve_member_uses = Syntax.Process.RESOLVE_USES(logger, symbol_table, namespaces, symbol_use_locations, true) | |
| 677 | ||
| 678 | resolve_ancestors = | |
| 679 | Syntax.Process.RESOLVE_ANCESTORS(logger, symbol_table, namespaces, innate_symbol_lookup) | |
| 680 | ||
| 681 | resolve_type_expressions = | |
| 682 | Syntax.Process.RESOLVE_TYPE_EXPRESSIONS( | |
| 683 | logger, | |
| 684 | symbol_table, | |
| 685 | namespaces, | |
| 686 | symbol_use_locations, | |
| 687 | innate_symbol_lookup) | |
| 688 | ||
| 689 | resolve_explicit_types = | |
| 690 | Syntax.Process.RESOLVE_EXPLICIT_TYPES( | |
| 691 | logger, | |
| 692 | symbol_table, | |
| 693 | namespaces, | |
| 694 | innate_symbol_lookup | |
| 695 | ) | |
| 696 | ||
| 697 | synthesize_class_equality = | |
| 698 | Syntax.Process.SYNTHESIZE_CLASS_EQUALITY(logger, symbol_table, innate_symbol_lookup) | |
| 699 | ||
| 700 | synthesize_iterator_reset = | |
| 701 | Syntax.Process.SYNTHESIZE_ITERATOR_RESET(symbol_table, innate_symbol_lookup) | |
| 702 | ||
| 703 | check_type_argument_bounds = | |
| 704 | Syntax.Process.CHECK_TYPE_ARGUMENT_BOUNDS( | |
| 705 | logger, | |
| 706 | symbol_table, | |
| 707 | namespaces | |
| 708 | ) | |
| 709 | ||
| 710 | compile_expressions = | |
| 711 | Syntax.Process.COMPILE_EXPRESSIONS( | |
| 712 | logger, | |
| 713 | symbol_table, | |
| 714 | namespaces, | |
| 715 | symbol_loader, | |
| 716 | innate_symbol_lookup, | |
| 717 | function_caller, | |
| 718 | type_caster, | |
| 719 | task_conversion, | |
| 720 | overload_resolver, | |
| 721 | symbol_use_locations, | |
| 722 | value_converter, | |
| 723 | value_boxer, | |
| 724 | build_flags, | |
| 725 | variable_left_state, | |
| 726 | composite_spill_state | |
| 727 | ) | |
| 728 | ||
| 729 | resolve_overrides = | |
| 730 | Syntax.Process.RESOLVE_OVERRIDES( | |
| 731 | logger, | |
| 732 | symbol_table, | |
| 733 | namespaces | |
| 734 | ) | |
| 735 | ||
| 736 | infer_store_free = | |
| 737 | Syntax.Process.INFER_STORE_FREE( | |
| 738 | logger, | |
| 739 | symbol_table, | |
| 740 | namespaces, | |
| 741 | innate_symbol_lookup | |
| 742 | ) | |
| 743 | ||
| 744 | check_pure_overrides = | |
| 745 | Syntax.Process.CHECK_PURE_OVERRIDES( | |
| 746 | logger, | |
| 747 | symbol_table, | |
| 748 | namespaces | |
| 749 | ) | |
| 750 | ||
| 751 | verify_compile_state = | |
| 752 | Syntax.Process.VERIFY_COMPILE_STATE( | |
| 753 | logger, | |
| 754 | symbol_table, | |
| 755 | namespaces | |
| 756 | ) | |
| 757 | ||
| 758 | register_source_intrinsics = | |
| 759 | Syntax.Process.REGISTER_SOURCE_INTRINSICS( | |
| 760 | logger, | |
| 761 | symbol_table, | |
| 762 | namespaces, | |
| 763 | innate_symbol_lookup | |
| 764 | ) | |
| 765 | ||
| 766 | record_type_argument_uses = | |
| 767 | Syntax.Process.RECORD_TYPE_ARGUMENT_USES( | |
| 768 | logger, | |
| 769 | symbol_table, | |
| 770 | namespaces, | |
| 771 | innate_symbol_lookup | |
| 772 | ) | |
| 773 | ||
| 774 | mark_boxed_locals = | |
| 775 | Syntax.Process.MARK_BOXED_LOCALS( | |
| 776 | logger, | |
| 777 | symbol_table, | |
| 778 | namespaces | |
| 779 | ) | |
| 780 | ||
| 781 | generate_il = | |
| 782 | Syntax.Process.GENERATE_IL( | |
| 783 | logger, | |
| 784 | symbol_table, | |
| 785 | namespaces, | |
| 786 | symbol_loader, | |
| 787 | innate_symbol_lookup, | |
| 788 | function_caller, | |
| 789 | type_caster, | |
| 790 | overload_resolver, | |
| 791 | symbol_use_locations, | |
| 792 | backend, | |
| 793 | block_stack, | |
| 794 | value_boxer, | |
| 795 | build_flags, | |
| 796 | composite_spill_state, | |
| 797 | variable_left_state | |
| 798 | ) | |
| 799 | ||
| 800 | @IF.dotnet() | |
| 801 | completer = | |
| 802 | Syntax.Process.COMPLETER( | |
| 803 | logger, | |
| 804 | symbol_table, | |
| 805 | namespaces, | |
| 806 | dotnet_symbol_table | |
| 807 | ) | |
| 808 | ||
| 809 | signature_help = | |
| 810 | Syntax.Process.SIGNATURE_HELP( | |
| 811 | logger, | |
| 812 | symbol_table, | |
| 813 | namespaces, | |
| 814 | overload_resolver | |
| 815 | ) | |
| 816 | si | |
| 817 | ||
| 818 | want_tab_delimited_logger(writer: IO.TextWriter) is | |
| 819 | logger_writer = writer | |
| 820 | ||
| 821 | logger_formatter = Logging.TAB_DELIMITED_DIAGNOSTIC_FORMATTER() | |
| 822 | si | |
| 823 | ||
| 824 | // A test run captures diagnostics as a snapshot, so it sees | |
| 825 | // exactly what the passes reported: a pass that reports the | |
| 826 | // same thing four times shows as four lines rather than one. | |
| 827 | want_duplicate_diagnostics() is | |
| 828 | if let store: Logging.DIAGNOSTICS_STORE = logger then | |
| 829 | store.keep_duplicate_diagnostics() | |
| 830 | fi | |
| 831 | si | |
| 832 | ||
| 833 | want_human_readable_logger(writer: IO.TextWriter) is | |
| 834 | logger_writer = writer | |
| 835 | ||
| 836 | logger_formatter = Logging.HUMAN_READABLE_DIAGNOSTIC_FORMATTER() | |
| 837 | si | |
| 838 | ||
| 839 | want_msbuild_logger(writer: IO.TextWriter) is | |
| 840 | logger_writer = writer | |
| 841 | ||
| 842 | logger_formatter = Logging.MSBUILD_DIAGNOSTIC_FORMATTER() | |
| 843 | si | |
| 844 | ||
| 845 | // The innate symbols read from the referenced .NET assemblies, for a | |
| 846 | // target whose core library is not compiled from source. | |
| 847 | @IF.dotnet() | |
| 848 | _reflection_innate_symbol_lookup() -> Semantic.Lookups.InnateSymbolLookup => | |
| 849 | Semantic.Lookups.REFLECTION_INNATE_SYMBOL_LOOKUP( | |
| 850 | type_mapper, | |
| 851 | dotnet_symbol_table.value, | |
| 852 | Semantic.Lookups.GHUL_INNATE_TYPE_LOOKUP(symbol_table), | |
| 853 | assemblies | |
| 854 | ) | |
| 855 | ||
| 856 | @IF.not.dotnet() | |
| 857 | _reflection_innate_symbol_lookup() -> Semantic.Lookups.InnateSymbolLookup => | |
| 858 | throw Ghul.NotSupportedException("the dotnet target is not available in this build of the compiler") | |
| 859 | si | |
| 860 | si |