import Foundation enum CheckTools { static func run(command: String, args: [String]) throws { switch command { case "check-swift-safety": var failures: [String] = [] for path in args { let source = try String(contentsOfFile: path, encoding: .utf8) failures += try safetyFailures(source: source, path: path) } guard failures.isEmpty else { throw DevError(failures.joined(separator: "\n")) } case "prepare-catalog": guard args.count == 2 else { throw DevError("Usage: parcel-dev prepare-catalog source destination") } let catalog = try preparedCatalog(DevJSON.read(args[0])) try catalog.encoded().write(to: URL(fileURLWithPath: args[1])) case "check-package-settings": guard !args.isEmpty else { throw DevError("Usage: parcel-dev check-package-settings package-json ...") } var count = 0 for path in args { count += try packageTargetCount(DevJSON.read(path)) } print("Package settings checks passed: \(count) targets") default: throw DevError("Unknown check command: \(command)") } } static func safetyFailures(source: String, path: String) throws -> [String] { let pattern = try NSRegularExpression(pattern: #"\b(?:try\s*\?|as\s*!)"#) let allowance = try NSRegularExpression(pattern: #"// swift-safety: allow-try\? -- \S.*"#) var failures: [String] = [] let lines = source.replacingOccurrences(of: "\r\n", with: "\n").components(separatedBy: .newlines) for (index, line) in lines.enumerated() { let code = line.components(separatedBy: "//")[0] let matches = pattern.matches(in: code, range: NSRange(code.startIndex..., in: code)) guard !matches.isEmpty else { continue } let onlyOptionalTry = matches.allSatisfy { match in guard let range = Range(match.range, in: code) else { return false } return code[range].hasPrefix("try") } let reason = allowance.firstMatch(in: line, range: NSRange(line.startIndex..., in: line)) != nil if onlyOptionalTry && reason { continue } failures.append( "\(path):\(index + 1): surface errors and use checked casts; intentional optional failure needs " + "// swift-safety: allow-try" + "? -- reason") } return failures } static func preparedCatalog(_ catalog: DevJSON) throws -> DevJSON { var catalog = try catalog.requireObject() guard let sourceLanguage = catalog["sourceLanguage"]?.string, !sourceLanguage.isEmpty, let entries = catalog["strings"] else { throw DevError("Catalog needs sourceLanguage and strings") } var strings = try entries.requireObject() for (key, entry) in strings { var entry = try entry.requireObject() var localizations = try (entry["localizations"] ?? .object([:])).requireObject() if localizations[sourceLanguage] == nil { localizations[sourceLanguage] = .object([ "stringUnit": .object(["state": .string("translated"), "value": .string(key)]) ]) } entry["localizations"] = .object(localizations) strings[key] = .object(entry) } catalog["strings"] = .object(strings) return .object(catalog) } static func packageTargetCount(_ package: DevJSON) throws -> Int { let package = try package.requireObject() guard package["swiftLanguageVersions"] == .array([.string("6")]), let targets = package["targets"] else { throw DevError("Package must use Swift language version 6") } var count = 0 for target in try targets.requireArray() { let target = try target.requireObject() guard let name = target["name"]?.string, let type = target["type"]?.string else { throw DevError("Target needs name and type") } if type == "plugin" { continue } guard let settings = target["settings"]?.array else { throw DevError("Missing settings: \(name)") } if name == "CPrivateAPI" { let hasWarnings = settings.contains { setting in setting["tool"] == .string("c") && setting["kind"]?["unsafeFlags"]?["_0"]?.array?.contains(.string("-Werror")) == true } guard hasWarnings else { throw DevError("Missing C warnings-as-errors: \(name)") } } else { let kinds = settings.filter { $0["tool"] == .string("swift") }.compactMap { $0["kind"] } let required: [DevJSON] = [ .object(["treatAllWarnings": .object(["_0": .string("error")])]), .object(["enableUpcomingFeature": .object(["_0": .string("ExistentialAny")])]), .object(["enableUpcomingFeature": .object(["_0": .string("InternalImportsByDefault")])]), ] for kind in required { guard kinds.contains(kind) else { throw DevError("Missing Swift compiler setting for \(name): \(kind)") } } } count += 1 } return count } }