Merge pull request #369 from owenv/sanitize-coverage

Add validation for -sanitize-coverage=

Author: owenv

Sources/SwiftDriver/Driver/Driver.swift

@@ -463,6 +463,10 @@ public struct Driver {
       toolchain: toolchain,
       targetInfo: frontendTargetInfo)
 
+    Self.validateSanitizerCoverageArgs(&parsedOptions,
+                                       anySanitizersEnabled: !enabledSanitizers.isEmpty,
+                                       diagnosticsEngine: diagnosticsEngine)
+
     // Supplemental outputs.
     self.dependenciesFilePath = try Self.computeSupplementaryOutputPath(
         &parsedOptions, type: .dependencies, isOutputOptions: [.emitDependencies],
@@ -1411,7 +1415,7 @@ extension Driver {
       }
 
       if !parsedOptions.contains(in: .g) {
-        diagnosticsEngine.emit(.error_option_missing_required_argument(option: .debugInfoFormat, requiredArg: .g))
+        diagnosticsEngine.emit(.error_option_missing_required_argument(option: .debugInfoFormat, requiredArg: "-g"))
       }
     } else {
       // Default to DWARF.
@@ -1885,6 +1889,28 @@ extension Driver {
       }
     }
   }
+
+  private static func validateSanitizerCoverageArgs(_ parsedOptions: inout ParsedOptions,
+                                                    anySanitizersEnabled: Bool,
+                                                    diagnosticsEngine: DiagnosticsEngine) {
+    var foundRequiredArg = false
+    for arg in parsedOptions.arguments(for: .sanitizeCoverageEQ).flatMap(\.argument.asMultiple) {
+      if ["func", "bb", "edge"].contains(arg) {
+        foundRequiredArg = true
+      } else if !["indirect-calls", "trace-bb", "trace-cmp", "8bit-counters", "trace-pc", "trace-pc-guard"].contains(arg) {
+        diagnosticsEngine.emit(.error_unsupported_argument(argument: arg, option: .sanitizeCoverageEQ))
+      }
+
+      if !foundRequiredArg {
+        diagnosticsEngine.emit(.error_option_missing_required_argument(option: .sanitizeCoverageEQ,
+                                                                       requiredArg: #""func", "bb", "edge""#))
+      }
+    }
+
+    if parsedOptions.hasArgument(.sanitizeCoverageEQ) && !anySanitizersEnabled {
+      diagnosticsEngine.emit(.error_option_requires_sanitizer(option: .sanitizeCoverageEQ))
+    }
+  }
 }
 
 extension Triple {

Sources/SwiftDriver/Utilities/Diagnostics.swift

@@ -17,14 +17,22 @@ extension Diagnostic.Message {
     .error("-static may not be used with -emit-executable")
   }
 
-  static func error_option_missing_required_argument(option: Option, requiredArg: Option) -> Diagnostic.Message {
-    .error("option '\(option.spelling)' is missing a required argument (\(requiredArg.spelling))")
+  static func error_option_missing_required_argument(option: Option, requiredArg: String) -> Diagnostic.Message {
+    .error("option '\(option.spelling)' is missing a required argument (\(requiredArg))")
   }
 
   static func error_opt_invalid_mapping(option: Option, value: String) -> Diagnostic.Message {
     .error("values for '\(option.spelling)' must be in the format 'original=remapped', but '\(value)' was provided")
   }
 
+  static func error_unsupported_argument(argument: String, option: Option) -> Diagnostic.Message {
+    .error("unsupported argument '\(argument)' to option '\(option.spelling)'")
+  }
+
+  static func error_option_requires_sanitizer(option: Option) -> Diagnostic.Message {
+    .error("option '\(option.spelling)' requires a sanitizer to be enabled. Use -sanitize= to enable a sanitizer")
+  }
+
   static func error_invalid_arg_value(arg: Option, value: String) -> Diagnostic.Message {
     .error("invalid value '\(value)' in '\(arg.spelling)'")
   }

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -1420,6 +1420,23 @@ final class SwiftDriverTests: XCTestCase {
   #endif
   }
 
+  func testSanitizerCoverageArgs() throws {
+    try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-sanitize=thread", "-sanitize-coverage=bar"]) {
+      $1.expect(.error("option '-sanitize-coverage=' is missing a required argument (\"func\", \"bb\", \"edge\")"))
+      $1.expect(.error("unsupported argument 'bar' to option '-sanitize-coverage='"))
+    }
+
+    try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-sanitize=thread", "-sanitize-coverage=func,baz"]) {
+      $1.expect(.error("unsupported argument 'baz' to option '-sanitize-coverage='"))
+    }
+
+    try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-sanitize-coverage=func,trace-cmp"]) {
+      $1.expect(.error("option '-sanitize-coverage=' requires a sanitizer to be enabled. Use -sanitize= to enable a sanitizer"))
+    }
+
+    try assertNoDriverDiagnostics(args: "swiftc", "foo.swift", "-sanitize=thread", "-sanitize-coverage=edge,indirect-calls,trace-bb,trace-cmp,8bit-counters")
+  }
+
   func testBatchModeCompiles() throws {
     do {
       var driver1 = try Driver(args: ["swiftc", "foo1.swift", "bar1.swift", "foo2.swift", "bar2.swift", "foo3.swift", "bar3.swift", "foo4.swift", "bar4.swift", "foo5.swift", "bar5.swift", "wibble.swift", "-module-name", "Test", "-enable-batch-mode", "-driver-batch-count", "3"])