Remove the @Flag(default:) overload in favour of initialiser-only.

Author: Rob Amos

.gitignore

@@ -1,5 +1,5 @@
 .DS_Store
-/.build
+.build
 /build
 /.swiftpm
 /Packages

Sources/Vexil/Flag.swift

@@ -11,54 +11,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Creates a flag with the specified configuration.
-///
-/// All Flags must be initialised with a default value and a description.
-/// The default value is used when none of the sources on the `FlagPole`
-/// have a value specified for this flag. The description is used for future
-/// developer reference and in Vexlliographer to describe the flag.
-///
-/// The type that you wrap with `@Flag` must conform to `FlagValue`.
-///
-/// You can access flag details and observe flag value changes using a peer
-/// property prefixed with `$`.
-///
-/// ```swift
-/// @Flag(default: false, description: "My magical flag")
-/// var magicFlag: Bool
-///
-/// // Subscribe to flag updates
-/// for try await magic in $magicFlag {
-///     // Do magic thing
-/// }
-///
-/// // Also works with Combine
-/// $magicFlag
-///     .sink { magic in
-///         // Do magic thing
-///     }
-/// ```
-///
-/// - Parameters:
-///   - name:               An optional display name to give the flag. Only visible in flag editors like Vexillographer.
-///                         Default is to calculate one based on the property name.
-///   - keyStrategy:        An optional strategy to use when calculating the key name. The default is to use the `FlagPole`s strategy.
-///   - default:            The default value for this `Flag` should no sources have it set.
-///   - description:        A description of this flag. Used in flag editors like Vexillographer,
-///                         and also for future developer context.
-///   - display:            How the flag should be displayed in Vexillographer. Defaults to `.default`,
-///                         you can set it to `.hidden` to hide the flag.
-///
-@attached(accessor)
-@attached(peer, names: prefixed(`$`))
-public macro Flag<Value: FlagValue>(
-    name: StaticString? = nil,
-    keyStrategy: VexilConfiguration.FlagKeyStrategy = .default,
-    default initialValue: Value,
-    description: StaticString,
-    display: FlagDisplayOption = .default
-) = #externalMacro(module: "VexilMacros", type: "FlagMacro")
-
 /// Creates a flag with the specified configuration.
 ///
 /// All Flags must be initialised via the property and include a description.

Sources/Vexil/Vexil.docc/DefiningFlags.md

@@ -69,14 +69,14 @@ import Vexil
 
 struct NormalFlags: FlagContainer {
 
-    @Flag(default: 10, "This is a demonstration Int flag")
-    var myIntFlag: Int
+    @Flag("This is a demonstration Int flag")
+    var myIntFlag = 10
 
-    @Flag(default: 0.5, "This is a demonstration Double flag")
-    var myDoubleFlag: Double
+    @Flag("This is a demonstration Double flag")
+    var myDoubleFlag = 0.5
 
-    @Flag(default: "Placeholder", "This is a demonstration String flag")
-    var myStringFlag: String
+    @Flag("This is a demonstration String flag")
+    var myStringFlag = "Placeholder""
 
 }
 ```
@@ -98,8 +98,8 @@ enum MyTheme: String, FlagValue, CaseIterable {
 
 struct ThemeFlags {
 
-    @Flag(default: .blue, "The theme to use for the app")
-    var currentTheme: MyTheme
+    @Flag("The theme to use for the app")
+    var currentTheme = MyTheme.blue
     
 }
 ```
@@ -117,8 +117,8 @@ struct MyStruct: FlagValue, Codable {
 
 struct TestFlags: FlagContainer {
 
-    @Flag(defaultValue: MyStruct(property1: "abc123", property2: 123, property3: "🤯"), description: "...")
-    var testFlag: MyStruct
+    @Flag(description: "...")
+    var testFlag = MyStruct(property1: "abc123", property2: 123, property3: "🤯")
     
 }
 ```

Sources/Vexil/Vexil.docc/FlagKeys.md

@@ -73,8 +73,8 @@ print(flagPole.subgroup.secondSubgroup.$myAwesomeFlag.key)
 Sometimes though you want to override how a specific flag calculates its key. Vexil allows you to pass in a ``Flag/CodingKeyStrategy`` when you declare your ``Flag`` to alter how its key is calculated:
 
 ```swift
-@Flag(codingKeyStrategy: .snakecase, default: false, description: "My Awesome Flag")
-var myAwesomeFlag: Bool
+@Flag(codingKeyStrategy: .snakecase, description: "My Awesome Flag")
+var myAwesomeFlag = false
 
 // Key is "subgroup.second-subgroup.my_awesome_flag"
 ```
@@ -86,8 +86,8 @@ That would leave `myAwesomeFlag` calculating its key as `"subgroup.second-subgro
 You can also go for a manually specified key instead of a calculated one using a ``Flag/CodingKeyStrategy`` of `.customKey("my-key")`:
 
 ```swift
-@Flag(codingKeyStrategy: .customKey("my-key"), default: false, description: "My Awesome Flag")
-var myAwesomeFlag: Bool
+@Flag(codingKeyStrategy: .customKey("my-key"), description: "My Awesome Flag")
+var myAwesomeFlag = false
 
 // Key is "subgroup.second-subgroup.my-key"
 ```
@@ -97,8 +97,8 @@ var myAwesomeFlag: Bool
 But sometimes your ``FlagValueSource`` doesn't play nice, or the people naming flags in the backend don't provide the same structure that you want your local flags to be in. You can instead set a manual key path. In this case the ``FlagPole`` will ignore the location of the ``Flag`` in the flag structure and will just use the key you specify.
 
 ```swift
-@Flag(codingKeyStrategy: .customKeyPath("my-key"), default: false, description: "My Awesome Flag")
-var myAwesomeFlag: Bool
+@Flag(codingKeyStrategy: .customKeyPath("my-key"), description: "My Awesome Flag")
+var myAwesomeFlag = false
 
 // Key is "my-key"
 ```
@@ -110,7 +110,7 @@ While a ``FlagGroup`` doesn't have an explicit key of its own, it does form part
 ```swift
 struct MyFlags: FlagContainer {
 
-    @FlagGroup(description: "A subgroup of flags")
+    @FlagGroup("A subgroup of flags")
     var subgroup: Subgroup
 
 }

Sources/Vexil/Vexil.docc/Migration2-3.md

@@ -57,10 +57,10 @@ struct MyFlags: FlagContainer {
 @FlagContainer
 struct MyFlags {
 
-    @Flag(default: false, description: "Test flag that does something magical")
-    var testFlag: Bool
+    @Flag("Test flag that does something magical")
+    var testFlag = false
 
-    @FlagGroup(description: "Some nested flags")
+    @FlagGroup("Some nested flags")
     var nested: NestedFlags
 
 }
@@ -117,12 +117,19 @@ FlagContainer.init(
 Under Vexil 3, this is now a macro:
 
 ```swift
+// Full macro
 public macro FlagGroup(
     name: StaticString? = nil,
     keyStrategy: VexilConfiguration.GroupKeyStrategy = .default,
     description: StaticString,
     display: VexilDisplayOption = .navigation
 )
+
+// Or shorter
+public macro FlagGroup(
+    _ description: StaticString,
+    display: VexilDisplayOption = .navigation
+)
 ```
 
 As you can see the changes here purely for simplification: `codingKeyStrategy`
@@ -136,14 +143,14 @@ could set your description to `.hidden`; now you pass `.hidden` to display:
 var nested: NestedFlags
 
 // Vexil 3
-@FlagGroup(description: "Nested flags", display: .hidden)
+@FlagGroup("Nested flags", display: .hidden)
 var nested: NestedFlags
 ```
 
 ### Flags
 
 Much like Flag Groups, the `@Flag` property wrapper was replaced with the
-``Flag(name:keyStrategy:default:description:)`` macro, with simplified parameters:
+``Flag(name:keyStrategy:description:display:)`` macro, with simplified parameters:
 
 ```swift
 // Vexil 2
@@ -156,9 +163,6 @@ var magic = false
 
 // Vexil 3
 
-@Flag(default: false, description: "Flag that enables magic")
-var magic: Bool
-
 @Flag("Flag that enables magic")
 var magic = false
 ```
@@ -184,18 +188,9 @@ init(
 )
 ```
 
-Both approaches are available via the `@Flag` macro:
+With the `@Flag` macro we now require the property initialiser.
 
 ```swift
-/// Explicit default parameter
-macro Flag<Value: FlagValue>(
-    name: StaticString? = nil,
-    keyStrategy: VexilConfiguration.FlagKeyStrategy = .default,
-    default initialValue: Value,
-    description: StaticString,
-    display: FlagDisplayOption = .default
-)
-
 /// Sets default via property initialiser
 macro Flag(
     name: StaticString? = nil,
@@ -211,6 +206,19 @@ macro Flag(_ description: StaticString)
 Same as with the `FlagGroup`, the `codingKeyStrategy` parameter has been shortened
 to `keyStrategy`, and the ability to hide flags has been moved to the `display` property.
 
+>Note:
+>
+>The `default:` parameter option was removed as it included a large foot-gun with cryptic
+>error message. It was decided to remove this potential issue by aligning with
+>[swift-argument-parser](https://github.com/apple/swift-argument-parser)'s approach.
+>
+>As the macro is type-checked without reference to the attached property's type you get errors like:
+>
+>```swift
+>@Flag(default: .enumCase, description: "")             // compiler error: Type of `.enumCase` cannot be inferred.
+>var myFlag: MyEnum
+>```
+
 ## Flag Pole Observation
 
 Under Vexil 2, every time a `FlagValueSource` reported a flag value change, we would

Sources/Vexil/Vexil.docc/Vexil.md

@@ -148,14 +148,14 @@ let snapshot = flagPole.snapshot()
 ### Flags
 
 - <doc:DefiningFlags>
-- ``Flag(name:keyStrategy:default:description:display:)``
 - ``Flag(name:keyStrategy:description:display:)``
 - ``Flag(_:)``
 - ``FlagValue``
 
 ### Flag Groups
 
 - ``FlagGroup(name:keyStrategy:description:display:)``
+- ``FlagGroup(_:display:)``
 - ``FlagContainer(generateEquatable:)``
 
 ### Snapshots

Sources/VexilMacros/FlagContainerMacro.swift

@@ -170,7 +170,7 @@ extension FlagContainerMacro: ExtensionMacro {
                                         ])
                                     }
                                 }
-                                ExprSyntax("lhs.\(lastBinding) == rhs.\(lastBinding)")
+                                ExprSyntax("lhs.\(lastBinding.trimmed) == rhs.\(lastBinding.trimmed)")
                             }
                         }
                         .with(\.modifiers, Array(scopes) + [ DeclModifierSyntax(name: .keyword(.static)) ])

Sources/VexilMacros/FlagMacro.swift

@@ -50,15 +50,19 @@ public struct FlagMacro {
             let property = declaration.as(VariableDeclSyntax.self),
             let binding = property.bindings.first,
             let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier,
-            let type = binding.typeAnnotation?.type ?? binding.inferredType,
             binding.accessorBlock == nil
         else {
             throw DiagnosticsError(diagnostics: [ .init(node: node, message: Diagnostic.onlySimpleVariableSupported) ])
         }
+
+        guard let type = binding.typeAnnotation?.type ?? binding.inferredType else {
+            throw DiagnosticsError(diagnostics: [ .init(node: node, message: Diagnostic.onlySimpleVariableSupported) ])
+        }
+
         self.scopes = property.modifiers.scopeSyntax
 
         var defaultExprSyntax: ExprSyntax
-        if let defaultExpr = arguments[label: "default"]?.expression ?? binding.initializer?.value {
+        if let defaultExpr = binding.initializer?.value {
             defaultExprSyntax = defaultExpr
         } else if binding.typeAnnotation?.type.is(OptionalTypeSyntax.self) == true {
             defaultExprSyntax = ExprSyntax(NilLiteralExprSyntax())
@@ -192,6 +196,7 @@ extension FlagMacro {
         case missingDefaultValue
         case missingDescription
         case onlySimpleVariableSupported
+        case typeCouldNotBeInferred
 
         var message: String {
             switch self {
@@ -200,6 +205,7 @@ extension FlagMacro {
             case .missingDefaultValue:          "Could not infer the default value. Initialise the property or set the default: parameter."
             case .missingDescription:           "Description parameter missing."
             case .onlySimpleVariableSupported:  "Only simple single-binding properties supported."
+            case .typeCouldNotBeInferred:       "Type could not be inferred from the initializer. Specify a type explicitly."
             }
         }
 
@@ -210,6 +216,7 @@ extension FlagMacro {
             case .missingDefaultValue:          MessageID(domain: "com.unsignedapps.vexil.flagMacro", id: "missingDefaultValue")
             case .missingDescription:           MessageID(domain: "com.unsignedapps.vexil.flagMacro", id: "missingDescription")
             case .onlySimpleVariableSupported:  MessageID(domain: "com.unsignedapps.vexil.flagMacro", id: "onlySimpleVariableSupported")
+            case .typeCouldNotBeInferred:       MessageID(domain: "com.unsignedapps.vexil.flagMacro", id: "typeCouldNotBeInferred")
             }
         }
 

Sources/VexilMacros/Utilities/PatternBindingSyntax.swift

@@ -21,23 +21,24 @@ extension PatternBindingSyntax {
         }
 
         if let initializer {
-            if initializer.value.is(BooleanLiteralExprSyntax.self) {
+            let value = initializer.value.as(ForceUnwrapExprSyntax.self)?.expression ?? initializer.value
+            if value.is(BooleanLiteralExprSyntax.self) {
                 return "Bool"
-            } else if initializer.value.is(IntegerLiteralExprSyntax.self) {
+            } else if value.is(IntegerLiteralExprSyntax.self) {
                 return "Int"
-            } else if initializer.value.is(StringLiteralExprSyntax.self) {
+            } else if value.is(StringLiteralExprSyntax.self) {
                 return "String"
-            } else if initializer.value.is(FloatLiteralExprSyntax.self) {
+            } else if value.is(FloatLiteralExprSyntax.self) {
                 return "Double"
-            } else if initializer.value.is(RegexLiteralExprSyntax.self) {
+            } else if value.is(RegexLiteralExprSyntax.self) {
                 return "Regex"
-            } else if let function = initializer.value.as(FunctionCallExprSyntax.self) {
+            } else if let function = value.as(FunctionCallExprSyntax.self) {
                 if let identifier = function.calledExpression.as(DeclReferenceExprSyntax.self) {
                     return TypeSyntax(IdentifierTypeSyntax(name: identifier.baseName))
                 } else if let memberAccess = function.calledExpression.as(MemberAccessExprSyntax.self)?.asMemberTypeSyntax() {
                     return TypeSyntax(memberAccess.baseType)
                 }
-            } else if let memberAccess = initializer.value.as(MemberAccessExprSyntax.self)?.asMemberTypeSyntax() {
+            } else if let memberAccess = value.as(MemberAccessExprSyntax.self)?.asMemberTypeSyntax() {
                 return TypeSyntax(memberAccess.baseType)
             }
         }