private static <T> void checkTemplateContracts(CtClass<T> c) { for (CtField f : c.getFields()) { Parameter templateParamAnnotation = f.getAnnotation(Parameter.class); if (templateParamAnnotation != null && !templateParamAnnotation.value().isEmpty()) {
@Override public <T> void visitCtClass(CtClass<T> ctClass) { scanElementsIn(ctClass.getFields()); }
private void removeExtraFields() { forEachBaseClass(baseC -> { List<CtField<?>> fieldsToRemove = baseC.getFields().stream() .filter(f -> f.getAnnotation(StageRef.class) != null) .filter(f -> { CompilationNode referencedNode = cxt.getCompilationNode(cxt.getReferencedClass(f)); return referencedNode.parentAccessField != f; }) .collect(toList()); fieldsToRemove.forEach(baseC::removeField); }); }
private static String getRightField(Object value, Factory factory) { return Arrays.stream(supportedClassesForFieldRead).map(aClass -> factory.Class().get(aClass) .getFields() .stream() .filter(CtModifiable::isStatic) .filter(CtModifiable::isFinal) .filter(ctField -> { try { return value.equals(aClass.getField(ctField.getSimpleName()).get(null)); } catch (Exception ignored) { return false; } }) .findFirst() .map(CtNamedElement::getSimpleName) .orElse("") ).filter(s -> !s.isEmpty()) .findFirst() .orElse(value.toString()); }
/** * This method checks if the given value is a field. To do this, it uses the classes in <code>supportedClassesForFieldRead</code> * and reflection * * @param value value to checkEnum * @param factory factory with spoon model * @return true if the value is a field read, false otherwise */ private static boolean isAFieldRead(Object value, Factory factory) { return (!Pattern.compile("\\d*").matcher(value.toString()).matches()) && Arrays.stream(supportedClassesForFieldRead).anyMatch(aClass -> factory.Class().get(aClass) .getFields() .stream() .filter(CtModifiable::isStatic) .filter(CtModifiable::isFinal) .anyMatch(ctField -> { try { return value.equals(aClass.getField(ctField.getSimpleName()).get(null)); } catch (Exception ignored) { return false; } })); }
public static CtField<?> getParameterField(CtClass<? extends Template<?>> templateClass, String parameterName) { for (CtField<?> f : templateClass.getFields()) { 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; }
public void computeAccessPaths() { cxt.allClasses().forEach(ctC -> stagedClassExtensionChain(ctC).forEach(baseClass -> baseClass.getFields().forEach((CtField<?> field) -> { if (field.getAnnotation(StageRef.class) != null) { CtTypeReference<?> fieldClass = field.getType(); List<CtClass<?>> candidates = cxt.allClasses() .filter(c -> fieldClass.isAssignableFrom(c.getReference())) .collect(toList()); if (candidates.size() != 1) { throw sgce("Can assign " + candidates.stream().map(CtClass::getSimpleName).collect(toList()) + " to field " + field + " in " + baseClass.getSimpleName()); } cxt.bindReferenced(field, candidates.get(0)); CompilationNode referencingNode = cxt.getCompilationNode(ctC); CompilationNode referencedNode = cxt.getCompilationNode(candidates.get(0)); if (referencedNode.parent == referencingNode && referencedNode.parentAccessField == null) { referencedNode.parentAccessField = field; } } }))); root.computeRootAccessPath(); }
.forEach(ae -> add(mergedClass, ae, mergedClass::addAnonymousExecutable)); ctClass.getNestedTypes().forEach(t -> add(mergedClass, t, mergedClass::addNestedType)); ctClass.getFields().forEach(f -> add(mergedClass, f, mergedClass::addField)); ctClass.getConstructors() .stream()
private static <T> void mergeStagedChainInner(List<CtClass<T>> chain) { if (chain.size() == 1) return; reverse(chain); CtClass<T> toMerge = chain.get(0); for (int i = 1; i < chain.size(); i++) { CtClass<T> mergeInto = chain.get(i); replaceInstantiatedTypeParams(toMerge, mergeInto); toMerge.getAnnotations().stream() .forEach((CtAnnotation<? extends Annotation> a) -> { if (mergeInto.getAnnotation(a.getActualAnnotation().getClass()) == null) add(mergeInto, a, mergeInto::addAnnotation); }); toMerge.getSuperInterfaces().forEach(mergeInto::addSuperInterface); toMerge.getAnonymousExecutables() .forEach(b -> add(mergeInto, b, mergeInto::addAnonymousExecutable)); toMerge.getNestedTypes().forEach(nt -> add(mergeInto, nt, mergeInto::addNestedType)); toMerge.getFields().forEach(f -> add(mergeInto, f, mergeInto::addField)); for (CtMethod<?> methodToMerge : toMerge.getMethods()) { processMethod(mergeInto, toMerge, methodToMerge); } final CtClass<T> finalToMerge = toMerge; mergeInto.getConstructors().forEach(c -> processConstructor(c, finalToMerge)); mergeInto.setSuperclass(toMerge.getSuperclass()); toMerge = mergeInto; } }
private void createNodes() { cxt.allClasses().forEach(ctClass -> { for (CtClass<?> baseType : stagedClassExtensionChain(ctClass)) { baseType.getFields().stream() .filter(field -> !field.hasModifier(STATIC) && !field.hasModifier(FINAL) && field.getAnnotation(StageRef.class) == null && cxt.getStageModel(field) == null) .forEach(field -> new StageModel(cxt, field, ctClass)); } }); cxt.allClasses().forEach(ctClass -> { for (CtClass<?> baseType : stagedClassExtensionChain(ctClass)) { baseType.getMethods().stream() .filter(m -> !m.hasModifier(STATIC) && !m.hasModifier(ABSTRACT)) .filter(m -> cxt.getStageModelByClose(m) == null) .filter(m -> cxt.getStageModelByInitStage(m) == null) .filter(m -> cxt.getStageModelByStageInit(m) == null) .filter(m -> cxt.getStageModelByStageMethod(m) == null) .forEach(m -> { if (cxt.getMethodNode(m) == null) new MethodNode(cxt, m, ctClass); }); } }); }
for (CtField<?> field : new TreeSet<CtField<?>>(ctClass.getFields())) { if ((field.getAnnotation(Local.class) != null) || Parameters.isParameterSource(field.getReference())) { ctClass.removeField(field); if (name.equals(pname)) { Object value = Parameters.getValue(template, pname, null); int i = ctClass.getFields().indexOf(field); if (value instanceof List) { List<?> l = (List<?>) value; CtField<?> f2 = ctClass.getFactory().Core().clone((CtField<?>) f); f2.setParent(ctClass); ctClass.getFields().add(i++, f2);
|| ctclass.getFields().contains(ctFieldReference.getDeclaration()))) {
/** * Inserts all the fields from a given template by substituting all the * template parameters by their values. Members annotated with * {@link spoon.template.Local} or {@link Parameter} are not inserted. * * @param targetType * the target type * @param template * the source template */ public static void insertAllFields(CtType<?> targetType, Template<?> template) { CtClass<?> sourceClass = targetType.getFactory().Class().get(template.getClass()); // insert all the fields for (CtField<?> f : sourceClass.getFields()) { if (f.getAnnotation(Local.class) != null) { continue; } if (Parameters.isParameterSource(f.getReference())) { continue; } insertField(targetType, template, f); } }
for (CtField<?> field : baseType.getFields()) { if (capitalize(field.getSimpleName()).equals(name) || (field.getAnnotation(Stage.class) != null &&
@Override public boolean canBeAppliedToPoint(ModificationPoint point) { if (!(point.getCodeElement() instanceof CtStatement)) return false; // Do not remove local declaration if (point.getCodeElement() instanceof CtLocalVariable) { CtLocalVariable lv = (CtLocalVariable) point.getCodeElement(); boolean shadow = false; CtClass parentC = point.getCodeElement().getParent(CtClass.class); List<CtField> ff = parentC.getFields(); for (CtField<?> f : ff) { if (f.getSimpleName().equals(lv.getSimpleName())) shadow = true; } if (!shadow) return false; } // do not remove the last statement CtMethod parentMethd = point.getCodeElement().getParent(CtMethod.class); if (point.getCodeElement() instanceof CtReturn && parentMethd.getBody().getLastStatement().equals(point.getCodeElement())) { return false; } // Otherwise, accept the element return true; }
Factory spoonFactory) { List<CtField<?>> fields=parentTarget.getFields();
List<CtField<?>> fields = processedClass.getFields(); Map<String, String> attributes = new HashMap<String, String>();
public <T> void visitCtClass(CtClass<T> ctClass) { enter(ctClass); scan(ctClass.getAnnotations()); scan(ctClass.getSuperclass()); scanReferences(ctClass.getSuperInterfaces()); scanReferences(ctClass.getFormalTypeParameters()); scan(ctClass.getAnonymousExecutables()); scan(ctClass.getNestedTypes()); scan(ctClass.getFields()); scan(ctClass.getConstructors()); scan(ctClass.getMethods()); exit(ctClass); }
lst.addAll(ctClass.getFields()); lst.addAll(ctClass.getMethods());
for (CtField<?> f : templateClass.getFields()) { if (f.getAnnotation(Local.class) != null) { continue;