//===--- 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<"">, HelpText<"Output module documentation file ">; def emit_variant_module_doc_path : Separate<["-"], "emit-variant-module-doc-path">, MetaVarName<"">, Flags<[NewDriverOnlyOption]>, HelpText<"Output module documentation file for the target variant to ">; def emit_dependencies_path : Separate<["-"], "emit-dependencies-path">, MetaVarName<"">, HelpText<"Output basic Make-compatible dependencies file to ">; def emit_reference_dependencies_path : Separate<["-"], "emit-reference-dependencies-path">, MetaVarName<"">, HelpText<"Output Swift-style dependencies file to ">; def emit_fixits_path : Separate<["-"], "emit-fixits-path">, MetaVarName<"">, HelpText<"Output compiler fixits as source edits to ">; def emit_abi_descriptor_path : Separate<["-"], "emit-abi-descriptor-path">, MetaVarName<"">, HelpText<"Output the ABI descriptor of current module to ">; def emit_variant_abi_descriptor_path : Separate<["-"], "emit-variant-abi-descriptor-path">, MetaVarName<"">, Flags<[NewDriverOnlyOption]>, HelpText<"Output the ABI descriptor of current target variant module to ">; def emit_module_semantic_info_path : Separate<["-"], "emit-module-semantic-info-path">, MetaVarName<"">, HelpText<"Output semantic info of current module to ">; def diagnostic_documentation_path : Separate<["-"], "diagnostic-documentation-path">, MetaVarName<"">, 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; 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; 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">; def block_list_file : Separate<["-"], "blocklist-file">, MetaVarName<"">, Flags<[FrontendOption, NoDriverOption, ArgumentIsPath]>, HelpText<"The path to a blocklist configuration file">; let Flags = [FrontendOption, NoDriverOption] in { def triple : Separate<["-"], "triple">, Alias; 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, Flags<[HelpHidden]>; def tbd_install_name : Separate<["-"], "tbd-install_name">, MetaVarName<"">, HelpText<"The install_name to use in an emitted TBD file">; def tbd_install_name_EQ : Joined<["-"], "tbd-install_name=">, Alias; def tbd_current_version : Separate<["-"], "tbd-current-version">, MetaVarName<"">, HelpText<"The current_version to use in an emitted TBD file">; def tbd_current_version_EQ : Joined<["-"], "tbd-current-version=">, Alias; def tbd_compatibility_version : Separate<["-"], "tbd-compatibility-version">, MetaVarName<"">, HelpText<"The compatibility_version to use in an emitted TBD file">; def tbd_compatibility_version_EQ : Joined<["-"], "tbd-compatibility-version=">, Alias; 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- 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 '' location in verify mode">; def verify_generic_signatures : Separate<["-"], "verify-generic-signatures">, MetaVarName<"">, 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<"">; 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 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<"=">, HelpText<"Specify Swift module input explicitly built from textual interface">; def swift_module_cross_import: MultiArg<["-"], "swift-module-cross-import", 2>, MetaVarName<" ">, HelpText<"Specify the cross import module">; def module_can_import: Separate<["-"], "module-can-import">, MetaVarName<"">, HelpText<"Specify canImport module name">; def module_can_import_version: MultiArg<["-"], "module-can-import-version", 3>, MetaVarName<" ">, HelpText<"Specify canImport module and versions">; def module_import_from_cas: Flag<["-"], "module-import-from-cas">, HelpText<"Import modules from CAS instead of file system">; 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<"">, HelpText<"Specify a JSON file containing information of explicit Swift modules">; def const_gather_protocols_file : Separate<["-"], "const-gather-protocols-file">, MetaVarName<"">, HelpText<"Specify a list of protocols for extraction of conformances' const values'">; 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<"For performing a dependency scan, deserialize the scanner's internal state from a prior scan.">; def validate_prior_dependency_scan_cache : Flag<["-"], "validate-prior-dependency-scan-cache">, HelpText<"For performing a dependency scan with a prior scanner state, validate module dependencies.">; 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 no_parallel_scan : Flag<["-"], "no-parallel-scan">, HelpText<"Perform dependency scanning in a single-threaded fashion.">; def enable_copy_propagation : Flag<["-"], "enable-copy-propagation">, HelpText<"Always 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<"always|optimizing|requested-passes-only|false">; 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; } // end let Flags = [FrontendOption, NoDriverOption] def debug_crash_Group : OptionGroup<"">; class DebugCrashOpt : 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">; def formal_cxx_interoperability_mode : Joined<["-"], "formal-cxx-interoperability-mode=">, HelpText<"What version of C++ interoperability a textual interface was originally generated with">, MetaVarName<"|off">; def enable_assembly_vision_all : Flag<["-"], "enable-assembly-vision-all">, HelpText<"Enable assembly vision for all functions">; def disable_assembly_vision_all : Flag<["-"], "disable-assembly-vision-all">, HelpText<"Disable assembly vision for all functions">; } // 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">; def public_autolink_library : Separate<["-"], "public-autolink-library">, HelpText<"Add public dependent library">; } // 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 ">, MetaVarName<"">; def debug_constraints_on_line_EQ : Joined<["-"], "debug-constraints-on-line=">, Alias; 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 dump_source_file_imports : Flag<["-"], "dump-source-file-imports">, HelpText<"Dumps the list of imports for each source file">; def analyze_request_evaluator : Flag<["-"], "analyze-request-evaluator">, Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>, HelpText<"Print out request evaluator cache statistics at the end of the compilation job">; 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_concrete_size : Joined<["-"], "requirement-machine-max-concrete-size=">, Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>, HelpText<"Set the maximum concrete type total size before giving up">; def requirement_machine_max_type_differences : Joined<["-"], "requirement-machine-max-type-differences=">, Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>, HelpText<"Set the maximum number of type difference structures allocated 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 max_substitution_depth : Joined<["-"], "max-substitution-depth=">, Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>, HelpText<"Set the maximum nesting depth for type substitution operations">; def max_substitution_count : Joined<["-"], "max-substitution-count=">, Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>, HelpText<"Set the maximum step count for type substitution operations">; 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_const_value_importing : Flag<["-"], "disable-const-value-importing">, HelpText<"Disable constant value importing in ClangImporter.">; 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 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 enable_throws_prediction : Flag<["-"], "enable-throws-prediction">, HelpText<"Enables optimization assumption that functions rarely throw errors.">; def disable_throws_prediction : Flag<["-"], "disable-throws-prediction">, HelpText<"Disables optimization assumption that functions rarely throw errors.">; def enable_noreturn_prediction : Flag<["-"], "enable-noreturn-prediction">, HelpText<"Enables optimization assumption that calls to no-return functions are cold.">; def disable_noreturn_prediction : Flag<["-"], "disable-noreturn-prediction">, HelpText<"Disables optimization assumption that calls to no-return functions are cold.">; 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_force_load_symbols : Flag<["-"],"disable-force-load-symbols">, Flags<[FrontendOption, HelpHidden]>, HelpText<"Disable generation of all Swift _FORCE_LOAD symbols">; 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 enable_llvm_verify_each : Flag<["-"], "enable-llvm-verify-each">, HelpText<"Run the LLVM IR verifier after every pass.">; def disable_llvm_verify_each : Flag<["-"], "disable-llvm-verify-each">, HelpText<"Don't run the LLVM IR verifier after every pass.">; 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 disable_llvm_merge_functions_pass : Flag<["-"], "disable-llvm-merge-functions-pass">, HelpText<"Disable the MergeFunctionPass LLVM IR pass">; 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 dump_availability_scopes : Flag<["-"], "dump-availability-scopes">, HelpText<"Dump availability scopes 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 version_independent_apinotes : Flag<["-"], "version-independent-apinotes">, HelpText<"Input clang modules carry all versioned APINotes">; 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 mergeable_symbols : Flag<["-"], "mergeable-symbols">, Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>, HelpText<"Emit symbol definitions as mergeable (linkonce_odr)">; 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<"">, 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<"">, HelpText<"Warns when type-checking a function takes longer than ms">; def warn_long_function_bodies_EQ : Joined<["-"], "warn-long-function-bodies=">, Alias; def warn_long_expression_type_checking : Separate<["-"], "warn-long-expression-type-checking">, MetaVarName<"">, HelpText<"Warns when type-checking an expression takes longer than ms">; def warn_long_expression_type_checking_EQ : Joined<["-"], "warn-long-expression-type-checking=">, Alias; 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_memory_threshold_EQ : Joined<["-"], "solver-memory-threshold=">, HelpText<"Set the upper bound for memory consumption, in bytes, by the constraint solver">; def solver_expression_time_threshold_EQ : Joined<["-"], "solver-expression-time-threshold=">, HelpText<"Expression type checking timeout, in seconds">; def solver_scope_threshold_EQ : Joined<["-"], "solver-scope-threshold=">, HelpText<"Expression type checking scope limit">; def solver_trail_threshold_EQ : Joined<["-"], "solver-trail-threshold=">, HelpText<"Expression type checking trail change limit">; def solver_disable_prepared_overloads : Flag<["-"], "solver-disable-prepared-overloads">, HelpText<"Disable experimental prepared overloads optimization">; def solver_enable_prepared_overloads : Flag<["-"], "solver-enable-prepared-overloads">, HelpText<"Enable experimental prepared overloads optimization">; def solver_disable_splitter : Flag<["-"], "solver-disable-splitter">, HelpText<"Disable the component splitter phase of expression type checking">; def enable_constraint_solver_performance_hacks : Flag<["-"], "enable-constraint-solver-performance-hacks">, HelpText<"Enable all the old 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 dynamic_member_lookup_depth_limit_EQ : Joined<["-"], "dynamic-member-lookup-depth-limit=">, HelpText< "The maximum number of dynamic member lookups that can be chained " "to resolve a member reference">; 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 sil_ownership_verify_all : Flag<["-"], "sil-ownership-verify-all">, HelpText<"Verify ownership after each transform">; 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<"">; def external_pass_pipeline_filename : Separate<["-"], "external-pass-pipeline-filename">, HelpText<"Use the pass pipeline defined by ">, MetaVarName<"">; 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 : Flag<["-"], "build-module-from-parseable-interface">, Alias, ModeOpt; def typecheck_module_from_interface : Flag<["-"], "typecheck-module-from-interface">, HelpText<"Treat the (single) input as a swiftinterface and typecheck it">, ModeOpt; def module_interface_preserve_types_as_written : Flag<["-"], "module-interface-preserve-types-as-written">, HelpText<"When emitting a module interface, preserve types as they were " "written in the source">; def alias_module_names_in_module_interface : Flag<["-"], "alias-module-names-in-module-interface">, HelpText<"When emitting a module interface, disambiguate modules using " "distinct alias names">; def disable_alias_module_names_in_module_interface : Flag<["-"], "disable-alias-module-names-in-module-interface">, HelpText<"When emitting a module interface, disable disambiguating modules " "using distinct alias names">; def experimental_spi_imports : Flag<["-"], "experimental-spi-imports">, HelpText<"Enable experimental support for SPI imports">; def disable_print_missing_imports_in_module_interface : Flag<["-"], "disable-print-missing-imports-in-module-interface">, HelpText<"Disable adding to the module interface imports used from API and " "missing from the sources">; // [FIXME: Clang-type-plumbing] Make this a SIL-only option once we start // unconditionally emitting non-canonical Clang types in swiftinterfaces. def experimental_print_full_convention : Flag<["-"], "experimental-print-full-convention">, HelpText<"When emitting a module interface or SIL, emit additional @convention" " arguments, regardless of whether they were written in the source." " Also requires -use-clang-function-types to be enabled.">; def force_public_linkage : Flag<["-"], "force-public-linkage">, HelpText<"Force public linkage for private symbols. Used by LLDB.">; def diagnostics_editor_mode : Flag<["-"], "diagnostics-editor-mode">, HelpText<"Diagnostics will be used in editor">; def validate_tbd_against_ir_EQ: Joined<["-"], "validate-tbd-against-ir=">, HelpText<"Compare the symbols in the IR against the TBD file that would be generated.">, MetaVarName<"">; def bypass_batch_mode_checks: Flag<["-"], "bypass-batch-mode-checks">, HelpText<"Bypass checks for batch-mode errors.">; def enable_verify_exclusivity : Flag<["-"], "enable-verify-exclusivity">, HelpText<"Enable verification of access markers used to enforce exclusivity.">; def disable_verify_exclusivity : Flag<["-"], "disable-verify-exclusivity">, HelpText<"Disable verification of access markers used to enforce exclusivity.">; def disable_legacy_type_info : Flag<["-"], "disable-legacy-type-info">, HelpText<"Completely disable legacy type layout">; def disable_generic_metadata_prespecialization : Flag<["-"], "disable-generic-metadata-prespecialization">, HelpText<"Do not statically specialize metadata for generic types at types " "that are known to be used in source.">; def prespecialize_generic_metadata : Flag<["-"], "prespecialize-generic-metadata">, HelpText<"Statically specialize metadata for generic types at types that " "are known to be used in source.">; def emit_singleton_metadata_pointer : Flag<["-"], "emit-singleton-metadata-pointer">, HelpText<"Emit a pointer to the corresponding type metadata into non-public " "non-generic type descriptors.">; def read_legacy_type_info_path_EQ : Joined<["-"], "read-legacy-type-info-path=">, HelpText<"Read legacy type layout from the given path instead of default path">; def type_info_dump_filter_EQ : Joined<["-"], "type-info-dump-filter=">, Flags<[FrontendOption]>, HelpText<"One of 'all', 'resilient' or 'fragile'">; def swift_async_frame_pointer_EQ : Joined<["-"], "swift-async-frame-pointer=">, Flags<[FrontendOption]>, HelpText<"One of 'auto', 'always' or 'never'">; def previous_module_installname_map_file : Separate<["-"], "previous-module-installname-map-file">, MetaVarName<"">, HelpText<"Path to a Json file indicating module name to installname map for @_originallyDefinedIn">; def enable_type_layouts : Flag<["-"], "enable-type-layout">, HelpText<"Enable type layout based lowering">; def disable_type_layouts : Flag<["-"], "disable-type-layout">, HelpText<"Disable type layout based lowering">; def force_struct_type_layouts : Flag<["-"], "force-struct-type-layouts">, HelpText<"Force type layout based lowering for structs">; def enable_layout_string_value_witnesses : Flag<["-"], "enable-layout-string-value-witnesses">, HelpText<"Enable layout string based value witnesses">; def enable_large_loadable_types_reg2mem : Flag<["-"], "enable-large-loadable-types-reg2mem">, HelpText<"Enable large loadable types register to memory pass">; def disable_large_loadable_types_reg2mem : Flag<["-"], "disable-large-loadable-types-reg2mem">, HelpText<"Disable large loadable types register to memory pass">; def enable_x86_64_corocc : Flag<["-"], "enable-x86_64-corocc">, HelpText<"Use swiftcorocc for yield_once_2 routines on x86_64.">; def disable_x86_64_corocc : Flag<["-"], "disable-x86_64-corocc">, HelpText<"Don't use swiftcorocc for yield_once_2 routines on x86_64.">; def enable_arm64_corocc : Flag<["-"], "enable-arm64-corocc">, HelpText<"Use swiftcorocc for yield_once_2 routines on arm64 variants.">; def disable_arm64_corocc : Flag<["-"], "disable-arm64-corocc">, HelpText<"Don't use swiftcorocc for yield_once_2 routines on arm64 variants.">; def enable_callee_allocated_coro_abi : Flag<["-"], "enable-callee-allocated-coro-abi">, HelpText<"Override per-platform settings and use yield_once_2.">; def disable_callee_allocated_coro_abi : Flag<["-"], "disable-callee-allocated-coro-abi">, HelpText<"Override per-platform settings and don't use yield_once_2.">; def enable_cond_fail_message_annotation : Flag<["-"], "enable-cond-fail-message-annotation">, HelpText<"Enable cond_fail message annotation. Will serialize a .o.yaml file per .o file.">; def disable_cond_fail_message_annotation : Flag<["-"], "dissable-cond-fail-message-annotation">, HelpText<"Disable cond_fail message annotation.">; def min_valid_pointer_value : Joined<["-"], "min-valid-pointer-value=">, MetaVarName<"">, HelpText<"Overrides the target's least valid pointer value.'">; let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable] in { def enable_pack_metadata_stack_promotion : Joined<["-"], "enable-pack-metadata-stack-promotion=">, HelpText<"Whether to skip heapifying stack metadata packs when possible.">, MetaVarName<"true|false">; def enable_pack_metadata_stack_promotion_noArg : Flag<["-"], "enable-pack-metadata-stack-promotion">, HelpText<"Skip heapifying stack metadata packs when possible.">; } def disable_layout_string_value_witnesses : Flag<["-"], "disable-layout-string-value-witnesses">, HelpText<"Disable layout string based value witnesses">; def enable_layout_string_value_witnesses_instantiation : Flag<["-"], "enable-layout-string-value-witnesses-instantiation">, HelpText<"Enable runtime instantiation of layout string value witnesses for generic types">; def disable_layout_string_value_witnesses_instantiation : Flag<["-"], "disable-layout-string-value-witnesses-instantiation">, HelpText<"Disable runtime instantiation of layout string value witnesses for generic types">; def disable_interface_lockfile : Flag<["-"], "disable-interface-lock">, HelpText<"Don't lock interface file when building module">; def bridging_header_directory_for_print: Separate<["-"], "bridging-header-directory-for-print">, MetaVarName<"">, HelpText<"Directory for bridging header to be printed in compatibility header">; def entry_point_function_name: Separate<["-"], "entry-point-function-name">, MetaVarName<"">, HelpText<"Name of the entry point function">; def target_sdk_version : Separate<["-"], "target-sdk-version">, HelpText<"The version of target SDK used for compilation">; def target_variant_sdk_version : Separate<["-"], "target-variant-sdk-version">, HelpText<"The version of target variant SDK used for compilation">; def target_sdk_name : Separate<["-"], "target-sdk-name">, HelpText<"Canonical name of the target SDK used for compilation">; def candidate_module_file : Separate<["-"], "candidate-module-file">, MetaVarName<"">, HelpText<"Specify Swift module may be ready to use for an interface">; def use_static_resource_dir : Flag<["-"], "use-static-resource-dir">, HelpText<"Use resources in the static resource directory">; def disable_building_interface : Flag<["-"], "disable-building-interface">, HelpText<"Disallow building binary module from textual interface">; def experimental_skip_all_function_bodies: Flag<["-"], "experimental-skip-all-function-bodies">, HelpText<"Skip type-checking function bodies and all SIL generation">; def experimental_allow_module_with_compiler_errors: Flag<["-"], "experimental-allow-module-with-compiler-errors">, Flags<[HelpHidden]>, HelpText<"Attempt to output .swiftmodule, regardless of compilation errors">; def experimental_skip_non_exportable_decls : Flag<["-"], "experimental-skip-non-exportable-decls">, HelpText<"Skip decls that are not exported to clients">; def bad_file_descriptor_retry_count: Separate<["-"], "bad-file-descriptor-retry-count">, HelpText<"Number of retrying opening a file if previous open returns a bad " "file descriptor error.">; def enable_ast_verifier : Flag<["-"], "enable-ast-verifier">, HelpText<"Run the AST verifier during compilation. NOTE: This lets the user " "override the default behavior on whether or not the ASTVerifier " "is run. The default behavior is to run the verifier when asserts " "are enabled and not run it when asserts are disabled. NOTE: " "Can not be used if disable-ast-verifier is used as well">; def disable_ast_verifier : Flag<["-"], "disable-ast-verifier">, HelpText<"Do not run the AST verifier during compilation. NOTE: This lets " "the user override the default behavior on whether or not the " "ASTVerifier is run. The default behavior is to run the verifier " "when asserts are enabled and not run it when asserts are " "disabled. NOTE: Can not be used if enable-ast-verifier is used " "as well">; let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable] in { def enable_ossa_modules : Flag<["-"], "enable-ossa-modules">, HelpText<"Always serialize SIL in ossa form. If this flag is not passed in, " "when optimizing ownership will be lowered before serializing SIL">; } def enable_recompilation_to_ossa_module : Flag<["-"], "enable-recompilation-to-ossa-module">, HelpText<"Allow recompilation of a non-OSSA module to an OSSA module when imported from another OSSA module">; def enable_sil_opaque_values : Flag<["-"], "enable-sil-opaque-values">, HelpText<"Enable SIL Opaque Values">; def disable_sil_opaque_values : Flag<["-"], "disable-sil-opaque-values">, HelpText<"Disable SIL Opaque Values">; def new_driver_path : Separate<["-"], "new-driver-path">, MetaVarName<"">, HelpText<"Path of the new driver to be used">; def disable_fine_module_tracing: Flag<["-"], "disable-fine-module-tracing">, HelpText<"Skip the emission of fine grained module tracing file.">; def clang_header_expose_decls: Joined<["-"], "clang-header-expose-decls=">, HelpText<"Which declarations should be exposed in the generated clang header.">, Flags<[FrontendOption, HelpHidden]>, MetaVarName<"all-public|has-expose-attr">; def clang_header_expose_module: Separate<["-"], "clang-header-expose-module">, HelpText<"Allow the compiler to assume that APIs from the specified module are exposed to C/C++/Objective-C in another generated header, so that APIs in the current module that depend on declarations from the specified module can be exposed in the generated header.">, Flags<[FrontendOption, HelpHidden]>, MetaVarName<"=">; def weak_link_at_target : Flag<["-"], "weak-link-at-target">, HelpText<"Weakly link symbols for declarations that were introduced at the " "deployment target. Symbols introduced before the deployment " "target are still strongly linked.">; def concurrency_model : Separate<["-"], "concurrency-model">, HelpText<"Which concurrency model is used. Defaults to standard.">, MetaVarName<"standard|task-to-thread">; def concurrency_model_EQ : Joined<["-"], "concurrency-model=">, Alias; def enable_stack_protector : Flag<["-"], "enable-stack-protector">, HelpText<"Enable the stack protector">; def disable_stack_protector : Flag<["-"], "disable-stack-protector">, HelpText<"Disable the stack-protector">; def enable_move_inout_stack_protector : Flag<["-"], "enable-move-inout-stack-protector">, HelpText<"Enable the stack protector by moving values to temporaries">; // This feature is enabled by default, the flag is a no-op. def enable_import_ptrauth_field_function_pointers : Flag<["-"], "enable-import-ptrauth-field-function-pointers">, HelpText<"Enable import of custom ptrauth qualified field function pointers. " "This is on by default.">; def disable_import_ptrauth_field_function_pointers : Flag<["-"], "disable-import-ptrauth-field-function-pointers">, HelpText<"Disable import of custom ptrauth qualified field function pointers">; def enable_lifetime_dependence_diagnostics : Flag<["-"], "enable-lifetime-dependence-diagnostics">, HelpText<"Enable lifetime dependence diagnostics for Nonescapable types.">; def disable_lifetime_dependence_diagnostics : Flag<["-"], "disable-lifetime-dependence-diagnostics">, HelpText<"Disable lifetime dependence diagnostics for Nonescapable types.">; def enable_aggressive_reg2mem : Flag<["-"], "enable-aggressive-reg2mem">, HelpText<"Enable a more aggressive reg2mem heuristic">; def disable_aggressive_reg2mem : Flag<["-"], "disable-aggressive-reg2mem">, HelpText<"Disable a more aggressive reg2mem heuristic">; def enable_collocate_metadata_functions : Flag<["-"], "enable-collocate-metadata-functions">, HelpText<"Enable collocate metadata functions">; def disable_collocate_metadata_functions : Flag<["-"], "disable-collocate-metadata-functions">, HelpText<"Disable collocate metadata functions">; def enable_colocate_type_descriptors : Flag<["-"], "enable-colocate-type-descriptors">, HelpText<"Enable colocate type descriptors">; def disable_colocate_type_descriptors : Flag<["-"], "disable-colocate-type-descriptors">, HelpText<"Disable colocate type descriptors">; def enable_relative_protocol_witness_tables : Flag<["-"], "enable-relative-protocol-witness-tables">, HelpText<"Enable relative protocol witness tables">; def disable_relative_protocol_witness_tables : Flag<["-"], "disable-relative-protocol-witness-tables">, HelpText<"Disable relative protocol witness tables">; def enable_fragile_resilient_protocol_witnesses : Flag<["-"], "enable-fragile-relative-protocol-tables">, HelpText<"Enable relative protocol witness tables">; def disable_fragile_resilient_protocol_witnesses : Flag<["-"], "disable-fragile-relative-protocol-tables">, HelpText<"Disable relative protocol witness tables">; def enable_async_frame_push_pop_metadata : Flag<["-"], "enable-async-frame-push-pop-metadata">, HelpText<"Enable async frame push pop metadata">; def disable_async_frame_push_pop_metadata : Flag<["-"], "disable-async-frame-push-pop-metadata">, HelpText<"Disable async frame push pop metadata">; def enable_emit_type_malloc_for_coro_frame : Flag<["-"], "enable-emit-type-malloc-for-coro-frame">, HelpText<"Enable emitting typed malloc for coroutine frame allocation">; def disable_emit_type_malloc_for_coro_frame : Flag<["-"], "disable-emit-type-malloc-for-coro-frame">, HelpText<"Disable emitting typed malloc for coroutine frame allocation">; def enable_async_frame_pointer_all : Flag<["-"], "enable-async-frame-pointer-all">, HelpText<"Always emit async frame stack frames (frame-pointer=all)">; def disable_async_frame_pointer_all: Flag<["-"], "disable-async-frame-pointer-all">, HelpText<"Disable always emit async frame stack frames">; def enable_split_cold_code : Flag<["-"], "enable-split-cold-code">, HelpText<"Enable splitting of cold code when optimizing">; def disable_split_cold_code : Flag<["-"], "disable-split-cold-code">, HelpText<"Disable splitting of cold code when optimizing">; def mergeable_traps : Flag<["-"], "mergeable-traps">, HelpText<"Emit mergeable traps even in optimized builds">; def enable_new_llvm_pass_manager : Flag<["-"], "enable-new-llvm-pass-manager">, HelpText<"Enable the new llvm pass manager">; def disable_new_llvm_pass_manager : Flag<["-"], "disable-new-llvm-pass-manager">, HelpText<"Disable the new llvm pass manager">; def enable_profiling_marker_thunks : Flag<["-"], "enable-profiling-marker-thunks">, HelpText<"Enable profiling marker thunks">; def disable_profiling_marker_thunks : Flag<["-"], "disable-profiling-marker-thunks">, HelpText<"Disable profiling marker thunks">; def enable_objective_c_protocol_symbolic_references : Flag<["-"], "enable-objective-c-protocol-symbolic-references">, HelpText<"Enable objective-c protocol symbolic references">; def disable_objective_c_protocol_symbolic_references : Flag<["-"], "disable-objective-c-protocol-symbolic-references">, HelpText<"Disable objective-c protocol symbolic references">; def disable_emit_generic_class_ro_t_list : Flag<["-"], "disable-emit-generic-class-ro_t-list">, HelpText<"Disable emission of a section with references to class_ro_t of " "generic class patterns">; def enable_emit_generic_class_ro_t_list : Flag<["-"], "enable-emit-generic-class-ro_t-list">, HelpText<"Enable emission of a section with references to class_ro_t of " "generic class patterns">; def always_compile_output_files : Flag<["-"], "always-compile-output-files">, HelpText<"Always compile output files even it might not change the results">; // CAS/Caching related options. def input_file_key : Separate<["-"], "input-file-key">, HelpText<"Cache Key for input file">; def bridging_header_pch_key : Separate<["-"], "bridging-header-pch-key">, HelpText<"Cache Key for bridging header pch">; def no_clang_include_tree: Flag<["-"], "no-clang-include-tree">, HelpText<"Do not use clang include tree, fallback to use CAS filesystem to build clang modules">; def clang_include_tree_root: Separate<["-"], "clang-include-tree-root">, HelpText<"Clang Include Tree CASID">, MetaVarName<"">; def clang_include_tree_filelist: Separate<["-"], "clang-include-tree-filelist">, HelpText<"Clang Include Tree FileList CASID">, MetaVarName<"">; def experimental_spi_only_imports : Flag<["-"], "experimental-spi-only-imports">, HelpText<"Enable use of @_spiOnly imports">; def enable_ossa_complete_lifetimes : Flag<["-"], "enable-ossa-complete-lifetimes">, HelpText<"Require linear OSSA lifetimes after SILGen">; def disable_ossa_complete_lifetimes : Flag<["-"], "disable-ossa-complete-lifetimes">, HelpText<"Do not require linear OSSA lifetimes after SILGen">; def enable_ossa_verify_complete : Flag<["-"], "enable-ossa-verify-complete">, HelpText<"Verify linear OSSA lifetimes after SILGen">; def disable_ossa_verify_complete : Flag<["-"], "disable-ossa-verify-complete">, HelpText<"Do not verify linear OSSA lifetimes after SILGen">; def platform_c_calling_convention : Separate<["-"], "experimental-platform-c-calling-convention">, HelpText<"Which calling convention is used to perform non-swift calls. " "Defaults to llvm's standard C calling convention.">; def platform_c_calling_convention_EQ : Joined<["-"], "experimental-platform-c-calling-convention=">, Alias; def disable_sending_args_and_results_with_region_isolation : Flag<["-"], "disable-sending-args-and-results-with-region-based-isolation">, HelpText<"Disable sending args and results when region-based isolation is enabled. Only enabled with asserts">, Flags<[HelpHidden]>; def scanner_module_validation: Flag<["-"], "scanner-module-validation">, HelpText<"Validate binary modules in the dependency scanner">; def no_scanner_module_validation: Flag<["-"], "no-scanner-module-validation">, HelpText<"Do not validate binary modules in scanner and delegate the validation to swift-frontend">; def module_load_mode: Separate<["-"], "module-load-mode">, MetaVarName<"only-interface|prefer-interface|prefer-serialized|only-serialized">, HelpText<"Module loading mode">; def scanner_output_dir: Separate<["-"], "scanner-output-dir">, HelpText<"Directory for generated files from swift dependency scanner">; def scanner_debug_write_output: Flag<["-"], "scanner-debug-write-output">, HelpText<"Write generated output from scanner for debugging purpose">, Flags<[HelpHidden]>; def platform_availability_inheritance_map_path : Separate<["-"], "platform-availability-inheritance-map-path">, MetaVarName<"">, HelpText<"Path of the platform inheritance platform map">; def enable_address_dependencies : Flag<["-"], "enable-address-dependencies">, HelpText<"Enable enforcement of lifetime dependencies on addressable values.">; def disable_address_dependencies : Flag<["-"], "disable-address-dependencies">, HelpText<"Disable enforcement of lifetime dependencies on addressable values.">; def gen_reproducer : Flag<["-"], "gen-reproducer">, HelpText<"Generate a reproducer for current compilation.">; def gen_reproducer_dir : Separate<["-"], "gen-reproducer-dir">, HelpText<"Path to directory where reproducers write to.">; } // end let Flags = [FrontendOption, NoDriverOption, HelpHidden] def disable_experimental_parser_round_trip : Flag<["-"], "disable-experimental-parser-round-trip">, HelpText<"Disable round trip through the new swift parser">, Flags<[FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable]>;