Explicitencoding cleanup

org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/common/ASTProcessor.java

@@ -13,8 +13,10 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.common;
 
+import java.util.AbstractMap;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.Set;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
@@ -1197,7 +1199,9 @@ public ASTProcessor<E, V, T> callMethodInvocationVisitor(
  */
  public ASTProcessor<E, V, T> callMethodInvocationVisitor(String methodname,
  BiPredicate<ASTNode, E> bs) {
- nodetypelist.put(VisitorEnum.MethodInvocation, new NodeHolder(bs, null, methodname));
+ nodetypelist.put(VisitorEnum.MethodInvocation, new NodeHolder(bs, null, Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(HelperVisitor.METHODNAME, methodname)
+ )));
  return this;
  }
 
@@ -1209,7 +1213,9 @@ public ASTProcessor<E, V, T> callMethodInvocationVisitor(String methodname,
  */
  public ASTProcessor<E, V, T> callMethodInvocationVisitor(String methodname,
  BiPredicate<ASTNode, E> bs, Function<ASTNode, ASTNode> navigate) {
- nodetypelist.put(VisitorEnum.MethodInvocation, new NodeHolder(bs, navigate, methodname));
+ nodetypelist.put(VisitorEnum.MethodInvocation, new NodeHolder(bs, navigate, Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(HelperVisitor.METHODNAME, methodname)
+ )));
  return this;
  }
 

org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/common/HelperVisitor.java

@@ -13,6 +13,7 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.common;
 
+import java.util.AbstractMap;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -34,6 +35,9 @@
  */
 public class HelperVisitor<E extends HelperVisitorProvider<V, T, E>,V,T> {
 
+ public static final String TYPEOF = "typeof"; //$NON-NLS-1$
+ public static final String METHODNAME = "methodname"; //$NON-NLS-1$
+ public static final String PARAMTYPENAMES = "paramtypenames"; //$NON-NLS-1$
  ASTVisitor astvisitor;
 
  public E dataholder;
@@ -370,6 +374,20 @@ public BiPredicate<? extends ASTNode, E> addClassInstanceCreation(BiPredicate<Cl
  return predicatemap.put(VisitorEnum.ClassInstanceCreation, bs);
  }
 
+ /**
+ *
+ * @param typeof class to be instantiated
+ * @param bs - BiPredicate that can be assigned a lambda expression
+ * @return - previous BiPredicate registered
+ */
+ public BiPredicate<? extends ASTNode, E> addClassInstanceCreation(Class<?> typeof, BiPredicate<ClassInstanceCreation, E> bs) {
+ Map<String, Object> map = Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(TYPEOF, typeof)
+ );
+ predicatedata.put(VisitorEnum.ClassInstanceCreation, map);
+ return predicatemap.put(VisitorEnum.ClassInstanceCreation, bs);
+ }
+
  /**
  * Add BiPredicate to use for CompilationUnit visit
  *
@@ -719,7 +737,27 @@ public BiPredicate<? extends ASTNode, E> addMethodInvocation(BiPredicate<MethodI
  */
  public BiPredicate<? extends ASTNode, E> addMethodInvocation(String methodname,
  BiPredicate<MethodInvocation, E> bs) {
- this.predicatedata.put(VisitorEnum.MethodInvocation, methodname);
+ this.predicatedata.put(VisitorEnum.MethodInvocation, Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(METHODNAME, methodname)
+ ));
+ return predicatemap.put(VisitorEnum.MethodInvocation, bs);
+ }
+
+ /**
+ * Add BiPredicate to use for MethodInvocation visit where class and method name is specified
+ *
+ * @param typeof class whose method is called
+ * @param methodname name of the method that is called
+ * @param bs BiPredicate that can be assigned a lambda expression
+ * @return previous BiPredicate registered
+ */
+ public BiPredicate<? extends ASTNode, E> addMethodInvocation(Class<?> typeof, String methodname,
+ BiPredicate<MethodInvocation, E> bs) {
+ Map<String, Object> map = Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(METHODNAME, methodname),
+ new AbstractMap.SimpleEntry<>(TYPEOF, typeof)
+ );
+ predicatedata.put(VisitorEnum.MethodInvocation, map);
  return predicatemap.put(VisitorEnum.MethodInvocation, bs);
  }
 
@@ -1484,7 +1522,9 @@ public BiConsumer<? extends ASTNode, E> addMethodInvocation(BiConsumer<MethodInv
  }
 
  public BiConsumer<? extends ASTNode, E> addMethodInvocation(String methodname, BiConsumer<MethodInvocation, E> bc) {
- this.consumerdata.put(VisitorEnum.MethodInvocation, methodname);
+ this.consumerdata.put(VisitorEnum.MethodInvocation, Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(METHODNAME, methodname)
+ ));
  return consumermap.put(VisitorEnum.MethodInvocation, bc);
  }
 
@@ -2180,24 +2220,51 @@ public void addMethodDeclaration(BiPredicate<MethodDeclaration, E> bs, BiConsume
 
  /**
  *
- * @param bs - BiPredicate that can be assigned a lambda expression
+ * @param methodname Only visit MethodInvocation with this name
+ * @param bs - BiPredicate that is visited when a MethodInvocation is found
+ * @param bc - BiConsumer that is visited at the end after a MethodInvocation has been found
  */
  public void addMethodInvocation(String methodname, BiPredicate<MethodInvocation, E> bs,
  BiConsumer<MethodInvocation, E> bc) {
- this.predicatedata.put(VisitorEnum.MethodInvocation, methodname);
+ predicatedata.put(VisitorEnum.MethodInvocation, Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(METHODNAME, methodname)
+ ));
+ predicatemap.put(VisitorEnum.MethodInvocation, bs);
+ consumerdata.put(VisitorEnum.MethodInvocation, Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(METHODNAME, methodname)
+ ));
+ consumermap.put(VisitorEnum.MethodInvocation, bc);
+ }
+
+ /**
+ * @param typeof Only visit MethodInvocation calling a method of this class
+ * @param methodname Only visit MethodInvocation with this name
+ * @param bs - BiPredicate that is visited when a MethodInvocation is found
+ * @param bc - BiConsumer that is visited at the end after a MethodInvocation has been found
+ */
+ public void addMethodInvocation(Class<?> typeof, String methodname, BiPredicate<MethodInvocation, E> bs,
+ BiConsumer<MethodInvocation, E> bc) {
+ Map<String, Object> map = Map.ofEntries(
+ new AbstractMap.SimpleEntry<>(METHODNAME, methodname),
+ new AbstractMap.SimpleEntry<>(TYPEOF, typeof)
+ );
+ predicatedata.put(VisitorEnum.MethodInvocation, map);
  predicatemap.put(VisitorEnum.MethodInvocation, bs);
+ consumerdata.put(VisitorEnum.MethodInvocation, map);
  consumermap.put(VisitorEnum.MethodInvocation, bc);
  }
 
  /**
  *
  * @param bs - BiPredicate that can be assigned a lambda expression
+ * @param bc - BiConsumer that is visited at the end after a MethodInvocation has been found
  */
  public void addMethodInvocation(BiPredicate<MethodInvocation, E> bs, BiConsumer<MethodInvocation, E> bc) {
  predicatemap.put(VisitorEnum.MethodInvocation, bs);
  consumermap.put(VisitorEnum.MethodInvocation, bc);
  }
 
+
  /**
  *
  * @param bs - BiPredicate that can be assigned a lambda expression
@@ -3428,6 +3495,13 @@ public static <V, T> void callMethodInvocationVisitor(String methodname, ASTNode
  hv.build(node);
  }
 
+ public static <V, T> void callMethodInvocationVisitor(Class<?> methodof, String methodname, ASTNode node, ReferenceHolder<V, T> dataholder, Set<ASTNode> nodesprocessed,
+ BiPredicate<MethodInvocation, ReferenceHolder<V, T>> bs) {
+
+ HelperVisitor<ReferenceHolder<V, T>,V,T> hv= new HelperVisitor<>(nodesprocessed, dataholder);
+ hv.addMethodInvocation(methodof, methodname, bs);
+ hv.build(node);
+ }
  /**
  *
  * @param nodesprocessed - set of nodes processed
@@ -5627,6 +5701,13 @@ public static <V, T> void callClassInstanceCreationVisitor(ASTNode node, Referen
  hv.build(node);
  }
 
+ public static <V, T> void callClassInstanceCreationVisitor(Class<?> class1, ASTNode node, ReferenceHolder<V, T> dataholder, Set<ASTNode> nodesprocessed,
+ BiPredicate<ClassInstanceCreation, ReferenceHolder<V, T>> bs) {
+
+ HelperVisitor<ReferenceHolder<V, T>,V,T> hv= new HelperVisitor<>(nodesprocessed, dataholder);
+ hv.addClassInstanceCreation(class1, bs);
+ hv.build(node);
+ }
  /**
  *
  * @param nodesprocessed - set of nodes processed

org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/common/LambdaASTVisitor.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2021, 2022 Carsten Hammer.
+ * Copyright (c) 2021 Carsten Hammer.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -9,25 +9,32 @@
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
- * Carsten Hammer - initial API and implementation
+ * Carsten Hammer
  *******************************************************************************/
 package org.eclipse.jdt.internal.common;
 
+import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.BiPredicate;
 
 import org.eclipse.jdt.core.dom.*;
 
+import org.eclipse.jdt.internal.corext.dom.ASTNodes;
+
 /**
  *
  * @author chammer
  *
  * @param <E> - type that extends HelpVisitorProvider that provides {@code HelperVisitor<V, T>}
  * @param <V> - type that HelperVisitor uses as map key type
  * @param <T> - type that HelperVisitor uses as map value type
+ * @since 1.15
  */
-@SuppressWarnings("unchecked")
+@SuppressWarnings({ "unchecked" })
 public class LambdaASTVisitor<E extends HelperVisitorProvider<V,T,E>, V, T> extends ASTVisitor {
+ /**
+ *
+ */
  private final HelperVisitor<E,V,T> helperVisitor;
 
  /**
@@ -190,6 +197,16 @@ public boolean visit(CharacterLiteral node) {
  @Override
  public boolean visit(ClassInstanceCreation node) {
  if (this.helperVisitor.predicatemap.containsKey(VisitorEnum.ClassInstanceCreation)) {
+ Map<String, Object> map=(Map<String, Object>) this.helperVisitor.getSupplierData().get(VisitorEnum.ClassInstanceCreation);
+ if(map != null) {
+ Class<?> typeof=(Class<?>) map.get(HelperVisitor.TYPEOF);
+ if(typeof!=null) {
+ ITypeBinding binding= node.resolveTypeBinding();
+ if (!typeof.getSimpleName().equals(binding.getName())) {
+ return true;
+ }
+ }
+ }
  return ((BiPredicate<ClassInstanceCreation, E>) (this.helperVisitor.predicatemap
  .get(VisitorEnum.ClassInstanceCreation))).test(node, this.helperVisitor.dataholder);
  }
@@ -496,9 +513,25 @@ public boolean visit(MethodDeclaration node) {
  @Override
  public boolean visit(MethodInvocation node) {
  if (this.helperVisitor.predicatemap.containsKey(VisitorEnum.MethodInvocation)) {
- String data=(String) this.helperVisitor.getSupplierData().get(VisitorEnum.MethodInvocation);
- if (data!= null && !node.getName().getIdentifier().equals(data)) {
- return true;
+ Map<String, Object> map=(Map<String, Object>) this.helperVisitor.getSupplierData().get(VisitorEnum.MethodInvocation);
+ if(map != null) {
+ String data=(String) map.get(HelperVisitor.METHODNAME);
+ if ((data!= null) && !node.getName().getIdentifier().equals(data)) {
+ return true;
+ }
+ Class<?> typeof=(Class<?>) map.get(HelperVisitor.TYPEOF);
+ String[] parameterTypesQualifiedNames=(String[]) map.get(HelperVisitor.PARAMTYPENAMES);
+
+ if(typeof!=null) {
+ if(parameterTypesQualifiedNames==null) {
+ if (ASTNodes.usesGivenSignature(node, typeof.getCanonicalName(), data)) {
+ return ((BiPredicate<MethodInvocation, E>) (this.helperVisitor.predicatemap.get(VisitorEnum.MethodInvocation))).test(node, this.helperVisitor.dataholder);
+ }
+ } else
+ if (ASTNodes.usesGivenSignature(node, typeof.getCanonicalName(), data, parameterTypesQualifiedNames)) {
+ return ((BiPredicate<MethodInvocation, E>) (this.helperVisitor.predicatemap.get(VisitorEnum.MethodInvocation))).test(node, this.helperVisitor.dataholder);
+ }
+ }
  }
  return ((BiPredicate<MethodInvocation, E>) (this.helperVisitor.predicatemap.get(VisitorEnum.MethodInvocation))).test(node, this.helperVisitor.dataholder);
  }
@@ -949,14 +982,17 @@ public boolean visit(VariableDeclarationExpression node) {
  @Override
  public boolean visit(VariableDeclarationStatement node) {
  if (this.helperVisitor.predicatemap.containsKey(VisitorEnum.VariableDeclarationStatement)) {
- Class<?> data=(Class<?>) this.helperVisitor.getSupplierData().get(VisitorEnum.VariableDeclarationStatement);
- if (data!= null) {
- VariableDeclarationFragment bli = (VariableDeclarationFragment) node.fragments().get(0);
- IVariableBinding resolveBinding = bli.resolveBinding();
- if(resolveBinding!=null) {
- String qualifiedName = resolveBinding.getType().getErasure().getQualifiedName();
- if (!data.getCanonicalName().equals(qualifiedName)) {
- return true;
+ Map<String, Object> map=(Map<String, Object>)this.helperVisitor.getConsumerData().get(VisitorEnum.VariableDeclarationStatement);
+ if(map != null) {
+ Class<?> data=(Class<?>) map.get(HelperVisitor.TYPEOF);
+ if (data!= null) {
+ VariableDeclarationFragment bli = (VariableDeclarationFragment) node.fragments().get(0);
+ IVariableBinding resolveBinding = bli.resolveBinding();
+ if(resolveBinding!=null) {
+ String qualifiedName = resolveBinding.getType().getErasure().getQualifiedName();
+ if (!data.getCanonicalName().equals(qualifiedName)) {
+ return true;
+ }
  }
  }
  }
@@ -1388,9 +1424,18 @@ public void endVisit(MethodDeclaration node) {
  @Override
  public void endVisit(MethodInvocation node) {
  if (this.helperVisitor.consumermap.containsKey(VisitorEnum.MethodInvocation)) {
- String data=(String) this.helperVisitor.getConsumerData().get(VisitorEnum.MethodInvocation);
- if (data!= null && !node.getName().getIdentifier().equals(data)) {
- return;
+ Map<String, Object> map=(Map<String, Object>) this.helperVisitor.getConsumerData().get(VisitorEnum.MethodInvocation);
+ if(map != null) {
+ String data=(String) map.get(HelperVisitor.METHODNAME);
+ if ((data!= null) && !node.getName().getIdentifier().equals(data)) {
+ return;
+ }
+ Class<?> typeof=(Class<?>) map.get(HelperVisitor.TYPEOF);
+ if(typeof!=null) {
+ if (!ASTNodes.usesGivenSignature(node, typeof.getCanonicalName(), data)) {
+ return;
+ }
+ }
  }
  ((BiConsumer<MethodInvocation, E>) (this.helperVisitor.consumermap.get(VisitorEnum.MethodInvocation))).accept(node,
  this.helperVisitor.dataholder);
@@ -1774,14 +1819,17 @@ public void endVisit(VariableDeclarationExpression node) {
  @Override
  public void endVisit(VariableDeclarationStatement node) {
  if (this.helperVisitor.consumermap.containsKey(VisitorEnum.VariableDeclarationStatement)) {
- Class<?> data=(Class<?>) this.helperVisitor.getConsumerData().get(VisitorEnum.VariableDeclarationStatement);
- if (data!= null) {
- VariableDeclarationFragment bli = (VariableDeclarationFragment) node.fragments().get(0);
- IVariableBinding resolveBinding = bli.resolveBinding();
- if(resolveBinding!=null) {
- String qualifiedName = resolveBinding.getType().getErasure().getQualifiedName();
- if (!data.getCanonicalName().equals(qualifiedName)) {
- return;
+ Map<String, Object> map=(Map<String, Object>)this.helperVisitor.getConsumerData().get(VisitorEnum.VariableDeclarationStatement);
+ if(map != null) {
+ Class<?> data=(Class<?>) map.get(HelperVisitor.TYPEOF);
+ if (data!= null) {
+ VariableDeclarationFragment bli = (VariableDeclarationFragment) node.fragments().get(0);
+ IVariableBinding resolveBinding = bli.resolveBinding();
+ if(resolveBinding!=null) {
+ String qualifiedName = resolveBinding.getType().getErasure().getQualifiedName();
+ if (!data.getCanonicalName().equals(qualifiedName)) {
+ return;
+ }
  }
  }
  }

org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java

@@ -209,6 +209,8 @@ private MultiFixMessages() {
  public static String StringConcatToTextBlockCleanUp_description;
  public static String StringConcatToTextBlockStringBuffer_description;
  public static String StringBuilderForLocalVarsOnlyCleanUp_description;
+ public static String ExplicitEncodingCleanUp_description;
+ public static String ExplicitEncodingCleanUpFix_refactor;
 
  static {
  // initialize resource bundle

org.eclipse.jdt.core.manipulation/common/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties

@@ -191,3 +191,5 @@ StringBufferToStringBuilderCleanUp_description=Convert StringBuffer to StringBui
 StringConcatToTextBlockCleanUp_description=Convert String concatenation to Text Block
 StringConcatToTextBlockStringBuffer_description=Convert String/StringBuffer/StringBuilder concatenation to Text Block
 StringBuilderForLocalVarsOnlyCleanUp_description=Convert StringBuffer to StringBuilder for local variables
+ExplicitEncodingCleanUp_description=Set explicit encoding or default encoding where applicable on methods ''{0}'' using {1}
+ExplicitEncodingCleanUpFix_refactor=Use explicit encoding