Add ClosingParenthese marker to add extra parentheses

rewrite-groovy/src/main/java/org/openrewrite/groovy/GroovyParserVisitor.java

@@ -1630,27 +1630,20 @@ public void visitMapExpression(MapExpression map) {
             queue.add(new G.MapLiteral(randomId(), prefix, Markers.EMPTY, entries, typeMapping.type(map.getType())));
         }
 
-        // zero or more ")" AND "?." or "*." or "." AND <rest>
-        private final Pattern MATCH_INVOKE = Pattern.compile("^(\\)*)(\\*?\\??\\.).*", Pattern.DOTALL);
-
         @Override
         public void visitMethodCallExpression(MethodCallExpression call) {
             queue.add(insideParentheses(call, fmt -> {
+                Markers markers = Markers.EMPTY;
 
                 ImplicitDot implicitDot = null;
                 JRightPadded<Expression> select = null;
                 if (!call.isImplicitThis()) {
-                    System.out.println("aaaa");
                     Expression selectExpr = visit(call.getObjectExpression());
                     int saveCursor = cursor;
                     Space afterSelect = whitespace();
-                    Matcher matcher = MATCH_INVOKE.matcher(source.substring(cursor));
-                    if (matcher.matches()) {
+                    if (source.charAt(cursor) == '.' || source.charAt(cursor) == '?' || source.charAt(cursor) == '*') {
                         cursor = saveCursor;
-                        afterSelect = sourceBefore(matcher.group(1) + matcher.group(2));
-                        /*if (!matcher.group(1).isEmpty()) {
-                            afterSelect.withWhitespace(matcher.group(1) + afterSelect.getWhitespace());
-                        }*/
+                        afterSelect = sourceBefore(call.isSpreadSafe() ? "*." : call.isSafe() ? "?." : ".");
                     } else {
                         implicitDot = new ImplicitDot(randomId());
                     }
@@ -1691,7 +1684,6 @@ public void visitMethodCallExpression(MethodCallExpression call) {
                     name = name.withMarkers(name.getMarkers().add(implicitDot));
                 }
                 // Method invocations may have type information that can enrich the type information of its parameters
-                Markers markers = Markers.EMPTY;
                 if (call.getArguments() instanceof ArgumentListExpression) {
                     ArgumentListExpression args = (ArgumentListExpression) call.getArguments();
                     if (call.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE) != null) {
@@ -1764,6 +1756,16 @@ public void visitMethodCallExpression(MethodCallExpression call) {
                 } else {
                     methodType = typeMapping.methodType(methodNode);
                 }
+
+                if (source.charAt(cursor) == ')') {
+                    int closingParenthese = 0;
+                    while (source.charAt(cursor) == ')') {
+                        closingParenthese++;
+                        cursor++;
+                    }
+                    markers = markers.add(new ClosingParenthese(randomId(), closingParenthese));
+                }
+
                 return new J.MethodInvocation(randomId(), fmt, markers,
                         select, null, name, args, methodType);
             }));

rewrite-groovy/src/main/java/org/openrewrite/groovy/GroovyPrinter.java

@@ -24,6 +24,7 @@
 import org.openrewrite.groovy.tree.GContainer;
 import org.openrewrite.groovy.tree.GRightPadded;
 import org.openrewrite.groovy.tree.GSpace;
+import org.openrewrite.internal.StringUtils;
 import org.openrewrite.java.JavaPrinter;
 import org.openrewrite.java.tree.*;
 import org.openrewrite.marker.Marker;
@@ -380,6 +381,12 @@ public J visitMethodInvocation(J.MethodInvocation method, PrintOutputCapture<P>
                 }
             }
 
+            if (method.getMarkers().findFirst(ClosingParenthese.class).isPresent()) {
+                System.out.println(method);
+                System.out.println("PRESENT");
+                p.append(StringUtils.repeat(")", method.getMarkers().findFirst(ClosingParenthese.class).get().getAmount()));
+            }
+
             afterSyntax(method, p);
             return method;
         }

rewrite-groovy/src/main/java/org/openrewrite/groovy/marker/ClosingParenthese.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2021 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.groovy.marker;
+
+import lombok.Value;
+import lombok.With;
+import org.openrewrite.marker.Marker;
+
+import java.util.UUID;
+
+@Value
+@With
+public class ClosingParenthese implements Marker {
+    UUID id;
+    int amount;
+}

rewrite-groovy/src/test/java/org/openrewrite/groovy/tree/BinaryTest.java

@@ -206,8 +206,8 @@ void extraParenthesesAroundMethodInvocationSelects() {
         rewriteRun(
           groovy(
             """
-              def foo(Map map) {
-                  map.containsKey("foo") && (map.get("foo")).equals("bar")
+              def foo(Map someMap) {
+                  (someMap.get("bar")).equals("baz")
               }
               """
           )