public <T> void visitCtLocalVariable(spoon.reflect.code.CtLocalVariable<T> e) { ((spoon.reflect.code.CtLocalVariable<T>) (other)).setSimpleName(e.getSimpleName()); ((spoon.reflect.code.CtLocalVariable<T>) (other)).setModifiers(e.getModifiers()); ((spoon.reflect.code.CtLocalVariable<T>) (other)).setInferred(e.isInferred()); super.visitCtLocalVariable(e); }
public <T> void visitCtLocalVariable(final spoon.reflect.code.CtLocalVariable<T> localVariable) { spoon.reflect.code.CtLocalVariable<T> aCtLocalVariable = localVariable.getFactory().Core().createLocalVariable(); this.builder.copy(localVariable, aCtLocalVariable); aCtLocalVariable.setAnnotations(this.cloneHelper.clone(localVariable.getAnnotations())); aCtLocalVariable.setType(this.cloneHelper.clone(localVariable.getType())); aCtLocalVariable.setDefaultExpression(this.cloneHelper.clone(localVariable.getDefaultExpression())); aCtLocalVariable.setComments(this.cloneHelper.clone(localVariable.getComments())); this.cloneHelper.tailor(localVariable, aCtLocalVariable); this.other = aCtLocalVariable; }
@Override public <T extends CtTryWithResource> T addResource(CtLocalVariable<?> resource) { if (resource == null) { return (T) this; } if (resources == CtElementImpl.<CtLocalVariable<?>>emptyList()) { resources = new ArrayList<>(RESOURCES_CONTAINER_DEFAULT_CAPACITY); } resource.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, TRY_RESOURCE, this.resources, resource); resources.add(resource); return (T) this; }
@Override public <T> void visitCtLocalVariable(final CtLocalVariable<T> localVariable) { CtLocalVariable<T> r = localVariable.clone(); r.setDefaultExpression(evaluate(localVariable.getDefaultExpression())); setResult(r); }
public <T> void visitCtLocalVariable(final spoon.reflect.code.CtLocalVariable<T> localVariable) { spoon.reflect.code.CtLocalVariable other = ((spoon.reflect.code.CtLocalVariable) (this.stack.peek())); enter(localVariable); biScan(spoon.reflect.path.CtRole.ANNOTATION, localVariable.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE, localVariable.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.DEFAULT_EXPRESSION, localVariable.getDefaultExpression(), other.getDefaultExpression()); biScan(spoon.reflect.path.CtRole.COMMENT, localVariable.getComments(), other.getComments()); exit(localVariable); }
@Override public <T> void visitCtLocalVariable(CtLocalVariable<T> localVariable) { enterCtStatement(localVariable); if (env.isPreserveLineNumbers()) { getPrinterHelper().adjustStartPosition(localVariable); } if (!context.isNextForVariable()) { elementPrinterHelper.writeModifiers(localVariable); if (localVariable.isInferred() && this.env.getComplianceLevel() >= 10) { getPrinterTokenWriter().writeKeyword("var"); } else { scan(localVariable.getType()); } printer.writeSpace(); } printer.writeIdentifier(localVariable.getSimpleName()); if (localVariable.getDefaultExpression() != null) { printer.writeSpace().writeOperator("=").writeSpace(); scan(localVariable.getDefaultExpression()); } exitCtStatement(localVariable); }
LOCAL_VARIABLE_READ_FILTER(CtLocalVariable localVariable) { super(CtVariableRead.class); this.localVariableReference = localVariable.getReference(); }
@SuppressWarnings("unchecked") private static void addLogStmt(CtStatement stmt, String id) { if (stmt instanceof CtLocalVariable && ((CtLocalVariable) stmt).getDefaultExpression() == null) { return; } else if (stmt instanceof CtLocalVariable) { CtLocalVariable localVar = (CtLocalVariable) stmt; final CtVariableAccess variableRead = stmt.getFactory().createVariableRead(localVar.getReference(), false);// TODO checks static invocationToObjectLog.addArgument(variableRead); invocationToObjectLog.addArgument(stmt.getFactory().createLiteral(localVar.getSimpleName())); insertAfter = stmt; } else if (stmt instanceof CtAssignment) { throw new RuntimeException(e); invocationToObjectLog.addArgument(stmt.getFactory().createVariableRead(localVariable.getReference(), false)); invocationToObjectLog.addArgument(stmt.getFactory().createLiteral("o_" + id)); insertAfter = localVariable;
if (simpleName.equals(var.getSimpleName())) { return var;
public <T> DefaultJavaPrettyPrinter writeLocalVariable(CtLocalVariable<T> localVariable) { if (env.isPreserveLineNumbers()) { adjustPosition(localVariable); } if (!context.noTypeDecl) { writeModifiers(localVariable); scan(localVariable.getType()); write(" "); } write(localVariable.getSimpleName()); if (localVariable.getDefaultExpression() != null) { write(" = "); scan(localVariable.getDefaultExpression()); } return this; }
/** * Creates a local variable reference that points to an existing local * variable (strong referencing). */ public <T> CtLocalVariableReference<T> createLocalVariableReference(CtLocalVariable<T> localVariable) { CtLocalVariableReference<T> ref = factory.Core().createLocalVariableReference(); ref.setType(localVariable.getType() == null ? null : localVariable.getType().clone()); ref.setSimpleName(localVariable.getSimpleName()); ref.setParent(localVariable); return ref; }
/** * Creates a local variable declaration. * * @param <T> * the local variable type * @param type * the reference to the type * @param name * the name of the variable * @param defaultExpression * the assigned default expression * @return a new local variable declaration */ public <T> CtLocalVariable<T> createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression) { return factory.Core().<T>createLocalVariable().<CtLocalVariable<T>>setSimpleName(name).<CtLocalVariable<T>>setType(type).setDefaultExpression(defaultExpression); }
@Override public boolean matches(CtLocalVariable element) { return !element.getSimpleName().contains("DSPOT") && element.getParent() instanceof CtBlock && ValueCreatorHelper.canGenerateAValueForType(element.getType()); } }).stream()
public <T> void visitCtLocalVariable(CtLocalVariable<T> localVariable) { enter(localVariable); scan(localVariable.getAnnotations()); scan(localVariable.getType()); scan(localVariable.getDefaultExpression()); exit(localVariable); }
public <T> void visitCtLocalVariable(final CtLocalVariable<T> localVariable) { // if (localVariable.getParent(CtBlock.class)!=null) { // // List<CtVariableAccess> res = Query.getElements(localVariable // .getParent(CtBlock.class), new TypeFilter<CtVariableAccess>( // CtVariableAccess.class) { // @Override // public boolean matches(CtVariableAccess element) { // boolean ret = super.matches(element) // && element.getVariable().getSimpleName().equals( // localVariable.getSimpleName()); // return ret; // } // }); // if (res.size() != 0) CtLocalVariable<T> r = localVariable.getFactory().Core().clone(localVariable); r.setDefaultExpression(evaluate(r, localVariable.getDefaultExpression())); setResult(r); }
private void inlineLocalVariable(CtMethod<?> amplifiedTestToBeMinimized) { final List<CtLocalVariable> localVariables = amplifiedTestToBeMinimized.getElements(new TypeFilter<>(CtLocalVariable.class)); final List<CtVariableRead> variableReads = localVariables.stream().map(LOCAL_VARIABLE_READ_FILTER::new) .flatMap(filter -> amplifiedTestToBeMinimized.getElements(filter).stream()) .collect(Collectors.toList()); // we can inline all local variables that are used one time and that have been generated by DSpot final List<CtLocalVariable> oneTimeUsedLocalVariable = localVariables.stream() .filter(localVariable -> variableReads.stream() .map(CtVariableRead::getVariable) .filter(variableRead -> variableRead.equals(localVariable.getReference())) .count() == 1 ).collect(Collectors.toList()); oneTimeUsedLocalVariable.stream().map(localVariable -> { DSpotUtils.printProgress(oneTimeUsedLocalVariable.indexOf(localVariable), oneTimeUsedLocalVariable.size()); variableReads.stream() .filter(variableRead -> variableRead.getVariable().equals(localVariable.getReference()) ).findFirst() .get() .replace(localVariable.getAssignment().clone()); return localVariable; }).forEach(amplifiedTestToBeMinimized.getBody()::removeStatement); //TODO we can inline all local variables that are used only in assertion }
@Override public boolean visit(LocalDeclaration localDeclaration, BlockScope scope) { CtLocalVariable<Object> v = factory.Core().createLocalVariable(); v.setSimpleName(new String(localDeclaration.name)); v.setType(references.getTypeReference(localDeclaration.type.resolvedType)); v.setModifiers(getModifiers(localDeclaration.modifiers)); context.enter(v, localDeclaration); if (localDeclaration.initialization != null) { context.arguments.push(v); localDeclaration.initialization.traverse(this, scope); context.arguments.pop(); } if (localDeclaration.annotations != null) { for (Annotation a : localDeclaration.annotations) { // TODO Sorry for that but there is a bug in JDT : https://bugs.eclipse.org/bugs/show_bug.cgi?id=459528 if (isContainsInTypeAnnotation(localDeclaration.type.resolvedType, a)) { a.traverse(this, scope); } } } return false; }
@SuppressWarnings("unchecked") @Override public Stream<CtMethod<?>> amplify(CtMethod<?> testMethod, int iteration) { return testMethod.getElements(new TypeFilter<CtLocalVariable>(CtLocalVariable.class) { @Override public boolean matches(CtLocalVariable element) { return !element.getSimpleName().contains("DSPOT") && element.getParent() instanceof CtBlock && ValueCreatorHelper.canGenerateAValueForType(element.getType()); } }).stream() .map(ctLocalVariable -> { final CtMethod clone = CloneHelper.cloneTestMethodForAmp(testMethod, "_replacement"); final CtLocalVariable localVariable = clone.getElements(new TypeFilter<>(CtLocalVariable.class)) .stream() .filter(ctLocalVariable1 -> ctLocalVariable1.equals(ctLocalVariable)) .findFirst() .get(); CtExpression<?> ctExpression = ValueCreator.generateRandomValue(ctLocalVariable.getType(), 0, localVariable.getAssignment()); localVariable.setAssignment(ctExpression); return clone; }); }
@Override public boolean visit(LocalDeclaration localDeclaration, BlockScope scope) { CtLocalVariable<Object> v = factory.Core().createLocalVariable(); boolean isVar = localDeclaration.type.isTypeNameVar(scope); if (isVar) { v.setInferred(true); } v.setSimpleName(CharOperation.charToString(localDeclaration.name)); if (localDeclaration.binding != null) { v.setExtendedModifiers(getModifiers(localDeclaration.binding.modifiers, true, false)); } for (CtExtendedModifier extendedModifier : getModifiers(localDeclaration.modifiers, false, false)) { v.addModifier(extendedModifier.getKind()); // avoid to keep implicit AND explicit modifier of the same kind. } context.enter(v, localDeclaration); return true; }