<change id="GeneratorUtilities.createMethod">

             <api name="general"/>

             <summary>Added GeneratorUtilities.createMethod</summary>

             <version major="0" minor="34"/>

             <date day="25" month="3" year="2008"/>

             <author login="jlahoda"/>

             <compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible"/>

             <description>

                 Added method to create a new method tree for given method element.

             </description>

            <issue number="999999"/>

        </change>

import javax.lang.model.util.Types;

    /**Create a new method tree for the given method element. The method will be created as if it were member of {@link asMemberOf} type

     * (see also {@link Types#asMemberOf(javax.lang.model.type.DeclaredType,javax.lang.model.element.Element)}).

     * The new method will have an empty body.

     * 

     * @param asMemberOf create the method as if it were member of this type

     * @param method method to create

     * @return a newly created method

     * @see Types#asMemberOf(javax.lang.model.type.DeclaredType,javax.lang.model.element.Element)

     * @since 0.34

     */

    public MethodTree createMethod(DeclaredType asMemberOf, ExecutableElement method) {

        TreeMaker make = copy.getTreeMaker();

        Set<Modifier> mods = method.getModifiers();

        Set<Modifier> flags = mods.isEmpty() ? EnumSet.noneOf(Modifier.class) : EnumSet.copyOf(mods);

        flags.remove(Modifier.ABSTRACT);

        flags.remove(Modifier.NATIVE);

        ExecutableType et = (ExecutableType) method.asType();

        try {

            et = (ExecutableType) copy.getTypes().asMemberOf(asMemberOf, method);

        } catch (IllegalArgumentException iae) {

        }

        List<TypeParameterTree> typeParams = new ArrayList<TypeParameterTree>();

        for (TypeVariable typeVariable : et.getTypeVariables()) {

            List<ExpressionTree> bounds = new ArrayList<ExpressionTree>();

            TypeMirror bound = typeVariable.getUpperBound();

            if (bound.getKind() != TypeKind.NULL) {

                if (bound.getKind() == TypeKind.DECLARED) {

                    ClassSymbol boundSymbol = (ClassSymbol) ((DeclaredType) bound).asElement();

                    if (boundSymbol.getSimpleName().length() == 0 && (boundSymbol.flags() & Flags.COMPOUND) != 0) {

                        bounds.add((ExpressionTree) make.Type(boundSymbol.getSuperclass()));

                        for (Type iface : boundSymbol.getInterfaces()) {

                            bounds.add((ExpressionTree) make.Type(iface));

                        }

                    } else if (!boundSymbol.getQualifiedName().contentEquals("java.lang.Object")) { //NOI18N

                        //if the bound is java.lang.Object, do not generate the extends clause:

                        bounds.add((ExpressionTree) make.Type(bound));

                    }

                } else {

                    bounds.add((ExpressionTree) make.Type(bound));

                }

            }

            typeParams.add(make.TypeParameter(typeVariable.asElement().getSimpleName(), bounds));

        }

        Tree returnType = make.Type(et.getReturnType());

        List<VariableTree> params = new ArrayList<VariableTree>();

        boolean isVarArgs = method.isVarArgs();

        Iterator<? extends VariableElement> formArgNames = method.getParameters().iterator();

        Iterator<? extends TypeMirror> formArgTypes = et.getParameterTypes().iterator();

        ModifiersTree parameterModifiers = make.Modifiers(EnumSet.noneOf(Modifier.class));

        while (formArgNames.hasNext() && formArgTypes.hasNext()) {

            VariableElement formArgName = formArgNames.next();

            TypeMirror formArgType = formArgTypes.next();

            if (isVarArgs && !formArgNames.hasNext()) {

                parameterModifiers = make.Modifiers(1L << 34,

                        Collections.<AnnotationTree>emptyList());

            }

            params.add(make.Variable(parameterModifiers, formArgName.getSimpleName(), make.Type(formArgType), null));

        }

        List<ExpressionTree> throwsList = new ArrayList<ExpressionTree>();

        for (TypeMirror tm : et.getThrownTypes()) {

            throwsList.add((ExpressionTree) make.Type(tm));

        }

        ModifiersTree mt = make.Modifiers(flags, Collections.<AnnotationTree>emptyList());

        return make.Method(mt, method.getSimpleName(), returnType, typeParams, params, throwsList, "{}", null);

    }

        MethodTree prototype = createMethod(type, element);

        ModifiersTree mt = prototype.getModifiers();

    }

    public void testCreateMethod() throws Exception {

        performTest("package test;\npublic class Test { }\n", "1.5", new CreateMethodTask(34), new Validator() {

            public void validate(CompilationInfo info) {

                assertEquals(1, info.getDiagnostics().size());

                for (ExecutableElement ee : ElementFilter.methodsIn(info.getElements().getTypeElement("test.Test").getEnclosedElements())) {

                    assertEquals("toArray", ee.getSimpleName().toString());

                    assertEquals(1, ee.getTypeParameters().size());

                    return ;

                }

                fail("toArray method not found");

            }

        }, false);

    private static class CreateMethodTask implements CancellableTask<WorkingCopy> {        

        private int offset;

        public CreateMethodTask(int offset) {

            this.offset = offset;

        }

        public void cancel() {

        }

        public void run(WorkingCopy copy) throws Exception {

            copy.toPhase(JavaSource.Phase.RESOLVED);

            TreePath tp = copy.getTreeUtilities().pathFor(offset);

            assertTrue(tp.getLeaf().getKind() == Tree.Kind.CLASS);

            ClassTree ct = (ClassTree)tp.getLeaf();

            TypeElement te = (TypeElement)copy.getTrees().getElement(tp);

            DeclaredType dt = (DeclaredType) copy.getTreeUtilities().parseType("java.util.List<java.lang.String>", te);

            TypeElement list = copy.getElements().getTypeElement("java.util.List");

            ExecutableElement ee = null;

            for (ExecutableElement m : ElementFilter.methodsIn(list.getEnclosedElements())) {

                if (m.getSimpleName().contentEquals("toArray") && !m.getTypeParameters().isEmpty()) {

                    ee = m;

                }

            }

            assertNotNull(ee);

            GeneratorUtilities utilities = GeneratorUtilities.get(copy);

            assertNotNull(utilities);

            ClassTree newCt = utilities.insertClassMembers(ct, Collections.singletonList(utilities.createMethod(dt, ee)));

            copy.rewrite(ct, newCt);

        }

    }

        performTest(sourceCode, sourceLevel, task, validator, true);

    }

    private void performTest(String sourceCode, String sourceLevel, final Task<WorkingCopy> task, final Validator validator, final boolean requireNoErrors) throws Exception {