public static CtField<?> getParameterField(CtClass<? extends Template<?>> templateClass, String parameterName) { for (CtTypeMember typeMember : templateClass.getTypeMembers()) { if (!(typeMember instanceof CtField)) { continue; } CtField<?> f = (CtField<?>) typeMember; Parameter p = f.getAnnotation(Parameter.class); if (p == null) { continue; } if (f.getSimpleName().equals(parameterName)) { return f; } if (parameterName.equals(p.value())) { return f; } } return null; }
/** * Inserts the field by substituting all the * template parameters by their values. Field annotated with * {@link spoon.template.Local} or {@link Parameter} is not inserted. * @param targetType * @param template * @param field */ static void insertGeneratedField(CtType<?> targetType, Template<?> template, CtField<?> field) { if (field.getAnnotation(Local.class) != null) { return; } if (Parameters.isParameterSource(field.getReference())) { return; } insertField(targetType, template, field); }
/** * Creates a field reference from an existing field. */ public <T> CtFieldReference<T> createReference(CtField<T> field) { final CtFieldReference<T> reference = createReference(factory.Type().createReference(field.getDeclaringType()), field.getType().clone(), field.getSimpleName()); reference.setFinal(field.hasModifier(ModifierKind.FINAL)); reference.setStatic(field.hasModifier(ModifierKind.STATIC)); return reference; }
@Override public <T> void visitCtField(CtField<T> f) { CtField<T> r = f.clone(); r.setDefaultExpression(evaluate(f.getDefaultExpression())); setResult(r); }
public <T> void visitCtField(final spoon.reflect.declaration.CtField<T> f) { spoon.reflect.declaration.CtField other = ((spoon.reflect.declaration.CtField) (this.stack.peek())); enter(f); biScan(spoon.reflect.path.CtRole.ANNOTATION, f.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE, f.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.DEFAULT_EXPRESSION, f.getDefaultExpression(), other.getDefaultExpression()); biScan(spoon.reflect.path.CtRole.COMMENT, f.getComments(), other.getComments()); exit(f); }
public <T> void visitCtField(final spoon.reflect.declaration.CtField<T> f) { spoon.reflect.declaration.CtField<T> aCtField = f.getFactory().Core().createField(); this.builder.copy(f, aCtField); aCtField.setAnnotations(this.cloneHelper.clone(f.getAnnotations())); aCtField.setType(this.cloneHelper.clone(f.getType())); aCtField.setDefaultExpression(this.cloneHelper.clone(f.getDefaultExpression())); aCtField.setComments(this.cloneHelper.clone(f.getComments())); this.cloneHelper.tailor(f, aCtField); this.other = aCtField; }
private void generateFinalAccessors() { List<CtField<?>> finalFields = root.getMergedClass() .getElements((CtField<?> field) -> field.hasModifier(FINAL)); finalFields.forEach(f -> { CtType<?> declaringType = f.getDeclaringType(); if (declaringType.getMethodsByName(f.getSimpleName()).isEmpty()) { Factory factory = f.getFactory(); CtMethod access = factory.Method().create( declaringType, EnumSet.of(PUBLIC), f.getType(), f.getSimpleName(), emptyList(), emptySet()); access.setParent(declaringType); access.setBody((CtBlock) factory.Core().createBlock()); CtReturn fReturn = factory.Core().createReturn(); fReturn.setReturnedExpression( factory.Code().createVariableRead(f.getReference(), false)); access.getBody().addStatement(fReturn); access.setPosition(new LinedSourcePosition( ((LinedSourcePosition) f.getPosition()).delegate, ((LinedSourcePosition) f.getPosition()).line)); } }); }
private void sortFinals() { List<CtField<?>> finalFields = cxt.allCompilationNodes().flatMap(n -> n.getMergedClass() .getElements((CtField<?> field) -> field.hasModifier(FINAL)).stream()) .collect(toList()); Map<CtField<?>, List<CtField<?>>> dependencies = namedHashedMap(); }); finalFields.forEach(f -> { CtExpression<?> defaultExpression = f.getDefaultExpression(); if (defaultExpression == null) return; CtType<?> fieldClass = f.getType().getDeclaration(); if (fieldClass instanceof CtClass && cxt.getCompilationNode((CtClass<?>) fieldClass) != null) { fieldClass.getFields().forEach(field -> field.getElements(addDependencies)); int order = 0; for (CtField field : sortedList) { CtExpression fieldInit = field.getDefaultExpression(); if (fieldInit != null && !field.hasModifier(STATIC)) { CtType<?> declaringType = field.getDeclaringType(); if (declaringType instanceof CtClass) { CtClass<?> declaringClass = (CtClass) declaringType; field.getReference(), false, root.f.Core().clone(fieldInit)); ctr.getBody().addStatement(assignment); }); field.setDefaultExpression(null);
@Override public CtField<?> getField(String name) { for (CtTypeMember typeMember : typeMembers) { if (typeMember instanceof CtField && ((CtField) typeMember).getSimpleName().equals(name)) { return (CtField<?>) typeMember; } } return null; }
if ((field.getAnnotation(Local.class) != null) || Parameters.isParameterSource(field.getReference())) { ctClass.removeField(field); continue; String name = field.getSimpleName(); for (String pname : parameterNames) { if (name.equals(pname)) { for (Object f : l) { CtField<?> f2 = ctClass.getFactory().Core().clone((CtField<?>) f); f2.setParent(ctClass); ctClass.getFields().add(i++, f2);
public <T> void visitCtField(CtField<T> f) { visitCtNamedElement(f); writeModifiers(f); scan(f.getType()); write(" "); write(f.getSimpleName()); if ((!f.isParentInitialized()) || !CtAnnotationType.class.isAssignableFrom(f.getParent().getClass()) || f.getModifiers().contains(ModifierKind.STATIC)) { if (f.getDefaultExpression() != null) { write(" = "); scan(f.getDefaultExpression()); } } else { write("()"); if (f.getDefaultExpression() != null) { write(" default "); scan(f.getDefaultExpression()); } } write(";"); }
@Override public <T> void visitCtField(CtField<T> f) { elementPrinterHelper.writeComment(f, CommentOffset.BEFORE); elementPrinterHelper.visitCtNamedElement(f, sourceCompilationUnit); elementPrinterHelper.writeModifiers(f); scan(f.getType()); printer.writeSpace(); printer.writeIdentifier(f.getSimpleName()); if (f.getDefaultExpression() != null) { printer.writeSpace().writeOperator("=").writeSpace(); scan(f.getDefaultExpression()); } printer.writeSeparator(";"); elementPrinterHelper.writeComment(f, CommentOffset.AFTER); }
private <T> CtMethod<T> fieldAccess(CtField<T> field) { @SuppressWarnings("unchecked") Map<CtField<T>, CtMethod<T>> fields = (Map<CtField<T>, CtMethod<T>>) (Map) this.fields; return fields.compute(field, (f, proxy) -> { if (proxy == null) { proxy = createSimpleMethod(f.getType(), f.getSimpleName()); } else if (proxy.hasModifier(ABSTRACT)) { proxy.setBody(f().Core().createBlock()); proxy.removeModifier(ABSTRACT); } else { return proxy; } addGuardingPrologue(proxy); CtReturn<T> ret = f().Core().createReturn(); ret.setReturnedExpression(f().Code().createVariableRead(f.getReference(), false)); proxy.getBody().addStatement(ret); cxt.bindAccessMethod(proxy, StageModel.this); return proxy; }); }
/** * Creates a field reference from an existing field. */ public <T> CtFieldReference<T> createReference(CtField<T> field) { return createReference(factory.Type().createReference(field.getDeclaringType()), field.getType(), field.getSimpleName()); }
@Override public void accept(CtField<?> field) { fields.add(field.getReference()); } });
/** * Creates a field. * * @param name * Name of the field. * @param type * Type of the field. * @param exp * Default expression of the field. * @param visibilities * All visibilities of the field. * @param <T> * Generic type for the type of the field. * @return a field */ public <T> CtField<T> createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities) { return factory.Core().createField().<CtField<T>>setModifiers(modifiers(visibilities)).<CtField<T>>setSimpleName(name).<CtField<T>>setType(type) .setDefaultExpression(this.<T>createCodeSnippetExpression(exp)); }
if (capitalize(field.getSimpleName()).equals(name) || (field.getAnnotation(Stage.class) != null && getStageName(field).equals(name))) { if (fieldsFound) fieldsFoundInThisClass = true; fields.put(field, null); if (field.getDefaultExpression() != null) { if (initField != null || manyFieldsInitialized) { if (stageInitMethod == null || stageInitMethod.hasModifier(ABSTRACT)) { if (method.getSimpleName().equals(field.getSimpleName()) && method.hasModifier(ABSTRACT)) { fields.put(field, method); if (m.getSimpleName().equals(field.getSimpleName())) fieldsToGenerateAccessMethods.add(field); });
@Override public <T> void visitCtFieldReference(CtFieldReference<T> reference) { assertNotNull(reference); if (isLanguageField(reference) || isDeclaredInSuperClass(reference)) { super.visitCtFieldReference(reference); return; } final CtField<T> fieldDeclaration = reference.getFieldDeclaration(); assertNotNull(fieldDeclaration); assertEquals(reference.getSimpleName(), fieldDeclaration.getSimpleName()); assertEquals(reference.getType().getQualifiedName(), fieldDeclaration.getType().getQualifiedName()); if (reference.getDeclaration() == null) { assertTrue("fieldDecl must be shadow", fieldDeclaration.isShadow()); } super.visitCtFieldReference(reference); }
private static String getParameterName(CtFieldReference<?> f) { String name = f.getSimpleName(); Parameter p = f.getDeclaration().getAnnotation(Parameter.class); if ((p != null) && !p.value().isEmpty()) { name = p.value(); } return name; }
protected String nameForField(CtField<?> field, String fieldOwner) { String fieldName = field.getSimpleName(); CtType<?> declaringType = field.getDeclaringType(); String declaringClass = declaringType.getQualifiedName().replace('$', '.'); if (hasStaticModifier(field)) { fieldName = declaringClass + "." + fieldName; } else if (declaringType.getSimpleName().isEmpty()) { /* only when 'variable' is a field of an Anonymous Class */ fieldName = "this." + fieldName; } else if (fieldOwner == null) { fieldName = declaringClass + ".this." + fieldName; } else { fieldName = fieldOwner + "." + fieldName; } return fieldName; }