Specify default options in configurations only (#5020)

2023-05-18 17:21:30 +02:00 · 2023-05-18 17:21:30 +02:00 · d938b2d3c3
parent 7fd22e0d6e
commit d938b2d3c3
42 changed files with 160 additions and 319 deletions
--- a/Source/SwiftLintBuiltInRules/Rules/Idiomatic/FileNameNoSpaceRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Idiomatic/FileNameNoSpaceRule.swift
@ -2,10 +2,7 @@ import Foundation
 import SourceKittenFramework

 struct FileNameNoSpaceRule: ConfigurationProviderRule, OptInRule, SourceKitFreeRule {
-    var configuration = FileNameNoSpaceConfiguration(
-        severity: .warning,
-        excluded: []
-    )
+    var configuration = FileNameNoSpaceConfiguration()

    static let description = RuleDescription(
        identifier: "file_name_no_space",
--- a/Source/SwiftLintBuiltInRules/Rules/Idiomatic/FileNameRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Idiomatic/FileNameRule.swift
@ -1,13 +1,7 @@
 import SwiftSyntax

 struct FileNameRule: ConfigurationProviderRule, OptInRule, SourceKitFreeRule {
-    var configuration = FileNameConfiguration(
-        severity: .warning,
-        excluded: ["main.swift", "LinuxMain.swift"],
-        prefixPattern: "",
-        suffixPattern: "\\+.*",
-        nestedTypeSeparator: "."
-    )
+    var configuration = FileNameConfiguration()

    static let description = RuleDescription(
        identifier: "file_name",
--- a/Source/SwiftLintBuiltInRules/Rules/Idiomatic/ImplicitlyUnwrappedOptionalRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Idiomatic/ImplicitlyUnwrappedOptionalRule.swift
@ -1,10 +1,7 @@
 import SwiftSyntax

 struct ImplicitlyUnwrappedOptionalRule: SwiftSyntaxRule, ConfigurationProviderRule, OptInRule {
-    var configuration = ImplicitlyUnwrappedOptionalConfiguration(
-        mode: .allExceptIBOutlets,
-        severityConfiguration: SeverityConfiguration(.warning)
-    )
+    var configuration = ImplicitlyUnwrappedOptionalConfiguration()

    static let description = RuleDescription(
        identifier: "implicitly_unwrapped_optional",
--- a/Source/SwiftLintBuiltInRules/Rules/Lint/PrivateOutletRule.swift
+++ b/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",
--- a/Source/SwiftLintBuiltInRules/Rules/Lint/PrivateUnitTestRule.swift
+++ b/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(identifier: "private_unit_test")
-        configuration.message = "Unit test marked `private` will not be run by XCTest."
-        configuration.regex = regex("XCTestCase")
-        return configuration
-    }()
+    var configuration = PrivateUnitTestConfiguration()

    var cacheDescription: String {
        return configuration.cacheDescription
--- a/Source/SwiftLintBuiltInRules/Rules/Lint/UnusedDeclarationRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Lint/UnusedDeclarationRule.swift
@ -16,11 +16,7 @@ struct UnusedDeclarationRule: ConfigurationProviderRule, AnalyzerRule, Collectin

    typealias FileInfo = FileUSRs

-    var configuration = UnusedDeclarationConfiguration(
-        severity: .error,
-        includePublicAndOpen: false,
-        relatedUSRsToSkip: ["s:7SwiftUI15PreviewProviderP"]
-    )
+    var configuration = UnusedDeclarationConfiguration()

    static let description = RuleDescription(
        identifier: "unused_declaration",
--- a/Source/SwiftLintBuiltInRules/Rules/Lint/UnusedImportRule.swift
+++ b/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,
-                                                  allowedTransitiveImports: [], alwaysKeepImports: [])
+    var configuration = UnusedImportConfiguration()

    static let description = RuleDescription(
        identifier: "unused_import",
--- a/Source/SwiftLintBuiltInRules/Rules/Metrics/CyclomaticComplexityRule.swift
+++ b/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",
--- a/Source/SwiftLintBuiltInRules/Rules/Metrics/FileLengthRule.swift
+++ b/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",
--- a/Source/SwiftLintBuiltInRules/Rules/Metrics/FunctionParameterCountRule.swift
+++ b/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",
--- a/Source/SwiftLintBuiltInRules/Rules/Metrics/LineLengthRule.swift
+++ b/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)
--- a/Source/SwiftLintBuiltInRules/Rules/Metrics/NestingRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Metrics/NestingRule.swift
@ -1,10 +1,7 @@
 import SourceKittenFramework

 struct NestingRule: ConfigurationProviderRule {
-    var configuration = NestingConfiguration(typeLevelWarning: 1,
-                                             typeLevelError: nil,
-                                             functionLevelWarning: 2,
-                                             functionLevelError: nil)
+    var configuration = NestingConfiguration()

    static let description = RuleDescription(
        identifier: "nesting",
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/CyclomaticComplexityConfiguration.swift
+++ b/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: Bool {
+    private(set) var ignoresCaseStatements = false {
        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 {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FileLengthRuleConfiguration.swift
+++ b/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
+    private(set) var severityConfiguration = SeverityLevelsConfiguration(warning: 400, error: 1000)
+    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 {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FileNameConfiguration.swift
+++ b/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 excluded: Set<String>
-    private(set) var prefixPattern: String
-    private(set) var suffixPattern: String
-    private(set) var nestedTypeSeparator: String
-
-    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
-    }
+    private(set) var severityConfiguration = SeverityConfiguration.warning
+    private(set) var excluded = Set<String>(["main.swift", "LinuxMain.swift"])
+    private(set) var prefixPattern = ""
+    private(set) var suffixPattern = "\\+.*"
+    private(set) var nestedTypeSeparator = "."

    mutating func apply(configuration: Any) throws {
        guard let configurationDict = configuration as? [String: Any] else {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FileNameNoSpaceConfiguration.swift
+++ b/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 excluded: Set<String>
-
-    init(severity: ViolationSeverity, excluded: [String] = []) {
-        self.severityConfiguration = SeverityConfiguration(severity)
-        self.excluded = Set(excluded)
-    }
+    private(set) var severityConfiguration: SeverityConfiguration = .warning
+    private(set) var excluded = Set<String>()

    mutating func apply(configuration: Any) throws {
        guard let configurationDict = configuration as? [String: Any] else {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/FunctionParameterCountConfiguration.swift
+++ b/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 severityConfiguration: SeverityLevelsConfiguration
+    private(set) var ignoresDefaultParameters = true
+    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 {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/ImplicitlyUnwrappedOptionalConfiguration.swift
+++ b/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
-
-    init(mode: ImplicitlyUnwrappedOptionalModeConfiguration, severityConfiguration: SeverityConfiguration) {
-        self.mode = mode
-        self.severityConfiguration = severityConfiguration
-    }
+    private(set) var mode = ImplicitlyUnwrappedOptionalModeConfiguration.allExceptIBOutlets
+    private(set) var severityConfiguration = SeverityConfiguration.warning

    var consoleDescription: String {
        return "severity: \(severityConfiguration.consoleDescription)" +
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/IndentationWidthConfiguration.swift
+++ b/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 indentationWidth: Int
-    private(set) var includeComments: Bool
-    private(set) var includeCompilerDirectives: Bool
-    private(set) var includeMultilineStrings: Bool
-
-    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
-    }
+    private(set) var severityConfiguration = SeverityConfiguration.warning
+    private(set) var indentationWidth = 4
+    private(set) var includeComments = true
+    private(set) var includeCompilerDirectives = true
+    private(set) var includeMultilineStrings = true

    mutating func apply(configuration: Any) throws {
        guard let configurationDict = configuration as? [String: Any] else {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/LineLengthConfiguration.swift
+++ b/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
-    var ignoresURLs: Bool
-    var ignoresFunctionDeclarations: Bool
-    var ignoresComments: Bool
-    var ignoresInterpolatedStrings: Bool
+    private(set) var length = SeverityLevelsConfiguration(warning: 120, error: 200)
+    private(set) var ignoresURLs = false
+    private(set) var ignoresFunctionDeclarations = false
+    private(set) var ignoresComments = false
+    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
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/NameConfiguration.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/NameConfiguration.swift
@ -12,11 +12,11 @@ struct NameConfiguration: RuleConfiguration, Equatable {
        return output
    }

-    var minLength: SeverityLevelsConfiguration
-    var maxLength: SeverityLevelsConfiguration
-    var excludedRegularExpressions: Set<NSRegularExpression>
+    private(set) var minLength: SeverityLevelsConfiguration
+    private(set) var maxLength: SeverityLevelsConfiguration
+    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)
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/NestingConfiguration.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/NestingConfiguration.swift
@ -6,22 +6,10 @@ struct NestingConfiguration: RuleConfiguration, Equatable {
            + ", (always_allow_one_type_in_functions) \(alwaysAllowOneTypeInFunctions)"
    }

-    var typeLevel: SeverityLevelsConfiguration
-    var functionLevel: SeverityLevelsConfiguration
-    var checkNestingInClosuresAndStatements: Bool
-    var alwaysAllowOneTypeInFunctions: Bool
-
-    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
-    }
+    private(set) var typeLevel = SeverityLevelsConfiguration(warning: 1)
+    private(set) var functionLevel = SeverityLevelsConfiguration(warning: 2)
+    private(set) var checkNestingInClosuresAndStatements = true
+    private(set) var alwaysAllowOneTypeInFunctions = false

    mutating func apply(configuration: Any) throws {
        guard let configurationDict = configuration as? [String: Any] else {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrefixedConstantRuleConfiguration.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrefixedConstantRuleConfiguration.swift
@ -1,15 +1,11 @@
 struct PrefixedConstantRuleConfiguration: SeverityBasedRuleConfiguration, Equatable {
-    var severityConfiguration = SeverityConfiguration(.warning)
-    var onlyPrivateMembers = false
+    private(set) var severityConfiguration = SeverityConfiguration(.warning)
+    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
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrivateOutletRuleConfiguration.swift
+++ b/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
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrivateUnitTestConfiguration.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/PrivateUnitTestConfiguration.swift
@ -1,12 +1,12 @@
 import Foundation
+import SwiftLintCore

 struct PrivateUnitTestConfiguration: SeverityBasedRuleConfiguration, Equatable, CacheDescriptionProvider {
-    let identifier: String
-    var name: String?
-    var message = "Regex matched."
-    var regex: NSRegularExpression!
-    var included: NSRegularExpression?
-    var severityConfiguration = SeverityConfiguration(.warning)
+    private(set) var name: String?
+    private(set) var message = "Unit test marked `private` will not be run by XCTest."
+    private(set) var regex = SwiftLintCore.regex("XCTestCase")
+    private(set) var included: NSRegularExpression?
+    private(set) 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
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/StatementModeConfiguration.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/StatementModeConfiguration.swift
@ -18,8 +18,8 @@ struct StatementConfiguration: SeverityBasedRuleConfiguration, Equatable {
            "(severity) \(severityConfiguration.consoleDescription)"
    }

-    var statementMode: StatementModeConfiguration
-    var severityConfiguration: SeverityConfiguration
+    private(set) var statementMode = StatementModeConfiguration.default
+    private(set) var severityConfiguration = SeverityConfiguration.warning

    mutating func apply(configuration: Any) throws {
        guard let configurationDict = configuration as? [String: Any] else {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/TrailingWhitespaceConfiguration.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/TrailingWhitespaceConfiguration.swift
@ -1,7 +1,7 @@
 struct TrailingWhitespaceConfiguration: SeverityBasedRuleConfiguration, Equatable {
-    var severityConfiguration = SeverityConfiguration(.warning)
-    var ignoresEmptyLines = false
-    var ignoresComments = true
+    private(set) var severityConfiguration = SeverityConfiguration(.warning)
+    private(set) var ignoresEmptyLines = false
+    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
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/UnusedDeclarationConfiguration.swift
+++ b/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
-    private(set) var relatedUSRsToSkip: Set<String>
+    private(set) var severityConfiguration = SeverityConfiguration.error
+    private(set) var includePublicAndOpen = false
+    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
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/UnusedImportConfiguration.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/UnusedImportConfiguration.swift
@ -29,20 +29,11 @@ struct UnusedImportConfiguration: SeverityBasedRuleConfiguration, Equatable {
        ].joined(separator: ", ")
    }

-    private(set) var severityConfiguration: SeverityConfiguration
-    private(set) var requireExplicitImports: Bool
-    private(set) var allowedTransitiveImports: [TransitiveModuleConfiguration]
+    private(set) var severityConfiguration = SeverityConfiguration.warning
+    private(set) var requireExplicitImports = false
+    private(set) var allowedTransitiveImports = [TransitiveModuleConfiguration]()
    /// A set of modules to never remove the imports of.
-    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
-    }
+    private(set) var alwaysKeepImports = [String]()

    mutating func apply(configuration: Any) throws {
        guard let configurationDict = configuration as? [String: Any] else {
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/UnusedOptionalBindingConfiguration.swift
+++ b/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
--- a/Source/SwiftLintBuiltInRules/Rules/RuleConfigurations/VerticalWhitespaceConfiguration.swift
+++ b/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
--- a/Source/SwiftLintBuiltInRules/Rules/Style/IndentationWidthRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Style/IndentationWidthRule.swift
@ -16,13 +16,8 @@ struct IndentationWidthRule: ConfigurationProviderRule, OptInRule {
    }

    // MARK: - Properties
-    var configuration = IndentationWidthConfiguration(
-        severity: .warning,
-        indentationWidth: 4,
-        includeComments: true,
-        includeCompilerDirectives: true,
-        includeMultilineStrings: true
-    )
+    var configuration = IndentationWidthConfiguration()
+
    static let description = RuleDescription(
        identifier: "indentation_width",
        name: "Indentation Width",
--- a/Source/SwiftLintBuiltInRules/Rules/Style/PrefixedTopLevelConstantRule.swift
+++ b/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",
--- a/Source/SwiftLintBuiltInRules/Rules/Style/StatementPositionRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Style/StatementPositionRule.swift
@ -2,8 +2,7 @@ import Foundation
 import SourceKittenFramework

 struct StatementPositionRule: CorrectableRule, ConfigurationProviderRule {
-    var configuration = StatementConfiguration(statementMode: .default,
-                                               severityConfiguration: SeverityConfiguration(.warning))
+    var configuration = StatementConfiguration()

    static let description = RuleDescription(
        identifier: "statement_position",
--- a/Source/SwiftLintBuiltInRules/Rules/Style/TrailingWhitespaceRule.swift
+++ b/Source/SwiftLintBuiltInRules/Rules/Style/TrailingWhitespaceRule.swift
@ -2,8 +2,7 @@ import Foundation
 import SourceKittenFramework

 struct TrailingWhitespaceRule: CorrectableRule, ConfigurationProviderRule {
-    var configuration = TrailingWhitespaceConfiguration(ignoresEmptyLines: false,
-                                                        ignoresComments: true)
+    var configuration = TrailingWhitespaceConfiguration()

    static let description = RuleDescription(
        identifier: "trailing_whitespace",
--- a/Source/SwiftLintBuiltInRules/Rules/Style/UnusedOptionalBindingRule.swift
+++ b/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",
--- a/Source/SwiftLintBuiltInRules/Rules/Style/VerticalWhitespaceRule.swift
+++ b/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",
--- a/Tests/SwiftLintFrameworkTests/CyclomaticComplexityConfigurationTests.swift
+++ b/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,
-                                                               ignoresCaseStatements: true)
+        let configuration1 = CyclomaticComplexityConfiguration(
+            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 config2 = CyclomaticComplexityConfiguration(warning: 10, error: 30, ignoresCaseStatements: true)
-        let config3 = CyclomaticComplexityConfiguration(warning: 10, error: 30, ignoresCaseStatements: false)
-        let config4 = CyclomaticComplexityConfiguration(warning: 10, error: 40)
-        let config5 = CyclomaticComplexityConfiguration(warning: 20, error: 30)
+        let config1 = CyclomaticComplexityConfiguration(
+            length: SeverityLevelsConfiguration(warning: 10, error: 30)
+        )
+        let config2 = CyclomaticComplexityConfiguration(
+            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)
--- a/Tests/SwiftLintFrameworkTests/LineLengthConfigurationTests.swift
+++ b/Tests/SwiftLintFrameworkTests/LineLengthConfigurationTests.swift
@ -2,87 +2,66 @@
 import XCTest

 class LineLengthConfigurationTests: SwiftLintTestCase {
-    func testLineLengthConfigurationInitializerSetsLength() {
-        let warning = 100
-        let error = 150
-        let length1 = SeverityLevelsConfiguration(warning: warning, error: error)
-        let configuration1 = LineLengthConfiguration(warning: warning,
-                                                     error: error)
-        XCTAssertEqual(configuration1.length, length1)
+    private let severityLevels = SeverityLevelsConfiguration(warning: 100, error: 150)

-        let length2 = SeverityLevelsConfiguration(warning: warning, error: nil)
-        let configuration2 = LineLengthConfiguration(warning: warning,
-                                                     error: nil)
+    func testLineLengthConfigurationInitializerSetsLength() {
+        let configuration1 = LineLengthConfiguration(length: severityLevels)
+        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,
-                                                     error: 150,
-                                                     options: [.ignoreURLs])
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresURLs: true)

        XCTAssertTrue(configuration1.ignoresURLs)

-        let configuration2 = LineLengthConfiguration(warning: 100,
-                                                     error: 150)
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
        XCTAssertFalse(configuration2.ignoresURLs)
    }

    func testLineLengthConfigurationInitialiserSetsIgnoresFunctionDeclarations() {
-        let configuration1 = LineLengthConfiguration(warning: 100,
-                                                     error: 150,
-                                                     options: [.ignoreFunctionDeclarations])
-
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresFunctionDeclarations: true)
        XCTAssertTrue(configuration1.ignoresFunctionDeclarations)

-        let configuration2 = LineLengthConfiguration(warning: 100,
-                                                     error: 150)
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
        XCTAssertFalse(configuration2.ignoresFunctionDeclarations)
    }

    func testLineLengthConfigurationInitialiserSetsIgnoresComments() {
-        let configuration1 = LineLengthConfiguration(warning: 100,
-                                                     error: 150,
-                                                     options: [.ignoreComments])
-
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresComments: true)
        XCTAssertTrue(configuration1.ignoresComments)

-        let configuration2 = LineLengthConfiguration(warning: 100,
-                                                     error: 150)
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
        XCTAssertFalse(configuration2.ignoresComments)
    }

    func testLineLengthConfigurationInitialiserSetsIgnoresInterpolatedStrings() {
-        let configuration1 = LineLengthConfiguration(warning: 100,
-                                                     error: 150,
-                                                     options: [.ignoreInterpolatedStrings])
-
+        let configuration1 = LineLengthConfiguration(length: severityLevels, ignoresInterpolatedStrings: true)
        XCTAssertTrue(configuration1.ignoresInterpolatedStrings)

-        let configuration2 = LineLengthConfiguration(warning: 100,
-                                                     error: 150)
+        let configuration2 = LineLengthConfiguration(length: severityLevels)
        XCTAssertFalse(configuration2.ignoresInterpolatedStrings)
    }

    func testLineLengthConfigurationParams() {
        let warning = 13
        let error = 10
-        let configuration = LineLengthConfiguration(warning: warning,
-                                                    error: error)
+        let configuration = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: warning, 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(warning: warning,
-                                                    error: nil)
+        let configuration = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 13))
        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 configuration2 = LineLengthConfiguration(warning: 100,
-                                                     error: 100,
-                                                     options: [.ignoreFunctionDeclarations,
-                                                               .ignoreComments])
+        let configuration1 = LineLengthConfiguration(length: SeverityLevelsConfiguration(warning: 100, error: 100))
+        let configuration2 = LineLengthConfiguration(
+            length: SeverityLevelsConfiguration(warning: 100, error: 100),
+            ignoresFunctionDeclarations: true,
+            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,
-                                                     error: 100,
-                                                     options: [.ignoreFunctionDeclarations,
-                                                               .ignoreComments])
+        let configuration6 = LineLengthConfiguration(
+            length: SeverityLevelsConfiguration(warning: 100, error: 100),
+            ignoresFunctionDeclarations: true,
+            ignoresComments: true
+        )
        XCTAssertEqual(configuration2, configuration6)
    }
 }
--- a/Tests/SwiftLintFrameworkTests/NameConfigurationTests.swift
+++ b/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)
    }
 }
--- a/Tests/SwiftLintFrameworkTests/RuleConfigurationTests.swift
+++ b/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,
-                                                 typeLevelError: nil,
-                                                 functionLevelWarning: 0,
-                                                 functionLevelError: nil)
+        var nestingConfig = defaultNestingConfiguration
        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,
-                                                 typeLevelError: nil,
-                                                 functionLevelWarning: 0,
-                                                 functionLevelError: nil)
+        var nestingConfig = defaultNestingConfiguration
        checkError(Issue.unknownConfiguration) {
            try nestingConfig.apply(configuration: config)
        }
@ -201,9 +200,11 @@ class RuleConfigurationTests: SwiftLintTestCase {
    }

    func testTrailingWhitespaceConfigurationApplyConfigurationUpdatesSeverityConfiguration() {
-        var configuration = TrailingWhitespaceConfiguration(ignoresEmptyLines: false,
-                                                            ignoresComments: true)
-        configuration.severityConfiguration.severity = .warning
+        var configuration = TrailingWhitespaceConfiguration(
+            severityConfiguration: .warning,
+            ignoresEmptyLines: false,
+            ignoresComments: true
+        )

        do {
            try configuration.apply(configuration: ["severity": "error"])
--- a/Tests/SwiftLintFrameworkTests/UnusedDeclarationConfigurationTests.swift
+++ b/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: []
        )