feat(ast): Creates CtTypeMember list in CtType. (Closes INRIA#681)

src/main/java/spoon/generating/CloneVisitorGenerator.java

@@ -52,6 +52,7 @@
 import spoon.reflect.visitor.ReferenceFilter;
 import spoon.reflect.visitor.filter.OverridingMethodFilter;
 import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.support.reflect.cu.CtLineElementComparator;
 import spoon.support.visitor.clone.CloneBuilder;
 
 import java.util.ArrayList;
@@ -505,6 +506,9 @@ private boolean isConstantOrStatic(CtField<?> ctField) {
  return ctField.getModifiers().contains(ModifierKind.FINAL) || ctField.getModifiers().contains(ModifierKind.STATIC);
  }
  }.scan(getFactory().Class().get(CtInheritanceScanner.class));
+
+ Collections.sort(target.getTypeMembers(), new CtLineElementComparator());
+ Collections.sort(targetBuilder.getTypeMembers(), new CtLineElementComparator());
  }
 
  private CtClass<Object> createCloneVisitor() {

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

@@ -56,6 +56,11 @@ public interface CtEnum<T extends Enum<?>> extends CtClass<T> {
  */
  List<CtEnumValue<?>> getEnumValues();
 
+ /**
+ *Sets all enum values of the enum.
+ */
+ <C extends CtEnum<T>> C setEnumValues(List<CtEnumValue<?>> enumValues);
+
  @Override
  CtEnum<T> clone();
 }

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

@@ -252,6 +252,32 @@ public interface CtType<T> extends CtNamedElement, CtTypeInformation, CtTypeMemb
  */
  <S> boolean removeSuperInterface(CtTypeReference<S> interfac);
 
+ /**
+ * Gets all type members of the type like fields, methods, anonymous block, etc.
+ */
+ List<CtTypeMember> getTypeMembers();
+
+ /**
+ * Adds a type member at the end of all type member of the type.
+ */
+ <C extends CtType<T>> C addTypeMember(CtTypeMember member);
+
+ /**
+ * Adds a type member at a given position. Think to use this method if the order is
+ * important for you.
+ */
+ <C extends CtType<T>> C addTypeMemberAt(int position, CtTypeMember member);
+
+ /**
+ * Removes the type member.
+ */
+ boolean removeTypeMember(CtTypeMember member);
+
+ /**
+ * Removes all types members with these new members.
+ */
+ <C extends CtType<T>> C setTypeMembers(List<CtTypeMember> members);
+
  @Override
  CtType<T> clone();
 }

src/main/java/spoon/reflect/factory/InterfaceFactory.java

@@ -49,10 +49,10 @@ public <T> CtInterface<T> create(CtPackage owner, String simpleName) {
  * Creates an inner interface
  */
  public <T> CtInterface<T> create(CtType<T> owner, String simpleName) {
- CtInterface<T> i = factory.Core().createInterface();
- i.setSimpleName(simpleName);
- owner.getNestedTypes().add(i);
- return i;
+ CtInterface<T> ctInterface = factory.Core().createInterface();
+ ctInterface.setSimpleName(simpleName);
+ owner.addNestedType(ctInterface);
+ return ctInterface;
  }
 
  /**

src/main/java/spoon/reflect/visitor/CtBiScannerDefault.java

@@ -43,8 +43,7 @@ public <A extends java.lang.annotation.Annotation> void visitCtAnnotationType(fi
  spoon.reflect.declaration.CtAnnotationType other = ((spoon.reflect.declaration.CtAnnotationType) (stack.peek()));
  enter(annotationType);
  biScan(annotationType.getAnnotations(), other.getAnnotations());
- biScan(annotationType.getNestedTypes(), other.getNestedTypes());
- biScan(annotationType.getFields(), other.getFields());
+ biScan(annotationType.getTypeMembers(), other.getTypeMembers());
  biScan(annotationType.getComments(), other.getComments());
  exit(annotationType);
  }
@@ -173,16 +172,12 @@ public <T> void visitCtClass(final spoon.reflect.declaration.CtClass<T> ctClass)
  biScan(ctClass.getSuperclass(), other.getSuperclass());
  biScan(ctClass.getSuperInterfaces(), other.getSuperInterfaces());
  biScan(ctClass.getFormalCtTypeParameters(), other.getFormalCtTypeParameters());
- biScan(ctClass.getAnonymousExecutables(), other.getAnonymousExecutables());
- biScan(ctClass.getNestedTypes(), other.getNestedTypes());
- biScan(ctClass.getFields(), other.getFields());
- biScan(ctClass.getConstructors(), other.getConstructors());
- biScan(ctClass.getMethods(), other.getMethods());
+ biScan(ctClass.getTypeMembers(), other.getTypeMembers());
  biScan(ctClass.getComments(), other.getComments());
  exit(ctClass);
  }
 
- @Override
+ @java.lang.Override
  public void visitCtTypeParameter(spoon.reflect.declaration.CtTypeParameter typeParameter) {
  spoon.reflect.declaration.CtTypeParameter other = ((spoon.reflect.declaration.CtTypeParameter) (stack.peek()));
  enter(typeParameter);
@@ -240,10 +235,8 @@ public <T extends java.lang.Enum<?>> void visitCtEnum(final spoon.reflect.declar
  enter(ctEnum);
  biScan(ctEnum.getAnnotations(), other.getAnnotations());
  biScan(ctEnum.getSuperInterfaces(), other.getSuperInterfaces());
- biScan(ctEnum.getFields(), other.getFields());
- biScan(ctEnum.getConstructors(), other.getConstructors());
- biScan(ctEnum.getMethods(), other.getMethods());
- biScan(ctEnum.getNestedTypes(), other.getNestedTypes());
+ biScan(ctEnum.getTypeMembers(), other.getTypeMembers());
+ biScan(ctEnum.getEnumValues(), other.getEnumValues());
  biScan(ctEnum.getComments(), other.getComments());
  exit(ctEnum);
  }
@@ -353,9 +346,7 @@ public <T> void visitCtInterface(final spoon.reflect.declaration.CtInterface<T>
  biScan(intrface.getAnnotations(), other.getAnnotations());
  biScan(intrface.getSuperInterfaces(), other.getSuperInterfaces());
  biScan(intrface.getFormalCtTypeParameters(), other.getFormalCtTypeParameters());
- biScan(intrface.getNestedTypes(), other.getNestedTypes());
- biScan(intrface.getFields(), other.getFields());
- biScan(intrface.getMethods(), other.getMethods());
+ biScan(intrface.getTypeMembers(), other.getTypeMembers());
  biScan(intrface.getComments(), other.getComments());
  exit(intrface);
  }

src/main/java/spoon/reflect/visitor/CtScanner.java

@@ -179,8 +179,7 @@ public <A extends Annotation> void visitCtAnnotationType(
  final CtAnnotationType<A> annotationType) {
  enter(annotationType);
  scan(annotationType.getAnnotations());
- scan(annotationType.getNestedTypes());
- scan(annotationType.getFields());
+ scan(annotationType.getTypeMembers());
  scan(annotationType.getComments());
  exit(annotationType);
  }
@@ -298,11 +297,7 @@ public <T> void visitCtClass(final CtClass<T> ctClass) {
  scan(ctClass.getSuperclass());
  scan(ctClass.getSuperInterfaces());
  scan(ctClass.getFormalCtTypeParameters());
- scan(ctClass.getAnonymousExecutables());
- scan(ctClass.getNestedTypes());
- scan(ctClass.getFields());
- scan(ctClass.getConstructors());
- scan(ctClass.getMethods());
+ scan(ctClass.getTypeMembers());
  scan(ctClass.getComments());
  exit(ctClass);
  }
@@ -359,10 +354,8 @@ public <T extends Enum<?>> void visitCtEnum(final CtEnum<T> ctEnum) {
  enter(ctEnum);
  scan(ctEnum.getAnnotations());
  scan(ctEnum.getSuperInterfaces());
- scan(ctEnum.getFields());
- scan(ctEnum.getConstructors());
- scan(ctEnum.getMethods());
- scan(ctEnum.getNestedTypes());
+ scan(ctEnum.getTypeMembers());
+ scan(ctEnum.getEnumValues());
  scan(ctEnum.getComments());
  exit(ctEnum);
  }
@@ -464,9 +457,7 @@ public <T> void visitCtInterface(final CtInterface<T> intrface) {
  scan(intrface.getAnnotations());
  scan(intrface.getSuperInterfaces());
  scan(intrface.getFormalCtTypeParameters());
- scan(intrface.getNestedTypes());
- scan(intrface.getFields());
- scan(intrface.getMethods());
+ scan(intrface.getTypeMembers());
  scan(intrface.getComments());
  exit(intrface);
  }

src/main/java/spoon/reflect/visitor/DefaultJavaPrettyPrinter.java

@@ -105,8 +105,6 @@
 import spoon.reflect.visitor.printer.CommentOffset;
 import spoon.reflect.visitor.printer.ElementPrinterHelper;
 import spoon.reflect.visitor.printer.PrinterHelper;
-import spoon.support.reflect.cu.CtLineElementComparator;
-import spoon.support.util.SortedList;
 
 import java.lang.annotation.Annotation;
 import java.util.ArrayDeque;
@@ -347,11 +345,7 @@ public <A extends Annotation> void visitCtAnnotationType(CtAnnotationType<A> ann
  visitCtType(annotationType);
  printer.write("@interface " + annotationType.getSimpleName() + " {").incTab();
 
- SortedList<CtElement> lst = new SortedList<>(new CtLineElementComparator());
- lst.addAll(annotationType.getNestedTypes());
- lst.addAll(annotationType.getFields());
- lst.addAll(annotationType.getMethods());
- elementPrinterHelper.writeElementList(lst);
+ elementPrinterHelper.writeElementList(annotationType.getTypeMembers());
  printer.decTab().writeTabs().write("}");
  }
 
@@ -513,7 +507,6 @@ public void visitCtCatch(CtCatch catchBlock) {
 
  @Override
  public <T> void visitCtClass(CtClass<T> ctClass) {
- SortedList<CtElement> lst = new SortedList<>(new CtLineElementComparator());
  if (ctClass.getSimpleName() != null && !CtType.NAME_UNKNOWN.equals(ctClass.getSimpleName()) && !ctClass.isAnonymous()) {
  visitCtType(ctClass);
  if (ctClass.isLocalType()) {
@@ -525,21 +518,12 @@ public <T> void visitCtClass(CtClass<T> ctClass) {
  elementPrinterHelper.writeFormalTypeParameters(ctClass);
  elementPrinterHelper.writeExtendsClause(ctClass);
  elementPrinterHelper.writeImplementsClause(ctClass);
- for (CtConstructor<T> c : ctClass.getConstructors()) {
- if (!c.isImplicit()) {
- lst.add(c);
- }
- }
  }
- lst.addAll(ctClass.getAnonymousExecutables());
- lst.addAll(ctClass.getNestedTypes());
- lst.addAll(ctClass.getFields());
- lst.addAll(ctClass.getMethods());
- lst.addAll(elementPrinterHelper.getComments(ctClass, CommentOffset.INSIDE));
+ // lst.addAll(elementPrinterHelper.getComments(ctClass, CommentOffset.INSIDE));
 
  context.currentThis.push(ctClass.getReference());
  printer.write(" {").incTab();
- elementPrinterHelper.writeElementList(lst);
+ elementPrinterHelper.writeElementList(ctClass.getTypeMembers());
  printer.decTab().writeTabs().write("}");
  context.currentThis.pop();
  }
@@ -659,27 +643,7 @@ public <T extends Enum<?>> void visitCtEnum(CtEnum<T> ctEnum) {
  printer.write(";");
  }
 
- for (CtField<?> field : ctEnum.getFields()) {
- if (!(field instanceof CtEnumValue)) {
- printer.writeln().writeTabs();
- scan(field);
- }
- }
-
- for (CtConstructor<?> c : ctEnum.getConstructors()) {
- if (!c.isImplicit()) {
- printer.writeln().writeTabs();
- scan(c);
- }
- }
-
- SortedList<CtElement> lst = new SortedList<>(new CtLineElementComparator());
-
- lst.addAll(ctEnum.getAnonymousExecutables());
- lst.addAll(ctEnum.getNestedTypes());
- lst.addAll(ctEnum.getMethods());
-
- elementPrinterHelper.writeElementList(lst);
+ elementPrinterHelper.writeElementList(ctEnum.getTypeMembers());
  printer.decTab().writeTabs().write("}");
  context.currentThis.pop();
  }
@@ -1031,12 +995,8 @@ public <T> void visitCtInterface(CtInterface<T> intrface) {
  printer.removeLastChar();
  }
  printer.write(" {").incTab();
- SortedList<CtElement> lst = new SortedList<>(new CtLineElementComparator());
- lst.addAll(intrface.getNestedTypes());
- lst.addAll(intrface.getFields());
- lst.addAll(intrface.getMethods());
  // Content
- elementPrinterHelper.writeElementList(lst);
+ elementPrinterHelper.writeElementList(intrface.getTypeMembers());
  printer.decTab().writeTabs().write("}");
  }
 

src/main/java/spoon/reflect/visitor/ImportScannerImpl.java

@@ -26,6 +26,7 @@
 import spoon.reflect.declaration.CtEnum;
 import spoon.reflect.declaration.CtInterface;
 import spoon.reflect.declaration.CtType;
+import spoon.reflect.declaration.CtTypeMember;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
@@ -142,17 +143,23 @@ public <T extends Enum<?>> void visitCtEnum(CtEnum<T> ctEnum) {
  @Override
  public <T> void visitCtInterface(CtInterface<T> intrface) {
  addImport(intrface.getReference());
- for (CtType<?> t : intrface.getNestedTypes()) {
- addImport(t.getReference());
+ for (CtTypeMember t : intrface.getTypeMembers()) {
+ if (!(t instanceof CtType)) {
+ continue;
+ }
+ addImport(((CtType) t).getReference());
  }
  super.visitCtInterface(intrface);
  }
 
  @Override
  public <T> void visitCtClass(CtClass<T> ctClass) {
  addImport(ctClass.getReference());
- for (CtType<?> t : ctClass.getNestedTypes()) {
- addImport(t.getReference());
+ for (CtTypeMember t : ctClass.getTypeMembers()) {
+ if (!(t instanceof CtType)) {
+ continue;
+ }
+ addImport(((CtType) t).getReference());
  }
  super.visitCtClass(ctClass);
  }

src/main/java/spoon/reflect/visitor/printer/ElementPrinterHelper.java

@@ -31,21 +31,22 @@
 import spoon.reflect.cu.CompilationUnit;
 import spoon.reflect.declaration.CtAnnotation;
 import spoon.reflect.declaration.CtClass;
+import spoon.reflect.declaration.CtConstructor;
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtExecutable;
 import spoon.reflect.declaration.CtFormalTypeDeclarer;
 import spoon.reflect.declaration.CtModifiable;
 import spoon.reflect.declaration.CtNamedElement;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.declaration.CtType;
+import spoon.reflect.declaration.CtTypeMember;
 import spoon.reflect.declaration.CtTypeParameter;
 import spoon.reflect.declaration.ModifierKind;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.reference.CtActualTypeContainer;
 import spoon.reflect.reference.CtFieldReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.visitor.DefaultJavaPrettyPrinter;
-import spoon.support.util.SortedList;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -141,8 +142,11 @@ public void writeStatement(CtStatement statement) {
  writeComment(statement, CommentOffset.AFTER);
  }
 
- public void writeElementList(SortedList<CtElement> elements) {
- for (CtElement element : elements) {
+ public void writeElementList(List<CtTypeMember> elements) {
+ for (CtTypeMember element : elements) {
+ if (element instanceof CtConstructor && element.isImplicit()) {
+ continue;
+ }
  printer.writeln().writeTabs();
  prettyPrinter.scan(element);
  if (!env.isPreserveLineNumbers()) {

src/main/java/spoon/support/compiler/jdt/JDTCommentBuilder.java

@@ -40,6 +40,7 @@
 import spoon.reflect.declaration.CtInterface;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtParameter;
+import spoon.reflect.declaration.CtTypeMember;
 import spoon.reflect.declaration.ParentNotInitializedException;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.visitor.CtInheritanceScanner;
@@ -243,10 +244,12 @@ public <T> void visitCtClass(CtClass<T> e) {
  e.addComment(comment);
  return;
  }
- List<CtElement> elements = new ArrayList<>();
- elements.addAll(e.getFields());
- elements.addAll(e.getMethods());
- elements.addAll(e.getConstructors());
+ final List<CtElement> elements = new ArrayList<>();
+ for (CtTypeMember typeMember : e.getTypeMembers()) {
+ if (typeMember instanceof CtField || typeMember instanceof CtMethod || typeMember instanceof CtConstructor) {
+ elements.add(typeMember);
+ }
+ }
  addCommentToNear(comment, elements);
 
  try {
@@ -258,9 +261,12 @@ public <T> void visitCtClass(CtClass<T> e) {
 
  @Override
  public <T> void visitCtInterface(CtInterface<T> e) {
- List<CtElement> elements = new ArrayList<>();
- elements.addAll(e.getFields());
- elements.addAll(e.getMethods());
+ final List<CtElement> elements = new ArrayList<>();
+ for (CtTypeMember typeMember : e.getTypeMembers()) {
+ if (typeMember instanceof CtField || typeMember instanceof CtMethod) {
+ elements.add(typeMember);
+ }
+ }
  addCommentToNear(comment, elements);
 
  try {