Add method to deal with matrix and fix comment

experiments/inferred-annos-counter/app/src/main/java/org/checkerframework/wholeprograminference/inferredannoscounter/InferredAnnosCounter.java

@@ -11,7 +11,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.checkerframework.checker.index.qual.IndexFor;
 
 /**
  * The entry point for the inferred annos counter. Run this by passing arguments, with the first
@@ -68,7 +67,7 @@ private static boolean checkGoogleFormatOpenCase(String line) {
     }
     String elements[] = line.split(" ");
     int n = elements.length;
-    if (n >= 1 && elements[n - 1].contains("@org.checkerframework")) {
+    if (n >= 1 && elements[n - 1].contains("@org")) {
       String breaks[] = elements[n - 1].split("[.]");
       int numberOfParts = breaks.length;
       if (numberOfParts < 2) {
@@ -270,18 +269,21 @@ private static int countAnnos(String line) {
    * This method checks if a particular index in a line belongs to a string literal
    *
    * @param line a line
-   * @param Index index of line
-   * @return true if Index belong to a string literal, false otherwise
+   * @param index index of line
+   * @return false if index belongs to a string literal, true otherwise
    */
-  private static boolean checkInString(@IndexFor("#2") int Index, String line) {
+  private static boolean checkInString(int index, String line) {
+    if (index >= line.length() || index < 0) {
+      throw new RuntimeException("The index provided for checkInString is not valid");
+    }
     int before = 0;
     int after = 0;
-    for (int i = 0; i < Index; i++) {
+    for (int i = 0; i < index; i++) {
       if (line.charAt(i) == '\"') {
         before++;
       }
     }
-    for (int i = Index + 1; i < line.length(); i++) {
+    for (int i = index + 1; i < line.length(); i++) {
       if (line.charAt(i) == '\"') {
         after++;
       }
@@ -292,6 +294,70 @@ private static boolean checkInString(@IndexFor("#2") int Index, String line) {
     return false;
   }
 
+  /**
+   * This method replaces a particular character at an index of a string with a new symbol.
+   *
+   * @param line a line that needs to be modified
+   * @param index a valid index of that line, which is non-negative and less than the length of line
+   * @param symbol the new character
+   * @return the line with the character at index replaced by symbol
+   */
+  private static String replaceAtIndex(String line, int index, String symbol) {
+    if (index < 0 || index > line.length()) {
+      throw new RuntimeException("The index provided for replaceAtIndex is not valid");
+    }
+    String result = line;
+    String firstPart = result.substring(0, index);
+    if (index + 1 < result.length()) {
+      String secondPart = result.substring(index + 1, result.length());
+      result = firstPart + symbol + secondPart;
+    } else // the element at index is also the last element of the string
+    {
+      result = firstPart + symbol;
+    }
+
+    return result;
+  }
+
+  /**
+   * This method formats annotations that contain arguments, such as @EnsuresNonNull("tz1").
+   * Previously, we had a problem when working with these types of annotations. The
+   * computer-generated files sometimes put an additional pair of curly braces. Initially, we
+   * approached this problem by adding a pair of curly braces to every annotation having a pair of
+   * parentheses but no curly braces. But then we might run into a problem if there are parentheses
+   * inside the arguments. This new method has two parts. First, we check if the annotation contains
+   * a matrix and format the matrix if we found one. We format it by changing all "}, {" pattern to
+   * "|, |". Second, we'll remove all curly braces in that annotation. By this way way, we make sure
+   * that we will not mess up the important curly braces, otherwise something like ({3, 4}) and
+   * ({3}, {4}) will both end up being (3,4).
+   *
+   * @param annotation an annotation to be formatted
+   * @return formatted annotation
+   */
+  private static String formatAnnotaionsWithArguments(String annotation) {
+    String result = annotation;
+    /*
+    First, we format cases involving matrix by changing all "}, {" to "|, |"
+     */
+    int indexOfClose = result.indexOf("},");
+    while (indexOfClose != -1) {
+      int indexOfOpen = result.indexOf('{', indexOfClose);
+      if (checkInString(indexOfClose, result)) {
+        result = replaceAtIndex(result, indexOfClose, "|");
+        result = replaceAtIndex(result, indexOfOpen, "|");
+        indexOfClose = result.indexOf("},");
+      } else {
+        indexOfOpen = result.indexOf("},", indexOfClose + 1);
+      }
+    }
+    /*
+    Second, we will remove all curly braces
+     */
+    result = result.replace("{", "");
+    result = result.replace("}", "");
+    return result;
+  }
+
   /**
    * This method trims out all the comments in a line from the input files
    *
@@ -301,13 +367,13 @@ private static boolean checkInString(@IndexFor("#2") int Index, String line) {
   private static String ignoreComment(String line) {
     int indexComment = line.length() + 1;
     String finalLine = line;
-    int indexDash = line.indexOf("// ");
+    int indexDash = line.indexOf("//");
     int indexStar = line.indexOf("*");
     int indexDashStar = line.indexOf("/*");
     if (indexDash != -1) {
       if (indexDash == 0) {
         finalLine = line.substring(0, indexDash);
-      } else {
+      } else if (checkInString(indexDash, line)) {
         finalLine = line.substring(0, indexDash - 1);
       }
     }
@@ -473,15 +539,11 @@ public static void main(String[] args) {
       // since it's too difficult to keep the length of whitespace at the beginning of each line the
       // same
       originalFileLine = originalFileLine.trim();
-      originalFile.add(originalFileLine);
       String specialAnno = trimParen(originalFileLine);
       // the fact that this if statement's condition is true means that this line contains exactly
       // one CF annotation and nothing else.
       if (checkerPackage.contains(specialAnno)) {
-        if (originalFileLine.contains("(") && !originalFileLine.contains("{")) {
-          originalFileLine = originalFileLine.replace("(", "({");
-          originalFileLine = originalFileLine.replace(")", "})");
-        }
+        originalFileLine = formatAnnotaionsWithArguments(originalFileLine);
         if (annoCount.containsKey(specialAnno)) {
           int numberOfAnno = annoCount.get(specialAnno);
           annoCount.put(specialAnno, numberOfAnno + 1);
@@ -492,6 +554,7 @@ public static void main(String[] args) {
         // we want the keys in the map annoLocate has this following format: type_position
         annoLocate.put(originalFileLine + "_" + originalFileLineIndex, 0);
       }
+      originalFile.add(originalFileLine);
       originalFileLineCount = originalFileLineIndex;
     }
     // Iterate over the arguments from 1 to the end and diff each with the original,
@@ -506,6 +569,10 @@ public static void main(String[] args) {
       List<String> newFile = new ArrayList<>();
       for (String ajavaFileLine : inputFileWithEachAnnoOnOneLine2) {
         ajavaFileLine = ignoreComment(ajavaFileLine);
+        // if the condition is true, this line contains only one single annotation and nothing else.
+        if (ajavaFileLine.contains("@org")) {
+          ajavaFileLine = formatAnnotaionsWithArguments(ajavaFileLine);
+        }
         ajavaFileLine = extractCheckerPackage(ajavaFileLine);
         ajavaFileLine = ajavaFileLine.trim();
         newFile.add(ajavaFileLine);