@java.lang.Override public <T> void visitCtTypeAccess(final spoon.reflect.code.CtTypeAccess<T> typeAccess) { spoon.reflect.code.CtTypeAccess<T> aCtTypeAccess = typeAccess.getFactory().Core().createTypeAccess(); this.builder.copy(typeAccess, aCtTypeAccess); aCtTypeAccess.setAnnotations(this.cloneHelper.clone(typeAccess.getAnnotations())); aCtTypeAccess.setTypeCasts(this.cloneHelper.clone(typeAccess.getTypeCasts())); aCtTypeAccess.setAccessedType(this.cloneHelper.clone(typeAccess.getAccessedType())); aCtTypeAccess.setComments(this.cloneHelper.clone(typeAccess.getComments())); this.cloneHelper.tailor(typeAccess, aCtTypeAccess); this.other = aCtTypeAccess; }
@Override public <T> CtTypeAccess<T> createTypeAccess() { CtTypeAccess<T> e = new CtTypeAccessImpl<>(); e.setFactory(getMainFactory()); return e; }
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { if (typeAccess.isImplicit()) { return; } enterCtExpression(typeAccess); scan(typeAccess.getAccessedType()); exitCtExpression(typeAccess); }
@java.lang.Override public <T> void visitCtTypeAccess(final spoon.reflect.code.CtTypeAccess<T> typeAccess) { spoon.reflect.code.CtTypeAccess other = ((spoon.reflect.code.CtTypeAccess) (this.stack.peek())); enter(typeAccess); biScan(spoon.reflect.path.CtRole.ANNOTATION, typeAccess.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.CAST, typeAccess.getTypeCasts(), other.getTypeCasts()); biScan(spoon.reflect.path.CtRole.ACCESSED_TYPE, typeAccess.getAccessedType(), other.getAccessedType()); biScan(spoon.reflect.path.CtRole.COMMENT, typeAccess.getComments(), other.getComments()); exit(typeAccess); }
@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getAccessedType()))); }
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { enter(typeAccess); scan(typeAccess.getAnnotations()); scan(typeAccess.getType()); scanReferences(typeAccess.getTypeCasts()); exit(typeAccess); }
@java.lang.Override public void set(spoon.reflect.reference.CtTypeReference replace) { this.element.setAccessedType(replace); } }
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { scan(typeAccess.getType()); }
@Override public <T> void visitCtTypeAccess(final CtTypeAccess<T> typeAccess) { enter(typeAccess); scan(CtRole.ANNOTATION, typeAccess.getAnnotations()); scan(CtRole.CAST, typeAccess.getTypeCasts()); scan(CtRole.ACCESSED_TYPE, typeAccess.getAccessedType()); scan(CtRole.COMMENT, typeAccess.getComments()); exit(typeAccess); }
@Override public void visitCtWildcardReference(CtWildcardReference e) { if (childJDT instanceof TypeReference && child instanceof CtTypeAccess) { e.setBoundingType(((CtTypeAccess) child).getAccessedType()); } super.visitCtWildcardReference(e); } }
@Override public <T, U> void setValue(T element, U value) { castTarget(element).setAccessedType(castValue(value)); } }
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { scan(typeAccess.getType()); }
@java.lang.Override public <T> void visitCtTypeAccess(final spoon.reflect.code.CtTypeAccess<T> typeAccess) { replaceInListIfExist(typeAccess.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(typeAccess)); replaceInListIfExist(typeAccess.getTypeCasts(), new spoon.support.visitor.replace.ReplacementVisitor.CtExpressionTypeCastsReplaceListener(typeAccess)); replaceElementIfExist(typeAccess.getAccessedType(), new spoon.support.visitor.replace.ReplacementVisitor.CtTypeAccessAccessedTypeReplaceListener(typeAccess)); replaceInListIfExist(typeAccess.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(typeAccess)); }
@Override public void visitCtTypeParameter(CtTypeParameter typeParameter) { if (childJDT instanceof TypeReference && child instanceof CtTypeAccess) { if (typeParameter.getSuperclass() == null) { typeParameter.setSuperclass(((CtTypeAccess) child).getAccessedType()); } else if (typeParameter.getSuperclass() instanceof CtIntersectionTypeReference) { typeParameter.getSuperclass().asCtIntersectionTypeReference().addBound(((CtTypeAccess) child).getAccessedType()); } else { final List<CtTypeReference<?>> refs = new ArrayList<>(); refs.add(typeParameter.getSuperclass()); refs.add(((CtTypeAccess) child).getAccessedType()); typeParameter.setSuperclass(jdtTreeBuilder.getFactory().Type().createIntersectionTypeReferenceWithBounds(refs)); } return; } super.visitCtTypeParameter(typeParameter); }
@Override public <T> CtTypeAccess<T> createTypeAccess() { CtTypeAccess<T> e = new CtTypeAccessImpl<T>(); e.setFactory(getMainFactory()); return e; }
/** * Creates a accessed type, see {@link #createTypeAccess(CtTypeReference)} for details. * @param accessedType a type reference to the accessed type. * @param <T> the type of the expression. * @return a accessed type expression. */ public <T> CtTypeAccess<T> createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType) { final CtTypeAccess<T> typeAccess = factory.Core().createTypeAccess(); typeAccess.setAccessedType(accessedType); return typeAccess; }
@Override public boolean visit(ArrayTypeReference arrayTypeReference, BlockScope scope) { CtTypeReference<Object> objectCtTypeReference = references.buildTypeReference(arrayTypeReference, scope); final CtTypeAccess<Object> typeAccess = factory.Code().createTypeAccess(objectCtTypeReference); if (typeAccess.getAccessedType() instanceof CtArrayTypeReference) { ((CtArrayTypeReference) typeAccess.getAccessedType()).getArrayType().setAnnotations(this.references.buildTypeReference(arrayTypeReference, scope).getAnnotations()); } context.enter(typeAccess, arrayTypeReference); return true; }
@Override public boolean visit(ArrayQualifiedTypeReference arrayQualifiedTypeReference, BlockScope scope) { final CtTypeAccess<Object> typeAccess = factory.Core().createTypeAccess(); context.enter(typeAccess, arrayQualifiedTypeReference); final CtArrayTypeReference<Object> arrayType = (CtArrayTypeReference<Object>) references.getTypeReference(arrayQualifiedTypeReference.resolvedType); arrayType.getArrayType().setAnnotations(this.references.buildTypeReference(arrayQualifiedTypeReference, scope).getAnnotations()); typeAccess.setAccessedType(arrayType); return true; }
@Override public <R> void scanCtExecutable(CtExecutable<R> e) { if (child instanceof CtTypeAccess) { e.addThrownType(((CtTypeAccess) child).getAccessedType()); return; } else if (child instanceof CtParameter) { e.addParameter((CtParameter<?>) child); return; } else if (child instanceof CtBlock && !(e instanceof CtMethod || e instanceof CtConstructor)) { e.setBody((CtBlock<R>) child); return; } super.scanCtExecutable(e); }
@Override public <T> void scanCtVariable(CtVariable<T> v) { if (childJDT instanceof TypeReference && child instanceof CtTypeAccess) { v.setType(((CtTypeAccess) child).getAccessedType()); substituteAnnotation((CtTypedElement) v); return; } else if (child instanceof CtExpression && hasChildEqualsToDefaultValue(v)) { v.setDefaultExpression((CtExpression<T>) child); return; } super.scanCtVariable(v); }