Add regex stuff

src/models/capture_group_patterns.rs

@@ -25,7 +25,7 @@ use serde_derive::Deserialize;
 use std::collections::HashMap;
 use tree_sitter::{Node, Query};
 
-use super::matches::Match;
+use super::{default_configs::REGEX_QUERY_PREFIX, matches::Match};
 
 #[pyclass]
 #[derive(Deserialize, Debug, Clone, Default, PartialEq, Hash, Eq)]
@@ -40,19 +40,19 @@ impl CGPattern {
     self.0.to_string()
   }
 
-  pub(crate) fn extract_regex(&self) -> String {
-    let mut _val = &self.pattern()[4..];
-    _val.to_string()
+  pub(crate) fn extract_regex(&self) -> Result<Regex, regex::Error> {
+    let mut _val = &self.pattern()[REGEX_QUERY_PREFIX.len()..];
+    Regex::new(_val)
   }
 }
 
 impl Validator for CGPattern {
   fn validate(&self) -> Result<(), String> {
     if self.pattern().starts_with("rgx ") {
-      let mut _val = &self.pattern()[4..];
-      return Regex::new(_val)
+      return self
+        .extract_regex()
         .map(|_| Ok(()))
-        .unwrap_or(Err(format!("Cannot parse the regex - {_val}")));
+        .unwrap_or(Err(format!("Cannot parse the regex - {}", self.pattern())));
     }
     let mut parser = get_ts_query_parser();
     parser
@@ -79,7 +79,7 @@ impl Instantiate for CGPattern {
 #[derive(Debug)]
 pub(crate) enum CompiledCGPattern {
   Q(Query),
-  R(Regex), // Regex is not yet supported
+  R(Regex),
 }
 
 impl CompiledCGPattern {

src/models/default_configs.rs

@@ -31,6 +31,8 @@ pub const THRIFT: &str = "thrift";
 pub const STRINGS: &str = "strings";
 pub const TS_SCHEME: &str = "scm"; // We support scheme files that contain tree-sitter query
 
+pub const REGEX_QUERY_PREFIX: &str = "rgx ";
+
 #[cfg(test)]
 //FIXME: Remove this  hack by not passing PiranhaArguments to SourceCodeUnit
 pub(crate) const UNUSED_CODE_PATH: &str = "/dev/null";

src/models/rule_store.rs

@@ -82,7 +82,7 @@ impl RuleStore {
       return &*self
         .rule_query_cache
         .entry(pattern)
-        .or_insert_with(|| CompiledCGPattern::R(Regex::new(&cg_pattern.extract_regex()).unwrap()));
+        .or_insert_with(|| CompiledCGPattern::R(cg_pattern.extract_regex().unwrap()));
     }
 
     &*self

src/tests/test_piranha_java.rs

@@ -62,11 +62,11 @@ create_rewrite_tests! {
   test_non_seed_user_rule:  "non_seed_user_rule", 1, substitutions = substitutions! {"input_type_name" => "ArrayList"};
   test_insert_field_and_initializer:  "insert_field_and_initializer", 1;
   test_user_option_delete_if_empty: "user_option_delete_if_empty", 1;
-  test_user_option_do_not_delete_if_empty : "user_option_do_not_delete_if_empty", 1, delete_file_if_empty =false;
+  test_user_option_do_not_delete_if_empty : "user_option_do_not_delete_if_empty", 1, delete_file_if_empty = false;
   test_new_line_character_used_in_string_literal:  "new_line_character_used_in_string_literal",   1;
   test_java_delete_method_invocation_argument: "delete_method_invocation_argument", 1;
   test_java_delete_method_invocation_argument_no_op: "delete_method_invocation_argument_no_op", 0;
-  test_regex_based_matcher: "regex_based_matcher", 1;
+  test_regex_based_matcher: "regex_based_matcher", 1, cleanup_comments = true;
 }
 
 create_match_tests! {

src/utilities/regex_utilities.rs

@@ -25,11 +25,10 @@ use tree_sitter::Node;
 /// * `replace_node` - node to replace
 ///
 /// # Returns
-/// The range of the match in the source code and the corresponding mapping from tags to code snippets.
+/// List containing all the matches against `node`
 pub(crate) fn get_all_matches_for_regex(
   node: &Node, source_code: String, regex: &Regex, recursive: bool, replace_node: Option<String>,
 ) -> Vec<Match> {
-  // let code_snippet = node.utf8_text(source_code.as_bytes()).unwrap();
   let all_captures = regex.captures_iter(&source_code).collect_vec();
   let names = regex.capture_names().collect_vec();
   let mut all_matches = vec![];
@@ -40,21 +39,25 @@ pub(crate) fn get_all_matches_for_regex(
     let range_matches_inside_node = node.start_byte() <= captures.get(0).unwrap().start()
       && node.end_byte() >= captures.get(0).unwrap().end();
     if (recursive && range_matches_inside_node) || range_matches_node {
-      let group_by_tag = if let Some(ref rn) = replace_node {
+      let replace_node_match = if let Some(ref rn) = replace_node {
         captures
           .name(rn)
-          .unwrap_or_else(|| panic!("the tag {rn} provided in the replace node is not present"))
+          .unwrap_or_else(|| panic!("The tag {rn} provided in the replace node is not present"))
       } else {
         captures.get(0).unwrap()
       };
       let matches = extract_captures(&captures, &names);
-      all_matches.push(Match::from_regex(&group_by_tag, matches, &source_code));
+      all_matches.push(Match::from_regex(
+        &replace_node_match,
+        matches,
+        &source_code,
+      ));
     }
   }
   all_matches
 }
 
-// Creates an hashmap from the capture group(name) to the corresponding code snippet.
+// Creates a hashmap from the capture group(name) to the corresponding code snippet.
 fn extract_captures(
   captures: &regex::Captures<'_>, names: &Vec<Option<&str>>,
 ) -> HashMap<String, String> {

src/utilities/tree_sitter_utilities.rs

@@ -57,7 +57,7 @@ pub(crate) fn get_all_matches_for_query(
     // If `recursive` it allows matches to the subtree of self (Node)
     // Else it ensure that the query perfectly matches the node (`self`).
     if recursive || range_matches_self {
-      let mut replace_node_range: Range = captured_node_range;
+      let mut replace_node_range = captured_node_range;
       if let Some(replace_node_name) = &replace_node {
         if let Some(r) =
           get_range_for_replace_node(query, &query_matches, replace_node_name, replace_node_idx)

test-resources/java/regex_based_matcher/configurations/edges.toml

@@ -18,3 +18,14 @@ to = ["update_list_int"]
 scope = "Method"
 from = "update_list_int"
 to = ["update_add"]
+
+
+[[edges]]
+scope = "File"
+from = "delete_import_our_map_of"
+to = ["change_type_from_OurHashMap", "add_import_For_hashmap"]
+
+[[edges]]
+scope = "Method"
+from = "change_type_from_OurHashMap"
+to = ["update_push"]

test-resources/java/regex_based_matcher/configurations/rules.toml

@@ -30,30 +30,75 @@ replace_node = "m_def"
 replace = "fed"
 
 
-# The below three rules do a dummy type migration from List<Integer> to NewList 
+# The below three rules do a dummy type migration from OurListOfInteger to List<Integer> 
 
-# Updates the import statement from `java.util.List` to `com.uber.NEwList`
+# Updates the import statement from `java.util.List` to `com.uber.NewList`
 [[rules]]
 name = "update_import"
-query = """rgx (?P<n>java\\.util\\.List)"""
+query = """rgx (?P<n>our\\.list\\.OurListOfInteger)"""
 replace_node = "n"
-replace = "com.uber.NewList"
+replace = "java.util.List"
 
-# Updates the type of local variables from `List<Integer>` to `com.uber.NewList`
+# Updates the type of local variables from `OurListOfInteger` to `List<Integer>`
 [[rules]]
 name = "update_list_int"
-query = """rgx (?P<var_decl>(?P<type>List<Integer>)\\s*(?P<name>\\w+)\\s*=.*;)"""
+query = """rgx (?P<var_decl>(?P<type>OurListOf(?P<param>Integer))\\s*(?P<name>\\w+)\\s*=.*;)"""
 replace_node = "type"
-replace = "NewList"
+replace = "List<@param>"
 is_seed_rule = false
 [[rules.filter]]
 enclosing_node = "(method_declaration) @cmd"
 
-# Updates the relevant callsite from `add` to `addToNewList`
+# Updates the relevant callsite from `addToOurList` to `add`
 [[rules]]
 name = "update_add"
-query = """rgx (?P<call>@name\\.(?P<m_name>add)\\(\\w+\\))"""
+query = """rgx (?P<call>@name\\.(?P<m_name>addToOurList)\\(\\w+\\))"""
 replace_node = "m_name"
-replace = "addToNewList"
+replace = "add"
+holes = ["name"]
+is_seed_rule = false
+
+
+# The below three rules do a dummy type migration  like - from OurMapOfStringInteger to HashMap<String, Integer>
+
+# Deletes the import statement `our.map.OurMapOf...` 
+[[rules]]
+name = "delete_import_our_map_of"
+query = """rgx (?P<n>import our\\.map\\.OurMapOf\\w+;)"""
+replace_node = "n"
+replace = ""
+
+# Adds Import to java.util.hashmap if absent
+[[rules]]
+name = "add_import_For_hashmap"
+query = """(package_declaration) @pkg"""
+replace_node = "pkg"
+replace = "@pkg\nimport java.util.HashMap;"
+is_seed_rule = false
+[[rules.filters]]
+enclosing_node = "(program) @prgrm"
+not_contains = [
+  "((import_declaration) @im (#match? @im \"java.util.HashMap\"))",
+]
+
+# Before:
+# OurMapOfStringInteger
+# After: 
+# HashMap<String, Integer>
+[[rules]]
+name = "change_type_from_OurHashMap"
+query = """rgx (?P<var_decl>(?P<type>\\bOurMapOf(?P<param1>[A-Z]\\w+)(?P<param2>[A-Z]\\w+))\\s*(?P<name>\\w+)\\s*=.*;)"""
+replace_node = "type"
+replace = "HashMap<@param1, @param2>"
+is_seed_rule = false
+[[rules.filter]]
+enclosing_node = "(method_declaration) @cmd"
+
+# Updates the relevant callsite from `pushIntoOurMap` to `push`
+[[rules]]
+name = "update_push"
+query = """rgx (?P<call>@name\\.(?P<m_name>pushIntoOurMap)\\(.*\\))"""
+replace_node = "m_name"
+replace = "push"
 holes = ["name"]
 is_seed_rule = false

test-resources/java/regex_based_matcher/expected/Sample.java

@@ -1,6 +1,8 @@
 package com.uber.piranha;
 
-import com.uber.NewList;
+import java.util.HashMap;
+import java.util.List;
+import not.our.map.NotOurMapOfDoubleInteger;
 
 class A {
 
@@ -21,14 +23,33 @@ void foofn() {
 
     void someTypeChange() {
         // Will get updated
-        NewList a = getList();
+        List<Integer> a = getList();
         Integer item = getItem();
-        a.addToNewList(item);
+        a.add(item);
 
         // Will not get updated
         List<String> b = getListStr();
-        Integer item = getItemStr();
+        String item = getItemStr();
         b.add(item);
     }
 
+    void someOtherTypeChange() {
+        // Will get updated
+        HashMap<String, Integer> siMap = getMapSI();
+        String sKey = getStrKey();
+        Integer iItem = getIItem();
+        siMap.push(sKey, iItem);
+
+        // Will get updated
+        HashMap<Long, Float>  lfMap = getMapLF();
+        Long lKey = getLongKey();
+        Float fItem = getFItem();
+        lfMap.push(lKey, fItem);
+
+        // Will not get updated
+        NotOurMapOfDoubleInteger dlMap = getMapDL();
+        Double dKey = getDoubleKey();
+        dlMap.pushIntoOurMap(dKey, iItem);
+    }
+
 }

test-resources/java/regex_based_matcher/input/Sample.java

@@ -1,10 +1,14 @@
 package com.uber.piranha;
 
-import java.util.List;
+import our.list.OurListOfInteger;
+import our.map.OurMapOfStringInteger;
+import our.map.OurMapOfLongFloat;
+import not.our.map.NotOurMapOfDoubleInteger;
 
 class A {
 
     void foobar() {
+        // Will be removed
         boolean b = foo().bar().baz();
         if (b) {
             System.out.println("Hello World!");
@@ -24,14 +28,33 @@ void foofn() {
 
     void someTypeChange() {
         // Will get updated
-        List<Integer> a = getList();
+        OurListOfInteger a = getList();
         Integer item = getItem();
-        a.add(item);
+        a.addToOurList(item);
 
         // Will not get updated
         List<String> b = getListStr();
-        Integer item = getItemStr();
+        String item = getItemStr();
         b.add(item);
     }
 
+    void someOtherTypeChange() {
+        // Will get updated
+        OurMapOfStringInteger siMap = getMapSI();
+        String sKey = getStrKey();
+        Integer iItem = getIItem();
+        siMap.pushIntoOurMap(sKey, iItem);
+
+        // Will get updated
+        OurMapOfLongFloat lfMap = getMapLF();
+        Long lKey = getLongKey();
+        Float fItem = getFItem();
+        lfMap.pushIntoOurMap(lKey, fItem);
+
+        // Will not get updated
+        NotOurMapOfDoubleInteger dlMap = getMapDL();
+        Double dKey = getDoubleKey();
+        dlMap.pushIntoOurMap(dKey, iItem);
+    }
+
 }