Support one-line-one-function file format for asyncify lists (#6051)

If there are newlines in the list, then we split using them in a simple manner
(that does not take into account nesting of any other delimiters).

Fixes #6047
Fixes #5271

2 files changed, 43 insertions, 7 deletions

diff --git a/src/passes/Asyncify.cpp b/src/passes/Asyncify.cpp
index 2412a754a..b30af085e 100644
--- a/src/passes/Asyncify.cpp
+++ b/src/passes/Asyncify.cpp
@@ -1626,7 +1626,8 @@ struct Asyncify : public Pass {
       options.getArgumentOrDefault("asyncify-ignore-imports", "");
     bool allImportsCanChangeState =
       stateChangingImports == "" && ignoreImports == "";
-    String::Split listedImports(stateChangingImports, ",");
+    String::Split listedImports(stateChangingImports,
+                                String::Split::NewLineOr(","));
     // canIndirectChangeState is the default.  asyncify-ignore-indirect sets it
     // to false.
     auto canIndirectChangeState =
@@ -1638,11 +1639,12 @@ struct Asyncify : public Pass {
       removeListInput = options.getArgumentOrDefault("asyncify-blacklist", "");
     }
     String::Split removeList(
-      String::trim(read_possible_response_file(removeListInput)), ",");
+      String::trim(read_possible_response_file(removeListInput)),
+      String::Split::NewLineOr(","));
     String::Split addList(
       String::trim(read_possible_response_file(
         options.getArgumentOrDefault("asyncify-addlist", ""))),
-      ",");
+      String::Split::NewLineOr(","));
     std::string onlyListInput =
       options.getArgumentOrDefault("asyncify-onlylist", "");
     if (onlyListInput.empty()) {
@@ -1650,7 +1652,8 @@ struct Asyncify : public Pass {
       onlyListInput = options.getArgumentOrDefault("asyncify-whitelist", "");
     }
     String::Split onlyList(
-      String::trim(read_possible_response_file(onlyListInput)), ",");
+      String::trim(read_possible_response_file(onlyListInput)),
+      String::Split::NewLineOr(","));
     auto asserts = options.hasArgument("asyncify-asserts");
     auto verbose = options.hasArgument("asyncify-verbose");
     auto relocatable = options.hasArgument("asyncify-relocatable");
diff --git a/src/support/string.h b/src/support/string.h
index a73121f6b..751efdac5 100644
--- a/src/support/string.h
+++ b/src/support/string.h
@@ -31,10 +31,14 @@ namespace wasm::String {
 
 // Creates a vector of the split parts of a string, by a delimiter.
 class Split : public std::vector<std::string> {
-public:
-  Split() = default;
+private:
+  // If we split on newlines then we do not need to handle bracketing at all.
+  // Otherwise, splitting on say "," does require us to understanding the
+  // scoping of brackets, e.g., "foo(x, y),bar" should be split as "foo(x, y)",
+  // "bar".
+  bool needToHandleBracketingOperations = true;
 
-  Split(const std::string& input, const std::string& delim) {
+  void split(const std::string& input, const std::string& delim) {
     size_t lastEnd = 0;
     while (lastEnd < input.size()) {
       auto nextDelim = input.find(delim, lastEnd);
@@ -44,6 +48,31 @@ public:
       (*this).push_back(input.substr(lastEnd, nextDelim - lastEnd));
       lastEnd = nextDelim + delim.size();
     }
+    needToHandleBracketingOperations = delim != "\n";
+  }
+  friend String::Split handleBracketingOperators(String::Split split);
+
+public:
+  // This can be used when we want to split on newlines if there are any, and if
+  // there are not, then using the given delimiter.
+  struct NewLineOr {
+    const std::string delim;
+    explicit NewLineOr(const std::string& delim) : delim(delim) {}
+  };
+
+  Split() = default;
+
+  Split(const std::string& input, const NewLineOr& newLineOrDelim) {
+    auto first = input.find("\n", 0);
+    if (first != std::string::npos && first != input.length() - 1) {
+      split(input, "\n");
+    } else {
+      split(input, newLineOrDelim.delim);
+    }
+  }
+
+  Split(const std::string& input, const std::string& delim) {
+    split(input, delim);
   }
 };
 
@@ -53,6 +82,10 @@ public:
 // must be kept together because of the "(". Likewise, "{", "<", "[" are
 // handled.
 inline String::Split handleBracketingOperators(String::Split split) {
+  if (!split.needToHandleBracketingOperations) {
+    return split;
+  }
+
   String::Split ret;
   std::string last;
   int nesting = 0;