review refactor: all non-leaf interfaces of the metamodel should be visited by CtInheritanceScanner

src/test/java/spoon/generating/RoleHandlersGenerator.java

@@ -105,10 +105,10 @@ public void process() {
  }
  params.put("$Role$", getFactory().Type().createReference(CtRole.class));
  params.put("ROLE", rim.getRole().name());
- params.put("$TargetType$", rim.getOwnerType().getModelInteface().getReference());
+ params.put("$TargetType$", rim.getOwnerType().getModelInterface().getReference());
 // params.put("AbstractHandler", getFactory().Type().createReference("spoon.reflect.meta.impl.AbstractRoleHandler"));
  params.put("AbstractHandler", getRoleHandlerSuperTypeQName(rim));
- params.put("Node", rim.getOwnerType().getModelInteface().getReference());
+ params.put("Node", rim.getOwnerType().getModelInterface().getReference());
  params.put("ValueType", fixMainValueType(getRoleHandlerSuperTypeQName(rim).endsWith("SingleHandler") ? rim.getValueType() : rim.getItemValueType()));
  CtClass<?> modelRoleHandlerClass = Substitution.createTypeFromTemplate(
  getHandlerName(rim),

src/test/java/spoon/test/architecture/SpoonArchitectureEnforcerTest.java

@@ -21,6 +21,7 @@
 import spoon.reflect.visitor.CtScanner;
 import spoon.reflect.visitor.filter.AbstractFilter;
 import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.test.metamodel.SpoonMetaModel;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -30,6 +31,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static spoon.test.metamodel.MMTypeKind.ABSTRACT;
 
 public class SpoonArchitectureEnforcerTest {
 
@@ -217,26 +219,26 @@ public boolean matches(CtClass element) {
  public void testInterfacesAreCtScannable() {
  // contract: all interface inherited from CtElement should be visited in CtScanner
  Launcher interfaces = new Launcher();
+ interfaces.addInputResource("src/main/java/spoon/support");
  interfaces.addInputResource("src/main/java/spoon/reflect/declaration");
  interfaces.addInputResource("src/main/java/spoon/reflect/code");
  interfaces.addInputResource("src/main/java/spoon/reflect/reference");
  interfaces.addInputResource("src/main/java/spoon/reflect/visitor/CtScanner.java");
  interfaces.buildModel();
 
- Collection<CtType<?>> allTypes = interfaces.getModel().getAllTypes();
-
  CtClass<?> ctScanner = interfaces.getFactory().Class().get(CtInheritanceScanner.class);
- CtType<?> ctElement = interfaces.getFactory().Type().get(CtElement.class);
 
  List<String> missingMethods = new ArrayList<>();
- for (CtType type : allTypes) {
- if (type.isSubtypeOf(ctElement.getReference())) {
- String methodName = "scan"+type.getSimpleName();
+
+ new SpoonMetaModel(interfaces.getFactory()).getMMTypes().forEach(mmType->{
+ if(mmType.getKind()==ABSTRACT && mmType.getModelInterface() != null) {
+ CtInterface abstractIface = mmType.getModelInterface();
+ String methodName = "scan"+abstractIface.getSimpleName();
  if (ctScanner.getMethodsByName(methodName).isEmpty()) {
  missingMethods.add(methodName);
  }
  }
- }
+ });
 
  assertTrue("The following methods are missing in CtScanner: \n"+ StringUtils.join(missingMethods, "\n"),missingMethods.isEmpty());
  }

src/test/java/spoon/test/metamodel/MMType.java

@@ -28,8 +28,10 @@
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtInterface;
 import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.ModifierKind;
 import spoon.reflect.path.CtRole;
+import spoon.support.reflect.CtExtendedModifier;
 import spoon.support.visitor.ClassTypingContext;
 
 /**
@@ -99,10 +101,19 @@ MMField getOrCreateMMField(CtRole role) {
  */
  public MMTypeKind getKind() {
  if (kind == null) {
- if (modelClass != null && modelClass.hasModifier(ModifierKind.ABSTRACT) == false) {
- kind = MMTypeKind.LEAF;
+ if (modelClass == null && modelInterface == null) {
+ return null;
  } else {
- kind = MMTypeKind.ABSTRACT;
+ // we first consider interface
+ if (modelClass == null) {
+ this.kind = MMTypeKind.ABSTRACT;
+ } else {
+ if (modelClass.hasModifier(ModifierKind.ABSTRACT)) {
+ this.kind = MMTypeKind.ABSTRACT;
+ } else {
+ this.kind = MMTypeKind.LEAF;
+ }
+ }
  }
  }
  return kind;