Specify default options in configurations only (#5020)

Source/SwiftLintBuiltInRules/Rules/Idiomatic/FileNameNoSpaceRule.swift

@@ -2,10 +2,7 @@ import Foundation
 import SourceKittenFramework
 
 struct FileNameNoSpaceRule: ConfigurationProviderRule, OptInRule, SourceKitFreeRule {
-    var configuration = FileNameNoSpaceConfiguration(
+    var configuration = FileNameNoSpaceConfiguration()
-        severity: .warning,
-        excluded: []
-    )
 
     static let description = RuleDescription(
         identifier: "file_name_no_space",

Source/SwiftLintBuiltInRules/Rules/Idiomatic/FileNameRule.swift

@@ -1,13 +1,7 @@
 import SwiftSyntax
 
 struct FileNameRule: ConfigurationProviderRule, OptInRule, SourceKitFreeRule {
-    var configuration = FileNameConfiguration(
+    var configuration = FileNameConfiguration()
-        severity: .warning,
-        excluded: ["main.swift", "LinuxMain.swift"],
-        prefixPattern: "",
-        suffixPattern: "\\+.*",
-        nestedTypeSeparator: "."
-    )
 
     static let description = RuleDescription(
         identifier: "file_name",

Source/SwiftLintBuiltInRules/Rules/Idiomatic/ImplicitlyUnwrappedOptionalRule.swift

@@ -1,10 +1,7 @@
 import SwiftSyntax
 
 struct ImplicitlyUnwrappedOptionalRule: SwiftSyntaxRule, ConfigurationProviderRule, OptInRule {
-    var configuration = ImplicitlyUnwrappedOptionalConfiguration(
+    var configuration = ImplicitlyUnwrappedOptionalConfiguration()
-        mode: .allExceptIBOutlets,
-        severityConfiguration: SeverityConfiguration(.warning)
-    )
 
     static let description = RuleDescription(
         identifier: "implicitly_unwrapped_optional",

Source/SwiftLintBuiltInRules/Rules/Lint/PrivateOutletRule.swift

@@ -1,7 +1,7 @@
 import SwiftSyntax
 
 struct PrivateOutletRule: SwiftSyntaxRule, OptInRule, ConfigurationProviderRule {
-    var configuration = PrivateOutletRuleConfiguration(allowPrivateSet: false)
+    var configuration = PrivateOutletRuleConfiguration()
 
     static let description = RuleDescription(
         identifier: "private_outlet",

Source/SwiftLintBuiltInRules/Rules/Lint/PrivateUnitTestRule.swift

@@ -2,12 +2,7 @@ import Foundation
 import SwiftSyntax
 
 struct PrivateUnitTestRule: SwiftSyntaxCorrectableRule, ConfigurationProviderRule, CacheDescriptionProvider {
-    var configuration: PrivateUnitTestConfiguration = {
+    var configuration = PrivateUnitTestConfiguration()
-        var configuration = PrivateUnitTestConfiguration(identifier: "private_unit_test")
-        configuration.message = "Unit test marked `private` will not be run by XCTest."
-        configuration.regex = regex("XCTestCase")
-        return configuration
-    }()
 
     var cacheDescription: String {
         return configuration.cacheDescription

Source/SwiftLintBuiltInRules/Rules/Lint/UnusedDeclarationRule.swift

@@ -16,11 +16,7 @@ struct UnusedDeclarationRule: ConfigurationProviderRule, AnalyzerRule, Collectin
 
     typealias FileInfo = FileUSRs
 
-    var configuration = UnusedDeclarationConfiguration(
+    var configuration = UnusedDeclarationConfiguration()
-        severity: .error,
-        includePublicAndOpen: false,
-        relatedUSRsToSkip: ["s:7SwiftUI15PreviewProviderP"]
-    )
 
     static let description = RuleDescription(
         identifier: "unused_declaration",

Source/SwiftLintBuiltInRules/Rules/Lint/UnusedImportRule.swift

@@ -4,8 +4,7 @@ import SourceKittenFramework
 private let moduleToLog = ProcessInfo.processInfo.environment["SWIFTLINT_LOG_MODULE_USAGE"]
 
 struct UnusedImportRule: CorrectableRule, ConfigurationProviderRule, AnalyzerRule {
-    var configuration = UnusedImportConfiguration(severity: .warning, requireExplicitImports: false,
+    var configuration = UnusedImportConfiguration()
-                                                  allowedTransitiveImports: [], alwaysKeepImports: [])
 
     static let description = RuleDescription(
         identifier: "unused_import",

Source/SwiftLintBuiltInRules/Rules/Metrics/CyclomaticComplexityRule.swift

@@ -2,7 +2,7 @@ import Foundation
 import SourceKittenFramework
 
 struct CyclomaticComplexityRule: ASTRule, ConfigurationProviderRule {
-    var configuration = CyclomaticComplexityConfiguration(warning: 10, error: 20)
+    var configuration = CyclomaticComplexityConfiguration()
 
     static let description = RuleDescription(
         identifier: "cyclomatic_complexity",

Source/SwiftLintBuiltInRules/Rules/Metrics/FileLengthRule.swift

@@ -1,7 +1,7 @@
 import SourceKittenFramework
 
 struct FileLengthRule: ConfigurationProviderRule {
-    var configuration = FileLengthRuleConfiguration(warning: 400, error: 1000)
+    var configuration = FileLengthRuleConfiguration()
 
     static let description = RuleDescription(
         identifier: "file_length",

Source/SwiftLintBuiltInRules/Rules/Metrics/FunctionParameterCountRule.swift

@@ -1,7 +1,7 @@
 import SwiftSyntax
 
 struct FunctionParameterCountRule: SwiftSyntaxRule, ConfigurationProviderRule {
-    var configuration = FunctionParameterCountConfiguration(warning: 5, error: 8)
+    var configuration = FunctionParameterCountConfiguration()
 
     static let description = RuleDescription(
         identifier: "function_parameter_count",

Source/SwiftLintBuiltInRules/Rules/Metrics/LineLengthRule.swift

@@ -2,7 +2,7 @@ import Foundation
 import SourceKittenFramework
 
 struct LineLengthRule: ConfigurationProviderRule {
-    var configuration = LineLengthConfiguration(warning: 120, error: 200)
+    var configuration = LineLengthConfiguration()
 
     private let commentKinds = SyntaxKind.commentKinds
     private let nonCommentKinds = SyntaxKind.allKinds.subtracting(SyntaxKind.commentKinds)

Source/SwiftLintBuiltInRules/Rules/Metrics/NestingRule.swift

@@ -1,10 +1,7 @@
 import SourceKittenFramework
 
 struct NestingRule: ConfigurationProviderRule {
-    var configuration = NestingConfiguration(typeLevelWarning: 1,
+    var configuration = NestingConfiguration()
-                                             typeLevelError: nil,
-                                             functionLevelWarning: 2,
-                                             functionLevelError: nil)
 
     static let description = RuleDescription(
         identifier: "nesting",

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/CyclomaticComplexityConfiguration.swift

@@ -12,7 +12,7 @@ struct CyclomaticComplexityConfiguration: RuleConfiguration, Equatable {
             ", \(ConfigurationKey.ignoresCaseStatements.rawValue): \(ignoresCaseStatements)"
     }
 
-    static let defaultComplexityStatements: Set<StatementKind> = [
+    private static let defaultComplexityStatements: Set<StatementKind> = [
         .forEach,
         .if,
         .guard,
@@ -22,11 +22,10 @@ struct CyclomaticComplexityConfiguration: RuleConfiguration, Equatable {
         .case
     ]
 
-    private(set) var length: SeverityLevelsConfiguration
+    private(set) var length = SeverityLevelsConfiguration(warning: 10, error: 20)
+    private(set) var complexityStatements = Self.defaultComplexityStatements
 
-    private(set) var complexityStatements: Set<StatementKind>
+    private(set) var ignoresCaseStatements = false {
-
-    private(set) var ignoresCaseStatements: Bool {
         didSet {
             if ignoresCaseStatements {
                 complexityStatements.remove(.case)
@@ -40,12 +39,6 @@ struct CyclomaticComplexityConfiguration: RuleConfiguration, Equatable {
         return length.params
     }
 
-    init(warning: Int, error: Int?, ignoresCaseStatements: Bool = false) {
-        self.length = SeverityLevelsConfiguration(warning: warning, error: error)
-        self.complexityStatements = Self.defaultComplexityStatements
-        self.ignoresCaseStatements = ignoresCaseStatements
-    }
-
     mutating func apply(configuration: Any) throws {
         if let configurationArray = [Int].array(of: configuration),
             configurationArray.isNotEmpty {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FileLengthRuleConfiguration.swift

@@ -5,19 +5,14 @@ private enum ConfigurationKey: String {
 }
 
 struct FileLengthRuleConfiguration: RuleConfiguration, Equatable {
-    private(set) var ignoreCommentOnlyLines: Bool
+    private(set) var severityConfiguration = SeverityLevelsConfiguration(warning: 400, error: 1000)
-    private(set) var severityConfiguration: SeverityLevelsConfiguration
+    private(set) var ignoreCommentOnlyLines = false
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" +
             ", \(ConfigurationKey.ignoreCommentOnlyLines.rawValue): \(ignoreCommentOnlyLines)"
     }
 
-    init(warning: Int, error: Int?, ignoreCommentOnlyLines: Bool = false) {
-        self.ignoreCommentOnlyLines = ignoreCommentOnlyLines
-        self.severityConfiguration = SeverityLevelsConfiguration(warning: warning, error: error)
-    }
-
     mutating func apply(configuration: Any) throws {
         if let configurationArray = [Int].array(of: configuration),
             configurationArray.isNotEmpty {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FileNameConfiguration.swift

@@ -7,20 +7,11 @@ struct FileNameConfiguration: SeverityBasedRuleConfiguration, Equatable {
             "nested_type_separator: \(nestedTypeSeparator)"
     }
 
-    private(set) var severityConfiguration: SeverityConfiguration
+    private(set) var severityConfiguration = SeverityConfiguration.warning
-    private(set) var excluded: Set<String>
+    private(set) var excluded = Set<String>(["main.swift", "LinuxMain.swift"])
-    private(set) var prefixPattern: String
+    private(set) var prefixPattern = ""
-    private(set) var suffixPattern: String
+    private(set) var suffixPattern = "\\+.*"
-    private(set) var nestedTypeSeparator: String
+    private(set) var nestedTypeSeparator = "."
-
-    init(severity: ViolationSeverity, excluded: [String] = [],
-         prefixPattern: String = "", suffixPattern: String = "\\+.*", nestedTypeSeparator: String = ".") {
-        self.severityConfiguration = SeverityConfiguration(severity)
-        self.excluded = Set(excluded)
-        self.prefixPattern = prefixPattern
-        self.suffixPattern = suffixPattern
-        self.nestedTypeSeparator = nestedTypeSeparator
-    }
 
     mutating func apply(configuration: Any) throws {
         guard let configurationDict = configuration as? [String: Any] else {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FileNameNoSpaceConfiguration.swift

@@ -4,13 +4,8 @@ struct FileNameNoSpaceConfiguration: SeverityBasedRuleConfiguration, Equatable {
             "excluded: \(excluded.sorted())"
     }
 
-    private(set) var severityConfiguration: SeverityConfiguration
+    private(set) var severityConfiguration: SeverityConfiguration = .warning
-    private(set) var excluded: Set<String>
+    private(set) var excluded = Set<String>()
-
-    init(severity: ViolationSeverity, excluded: [String] = []) {
-        self.severityConfiguration = SeverityConfiguration(severity)
-        self.excluded = Set(excluded)
-    }
 
     mutating func apply(configuration: Any) throws {
         guard let configurationDict = configuration as? [String: Any] else {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FunctionParameterCountConfiguration.swift

@@ -5,19 +5,14 @@ private enum ConfigurationKey: String {
 }
 
 struct FunctionParameterCountConfiguration: RuleConfiguration, Equatable {
-    private(set) var ignoresDefaultParameters: Bool
+    private(set) var ignoresDefaultParameters = true
-    private(set) var severityConfiguration: SeverityLevelsConfiguration
+    private(set) var severityConfiguration = SeverityLevelsConfiguration(warning: 5, error: 8)
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" +
         ", \(ConfigurationKey.ignoresDefaultParameters.rawValue): \(ignoresDefaultParameters)"
     }
 
-    init(warning: Int, error: Int?, ignoresDefaultParameters: Bool = true) {
-        self.ignoresDefaultParameters = ignoresDefaultParameters
-        self.severityConfiguration = SeverityLevelsConfiguration(warning: warning, error: error)
-    }
-
     mutating func apply(configuration: Any) throws {
         if let configurationArray = [Int].array(of: configuration),
             configurationArray.isNotEmpty {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/ImplicitlyUnwrappedOptionalConfiguration.swift

@@ -14,13 +14,8 @@ enum ImplicitlyUnwrappedOptionalModeConfiguration: String {
 }
 
 struct ImplicitlyUnwrappedOptionalConfiguration: SeverityBasedRuleConfiguration, Equatable {
-    private(set) var severityConfiguration: SeverityConfiguration
+    private(set) var mode = ImplicitlyUnwrappedOptionalModeConfiguration.allExceptIBOutlets
-    private(set) var mode: ImplicitlyUnwrappedOptionalModeConfiguration
+    private(set) var severityConfiguration = SeverityConfiguration.warning
-
-    init(mode: ImplicitlyUnwrappedOptionalModeConfiguration, severityConfiguration: SeverityConfiguration) {
-        self.mode = mode
-        self.severityConfiguration = severityConfiguration
-    }
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" +

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/IndentationWidthConfiguration.swift

@@ -7,25 +7,11 @@ struct IndentationWidthConfiguration: SeverityBasedRuleConfiguration, Equatable
             + "include_multiline_strings: \(includeMultilineStrings)"
     }
 
-    private(set) var severityConfiguration: SeverityConfiguration
+    private(set) var severityConfiguration = SeverityConfiguration.warning
-    private(set) var indentationWidth: Int
+    private(set) var indentationWidth = 4
-    private(set) var includeComments: Bool
+    private(set) var includeComments = true
-    private(set) var includeCompilerDirectives: Bool
+    private(set) var includeCompilerDirectives = true
-    private(set) var includeMultilineStrings: Bool
+    private(set) var includeMultilineStrings = true
-
-    init(
-        severity: ViolationSeverity,
-        indentationWidth: Int,
-        includeComments: Bool,
-        includeCompilerDirectives: Bool,
-        includeMultilineStrings: Bool
-    ) {
-        self.severityConfiguration = SeverityConfiguration(severity)
-        self.indentationWidth = indentationWidth
-        self.includeComments = includeComments
-        self.includeCompilerDirectives = includeCompilerDirectives
-        self.includeMultilineStrings = includeMultilineStrings
-    }
 
     mutating func apply(configuration: Any) throws {
         guard let configurationDict = configuration as? [String: Any] else {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/LineLengthConfiguration.swift

@@ -1,16 +1,3 @@
-struct LineLengthRuleOptions: OptionSet {
-    let rawValue: Int
-
-    init(rawValue: Int = 0) {
-        self.rawValue = rawValue
-    }
-
-    static let ignoreURLs = Self(rawValue: 1 << 0)
-    static let ignoreFunctionDeclarations = Self(rawValue: 1 << 1)
-    static let ignoreComments = Self(rawValue: 1 << 2)
-    static let ignoreInterpolatedStrings = Self(rawValue: 1 << 3)
-}
-
 private enum ConfigurationKey: String {
     case warning = "warning"
     case error = "error"
@@ -29,24 +16,16 @@ struct LineLengthConfiguration: RuleConfiguration, Equatable {
                ", ignores_interpolated_strings: \(ignoresInterpolatedStrings)"
     }
 
-    var length: SeverityLevelsConfiguration
+    private(set) var length = SeverityLevelsConfiguration(warning: 120, error: 200)
-    var ignoresURLs: Bool
+    private(set) var ignoresURLs = false
-    var ignoresFunctionDeclarations: Bool
+    private(set) var ignoresFunctionDeclarations = false
-    var ignoresComments: Bool
+    private(set) var ignoresComments = false
-    var ignoresInterpolatedStrings: Bool
+    private(set) var ignoresInterpolatedStrings = false
 
     var params: [RuleParameter<Int>] {
         return length.params
     }
 
-    init(warning: Int, error: Int?, options: LineLengthRuleOptions = []) {
-        self.length = SeverityLevelsConfiguration(warning: warning, error: error)
-        self.ignoresURLs = options.contains(.ignoreURLs)
-        self.ignoresFunctionDeclarations = options.contains(.ignoreFunctionDeclarations)
-        self.ignoresComments = options.contains(.ignoreComments)
-        self.ignoresInterpolatedStrings = options.contains(.ignoreInterpolatedStrings)
-    }
-
     mutating func apply(configuration: Any) throws {
         if applyArray(configuration: configuration) {
             return

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/NameConfiguration.swift

@@ -12,11 +12,11 @@ struct NameConfiguration: RuleConfiguration, Equatable {
         return output
     }
 
-    var minLength: SeverityLevelsConfiguration
+    private(set) var minLength: SeverityLevelsConfiguration
-    var maxLength: SeverityLevelsConfiguration
+    private(set) var maxLength: SeverityLevelsConfiguration
-    var excludedRegularExpressions: Set<NSRegularExpression>
+    private(set) var excludedRegularExpressions: Set<NSRegularExpression>
+    private(set) var validatesStartWithLowercase: SeverityConfiguration?
     private var allowedSymbolsSet: Set<String>
-    var validatesStartWithLowercase: SeverityConfiguration?
 
     var minLengthThreshold: Int {
         return max(minLength.warning, minLength.error ?? minLength.warning)

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/NestingConfiguration.swift

@@ -6,22 +6,10 @@ struct NestingConfiguration: RuleConfiguration, Equatable {
             + ", (always_allow_one_type_in_functions) \(alwaysAllowOneTypeInFunctions)"
     }
 
-    var typeLevel: SeverityLevelsConfiguration
+    private(set) var typeLevel = SeverityLevelsConfiguration(warning: 1)
-    var functionLevel: SeverityLevelsConfiguration
+    private(set) var functionLevel = SeverityLevelsConfiguration(warning: 2)
-    var checkNestingInClosuresAndStatements: Bool
+    private(set) var checkNestingInClosuresAndStatements = true
-    var alwaysAllowOneTypeInFunctions: Bool
+    private(set) var alwaysAllowOneTypeInFunctions = false
-
-    init(typeLevelWarning: Int,
-         typeLevelError: Int?,
-         functionLevelWarning: Int,
-         functionLevelError: Int?,
-         checkNestingInClosuresAndStatements: Bool = true,
-         alwaysAllowOneTypeInFunctions: Bool = false) {
-        self.typeLevel = SeverityLevelsConfiguration(warning: typeLevelWarning, error: typeLevelError)
-        self.functionLevel = SeverityLevelsConfiguration(warning: functionLevelWarning, error: functionLevelError)
-        self.checkNestingInClosuresAndStatements = checkNestingInClosuresAndStatements
-        self.alwaysAllowOneTypeInFunctions = alwaysAllowOneTypeInFunctions
-    }
 
     mutating func apply(configuration: Any) throws {
         guard let configurationDict = configuration as? [String: Any] else {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrefixedConstantRuleConfiguration.swift

@@ -1,15 +1,11 @@
 struct PrefixedConstantRuleConfiguration: SeverityBasedRuleConfiguration, Equatable {
-    var severityConfiguration = SeverityConfiguration(.warning)
+    private(set) var severityConfiguration = SeverityConfiguration(.warning)
-    var onlyPrivateMembers = false
+    private(set) var onlyPrivateMembers = false
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" + ", only_private: \(onlyPrivateMembers)"
     }
 
-    init(onlyPrivateMembers: Bool) {
-        self.onlyPrivateMembers = onlyPrivateMembers
-    }
-
     mutating func apply(configuration: Any) throws {
         guard let configuration = configuration as? [String: Any] else {
             throw Issue.unknownConfiguration

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrivateOutletRuleConfiguration.swift

@@ -1,15 +1,11 @@
 struct PrivateOutletRuleConfiguration: SeverityBasedRuleConfiguration, Equatable {
     private(set) var severityConfiguration = SeverityConfiguration(.warning)
-    var allowPrivateSet = false
+    private(set) var allowPrivateSet = false
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" + ", allow_private_set: \(allowPrivateSet)"
     }
 
-    init(allowPrivateSet: Bool) {
-        self.allowPrivateSet = allowPrivateSet
-    }
-
     mutating func apply(configuration: Any) throws {
         guard let configuration = configuration as? [String: Any] else {
             throw Issue.unknownConfiguration

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrivateUnitTestConfiguration.swift

@@ -1,12 +1,12 @@
 import Foundation
+import SwiftLintCore
 
 struct PrivateUnitTestConfiguration: SeverityBasedRuleConfiguration, Equatable, CacheDescriptionProvider {
-    let identifier: String
+    private(set) var name: String?
-    var name: String?
+    private(set) var message = "Unit test marked `private` will not be run by XCTest."
-    var message = "Regex matched."
+    private(set) var regex = SwiftLintCore.regex("XCTestCase")
-    var regex: NSRegularExpression!
+    private(set) var included: NSRegularExpression?
-    var included: NSRegularExpression?
+    private(set) var severityConfiguration = SeverityConfiguration(.warning)
-    var severityConfiguration = SeverityConfiguration(.warning)
 
     var consoleDescription: String {
         return "\(severity.rawValue): \(regex.pattern)"
@@ -14,7 +14,7 @@ struct PrivateUnitTestConfiguration: SeverityBasedRuleConfiguration, Equatable,
 
     var cacheDescription: String {
         let jsonObject: [String] = [
-            identifier,
+            "private_unit_test",
             name ?? "",
             message,
             regex.pattern,
@@ -28,10 +28,6 @@ struct PrivateUnitTestConfiguration: SeverityBasedRuleConfiguration, Equatable,
         queuedFatalError("Could not serialize private unit test configuration for cache")
     }
 
-    init(identifier: String) {
-        self.identifier = identifier
-    }
-
     mutating func apply(configuration: Any) throws {
         guard let configurationDict = configuration as? [String: Any] else {
             throw Issue.unknownConfiguration

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/StatementModeConfiguration.swift

@@ -18,8 +18,8 @@ struct StatementConfiguration: SeverityBasedRuleConfiguration, Equatable {
             "(severity) \(severityConfiguration.consoleDescription)"
     }
 
-    var statementMode: StatementModeConfiguration
+    private(set) var statementMode = StatementModeConfiguration.default
-    var severityConfiguration: SeverityConfiguration
+    private(set) var severityConfiguration = SeverityConfiguration.warning
 
     mutating func apply(configuration: Any) throws {
         guard let configurationDict = configuration as? [String: Any] else {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/TrailingWhitespaceConfiguration.swift

@@ -1,7 +1,7 @@
 struct TrailingWhitespaceConfiguration: SeverityBasedRuleConfiguration, Equatable {
-    var severityConfiguration = SeverityConfiguration(.warning)
+    private(set) var severityConfiguration = SeverityConfiguration(.warning)
-    var ignoresEmptyLines = false
+    private(set) var ignoresEmptyLines = false
-    var ignoresComments = true
+    private(set) var ignoresComments = true
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" +
@@ -9,11 +9,6 @@ struct TrailingWhitespaceConfiguration: SeverityBasedRuleConfiguration, Equatabl
             ", ignores_comments: \(ignoresComments)"
     }
 
-    init(ignoresEmptyLines: Bool, ignoresComments: Bool) {
-        self.ignoresEmptyLines = ignoresEmptyLines
-        self.ignoresComments = ignoresComments
-    }
-
     mutating func apply(configuration: Any) throws {
         guard let configuration = configuration as? [String: Any] else {
             throw Issue.unknownConfiguration

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/UnusedDeclarationConfiguration.swift

@@ -5,9 +5,9 @@ private enum ConfigurationKey: String {
 }
 
 struct UnusedDeclarationConfiguration: SeverityBasedRuleConfiguration, Equatable {
-    private(set) var includePublicAndOpen: Bool
+    private(set) var severityConfiguration = SeverityConfiguration.error
-    private(set) var severityConfiguration: SeverityConfiguration
+    private(set) var includePublicAndOpen = false
-    private(set) var relatedUSRsToSkip: Set<String>
+    private(set) var relatedUSRsToSkip = Set(["s:7SwiftUI15PreviewProviderP"])
 
     var consoleDescription: String {
         return "\(ConfigurationKey.severity.rawValue): \(severityConfiguration.severity.rawValue), " +
@@ -15,12 +15,6 @@ struct UnusedDeclarationConfiguration: SeverityBasedRuleConfiguration, Equatable
             "\(ConfigurationKey.relatedUSRsToSkip.rawValue): \(relatedUSRsToSkip.sorted())"
     }
 
-    init(severity: ViolationSeverity, includePublicAndOpen: Bool, relatedUSRsToSkip: Set<String>) {
-        self.includePublicAndOpen = includePublicAndOpen
-        self.severityConfiguration = SeverityConfiguration(severity)
-        self.relatedUSRsToSkip = relatedUSRsToSkip
-    }
-
     mutating func apply(configuration: Any) throws {
         guard let configDict = configuration as? [String: Any], configDict.isNotEmpty else {
             throw Issue.unknownConfiguration

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/UnusedImportConfiguration.swift

@@ -29,20 +29,11 @@ struct UnusedImportConfiguration: SeverityBasedRuleConfiguration, Equatable {
         ].joined(separator: ", ")
     }
 
-    private(set) var severityConfiguration: SeverityConfiguration
+    private(set) var severityConfiguration = SeverityConfiguration.warning
-    private(set) var requireExplicitImports: Bool
+    private(set) var requireExplicitImports = false
-    private(set) var allowedTransitiveImports: [TransitiveModuleConfiguration]
+    private(set) var allowedTransitiveImports = [TransitiveModuleConfiguration]()
     /// A set of modules to never remove the imports of.
-    private(set) var alwaysKeepImports: [String]
+    private(set) var alwaysKeepImports = [String]()
-
-    init(severity: ViolationSeverity, requireExplicitImports: Bool,
-         allowedTransitiveImports: [TransitiveModuleConfiguration],
-         alwaysKeepImports: [String]) {
-        self.severityConfiguration = SeverityConfiguration(severity)
-        self.requireExplicitImports = requireExplicitImports
-        self.allowedTransitiveImports = allowedTransitiveImports
-        self.alwaysKeepImports = alwaysKeepImports
-    }
 
     mutating func apply(configuration: Any) throws {
         guard let configurationDict = configuration as? [String: Any] else {

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/UnusedOptionalBindingConfiguration.swift

@@ -1,15 +1,11 @@
 struct UnusedOptionalBindingConfiguration: SeverityBasedRuleConfiguration, Equatable {
     private(set) var severityConfiguration = SeverityConfiguration(.warning)
-    private(set) var ignoreOptionalTry: Bool
+    private(set) var ignoreOptionalTry = false
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" + ", ignore_optional_try: \(ignoreOptionalTry)"
     }
 
-    init(ignoreOptionalTry: Bool) {
-        self.ignoreOptionalTry = ignoreOptionalTry
-    }
-
     mutating func apply(configuration: Any) throws {
         guard let configuration = configuration as? [String: Any] else {
             throw Issue.unknownConfiguration

Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/VerticalWhitespaceConfiguration.swift

@@ -1,15 +1,11 @@
 struct VerticalWhitespaceConfiguration: SeverityBasedRuleConfiguration, Equatable {
     private(set) var severityConfiguration = SeverityConfiguration(.warning)
-    private(set) var maxEmptyLines: Int
+    private(set) var maxEmptyLines = 1
 
     var consoleDescription: String {
         return "severity: \(severityConfiguration.consoleDescription)" + ", max_empty_lines: \(maxEmptyLines)"
     }
 
-    init(maxEmptyLines: Int) {
-        self.maxEmptyLines = maxEmptyLines
-    }
-
     mutating func apply(configuration: Any) throws {
         guard let configuration = configuration as? [String: Any] else {
             throw Issue.unknownConfiguration

Source/SwiftLintBuiltInRules/Rules/Style/IndentationWidthRule.swift

@@ -16,13 +16,8 @@ struct IndentationWidthRule: ConfigurationProviderRule, OptInRule {
     }
 
     // MARK: - Properties
-    var configuration = IndentationWidthConfiguration(
+    var configuration = IndentationWidthConfiguration()
-        severity: .warning,
+
-        indentationWidth: 4,
-        includeComments: true,
-        includeCompilerDirectives: true,
-        includeMultilineStrings: true
-    )
     static let description = RuleDescription(
         identifier: "indentation_width",
         name: "Indentation Width",

Source/SwiftLintBuiltInRules/Rules/Style/PrefixedTopLevelConstantRule.swift

@@ -1,7 +1,7 @@
 import SwiftSyntax
 
 struct PrefixedTopLevelConstantRule: SwiftSyntaxRule, OptInRule, ConfigurationProviderRule {
-    var configuration = PrefixedConstantRuleConfiguration(onlyPrivateMembers: false)
+    var configuration = PrefixedConstantRuleConfiguration()
 
     static let description = RuleDescription(
         identifier: "prefixed_toplevel_constant",

Source/SwiftLintBuiltInRules/Rules/Style/StatementPositionRule.swift

@@ -2,8 +2,7 @@ import Foundation
 import SourceKittenFramework
 
 struct StatementPositionRule: CorrectableRule, ConfigurationProviderRule {
-    var configuration = StatementConfiguration(statementMode: .default,
+    var configuration = StatementConfiguration()
-                                               severityConfiguration: SeverityConfiguration(.warning))
 
     static let description = RuleDescription(
         identifier: "statement_position",

Source/SwiftLintBuiltInRules/Rules/Style/TrailingWhitespaceRule.swift

@@ -2,8 +2,7 @@ import Foundation
 import SourceKittenFramework
 
 struct TrailingWhitespaceRule: CorrectableRule, ConfigurationProviderRule {
-    var configuration = TrailingWhitespaceConfiguration(ignoresEmptyLines: false,
+    var configuration = TrailingWhitespaceConfiguration()
-                                                        ignoresComments: true)
 
     static let description = RuleDescription(
         identifier: "trailing_whitespace",

Source/SwiftLintBuiltInRules/Rules/Style/UnusedOptionalBindingRule.swift

@@ -1,7 +1,7 @@
 import SwiftSyntax
 
 struct UnusedOptionalBindingRule: SwiftSyntaxRule, ConfigurationProviderRule {
-    var configuration = UnusedOptionalBindingConfiguration(ignoreOptionalTry: false)
+    var configuration = UnusedOptionalBindingConfiguration()
 
     static let description = RuleDescription(
         identifier: "unused_optional_binding",

Source/SwiftLintBuiltInRules/Rules/Style/VerticalWhitespaceRule.swift

@@ -4,7 +4,7 @@ import SourceKittenFramework
 private let defaultDescriptionReason = "Limit vertical whitespace to a single empty line"
 
 struct VerticalWhitespaceRule: CorrectableRule, ConfigurationProviderRule {
-    var configuration = VerticalWhitespaceConfiguration(maxEmptyLines: 1)
+    var configuration = VerticalWhitespaceConfiguration()
 
     static let description = RuleDescription(
         identifier: "vertical_whitespace",

Tests/SwiftLintFrameworkTests/CyclomaticComplexityConfigurationTests.swift

@@ -6,25 +6,31 @@ class CyclomaticComplexityConfigurationTests: SwiftLintTestCase {
         let warning = 10
         let error = 30
         let level = SeverityLevelsConfiguration(warning: warning, error: error)
-        let configuration1 = CyclomaticComplexityConfiguration(warning: warning, error: error)
+        let configuration1 = CyclomaticComplexityConfiguration(length: level)
         XCTAssertEqual(configuration1.length, level)
 
         let length2 = SeverityLevelsConfiguration(warning: warning, error: nil)
-        let configuration2 = CyclomaticComplexityConfiguration(warning: warning, error: nil)
+        let configuration2 = CyclomaticComplexityConfiguration(length: length2)
         XCTAssertEqual(configuration2.length, length2)
     }
 
     func testCyclomaticComplexityConfigurationInitializerSetsIgnoresCaseStatements() {
-        let configuration1 = CyclomaticComplexityConfiguration(warning: 10, error: 30,
+        let configuration1 = CyclomaticComplexityConfiguration(
-                                                               ignoresCaseStatements: true)
+            length: SeverityLevelsConfiguration(warning: 10, error: 30),
+            ignoresCaseStatements: true
+        )
         XCTAssertTrue(configuration1.ignoresCaseStatements)
 
-        let configuration2 = CyclomaticComplexityConfiguration(warning: 0, error: 30)
+        let configuration2 = CyclomaticComplexityConfiguration(
+            length: SeverityLevelsConfiguration(warning: 10, error: 30)
+        )
         XCTAssertFalse(configuration2.ignoresCaseStatements)
     }
 
     func testCyclomaticComplexityConfigurationApplyConfigurationWithDictionary() throws {
-        var configuration = CyclomaticComplexityConfiguration(warning: 0, error: 0)
+        var configuration = CyclomaticComplexityConfiguration(
+            length: SeverityLevelsConfiguration(warning: 0, error: 0)
+        )
 
         let warning1 = 10
         let error1 = 30
@@ -60,7 +66,9 @@ class CyclomaticComplexityConfigurationTests: SwiftLintTestCase {
         ]
 
         for badConfig in badConfigs {
-            var configuration = CyclomaticComplexityConfiguration(warning: 100, error: 150)
+            var configuration = CyclomaticComplexityConfiguration(
+                length: SeverityLevelsConfiguration(warning: 100, error: 150)
+            )
             checkError(Issue.unknownConfiguration) {
                 try configuration.apply(configuration: badConfig)
             }
@@ -68,11 +76,23 @@ class CyclomaticComplexityConfigurationTests: SwiftLintTestCase {
     }
 
     func testCyclomaticComplexityConfigurationCompares() {
-        let config1 = CyclomaticComplexityConfiguration(warning: 10, error: 30)
+        let config1 = CyclomaticComplexityConfiguration(
-        let config2 = CyclomaticComplexityConfiguration(warning: 10, error: 30, ignoresCaseStatements: true)
+            length: SeverityLevelsConfiguration(warning: 10, error: 30)
-        let config3 = CyclomaticComplexityConfiguration(warning: 10, error: 30, ignoresCaseStatements: false)
+        )
-        let config4 = CyclomaticComplexityConfiguration(warning: 10, error: 40)
+        let config2 = CyclomaticComplexityConfiguration(
-        let config5 = CyclomaticComplexityConfiguration(warning: 20, error: 30)
+            length: SeverityLevelsConfiguration(warning: 10, error: 30),
+            ignoresCaseStatements: true
+        )
+        let config3 = CyclomaticComplexityConfiguration(
+            length: SeverityLevelsConfiguration(warning: 10, error: 30),
+            ignoresCaseStatements: false
+        )
+        let config4 = CyclomaticComplexityConfiguration(
+            length: SeverityLevelsConfiguration(warning: 10, error: 40)
+        )
+        let config5 = CyclomaticComplexityConfiguration(
+            length: SeverityLevelsConfiguration(warning: 20, error: 30)
+        )
         XCTAssertNotEqual(config1, config2)
         XCTAssertEqual(config1, config3)
         XCTAssertNotEqual(config1, config4)

Tests/SwiftLintFrameworkTests/LineLengthConfigurationTests.swift

@@ -2,87 +2,66 @@
 import XCTest
 
 class LineLengthConfigurationTests: SwiftLintTestCase {
-    func testLineLengthConfigurationInitializerSetsLength() {
+    private let severityLevels = SeverityLevelsConfiguration(warning: 100, error: 150)
-        let warning = 100
-        let error = 150
-        let length1 = SeverityLevelsConfiguration(warning: warning, error: error)
-        let configuration1 = LineLengthConfiguration(warning: warning,
-                                                     error: error)
-        XCTAssertEqual(configuration1.length, length1)
 
-        let length2 = SeverityLevelsConfiguration(warning: warning, error: nil)
+    func testLineLengthConfigurationInitializerSetsLength() {
-        let configuration2 = LineLengthConfiguration(warning: warning,
+        let configuration1 = LineLengthConfiguration(length: severityLevels)
-                                                     error: nil)
+        XCTAssertEqual(configuration1.length, severityLevels)
+
+        let length2 = SeverityLevelsConfiguration(warning: 100, error: nil)
+        let configuration2 = LineLengthConfiguration(length: length2)
         XCTAssertEqual(configuration2.length, length2)
     }
 
     func testLineLengthConfigurationInitialiserSetsIgnoresURLs() {
-        let configuration1 = LineLengthConfiguration(warning: 100,
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresURLs: true)
-                                                     error: 150,
-                                                     options: [.ignoreURLs])
 
         XCTAssertTrue(configuration1.ignoresURLs)
 
-        let configuration2 = LineLengthConfiguration(warning: 100,
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
-                                                     error: 150)
         XCTAssertFalse(configuration2.ignoresURLs)
     }
 
     func testLineLengthConfigurationInitialiserSetsIgnoresFunctionDeclarations() {
-        let configuration1 = LineLengthConfiguration(warning: 100,
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresFunctionDeclarations: true)
-                                                     error: 150,
-                                                     options: [.ignoreFunctionDeclarations])
-
         XCTAssertTrue(configuration1.ignoresFunctionDeclarations)
 
-        let configuration2 = LineLengthConfiguration(warning: 100,
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
-                                                     error: 150)
         XCTAssertFalse(configuration2.ignoresFunctionDeclarations)
     }
 
     func testLineLengthConfigurationInitialiserSetsIgnoresComments() {
-        let configuration1 = LineLengthConfiguration(warning: 100,
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresComments: true)
-                                                     error: 150,
-                                                     options: [.ignoreComments])
-
         XCTAssertTrue(configuration1.ignoresComments)
 
-        let configuration2 = LineLengthConfiguration(warning: 100,
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
-                                                     error: 150)
         XCTAssertFalse(configuration2.ignoresComments)
     }
 
     func testLineLengthConfigurationInitialiserSetsIgnoresInterpolatedStrings() {
-        let configuration1 = LineLengthConfiguration(warning: 100,
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresInterpolatedStrings: true)
-                                                     error: 150,
-                                                     options: [.ignoreInterpolatedStrings])
-
         XCTAssertTrue(configuration1.ignoresInterpolatedStrings)
 
-        let configuration2 = LineLengthConfiguration(warning: 100,
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
-                                                     error: 150)
         XCTAssertFalse(configuration2.ignoresInterpolatedStrings)
     }
 
     func testLineLengthConfigurationParams() {
         let warning = 13
         let error = 10
-        let configuration = LineLengthConfiguration(warning: warning,
+        let configuration = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: warning, error: error))
-                                                    error: error)
         let params = [RuleParameter(severity: .error, value: error), RuleParameter(severity: .warning, value: warning)]
         XCTAssertEqual(configuration.params, params)
     }
 
     func testLineLengthConfigurationPartialParams() {
-        let warning = 13
+        let configuration = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 13))
-        let configuration = LineLengthConfiguration(warning: warning,
-                                                    error: nil)
         XCTAssertEqual(configuration.params, [RuleParameter(severity: .warning, value: 13)])
     }
 
     func testLineLengthConfigurationThrowsOnBadConfig() {
         let config = "unknown"
-        var configuration = LineLengthConfiguration(warning: 100, error: 150)
+        var configuration = LineLengthConfiguration(length: severityLevels)
         checkError(Issue.unknownConfiguration) {
             try configuration.apply(configuration: config)
         }
@@ -96,7 +75,7 @@ class LineLengthConfigurationTests: SwiftLintTestCase {
         ]
 
         for badConfig in badConfigs {
-            var configuration = LineLengthConfiguration(warning: 100, error: 150)
+            var configuration = LineLengthConfiguration(length: severityLevels)
             checkError(Issue.unknownConfiguration) {
                 try configuration.apply(configuration: badConfig)
             }
@@ -104,7 +83,7 @@ class LineLengthConfigurationTests: SwiftLintTestCase {
     }
 
     func testLineLengthConfigurationApplyConfigurationWithArray() {
-        var configuration = LineLengthConfiguration(warning: 0, error: 0)
+        var configuration = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 0, error: 0))
 
         let warning1 = 100
         let error1 = 100
@@ -127,7 +106,7 @@ class LineLengthConfigurationTests: SwiftLintTestCase {
     }
 
     func testLineLengthConfigurationApplyConfigurationWithDictionary() {
-        var configuration = LineLengthConfiguration(warning: 0, error: 0)
+        var configuration = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 0, error: 0))
 
         let warning1 = 100
         let error1 = 100
@@ -172,26 +151,28 @@ class LineLengthConfigurationTests: SwiftLintTestCase {
     }
 
     func testLineLengthConfigurationCompares() {
-        let configuration1 = LineLengthConfiguration(warning: 100, error: 100)
+        let configuration1 = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 100, error: 100))
-        let configuration2 = LineLengthConfiguration(warning: 100,
+        let configuration2 = LineLengthConfiguration(
-                                                     error: 100,
+            length: SeverityLevelsConfiguration(warning: 100, error: 100),
-                                                     options: [.ignoreFunctionDeclarations,
+            ignoresFunctionDeclarations: true,
-                                                               .ignoreComments])
+            ignoresComments: true
+        )
         XCTAssertNotEqual(configuration1, configuration2)
 
-        let configuration3 = LineLengthConfiguration(warning: 100, error: 200)
+        let configuration3 = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 100, error: 200))
         XCTAssertNotEqual(configuration1, configuration3)
 
-        let configuration4 = LineLengthConfiguration(warning: 200, error: 100)
+        let configuration4 = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 200, error: 200))
         XCTAssertNotEqual(configuration1, configuration4)
 
-        let configuration5 = LineLengthConfiguration(warning: 100, error: 100)
+        let configuration5 = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 100, error: 100))
         XCTAssertEqual(configuration1, configuration5)
 
-        let configuration6 = LineLengthConfiguration(warning: 100,
+        let configuration6 = LineLengthConfiguration(
-                                                     error: 100,
+            length: SeverityLevelsConfiguration(warning: 100, error: 100),
-                                                     options: [.ignoreFunctionDeclarations,
+            ignoresFunctionDeclarations: true,
-                                                               .ignoreComments])
+            ignoresComments: true
+        )
         XCTAssertEqual(configuration2, configuration6)
     }
 }

Tests/SwiftLintFrameworkTests/NameConfigurationTests.swift

@@ -54,26 +54,20 @@ class NameConfigurationTests: SwiftLintTestCase {
     }
 
     func testNameConfigurationMinLengthThreshold() {
-        var nameConfig = NameConfiguration(minLengthWarning: 7,
+        let nameConfig = NameConfiguration(minLengthWarning: 7,
                                            minLengthError: 17,
                                            maxLengthWarning: 0,
                                            maxLengthError: 0,
                                            excluded: [])
         XCTAssertEqual(nameConfig.minLengthThreshold, 17)
-
-        nameConfig.minLength.error = nil
-        XCTAssertEqual(nameConfig.minLengthThreshold, 7)
     }
 
     func testNameConfigurationMaxLengthThreshold() {
-        var nameConfig = NameConfiguration(minLengthWarning: 0,
+        let nameConfig = NameConfiguration(minLengthWarning: 0,
                                            minLengthError: 0,
                                            maxLengthWarning: 17,
                                            maxLengthError: 7,
                                            excluded: [])
         XCTAssertEqual(nameConfig.maxLengthThreshold, 7)
-
-        nameConfig.maxLength.error = nil
-        XCTAssertEqual(nameConfig.maxLengthThreshold, 17)
     }
 }

Tests/SwiftLintFrameworkTests/RuleConfigurationTests.swift

@@ -4,6 +4,11 @@ import SourceKittenFramework
 import XCTest
 
 class RuleConfigurationTests: SwiftLintTestCase {
+    private let defaultNestingConfiguration = NestingConfiguration(
+        typeLevel: SeverityLevelsConfiguration(warning: 0),
+        functionLevel: SeverityLevelsConfiguration(warning: 0)
+    )
+
     func testNestingConfigurationSetsCorrectly() {
         let config = [
             "type_level": [
@@ -15,10 +20,7 @@ class RuleConfigurationTests: SwiftLintTestCase {
             "check_nesting_in_closures_and_statements": false,
             "always_allow_one_type_in_functions": true
         ] as [String: Any]
-        var nestingConfig = NestingConfiguration(typeLevelWarning: 0,
+        var nestingConfig = defaultNestingConfiguration
-                                                 typeLevelError: nil,
-                                                 functionLevelWarning: 0,
-                                                 functionLevelError: nil)
         do {
             try nestingConfig.apply(configuration: config)
             XCTAssertEqual(nestingConfig.typeLevel.warning, 7)
@@ -34,10 +36,7 @@ class RuleConfigurationTests: SwiftLintTestCase {
 
     func testNestingConfigurationThrowsOnBadConfig() {
         let config = 17
-        var nestingConfig = NestingConfiguration(typeLevelWarning: 0,
+        var nestingConfig = defaultNestingConfiguration
-                                                 typeLevelError: nil,
-                                                 functionLevelWarning: 0,
-                                                 functionLevelError: nil)
         checkError(Issue.unknownConfiguration) {
             try nestingConfig.apply(configuration: config)
         }
@@ -201,9 +200,11 @@ class RuleConfigurationTests: SwiftLintTestCase {
     }
 
     func testTrailingWhitespaceConfigurationApplyConfigurationUpdatesSeverityConfiguration() {
-        var configuration = TrailingWhitespaceConfiguration(ignoresEmptyLines: false,
+        var configuration = TrailingWhitespaceConfiguration(
-                                                            ignoresComments: true)
+            severityConfiguration: .warning,
-        configuration.severityConfiguration.severity = .warning
+            ignoresEmptyLines: false,
+            ignoresComments: true
+        )
 
         do {
             try configuration.apply(configuration: ["severity": "error"])

Tests/SwiftLintFrameworkTests/UnusedDeclarationConfigurationTests.swift

@@ -4,7 +4,7 @@ import XCTest
 class UnusedDeclarationConfigurationTests: XCTestCase {
     func testParseConfiguration() throws {
         var testee = UnusedDeclarationConfiguration(
-            severity: .warning,
+            severityConfiguration: .warning,
             includePublicAndOpen: false,
             relatedUSRsToSkip: []
         )