averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-21 12:14:44 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
60cdbb84a508a499caee6b3ccae5ca50aaa5f02d
swift-mirror/include/swift/Basic/Features.def
Nate Chandler 60cdbb84a5 [Features] Move NoncopyableGenerics up. 
Some compilers have the NoncopyableGenerics feature enabled via
interesting mechanisms but do not have ConformanceSuppression.  To
support such compilers, the NoncopyableGenerics feature must appear
before ConformanceSuppression in the list of features.  Otherwise, when
parsing the portion of the swiftinterface corresponding to an entity
which involves both features, the first check will be for
NoncopyableGenerics (which that old compiler has) and the code inside
will involve ConformanceSuppression (which that old compiler does not
have).

rdar://128611158
2024-05-23 10:12:01 -07:00

412 lines
19 KiB
C++
Raw Blame History

//===--- Features.def - Swift Features Metaprogramming ----------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2021 - 2023 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 macros used for macro-metaprogramming with language
// features.
//
//
// LANGUAGE_FEATURE(FeatureName, SENumber, Description)
//
// The LANGUAGE_FEATURE macro describes each named feature that is
// introduced in Swift. It allows Swift code to check for a particular
// feature with "#if $FeatureName" in source code.
//
// FeatureName: The name given to this feature to be used in source code,
// e.g., AsyncAwait.
// SENumber: The number assigned to this feature in the Swift Evolution
// process, or 0 if there isn't one.
// Description: A string literal describing the feature.
//
// Suppressible language features can be suppressed when printing
// an interface without having to suppress the entire declaration they're
// contained within. The declaration will be emitted multiple times,
// each with a subset of the suppressible features. To avoid combinatoric
// re-emission, we assume a linear history: later features in this file
// imply the existence of earlier features. (This only needs to apply to
// suppressible features.)
//
// Sometimes, certain declarations will conflict with existing declarations
// when printed with a suppressible feature disabled. The attribute
// @_disallowFeatureSuppression can be used to suppress feature suppression on
// a particular declaration.
//
// If suppressing a feature in general is problematic, but it's okay to
// suppress it for specific declarations, the feature can be made
// conditionally suppressible. Declarations opt in to suppression with
// the @_allowFeatureSuppression attribute.
//
// BASELINE_LANGUAGE_FEATURE is the same as LANGUAGE_FEATURE, but is used
// for features that can be assumed to be available in any Swift compiler that
// will be used to process the textual interface files produced by this
// Swift compiler.
//===----------------------------------------------------------------------===//
#ifndef LANGUAGE_FEATURE
# error define LANGUAGE_FEATURE before including Features.def
#endif
// A feature that's both suppressible and experimental.
// Delegates to whichever the includer defines.
#ifndef SUPPRESSIBLE_EXPERIMENTAL_FEATURE
# if defined(SUPPRESSIBLE_LANGUAGE_FEATURE) && \
defined(EXPERIMENTAL_FEATURE)
# error ambiguous defines when including Features.def
# elif defined(SUPPRESSIBLE_LANGUAGE_FEATURE)
# define SUPPRESSIBLE_EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd) \
SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, 0, #FeatureName)
# else
# define SUPPRESSIBLE_EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd) \
EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd)
# endif
#endif
// A feature that's both suppressible and upcoming.
// Delegates to whichever the includer defines.
#ifndef SUPPRESSIBLE_UPCOMING_FEATURE
# if defined(SUPPRESSIBLE_UPCOMING_FEATURE) && \
defined(UPCOMING_FEATURE)
# error ambiguous defines when including Features.def
# elif defined(SUPPRESSIBLE_LANGUAGE_FEATURE)
# define SUPPRESSIBLE_UPCOMING_FEATURE(FeatureName, SENumber, Version) \
SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, #FeatureName)
# else
# define SUPPRESSIBLE_UPCOMING_FEATURE(FeatureName, SENumber, Version) \
UPCOMING_FEATURE(FeatureName, SENumber, Version)
# endif
#endif
#ifndef SUPPRESSIBLE_LANGUAGE_FEATURE
# define SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, Description) \
LANGUAGE_FEATURE(FeatureName, SENumber, Description)
#endif
// A feature that's both conditionally-suppressible and experimental.
// Delegates to whichever the includer defines.
#ifndef CONDITIONALLY_SUPPRESSIBLE_EXPERIMENTAL_FEATURE
# if defined(CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE) && \
defined(EXPERIMENTAL_FEATURE)
# error ambiguous defines when including Features.def
# elif defined(CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE)
# define CONDITIONALLY_SUPPRESSIBLE_EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd) \
CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, 0, #FeatureName)
# else
# define CONDITIONALLY_SUPPRESSIBLE_EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd) \
EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd)
# endif
#endif
#ifndef CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE
# define CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, Description) \
LANGUAGE_FEATURE(FeatureName, SENumber, Description)
#endif
#ifndef UPCOMING_FEATURE
# define UPCOMING_FEATURE(FeatureName, SENumber, Version) \
LANGUAGE_FEATURE(FeatureName, SENumber, #FeatureName)
#endif
#ifndef EXPERIMENTAL_FEATURE
// Warning: setting `AvailableInProd` to `true` on a feature means that the flag
// cannot be dropped in the future.
# define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd) \
LANGUAGE_FEATURE(FeatureName, 0, #FeatureName)
#endif
#ifndef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
# define EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE(FeatureName, AvailableInProd) \
EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd)
#endif
#ifndef BASELINE_LANGUAGE_FEATURE
# define BASELINE_LANGUAGE_FEATURE(FeatureName, SENumber, Description) \
LANGUAGE_FEATURE(FeatureName, SENumber, Description)
#endif
BASELINE_LANGUAGE_FEATURE(AsyncAwait, 296, "async/await")
BASELINE_LANGUAGE_FEATURE(EffectfulProp, 310, "Effectful properties")
BASELINE_LANGUAGE_FEATURE(MarkerProtocol, 0, "@_marker protocol")
BASELINE_LANGUAGE_FEATURE(Actors, 0, "actors")
BASELINE_LANGUAGE_FEATURE(ConcurrentFunctions, 0, "@concurrent functions")
LANGUAGE_FEATURE(RethrowsProtocol, 0, "@rethrows protocol")
BASELINE_LANGUAGE_FEATURE(GlobalActors, 316, "Global actors")
BASELINE_LANGUAGE_FEATURE(BuiltinJob, 0, "Builtin.Job type")
BASELINE_LANGUAGE_FEATURE(Sendable, 0, "Sendable and @Sendable")
BASELINE_LANGUAGE_FEATURE(BuiltinExecutor, 0, "Builtin.Executor type")
BASELINE_LANGUAGE_FEATURE(BuiltinContinuation, 0, "Continuation builtins")
BASELINE_LANGUAGE_FEATURE(BuiltinHopToActor, 0, "Builtin.HopToActor")
BASELINE_LANGUAGE_FEATURE(BuiltinTaskGroupWithArgument, 0, "TaskGroup builtins")
BASELINE_LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute")
BASELINE_LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute")
LANGUAGE_FEATURE(BuiltinBuildTaskExecutorRef, 0, "TaskExecutor-building builtins")
BASELINE_LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins")
LANGUAGE_FEATURE(BuiltinBuildComplexEqualityExecutor, 0, "Executor-building for 'complexEquality executor' builtins")
BASELINE_LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin")
BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "Task create in task group builtin with extra flags")
LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroupWithExecutor, 0, "Task create in task group builtin with extra flags")
LANGUAGE_FEATURE(BuiltinCreateAsyncDiscardingTaskInGroup, 0, "Task create in discarding task group builtin, accounting for the Void return type")
BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncTaskWithExecutor, 0, "Task create builtin with extra executor preference")
LANGUAGE_FEATURE(BuiltinCreateAsyncDiscardingTaskInGroupWithExecutor, 0, "Task create in discarding task group with extra executor preference")
BASELINE_LANGUAGE_FEATURE(BuiltinStackAlloc, 0, "Builtin.stackAlloc")
LANGUAGE_FEATURE(BuiltinUnprotectedStackAlloc, 0, "Builtin.unprotectedStackAlloc")
LANGUAGE_FEATURE(BuiltinAllocVector, 0, "Builtin.allocVector")
BASELINE_LANGUAGE_FEATURE(BuiltinTaskRunInline, 0, "Builtin.taskRunInline")
BASELINE_LANGUAGE_FEATURE(BuiltinUnprotectedAddressOf, 0, "Builtin.unprotectedAddressOf")
LANGUAGE_FEATURE(NewCxxMethodSafetyHeuristics, 0, "Only import C++ methods that return pointers (projections) on owned types as unsafe")
SUPPRESSIBLE_LANGUAGE_FEATURE(SpecializeAttributeWithAvailability, 0, "@_specialize attribute with availability")
BASELINE_LANGUAGE_FEATURE(BuiltinAssumeAlignment, 0, "Builtin.assumeAlignment")
BASELINE_LANGUAGE_FEATURE(BuiltinCreateTaskGroupWithFlags, 0, "Builtin.createTaskGroupWithFlags")
BASELINE_LANGUAGE_FEATURE(UnsafeInheritExecutor, 0, "@_unsafeInheritExecutor")
SUPPRESSIBLE_LANGUAGE_FEATURE(PrimaryAssociatedTypes2, 346, "Primary associated types")
BASELINE_LANGUAGE_FEATURE(UnavailableFromAsync, 0, "@_unavailableFromAsync")
BASELINE_LANGUAGE_FEATURE(NoAsyncAvailability, 340, "@available(*, noasync)")
SUPPRESSIBLE_LANGUAGE_FEATURE(AssociatedTypeAvailability, 0, "Availability on associated types")
SUPPRESSIBLE_LANGUAGE_FEATURE(AsyncSequenceFailure, 0, "Failure associated type on AsyncSequence and AsyncIteratorProtocol")
BASELINE_LANGUAGE_FEATURE(BuiltinIntLiteralAccessors, 368, "Builtin.IntLiteral accessors")
LANGUAGE_FEATURE(Macros, 0, "Macros")
LANGUAGE_FEATURE(FreestandingExpressionMacros, 382, "Expression macros")
LANGUAGE_FEATURE(AttachedMacros, 389, "Attached macros")
LANGUAGE_FEATURE(ExtensionMacros, 402, "Extension macros")
LANGUAGE_FEATURE(MoveOnly, 390, "noncopyable types")
LANGUAGE_FEATURE(MoveOnlyResilientTypes, 390, "non-@frozen noncopyable types with library evolution")
LANGUAGE_FEATURE(ParameterPacks, 393, "Value and type parameter packs")
SUPPRESSIBLE_LANGUAGE_FEATURE(LexicalLifetimes, 0, "@_eagerMove/@_noEagerMove/@_lexicalLifetimes annotations")
LANGUAGE_FEATURE(FreestandingMacros, 397, "freestanding declaration macros")
SUPPRESSIBLE_LANGUAGE_FEATURE(RetroactiveAttribute, 364, "@retroactive")
SUPPRESSIBLE_LANGUAGE_FEATURE(ExtensionMacroAttr, 0, "@attached(extension)")
LANGUAGE_FEATURE(TypedThrows, 413, "Typed throws")
CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE(OptionalIsolatedParameters, 420, "Optional isolated parameters")
SUPPRESSIBLE_LANGUAGE_FEATURE(Extern, 0, "@_extern")
LANGUAGE_FEATURE(ExpressionMacroDefaultArguments, 422, "Expression macro as caller-side default argument")
LANGUAGE_FEATURE(BuiltinStoreRaw, 0, "Builtin.storeRaw")
LANGUAGE_FEATURE(BuiltinCreateTask, 0, "Builtin.createTask and Builtin.createDiscardingTask")
SUPPRESSIBLE_LANGUAGE_FEATURE(AssociatedTypeImplements, 0, "@_implements on associated types")
LANGUAGE_FEATURE(BuiltinAddressOfRawLayout, 0, "Builtin.addressOfRawLayout")
LANGUAGE_FEATURE(MoveOnlyPartialConsumption, 429, "Partial consumption of noncopyable values")
LANGUAGE_FEATURE(BitwiseCopyable, 426, "BitwiseCopyable protocol")
SUPPRESSIBLE_LANGUAGE_FEATURE(NoncopyableGenerics, 427, "Noncopyable generics")
SUPPRESSIBLE_LANGUAGE_FEATURE(ConformanceSuppression, 426, "Suppressible inferred conformances")
SUPPRESSIBLE_LANGUAGE_FEATURE(BitwiseCopyable2, 426, "BitwiseCopyable feature")
LANGUAGE_FEATURE(BodyMacros, 415, "Function body macros")
// Swift 6
UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
UPCOMING_FEATURE(ForwardTrailingClosures, 286, 6)
UPCOMING_FEATURE(StrictConcurrency, 0337, 6)
UPCOMING_FEATURE(BareSlashRegexLiterals, 354, 6)
UPCOMING_FEATURE(DeprecateApplicationMain, 383, 6)
UPCOMING_FEATURE(ImportObjcForwardDeclarations, 384, 6)
UPCOMING_FEATURE(DisableOutwardActorInference, 401, 6)
UPCOMING_FEATURE(IsolatedDefaultValues, 411, 6)
UPCOMING_FEATURE(GlobalConcurrency, 412, 6)
UPCOMING_FEATURE(InferSendableFromCaptures, 418, 6)
UPCOMING_FEATURE(ImplicitOpenExistentials, 352, 6)
UPCOMING_FEATURE(RegionBasedIsolation, 414, 6)
UPCOMING_FEATURE(DynamicActorIsolation, 423, 6)
UPCOMING_FEATURE(NonfrozenEnumExhaustivity, 192, 6)
UPCOMING_FEATURE(GlobalActorIsolatedTypesUsability, 0434, 6)
UPCOMING_FEATURE(BorrowingSwitch, 432, 6)
UPCOMING_FEATURE(TransferringArgsAndResults, 430, 6)
SUPPRESSIBLE_UPCOMING_FEATURE(SendingArgsAndResults, 430, 6)
// Swift 7
UPCOMING_FEATURE(ExistentialAny, 335, 7)
UPCOMING_FEATURE(InternalImportsByDefault, 409, 7)
EXPERIMENTAL_FEATURE(StaticAssert, false)
EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)
EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
EXPERIMENTAL_FEATURE(CodeItemMacros, false)
EXPERIMENTAL_FEATURE(PreambleMacros, false)
EXPERIMENTAL_FEATURE(TupleConformances, false)
EXPERIMENTAL_FEATURE(FullTypedThrows, true)
// Whether to enable @_used and @_section attributes
EXPERIMENTAL_FEATURE(SymbolLinkageMarkers, true)
// Whether to compile scripts lazily in immediate mode
EXPERIMENTAL_FEATURE(LazyImmediate, false)
// FIXME: MoveOnlyClasses is not intended to be in production,
// but our tests currently rely on it, and we want to run those
// tests in non-asserts builds too.
EXPERIMENTAL_FEATURE(MoveOnlyClasses, true)
EXPERIMENTAL_FEATURE(NoImplicitCopy, true)
EXPERIMENTAL_FEATURE(OldOwnershipOperatorSpellings, true)
EXPERIMENTAL_FEATURE(MoveOnlyEnumDeinits, true)
EXPERIMENTAL_FEATURE(MoveOnlyTuples, true)
EXPERIMENTAL_FEATURE(MoveOnlyPartialReinitialization, true)
EXPERIMENTAL_FEATURE(OneWayClosureParameters, false)
EXPERIMENTAL_FEATURE(LayoutPrespecialization, true)
EXPERIMENTAL_FEATURE(AccessLevelOnImport, true)
/// Enables a module to allow non resilient access from other
/// modules within a package if built from source.
EXPERIMENTAL_FEATURE(AllowNonResilientAccessInPackage, false)
/// Enables a client module within a package to bypass resilient
/// access (at use site) to decls defined in another module within
/// the same package.
EXPERIMENTAL_FEATURE(ClientBypassResilientAccessInPackage, false)
/// Enables serialization of package decls and bodies and performs
/// CMO within a package.
EXPERIMENTAL_FEATURE(PackageCMO, false)
/// Whether to enable experimental layout string value witnesses
EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE(LayoutStringValueWitnesses, true)
EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE(LayoutStringValueWitnessesInstantiation, true)
/// Whether to enable experimental differentiable programming features:
/// `@differentiable` declaration attribute, etc.
EXPERIMENTAL_FEATURE(DifferentiableProgramming, false)
/// Whether to enable forward mode differentiation.
EXPERIMENTAL_FEATURE(ForwardModeDifferentiation, false)
/// Whether to enable experimental `AdditiveArithmetic` derived
/// conformances.
EXPERIMENTAL_FEATURE(AdditiveArithmeticDerivedConformances, false)
/// Whether Objective-C completion handler parameters are imported as
/// @Sendable.
EXPERIMENTAL_FEATURE(SendableCompletionHandlers, false)
/// Enables opaque type erasure without also enabling implict dynamic
EXPERIMENTAL_FEATURE(OpaqueTypeErasure, true)
/// Whether to perform round-trip testing of the Swift Swift parser.
EXPERIMENTAL_FEATURE(ParserRoundTrip, false)
/// Whether to perform validation of the parse tree produced by the Swift
/// Swift parser.
EXPERIMENTAL_FEATURE(ParserValidation, false)
/// Whether to emit diagnostics from the new parser first, and only emit
/// diagnostics from the existing parser when there are none from the new
/// parser.
EXPERIMENTAL_FEATURE(ParserDiagnostics, false)
/// Enables implicit some while also enabling existential `any`
EXPERIMENTAL_FEATURE(ImplicitSome, false)
/// Parse using the Swift (swift-syntax) parser and use ASTGen to generate the
/// corresponding syntax tree.
EXPERIMENTAL_FEATURE(ParserASTGen, false)
/// Parse using the Swift (swift-syntax) parser and use ASTGen to generate the
/// corresponding syntax tree.
EXPERIMENTAL_FEATURE(BuiltinMacros, false)
/// Import C++ class templates as semantically-meaningless symbolic
/// Swift types and C++ methods as symbolic functions with blank
/// signatures.
EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
/// Generate bindings for functions that 'throw' in the C++ section of the generated Clang header.
EXPERIMENTAL_FEATURE(GenerateBindingsForThrowingFunctionsInCXX, false)
/// Enable reference bindings.
EXPERIMENTAL_FEATURE(ReferenceBindings, true)
/// Enable the explicit 'import Builtin' and allow Builtin usage.
EXPERIMENTAL_FEATURE(BuiltinModule, true)
/// Enable extended callbacks (with additional parameters) to be used when the
/// "playground transform" is enabled.
EXPERIMENTAL_FEATURE(PlaygroundExtendedCallbacks, true)
/// Enable 'then' statements.
EXPERIMENTAL_FEATURE(ThenStatements, false)
/// Enable 'do' expressions.
EXPERIMENTAL_FEATURE(DoExpressions, false)
/// Enable implicitly treating the last expression in a function, closure,
/// and 'if'/'switch' expression as the result.
EXPERIMENTAL_FEATURE(ImplicitLastExprResults, false)
/// Enable the `@_rawLayout` attribute.
EXPERIMENTAL_FEATURE(RawLayout, true)
/// Enables the "embedded" swift mode (no runtime).
EXPERIMENTAL_FEATURE(Embedded, true)
/// Enables importing the Volatile module
EXPERIMENTAL_FEATURE(Volatile, true)
// Alias for NoncopyableGenerics
EXPERIMENTAL_FEATURE(NoncopyableGenerics2, true)
// Enables ~Copyable and ~Escapable annotations on associatedtype declarations.
EXPERIMENTAL_FEATURE(SuppressedAssociatedTypes, true)
/// Allow destructuring stored `let` bindings in structs.
EXPERIMENTAL_FEATURE(StructLetDestructuring, true)
/// Enable non-escapable type attributes and function attributes that support
/// lifetime-dependent results.
EXPERIMENTAL_FEATURE(NonescapableTypes, true)
/// Enable the `@_staticExclusiveOnly` attribute.
EXPERIMENTAL_FEATURE(StaticExclusiveOnly, true)
/// Enable the @extractConstantsFromMembers attribute.
EXPERIMENTAL_FEATURE(ExtractConstantsFromMembers, false)
/// Enables the FixedArray data type.
EXPERIMENTAL_FEATURE(FixedArrays, true)
// Group Main Actor Isolation Errors by Scope
EXPERIMENTAL_FEATURE(GroupActorErrors, true)
// Enable explicit isolation of closures.
EXPERIMENTAL_FEATURE(ClosureIsolation, true)
// Enable isolated(any) attribute on function types.
CONDITIONALLY_SUPPRESSIBLE_EXPERIMENTAL_FEATURE(IsolatedAny, true)
// Whether lookup of members respects the enclosing file's imports.
EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE(MemberImportVisibility, true)
// Alias for IsolatedAny
EXPERIMENTAL_FEATURE(IsolatedAny2, true)
// Enable @implementation on extensions of ObjC classes.
EXPERIMENTAL_FEATURE(ObjCImplementation, true)
// Enable @implementation on extensions of ObjC classes with non-fixed layout
// due to resilient stored properties. Requires OS support; this flag exists for
// staging purposes.
EXPERIMENTAL_FEATURE(ObjCImplementationWithResilientStorage, true)
// Enable @implementation on @_cdecl functions.
EXPERIMENTAL_FEATURE(CImplementation, true)
// Enable @sensitive attribute.
EXPERIMENTAL_FEATURE(Sensitive, true)
// Enable the stdlib @DebugDescription macro.
EXPERIMENTAL_FEATURE(DebugDescriptionMacro, true)
#undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
#undef EXPERIMENTAL_FEATURE
#undef UPCOMING_FEATURE
#undef BASELINE_LANGUAGE_FEATURE
#undef CONDITIONALLY_SUPPRESSIBLE_EXPERIMENTAL_FEATURE
#undef CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE
#undef SUPPRESSIBLE_EXPERIMENTAL_FEATURE
#undef SUPPRESSIBLE_UPCOMING_FEATURE
#undef SUPPRESSIBLE_LANGUAGE_FEATURE
#undef LANGUAGE_FEATURE
Reference in New Issue View Git Blame Copy Permalink