Remove CtImplicitTypeRef and CtImplicitArrayTypeRef

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

@@ -17,8 +17,6 @@
 package spoon.reflect.factory;
 
 import spoon.reflect.internal.CtCircularTypeReference;
-import spoon.reflect.internal.CtImplicitArrayTypeReference;
-import spoon.reflect.internal.CtImplicitTypeReference;
 
 /**
  * This interface defines the creation methods for internal nodes of the
@@ -30,14 +28,4 @@ public interface InternalFactory {
  * Creates a circular type reference.
  */
  CtCircularTypeReference createCircularTypeReference();
-
- /**
- * Creates a inference type reference.
- */
- <T> CtImplicitTypeReference<T> createImplicitTypeReference();
-
- /**
- * Creates an implicit array type reference.
- */
- <T> CtImplicitArrayTypeReference<T> createImplicitArrayTypeReference();
 }

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

@@ -75,8 +75,6 @@
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.internal.CtCircularTypeReference;
-import spoon.reflect.internal.CtImplicitArrayTypeReference;
-import spoon.reflect.internal.CtImplicitTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -138,11 +136,6 @@ public <T> void visitCtArrayTypeReference(CtArrayTypeReference<T> reference) {
 
  }
 
- @Override
- public <T> void visitCtImplicitArrayTypeReference(CtImplicitArrayTypeReference<T> reference) {
-
- }
-
  @Override
  public <T> void visitCtAssert(CtAssert<T> asserted) {
 
@@ -387,11 +380,6 @@ public void visitCtCircularTypeReference(CtCircularTypeReference reference) {
 
  }
 
- @Override
- public <T> void visitCtImplicitTypeReference(CtImplicitTypeReference<T> reference) {
-
- }
-
  @Override
  public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) {
 

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

@@ -97,8 +97,6 @@
 import spoon.reflect.declaration.CtTypedElement;
 import spoon.reflect.declaration.CtVariable;
 import spoon.reflect.internal.CtCircularTypeReference;
-import spoon.reflect.internal.CtImplicitArrayTypeReference;
-import spoon.reflect.internal.CtImplicitTypeReference;
 import spoon.reflect.reference.CtActualTypeContainer;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
@@ -418,11 +416,6 @@ public <T> void visitCtArrayTypeReference(CtArrayTypeReference<T> e) {
  visitCtTypeReference(e);
  }
 
- @Override
- public <T> void visitCtImplicitArrayTypeReference(CtImplicitArrayTypeReference<T> reference) {
- visitCtArrayTypeReference(reference);
- }
-
  public <T> void visitCtAssert(CtAssert<T> e) {
  scanCtStatement(e);
  scanCtCodeElement(e);
@@ -813,11 +806,6 @@ public void visitCtCircularTypeReference(CtCircularTypeReference e) {
  visitCtTypeParameterReference(e);
  }
 
- @Override
- public <T> void visitCtImplicitTypeReference(CtImplicitTypeReference<T> reference) {
- visitCtTypeReference(reference);
- }
-
  @Override
  public <T> void visitCtTypeAccess(CtTypeAccess<T> e) {
  scanCtExpression(e);

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

@@ -78,8 +78,6 @@
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.internal.CtCircularTypeReference;
-import spoon.reflect.internal.CtImplicitArrayTypeReference;
-import spoon.reflect.internal.CtImplicitTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -243,11 +241,6 @@ public <T> void visitCtArrayTypeReference(final CtArrayTypeReference<T> referenc
  exit(reference);
  }
 
- @Override
- public <T> void visitCtImplicitArrayTypeReference(final CtImplicitArrayTypeReference<T> reference) {
- visitCtArrayTypeReference(reference);
- }
-
  public <T> void visitCtAssert(final CtAssert<T> asserted) {
  enter(asserted);
  scan(asserted.getAnnotations());
@@ -744,11 +737,6 @@ public void visitCtCircularTypeReference(final CtCircularTypeReference reference
  exit(reference);
  }
 
- @Override
- public <T> void visitCtImplicitTypeReference(final CtImplicitTypeReference<T> reference) {
- visitCtTypeReference(reference);
- }
-
  @Override
  public <T> void visitCtTypeAccess(final CtTypeAccess<T> typeAccess) {
  enter(typeAccess);

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

@@ -75,8 +75,6 @@
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.declaration.CtParameter;
 import spoon.reflect.internal.CtCircularTypeReference;
-import spoon.reflect.internal.CtImplicitArrayTypeReference;
-import spoon.reflect.internal.CtImplicitTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.reference.CtExecutableReference;
@@ -138,11 +136,6 @@ public interface CtVisitor {
  */
  <T> void visitCtArrayTypeReference(CtArrayTypeReference<T> reference);
 
- /**
- * Visits a reference to an implicit array type.
- */
- <T> void visitCtImplicitArrayTypeReference(CtImplicitArrayTypeReference<T> reference);
-
  /**
  * Visits an assert.
  */
@@ -400,11 +393,6 @@ <T, A extends T> void visitCtOperatorAssignment(
  */
  void visitCtCircularTypeReference(CtCircularTypeReference reference);
 
- /**
- * Visits a reference to an implicit type.
- */
- <T> void visitCtImplicitTypeReference(CtImplicitTypeReference<T> reference);
-
  /**
  * Visits a type access.
  */

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

@@ -94,8 +94,6 @@
 import spoon.reflect.declaration.ParentNotInitializedException;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.internal.CtCircularTypeReference;
-import spoon.reflect.internal.CtImplicitArrayTypeReference;
-import spoon.reflect.internal.CtImplicitTypeReference;
 import spoon.reflect.reference.CtActualTypeContainer;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtCatchVariableReference;
@@ -631,17 +629,15 @@ public <T, E extends CtExpression<?>> void printCtArrayAccess(CtArrayAccess<T, E
  }
 
  public <T> void visitCtArrayTypeReference(CtArrayTypeReference<T> reference) {
+ if (reference.isImplicit()) {
+ return;
+ }
  scan(reference.getComponentType());
  if (!context.skipArray) {
  write("[]");
  }
  }
 
- @Override
- public <T> void visitCtImplicitArrayTypeReference(CtImplicitArrayTypeReference<T> reference) {
- // The array type is implicit, we don't print it!
- }
-
  public <T> void visitCtAssert(CtAssert<T> asserted) {
  enterCtStatement(asserted);
  write("assert ");
@@ -2006,6 +2002,9 @@ public void visitCtTryWithResource(CtTryWithResource tryWithResource) {
  }
 
  public void visitCtTypeParameterReference(CtTypeParameterReference ref) {
+ if (ref.isImplicit()) {
+ return;
+ }
  writeAnnotations(ref);
  if (importsContext.isImported(ref)) {
  write(ref.getSimpleName());
@@ -2040,11 +2039,6 @@ public void visitCtCircularTypeReference(CtCircularTypeReference reference) {
  visitCtTypeReference(reference);
  }
 
- @Override
- public <T> void visitCtImplicitTypeReference(CtImplicitTypeReference<T> reference) {
- // The type is implicit, we don't print it!
- }
-
  @Override
  public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) {
  enterCtExpression(typeAccess);
@@ -2057,6 +2051,9 @@ public void visitCtTypeReferenceWithoutGenerics(CtTypeReference<?> ref) {
  }
 
  private void visitCtTypeReference(CtTypeReference<?> ref, boolean withGenerics) {
+ if (ref.isImplicit()) {
+ return;
+ }
  if (ref.isPrimitive()) {
  writeAnnotations(ref);
  write(ref.getSimpleName());
@@ -2247,7 +2244,7 @@ public DefaultJavaPrettyPrinter writeActualTypeArguments(CtActualTypeContainer c
  write("<");
  boolean isImplicitTypeReference = true;
  for (CtTypeReference<?> param : params) {
- if (!(param instanceof CtImplicitTypeReference)) {
+ if (!(param.isImplicit())) {
  isImplicitTypeReference = false;
  scan(param);
  write(", ");

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

@@ -26,7 +26,6 @@
 import spoon.reflect.declaration.CtEnum;
 import spoon.reflect.declaration.CtInterface;
 import spoon.reflect.declaration.CtType;
-import spoon.reflect.internal.CtImplicitTypeReference;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
@@ -173,7 +172,7 @@ public void computeImports(CtElement element) {
 
  @Override
  public boolean isImported(CtTypeReference<?> ref) {
- if (!(ref instanceof CtImplicitTypeReference) && imports.containsKey(ref.getSimpleName())) {
+ if (!(ref.isImplicit()) && imports.containsKey(ref.getSimpleName())) {
  CtTypeReference<?> exist = imports.get(ref.getSimpleName());
  if (exist.getQualifiedName().equals(ref.getQualifiedName())) {
  return true;

src/main/java/spoon/support/DefaultInternalFactory.java

@@ -19,11 +19,7 @@
 import spoon.reflect.factory.Factory;
 import spoon.reflect.factory.InternalFactory;
 import spoon.reflect.internal.CtCircularTypeReference;
-import spoon.reflect.internal.CtImplicitArrayTypeReference;
-import spoon.reflect.internal.CtImplicitTypeReference;
 import spoon.support.reflect.internal.CtCircularTypeReferenceImpl;
-import spoon.support.reflect.internal.CtImplicitArrayTypeReferenceImpl;
-import spoon.support.reflect.internal.CtImplicitTypeReferenceImpl;
 
 public class DefaultInternalFactory implements InternalFactory {
  private final Factory mainFactory;
@@ -38,18 +34,4 @@ public CtCircularTypeReference createCircularTypeReference() {
  e.setFactory(mainFactory);
  return e;
  }
-
- @Override
- public <T> CtImplicitTypeReference<T> createImplicitTypeReference() {
- final CtImplicitTypeReferenceImpl<T> e = new CtImplicitTypeReferenceImpl<T>();
- e.setFactory(mainFactory);
- return e;
- }
-
- @Override
- public <T> CtImplicitArrayTypeReference<T> createImplicitArrayTypeReference() {
- final CtImplicitArrayTypeReference<T> e = new CtImplicitArrayTypeReferenceImpl<T>();
- e.setFactory(mainFactory);
- return e;
- }
 }