public <T> void visitCtConstructor(final spoon.reflect.declaration.CtConstructor<T> c) { spoon.reflect.declaration.CtConstructor<T> aCtConstructor = c.getFactory().Core().createConstructor(); this.builder.copy(c, aCtConstructor); aCtConstructor.setAnnotations(this.cloneHelper.clone(c.getAnnotations())); aCtConstructor.setParameters(this.cloneHelper.clone(c.getParameters())); aCtConstructor.setThrownTypes(this.cloneHelper.clone(c.getThrownTypes())); aCtConstructor.setFormalCtTypeParameters(this.cloneHelper.clone(c.getFormalCtTypeParameters())); aCtConstructor.setBody(this.cloneHelper.clone(c.getBody())); aCtConstructor.setComments(this.cloneHelper.clone(c.getComments())); this.cloneHelper.tailor(c, aCtConstructor); this.other = aCtConstructor; }
@Override public <T> void visitCtConstructor(CtConstructor<T> c) { if (c.getDeclaringType() != null) { write(c.getDeclaringType().getQualifiedName()); } write("("); for (CtParameter<?> p : c.getParameters()) { scan(p.getType()); write(","); } if (!c.getParameters().isEmpty()) { clearLast(); } write(")"); }
@Override public boolean isFinal() { CtExecutable<T> e = getDeclaration(); if (e != null) { if (e instanceof CtMethod) { return ((CtMethod<T>) e).hasModifier(ModifierKind.FINAL); } else if (e instanceof CtConstructor) { return ((CtConstructor<T>) e).hasModifier(ModifierKind.FINAL); } return false; } Method m = getActualMethod(); return m != null && Modifier.isFinal(m.getModifiers()); }
public <T> void visitCtConstructor(final spoon.reflect.declaration.CtConstructor<T> c) { spoon.reflect.declaration.CtConstructor other = ((spoon.reflect.declaration.CtConstructor) (this.stack.peek())); enter(c); biScan(spoon.reflect.path.CtRole.ANNOTATION, c.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.PARAMETER, c.getParameters(), other.getParameters()); biScan(spoon.reflect.path.CtRole.THROWN, c.getThrownTypes(), other.getThrownTypes()); biScan(spoon.reflect.path.CtRole.TYPE_PARAMETER, c.getFormalCtTypeParameters(), other.getFormalCtTypeParameters()); biScan(spoon.reflect.path.CtRole.BODY, c.getBody(), other.getBody()); biScan(spoon.reflect.path.CtRole.COMMENT, c.getComments(), other.getComments()); exit(c); }
/** * Creates a constructor into a target class by copying it from a source * method. * * @param target * the target class * @param source * the method to be copied * @return the new constructor */ @SuppressWarnings("unchecked") public <T> CtConstructor<T> create(CtClass<T> target, CtMethod<?> source) { CtMethod<T> method = (CtMethod<T>) source.clone(); CtConstructor<T> newConstructor = factory.Core().createConstructor(); newConstructor.setAnnotations(method.getAnnotations()); newConstructor.setBody(method.getBody()); newConstructor.setDocComment(method.getDocComment()); newConstructor.setFormalCtTypeParameters(method.getFormalCtTypeParameters()); newConstructor.setModifiers(method.getModifiers()); newConstructor.setParameters(method.getParameters()); target.addConstructor(newConstructor); return newConstructor; }
public <T> void visitCtConstructor(CtConstructor<T> c) { visitCtNamedElement(c); writeModifiers(c); writeFormalTypeParameters(c.getFormalTypeParameters()); write(c.getDeclaringType().getSimpleName()); write("("); if (c.getParameters().size() > 0) { for (CtParameter<?> p : c.getParameters()) { visitCtParameter(p); write(" ,"); } removeLastChar(); } write(") "); if ((c.getThrownTypes() != null) && (c.getThrownTypes().size() > 0)) { write("throws "); for (CtTypeReference<?> ref : c.getThrownTypes()) { scan(ref); write(" , "); } removeLastChar(); write(" "); } scan(c.getBody()); }
public <T> void visitCtConstructor(CtConstructor<T> c) { enter(c); scan(c.getAnnotations()); scan(c.getParameters()); scanReferences(c.getThrownTypes()); scanReferences(c.getFormalTypeParameters()); scan(c.getBody()); exit(c); }
/** * Creates a constructor into a target class by copying it from a source * method. * * @param target * the target class * @param source * the method to be copied * @return the new constructor */ @SuppressWarnings("unchecked") public <T> CtConstructor<T> create(CtClass<T> target, CtMethod<?> source) { CtMethod<T> method = factory.Core().clone((CtMethod<T>) source); CtConstructor<T> newConstructor = factory.Core().createConstructor(); newConstructor.setAnnotations(method.getAnnotations()); newConstructor.setBody(method.getBody()); newConstructor.setDocComment(method.getDocComment()); newConstructor.setFormalTypeParameters(method.getFormalTypeParameters()); newConstructor.setModifiers(method.getModifiers()); newConstructor.setParameters(method.getParameters()); target.addConstructor(newConstructor); return newConstructor; }
@Override public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope scope) { CtConstructor<Object> c = factory.Core().createConstructor(); // if the source start of the class is equals to the source start of the constructor // it means that the constructor is implicit. c.setImplicit(scope.referenceContext.sourceStart() == constructorDeclaration.sourceStart()); if (constructorDeclaration.binding != null) { c.setExtendedModifiers(getModifiers(constructorDeclaration.binding.modifiers, true, true)); } // avoid to add explicit modifier to implicit constructor if (!c.isImplicit()) { for (CtExtendedModifier extendedModifier : getModifiers(constructorDeclaration.modifiers, false, true)) { c.addModifier(extendedModifier.getKind()); // avoid to keep implicit AND explicit modifier of the same kind. } } context.enter(c, constructorDeclaration); // Create block context.enter(factory.Core().createBlock(), constructorDeclaration); context.exit(constructorDeclaration); return true; }
/** * Generates a constructor from a template constructor by substituting all * the template parameters by their values. * * @param targetClass * the target class where to insert the generated constructor * @param template * the template instance that holds the source template * constructor and that defines the parameter values * @param sourceConstructor * the source template constructor * @return the generated constructor */ @SuppressWarnings("unchecked") public static <T> CtConstructor<T> insertConstructor(CtClass<T> targetClass, Template<?> template, CtConstructor<?> sourceConstructor) { CtConstructor<T> newConstrutor = substitute(targetClass, template, (CtConstructor<T>) sourceConstructor); // remove the implicit constructor if clashing if (newConstrutor.getParameters().isEmpty()) { CtConstructor<?> c = targetClass.getConstructor(); if (c != null && c.isImplicit()) { targetClass.removeConstructor((CtConstructor<T>) c); } } targetClass.addConstructor(newConstrutor); return newConstrutor; }
@Override public boolean matches(CtConstructor<?> element) { return element.hasModifier(ModifierKind.PUBLIC) && element.getParameters() .stream() .map(CtParameter::getType) .filter(reference -> ! reference.equals(type)) .allMatch(ValueCreatorHelper::canGenerateAValueForType); } }).isEmpty()) ||
CtConstructor ctr = factory.Constructor().create(declaringClass, EnumSet.of(PUBLIC), emptyList(), emptySet()); ctr.setBody(factory.Core().createBlock()); } else if (declaringClass.getConstructors().size() == 1) { declaringClass.getConstructors().iterator().next().setImplicit(false); ctr.getBody().addStatement(assignment); }); field.setDefaultExpression(null);
@Override public boolean matches(CtConstructor<?> element) { return element.getParameters().stream() .map(CtParameter::getType) .allMatch(ValueCreatorHelper::canGenerateAValueForType); } });
if (c.isImplicit()) { continue; if (c.getAnnotation(Local.class) != null) { continue;
@Override public <T> void visitCtConstructor(CtConstructor<T> constructor) { elementPrinterHelper.writeComment(constructor); elementPrinterHelper.visitCtNamedElement(constructor, sourceCompilationUnit); elementPrinterHelper.writeModifiers(constructor); elementPrinterHelper.writeFormalTypeParameters(constructor); if (!constructor.getFormalCtTypeParameters().isEmpty()) { printer.writeSpace(); } if (constructor.getDeclaringType() != null) { if (constructor.getDeclaringType().isLocalType()) { printer.writeIdentifier(constructor.getDeclaringType().getSimpleName().replaceAll("^[0-9]*", "")); } else { printer.writeIdentifier(constructor.getDeclaringType().getSimpleName()); } } elementPrinterHelper.writeExecutableParameters(constructor); elementPrinterHelper.writeThrowsClause(constructor); printer.writeSpace(); scan(constructor.getBody()); }
private static <T> void processConstructor(CtConstructor<T> c, CtClass<T> toMerge) { CtStatement firstStmt = c.getBody().getStatements().get(0); if (firstStmt instanceof CtInvocation) { CtInvocation<?> superConstructorCall = (CtInvocation) firstStmt; CtConstructor superConstructor = (CtConstructor) superConstructorCall .getExecutable().getDeclaration(); if (superConstructor.getDeclaringType() == toMerge) { CtBlock superConstructorBody = c.getFactory().Core().clone(superConstructor.getBody()); superConstructorBody.accept(new CtScanner() { @Override c.getBody().removeStatement(firstStmt); List<CtStatement> superConstructorBodyStatements = superConstructorBody.getStatements(); for (int i = superConstructorBodyStatements.size() - 1; i >= 0; i--) { c.getBody().insertBegin(superConstructorBodyStatements.get(i));
private <T> CtExecutableReference<T> createReferenceInternal(CtExecutable<T> e) { CtTypeReference<?>[] refs = new CtTypeReference[e.getParameters().size()]; int i = 0; for (CtParameter<?> param : e.getParameters()) { refs[i++] = getMethodParameterType(param.getType()); } String executableName = e.getSimpleName(); if (e instanceof CtMethod) { boolean isStatic = ((CtMethod) e).hasModifier(ModifierKind.STATIC); return createReference(((CtMethod<T>) e).getDeclaringType().getReference(), isStatic, ((CtMethod<T>) e).getType().clone(), executableName, refs); } else if (e instanceof CtLambda) { CtMethod<T> lambdaMethod = ((CtLambda) e).getOverriddenMethod(); return createReference(e.getParent(CtType.class).getReference(), lambdaMethod == null ? null : lambdaMethod.getType().clone(), executableName, refs); } else if (e instanceof CtAnonymousExecutable) { return createReference(((CtAnonymousExecutable) e).getDeclaringType().getReference(), e.getType().clone(), executableName); } // constructor return createReference(((CtConstructor<T>) e).getDeclaringType().getReference(), ((CtConstructor<T>) e).getType().clone(), CtExecutableReference.CONSTRUCTOR_NAME, refs); }
/** * Creates a constructor. * * @param modifiers * the modifiers * @param parameters * the parameters * @param thrownTypes * the thrown types * @param body * the body */ public <T> CtConstructor<T> create(CtClass<T> target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock<T> body) { CtConstructor<T> constructor = create(target, modifiers, parameters, thrownTypes); constructor.setBody(body); return constructor; }
ctClass.getConstructors() .stream() .filter(c -> !c.isImplicit()) .forEach((CtConstructor c) -> add(mergedClass, c, mergedClass::addConstructor)); if (ctClass.getSuperclass() != null)