feature(test): SpoonMetaModel

src/test/java/spoon/metamodel/MMContainerType.java

@@ -0,0 +1,60 @@
+/**
+ * Copyright (C) 2006-2017 INRIA and contributors
+ * Spoon - http://spoon.gforge.inria.fr/
+ *
+ * This software is governed by the CeCILL-C License under French law and
+ * abiding by the rules of distribution of free software. You can use, modify
+ * and/or redistribute the software under the terms of the CeCILL-C license as
+ * circulated by CEA, CNRS and INRIA at http://www.cecill.info.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL-C License for more details.
+ *
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL-C license and that you accept its terms.
+ */
+package spoon.metamodel;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Represents type of container used for field value.
+ */
+public enum MMContainerType {
+ /**
+ * it is a single value field
+ * Example: CtClassImpl.simpleName
+ */
+ SINGLE,
+ /**
+ * It is a list of values
+ * Example: CtClassImpl.typeMembers
+ */
+ LIST,
+ /**
+ * It is a set of values
+ * Example: CtPackageImpl.types
+ */
+ SET,
+ /**
+ * It is a map<String, T> of values
+ * Example: CtAnnotationImpl.elementValues
+ */
+ MAP;
+
+ public static MMContainerType valueOf(Class<?> valueClass) {
+ if (List.class.isAssignableFrom(valueClass)) {
+ return LIST;
+ }
+ if (Map.class.isAssignableFrom(valueClass)) {
+ return MAP;
+ }
+ if (Set.class.isAssignableFrom(valueClass)) {
+ return SET;
+ }
+ return SINGLE;
+ }
+}

src/test/java/spoon/metamodel/MMField.java

@@ -0,0 +1,241 @@
+/**
+ * Copyright (C) 2006-2017 INRIA and contributors
+ * Spoon - http://spoon.gforge.inria.fr/
+ *
+ * This software is governed by the CeCILL-C License under French law and
+ * abiding by the rules of distribution of free software. You can use, modify
+ * and/or redistribute the software under the terms of the CeCILL-C license as
+ * circulated by CEA, CNRS and INRIA at http://www.cecill.info.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL-C License for more details.
+ *
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL-C license and that you accept its terms.
+ */
+package spoon.metamodel;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.log4j.spi.RootLogger;
+
+import spoon.SpoonException;
+import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.path.CtRole;
+import spoon.reflect.reference.CtTypeReference;
+import spoon.support.DerivedProperty;
+
+import static spoon.metamodel.SpoonMetaModel.addUniqueObject;
+import static spoon.metamodel.SpoonMetaModel.getOrCreate;
+
+/**
+ * Represents a field of Spoon model type.
+ * Each MMField belongs to one MMType
+ */
+public class MMField {
+ /**
+ * Name of the field
+ */
+ final String name;
+ /**
+ * {@link CtRole} of the field
+ */
+ final CtRole role;
+ /**
+ * The list of {@link MMType}s which contains this field
+ */
+ final MMType ownerType;
+ /**
+ * Type of value container [single, list, set, map]
+ */
+ MMContainerType valueContainerType;
+ /**
+ * The type of value of this field - can be Set, List, Map or any non collection type
+ */
+ private CtTypeReference<?> valueType;
+ /**
+ * The item type of value of this field - can be non collection type
+ */
+ private CtTypeReference<?> itemValueType;
+
+ Boolean derived;
+
+ public CtMethod<?> get;
+ public CtMethod<?> set;
+ public CtMethod<?> add;
+ public CtMethod<?> addFirst;
+ public CtMethod<?> addLast;
+ public CtMethod<?> addOn;
+ public CtMethod<?> remove;
+
+
+ /**
+ * methods of this field defined directly on ownerType.
+ * There is PropertyGetter or PropertySetter annotation with `role` of this {@link MMField}
+ */
+ final List<CtMethod<?>> roleMethods = new ArrayList<>();
+ final Map<String, List<CtMethod<?>>> roleMethodsBySignature = new HashMap<>();
+ /**
+ * List of fields with same `role`, from super type of `ownerType` {@link MMType}
+ */
+ final List<MMField> superFields = new ArrayList<>();
+
+ /**
+ * own and inherited methods grouped by method signature and the methods
+ * in list ordered by own methods are first
+ */
+ final Map<String, List<CtMethod<?>>> allRoleMethodsBySignature = new HashMap<>();
+
+ MMField(String name, CtRole role, MMType ownerType) {
+ super();
+ this.name = name;
+ this.role = role;
+ this.ownerType = ownerType;
+ }
+
+ void addMethod(CtMethod<?> method) {
+ roleMethods.add(method);
+ String signature = method.getSignature();
+ addUniqueObject(getOrCreate(roleMethodsBySignature, signature, () -> new ArrayList<>()), method);
+ addUniqueObject(getOrCreate(allRoleMethodsBySignature, signature,() -> new ArrayList<>()), method);
+ }
+
+ void addSuperField(MMField superMMField) {
+ if (addUniqueObject(superFields, superMMField)) {
+ for (Map.Entry<String, List<CtMethod<?>>> e : superMMField.allRoleMethodsBySignature.entrySet()) {
+ getOrCreate(allRoleMethodsBySignature, e.getKey(), () -> new ArrayList<>()).addAll(e.getValue());
+ }
+ }
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public CtRole getRole() {
+ return role;
+ }
+
+ public MMType getOwnerType() {
+ return ownerType;
+ }
+
+ public MMContainerType getValueContainerType() {
+ return valueContainerType;
+ }
+
+ public CtTypeReference<?> getValueType() {
+ return valueType;
+ }
+
+ void setValueType(CtTypeReference<?> valueType) {
+ this.valueType = valueType;
+ this.valueContainerType = MMContainerType.valueOf(valueType.getActualClass());
+ if (valueContainerType != MMContainerType.SINGLE) {
+ if(valueContainerType == MMContainerType.MAP) {
+ itemValueType = valueType.getActualTypeArguments().get(1);
+ if (String.class.getName().equals(valueType.getActualTypeArguments().get(0).getQualifiedName()) == false) {
+ throw new SpoonException("Unexpected container of type: " + valueType.toString());
+ }
+ } else {
+ itemValueType = valueType.getActualTypeArguments().get(0);
+ }
+
+ } else {
+ itemValueType = valueType;
+ }
+ }
+
+ public CtTypeReference<?> getItemValueType() {
+ return itemValueType;
+ }
+ public void setItemValueType(CtTypeReference<?> itemValueType) {
+ this.itemValueType = itemValueType;
+ }
+
+ public boolean isDerived() {
+ if (derived == null) {
+ if(role == CtRole.FIELD) {
+ this.getClass();
+ }
+ CtTypeReference<DerivedProperty> derivedProperty = get.getFactory().createCtTypeReference(DerivedProperty.class);
+ //if DerivedProperty is found on any getter of this type, then this field is derived
+ boolean isConreteMethod = false;
+ List<CtMethod<?>> ownGetterMethods = roleMethodsBySignature.get(get.getSignature());
+ if (ownGetterMethods != null) {
+ for (CtMethod<?> ctMethod : ownGetterMethods) {
+ if(ctMethod.getAnnotation(derivedProperty) != null) {
+ derived = Boolean.TRUE;
+ return true;
+ }
+ isConreteMethod = isConreteMethod || ctMethod.getBody() != null;
+ }
+ if (isConreteMethod) {
+ //there exists a implementation of getter for this field in this type and there is no DerivedProperty here, so it is not derived!
+ derived = Boolean.FALSE;
+ return false;
+ }
+ }
+ //inherit derived property from super type
+ //if DerivedProperty annotation is not found on any get method, then it is not derived
+ derived = Boolean.FALSE;
+ //check all super fields. If any of them is derived then this field is derived too
+ for (MMField superField : superFields) {
+ if (superField.isDerived()) {
+ derived = Boolean.TRUE;
+ break;
+ }
+ }
+ }
+ return derived;
+ }
+
+ public List<CtMethod<?>> getRoleMethods() {
+ return roleMethods;
+ }
+
+ public List<MMField> getSuperFields() {
+ return superFields;
+ }
+
+ public Map<String, List<CtMethod<?>>> getAllRoleMethodsBySignature() {
+ return allRoleMethodsBySignature;
+ }
+
+ @Override
+ public String toString() {
+ return ownerType.getName() + "#" + getName() + "<" + valueType + ">";
+ }
+
+ /**
+ * @return the super MMField which has same valueType and which is in root of the most implementations
+ */
+ public MMField getRootSuperField() {
+ List<MMField> potentialRootSuperFields = new ArrayList<>();
+ if (roleMethods.size() > 0) {
+ potentialRootSuperFields.add(this);
+ }
+ superFields.forEach(superField -> {
+ addUniqueObject(potentialRootSuperFields, superField.getRootSuperField());
+ });
+ int idx = 0;
+ if (potentialRootSuperFields.size() > 1) {
+ CtTypeReference<?> expectedValueType = this.valueType.getTypeErasure();
+ for (int i = 1; i < potentialRootSuperFields.size(); i++) {
+ MMField superField = potentialRootSuperFields.get(i);
+ if (superField.valueType.getTypeErasure().equals(expectedValueType) == false) {
+ break;
+ }
+ idx = i;
+ }
+ }
+// if (role == CtRole.ASSIGNMENT && ownerType.getName().equals("CtLocalVariable")) {
+// this.getClass();
+// }
+ return potentialRootSuperFields.get(idx);
+ }
+}