Swiftformat: Disable #if-def indentation

9 files changed, 401 insertions, 400 deletions

diff --git a/ios/.swiftformat b/ios/.swiftformat
index ed479f35bd..2953ce46f8 100644
--- a/ios/.swiftformat
+++ b/ios/.swiftformat
@@ -11,4 +11,5 @@
 --wrapcollections before-first
 --wrapternary before-operators
 --redundanttype inferred
+--ifdef no-indent
 --disable initCoderUnavailable, redundantReturn, unusedArguments, redundantRawValues, preferKeyPath
diff --git a/ios/MullvadVPN/AppDelegate.swift b/ios/MullvadVPN/AppDelegate.swift
index 90a80e4626..74670008a7 100644
--- a/ios/MullvadVPN/AppDelegate.swift
+++ b/ios/MullvadVPN/AppDelegate.swift
@@ -18,7 +18,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
     private var logger: Logger!
 
     #if targetEnvironment(simulator)
-        private let simulatorTunnelProvider = SimulatorTunnelProviderHost()
+    private let simulatorTunnelProvider = SimulatorTunnelProviderHost()
     #endif
 
     private let operationQueue: AsyncOperationQueue = {
@@ -41,8 +41,8 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         logger = Logger(label: "AppDelegate")
 
         #if targetEnvironment(simulator)
-            // Configure mock tunnel provider on simulator
-            SimulatorTunnelProvider.shared.delegate = simulatorTunnelProvider
+        // Configure mock tunnel provider on simulator
+        SimulatorTunnelProvider.shared.delegate = simulatorTunnelProvider
         #endif
 
         if #available(iOS 13.0, *) {
diff --git a/ios/MullvadVPN/Bundle+ProductVersion.swift b/ios/MullvadVPN/Bundle+ProductVersion.swift
index 1030096834..a3631c1872 100644
--- a/ios/MullvadVPN/Bundle+ProductVersion.swift
+++ b/ios/MullvadVPN/Bundle+ProductVersion.swift
@@ -22,13 +22,13 @@ extension Bundle {
             "???"
 
         #if DEBUG
-            return "\(version)-dev\(buildNumber)"
+        return "\(version)-dev\(buildNumber)"
         #else
-            if appStoreReceiptURL?.lastPathComponent == "sandboxReceipt" {
-                return "\(version)-beta\(buildNumber)"
-            } else {
-                return version
-            }
+        if appStoreReceiptURL?.lastPathComponent == "sandboxReceipt" {
+            return "\(version)-beta\(buildNumber)"
+        } else {
+            return version
+        }
         #endif
     }
 }
diff --git a/ios/MullvadVPN/Logging/Logging.swift b/ios/MullvadVPN/Logging/Logging.swift
index 8d4f4f883f..a0c535853e 100644
--- a/ios/MullvadVPN/Logging/Logging.swift
+++ b/ios/MullvadVPN/Logging/Logging.swift
@@ -50,7 +50,7 @@ func initLoggingSystem(bundleIdentifier: String, metadata: Logger.Metadata? = ni
         var logHandlers: [LogHandler] = []
 
         #if DEBUG
-            logHandlers.append(OSLogHandler(subsystem: bundleIdentifier, category: label))
+        logHandlers.append(OSLogHandler(subsystem: bundleIdentifier, category: label))
         #endif
 
         if !streams.isEmpty {
diff --git a/ios/MullvadVPN/Operations/BackgroundObserver.swift b/ios/MullvadVPN/Operations/BackgroundObserver.swift
index b946d03440..ba924140f2 100644
--- a/ios/MullvadVPN/Operations/BackgroundObserver.swift
+++ b/ios/MullvadVPN/Operations/BackgroundObserver.swift
@@ -7,47 +7,47 @@
 
 #if canImport(UIKit)
 
-    import UIKit
+import UIKit
 
-    class BackgroundObserver: OperationObserver {
-        let name: String
-        let application: UIApplication
-        let cancelUponExpiration: Bool
+class BackgroundObserver: OperationObserver {
+    let name: String
+    let application: UIApplication
+    let cancelUponExpiration: Bool
 
-        private var taskIdentifier: UIBackgroundTaskIdentifier?
+    private var taskIdentifier: UIBackgroundTaskIdentifier?
 
-        init(
-            application: UIApplication = .shared,
-            name: String,
-            cancelUponExpiration: Bool
-        ) {
-            self.application = application
-            self.name = name
-            self.cancelUponExpiration = cancelUponExpiration
-        }
+    init(
+        application: UIApplication = .shared,
+        name: String,
+        cancelUponExpiration: Bool
+    ) {
+        self.application = application
+        self.name = name
+        self.cancelUponExpiration = cancelUponExpiration
+    }
 
-        func didAttach(to operation: Operation) {
-            let expirationHandler = cancelUponExpiration ? { operation.cancel() } : nil
+    func didAttach(to operation: Operation) {
+        let expirationHandler = cancelUponExpiration ? { operation.cancel() } : nil
 
-            taskIdentifier = application.beginBackgroundTask(
-                withName: name,
-                expirationHandler: expirationHandler
-            )
-        }
+        taskIdentifier = application.beginBackgroundTask(
+            withName: name,
+            expirationHandler: expirationHandler
+        )
+    }
 
-        func operationDidStart(_ operation: Operation) {
-            // no-op
-        }
+    func operationDidStart(_ operation: Operation) {
+        // no-op
+    }
 
-        func operationDidCancel(_ operation: Operation) {
-            // no-op
-        }
+    func operationDidCancel(_ operation: Operation) {
+        // no-op
+    }
 
-        func operationDidFinish(_ operation: Operation, error: Error?) {
-            if let taskIdentifier = taskIdentifier {
-                application.endBackgroundTask(taskIdentifier)
-            }
+    func operationDidFinish(_ operation: Operation, error: Error?) {
+        if let taskIdentifier = taskIdentifier {
+            application.endBackgroundTask(taskIdentifier)
         }
     }
+}
 
 #endif
diff --git a/ios/MullvadVPN/SimulatorTunnelProvider.swift b/ios/MullvadVPN/SimulatorTunnelProvider.swift
index 162a95590f..4c7e0e091a 100644
--- a/ios/MullvadVPN/SimulatorTunnelProvider.swift
+++ b/ios/MullvadVPN/SimulatorTunnelProvider.swift
@@ -48,388 +48,388 @@ extension NETunnelProviderManager: VPNTunnelProviderManagerProtocol {}
 
 #if targetEnvironment(simulator)
 
-    // MARK: - NEPacketTunnelProvider stubs
+// MARK: - NEPacketTunnelProvider stubs
 
-    class SimulatorTunnelProviderDelegate {
-        fileprivate(set) var connection: SimulatorVPNConnection?
+class SimulatorTunnelProviderDelegate {
+    fileprivate(set) var connection: SimulatorVPNConnection?
 
-        var protocolConfiguration: NEVPNProtocol {
-            return connection?.protocolConfiguration ?? NEVPNProtocol()
-        }
-
-        var reasserting: Bool {
-            get {
-                return connection?.reasserting ?? false
-            }
-            set {
-                connection?.reasserting = newValue
-            }
-        }
+    var protocolConfiguration: NEVPNProtocol {
+        return connection?.protocolConfiguration ?? NEVPNProtocol()
+    }
 
-        func startTunnel(
-            options: [String: NSObject]?,
-            completionHandler: @escaping (Error?) -> Void
-        ) {
-            completionHandler(nil)
+    var reasserting: Bool {
+        get {
+            return connection?.reasserting ?? false
         }
-
-        func stopTunnel(
-            with reason: NEProviderStopReason,
-            completionHandler: @escaping () -> Void
-        ) {
-            completionHandler()
+        set {
+            connection?.reasserting = newValue
         }
+    }
 
-        func handleAppMessage(_ messageData: Data, completionHandler: ((Data?) -> Void)?) {
-            completionHandler?(nil)
-        }
+    func startTunnel(
+        options: [String: NSObject]?,
+        completionHandler: @escaping (Error?) -> Void
+    ) {
+        completionHandler(nil)
     }
 
-    class SimulatorTunnelProvider {
-        static let shared = SimulatorTunnelProvider()
+    func stopTunnel(
+        with reason: NEProviderStopReason,
+        completionHandler: @escaping () -> Void
+    ) {
+        completionHandler()
+    }
 
-        private let lock = NSLock()
-        private var _delegate: SimulatorTunnelProviderDelegate?
+    func handleAppMessage(_ messageData: Data, completionHandler: ((Data?) -> Void)?) {
+        completionHandler?(nil)
+    }
+}
 
-        var delegate: SimulatorTunnelProviderDelegate! {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
+class SimulatorTunnelProvider {
+    static let shared = SimulatorTunnelProvider()
 
-                return _delegate
-            }
-            set {
-                lock.lock()
-                _delegate = newValue
-                lock.unlock()
-            }
-        }
+    private let lock = NSLock()
+    private var _delegate: SimulatorTunnelProviderDelegate?
 
-        private init() {}
+    var delegate: SimulatorTunnelProviderDelegate! {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
 
-        fileprivate func handleAppMessage(
-            _ messageData: Data,
-            completionHandler: ((Data?) -> Void)? = nil
-        ) {
-            delegate.handleAppMessage(messageData, completionHandler: completionHandler)
+            return _delegate
+        }
+        set {
+            lock.lock()
+            _delegate = newValue
+            lock.unlock()
         }
     }
 
-    // MARK: - NEVPNConnection stubs
+    private init() {}
 
-    class SimulatorVPNConnection: NSObject, VPNConnectionProtocol {
-        // Protocol configuration is automatically synced by `SimulatorTunnelInfo`
-        fileprivate var protocolConfiguration = NEVPNProtocol()
-
-        private let lock = NSRecursiveLock()
-        private var _status: NEVPNStatus = .disconnected
-        private var _reasserting = false
-        private var _connectedDate: Date?
+    fileprivate func handleAppMessage(
+        _ messageData: Data,
+        completionHandler: ((Data?) -> Void)? = nil
+    ) {
+        delegate.handleAppMessage(messageData, completionHandler: completionHandler)
+    }
+}
 
-        private(set) var status: NEVPNStatus {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
+// MARK: - NEVPNConnection stubs
 
-                return _status
-            }
-            set {
-                lock.lock()
+class SimulatorVPNConnection: NSObject, VPNConnectionProtocol {
+    // Protocol configuration is automatically synced by `SimulatorTunnelInfo`
+    fileprivate var protocolConfiguration = NEVPNProtocol()
 
-                if _status != newValue {
-                    _status = newValue
+    private let lock = NSRecursiveLock()
+    private var _status: NEVPNStatus = .disconnected
+    private var _reasserting = false
+    private var _connectedDate: Date?
 
-                    // Send notification while holding the lock. This should enable the receiver
-                    // to fetch the `SimulatorVPNConnection.status` before the concurrent code gets
-                    // opportunity to change it again.
-                    postStatusDidChangeNotification()
-                }
+    private(set) var status: NEVPNStatus {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
 
-                lock.unlock()
-            }
+            return _status
         }
+        set {
+            lock.lock()
 
-        var reasserting: Bool {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
+            if _status != newValue {
+                _status = newValue
 
-                return _reasserting
+                // Send notification while holding the lock. This should enable the receiver
+                // to fetch the `SimulatorVPNConnection.status` before the concurrent code gets
+                // opportunity to change it again.
+                postStatusDidChangeNotification()
             }
-            set {
-                lock.lock()
 
-                if _reasserting != newValue {
-                    _reasserting = newValue
+            lock.unlock()
+        }
+    }
 
-                    if newValue {
-                        status = .reasserting
-                    } else {
-                        status = .connected
-                    }
-                }
+    var reasserting: Bool {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
 
-                lock.unlock()
-            }
+            return _reasserting
         }
+        set {
+            lock.lock()
 
-        private(set) var connectedDate: Date? {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
+            if _reasserting != newValue {
+                _reasserting = newValue
 
-                return _connectedDate
-            }
-            set {
-                lock.lock()
-                _connectedDate = newValue
-                lock.unlock()
+                if newValue {
+                    status = .reasserting
+                } else {
+                    status = .connected
+                }
             }
-        }
 
-        func startVPNTunnel() throws {
-            try startVPNTunnel(options: nil)
+            lock.unlock()
         }
+    }
 
-        func startVPNTunnel(options: [String: NSObject]?) throws {
-            SimulatorTunnelProvider.shared.delegate.connection = self
-
-            status = .connecting
+    private(set) var connectedDate: Date? {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
 
-            SimulatorTunnelProvider.shared.delegate.startTunnel(options: options) { error in
-                if error == nil {
-                    self.status = .connected
-                    self.connectedDate = Date()
-                } else {
-                    self.status = .disconnected
-                    self.connectedDate = nil
-                }
-            }
+            return _connectedDate
+        }
+        set {
+            lock.lock()
+            _connectedDate = newValue
+            lock.unlock()
         }
+    }
 
-        func stopVPNTunnel() {
-            status = .disconnecting
+    func startVPNTunnel() throws {
+        try startVPNTunnel(options: nil)
+    }
+
+    func startVPNTunnel(options: [String: NSObject]?) throws {
+        SimulatorTunnelProvider.shared.delegate.connection = self
 
-            SimulatorTunnelProvider.shared.delegate.stopTunnel(with: .userInitiated) {
+        status = .connecting
+
+        SimulatorTunnelProvider.shared.delegate.startTunnel(options: options) { error in
+            if error == nil {
+                self.status = .connected
+                self.connectedDate = Date()
+            } else {
                 self.status = .disconnected
                 self.connectedDate = nil
             }
         }
+    }
+
+    func stopVPNTunnel() {
+        status = .disconnecting
 
-        private func postStatusDidChangeNotification() {
-            NotificationCenter.default.post(name: .NEVPNStatusDidChange, object: self)
+        SimulatorTunnelProvider.shared.delegate.stopTunnel(with: .userInitiated) {
+            self.status = .disconnected
+            self.connectedDate = nil
         }
     }
 
-    // MARK: - NETunnelProviderSession stubs
+    private func postStatusDidChangeNotification() {
+        NotificationCenter.default.post(name: .NEVPNStatusDidChange, object: self)
+    }
+}
 
-    class SimulatorTunnelProviderSession: SimulatorVPNConnection, VPNTunnelProviderSessionProtocol {
-        func sendProviderMessage(_ messageData: Data, responseHandler: ((Data?) -> Void)?) throws {
-            SimulatorTunnelProvider.shared.handleAppMessage(
-                messageData,
-                completionHandler: responseHandler
-            )
-        }
+// MARK: - NETunnelProviderSession stubs
+
+class SimulatorTunnelProviderSession: SimulatorVPNConnection, VPNTunnelProviderSessionProtocol {
+    func sendProviderMessage(_ messageData: Data, responseHandler: ((Data?) -> Void)?) throws {
+        SimulatorTunnelProvider.shared.handleAppMessage(
+            messageData,
+            completionHandler: responseHandler
+        )
     }
+}
 
-    // MARK: - NETunnelProviderManager stubs
+// MARK: - NETunnelProviderManager stubs
 
-    /// A mock struct for tunnel configuration and connection
-    private struct SimulatorTunnelInfo {
-        /// A unique identifier for the configuration
-        var identifier = UUID().uuidString
+/// A mock struct for tunnel configuration and connection
+private struct SimulatorTunnelInfo {
+    /// A unique identifier for the configuration
+    var identifier = UUID().uuidString
 
-        /// An associated VPN connection.
-        /// Intentionally initialized with a `SimulatorTunnelProviderSession` subclass which
-        /// implements the necessary protocol
-        var connection: SimulatorVPNConnection = SimulatorTunnelProviderSession()
+    /// An associated VPN connection.
+    /// Intentionally initialized with a `SimulatorTunnelProviderSession` subclass which
+    /// implements the necessary protocol
+    var connection: SimulatorVPNConnection = SimulatorTunnelProviderSession()
 
-        /// Whether configuration is enabled
-        var isEnabled = false
+    /// Whether configuration is enabled
+    var isEnabled = false
 
-        /// Whether on-demand VPN is enabled
-        var isOnDemandEnabled = false
+    /// Whether on-demand VPN is enabled
+    var isOnDemandEnabled = false
 
-        /// On-demand VPN rules
-        var onDemandRules = [NEOnDemandRule]()
+    /// On-demand VPN rules
+    var onDemandRules = [NEOnDemandRule]()
 
-        /// Protocol configuration
-        var protocolConfiguration: NEVPNProtocol? {
-            didSet {
-                connection.protocolConfiguration = protocolConfiguration ?? NEVPNProtocol()
-            }
+    /// Protocol configuration
+    var protocolConfiguration: NEVPNProtocol? {
+        didSet {
+            connection.protocolConfiguration = protocolConfiguration ?? NEVPNProtocol()
         }
+    }
 
-        /// Tunnel description
-        var localizedDescription: String?
+    /// Tunnel description
+    var localizedDescription: String?
 
-        /// Designated initializer
-        init() {}
-    }
+    /// Designated initializer
+    init() {}
+}
 
-    class SimulatorTunnelProviderManager: VPNTunnelProviderManagerProtocol, Equatable {
-        static let tunnelsLock = NSRecursiveLock()
-        fileprivate static var tunnels = [SimulatorTunnelInfo]()
+class SimulatorTunnelProviderManager: VPNTunnelProviderManagerProtocol, Equatable {
+    static let tunnelsLock = NSRecursiveLock()
+    fileprivate static var tunnels = [SimulatorTunnelInfo]()
 
-        private let lock = NSLock()
-        private var tunnelInfo: SimulatorTunnelInfo
-        private var identifier: String {
+    private let lock = NSLock()
+    private var tunnelInfo: SimulatorTunnelInfo
+    private var identifier: String {
+        lock.lock()
+        defer { lock.unlock() }
+
+        return tunnelInfo.identifier
+    }
+
+    var isOnDemandEnabled: Bool {
+        get {
             lock.lock()
             defer { lock.unlock() }
 
-            return tunnelInfo.identifier
+            return tunnelInfo.isOnDemandEnabled
         }
-
-        var isOnDemandEnabled: Bool {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
-
-                return tunnelInfo.isOnDemandEnabled
-            }
-            set {
-                lock.lock()
-                tunnelInfo.isOnDemandEnabled = newValue
-                lock.unlock()
-            }
+        set {
+            lock.lock()
+            tunnelInfo.isOnDemandEnabled = newValue
+            lock.unlock()
         }
+    }
 
-        var onDemandRules: [NEOnDemandRule] {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
+    var onDemandRules: [NEOnDemandRule] {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
 
-                return tunnelInfo.onDemandRules
-            }
-            set {
-                lock.lock()
-                tunnelInfo.onDemandRules = newValue
-                lock.unlock()
-            }
+            return tunnelInfo.onDemandRules
         }
-
-        var isEnabled: Bool {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
-
-                return tunnelInfo.isEnabled
-            }
-            set {
-                lock.lock()
-                tunnelInfo.isEnabled = newValue
-                lock.unlock()
-            }
+        set {
+            lock.lock()
+            tunnelInfo.onDemandRules = newValue
+            lock.unlock()
         }
+    }
 
-        var protocolConfiguration: NEVPNProtocol? {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
+    var isEnabled: Bool {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
 
-                return tunnelInfo.protocolConfiguration
-            }
-            set {
-                lock.lock()
-                tunnelInfo.protocolConfiguration = newValue
-                lock.unlock()
-            }
+            return tunnelInfo.isEnabled
         }
+        set {
+            lock.lock()
+            tunnelInfo.isEnabled = newValue
+            lock.unlock()
+        }
+    }
 
-        var localizedDescription: String? {
-            get {
-                lock.lock()
-                defer { lock.unlock() }
+    var protocolConfiguration: NEVPNProtocol? {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
 
-                return tunnelInfo.localizedDescription
-            }
-            set {
-                lock.lock()
-                tunnelInfo.localizedDescription = newValue
-                lock.unlock()
-            }
+            return tunnelInfo.protocolConfiguration
         }
+        set {
+            lock.lock()
+            tunnelInfo.protocolConfiguration = newValue
+            lock.unlock()
+        }
+    }
 
-        var connection: SimulatorVPNConnection {
+    var localizedDescription: String? {
+        get {
             lock.lock()
             defer { lock.unlock() }
 
-            return tunnelInfo.connection
+            return tunnelInfo.localizedDescription
         }
+        set {
+            lock.lock()
+            tunnelInfo.localizedDescription = newValue
+            lock.unlock()
+        }
+    }
 
-        static func loadAllFromPreferences(completionHandler: (
-            [SimulatorTunnelProviderManager]?,
-            Error?
-        ) -> Void) {
-            Self.tunnelsLock.lock()
-            let tunnelProviders = tunnels.map { tunnelInfo in
-                return SimulatorTunnelProviderManager(tunnelInfo: tunnelInfo)
-            }
-            Self.tunnelsLock.unlock()
+    var connection: SimulatorVPNConnection {
+        lock.lock()
+        defer { lock.unlock() }
 
-            completionHandler(tunnelProviders, nil)
-        }
+        return tunnelInfo.connection
+    }
 
-        required convenience init() {
-            self.init(tunnelInfo: SimulatorTunnelInfo())
+    static func loadAllFromPreferences(completionHandler: (
+        [SimulatorTunnelProviderManager]?,
+        Error?
+    ) -> Void) {
+        Self.tunnelsLock.lock()
+        let tunnelProviders = tunnels.map { tunnelInfo in
+            return SimulatorTunnelProviderManager(tunnelInfo: tunnelInfo)
         }
+        Self.tunnelsLock.unlock()
 
-        private init(tunnelInfo: SimulatorTunnelInfo) {
-            self.tunnelInfo = tunnelInfo
-        }
+        completionHandler(tunnelProviders, nil)
+    }
 
-        func loadFromPreferences(completionHandler: (Error?) -> Void) {
-            var error: NEVPNError?
+    required convenience init() {
+        self.init(tunnelInfo: SimulatorTunnelInfo())
+    }
 
-            Self.tunnelsLock.lock()
+    private init(tunnelInfo: SimulatorTunnelInfo) {
+        self.tunnelInfo = tunnelInfo
+    }
 
-            if let savedTunnel = Self.tunnels.first(where: { $0.identifier == self.identifier }) {
-                tunnelInfo = savedTunnel
-            } else {
-                error = NEVPNError(.configurationInvalid)
-            }
+    func loadFromPreferences(completionHandler: (Error?) -> Void) {
+        var error: NEVPNError?
 
-            Self.tunnelsLock.unlock()
+        Self.tunnelsLock.lock()
 
-            completionHandler(error)
+        if let savedTunnel = Self.tunnels.first(where: { $0.identifier == self.identifier }) {
+            tunnelInfo = savedTunnel
+        } else {
+            error = NEVPNError(.configurationInvalid)
         }
 
-        func saveToPreferences(completionHandler: ((Error?) -> Void)?) {
-            Self.tunnelsLock.lock()
+        Self.tunnelsLock.unlock()
 
-            if let index = Self.tunnels.firstIndex(where: { $0.identifier == self.identifier }) {
-                Self.tunnels[index] = tunnelInfo
-            } else {
-                Self.tunnels.append(tunnelInfo)
-            }
+        completionHandler(error)
+    }
 
-            Self.tunnelsLock.unlock()
+    func saveToPreferences(completionHandler: ((Error?) -> Void)?) {
+        Self.tunnelsLock.lock()
 
-            completionHandler?(nil)
+        if let index = Self.tunnels.firstIndex(where: { $0.identifier == self.identifier }) {
+            Self.tunnels[index] = tunnelInfo
+        } else {
+            Self.tunnels.append(tunnelInfo)
         }
 
-        func removeFromPreferences(completionHandler: ((Error?) -> Void)?) {
-            var error: NEVPNError?
+        Self.tunnelsLock.unlock()
 
-            Self.tunnelsLock.lock()
+        completionHandler?(nil)
+    }
 
-            if let index = Self.tunnels.firstIndex(where: { $0.identifier == self.identifier }) {
-                Self.tunnels.remove(at: index)
-            } else {
-                error = NEVPNError(.configurationReadWriteFailed)
-            }
+    func removeFromPreferences(completionHandler: ((Error?) -> Void)?) {
+        var error: NEVPNError?
 
-            Self.tunnelsLock.unlock()
+        Self.tunnelsLock.lock()
 
-            completionHandler?(error)
+        if let index = Self.tunnels.firstIndex(where: { $0.identifier == self.identifier }) {
+            Self.tunnels.remove(at: index)
+        } else {
+            error = NEVPNError(.configurationReadWriteFailed)
         }
 
-        static func == (
-            lhs: SimulatorTunnelProviderManager,
-            rhs: SimulatorTunnelProviderManager
-        ) -> Bool {
-            lhs.identifier == rhs.identifier
-        }
+        Self.tunnelsLock.unlock()
+
+        completionHandler?(error)
     }
 
+    static func == (
+        lhs: SimulatorTunnelProviderManager,
+        rhs: SimulatorTunnelProviderManager
+    ) -> Bool {
+        lhs.identifier == rhs.identifier
+    }
+}
+
 #endif
diff --git a/ios/MullvadVPN/SimulatorTunnelProviderHost.swift b/ios/MullvadVPN/SimulatorTunnelProviderHost.swift
index 9c3b2623a7..31d28ad84c 100644
--- a/ios/MullvadVPN/SimulatorTunnelProviderHost.swift
+++ b/ios/MullvadVPN/SimulatorTunnelProviderHost.swift
@@ -8,109 +8,109 @@
 
 #if targetEnvironment(simulator)
 
-    import Foundation
-    import Logging
-    import enum NetworkExtension.NEProviderStopReason
+import Foundation
+import Logging
+import enum NetworkExtension.NEProviderStopReason
 
-    class SimulatorTunnelProviderHost: SimulatorTunnelProviderDelegate {
-        private var selectorResult: RelaySelectorResult?
+class SimulatorTunnelProviderHost: SimulatorTunnelProviderDelegate {
+    private var selectorResult: RelaySelectorResult?
 
-        private let providerLogger = Logger(label: "SimulatorTunnelProviderHost")
-        private let dispatchQueue = DispatchQueue(label: "SimulatorTunnelProviderHostQueue")
+    private let providerLogger = Logger(label: "SimulatorTunnelProviderHost")
+    private let dispatchQueue = DispatchQueue(label: "SimulatorTunnelProviderHostQueue")
 
-        override func startTunnel(
-            options: [String: NSObject]?,
-            completionHandler: @escaping (Error?) -> Void
-        ) {
-            dispatchQueue.async {
-                var selectorResult: RelaySelectorResult?
+    override func startTunnel(
+        options: [String: NSObject]?,
+        completionHandler: @escaping (Error?) -> Void
+    ) {
+        dispatchQueue.async {
+            var selectorResult: RelaySelectorResult?
 
-                do {
-                    let tunnelOptions = PacketTunnelOptions(rawOptions: options ?? [:])
+            do {
+                let tunnelOptions = PacketTunnelOptions(rawOptions: options ?? [:])
 
-                    selectorResult = try tunnelOptions.getSelectorResult()
-                } catch {
-                    self.providerLogger.error(
-                        chainedError: AnyChainedError(error),
-                        message: """
-                        Failed to decode relay selector result passed from the app. \
-                        Will continue by picking new relay.
-                        """
-                    )
-                }
+                selectorResult = try tunnelOptions.getSelectorResult()
+            } catch {
+                self.providerLogger.error(
+                    chainedError: AnyChainedError(error),
+                    message: """
+                    Failed to decode relay selector result passed from the app. \
+                    Will continue by picking new relay.
+                    """
+                )
+            }
 
-                do {
-                    self.selectorResult = try selectorResult ?? self.pickRelay()
+            do {
+                self.selectorResult = try selectorResult ?? self.pickRelay()
 
-                    completionHandler(nil)
-                } catch {
-                    self.providerLogger.error(
-                        chainedError: AnyChainedError(error),
-                        message: "Failed to pick relay."
-                    )
-                    completionHandler(error)
-                }
+                completionHandler(nil)
+            } catch {
+                self.providerLogger.error(
+                    chainedError: AnyChainedError(error),
+                    message: "Failed to pick relay."
+                )
+                completionHandler(error)
             }
         }
+    }
 
-        override func stopTunnel(
-            with reason: NEProviderStopReason,
-            completionHandler: @escaping () -> Void
-        ) {
-            dispatchQueue.async {
-                self.selectorResult = nil
+    override func stopTunnel(
+        with reason: NEProviderStopReason,
+        completionHandler: @escaping () -> Void
+    ) {
+        dispatchQueue.async {
+            self.selectorResult = nil
 
-                completionHandler()
-            }
+            completionHandler()
         }
+    }
 
-        override func handleAppMessage(_ messageData: Data, completionHandler: ((Data?) -> Void)?) {
-            dispatchQueue.async {
-                do {
-                    let response = try self.processMessage(messageData)
+    override func handleAppMessage(_ messageData: Data, completionHandler: ((Data?) -> Void)?) {
+        dispatchQueue.async {
+            do {
+                let response = try self.processMessage(messageData)
 
-                    completionHandler?(response)
-                } catch {
-                    self.providerLogger.error(
-                        chainedError: AnyChainedError(error),
-                        message: "Failed to handle app message."
-                    )
+                completionHandler?(response)
+            } catch {
+                self.providerLogger.error(
+                    chainedError: AnyChainedError(error),
+                    message: "Failed to handle app message."
+                )
 
-                    completionHandler?(nil)
-                }
+                completionHandler?(nil)
             }
         }
+    }
 
-        private func processMessage(_ messageData: Data) throws -> Data? {
-            let message = try TunnelProviderMessage(messageData: messageData)
-
-            switch message {
-            case .getTunnelStatus:
-                var tunnelStatus = PacketTunnelStatus()
-                tunnelStatus.tunnelRelay = self.selectorResult?.packetTunnelRelay
+    private func processMessage(_ messageData: Data) throws -> Data? {
+        let message = try TunnelProviderMessage(messageData: messageData)
 
-                return try TunnelProviderReply(tunnelStatus).encode()
+        switch message {
+        case .getTunnelStatus:
+            var tunnelStatus = PacketTunnelStatus()
+            tunnelStatus.tunnelRelay = self.selectorResult?.packetTunnelRelay
 
-            case let .reconnectTunnel(aSelectorResult):
-                reasserting = true
-                if let aSelectorResult = aSelectorResult {
-                    selectorResult = aSelectorResult
-                }
-                reasserting = false
+            return try TunnelProviderReply(tunnelStatus).encode()
 
-                return nil
+        case let .reconnectTunnel(aSelectorResult):
+            reasserting = true
+            if let aSelectorResult = aSelectorResult {
+                selectorResult = aSelectorResult
             }
+            reasserting = false
+
+            return nil
         }
+    }
 
-        private func pickRelay() throws -> RelaySelectorResult {
-            let cachedRelays = try RelayCache.Tracker.shared.getCachedRelays()
-            let tunnelSettings = try SettingsManager.readSettings()
+    private func pickRelay() throws -> RelaySelectorResult {
+        let cachedRelays = try RelayCache.Tracker.shared.getCachedRelays()
+        let tunnelSettings = try SettingsManager.readSettings()
 
-            return try RelaySelector.evaluate(
-                relays: cachedRelays.relays,
-                constraints: tunnelSettings.relayConstraints
-            )
-        }
+        return try RelaySelector.evaluate(
+            relays: cachedRelays.relays,
+            constraints: tunnelSettings.relayConstraints
+        )
     }
+}
 
 #endif
diff --git a/ios/MullvadVPN/TunnelManager/Tunnel.swift b/ios/MullvadVPN/TunnelManager/Tunnel.swift
index 682b969485..260037b7a4 100644
--- a/ios/MullvadVPN/TunnelManager/Tunnel.swift
+++ b/ios/MullvadVPN/TunnelManager/Tunnel.swift
@@ -11,9 +11,9 @@ import NetworkExtension
 
 // Switch to stabs on simulator
 #if targetEnvironment(simulator)
-    typealias TunnelProviderManagerType = SimulatorTunnelProviderManager
+typealias TunnelProviderManagerType = SimulatorTunnelProviderManager
 #else
-    typealias TunnelProviderManagerType = NETunnelProviderManager
+typealias TunnelProviderManagerType = NETunnelProviderManager
 #endif
 
 protocol TunnelStatusObserver {
diff --git a/ios/MullvadVPN/TunnelManager/TunnelManager.swift b/ios/MullvadVPN/TunnelManager/TunnelManager.swift
index 41ca5213ec..00e203fb3a 100644
--- a/ios/MullvadVPN/TunnelManager/TunnelManager.swift
+++ b/ios/MullvadVPN/TunnelManager/TunnelManager.swift
@@ -246,7 +246,7 @@ final class TunnelManager {
 
     func refreshTunnelStatus() {
         #if DEBUG
-            logger.debug("Refresh tunnel status due to application becoming active.")
+        logger.debug("Refresh tunnel status due to application becoming active.")
         #endif
         _refreshTunnelStatus()
     }