review: feat: support to parse CtType, CtClass and CtField from JDK element CtPath.toString()

doc/path.md

@@ -13,13 +13,22 @@ For instance, a "then" branch in an if/then/else is a role (and not a node). All
 
 ### Evaluating AST paths
 
-Paths are used to find code elements, from a given root element.
+Paths are used to find code elements, from a given root element(e.g. `model.getRootPackage()`).
 
 ```java
 path = new CtPathStringBuilder().fromString(".spoon.test.path.testclasses.Foo.foo#body#statement[index=0]");
 List<CtElement> l = path.evaluateOn(root)
 ```
 
+If the root parameter is not given, spoon will try to find shadow elements(e.g. jdk classes).
+
+> If so, it can only supperts `CtType`, `CtMethod` and `CtField` for now.
+
+```java
+path = new CtPathStringBuilder().fromString("#subPackage[name=java]#subPackage[name=util]#containedType[name=HashSet]");
+List<CtElement> l = path.evaluateOn()
+```
+
 ### Creating AST paths
 
 #### From an existing element

src/main/java/spoon/reflect/declaration/CtClass.java

@@ -49,6 +49,18 @@ public interface CtClass<T> extends CtType<T>, CtStatement, CtSealable {
 	@PropertyGetter(role = CONSTRUCTOR)
 	CtConstructor<T> getConstructor(CtTypeReference<?>... parameterTypes);
 
+	/**
+	 * Returns the constructor of the class that takes the given signature.
+	 * e.g. java.util.HashSet has constructor with no parameters `()`
+	 * e.g. java.util.HashSet has constructor with a int and a float parameters `(int,float)`
+	 * e.g. java.util.HashSet has constructor with a java.util.Collection parameter `(java.util.Collection)`
+	 *
+	 * Derived from {@link #getTypeMembers()}
+	 */
+	@DerivedProperty
+	@PropertyGetter(role = CONSTRUCTOR)
+	CtConstructor<T> getConstructorBySignature(String signature);
+
 	/**
 	 * Returns the constructors of this class. This includes the default
 	 * constructor if this class has no constructors explicitly declared.

src/main/java/spoon/reflect/declaration/CtType.java

@@ -234,6 +234,14 @@ public interface CtType<T> extends CtNamedElement, CtTypeInformation, CtTypeMemb
 	@PropertyGetter(role = METHOD)
 	<R> CtMethod<R> getMethod(String name, CtTypeReference<?>... parameterTypes);
 
+	/**
+	 * Gets a method from its signature.
+	 *
+	 * @return null if does not exit
+	 */
+	@PropertyGetter(role = METHOD)
+	<R> CtMethod<R> getMethodBySignature(String signature);
+
 	/**
 	 * Returns the methods that are directly declared by this class or
 	 * interface.

src/main/java/spoon/reflect/path/CtPathStringBuilder.java

@@ -145,7 +145,8 @@ private String parseArgumentValue(Tokenizer tokenizer, String argName, CtPathEle
 				}
 			} else if ("]".equals(token) || ";".equals(token)) {
 				//finished reading of argument value
-				pathElement.addArgument(argName, argValue.toString());
+				//[fix bug]:AbstractPathElement.getArguments([constructor with no parameters])
+				pathElement.addArgument(argName, argValue.toString().replace("())","()"));
 				return token;
 			}
 			argValue.append(token);

src/main/java/spoon/reflect/path/impl/CtPathImpl.java

@@ -7,8 +7,12 @@
  */
 package spoon.reflect.path.impl;
 
+import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtElement;
+import spoon.reflect.declaration.CtType;
+import spoon.reflect.factory.TypeFactory;
 import spoon.reflect.path.CtPath;
+import spoon.reflect.path.CtRole;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -33,9 +37,70 @@ public <T extends CtElement> List<T> evaluateOn(CtElement... startNode) {
 		for (CtPathElement element : elements) {
 			filtered = element.getElements(filtered);
 		}
+		if (filtered.isEmpty()) {
+			List<String> cls_name_list = new LinkedList<>();
+			CtType<?> ctType = null;
+			for (CtPathElement element : elements) {
+				if (element instanceof CtRolePathElement) {    // search by CtRolePathElement
+					Collection<String> values = ((CtRolePathElement) element).getArguments().values();
+					String val = null;
+					if (values.iterator().hasNext()) val = values.iterator().next();
+					if (val != null) {
+						if (CtRole.SUB_PACKAGE.equals(((CtRolePathElement) element).getRole())
+								|| CtRole.CONTAINED_TYPE.equals(((CtRolePathElement) element).getRole()))
+							cls_name_list.add(val);
+
+						Class<?> cls = getJdkClass(String.join(".", cls_name_list));
+						if (cls != null) {
+							ctType = new TypeFactory().get(cls);
+							if (ctType != null) {
+								CtElement result = null;
+								if (CtRole.METHOD.equals(((CtRolePathElement) element).getRole())) {
+									result = ctType.getMethodBySignature(val);
+								}
+								if (CtRole.CONSTRUCTOR.equals(((CtRolePathElement) element).getRole())) {
+									result = ((CtClass) ctType).getConstructorBySignature(val);
+								}
+								if (CtRole.FIELD.equals(((CtRolePathElement) element).getRole())) {
+									result = ctType.getField(val);
+								}
+								if (result != null) filtered.add(result);
+							}
+						}
+					}
+				}
+			}
+			if (filtered.isEmpty() && ctType != null) filtered.add(ctType);
+		}
 		return (List<T>) filtered;
 	}
 
+	private Class<?> getJdkClass(String name) {
+		name = name.replaceAll("[\\[\\]]", "");
+		switch (name) {
+			case "byte":
+				return byte.class;
+			case "int":
+				return int.class;
+			case "long":
+				return long.class;
+			case "float":
+				return float.class;
+			case "double":
+				return double.class;
+			case "char":
+				return char.class;
+			case "boolean":
+				return boolean.class;
+			default:
+				try {
+					return Class.forName(name);
+				} catch (ClassNotFoundException e) {
+				}
+		}
+		return null;
+	}
+
 	@Override
 	public CtPath relativePath(CtElement parent) {
 		List<CtElement> roots = new ArrayList<>();

src/main/java/spoon/support/reflect/declaration/CtClassImpl.java

@@ -88,6 +88,20 @@ public CtConstructor<T> getConstructor(CtTypeReference<?>... parameterTypes) {
 		return null;
 	}
 
+	@Override
+	public CtConstructor<T> getConstructorBySignature(String signature) {
+		for (CtTypeMember typeMember : getTypeMembers()) {
+			if (!(typeMember instanceof CtConstructor)) {
+				continue;
+			}
+			CtConstructor<T> c = (CtConstructor<T>) typeMember;
+			if (c.getSignature().replaceAll(c.getDeclaringType().getQualifiedName(), "").equals(signature)) {
+				return c;
+			}
+		}
+		return null;
+	}
+
 	@Override
 	public Set<CtConstructor<T>> getConstructors() {
 		Set<CtConstructor<T>> constructors = new SignatureBasedSortedSet<>();

src/main/java/spoon/support/reflect/declaration/CtTypeImpl.java

@@ -723,6 +723,21 @@ public <R> CtMethod<R> getMethod(String name, CtTypeReference<?>... parameterTyp
 		return null;
 	}
 
+	@Override
+	@SuppressWarnings("unchecked")
+	public <R> CtMethod<R> getMethodBySignature(String signature) {
+		if (signature == null) {
+			return null;
+		}
+		String name = signature.substring(0, signature.indexOf('('));
+		for (CtMethod<?> candidate : getMethodsByName(name)) {
+			if (candidate.getSignature().equals(signature)) {
+				return (CtMethod<R>) candidate;
+			}
+		}
+		return null;
+	}
+
 	protected boolean hasSameParameters(CtExecutable<?> candidate, CtTypeReference<?>... parameterTypes) {
 		if (candidate.getParameters().size() != parameterTypes.length) {
 			return false;

src/test/java/spoon/test/path/PathTest.java

@@ -17,12 +17,6 @@
 package spoon.test.path;
 
 
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import spoon.Launcher;
@@ -31,30 +25,18 @@
 import spoon.reflect.code.CtInvocation;
 import spoon.reflect.code.CtLiteral;
 import spoon.reflect.code.CtStatement;
-import spoon.reflect.declaration.CtClass;
-import spoon.reflect.declaration.CtConstructor;
-import spoon.reflect.declaration.CtElement;
-import spoon.reflect.declaration.CtMethod;
-import spoon.reflect.declaration.CtParameter;
-import spoon.reflect.declaration.CtType;
-import spoon.reflect.declaration.CtTypeMember;
+import spoon.reflect.declaration.*;
 import spoon.reflect.factory.Factory;
-import spoon.reflect.path.CtElementPathBuilder;
-import spoon.reflect.path.CtPath;
-import spoon.reflect.path.CtPathBuilder;
-import spoon.reflect.path.CtPathException;
-import spoon.reflect.path.CtPathStringBuilder;
-import spoon.reflect.path.CtRole;
+import spoon.reflect.factory.TypeFactory;
+import spoon.reflect.path.*;
 import spoon.reflect.reference.CtTypeParameterReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.visitor.filter.NamedElementFilter;
 import spoon.reflect.visitor.filter.TypeFilter;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * Created by nicolas on 10/06/2015.
@@ -409,4 +391,31 @@ public void testFieldOfArrayType() {
 		assertEquals(1, result.size());
 		assertSame(argType, result.get(0));
 	}
+
+	@Test
+	public void testGetJdkElementByCtPathString() {
+		CtPath path;
+		// test class
+		path = new CtPathStringBuilder().fromString("#subPackage[name=java]#subPackage[name=util]#containedType[name=HashSet]");
+		assertTrue(path.evaluateOn().iterator().hasNext());
+		CtType class_HashSet = new TypeFactory().get(java.util.HashSet.class);
+		assertEquals(path.evaluateOn().iterator().next(), class_HashSet);
+		// if unable to get the method or the field, it will try to return the method.
+		// test method
+		path = new CtPathStringBuilder().fromString("#subPackage[name=java]#subPackage[name=util]#containedType[name=HashSet]#method[signature=contains(java.lang.Object)]");
+		assertTrue(path.evaluateOn().iterator().hasNext());
+		assertEquals(path.evaluateOn().iterator().next(), class_HashSet.getMethodBySignature("contains(java.lang.Object)"));
+		// test constructor
+		path = new CtPathStringBuilder().fromString("#subPackage[name=java]#subPackage[name=util]#containedType[name=HashSet]#constructor[signature=()]");
+		assertTrue(path.evaluateOn().iterator().hasNext());
+		assertEquals(path.evaluateOn().iterator().next(), ((CtClass) class_HashSet).getConstructorBySignature("()"));
+
+		path = new CtPathStringBuilder().fromString("#subPackage[name=java]#subPackage[name=util]#containedType[name=HashSet]#constructor[signature=(int)]");
+		assertTrue(path.evaluateOn().iterator().hasNext());
+		assertEquals(path.evaluateOn().iterator().next(), ((CtClass) class_HashSet).getConstructorBySignature("(int)"));
+		// test field
+		path = new CtPathStringBuilder().fromString("#subPackage[name=java]#subPackage[name=util]#containedType[name=HashSet]#field[name=map]");
+		assertTrue(path.evaluateOn().iterator().hasNext());
+		assertEquals(path.evaluateOn().iterator().next(), class_HashSet.getField("map"));
+	}
 }