return $expr;

1 + 1 :: isAvailable("java.lang.ThreadLocal.initialValue()")

=> return $o != $t; :: matchesWithBind($expr, "$o == $t")

=> 2

=> return $t == $o; :: matchesWithBind($expr, "$t != $o")

%%TestCase bind-works-1

%%TestCase is-available-1

public class Test {

public class Test extends ThreadLocal {

    private boolean t(int v1, int v2) {

    private int t() {

        return v1 == v2;

        return 1 + 1;

public class Test {

public class Test extends ThreadLocal {

    private boolean t(int v1, int v2) {

    private int t() {

        return v1 != v2;

        return 2;

%%TestCase scope-works-1

%%TestCase is-not-available-1

    private boolean t(int v1, int v2) {

    private int t() {

        return v1 != v2;

        return 2 + 2;

        Matcher m = SPLIT.matcher(name);

        return (ExecutableElement) info.getElementUtilities().findElement(name);

        if (!m.matches()) {

            throw new IllegalArgumentException();

        }

        String className = m.group(1);

        String methodName = m.group(2);

        String paramsSpec = m.group(3);

        TypeElement te = info.getElements().getTypeElement(className);

        if (te == null) {

            return null;

        }

        String[] paramList = paramsSpec.split(",");

        List<TypeMirror> params = new LinkedList<TypeMirror>();

        TypeElement topLevel = info.getTopLevelElements().get(0);

        for (String t : paramList) {

            params.add(info.getTreeUtilities().parseType(t, topLevel));

        }

        for (ExecutableElement ee : ElementFilter.methodsIn(te.getEnclosedElements())) {

            if (!methodName.equals(ee.getSimpleName().toString()) || ee.getParameters().size() != params.size()) {

                continue;

            }

            Iterator<TypeMirror> designed = params.iterator();

            boolean found = true;

            for (VariableElement param : ee.getParameters()) {

                if (!info.getTypes().isSameType(info.getTypes().erasure(param.asType()), designed.next())) {

                    found = false;

                    break;

                }

            }

            if (found) {

                return ee;

            }

        }

        return null;

spec.version.base=0.113

spec.version.base=0.114

    };

    }

    /**Looks up the given Java element.

     * 

     * The <code>elementDescription</code> format is as follows:

     * <dl>

     *   <dt>for type (class, enum, interface or annotation type)</dt>

     *     <dd><em>the FQN of the type</em></dd>

     *   <dt>for field or enum constant</dt>

     *     <dd><em>the FQN of the enclosing type</em><code>.</code><em>field name</em></dd>

     *   <dt>for method</dt>

     *     <dd><em>the FQN of the enclosing type</em><code>.</code><em>method name</em><code>(</code><em>comma separated parameter types</em><code>)</code><br>

     *         The parameter types may include type parameters, but these are ignored. The last parameter type can use ellipsis (...) to denote vararg method.</dd>

     *   <dt>for constructor</dt>

     *     <dd><em>the FQN of the enclosing type</em><code>.</code><em>simple name of enclosing type</em><code>(</code><em>comma separated parameter types</em><code>)</code><br>

     *         See method format for more details on parameter types.</dd>

     * </dl>

     * 

     * @param elementDescription the description of the element that should be checked for existence

     * @return the found element, or null if not available

     * @since 0.114

     */

    public @CheckForNull Element findElement(@NonNull String description) {

        if (description.contains("(")) {

            //method:

            String methodFullName = description.substring(0, description.indexOf('('));

            String className = methodFullName.substring(0, methodFullName.lastIndexOf('.'));

            TypeElement clazz = info.getElements().getTypeElement(className);

            if (clazz == null) return null;

            String methodSimpleName = methodFullName.substring(methodFullName.lastIndexOf('.') + 1);

            boolean constructor = clazz.getSimpleName().contentEquals(methodSimpleName);

            String parameters = description.substring(description.indexOf('(') + 1, description.lastIndexOf(')') + 1);

            int paramIndex = 0;

            int lastParamStart = 0;

            int angleDepth = 0;

            //XXX:

            List<TypeMirror> types = new ArrayList<TypeMirror>();

            while (paramIndex < parameters.length()) {

                switch (parameters.charAt(paramIndex)) {

                    case '<': angleDepth++; break;

                    case '>': angleDepth--; break; //TODO: check underflow

                    case ',':

                        if (angleDepth > 0) break;

                    case ')':

                        if (paramIndex > lastParamStart) {

                            String type = parameters.substring(lastParamStart, paramIndex).replace("...", "[]");

                            //TODO: handle varargs

                            types.add(info.getTypes().erasure(info.getTreeUtilities().parseType(type, info.getTopLevelElements().get(0)/*XXX*/)));

                            lastParamStart = paramIndex + 1;

                        }

                        break;

                }

                paramIndex++;

            }

            OUTER: for (ExecutableElement ee : constructor ? ElementFilter.constructorsIn(clazz.getEnclosedElements()) : ElementFilter.methodsIn(clazz.getEnclosedElements())) {

                if ((constructor || ee.getSimpleName().contentEquals(methodSimpleName)) && ee.getParameters().size() == types.size()) {

                    Iterator<? extends TypeMirror> real = ((ExecutableType) info.getTypes().erasure(ee.asType())).getParameterTypes().iterator();

                    Iterator<TypeMirror> expected = types.iterator();

                    while (real.hasNext() && expected.hasNext()) {

                        if (!info.getTypes().isSameType(real.next(), expected.next())) {

                            continue OUTER;

                        }

                    }

                    assert real.hasNext() == expected.hasNext();

                    return ee;

                }

            }

        }

        //field or class:

        TypeElement el = info.getElements().getTypeElement(description);

        if (el != null) return el;

        int dot = description.lastIndexOf('.');

        if (dot != (-1)) {

            String simpleName = description.substring(dot + 1);

            el = info.getElements().getTypeElement(description.substring(0, dot));

            if (el != null) {

                for (VariableElement var : ElementFilter.fieldsIn(el.getEnclosedElements())) {

                    if (var.getSimpleName().contentEquals(simpleName)) {

                        return var;

                    }

                }

            }

        }

        return null;

    }

 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

 * Copyright 1997-2013 Oracle and/or its affiliates. All rights reserved.

 * Portions Copyrighted 2007 Sun Microsystems, Inc.

 * Portions Copyrighted 2007-2013 Sun Microsystems, Inc.

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.ElementKind;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.type.TypeMirror;

import javax.lang.model.type.TypeKind;

public class ElementsTest extends NbTestCase {

public class ElementUtilitiesTest extends NbTestCase {

    public ElementsTest(String name) {

    public ElementUtilitiesTest(String name) {

        SourceUtilsTestUtil.prepareTest(new String[0], new Object[] {new FileEncodingQueryImplementation() {

        SourceUtilsTestUtil.prepareTest(new String[0], new Object[0]);

            @Override

            public Charset getEncoding(FileObject file) {

                if (file.equals(testFO))

                    return Charset.forName("UTF-8");

                else

                    return null;

            }

        }});

                "public class Vecernicek {" +

                "public class Test {" +

                TypeElement typeElement = controller.getElements().getTypeElement("Vecernicek");

                assertNotNull(typeElement);

                {

            }

                    Element wait = controller.getElementUtilities().findElement("java.lang.Object.wait(long)");

        }, true);

                    assertNotNull(wait);

                    assertEquals(ElementKind.METHOD, wait.getKind());

        TestUtilities.copyStringToFile(FileUtil.toFile(testFO),

                    ExecutableElement waitMethod = (ExecutableElement) wait;

                "public class Večerníček {" +

                    assertEquals("wait", waitMethod.getSimpleName().toString());

                "}");

                    assertEquals(1, waitMethod.getParameters().size());

        testFO.refresh();

                    assertEquals(TypeKind.LONG, waitMethod.getParameters().get(0).asType().getKind());

        javaSource = JavaSource.forFileObject(testFO);

                    assertEquals(controller.getElements().getTypeElement("java.lang.Object"), waitMethod.getEnclosingElement());

        javaSource.runUserActionTask(new Task<CompilationController>() {

                }

            public void run(CompilationController controller) throws IOException {

                controller.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED);

                {

                TypeElement typeElement = controller.getElements().getTypeElement("Večerníček");

                    Element arrayListInit = controller.getElementUtilities().findElement("java.util.ArrayList.ArrayList(java.util.Collection)");

                assertNotNull(typeElement);

                    assertNotNull(arrayListInit);

                    assertEquals(ElementKind.CONSTRUCTOR, arrayListInit.getKind());

                    ExecutableElement arrayListInitMethod = (ExecutableElement) arrayListInit;

                    assertEquals("<init>", arrayListInitMethod.getSimpleName().toString());

                    assertEquals(1, arrayListInitMethod.getParameters().size());

                    assertEquals("java.util.Collection", controller.getTypes().erasure(arrayListInitMethod.getParameters().get(0).asType()).toString());

                    assertEquals(controller.getElements().getTypeElement("java.util.ArrayList"), arrayListInitMethod.getEnclosingElement());

                }

                {

                    Element arrayListAdd = controller.getElementUtilities().findElement("java.util.ArrayList.add(int, Object)");

                    assertNotNull(arrayListAdd);

                    assertEquals(ElementKind.METHOD, arrayListAdd.getKind());

                    ExecutableElement arrayListAddMethod = (ExecutableElement) arrayListAdd;

                    assertEquals("add", arrayListAddMethod.getSimpleName().toString());

                    assertEquals(2, arrayListAddMethod.getParameters().size());

                    assertEquals(TypeKind.INT, arrayListAddMethod.getParameters().get(0).asType().getKind());

                    assertEquals("java.lang.Object", controller.getTypes().erasure(arrayListAddMethod.getParameters().get(1).asType()).toString());

                    assertEquals(controller.getElements().getTypeElement("java.util.ArrayList"), arrayListAddMethod.getEnclosingElement());

                }

                {

                    Element arraysAsList = controller.getElementUtilities().findElement("java.util.Arrays.asList(Object...)");

                    assertNotNull(arraysAsList);

                    assertEquals(ElementKind.METHOD, arraysAsList.getKind());

                    ExecutableElement arraysAsListMethod = (ExecutableElement) arraysAsList;

                    assertEquals("asList", arraysAsListMethod.getSimpleName().toString());

                    assertEquals(1, arraysAsListMethod.getParameters().size());

                    assertEquals(TypeKind.ARRAY, arraysAsListMethod.getParameters().get(0).asType().getKind());

                    assertEquals(controller.getElements().getTypeElement("java.util.Arrays"), arraysAsListMethod.getEnclosingElement());

                }

                {

                    Element hashCode = controller.getElementUtilities().findElement("java.lang.Object.hashCode()");

                    assertNotNull(hashCode);

                    assertEquals(ElementKind.METHOD, hashCode.getKind());

                    ExecutableElement hashCodeMethod = (ExecutableElement) hashCode;

                    assertEquals("hashCode", hashCodeMethod.getSimpleName().toString());

                    assertEquals(0, hashCodeMethod.getParameters().size());

                    assertEquals(controller.getElements().getTypeElement("java.lang.Object"), hashCodeMethod.getEnclosingElement());

                }

                {

                    Element bigIntegerOne = controller.getElementUtilities().findElement("java.math.BigInteger.ONE");

                    assertNotNull(bigIntegerOne);

                    assertEquals(ElementKind.FIELD, bigIntegerOne.getKind());

                    assertEquals("ONE", bigIntegerOne.getSimpleName().toString());

                    assertEquals(controller.getElements().getTypeElement("java.math.BigInteger"), bigIntegerOne.getEnclosingElement());

                }

                {

                    Element bigInteger = controller.getElementUtilities().findElement("java.math.BigInteger");

                    assertEquals(controller.getElements().getTypeElement("java.math.BigInteger"), bigInteger);

                }