public <T> void visitCtNewArray(final spoon.reflect.code.CtNewArray<T> newArray) { spoon.reflect.code.CtNewArray<T> aCtNewArray = newArray.getFactory().Core().createNewArray(); this.builder.copy(newArray, aCtNewArray); aCtNewArray.setAnnotations(this.cloneHelper.clone(newArray.getAnnotations())); aCtNewArray.setType(this.cloneHelper.clone(newArray.getType())); aCtNewArray.setTypeCasts(this.cloneHelper.clone(newArray.getTypeCasts())); aCtNewArray.setElements(this.cloneHelper.clone(newArray.getElements())); aCtNewArray.setDimensionExpressions(this.cloneHelper.clone(newArray.getDimensionExpressions())); aCtNewArray.setComments(this.cloneHelper.clone(newArray.getComments())); this.cloneHelper.tailor(newArray, aCtNewArray); this.other = aCtNewArray; }
@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); } } }
public <T> void visitCtNewArray(final spoon.reflect.code.CtNewArray<T> newArray) { spoon.reflect.code.CtNewArray other = ((spoon.reflect.code.CtNewArray) (this.stack.peek())); enter(newArray); biScan(spoon.reflect.path.CtRole.ANNOTATION, newArray.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE, newArray.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.CAST, newArray.getTypeCasts(), other.getTypeCasts()); biScan(spoon.reflect.path.CtRole.EXPRESSION, newArray.getElements(), other.getElements()); biScan(spoon.reflect.path.CtRole.DIMENSION, newArray.getDimensionExpressions(), other.getDimensionExpressions()); biScan(spoon.reflect.path.CtRole.COMMENT, newArray.getComments(), other.getComments()); exit(newArray); }
@Override public <T> void visitCtNewArray(CtNewArray<T> e) { addCommentToNear(comment, new ArrayList<>(e.getElements())); try { comment.getParent(); } catch (ParentNotInitializedException ex) { e.addComment(comment); } }
/** * Creates a one-dimension array that must only contain literals. */ @SuppressWarnings("unchecked") public <T> CtNewArray<T[]> createLiteralArray(T[] value) { if (!value.getClass().isArray()) { throw new RuntimeException("value is not an array"); } if (value.getClass().getComponentType().isArray()) { throw new RuntimeException("can only create one-dimension arrays"); } final CtTypeReference<T> componentTypeRef = factory.Type().createReference((Class<T>) value.getClass().getComponentType()); final CtArrayTypeReference<T[]> arrayReference = factory.Type().createArrayReference(componentTypeRef); CtNewArray<T[]> array = factory.Core().<T[]>createNewArray().setType(arrayReference); for (T e : value) { CtLiteral<T> l = factory.Core().createLiteral(); l.setValue(e); array.addElement(l); } return array; }
boolean isNotInAnnotation; try { isNotInAnnotation = (newArray.getParent(CtAnnotationType.class) == null) && (newArray.getParent(CtAnnotation.class) == null); } catch (ParentNotInitializedException e) { isNotInAnnotation = true; CtTypeReference<?> ref = newArray.getType(); if (newArray.getDimensionExpressions().size() > i) { CtExpression<Integer> e = newArray.getDimensionExpressions().get(i); scan(e); if (newArray.getDimensionExpressions().isEmpty()) { elementPrinterHelper.printList(newArray.getElements(), null, false, "{", true, false, ",", true, true, "}", e -> scan(e));
List<CtExpression<?>> elements = ((CtNewArray) expression).getElements(); for (CtExpression expInArray : elements) { ((CtNewArray) ctExpression).addElement(expInArray); ((CtNewArray) ctExpression).addElement(expression); newArray.setType(ctExpression.getType()); newArray.setParent(this); newArray.addElement(ctExpression); newArray.addElement(expression); elementValues.put(elementName, newArray);
super.visitCtNewArray(newArray); List<CtExpression<Integer>> dimension = newArray.getDimensionExpressions(); for (int i = 0; i < dimension.size(); i++) { CtExpression p = dimension.get(i); if (candidates.containsKey(p)) { dimension.set(i, candidates.get(p)); newArray.setDimensionExpressions(dimension); saveSketchAndSynthesize(); dimension.set(i, p); newArray.setDimensionExpressions(dimension); resoreDiskFile(); List<CtExpression<?>> iniexper = newArray.getElements(); for (int i = 0; i < iniexper.size(); i++) { CtExpression p = iniexper.get(i); if (candidates.containsKey(p)) { iniexper.set(i, candidates.get(p)); newArray.setElements(iniexper); saveSketchAndSynthesize(); iniexper.set(i, p); newArray.setElements(iniexper); resoreDiskFile();
public <T> void visitCtNewArray(CtNewArray<T> newArray) { write("new "); scan(newArray.getType()); for (CtExpression<?> c : newArray.getDimensionExpressions()) { write("["); scan(c); write("]"); } write("{"); for (CtExpression<?> e : newArray.getElements()) { scan(e); write(","); } if (!newArray.getElements().isEmpty()) { clearLast(); } write("}"); }
private static CtExpression generateArray(CtTypeReference type) { CtArrayTypeReference arrayType = (CtArrayTypeReference) type; CtTypeReference typeComponent = arrayType.getComponentType(); CtNewArray<?> newArray = type.getFactory().createNewArray(); final int size = RandomHelper.getRandom().nextInt(MAX_ARRAY_SIZE); newArray.setType(arrayType); if (size == 0) { newArray.setDimensionExpressions(Collections.singletonList(type.getFactory().createLiteral(size))); } else if (ValueCreatorHelper.canGenerateAValueForType(typeComponent)) { IntStream.range(0, size) .mapToObj(i -> generateRandomValue(typeComponent, 0)) .forEach(newArray::addElement); } return newArray; }
/** creating a real low level Java array from a CtNewArray */ private Object toArray(CtNewArray value) { CtNewArray<?> arrayExpression = (CtNewArray<?>) value; Class<?> componentType = arrayExpression.getType().getActualClass().getComponentType(); List<CtExpression<?>> elements = arrayExpression.getElements(); Object array = Array.newInstance(componentType, elements.size()); for (int i = 0; i < elements.size(); i++) { Array.set(array, i, this.convertElementToRuntimeObject(elements.get(i))); } return array; }
@Override public <T> void visitCtNewArray(CtNewArray<T> newArray) { if (this.jdtTreeBuilder.context.isArgument(newArray)) { newArray.addDimensionExpression((CtExpression<Integer>) child); return; } else if (child instanceof CtExpression) { newArray.addElement((CtExpression<?>) child); return; } }
@java.lang.Override public void set(java.util.List replace) { this.element.setDimensionExpressions(replace); } }
@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getElements()))); }
@Override public boolean visit(ArrayAllocationExpression arrayAllocationExpression, BlockScope scope) { CtNewArray<Object> array = factory.Core().createNewArray(); array.setType(references.getTypeReference(arrayAllocationExpression.resolvedType)); context.enter(array, arrayAllocationExpression); context.pushArgument(array); if (arrayAllocationExpression.dimensions != null) { for (Expression e : arrayAllocationExpression.dimensions) { if (e != null) { e.traverse(this, scope); } } } context.popArgument(array); if (arrayAllocationExpression.initializer != null && arrayAllocationExpression.initializer.expressions != null) { for (Expression e : arrayAllocationExpression.initializer.expressions) { e.traverse(this, scope); } } return false; }
@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getDimensionExpressions()))); }
((CtNewArray) res).addElement(convertValueToExpression(o)); res.setType(getFactory().Type().createArrayReference(getFactory().Type().createReference(values.toArray()[0].getClass()))); for (Object o : values) { ((CtNewArray) res).addElement(convertValueToExpression(o));
public <T> void visitCtNewArray(CtNewArray<T> newArray) { setResult(newArray.getFactory().Core().clone(newArray)); }
public <T> void visitCtNewArray(final CtNewArray<T> newArray) { enter(newArray); scan(CtRole.ANNOTATION, newArray.getAnnotations()); scan(CtRole.TYPE, newArray.getType()); scan(CtRole.CAST, newArray.getTypeCasts()); scan(CtRole.EXPRESSION, newArray.getElements()); scan(CtRole.DIMENSION, newArray.getDimensionExpressions()); scan(CtRole.COMMENT, newArray.getComments()); exit(newArray); }
Class<?> itemClass = value.getClass().getComponentType(); if (CtExpression.class.isAssignableFrom(itemClass)) { CtNewArray<Object> arr = factory.Core().createNewArray().setType(factory.Type().objectType()); for (CtExpression expr : (CtExpression[]) value) { arr.addElement(expr); CtNewArray<?> arr = factory.Core().createNewArray().setType(factory.Type().createArrayReference(itemClass.getName())); for (Object v : (Object[]) value) { if (v == null || v instanceof String || v instanceof Number || v instanceof Boolean || v instanceof Character) { arr.addElement(factory.Code().createLiteral(v)); } else { throw new SpoonException("Parameter value item class: " + v.getClass().getName() + " cannot be converted to class is: " + valueClass.getName());