/
FrontendOptions.td
1391 lines (1062 loc) · 64 KB
/
FrontendOptions.td
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//===--- FrontendOptions.td - Options for swift -frontend -----------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines the options accepted by swift -frontend.
//
//===----------------------------------------------------------------------===//
let Flags = [FrontendOption, NoDriverOption, ArgumentIsFileList] in {
def filelist : Separate<["-"], "filelist">,
HelpText<"Specify source inputs in a file rather than on the command line">;
def primary_filelist : Separate<["-"], "primary-filelist">,
HelpText<"Specify primary inputs in a file rather than on the command line">;
} // end let Flags = [FrontendOption, NoDriverOption, ArgumentIsFileList]
let Flags = [FrontendOption, NoDriverOption, CacheInvariant] in {
def output_filelist : Separate<["-"], "output-filelist">,
HelpText<"Specify outputs in a file rather than on the command line">;
def supplementary_output_file_map : Separate<["-"], "supplementary-output-file-map">,
HelpText<"Specify supplementary outputs in a file rather than on the command line">;
def index_unit_output_path_filelist : Separate<["-"], "index-unit-output-path-filelist">,
HelpText<"Specify index unit output paths in a file rather than on the command line">;
def emit_module_doc_path
: Separate<["-"], "emit-module-doc-path">, MetaVarName<"<path>">,
HelpText<"Output module documentation file <path>">;
def emit_dependencies_path
: Separate<["-"], "emit-dependencies-path">, MetaVarName<"<path>">,
HelpText<"Output basic Make-compatible dependencies file to <path>">;
def emit_reference_dependencies_path
: Separate<["-"], "emit-reference-dependencies-path">, MetaVarName<"<path>">,
HelpText<"Output Swift-style dependencies file to <path>">;
def emit_fixits_path
: Separate<["-"], "emit-fixits-path">, MetaVarName<"<path>">,
HelpText<"Output compiler fixits as source edits to <path>">;
def emit_abi_descriptor_path
: Separate<["-"], "emit-abi-descriptor-path">, MetaVarName<"<path>">,
HelpText<"Output the ABI descriptor of current module to <path>">;
def emit_module_semantic_info_path
: Separate<["-"], "emit-module-semantic-info-path">, MetaVarName<"<path>">,
HelpText<"Output semantic info of current module to <path>">;
def diagnostic_documentation_path
: Separate<["-"], "diagnostic-documentation-path">, MetaVarName<"<path>">,
HelpText<"Path to diagnostic documentation resources">;
def dump_api_path : Separate<["-"], "dump-api-path">,
HelpText<"The path to output swift interface files for the compiled source files">;
def group_info_path : Separate<["-"], "group-info-path">,
HelpText<"The path to collect the group information of the compiled module">;
def prebuilt_module_cache_path :
Separate<["-"], "prebuilt-module-cache-path">,
HelpText<"Directory of prebuilt modules for loading module interfaces">;
def prebuilt_module_cache_path_EQ :
Joined<["-"], "prebuilt-module-cache-path=">,
Alias<prebuilt_module_cache_path>;
def backup_module_interface_path :
Separate<["-"], "backup-module-interface-path">,
HelpText<"Directory of module interfaces as backups to those from SDKs">;
def backup_module_interface_path_EQ :
Joined<["-"], "backup-module-interface-path=">,
Alias<backup_module_interface_path>;
def frontend_parseable_output : Flag<["-"], "frontend-parseable-output">,
HelpText<"Emit textual output in a parseable format">;
} // end let Flags = [FrontendOption, NoDriverOption, CacheInvariant]
def primary_file : Separate<["-"], "primary-file">,
Flags<[FrontendOption, NoDriverOption, ArgumentIsPath]>,
HelpText<"Produce output for this file, not the whole module">;
let Flags = [FrontendOption, NoDriverOption] in {
def triple : Separate<["-"], "triple">, Alias<target>;
def emit_module_doc : Flag<["-"], "emit-module-doc">,
HelpText<"Emit a module documentation file based on documentation "
"comments">;
def emit_module_source_info : Flag<["-"], "emit-module-source-info">,
HelpText<"Output module source info file">;
def ignore_module_source_info : Flag<["-"], "ignore-module-source-info">,
HelpText<"Avoid getting source location from .swiftsourceinfo files">;
def merge_modules
: Flag<["-"], "merge-modules">, ModeOpt,
HelpText<"Merge the input modules without otherwise processing them">;
def emit_reference_dependencies : Flag<["-"], "emit-reference-dependencies">,
HelpText<"Emit a Swift-style dependencies file">;
def serialize_module_interface_dependency_hashes
: Flag<["-"], "serialize-module-interface-dependency-hashes">,
Flags<[HelpHidden]>;
def serialize_parseable_module_interface_dependency_hashes
: Flag<["-"], "serialize-parseable-module-interface-dependency-hashes">,
Alias<serialize_module_interface_dependency_hashes>,
Flags<[HelpHidden]>;
def tbd_install_name
: Separate<["-"], "tbd-install_name">, MetaVarName<"<path>">,
HelpText<"The install_name to use in an emitted TBD file">;
def tbd_install_name_EQ : Joined<["-"], "tbd-install_name=">,
Alias<tbd_install_name>;
def tbd_current_version
: Separate<["-"], "tbd-current-version">, MetaVarName<"<version>">,
HelpText<"The current_version to use in an emitted TBD file">;
def tbd_current_version_EQ : Joined<["-"], "tbd-current-version=">,
Alias<tbd_current_version>;
def tbd_compatibility_version
: Separate<["-"], "tbd-compatibility-version">, MetaVarName<"<version>">,
HelpText<"The compatibility_version to use in an emitted TBD file">;
def tbd_compatibility_version_EQ : Joined<["-"], "tbd-compatibility-version=">,
Alias<tbd_compatibility_version>;
def tbd_is_installapi: Flag<["-"], "tbd-is-installapi">,
HelpText<"If the TBD file should indicate it's being generated during "
"InstallAPI">;
def verify : Flag<["-"], "verify">,
HelpText<"Verify diagnostics against expected-{error|warning|note} "
"annotations">;
def verify_additional_file : Separate<["-"], "verify-additional-file">,
HelpText<"Verify diagnostics in this file in addition to source files">;
def verify_additional_prefix : Separate<["-"], "verify-additional-prefix">,
HelpText<"Check for diagnostics with the prefix expected-<PREFIX> as well as expected-">;
def verify_apply_fixes : Flag<["-"], "verify-apply-fixes">,
HelpText<"Like -verify, but updates the original source file">;
def verify_ignore_unknown: Flag<["-"], "verify-ignore-unknown">,
HelpText<"Allow diagnostics for '<unknown>' location in verify mode">;
def verify_generic_signatures : Separate<["-"], "verify-generic-signatures">,
MetaVarName<"<module-name>">,
HelpText<"Verify the generic signatures in the given module">;
def show_diagnostics_after_fatal : Flag<["-"], "show-diagnostics-after-fatal">,
HelpText<"Keep emitting subsequent diagnostics after a fatal error">;
def enable_cross_import_overlays : Flag<["-"], "enable-cross-import-overlays">,
HelpText<"Automatically import declared cross-import overlays.">;
def disable_cross_import_overlays : Flag<["-"], "disable-cross-import-overlays">,
HelpText<"Do not automatically import declared cross-import overlays.">;
def enable_testable_attr_requires_testable_module :
Flag<["-"], "enable-testable-attr-requires-testable-module">,
HelpText<"Enable checking of @testable">;
def disable_testable_attr_requires_testable_module :
Flag<["-"], "disable-testable-attr-requires-testable-module">,
HelpText<"Disable checking of @testable">;
def disable_clang_spi :
Flag<["-"], "disable-clang-spi">,
HelpText<"Don't import Clang SPIs as Swift SPIs">;
def enable_target_os_checking :
Flag<["-"], "enable-target-os-checking">,
HelpText<"Enable checking the target OS of serialized modules">;
def disable_target_os_checking :
Flag<["-"], "disable-target-os-checking">,
HelpText<"Disable checking the target OS of serialized modules">;
def crosscheck_unqualified_lookup : Flag<["-"], "crosscheck-unqualified-lookup">,
HelpText<"Compare legacy DeclContext- to ASTScope-based unqualified name lookup (for debugging)">;
def use_clang_function_types : Flag<["-"], "use-clang-function-types">,
HelpText<"Use stored Clang function types for computing canonical types.">;
def print_clang_stats : Flag<["-"], "print-clang-stats">,
HelpText<"Print Clang importer statistics">;
def serialize_debugging_options : Flag<["-"], "serialize-debugging-options">,
HelpText<"Always serialize options for debugging (default: only for apps)">;
def serialized_path_obfuscate : Separate<["-"], "serialized-path-obfuscate">,
HelpText<"Remap source paths in debug info">, MetaVarName<"<prefix=replacement>">;
def empty_abi_descriptor : Flag<["-"], "empty-abi-descriptor">,
HelpText<"Avoid printing actual module content into ABI descriptor file">;
def no_serialize_debugging_options :
Flag<["-"], "no-serialize-debugging-options">,
HelpText<"Never serialize options for debugging (default: only for apps)">;
def autolink_library : Separate<["-"], "autolink-library">,
HelpText<"Add dependent library">, Flags<[FrontendOption]>;
def public_autolink_library : Separate<["-"], "public-autolink-library">,
HelpText<"Add public dependent library">, Flags<[FrontendOption]>;
def disable_typo_correction : Flag<["-"], "disable-typo-correction">,
HelpText<"Disable typo correction">;
def disable_implicit_swift_modules: Flag<["-"], "disable-implicit-swift-modules">,
HelpText<"Disable building Swift modules implicitly by the compiler">;
def swift_module_file: Joined<["-"], "swift-module-file=">,
MetaVarName<"<name>=<path>">,
HelpText<"Specify Swift module input explicitly built from textual interface">;
def swift_module_cross_import: MultiArg<["-"], "swift-module-cross-import", 2>,
MetaVarName<"<moduleName> <crossImport.swiftoverlay>">,
HelpText<"Specify the cross import module">;
def disable_cross_import_overlay_search: Flag<["-"], "disable-cross-import-overlay-search">,
HelpText<"Disable searching for cross import overlay file">;
def explicit_swift_module_map
: Separate<["-"], "explicit-swift-module-map-file">, MetaVarName<"<path>">,
HelpText<"Specify a JSON file containing information of explicit Swift modules">;
def const_gather_protocols_file
: Separate<["-"], "const-gather-protocols-file">, MetaVarName<"<path>">,
HelpText<"Specify a list of protocols for extraction of conformances' const values'">;
def placeholder_dependency_module_map
: Separate<["-"], "placeholder-dependency-module-map-file">, MetaVarName<"<path>">,
HelpText<"Specify a JSON file containing information of external Swift module dependencies">;
def batch_scan_input_file
: Separate<["-"], "batch-scan-input-file">, MetaVarName<"<path>">,
HelpText<"Specify a JSON file containing modules to perform batch dependencies scanning">;
def import_prescan : Flag<["-"], "import-prescan">,
HelpText<"When performing a dependency scan, only identify all imports of the main Swift module sources">;
def serialize_dependency_scan_cache : Flag<["-"], "serialize-dependency-scan-cache">,
HelpText<"After performing a dependency scan, serialize the scanner's internal state.">;
def reuse_dependency_scan_cache : Flag<["-"], "load-dependency-scan-cache">,
HelpText<"After performing a dependency scan, serialize the scanner's internal state.">;
def dependency_scan_cache_path : Separate<["-"], "dependency-scan-cache-path">,
HelpText<"The path to output the dependency scanner's internal state.">;
def dependency_scan_cache_remarks : Flag<["-"], "Rdependency-scan-cache">,
HelpText<"Emit remarks indicating use of the serialized module dependency scanning cache.">;
def parallel_scan : Flag<["-"], "parallel-scan">,
HelpText<"Perform dependency scanning in-parallel.">;
def enable_copy_propagation : Flag<["-"], "enable-copy-propagation">,
HelpText<"Run SIL copy propagation with lexical lifetimes to shorten object "
"lifetimes while preserving variable lifetimes.">;
def copy_propagation_state_EQ :
Joined<["-"], "enable-copy-propagation=">,
HelpText<"Whether to enable copy propagation">,
MetaVarName<"true|requested-passes-only|false">;
def enable_infer_public_concurrent_value : Flag<["-"], "enable-infer-public-sendable">,
HelpText<"Enable inference of Sendable conformances for public structs and enums">;
def disable_infer_public_concurrent_value : Flag<["-"], "disable-infer-public-sendable">,
HelpText<"Disable inference of Sendable conformances for public structs and enums">;
def Raccess_note : Separate<["-"], "Raccess-note">,
MetaVarName<"none|failures|all|all-validate">,
HelpText<"Control access note remarks (default: all)">;
def Raccess_note_EQ : Joined<["-"], "Raccess-note=">,
Alias<Raccess_note>;
def block_list_file
: Separate<["-"], "blocklist-file">, MetaVarName<"<path>">,
HelpText<"The path to a blocklist configuration file">;
} // end let Flags = [FrontendOption, NoDriverOption]
def debug_crash_Group : OptionGroup<"<automatic crashing options>">;
class DebugCrashOpt : Group<debug_crash_Group>;
let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable] in {
def enable_lexical_lifetimes :
Joined<["-"], "enable-lexical-lifetimes=">,
HelpText<"Whether to enable lexical lifetimes">,
MetaVarName<"true|false">;
def enable_lexical_lifetimes_noArg :
Flag<["-"], "enable-lexical-lifetimes">,
HelpText<"Enable lexical lifetimes">;
def enable_destroy_hoisting :
Joined<["-"], "enable-destroy-hoisting=">,
HelpText<"Whether to enable destroy hoisting">,
MetaVarName<"true|false">;
}
// Flags that are saved into module interfaces
let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOption] in {
def enable_objc_interop :
Flag<["-"], "enable-objc-interop">,
HelpText<"Enable Objective-C interop code generation and config directives">;
def disable_objc_interop :
Flag<["-"], "disable-objc-interop">,
HelpText<"Disable Objective-C interop code generation and config directives">;
def enable_experimental_opaque_type_erasure :
Flag<["-"], "enable-experimental-opaque-type-erasure">,
HelpText<"Type-erases opaque types that conform to @_typeEraser protocols">;
def enable_objc_attr_requires_foundation_module :
Flag<["-"], "enable-objc-attr-requires-foundation-module">,
HelpText<"Enable requiring uses of @objc to require importing the "
"Foundation module">;
def disable_objc_attr_requires_foundation_module :
Flag<["-"], "disable-objc-attr-requires-foundation-module">,
HelpText<"Disable requiring uses of @objc to require importing the "
"Foundation module">;
def enable_experimental_concurrency :
Flag<["-"], "enable-experimental-concurrency">,
HelpText<"Enable experimental concurrency model">;
def enable_experimental_move_only :
Flag<["-"], "enable-experimental-move-only">,
HelpText<"Enable experimental move only">;
def enable_experimental_distributed :
Flag<["-"], "enable-experimental-distributed">,
HelpText<"Enable experimental 'distributed' actors and functions">;
def enable_experimental_flow_sensitive_concurrent_captures :
Flag<["-"], "enable-experimental-flow-sensitive-concurrent-captures">,
HelpText<"Enable flow-sensitive concurrent captures">;
def disable_experimental_clang_importer_diagnostics :
Flag<["-"], "disable-experimental-clang-importer-diagnostics">,
HelpText<"Disable experimental diagnostics when importing C, C++, and Objective-C libraries">;
def enable_experimental_eager_clang_module_diagnostics :
Flag<["-"], "enable-experimental-eager-clang-module-diagnostics">,
HelpText<"Enable experimental eager diagnostics reporting on the importability of all referenced C, C++, and Objective-C libraries">;
def enable_experimental_pairwise_build_block :
Flag<["-"], "enable-experimental-pairwise-build-block">,
HelpText<"Enable experimental pairwise 'buildBlock' for result builders">;
def enable_resilience : Flag<["-"], "enable-resilience">,
HelpText<"Deprecated, use -enable-library-evolution instead">;
def enable_experimental_async_top_level :
Flag<["-"], "enable-experimental-async-top-level">,
HelpText<"Enable experimental concurrency in top-level code">;
}
// HIDDEN FLAGS
let Flags = [FrontendOption, NoDriverOption, HelpHidden] in {
def enable_experimental_swift_based_closure_specialization :
Flag<["-"], "experimental-swift-based-closure-specialization">,
HelpText<"Use the experimental Swift based closure-specialization optimization pass instead of the existing C++ one">;
def checked_async_objc_bridging : Joined<["-"], "checked-async-objc-bridging=">,
HelpText<"Control whether checked continuations are used when bridging "
"async calls from Swift to ObjC: 'on', 'off' ">;
def debug_constraints : Flag<["-"], "debug-constraints">,
HelpText<"Debug the constraint-based type checker">;
def debug_constraints_attempt : Separate<["-"], "debug-constraints-attempt">,
HelpText<"Debug the constraint solver at a given attempt">;
def debug_constraints_on_line : Separate<["-"], "debug-constraints-on-line">,
HelpText<"Debug the constraint solver for expressions on <line>">,
MetaVarName<"<line>">;
def debug_constraints_on_line_EQ : Joined<["-"], "debug-constraints-on-line=">,
Alias<debug_constraints_on_line>;
def disable_named_lazy_member_loading : Flag<["-"], "disable-named-lazy-member-loading">,
HelpText<"Disable per-name lazy member loading (obsolete)">;
def disable_named_lazy_import_as_member_loading :
Flag<["-"], "disable-named-lazy-import-as-member-loading">,
HelpText<"Import all of a type's import-as-member globals together, as Swift "
"5.10 and earlier did; temporary workaround for modules that are "
"sensitive to this change">;
def dump_requirement_machine : Flag<["-"], "dump-requirement-machine">,
HelpText<"Enables dumping rewrite systems from the generics implementation">;
def debug_requirement_machine : Joined<["-"], "debug-requirement-machine=">,
HelpText<"Fine-grained debug output from the generics implementation">;
def dump_macro_expansions : Flag<["-"], "dump-macro-expansions">,
HelpText<"Dumps the results of each macro expansion">;
def emit_macro_expansion_files : Separate<["-"], "emit-macro-expansion-files">,
HelpText<"Specify when to emit macro expansion file: 'none', 'debug', or 'diagnostics'">;
def analyze_requirement_machine : Flag<["-"], "analyze-requirement-machine">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Print out requirement machine statistics at the end of the compilation job">;
def requirement_machine_max_rule_count : Joined<["-"], "requirement-machine-max-rule-count=">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Set the maximum number of rules before giving up">;
def requirement_machine_max_rule_length : Joined<["-"], "requirement-machine-max-rule-length=">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Set the maximum rule length before giving up">;
def requirement_machine_max_concrete_nesting : Joined<["-"], "requirement-machine-max-concrete-nesting=">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Set the maximum concrete type nesting depth before giving up">;
def requirement_machine_max_split_concrete_equiv_class_attempts : Joined<["-"], "requirement-machine-max-split-concrete-equiv-class-attempts=">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Set the maximum concrete number of attempts at splitting "
"concrete equivalence classes before giving up. There should "
"never be a reason to change this">;
def disable_requirement_machine_concrete_contraction : Flag<["-"], "disable-requirement-machine-concrete-contraction">,
HelpText<"Disable preprocessing pass to eliminate conformance requirements "
"on generic parameters which are made concrete">;
def disable_requirement_machine_loop_normalization : Flag<["-"], "disable-requirement-machine-loop-normalization">,
HelpText<"Disable stronger minimization algorithm, for debugging only">;
def disable_requirement_machine_reuse : Flag<["-"], "disable-requirement-machine-reuse">,
HelpText<"Disable re-use of requirement machines for minimization, for debugging only">;
def enable_requirement_machine_opaque_archetypes : Flag<["-"], "enable-requirement-machine-opaque-archetypes">,
HelpText<"Enable more correct opaque archetype support, which is off by default because it might fail to produce a convergent rewrite system">;
def dump_type_witness_systems : Flag<["-"], "dump-type-witness-systems">,
HelpText<"Enables dumping type witness systems from associated type inference">;
def enable_round_trip_debug_types : Flag<["-"], "enable-round-trip-debug-types">,
HelpText<"Enables verification of debug info mangling">;
def disable_round_trip_debug_types : Flag<["-"], "disable-round-trip-debug-types">,
HelpText<"Disables verification of debug info mangling">;
def debug_generic_signatures : Flag<["-"], "debug-generic-signatures">,
HelpText<"Debug generic signatures">;
def debug_inverse_requirements : Flag<["-"], "debug-inverse-requirements">,
HelpText<"Print real requirements in -debug_generic_signatures output">;
def debug_forbid_typecheck_prefix : Separate<["-"], "debug-forbid-typecheck-prefix">,
HelpText<"Triggers llvm fatal_error if typechecker tries to typecheck a decl "
"with the provided prefix name">;
def experimental_lazy_typecheck : Flag<["-"], "experimental-lazy-typecheck">,
HelpText<"Type-check lazily as needed to produce requested outputs">;
def debug_emit_invalid_swiftinterface_syntax : Flag<["-"], "debug-emit-invalid-swiftinterface-syntax">,
HelpText<"Write an invalid declaration into swiftinterface files">;
def debug_cycles : Flag<["-"], "debug-cycles">,
HelpText<"Print out debug dumps when cycles are detected in evaluation">;
def debug_time_function_bodies : Flag<["-"], "debug-time-function-bodies">,
HelpText<"Dumps the time it takes to type-check each function body">;
def debug_time_expression_type_checking : Flag<["-"], "debug-time-expression-type-checking">,
HelpText<"Dumps the time it takes to type-check each expression">;
def debug_assert_immediately : Flag<["-"], "debug-assert-immediately">,
DebugCrashOpt, HelpText<"Force an assertion failure immediately">;
def debug_assert_after_parse : Flag<["-"], "debug-assert-after-parse">,
DebugCrashOpt, HelpText<"Force an assertion failure after parsing">;
def debug_crash_immediately : Flag<["-"], "debug-crash-immediately">,
DebugCrashOpt, HelpText<"Force a crash immediately">;
def debug_crash_after_parse : Flag<["-"], "debug-crash-after-parse">,
DebugCrashOpt, HelpText<"Force a crash after parsing">;
def debug_test_dependency_scan_cache_serialization: Flag<["-"], "test-dependency-scan-cache-serialization">,
HelpText<"After performing a dependency scan, serialize and then deserialize the scanner's internal state.">;
def debugger_support : Flag<["-"], "debugger-support">,
HelpText<"Process swift code as if running in the debugger">;
def disable_clangimporter_source_import : Flag<["-"],
"disable-clangimporter-source-import">,
HelpText<"Disable ClangImporter and forward all requests straight the DWARF importer.">;
def disable_implicit_concurrency_module_import : Flag<["-"],
"disable-implicit-concurrency-module-import">,
HelpText<"Disable the implicit import of the _Concurrency module.">;
def disable_implicit_string_processing_module_import : Flag<["-"],
"disable-implicit-string-processing-module-import">,
HelpText<"Disable the implicit import of the _StringProcessing module.">;
def enable_implicit_backtracing_module_import : Flag<["-"],
"enable-implicit-backtracing-module-import">,
HelpText<"Enable the implicit import of the _Backtracing module.">;
def disable_implicit_backtracing_module_import : Flag<["-"],
"disable-implicit-backtracing-module-import">,
HelpText<"Disable the implicit import of the _Backtracing module.">;
def disable_implicit_cxx_module_import : Flag<["-"],
"disable-implicit-cxx-module-import">,
HelpText<"Disable the implicit import of the C++ Standard Library module.">;
def disable_arc_opts : Flag<["-"], "disable-arc-opts">,
HelpText<"Don't run SIL ARC optimization passes.">;
def disable_ossa_opts : Flag<["-"], "disable-ossa-opts">,
HelpText<"Don't run SIL OSSA optimization passes.">;
def disable_sil_partial_apply : Flag<["-"], "disable-sil-partial-apply">,
HelpText<"Disable use of partial_apply in SIL generation">;
def enable_spec_devirt : Flag<["-"], "enable-spec-devirt">,
HelpText<"Enable speculative devirtualization pass.">;
def enable_async_demotion : Flag<["-"], "enable-experimental-async-demotion">,
HelpText<"Enables an optimization pass to demote async functions.">;
def disable_access_control : Flag<["-"], "disable-access-control">,
HelpText<"Don't respect access control restrictions">;
def enable_access_control : Flag<["-"], "enable-access-control">,
HelpText<"Respect access control restrictions">;
def code_complete_inits_in_postfix_expr : Flag<["-"], "code-complete-inits-in-postfix-expr">,
HelpText<"Include initializers when completing a postfix expression">;
def code_complete_call_pattern_heuristics : Flag<["-"], "code-complete-call-pattern-heuristics">,
HelpText<"Use heuristics to guess whether we want call pattern completions">;
def disable_autolink_framework : Separate<["-"],"disable-autolink-framework">,
HelpText<"Disable autolinking against the provided framework">;
def disable_autolink_library : Separate<["-"],"disable-autolink-library">,
HelpText<"Disable autolinking against the provided library">;
def disable_autolink_frameworks : Flag<["-"],"disable-autolink-frameworks">,
HelpText<"Disable autolinking against all frameworks">;
def disable_all_autolinking : Flag<["-"],"disable-all-autolinking">,
HelpText<"Disable all Swift autolink directives">;
def disable_diagnostic_passes : Flag<["-"], "disable-diagnostic-passes">,
HelpText<"Don't run diagnostic passes">;
def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">,
HelpText<"Don't run LLVM optimization passes">;
def disable_sil_perf_optzns : Flag<["-"], "disable-sil-perf-optzns">,
HelpText<"Don't run SIL performance optimization passes">;
def disable_swift_specific_llvm_optzns : Flag<["-"], "disable-swift-specific-llvm-optzns">,
HelpText<"Don't run Swift specific LLVM optimization passes.">;
def disable_llvm_verify : Flag<["-"], "disable-llvm-verify">,
HelpText<"Don't run the LLVM IR verifier.">;
def disable_llvm_value_names : Flag<["-"], "disable-llvm-value-names">,
HelpText<"Don't add names to local values in LLVM IR">;
def dump_jit : JoinedOrSeparate<["-"], "dump-jit">,
HelpText<"Dump JIT contents">;
def enable_llvm_value_names : Flag<["-"], "enable-llvm-value-names">,
HelpText<"Add names to local values in LLVM IR">;
def enable_anonymous_context_mangled_names :
Flag<["-"], "enable-anonymous-context-mangled-names">,
HelpText<"Enable emission of mangled names in anonymous context descriptors">;
def disable_reflection_metadata : Flag<["-"], "disable-reflection-metadata">,
HelpText<"Disable emission of reflection metadata for nominal types">;
def reflection_metadata_for_debugger_only : Flag<["-"], "reflection-metadata-for-debugger-only">,
HelpText<"Emit reflection metadata for debugger only, don't make them available at runtime">;
def disable_reflection_names : Flag<["-"], "disable-reflection-names">,
HelpText<"Disable emission of names of stored properties and enum cases in"
"reflection metadata">;
def function_sections: Flag<["-"], "function-sections">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Emit functions to separate sections.">;
def enable_single_module_llvm_emission: Flag<["-"], "enable-single-module-llvm-emission">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Emit LLVM IR into a single LLVM module in multithreaded mode.">;
def emit_empty_object_file : Flag<["-"], "emit-empty-object-file">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Produce a valid but dummy object file when building a library module">;
def stack_promotion_checks : Flag<["-"], "emit-stack-promotion-checks">,
HelpText<"Emit runtime checks for correct stack promotion of objects.">;
def stack_promotion_limit : Separate<["-"], "stack-promotion-limit">,
HelpText<"Limit the size of stack promoted objects to the provided number "
"of bytes.">;
def dump_clang_diagnostics : Flag<["-"], "dump-clang-diagnostics">,
HelpText<"Dump Clang diagnostics to stderr">;
def dump_clang_lookup_tables : Flag<["-"], "dump-clang-lookup-tables">,
HelpText<"Dump the importer's Swift-name-to-Clang-name lookup tables to "
"stderr">;
def disable_modules_validate_system_headers : Flag<["-"], "disable-modules-validate-system-headers">,
HelpText<"Disable validating system headers in the Clang importer">;
def emit_verbose_sil : Flag<["-"], "emit-verbose-sil">,
HelpText<"Emit locations during SIL emission">;
def emit_pch : Flag<["-"], "emit-pch">,
HelpText<"Emit PCH for imported Objective-C header file">, ModeOpt;
def pch_disable_validation : Flag<["-"], "pch-disable-validation">,
HelpText<"Disable validating the persistent PCH">;
def disable_sil_ownership_verifier : Flag<["-"], "disable-sil-ownership-verifier">,
HelpText<"Do not verify ownership invariants during SIL Verification ">;
def suppress_static_exclusivity_swap : Flag<["-"], "suppress-static-exclusivity-swap">,
HelpText<"Suppress static violations of exclusive access with swap()">;
def enable_experimental_static_assert :
Flag<["-"], "enable-experimental-static-assert">,
HelpText<"Enable experimental #assert">;
def disable_subst_sil_function_types :
Flag<["-"], "disable-subst-sil-function-types">,
HelpText<"Disable substituted function types for SIL type lowering of function values">;
def enable_experimental_named_opaque_types :
Flag<["-"], "enable-experimental-named-opaque-types">,
HelpText<"Enable experimental support for named opaque result types">;
def enable_explicit_existential_types :
Flag<["-"], "enable-explicit-existential-types">,
HelpText<"Enable experimental support for explicit existential types">;
def enable_experimental_opened_existential_types :
Flag<["-"], "enable-experimental-opened-existential-types">,
HelpText<"Enable experimental support for implicitly opened existentials">;
def disable_experimental_opened_existential_types :
Flag<["-"], "disable-experimental-opened-existential-types">,
HelpText<"Disable experimental support for implicitly opened existentials">;
def enable_deserialization_recovery :
Flag<["-"], "enable-deserialization-recovery">,
HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;
def disable_deserialization_recovery :
Flag<["-"], "disable-deserialization-recovery">,
HelpText<"Don't attempt to recover from missing xrefs (etc) in swiftmodules">;
def enable_deserialization_safety :
Flag<["-"], "enable-deserialization-safety">,
HelpText<"Avoid reading potentially unsafe decls in swiftmodules">;
def disable_deserialization_safety :
Flag<["-"], "disable-deserialization-safety">,
HelpText<"Don't avoid reading potentially unsafe decls in swiftmodules">;
def force_workaround_broken_modules :
Flag<["-"], "experimental-force-workaround-broken-modules">,
HelpText<"Attempt unsafe recovery for imported modules with broken modularization">;
def enable_experimental_string_processing :
Flag<["-"], "enable-experimental-string-processing">,
HelpText<"Enable experimental string processing">;
def disable_experimental_string_processing :
Flag<["-"], "disable-experimental-string-processing">,
HelpText<"Disable experimental string processing">;
def enable_experimental_lifetime_dependence_inference :
Flag<["-"], "enable-experimental-lifetime-dependence-inference">,
HelpText<"Enable experimental lifetime dependence inference">;
def disable_experimental_lifetime_dependence_inference :
Flag<["-"], "disable-experimental-lifetime-dependence-inference">,
HelpText<"Disable experimental lifetime dependence inference">;
def disable_availability_checking : Flag<["-"],
"disable-availability-checking">,
HelpText<"Disable checking for potentially unavailable APIs">;
def warn_on_potentially_unavailable_enum_case : Flag<["-"],
"warn-on-potentially-unavailable-enum-case">,
HelpText<"Deprecated, will be removed in future versions">;
def warn_on_editor_placeholder : Flag<["-"],
"warn-on-editor-placeholder">,
HelpText<"Downgrade the editor placeholder error to a warning">;
def report_errors_to_debugger : Flag<["-"], "report-errors-to-debugger">,
HelpText<"Deprecated, will be removed in future versions.">;
def enable_swift3_objc_inference : Flag<["-"], "enable-swift3-objc-inference">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Deprecated, has no effect">;
def disable_swift3_objc_inference :
Flag<["-"], "disable-swift3-objc-inference">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Deprecated, has no effect">;
def enable_implicit_dynamic : Flag<["-"], "enable-implicit-dynamic">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Add 'dynamic' to all declarations">;
def bypass_resilience : Flag<["-"], "bypass-resilience-checks">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Ignore all checks for module resilience.">;
def enable_llvm_vfe : Flag<["-"], "enable-llvm-vfe">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Use LLVM IR Virtual Function Elimination on Swift class virtual tables">;
def enable_llvm_wme : Flag<["-"], "enable-llvm-wme">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Use LLVM IR Witness Method Elimination on Swift protocol witness tables">;
def internalize_at_link : Flag<["-"], "internalize-at-link">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Allow internalizing public symbols and vtables at link time (assume"
" all client code of public types is part of the same link unit, or that"
" external symbols are explicitly requested via -exported_symbols_list)">;
def conditional_runtime_records : Flag<["-"], "conditional-runtime-records">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Allow removal of runtime metadata records (public types, protocol conformances) based on whether they're used or unused">;
def disable_preallocated_instantiation_caches : Flag<["-"], "disable-preallocated-instantiation-caches">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Avoid preallocating metadata instantiation caches in globals">;
def disable_readonly_static_objects : Flag<["-"], "disable-readonly-static-objects">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Avoid allocating static objects in a read-only data section">;
def trap_function
: Separate<["-"], "trap-function">, MetaVarName<"<name>">,
HelpText<"Lower traps to calls to this function instead of trap instructions">;
def disable_previous_implementation_calls_in_dynamic_replacements :
Flag<["-"], "disable-previous-implementation-calls-in-dynamic-replacements">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Disable calling the previous implementation in dynamic replacements">;
def enable_dynamic_replacement_chaining :
Flag<["-"], "enable-dynamic-replacement-chaining">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Enable chaining of dynamic replacements">;
def enable_nskeyedarchiver_diagnostics :
Flag<["-"], "enable-nskeyedarchiver-diagnostics">,
HelpText<"Diagnose classes with unstable mangled names adopting NSCoding">;
def disable_nskeyedarchiver_diagnostics :
Flag<["-"], "disable-nskeyedarchiver-diagnostics">,
HelpText<"Allow classes with unstable mangled names to adopt NSCoding">;
def enable_nonfrozen_enum_exhaustivity_diagnostics :
Flag<["-"], "enable-nonfrozen-enum-exhaustivity-diagnostics">,
HelpText<"Diagnose switches over non-frozen enums without catch-all cases">;
def disable_nonfrozen_enum_exhaustivity_diagnostics :
Flag<["-"], "disable-nonfrozen-enum-exhaustivity-diagnostics">,
HelpText<"Allow switches over non-frozen enums without catch-all cases">;
def warn_long_function_bodies : Separate<["-"], "warn-long-function-bodies">,
MetaVarName<"<n>">,
HelpText<"Warns when type-checking a function takes longer than <n> ms">;
def warn_long_function_bodies_EQ : Joined<["-"], "warn-long-function-bodies=">,
Alias<warn_long_function_bodies>;
def warn_long_expression_type_checking : Separate<["-"], "warn-long-expression-type-checking">,
MetaVarName<"<n>">,
HelpText<"Warns when type-checking a function takes longer than <n> ms">;
def warn_long_expression_type_checking_EQ : Joined<["-"], "warn-long-expression-type-checking=">,
Alias<warn_long_expression_type_checking>;
def Rmodule_interface_rebuild : Flag<["-"], "Rmodule-interface-rebuild">,
HelpText<"Emits a remark if an imported module needs to be re-compiled from its module interface">;
def downgrade_typecheck_interface_error : Flag<["-"], "downgrade-typecheck-interface-error">,
HelpText<"Downgrade error to warning when typechecking emitted module interfaces">;
def enable_volatile_modules : Flag<["-"], "enable-volatile-modules">,
HelpText<"Load Swift modules in memory">;
def solver_expression_time_threshold_EQ : Joined<["-"], "solver-expression-time-threshold=">;
def solver_disable_shrink :
Flag<["-"], "solver-disable-shrink">,
HelpText<"Disable the shrink phase of expression type checking">;
def disable_constraint_solver_performance_hacks : Flag<["-"], "disable-constraint-solver-performance-hacks">,
HelpText<"Disable all the hacks in the constraint solver">;
def enable_operator_designated_types :
Flag<["-"], "enable-operator-designated-types">,
HelpText<"Enable operator designated types">;
def enable_invalid_ephemeralness_as_error :
Flag<["-"], "enable-invalid-ephemeralness-as-error">,
HelpText<"Diagnose invalid ephemeral to non-ephemeral conversions as errors">;
def disable_invalid_ephemeralness_as_error :
Flag<["-"], "disable-invalid-ephemeralness-as-error">,
HelpText<"Diagnose invalid ephemeral to non-ephemeral conversions as warnings">;
def switch_checking_invocation_threshold_EQ : Joined<["-"],
"switch-checking-invocation-threshold=">;
def enable_new_operator_lookup :
Flag<["-"], "enable-new-operator-lookup">,
HelpText<"Enable the new operator decl and precedencegroup lookup behavior">;
def disable_new_operator_lookup :
Flag<["-"], "disable-new-operator-lookup">,
HelpText<"Disable the new operator decl and precedencegroup lookup behavior">;
def enable_source_import : Flag<["-"], "enable-source-import">,
HelpText<"Enable importing of Swift source files">;
def enable_throw_without_try : Flag<["-"], "enable-throw-without-try">,
HelpText<"Allow throwing function calls without 'try'">;
def throws_as_traps : Flag<["-"], "throws-as-traps">,
HelpText<"Turn all throw sites into immediate traps">;
def import_module : Separate<["-"], "import-module">,
HelpText<"Implicitly import the specified module">;
def testable_import_module : Separate<["-"], "testable-import-module">,
HelpText<"Implicitly import the specified module with @testable">;
def print_stats : Flag<["-"], "print-stats">,
HelpText<"Print various statistics">;
def check_onone_completeness : Flag<["-"], "check-onone-completeness">,
HelpText<"Print errors if the compile OnoneSupport module is missing symbols">;
def debugger_testing_transform : Flag<["-"], "debugger-testing-transform">,
HelpText<"Instrument the code with calls to an intrinsic that record the expected values of "
"local variables so they can be compared against the results from the debugger.">;
def disable_debugger_shadow_copies : Flag<["-"], "disable-debugger-shadow-copies">,
HelpText<"Disable debugger shadow copies of local variables."
"This option is only useful for testing the compiler.">,
Flags<[FrontendOption, HelpHidden]>;
def disable_concrete_type_metadata_mangled_name_accessors : Flag<["-"], "disable-concrete-type-metadata-mangled-name-accessors">,
HelpText<"Disable concrete type metadata access by mangled name">,
Flags<[FrontendOption, HelpHidden]>;
def disable_standard_substitutions_in_reflection_mangling : Flag<["-"], "disable-standard-substitutions-in-reflection-mangling">,
HelpText<"Disable referencing stdlib symbols via mangled names in reflection mangling">,
Flags<[FrontendOption, HelpHidden]>;
def playground : Flag<["-"], "playground">,
HelpText<"Apply the playground semantics and transformation">;
def playground_option : Separate<["-"], "playground-option">,
Flags<[FrontendOption]>,
HelpText<"Provide an option to the playground transform (if enabled)">;
def playground_high_performance : Flag<["-"], "playground-high-performance">,
HelpText<"Omit instrumentation that has a high runtime performance impact">;
def disable_playground_transform : Flag<["-"], "disable-playground-transform">,
HelpText<"Disable playground transformation">;
def pc_macro : Flag<["-"], "pc-macro">,
HelpText<"Apply the 'program counter simulation' macro">;
def no_clang_module_breadcrumbs : Flag<["-"], "no-clang-module-breadcrumbs">,
HelpText<"Don't emit DWARF skeleton CUs for imported Clang modules. "
"Use this when building a redistributable static archive.">;
def use_jit : Flag<["-"], "use-jit">,
HelpText<"Register Objective-C classes as if the JIT were in use">;
def sil_inline_threshold : Separate<["-"], "sil-inline-threshold">,
MetaVarName<"<50>">,
HelpText<"Controls the aggressiveness of performance inlining">;
def sil_inline_caller_benefit_reduction_factor : Separate<["-"], "sil-inline-caller-benefit-reduction-factor">,
MetaVarName<"<2>">,
HelpText<"Controls the aggressiveness of performance inlining in -Osize "
"mode by reducing the base benefits of a caller (lower value "
"permits more inlining!)">;
def sil_unroll_threshold : Separate<["-"], "sil-unroll-threshold">,
MetaVarName<"<250>">,
HelpText<"Controls the aggressiveness of loop unrolling">;
def sil_verify_all : Flag<["-"], "sil-verify-all">,
HelpText<"Verify SIL after each transform">;
def sil_verify_none : Flag<["-"], "sil-verify-none">,
HelpText<"Completely disable SIL verification">;
def verify_all_substitution_maps : Flag<["-"], "verify-all-substitution-maps">,
HelpText<"Verify all SubstitutionMaps on construction">;
def sil_debug_serialization : Flag<["-"], "sil-debug-serialization">,
HelpText<"Do not eliminate functions in Mandatory Inlining/SILCombine dead "
"functions. (for debugging only)">;
def sil_stop_optzns_before_lowering_ownership :
Flag<["-"], "sil-stop-optzns-before-lowering-ownership">,
HelpText<"Stop optimizing at SIL time before we lower ownership from SIL. "
"Intended only for SIL ossa tests">;
def print_inst_counts : Flag<["-"], "print-inst-counts">,
HelpText<"Before IRGen, count all the various SIL instructions. Must be used "
"in conjunction with -print-stats.">;
def debug_on_sil : Flag<["-"], "sil-based-debuginfo">,
HelpText<"Write the SIL into a file and generate debug-info to debug on SIL "
" level.">;
def legacy_gsil : Flag<["-"], "gsil">,
HelpText<"Deprecated, use '-sil-based-debuginfo' instead">;
def print_llvm_inline_tree : Flag<["-"], "print-llvm-inline-tree">,
HelpText<"Print the LLVM inline tree.">;
def disable_incremental_llvm_codegeneration :
Flag<["-"], "disable-incremental-llvm-codegen">,
HelpText<"Disable incremental llvm code generation.">;
def ignore_always_inline : Flag<["-"], "ignore-always-inline">,
HelpText<"Ignore @inline(__always) attributes.">;
def emit_sorted_sil : Flag<["-"], "emit-sorted-sil">,
HelpText<"When printing SIL, print out all sil entities sorted by name to "
"ease diffing">;
def cxx_interop_getters_setters_as_properties :
Flag<["-"], "cxx-interop-getters-setters-as-properties">,
HelpText<"Import getters and setters as computed properties in Swift">,
Flags<[FrontendOption, HelpHidden]>;
def cxx_interop_disable_requirement_at_import :
Flag<["-"], "disable-cxx-interop-requirement-at-import">,
HelpText<"Do not require C++ interoperability to be enabled when importing a Swift module that enables C++ interoperability">,
Flags<[FrontendOption, HelpHidden]>;
def cxx_interop_use_opaque_pointer_for_moveonly :
Flag<["-"], "cxx-interop-use-opaque-pointer-for-moveonly">,
HelpText<"Testing flag that will be eliminated soon. Do not use.">,
Flags<[FrontendOption, HelpHidden]>;
def use_malloc : Flag<["-"], "use-malloc">,
HelpText<"Allocate internal data structures using malloc "
"(for memory debugging)">;
def interpret : Flag<["-"], "interpret">, HelpText<"Immediate mode">, ModeOpt;
def verify_type_layout : JoinedOrSeparate<["-"], "verify-type-layout">,
HelpText<"Verify compile-time and runtime type layout information for type">,
MetaVarName<"<type>">;
def external_pass_pipeline_filename : Separate<["-"], "external-pass-pipeline-filename">,
HelpText<"Use the pass pipeline defined by <pass_pipeline_file>">,
MetaVarName<"<pass_pipeline_file>">;
def index_system_modules : Flag<["-"], "index-system-modules">,
HelpText<"Emit index data for imported serialized swift system modules">;
def index_ignore_stdlib :
Flag<["-"], "index-ignore-stdlib">,
HelpText<"Avoid emitting index data for the standard library.">;
def dump_interface_hash : Flag<["-"], "dump-interface-hash">,
HelpText<"Parse input file(s) and dump interface token hash(es)">,
ModeOpt;
def compile_module_from_interface :
Flag<["-"], "compile-module-from-interface">,
HelpText<"Treat the (single) input as a swiftinterface and produce a module">,
ModeOpt;
def explicit_interface_module_build :
Flag<["-"], "explicit-interface-module-build">,
HelpText<"Use the specified command-line to build the module from interface, instead of flags specified in the interface">;
def direct_clang_cc1_module_build :
Flag<["-"], "direct-clang-cc1-module-build">,
HelpText<"Use the specified -Xcc options to build a PCM by using Clang frontend directly, bypassing the Clang driver">;
def build_module_from_parseable_interface :