@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getAccessedType()))); }
@Override public void visitCtWildcardReference(CtWildcardReference e) { if (childJDT instanceof TypeReference && child instanceof CtTypeAccess) { e.setBoundingType(((CtTypeAccess) child).getAccessedType()); } super.visitCtWildcardReference(e); } }
@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 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 <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { if (typeAccess.isImplicit()) { return; } enterCtExpression(typeAccess); scan(typeAccess.getAccessedType()); exitCtExpression(typeAccess); }
@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); }
@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); }
@Override public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) { if (child instanceof CtTypeAccess) { if (hasChildEqualsToType(ctConstructorCall)) { ctConstructorCall.getExecutable().setType(((CtTypeAccess) child).getAccessedType()); } else { ctConstructorCall.addActualTypeArgument(((CtTypeAccess) child).getAccessedType()); } return; } else if (child instanceof CtExpression) { if (hasChildEqualsToEnclosingInstance(ctConstructorCall)) { ctConstructorCall.setTarget((CtExpression<?>) child); } else { ctConstructorCall.addArgument((CtExpression<?>) child); } return; } super.visitCtConstructorCall(ctConstructorCall); }
@Override public <T> void visitCtNewArray(CtNewArray<T> newArray) { if (childJDT instanceof TypeReference && child instanceof CtTypeAccess) { final ArrayAllocationExpression arrayAlloc = (ArrayAllocationExpression) jdtTreeBuilder.getContextBuilder().stack.peek().node; newArray.setType((CtArrayTypeReference) jdtTreeBuilder.getFactory().Type().createArrayReference(((CtTypeAccess) child).getAccessedType(), arrayAlloc.dimensions.length)); } else if (child instanceof CtExpression) { if (isContainedInDimensionExpression()) { newArray.addDimensionExpression((CtExpression<Integer>) child); } else if (child instanceof CtNewArray && childJDT instanceof ArrayInitializer && jdtTreeBuilder.getContextBuilder().stack.peek().node instanceof ArrayAllocationExpression) { newArray.setElements(((CtNewArray) child).getElements()); } else { newArray.addElement((CtExpression) child); } } }
@Override public <T> void visitCtMethod(CtMethod<T> e) { if (e.getBody() == null && child instanceof CtBlock) { e.setBody((CtBlock) child); return; } else if (child instanceof CtStatement) { visitCtBlock(e.getBody()); return; } else if (child instanceof CtTypeAccess && hasChildEqualsToType(e)) { e.setType(((CtTypeAccess) child).getAccessedType()); substituteAnnotation(e); return; } super.visitCtMethod(e); }
@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); }
<T> CtExecutableReference<T> getExecutableReference(MessageSend messageSend) { if (messageSend.binding != null) { return getExecutableReference(messageSend.binding); } CtExecutableReference<T> ref = jdtTreeBuilder.getFactory().Core().createExecutableReference(); ref.setSimpleName(CharOperation.charToString(messageSend.selector)); ref.setType(this.<T>getTypeReference(messageSend.expectedType(), true)); if (messageSend.receiver.resolvedType == null) { // It is crisis dude! static context, we don't have much more information. if (messageSend.receiver instanceof SingleNameReference) { ref.setDeclaringType(jdtTreeBuilder.getHelper().createTypeAccessNoClasspath((SingleNameReference) messageSend.receiver).getAccessedType()); } else if (messageSend.receiver instanceof QualifiedNameReference) { ref.setDeclaringType(jdtTreeBuilder.getHelper().createTypeAccessNoClasspath((QualifiedNameReference) messageSend.receiver).getAccessedType()); } } else { ref.setDeclaringType(getTypeReference(messageSend.receiver.resolvedType)); } if (messageSend.arguments != null) { final List<CtTypeReference<?>> parameters = new ArrayList<>(); for (Expression expression : messageSend.arguments) { parameters.add(getTypeReference(expression.resolvedType, true)); } ref.setParameters(parameters); } return ref; }
@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)); }
CtTypeReference targetType = target.getAccessedType();
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { if (typeAccess.getAccessedType() != null) { label = typeAccess.getAccessedType().getQualifiedName(); } } }
@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; }
fieldRead.setVariable(variable); fieldRead.setTarget(target); fieldRead.setType(target.getAccessedType()); res = fieldRead; } else if (isPrimitive(value.getClass()) || value instanceof String) {
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { label = typeAccess.getAccessedType().getQualifiedName(); } }
@Override public <T> void visitCtInvocation(CtInvocation<T> invocation) { if (childJDT instanceof TypeReference && child instanceof CtTypeAccess) { invocation.getExecutable().addActualTypeArgument(((CtTypeAccess) child).getAccessedType()); return; } else if (child instanceof CtExpression) { if (hasChildEqualsToReceiver(invocation) || hasChildEqualsToQualification(invocation)) { if (child instanceof CtThisAccess) { final CtTypeReference<?> declaringType = invocation.getExecutable().getDeclaringType(); if (declaringType != null && invocation.getExecutable().isStatic() && child.isImplicit()) { invocation.setTarget(jdtTreeBuilder.getFactory().Code().createTypeAccess(declaringType, declaringType.isAnonymous())); } else { invocation.setTarget((CtThisAccess<?>) child); } } else { invocation.setTarget((CtExpression<?>) child); } } else { invocation.addArgument((CtExpression<?>) child); } return; } super.visitCtInvocation(invocation); }