private static VariableTree createVariable(WorkingCopy wc, String name, Tree type) { TreeMaker make = wc.getTreeMaker(); return make.Variable(createModifiers(wc), name, type, null); }
public static VariableTree createPropertyField(WorkingCopy wc, String name, Class type) { TreeMaker make = wc.getTreeMaker(); Tree typeTree = createType(wc, type.getCanonicalName()); ExpressionTree initializer = make.NewClass(null, Collections.<ExpressionTree>emptyList(), (ExpressionTree)typeTree, Collections.<ExpressionTree>emptyList(), null); return make.Variable( createModifiers(wc, Modifier.PRIVATE), name, typeTree, initializer); }
/** * Creates a new variable (a <code>VariableTree</code> with no * modifiers nor initializer). * * @param variableType the variable type; cannot be null. * @param variableName the variable name; cannot be null. * @return the new variable; never null. */ public VariableTree createVariable(String variableName, Tree variableType) { Parameters.javaIdentifier("variableName", variableName); // NOI18N Parameters.notNull("variableType", variableType); // NOI18N return getTreeMaker().Variable( createEmptyModifiers(), variableName, variableType, null); }
ModifiersTree modifiersTree = maker.Modifiers(EnumSet .of(Modifier.PRIVATE)); VariableTree newParam = maker.Variable( maker.Modifiers(Collections.<Modifier>emptySet()), "resources", wildSet, null);
/** * Creates a setter method for a field. * * @param clazz the class to create the setter within * @param field field to create setter for * @return the setter method * @since 0.20 */ public MethodTree createSetter(TypeElement clazz, VariableElement field) { assert clazz != null && field != null; TreeMaker make = copy.getTreeMaker(); CodeStyle cs = DiffContext.getCodeStyle(copy); Set<Modifier> mods = EnumSet.of(Modifier.PUBLIC); boolean isStatic = field.getModifiers().contains(Modifier.STATIC); if (isStatic) { mods.add(Modifier.STATIC); } CharSequence name = field.getSimpleName(); assert name.length() > 0; TypeMirror type = copy.getTypes().asMemberOf((DeclaredType)clazz.asType(), field); String setterName = CodeStyleUtils.computeSetterName(field.getSimpleName(), isStatic, cs); String paramName = addParamPrefixSuffix(removeFieldPrefixSuffix(field, cs), cs); List<VariableTree> params = Collections.singletonList(make.Variable(make.Modifiers(EnumSet.noneOf(Modifier.class)), paramName, make.Type(type), null)); BlockTree body = make.Block(Collections.singletonList(make.ExpressionStatement(make.Assignment(make.MemberSelect(isStatic? make.Identifier(field.getEnclosingElement().getSimpleName()) : make.Identifier("this"), name), make.Identifier(paramName)))), false); //NOI18N return make.Method(make.Modifiers(mods), setterName, make.Type(copy.getTypes().getNoType(TypeKind.VOID)), Collections.<TypeParameterTree>emptyList(), params, Collections.<ExpressionTree>emptyList(), body, null); }
params.add(make.Variable(parameterModifiers, paramName, resolveWildcard(formArgType), null));
} else { String paramName = addParamPrefixSuffix(removeFieldPrefixSuffix(ve, cs), cs); parameters.add(make.Variable(parameterModifiers, paramName, make.Type(type), null)); statements.add(make.ExpressionStatement(make.Assignment(make.MemberSelect(make.Identifier("this"), ve.getSimpleName()), make.Identifier(paramName)))); //NOI18N } else { String paramName = addParamPrefixSuffix(removeParamPrefixSuffix(ve, cs), cs); parameters.add(make.Variable(parameterModifiers, paramName, make.Type(type), null)); arguments.add(make.Identifier(paramName));
/** * Creates a class constructor. * * @param clazz the class to create the constructor for * @param fields fields to be initialized by the constructor * @return the constructor * @since 0.20 */ public MethodTree createConstructor(ClassTree clazz, Iterable<? extends VariableTree> fields) { assert clazz != null && fields != null; TreeMaker make = copy.getTreeMaker(); CodeStyle cs = DiffContext.getCodeStyle(copy); Set<Modifier> mods = EnumSet.of(copy.getTreeUtilities().isEnum(clazz) ? Modifier.PRIVATE : Modifier.PUBLIC); List<VariableTree> parameters = new ArrayList<VariableTree>(); List<StatementTree> statements = new ArrayList<StatementTree>(); ModifiersTree parameterModifiers = make.Modifiers(EnumSet.noneOf(Modifier.class)); for (VariableTree vt : fields) { String paramName = addParamPrefixSuffix(removeFieldPrefixSuffix(vt, cs), cs); parameters.add(make.Variable(parameterModifiers, paramName, vt.getType(), null)); statements.add(make.ExpressionStatement(make.Assignment(make.MemberSelect(make.Identifier("this"), vt.getName()), make.Identifier(paramName)))); //NOI18N } BlockTree body = make.Block(statements, false); return make.Method(make.Modifiers(mods), "<init>", null, Collections.<TypeParameterTree> emptyList(), parameters, Collections.<ExpressionTree>emptyList(), body, null); //NOI18N }
/** * Creates a new field. * * @param scope the scope in which to create the field (will be e.g. used * to parse <code>fieldType</code>). * @param modifiersTree the field modifiers; cannot be null. * @param fieldType the fully-qualified name of the field type; cannot be null. * @param fieldName the field name; cannot be null. * @param expressionTree expression to initialize the field; can be null. * @return the new field; never null. */ public VariableTree createField(TypeElement scope, ModifiersTree modifiersTree, String fieldName, String fieldType, ExpressionTree expressionTree) { Parameters.notNull("modifiersTree", modifiersTree); // NOI18N Parameters.javaIdentifier("fieldName", fieldName); // NOI18N Parameters.notNull("fieldType", fieldType); // NOI18N return getTreeMaker().Variable( modifiersTree, fieldName, createType(fieldType, scope), expressionTree); }
/** * Removes any modifiers from the given <code>VariableTree</code>. This can be e.g. * used to create a variable suitable for use as a method parameter. * * @param variableTree the <code>VariableTree</code> to remove the modifiers from. * @return a <code>VariableTree</code> with the same properties but no modifiers. */ public VariableTree removeModifiers(VariableTree variableTree) { Parameters.notNull("variableTree", variableTree); TreeMaker make = getTreeMaker(); return make.Variable( createEmptyModifiers(), variableTree.getName(), variableTree.getType(), variableTree.getInitializer()); }
Tree changeSupportType = make.Type(changeSupportMirror); NewClassTree changeSupportConstructor = make.NewClass(null, Collections.EMPTY_LIST, make.QualIdent(changeSupportElement), Collections.singletonList(make.Identifier("this")), null); VariableTree changeSupport = make.Variable(modifiers, "changeSupport", changeSupportType, changeSupportConstructor); // NOI18N modifiedClass = make.insertClassMember(clazz, 0, changeSupport); String oldParameterName = "old" + Character.toUpperCase(parameterName.charAt(0)) + parameterName.substring(1); // NOI18N Tree parameterTree = parameter.getType(); VariableTree oldParameter = make.Variable(make.Modifiers(Collections.EMPTY_SET), oldParameterName, parameterTree, persistentVariable); BlockTree newBlock = make.insertBlockStatement(block, 0, oldParameter);
VariableTree var = make.Variable(make.Modifiers(Collections.<Modifier>singleton(Modifier.PRIVATE), Collections.<AnnotationTree>emptyList()), "context", make.Identifier("javax.ejb.SessionContext"), null); modifiedClass = make.insertClassMember(modifiedClass, 0, var); ); List<VariableTree> params = new ArrayList<VariableTree>(); params.add(make.Variable( make.Modifiers( Collections.<Modifier>emptySet(),
/** * Creates a setter method for a field. * * @param clazz the class to create the setter within * @param field field to create setter for * @return the setter method * @since 0.20 */ public MethodTree createSetter(ClassTree clazz, VariableTree field) { assert clazz != null && field != null; TreeMaker make = copy.getTreeMaker(); Set<Modifier> mods = EnumSet.of(Modifier.PUBLIC); boolean isStatic = field.getModifiers().getFlags().contains(Modifier.STATIC); if (isStatic) mods.add(Modifier.STATIC); CharSequence name = field.getName(); assert name.length() > 0; CodeStyle cs = DiffContext.getCodeStyle(copy); String propName = removeFieldPrefixSuffix(field, cs); String setterName = CodeStyleUtils.computeSetterName(field.getName(), isStatic, cs); String paramName = addParamPrefixSuffix(propName, cs); List<VariableTree> params = Collections.singletonList(make.Variable(make.Modifiers(EnumSet.noneOf(Modifier.class)), paramName, field.getType(), null)); BlockTree body = make.Block(Collections.singletonList(make.ExpressionStatement(make.Assignment(make.MemberSelect(isStatic? make.Identifier(clazz.getSimpleName()) : make.Identifier("this"), name), make.Identifier(paramName)))), false); //NOI18N return make.Method(make.Modifiers(mods), setterName, make.Type(copy.getTypes().getNoType(TypeKind.VOID)), Collections.<TypeParameterTree>emptyList(), params, Collections.<ExpressionTree>emptyList(), body, null); }
VariableTree par = make.Variable(parMods, "listener", make.QualIdent(changeListenerElement), null); // NOI18N TypeElement changeSupportElement = wc.getElements().getTypeElement("java.beans.PropertyChangeSupport"); // NOI18N VariableTree changeSupport = make.Variable(parMods, "changeSupport", make.QualIdent(changeSupportElement), null); // NOI18N MemberSelectTree addCall = make.MemberSelect(make.Identifier(changeSupport.getName()), "addPropertyChangeListener"); // NOI18N MethodInvocationTree addInvocation = make.MethodInvocation(Collections.EMPTY_LIST, addCall, Collections.singletonList(make.Identifier(par.getName())));
TypeElement detailElement = wc.getElements().getTypeElement(detailInfo[1]); ParameterizedTypeTree collectionTree = make.ParameterizedType(make.QualIdent(collectionElement), Collections.singletonList(make.QualIdent(detailElement))); VariableTree field = make.Variable(modifiers, masterFieldName, collectionTree, null); ClassTree modifiedClass = make.insertClassMember(clazz, fieldIndex, field); wc.rewrite(clazz, modifiedClass); VariableTree par = make.Variable(parMods, masterFieldName, collectionTree, null); AssignmentTree assignExp = make.Assignment(make.Identifier("this." + masterFieldName), make.Identifier(masterFieldName)); MethodTree setMethod = make.Method(
VariableTree par = make.Variable(parMods, "listener", make.QualIdent(changeListenerElement), null); // NOI18N TypeElement changeSupportElement = wc.getElements().getTypeElement("java.beans.PropertyChangeSupport"); // NOI18N VariableTree changeSupport = make.Variable(parMods, "changeSupport", make.QualIdent(changeSupportElement), null); // NOI18N MemberSelectTree removeCall = make.MemberSelect(make.Identifier(changeSupport.getName()), "removePropertyChangeListener"); // NOI18N MethodInvocationTree removeInvocation = make.MethodInvocation(Collections.EMPTY_LIST, removeCall, Collections.singletonList(make.Identifier(par.getName())));
ModifiersTree modifiers = make.Modifiers(Collections.singleton(Modifier.PRIVATE), annotations); TypeElement masterElement = wc.getElements().getTypeElement(masterInfo[1]); VariableTree field = make.Variable(modifiers, detailFieldName, make.QualIdent(masterElement), null); ClassTree modifiedClass = make.insertClassMember(clazz, fieldIndex, field); wc.rewrite(clazz, modifiedClass); VariableTree par = make.Variable(parMods, detailFieldName, make.QualIdent(masterElement), null); AssignmentTree assignExp = make.Assignment(make.Identifier("this." + detailFieldName), make.Identifier(detailFieldName)); MethodTree setMethod = make.Method(
/** * Adds an annotation to a variable. This is equivalent to {@link TreeMaker#addModifiersAnnotation}, * but it creates and returns a new <code>VariableTree, not a new <code>ModifiersTree</code>. * * @param variableTree the variable to add the annotation to; cannot be null. * @param annotationTree the annotation to add; cannot be null. * @return a new variable annotated with the new annotation; never null. */ public VariableTree addAnnotation(VariableTree variableTree, AnnotationTree annotationTree) { Parameters.notNull("variableTree", variableTree); // NOI18N Parameters.notNull("annotationTree", annotationTree); // NOI18N TreeMaker make = getTreeMaker(); return make.Variable( make.addModifiersAnnotation(variableTree.getModifiers(), annotationTree), variableTree.getName(), variableTree.getType(), variableTree.getInitializer()); }
VariableTree t = (VariableTree) node; @SuppressWarnings("unchecked") N clone = (N) Variable( t.getModifiers(), t.getName(),
N clone = (N) Variable( (ModifiersTree) t.getModifiers(), aLabel,