Regex fuzzer: identifier mutation

Mutates a WGSL-like string by replacing a randomly-selected identifier
with a different randomly-selected identifier.

Change-Id: Iecf45ad2800677cf3609b30d415520e5f2a05ba0
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/60561
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Alastair Donaldson <afdx@google.com>
Commit-Queue: Alastair Donaldson <afdx@google.com>

fuzzers/tint_regex_fuzzer/wgsl_mutator.cc

@@ -40,31 +40,68 @@ std::vector<size_t> FindDelimiterIndices(const std::string& delimiter,
   return result;
 }
 
-void SwapIntervals(size_t idx1,
-                   size_t idx2,
-                   size_t idx3,
-                   size_t idx4,
-                   std::string& wgsl_code) {
-  std::string region_1 = wgsl_code.substr(idx1 + 1, idx2 - idx1);
+std::vector<std::pair<size_t, size_t>> GetIdentifiers(
+    const std::string& wgsl_code) {
+  std::vector<std::pair<size_t, size_t>> result;
 
-  std::string region_2 = wgsl_code.substr(idx3 + 1, idx4 - idx3);
+  // This regular expression works by looking for a character that
+  // is not part of an identifier followed by a WGSL identifier, followed
+  // by a character which cannot be part of a WGSL identifer. The regex
+  // for the WGSL identifier is obtained from:
+  // https://www.w3.org/TR/WGSL/#identifiers.
+  std::regex wgsl_identifier_regex(
+      "[^a-zA-Z]([a-zA-Z][0-9a-zA-Z_]*)[^0-9a-zA-Z_]");
+
+  std::smatch match;
+
+  std::string::const_iterator search_start(wgsl_code.cbegin());
+  std::string prefix;
+
+  while (regex_search(search_start, wgsl_code.cend(), match,
+                      wgsl_identifier_regex) == true) {
+    prefix += match.prefix();
+    result.push_back(std::make_pair(prefix.size() + 1, match.str(1).size()));
+    prefix += match.str(0);
+    search_start = match.suffix().first;
+  }
+  return result;
+}
+
+void SwapIntervals(size_t idx1,
+                   size_t reg1_len,
+                   size_t idx2,
+                   size_t reg2_len,
+                   std::string& wgsl_code) {
+  std::string region_1 = wgsl_code.substr(idx1 + 1, reg1_len - 1);
+
+  std::string region_2 = wgsl_code.substr(idx2 + 1, reg2_len - 1);
 
   // The second transformation is done first as it doesn't affect ind1 and ind2
-  wgsl_code.replace(idx3 + 1, region_2.size(), region_1);
+  wgsl_code.replace(idx2 + 1, region_2.size(), region_1);
 
   wgsl_code.replace(idx1 + 1, region_1.size(), region_2);
 }
 
-void DeleteInterval(size_t idx1, size_t idx2, std::string& wgsl_code) {
-  wgsl_code.erase(idx1 + 1, idx2 - idx1);
+void DeleteInterval(size_t idx1, size_t reg_len, std::string& wgsl_code) {
+  wgsl_code.erase(idx1 + 1, reg_len - 1);
 }
 
 void DuplicateInterval(size_t idx1,
+                       size_t reg1_len,
                        size_t idx2,
-                       size_t idx3,
                        std::string& wgsl_code) {
-  std::string region = wgsl_code.substr(idx1 + 1, idx2 - idx1);
-  wgsl_code.insert(idx3 + 1, region);
+  std::string region = wgsl_code.substr(idx1 + 1, reg1_len - 1);
+  wgsl_code.insert(idx2 + 1, region);
+}
+
+void ReplaceRegion(size_t idx1,
+                   size_t id1_len,
+                   size_t idx2,
+                   size_t id2_len,
+                   std::string& wgsl_code) {
+  std::string region_1 = wgsl_code.substr(idx1, id1_len);
+  std::string region_2 = wgsl_code.substr(idx2, id2_len);
+  wgsl_code.replace(idx2, region_2.size(), region_1);
 }
 
 bool SwapRandomIntervals(const std::string& delimiter,
@@ -89,8 +126,10 @@ bool SwapRandomIntervals(const std::string& delimiter,
   size_t ind4 = GetRandomIntFromRange(
       ind3 + 1U, delimiter_positions.size() - 1U, generator);
 
-  SwapIntervals(delimiter_positions[ind1], delimiter_positions[ind2],
-                delimiter_positions[ind3], delimiter_positions[ind4],
+  SwapIntervals(delimiter_positions[ind1],
+                delimiter_positions[ind2] - delimiter_positions[ind1],
+                delimiter_positions[ind3],
+                delimiter_positions[ind4] - delimiter_positions[ind3],
                 wgsl_code);
 
   return true;
@@ -112,7 +151,8 @@ bool DeleteRandomInterval(const std::string& delimiter,
   size_t ind2 = GetRandomIntFromRange(
       ind1 + 1U, delimiter_positions.size() - 1U, generator);
 
-  DeleteInterval(delimiter_positions[ind1], delimiter_positions[ind2],
+  DeleteInterval(delimiter_positions[ind1],
+                 delimiter_positions[ind2] - delimiter_positions[ind1],
                  wgsl_code);
 
   return true;
@@ -137,12 +177,40 @@ bool DuplicateRandomInterval(const std::string& delimiter,
   size_t ind3 =
       GetRandomIntFromRange(0, delimiter_positions.size() - 1U, generator);
 
-  DuplicateInterval(delimiter_positions[ind1], delimiter_positions[ind2],
+  DuplicateInterval(delimiter_positions[ind1],
+                    delimiter_positions[ind2] - delimiter_positions[ind1],
                     delimiter_positions[ind3], wgsl_code);
 
   return true;
 }
 
+bool ReplaceRandomIdentifier(std::string& wgsl_code, std::mt19937& generator) {
+  std::vector<std::pair<size_t, size_t>> identifiers =
+      GetIdentifiers(wgsl_code);
+
+  // Need at least 2 identifiers
+  if (identifiers.size() < 2) {
+    return false;
+  }
+
+  size_t id1_index =
+      GetRandomIntFromRange(0, identifiers.size() - 1U, generator);
+
+  size_t id2_index =
+      GetRandomIntFromRange(0, identifiers.size() - 1U, generator);
+
+  // The two identifiers must be different
+  while (id1_index == id2_index) {
+    id2_index = GetRandomIntFromRange(0, identifiers.size() - 1U, generator);
+  }
+
+  ReplaceRegion(identifiers[id1_index].first, identifiers[id1_index].second,
+                identifiers[id2_index].first, identifiers[id2_index].second,
+                wgsl_code);
+
+  return true;
+}
+
 }  // namespace regex_fuzzer
 }  // namespace fuzzers
 }  // namespace tint