Skip to content
← Back

src/ioc/container.ghul

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