UseCollectionInterfaces updates methodInvovations type info to enable import removal (#517)

* Fixed issue

* Update src/main/java/org/openrewrite/staticanalysis/UseCollectionInterfaces.java

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

* Added logic to keep type information in the method invocation

* Added method for methodUpdating

* removed unused import

* Moved private method

* formatted and inlined

* Removed whitespace changes

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: JohannisK

src/main/java/org/openrewrite/staticanalysis/UseCollectionInterfaces.java

@@ -150,6 +150,28 @@ public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, Ex
                 return m;
             }
 
+            @Override
+            public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
+                J.MethodInvocation mi = super.visitMethodInvocation(method, ctx);
+                if (mi.getSelect() != null && mi.getSelect().getType() != null) {
+                    JavaType originalType = mi.getSelect().getType();
+                    JavaType.FullyQualified fullyQualified = TypeUtils.asFullyQualified(originalType);
+                    if (fullyQualified != null) {
+                        String fullyQualifiedName = fullyQualified.getFullyQualifiedName();
+                        if (rspecRulesReplaceTypeMap.containsKey(fullyQualifiedName)) {
+                            JavaType.FullyQualified newType = TypeUtils.asFullyQualified(JavaType.buildType(rspecRulesReplaceTypeMap.get(fullyQualifiedName)));
+                            if (newType != null) {
+                                if (originalType instanceof JavaType.Parameterized) {
+                                    newType = new JavaType.Parameterized(null, newType, ((JavaType.Parameterized) originalType).getTypeParameters());
+                                }
+                                return updateMethodInvocation(mi, newType);
+                            }
+                        }
+                    }
+                }
+                return mi;
+            }
+
             @Override
             public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) {
                 J.VariableDeclarations mv = super.visitVariableDeclarations(multiVariable, ctx);
@@ -201,6 +223,16 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations m
                 return mv;
             }
 
+            private J.MethodInvocation updateMethodInvocation(J.MethodInvocation mi, JavaType.FullyQualified newType) {
+                if (mi.getSelect() != null) {
+                    mi = mi.withSelect(mi.getSelect().withType(newType));
+                }
+                if (mi.getMethodType() != null) {
+                    mi = mi.withMethodType(mi.getMethodType().withDeclaringType(newType));
+                }
+                return mi;
+            }
+
             private TypeTree removeFromParameterizedType(JavaType.FullyQualified newType,
                                                          J.ParameterizedType parameterizedType) {
                 J.Identifier returnType = new J.Identifier(

src/test/java/org/openrewrite/staticanalysis/UseCollectionInterfacesTest.java

@@ -1001,4 +1001,64 @@ void groovyDefVariable() {
           )
         );
     }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/357")
+    @Test
+    void danglingGenericReference() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+            import java.util.concurrent.ConcurrentLinkedQueue;
+
+            class B {
+                private final ConcurrentLinkedQueue<String> widgetDataList;
+                public void foo() {
+                  widgetDataList.add("TEST");
+                }
+            }
+            """,
+            """
+            import java.util.Queue;
+
+            class B {
+                private final Queue<String> widgetDataList;
+                public void foo() {
+                  widgetDataList.add("TEST");
+                }
+            }
+            """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/357")
+    @Test
+    void danglingReference() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+            import java.util.concurrent.ConcurrentLinkedQueue;
+
+            class B {
+                private final ConcurrentLinkedQueue widgetDataList;
+                public void foo() {
+                  widgetDataList.add("TEST");
+                }
+            }
+            """,
+            """
+            import java.util.Queue;
+
+            class B {
+                private final Queue widgetDataList;
+                public void foo() {
+                  widgetDataList.add("TEST");
+                }
+            }
+            """
+          )
+        );
+    }
 }