Resolve ASAN issues

Author: CodaFi

Sources/FileCheck/CheckString.swift

@@ -386,45 +386,52 @@ private func diagnoseFailedCheck(
     return
   }
 
-  for i in 0..<min(buffer.count, 4096) {
-    let strIndex = buffer.index(buffer.startIndex, offsetBy: i)
-    let char = buffer[strIndex]
-    if char == "\n" {
-      NumLinesForward += 1
-    }
+  let exampleStringLen = exampleString.count
+  exampleString.withCString { (exampleBuf) -> Void in
+    for i in 0..<min(buffer.count, 4096) {
+      let strIndex = buffer.index(buffer.startIndex, offsetBy: i)
+      let char = buffer[strIndex]
+      if char == "\n" {
+        NumLinesForward += 1
+      }
 
-    // Patterns have leading whitespace stripped, so skip whitespace when
-    // looking for something which looks like a pattern.
-    if char == " " || char == "\t" {
-      continue;
-    }
+      // Patterns have leading whitespace stripped, so skip whitespace when
+      // looking for something which looks like a pattern.
+      if char == " " || char == "\t" {
+        continue;
+      }
 
-    let subEndIdx: String.Index
-    if buffer.count < exampleString.count + i {
-      subEndIdx = buffer.endIndex
-    } else {
-      subEndIdx = buffer.index(buffer.startIndex, offsetBy: exampleString.count + i)
-    }
-    let subBuffer = buffer[strIndex..<subEndIdx]
-
-    // Compute the "quality" of this match as an arbitrary combination of
-    // the match distance and the number of lines skipped to get to this
-    // match.
-    let distance = editDistance(from: subBuffer, to: exampleString)
-    let quality = Double(distance) + (Double(NumLinesForward) / 100.0)
-    if quality < BestQuality || BestLine == nil {
-      BestLine = i
-      BestQuality = quality
+      let subEndIdx: String.Index
+      if buffer.count < exampleString.count + i {
+        subEndIdx = buffer.endIndex
+      } else {
+        subEndIdx = buffer.index(buffer.startIndex, offsetBy: exampleString.count + i)
+      }
+      let subBuffer = buffer[strIndex..<subEndIdx]
+
+      // Compute the "quality" of this match as an arbitrary combination of
+      // the match distance and the number of lines skipped to get to this
+      // match.
+      let bodyBufLen = subBuffer.count
+      let distance = subBuffer.withCString { (bodyBuf) -> Int in
+        return editDistance(from: bodyBuf, fromLength: bodyBufLen,
+                            to: exampleBuf, toLength: exampleStringLen)
+      }
+      let quality = Double(distance) + (Double(NumLinesForward) / 100.0)
+      if quality < BestQuality || BestLine == nil {
+        BestLine = i
+        BestQuality = quality
+      }
     }
-  }
 
-  if let Best = BestLine, BestQuality < 50 {
-    buffer.utf8CString.withUnsafeBufferPointer { buf in
-      let otherPatternLoc = CheckLocation.inBuffer(
-        buf.baseAddress!.advanced(by: Best),
-        UnsafeBufferPointer(start: buf.baseAddress?.advanced(by: Best), count: buf.count - Best)
-      )
-      diagnose(.note, at: otherPatternLoc, with: "possible intended match here", options: options)
+    if let Best = BestLine, BestQuality < 50 {
+      buffer.utf8CString.withUnsafeBufferPointer { buf in
+        let otherPatternLoc = CheckLocation.inBuffer(
+          buf.baseAddress!.advanced(by: Best),
+          UnsafeBufferPointer(start: buf.baseAddress?.advanced(by: Best), count: buf.count - Best)
+        )
+        diagnose(.note, at: otherPatternLoc, with: "possible intended match here", options: options)
+      }
     }
   }
 }

Sources/FileCheck/EditDistance.swift

@@ -6,13 +6,16 @@
 /// - returns: the minimum number of element insertions, removals, or
 ///   replacements needed to transform one of the given sequences into the
 ///   other. If zero, the sequences are identical.
-func editDistance(from fa : Substring, to ta : Substring) -> Int {
-  guard !fa.isEmpty else {
-    return ta.count
+func editDistance(
+  from fa : UnsafePointer<CChar>, fromLength: Int,
+  to ta : UnsafePointer<CChar>, toLength: Int
+) -> Int {
+  guard fromLength != 0 else {
+    return toLength
   }
 
-  guard !ta.isEmpty else {
-    return fa.count
+  guard toLength != 0 else {
+    return fromLength
   }
 
   // The algorithm implemented below is the "classic"
@@ -27,12 +30,14 @@ func editDistance(from fa : Substring, to ta : Substring) -> Int {
   // only the entries to the left, top, and top-left are needed.  The left
   // entry is in `row[x-1]`, the top entry is what's in `row[x]` from the last
   // iteration, and the top-left entry is stored in Previous.
-  var pre = [Int](0..<(ta.count + 1))
-  var cur = [Int](repeating: 0, count: ta.count + 1)
+  var pre = [Int](0..<(toLength + 1))
+  var cur = [Int](repeating: 0, count: toLength + 1)
 
-  for (i, ca) in fa.enumerated() {
+  for i in 0..<fromLength {
+    let ca = fa[i]
     cur[0] = i + 1;
-    for (j, cb) in ta.enumerated() {
+    for j in 0..<toLength {
+      let cb = ta[j]
       cur[j + 1] = min(
         // deletion
         pre[j + 1] + 1, min(
@@ -43,5 +48,5 @@ func editDistance(from fa : Substring, to ta : Substring) -> Int {
     }
     swap(&cur, &pre)
   }
-  return pre[ta.count]
+  return pre[toLength]
 }

Sources/FileCheck/FileCheck.swift

@@ -161,14 +161,19 @@ public func fileCheckOutput(
     contents = buf
   }
 
-  let buf = contents.cString(using: .utf8)?.withUnsafeBufferPointer { buffer in
-    return readCheckStrings(in: buffer, withPrefixes: validPrefixes, checkNot: checkNot, options: options, prefixRE)
-  }
-  guard let checkStrings = buf, !checkStrings.isEmpty else {
+  guard let cstr = contents.cString(using: .utf8) else {
     return false
   }
 
-  return check(input: input, against: checkStrings, withGlobals: globals, options: options)
+  return cstr.withUnsafeBufferPointer { buffer in
+    let checkStrings = readCheckStrings(in: buffer, withPrefixes: validPrefixes,
+                                        checkNot: checkNot, options: options, prefixRE)
+    guard !checkStrings.isEmpty else {
+      return false
+    }
+
+    return check(input: input, against: checkStrings, withGlobals: globals, options: options)
+  }
 }
 
 private func overrideFDAndCollectOutput(file : FileCheckFD, of block : () -> ()) -> String {
@@ -322,11 +327,7 @@ extension CheckLocation {
       }
 
       var endPtr = ptr
-      while endPtr != buf.baseAddress!.advanced(by: buf.endIndex) && endPtr.successor().pointee != ("\n" as Character).utf8CodePoint {
-        endPtr = endPtr.successor()
-      }
-      // One more for good measure.
-      if endPtr != buf.baseAddress!.advanced(by: buf.endIndex) {
+      while buf.baseAddress!.advanced(by: buf.endIndex) - endPtr > 1 && endPtr.pointee != ("\n" as Character).utf8CodePoint {
         endPtr = endPtr.successor()
       }
       return substring(in: buf, with: NSMakeRange(buf.baseAddress!.distance(to: startPtr), startPtr.distance(to: endPtr)))
@@ -409,12 +410,11 @@ private func readCheckStrings(in buf : UnsafeBufferPointer<CChar>, withPrefixes
       continue
     }
 
-    notPattern.utf8CString.withUnsafeBufferPointer { buf in
-      let patBuf = UnsafeBufferPointer<CChar>(start: buf.baseAddress, count: buf.count - 1)
-      let pat = Pattern(checking: .not, in: buf, pattern: patBuf, withPrefix: "IMPLICIT-CHECK", at: 0, options: options)!
+    notPattern.utf8CString.withUnsafeBufferPointer { notBuf in
+      let patBuf = UnsafeBufferPointer<CChar>(start: notBuf.baseAddress, count: notBuf.count - 1)
+      let pat = Pattern(checking: .not, in: notBuf, pattern: patBuf, withPrefix: "IMPLICIT-CHECK", at: 0, options: options)!
       // Compute the message from this buffer now for diagnostics later.
-      let msg = CheckLocation.inBuffer(buf.baseAddress!, buf).message
-      implicitNegativeChecks.append(Pattern(copying: pat, at: .string("IMPLICIT-CHECK-NOT: " + msg)))
+      implicitNegativeChecks.append(Pattern(copying: pat, at: .string("IMPLICIT-CHECK-NOT: " + pat.fixedString)))
     }
   }
   var dagNotMatches = implicitNegativeChecks