feat: Adds unique serializable path for each CtElement from Root Element.

doc/path.md

@@ -30,7 +30,7 @@ For instance, if we want the first statement in the body of method `foo`, declar
 in the class `spoon.test.path.Foo`. 
 
 ```java
-new CtPathStringBuilder().fromString(".spoon.test.path.Foo.foo#body[index=0]");
+new CtPathStringBuilder().fromString(".spoon.test.path.Foo.foo#body#statement[index=0]");
 ```
 
 ## CtPathBuilder

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

@@ -19,6 +19,7 @@
 import spoon.processing.FactoryAccessor;
 import spoon.reflect.code.CtComment;
 import spoon.reflect.cu.SourcePosition;
+import spoon.reflect.path.CtPath;
 import spoon.reflect.path.CtRole;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.visitor.CtVisitable;
@@ -349,4 +350,10 @@ <E extends CtElement> List<E> getAnnotatedChildren(
 	 * @param value to be assigned to this field.
 	 */
 	<E extends CtElement, T> E  setValueByRole(CtRole role, T value);
+
+	/**
+	 * Gets a unique path from models root to the CtElement.
+	 */
+	CtPath getPath();
+
 }

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

@@ -0,0 +1,94 @@
+package spoon.reflect.path;
+
+import spoon.reflect.declaration.CtElement;
+import spoon.reflect.declaration.CtNamedElement;
+import spoon.reflect.path.impl.CtPathElement;
+import spoon.reflect.path.impl.CtPathImpl;
+import spoon.reflect.path.impl.CtRolePathElement;
+import spoon.reflect.reference.CtReference;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * This builder allow to create some CtPath from CtElements
+ *
+ * Created by nharrand on 21/02/2018.
+ */
+public class CtElementPathBuilder {
+	/**
+	 * Build path to a CtElement el, from one of its parent.
+	 *
+	 * @throws CtPathException is thrown when root is not a parent of el.
+	 *
+	 * @param el : the element to which the CtPath leads to
+	 * @param root : Starting point of the CtPath
+	 * @return CtPath from root to el
+	 */
+	public CtPath fromElement(CtElement el, CtElement root) throws CtPathException {
+		CtPathImpl path = new CtPathImpl();
+		CtElement cur = el;
+		while (cur != root) {
+			CtElement parent = cur.getParent();
+			CtRole role = cur.getRoleInParent();
+			if (parent == null || role == null) {
+				throw new CtPathException();
+			}
+			CtPathElement pathElement = new CtRolePathElement(role);
+			if (parent.getValueByRole(role) instanceof List) {
+				//Element needs to be differentiated from its brothers
+				List list = parent.getValueByRole(role);
+				//Assumes that List's order is deterministic.
+				int index = 0;
+				for (Object o : list) {
+					if (o == cur) {
+						break;
+					}
+					index++;
+				}
+				pathElement.addArgument("index", index + "");
+			} else if (parent.getValueByRole(role) instanceof Set) {
+				if (!(cur instanceof CtNamedElement) && !(cur instanceof CtReference)) {
+					throw new CtPathException();
+				}
+				//Element needs to be differentiated from its brothers
+				Set set = parent.getValueByRole(role);
+				String name = null;
+				for (Object o : set) {
+					if (o == cur) {
+						if (cur instanceof CtNamedElement) {
+							name = ((CtNamedElement) cur).getSimpleName();
+						} else {
+							name = ((CtReference) cur).getSimpleName();
+						}
+						break;
+					}
+				}
+				if (name == null) {
+					throw new CtPathException();
+				} else {
+					pathElement.addArgument("name", name);
+				}
+
+			} else if (parent.getValueByRole(role) instanceof Map) {
+				Map map = parent.getValueByRole(role);
+				String key = null;
+				for (Object o : map.keySet()) {
+					if (map.get(o) == cur) {
+						key = (String) o;
+						break;
+					}
+				}
+				if (key == null) {
+					throw new CtPathException();
+				} else {
+					pathElement.addArgument("key", key);
+				}
+			}
+			cur = parent;
+			path.addFirst(pathElement);
+		}
+		return path;
+	}
+}

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

@@ -16,11 +16,12 @@
  */
 package spoon.reflect.path;
 
+
 import spoon.reflect.path.impl.CtNamedPathElement;
 import spoon.reflect.path.impl.CtPathElement;
 import spoon.reflect.path.impl.CtPathImpl;
-import spoon.reflect.path.impl.CtRolePathElement;
 import spoon.reflect.path.impl.CtTypedNameElement;
+import spoon.reflect.path.impl.CtRolePathElement;
 
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

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

@@ -16,15 +16,18 @@
  */
 package spoon.reflect.path.impl;
 
-import spoon.reflect.code.CtIf;
+import spoon.SpoonException;
 import spoon.reflect.declaration.CtElement;
-import spoon.reflect.declaration.CtExecutable;
-import spoon.reflect.declaration.CtField;
+import spoon.reflect.declaration.CtNamedElement;
+import spoon.reflect.path.CtPathException;
 import spoon.reflect.path.CtRole;
-import spoon.reflect.visitor.CtInheritanceScanner;
+import spoon.reflect.reference.CtReference;
 
 import java.util.Collection;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * A CtPathElement that define some roles for matching.
@@ -40,60 +43,6 @@ public class CtRolePathElement extends AbstractPathElement<CtElement, CtElement>
 
 	public static final String STRING = "#";
 
-	private class RoleVisitor extends CtInheritanceScanner {
-		private Collection<CtElement> matchs = new LinkedList<>();
-
-		private RoleVisitor() {
-		}
-
-		@Override
-		public <R> void scanCtExecutable(CtExecutable<R> e) {
-			super.scanCtExecutable(e);
-
-			switch (role) {
-			case BODY:
-				if (e.getBody() != null) {
-					if (getArguments().containsKey("index")
-							&& e.getBody()
-								.getStatements()
-								.size() > Integer.parseInt(
-							getArguments().get("index"))) {
-						matchs.add(e.getBody().getStatements().get(Integer
-								.parseInt(getArguments().get("index"))));
-					} else {
-						matchs.addAll(e.getBody().getStatements());
-					}
-				}
-			}
-
-		}
-
-		@Override
-		public <T> void visitCtField(CtField<T> e) {
-			super.visitCtField(e);
-
-			if (role == CtRole.DEFAULT_EXPRESSION && e.getDefaultExpression() != null) {
-				matchs.add(e.getDefaultExpression());
-			}
-		}
-
-		@Override
-		public void visitCtIf(CtIf e) {
-			super.visitCtIf(e);
-
-			switch (role) {
-			case THEN:
-				if (e.getThenStatement() != null) {
-					matchs.add(e.getThenStatement());
-				}
-			case ELSE:
-				if (e.getElseStatement() != null) {
-					matchs.add(e.getElseStatement());
-				}
-			}
-		}
-	}
-
 	private final CtRole role;
 
 	public CtRolePathElement(CtRole role) {
@@ -106,14 +55,57 @@ public CtRole getRole() {
 
 	@Override
 	public String toString() {
-		return STRING + role.toString() + getParamString();
+		return STRING + getRole().toString() + getParamString();
+	}
+
+	public CtElement getFromSet(Set set, String name) throws CtPathException {
+		for (Object o: set) {
+			if (o instanceof CtNamedElement) {
+				if (((CtNamedElement) o).getSimpleName().equals(name)) {
+					return (CtElement) o;
+				}
+			} else if (o instanceof CtReference) {
+				if (((CtReference) o).getSimpleName().equals(name)) {
+					return (CtElement) o;
+				}
+			} else {
+				throw new CtPathException();
+			}
+		}
+		throw new CtPathException();
 	}
 
 	@Override
 	public Collection<CtElement> getElements(Collection<CtElement> roots) {
-		RoleVisitor visitor = new RoleVisitor();
-		visitor.scan(roots);
-		return visitor.matchs;
+		Collection<CtElement> matchs = new LinkedList<>();
+		for (CtElement root : roots) {
+			try {
+				if (root.getValueByRole(getRole()) instanceof List) {
+					if (getArguments().containsKey("index")) {
+						int index = Integer.parseInt(getArguments().get("index"));
+						matchs.add((CtElement) ((List) root.getValueByRole(getRole())).get(index));
+					}
+				} else if (root.getValueByRole(getRole()) instanceof Set) {
+					if (getArguments().containsKey("name")) {
+						String name = getArguments().get("name");
+						try {
+							matchs.add(getFromSet(root.getValueByRole(getRole()), name));
+						} catch (CtPathException e) {
+							//System.err.println("[ERROR] Element not found for name: " + name);
+							//No element found for name.
+						}
+					}
+				} else if (root.getValueByRole(getRole()) instanceof Map) {
+					if (getArguments().containsKey("key")) {
+						String name = getArguments().get("key");
+						matchs.add((CtElement) ((Map) root.getValueByRole(getRole())).get(name));
+					}
+				} else {
+					CtElement el = root.getValueByRole(getRole());
+					matchs.add(el);
+				}
+			} catch (SpoonException e) { } //When no element are found for a given role, return empty list.
+		}
+		return matchs;
 	}
-
 }

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

@@ -17,6 +17,7 @@
 package spoon.support.reflect.declaration;
 
 import org.apache.log4j.Logger;
+import spoon.reflect.CtModelImpl;
 import spoon.reflect.annotations.MetamodelPropertyField;
 import spoon.reflect.code.CtComment;
 import spoon.reflect.code.CtJavaDoc;
@@ -31,6 +32,9 @@
 import spoon.reflect.factory.FactoryImpl;
 import spoon.reflect.meta.RoleHandler;
 import spoon.reflect.meta.impl.RoleHandlerHelper;
+import spoon.reflect.path.CtElementPathBuilder;
+import spoon.reflect.path.CtPath;
+import spoon.reflect.path.CtPathException;
 import spoon.reflect.path.CtRole;
 import spoon.reflect.declaration.CtImport;
 import spoon.reflect.reference.CtReference;
@@ -536,4 +540,12 @@ public <E extends CtElement, T> E setValueByRole(CtRole role, T value) {
 		rh.setValue(this, value);
 		return (E) this;
 	}
+
+	public CtPath getPath() {
+		try {
+			return new CtElementPathBuilder().fromElement(this, getParent(CtModelImpl.CtRootPackage.class));
+		} catch (CtPathException e) {
+		}
+		return null;
+	}
 }

src/test/java/spoon/test/main/MainTest.java

@@ -23,6 +23,9 @@
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.CtTypeParameter;
 import spoon.reflect.declaration.ParentNotInitializedException;
+import spoon.reflect.path.CtPath;
+import spoon.reflect.path.CtPathException;
+import spoon.reflect.path.CtPathStringBuilder;
 import spoon.reflect.path.CtRole;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -40,13 +43,17 @@
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.io.StringWriter;
-import java.util.ArrayDeque;
-import java.util.Collection;
-import java.util.Deque;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Set;
 import java.util.HashSet;
-import java.util.IdentityHashMap;
+import java.util.Deque;
+import java.util.ArrayDeque;
 import java.util.Map;
-import java.util.Set;
+import java.util.IdentityHashMap;
+import java.util.Collection;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -441,6 +448,32 @@ public void scan(CtRole role, CtElement element) {
 		});
 	}
 
+	@Test
+	public void testElementToPathToElementEquivalency() {
+
+		List<CtElement> list = Arrays.asList(rootPackage);
+		rootPackage.accept(new CtScanner() {
+			@Override
+			public void scan(CtElement element) {
+				if (element != null) {
+					CtPath path = element.getPath();
+					String pathStr = path.toString();
+					try {
+						CtPath pathRead = new CtPathStringBuilder().fromString(pathStr);
+						Collection<CtElement> returnedElements = pathRead.evaluateOn(list);
+						//contract: CtUniqueRolePathElement.evaluateOn() returns a unique elements if provided only a list of one inputs
+						assertEquals(returnedElements.size(), 1);
+						CtElement actualElement = (CtElement) returnedElements.toArray()[0];
+						//contract: Element -> Path -> String -> Path -> Element leads to the original element
+						assertSame(element, actualElement);
+					} catch (CtPathException e) {
+						fail("Path is either incorrectly generated or incorrectly read");
+					}
+				}
+			}
+		});
+	}
+
 	@Test
 	public void testElementIsContainedInAttributeOfItsParent() {
 		rootPackage.accept(new CtScanner() {