Java Code Examples for javax.lang.model.element.ElementKind#CLASS

@TriggerPatterns({
    @TriggerPattern(value="$mods$ java.util.logging.Logger $LOG;"), //NOI18N
    @TriggerPattern(value="$mods$ java.util.logging.Logger $LOG = $init;") //NOI18N
})
public static ErrorDescription checkLoggerDeclaration(HintContext ctx) {
    Element e = ctx.getInfo().getTrees().getElement(ctx.getPath());
    if (e != null && e.getEnclosingElement().getKind() == ElementKind.CLASS &&
        (!e.getModifiers().contains(Modifier.STATIC) || !e.getModifiers().contains(Modifier.FINAL)) &&
        ctx.getInfo().getElementUtilities().outermostTypeElement(e) == e.getEnclosingElement()
    ) {
        return ErrorDescriptionFactory.forName(
                ctx,
                ctx.getPath(),
                NbBundle.getMessage(LoggerNotStaticFinal.class, "MSG_LoggerNotStaticFinal_checkLoggerDeclaration", e), //NOI18N
                new LoggerNotStaticFinalFix(NbBundle.getMessage(LoggerNotStaticFinal.class, "MSG_LoggerNotStaticFinal_checkLoggerDeclaration_fix", e), TreePathHandle.create(e, ctx.getInfo())).toEditorFix() //NOI18N
        );
    } else {
        return null;
    }
}
 

/**
         * Must be run under MDR transaction!
         */
        public javax.lang.model.element.Element getJavaClass() {
            TreePath path = null;
//            try {
//                path = getCompletionTreePath(getController(), endOffset, COMPLETION_QUERY_TYPE);
//            } catch (IOException ex) {
//                Exceptions.printStackTrace(ex);
//            }
            javax.lang.model.element.Element el = null;
            try {
                getController().toPhase(JavaSource.Phase.ELEMENTS_RESOLVED);
            } catch (IOException ex) {
                Exceptions.printStackTrace(ex);
            }
            while ((el == null || !(ElementKind.CLASS == el.getKind() || ElementKind.INTERFACE == el.getKind())) && path != null) {
                path.getCompilationUnit().getTypeDecls();
                el = getController().getTrees().getElement(path);
                path = path.getParentPath();
            }
            return el;
        }
 

private boolean isMethodOfStarlarkExposedConfigurationFragment(
    ExecutableElement methodElement) {

  if (methodElement.getEnclosingElement().getKind() != ElementKind.CLASS) {
    return false;
  }
  Element classElement = methodElement.getEnclosingElement();
  // If configurationFragmentType is null, then BuildConfiguration.Fragment isn't even included
  // in the current build, so the class clearly does not depend on it.
  if (configurationFragmentType == null
      || !typeUtils.isAssignable(classElement.asType(), configurationFragmentType.asType())) {
    return false;
  }

  return true;
}
 

public static String isDeclaredAsJavaBean(TypeElement clazz) {
    if (ElementKind.CLASS != clazz.getKind()) {
        return PaletteUtils.getBundleString("MSG_notAClass"); // NOI18N
    }

    Set<javax.lang.model.element.Modifier> mods = clazz.getModifiers();
    if (mods.contains(javax.lang.model.element.Modifier.ABSTRACT)) {
        return PaletteUtils.getBundleString("MSG_abstractClass"); // NOI18N
    }

    if (!mods.contains(javax.lang.model.element.Modifier.PUBLIC)) {
        return PaletteUtils.getBundleString("MSG_notPublic"); // NOI18N
    }
    
    for (Element member : clazz.getEnclosedElements()) {
        mods = member.getModifiers();
        if (ElementKind.CONSTRUCTOR == member.getKind() &&
                mods.contains(javax.lang.model.element.Modifier.PUBLIC) &&
                ((ExecutableElement) member).getParameters().isEmpty()) {
            return null;
        }
    }
    
    return PaletteUtils.getBundleString("MSG_noPublicConstructor"); // NOI18N
}
 

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
	if (!roundEnv.processingOver() && !fileCreated) {
		Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(GenerateLambda.class);
		for (Element element : elements) {
			if (element.getKind() == ElementKind.CLASS) {
				GenerateLambda generateSignatureContainerAnnotation = element.getAnnotation(GenerateLambda.class);
				generateCode(PACKAGE, INTERFACE_NAME, generateSignatureContainerAnnotation);
				return true;
			}
			break;
		}
	}
	return true;
}
 

private void processAddToFixPatch(RoundEnvironment roundEnv) throws IllegalArgumentException {
    for (Element element : roundEnv.getElementsAnnotatedWith(AddToFixPatch.class)) {
        if (element.getKind() != ElementKind.CLASS) {
            throw new IllegalArgumentException(String.format("Only java class can be annotated with @%s",
                    AddToFixPatch.class.getSimpleName()));
        }
        TypeElement element1 = (TypeElement) element;
        fieldSet.add(element1.getQualifiedName().toString());
    }
}
 

FileObject doCreateFromTemplate(CompilationUnitTree cut) throws IOException {
    ElementKind kind;
    if ("package-info.java".equals(cut.getSourceFile().getName())) {
        kind = ElementKind.PACKAGE;
    } else if (cut.getTypeDecls().isEmpty()) {
        kind = null;
    } else {
        switch (cut.getTypeDecls().get(0).getKind()) {
            case CLASS:
                kind = ElementKind.CLASS;
                break;
            case INTERFACE:
                kind = ElementKind.INTERFACE;
                break;
            case ANNOTATION_TYPE:
                kind = ElementKind.ANNOTATION_TYPE;
                break;
            case ENUM:
                kind = ElementKind.ENUM;
                break;
            default:
                Logger.getLogger(WorkingCopy.class.getName()).log(Level.SEVERE, "Cannot resolve template for {0}", cut.getTypeDecls().get(0).getKind());
                kind = null;
        }
    }
    FileObject template = FileUtil.getConfigFile(template(kind));
    return doCreateFromTemplate(template, cut.getSourceFile());
}
 

private static Element handlePossibleAnonymousInnerClass(CompilationInfo info, final Element el) {
    Element encl = el.getEnclosingElement();
    Element doubleEncl = encl != null ? encl.getEnclosingElement() : null;
    
    if (   doubleEncl != null
        && !doubleEncl.getKind().isClass()
        && !doubleEncl.getKind().isInterface()
        && doubleEncl.getKind() != ElementKind.PACKAGE
        && encl.getKind() == ElementKind.CLASS) {
        TreePath enclTreePath = info.getTrees().getPath(encl);
        Tree enclTree = enclTreePath != null ? enclTreePath.getLeaf() : null;
        
        if (enclTree != null && TreeUtilities.CLASS_TREE_KINDS.contains(enclTree.getKind()) && enclTreePath.getParentPath().getLeaf().getKind() == Tree.Kind.NEW_CLASS) {
            NewClassTree nct = (NewClassTree) enclTreePath.getParentPath().getLeaf();
            
            if (nct.getClassBody() != null) {
                Element parentElement = info.getTrees().getElement(new TreePath(enclTreePath, nct.getIdentifier()));
                
                if (parentElement == null || parentElement.getKind().isInterface()) {
                    return parentElement;
                } else {
                    //annonymous innerclass extending a class. Find out which constructor is used:
                    TreePath superConstructorCall = new FindSuperConstructorCall().scan(enclTreePath, null);
                    
                    if (superConstructorCall != null) {
                        return info.getTrees().getElement(superConstructorCall);
                    }
                }
            }
        }
        
        return null;//prevent jumps to incorrect positions
    } else {
        if (encl != null) {
            return encl;
        } else {
            return el;
        }
    }
}
 

protected ErrorDescription[] apply(TypeElement subject, ProblemContext ctx) {
    ArrayList<ErrorDescription> errors = new ArrayList<ErrorDescription>();
    AnnotationMirror annEntity = Utilities.findAnnotation(subject, ANNOTATION_WEBSERVICE);
    if (subject.getKind() == ElementKind.CLASS && Utilities.getAnnotationAttrValue
            (annEntity, ANNOTATION_ATTRIBUTE_SEI) != null) {
        for (String aName : new String[]{
            ANNOTATION_WEBMETHOD, 
            ANNOTATION_WEBPARAM, 
            ANNOTATION_WEBRESULT, 
            ANNOTATION_ONEWAY, 
            ANNOTATION_SOAPMESSAGEHANDLERS, 
            ANNOTATION_INITPARAM, 
            ANNOTATION_SOAPBINDING, 
            ANNOTATION_SOAPMESSAGEHANDLER}) {
            AnnotationMirror wrongAnnon = Utilities.findAnnotation(subject, aName);
            if (wrongAnnon != null) {
                String label = NbBundle.getMessage(InvalidJSRAnnotations.class, "MSG_Invalid_JSR181Annotation");
                Tree problemTree = ctx.getCompilationInfo().getTrees().getTree(subject, wrongAnnon);
                Fix removeHC = new RemoveAnnotation(ctx.getFileObject(), subject, wrongAnnon);
                ctx.setElementToAnnotate(problemTree);
                errors.add(createProblem(subject, ctx, label, removeHC));
                ctx.setElementToAnnotate(null);
            }
        }
    }
    return errors.isEmpty() ? null : errors.toArray(new ErrorDescription[errors.size()]);
}
 

/**
 * Whether the given node represents static {@link Iterable} field where can be used operators.
 * @param ccontext compilation context
 * @param element element to examine
 * @return {@code true} if the object is static {@link Iterable} field, {@code false} otherwise
 * @since 1.26
 */
public static boolean isIterableElement(CompilationContext ccontext, Element element) {
    if (element.getKind() == ElementKind.CLASS) {
        return isSubtypeOf(ccontext, element.asType(), "java.lang.Iterable"); //NOI18N
    } else if (element.getKind() == ElementKind.METHOD) {
        TypeMirror returnType = ELTypeUtilities.getReturnType(ccontext, (ExecutableElement) element);
        if (returnType.getKind() == TypeKind.ARRAY
                || isSubtypeOf(ccontext, returnType, "java.lang.Iterable")) { //NOI18N
            return true;
        }
    } else if (element.getKind() == ElementKind.INTERFACE) {
        return isSubtypeOf(ccontext, element.asType(), "java.lang.Iterable"); //NOI18N
    }
    return false;
}
 

/**
 * Register a service.
 * If the class does not have an appropriate signature, an error will be printed and the registration skipped.
 * @param clazz the service implementation type (an error will be reported if not a {@link TypeElement})
 * @param annotation the (top-level) annotation registering the service, for diagnostic purposes
 * @param type the type to which the implementation must be assignable
 * @param path a path under which to register, or "" if inapplicable
 * @param position a position at which to register, or {@link Integer#MAX_VALUE} to skip
 * @param supersedes possibly empty list of implementation to supersede
 * @since 8.8
 */
protected final void register(
    Element el, Class<? extends Annotation> annotation,
    TypeMirror type, String path, int position, String... supersedes
) {
    if (el.getKind() != ElementKind.CLASS) {
        processingEnv.getMessager().printMessage(Kind.ERROR, annotation.getName() + " is not applicable to a " + el.getKind(), el);
        return;
    }
    if (el.getEnclosingElement().getKind() == ElementKind.CLASS && !el.getModifiers().contains(Modifier.STATIC)) {
        processingEnv.getMessager().printMessage(Kind.ERROR, "Inner class needs to be static to be annotated with @ServiceProvider", el);
        return;
    }
    
    TypeElement clazz = (TypeElement) el;
    String impl = processingEnv.getElementUtils().getBinaryName(clazz).toString();
    String xface = processingEnv.getElementUtils().getBinaryName((TypeElement) processingEnv.getTypeUtils().asElement(type)).toString();
    if (!processingEnv.getTypeUtils().isAssignable(clazz.asType(), type)) {
        AnnotationMirror ann = findAnnotationMirror(clazz, annotation);
        processingEnv.getMessager().printMessage(Kind.ERROR, impl + " is not assignable to " + xface,
                clazz, ann, findAnnotationValue(ann, "service"));
        return;
    }
    String rsrc = (path.length() > 0 ? "META-INF/namedservices/" + path + "/" : "META-INF/services/") + xface;
    Boolean verify = verifiedClasses.get(clazz);
    if (verify == null) {
        verify = verifyServiceProviderSignature(clazz, annotation);
        verifiedClasses.put(clazz, verify);
    }
    if (!verify) {
        return;
    }
    registerImpl(clazz, impl, rsrc, position, supersedes);
}
 

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
	if (!roundEnv.processingOver() && !fileCreated) {
		Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(GenerateLambda.class);
		for (Element element : elements) {
			if (element.getKind() == ElementKind.CLASS) {
				GenerateLambda generateSignatureContainerAnnotation = element.getAnnotation(GenerateLambda.class);
				generateCode(PACKAGE, INTERFACE_NAME, generateSignatureContainerAnnotation);
				return true;
			}
			break;
		}
	}
	return true;
}
 

public List<Fix> run(final CompilationInfo info, String diagnosticKey, final int offset, TreePath treePath, Data<Object> data) {
    TreePath path = deepTreePath(info, offset);
    if (path == null) {
        return null;
    }

    Map<Tree, Object> holder = data == null ? null : (Map)data.getData();
    Object saved = null;
    if (holder != null) {
        saved = holder.get(path.getLeaf());
    }
    if (Boolean.TRUE == saved) {
        return null;
    }
    Element e = info.getTrees().getElement(path);
    final Tree leaf = path.getLeaf();
    boolean isUsableElement = e != null && (e.getKind().isClass() || e.getKind().isInterface());
    boolean containsDefaultMethod = saved == Boolean.FALSE;

    boolean completingAnonymous = e != null && e.getKind() == ElementKind.CONSTRUCTOR && 
            leaf.getKind() == Tree.Kind.NEW_CLASS;
    TypeElement tel = findTypeElement(info, path);
    
    if (!Utilities.isValidElement(tel)) {
        return null;
    }
    List<Fix> fixes = new ArrayList<>();
    if (TreeUtilities.CLASS_TREE_KINDS.contains(leaf.getKind()) || leaf.getKind().toString().equals(RECORD)) {
        CompilationUnitTree cut = info.getCompilationUnit();
        // do not offer for class declarations without body
        long start = info.getTrees().getSourcePositions().getStartPosition(cut, leaf);
        long end = info.getTrees().getSourcePositions().getEndPosition(cut, leaf);
        for (Diagnostic d : info.getDiagnostics()) {
            long position = d.getPosition();
            if (d.getCode().equals(PREMATURE_EOF_CODE) && position > start && position < end) {
                return null;
            }
        }
    }
    
    if (completingAnonymous) {
        //if the parent of path.getLeaf is an error, the situation probably is like:
        //new Runnable {}
        //(missing '()' for constructor)
        //do not propose the hint in this case:
        final boolean[] parentError = new boolean[] {false};
        new ErrorAwareTreePathScanner() {
            @Override
            public Object visitNewClass(NewClassTree nct, Object o) {
                if (leaf == nct) {
                    parentError[0] = getCurrentPath().getParentPath().getLeaf().getKind() == Kind.ERRONEOUS;
                }
                return super.visitNewClass(nct, o);
            }
        }.scan(path.getParentPath(), null);
        if (parentError[0]) {
            // ignore
            return null;
        }
        fixes.add(new ImplementAbstractMethodsFix(info, path, tel, containsDefaultMethod));
    }
    boolean someAbstract = false;
    X: if (isUsableElement) {
        for (ExecutableElement ee : ElementFilter.methodsIn(e.getEnclosedElements())) {
            if (ee.getModifiers().contains(Modifier.ABSTRACT)) {
                // make class abstract. In case of enums, suggest to implement the
                // abstract methods on all enum values.
                if (e.getKind() == ElementKind.ENUM) {
                    // cannot make enum abstract, but can generate abstract methods skeleton
                    // to all enum members
                    fixes.add(new ImplementOnEnumValues2(info,  tel, containsDefaultMethod));
                    // avoid other possible fixes:
                    break X;
                } else if (e.getKind().isClass()) {
                    someAbstract = true;
                    break;
                }
            }
        }
        // offer to fix all abstract methods
        if (!someAbstract) {
            fixes.add(new ImplementAbstractMethodsFix(info, path, tel, containsDefaultMethod));
        }
        if (e.getKind() == ElementKind.CLASS && e.getSimpleName() != null && !e.getSimpleName().contentEquals("")) {
            fixes.add(new MakeAbstractFix(info, path, e.getSimpleName().toString()).toEditorFix());
        }
    } 
    if (e != null && e.getKind() == ElementKind.ENUM_CONSTANT) {
        fixes.add(new ImplementAbstractMethodsFix(info, path, tel, containsDefaultMethod));
    }
    return fixes;
}
 

static boolean isClass(Element element) {
    return element.getKind() == ElementKind.CLASS;
}
 

Encoding(TypeElement type) {
  this.typeEncoding = type;
  if (type.getKind() != ElementKind.CLASS || type.getNestingKind() != NestingKind.TOP_LEVEL) {
    reporter.withElement(type).error("Encoding type '%s' should be top-level class", type.getSimpleName());
  }

  this.$$package = processing().getElementUtils().getPackageOf(type).getQualifiedName().toString();
  this.name = type.getSimpleName().toString();

  CharSequence source = SourceExtraction.extract(processing(), type);
  if (source.length() == 0) {
    reporter.withElement(type)
        .error("No source code can be extracted for @Encoding class. Unsupported compilation mode");
  }

  this.imports = SourceExtraction.importsFrom(source);
  this.sourceMapper = new SourceMapper(source);
  this.typesReader = new TypeExtractor(types, type);

  this.encodingSelfType = typesReader.get(type.asType());

  addTypeParameters(type);

  for (Element e : type.getEnclosedElements()) {
    processMember(e);
  }

  if (postValidate()) {
    provideSyntheticElements();
  }

  this.allElements = Iterables.concat(
      Arrays.asList(
          Iterables.filter(
              Arrays.asList(
                  impl,
                  from,
                  toString,
                  hashCode,
                  equals,
                  build,
                  isInit),
              Predicates.notNull()),
          fields,
          expose,
          copy,
          helpers,
          builderFields,
          builderHelpers,
          builderInits));

  this.linkage = new Linkage();
  this.generatedImports = generatedImports();
}
 

@Override
public Collection<ErrorDescription> check(final JPAProblemContext ctx, final HintContext hc, final AttributeWrapper attrib) {

    // Not applicable for embeddable classes, which do not have relationships.
    if (ctx.isEmbeddable()) {
        return null;
    }


    final Element typeElement = ctx.getCompilationInfo().getTypes().asElement(attrib.getType());
    final ArrayList<ErrorDescription> ret = new ArrayList<>();

    if (typeElement != null && typeElement.getKind() == ElementKind.CLASS) {
        try {
            MetadataModel<EntityMappingsMetadata> model = ModelUtils.getModel(hc.getInfo().getFileObject());
            model.runReadAction(new MetadataModelAction<EntityMappingsMetadata, Void>() {
                @Override
                public Void run(EntityMappingsMetadata metadata) {


                    Entity entity = ModelUtils.getEntity(ctx.getMetaData(), ((TypeElement) typeElement));

                    if (entity != null) {
                        //not appliable to derived ids, it's already attribute and relationship
                        //if id and have one-one and many-one
                        List<? extends AnnotationMirror> anns = attrib.getJavaElement().getAnnotationMirrors();
                        if (anns != null) {
                            boolean id = false;
                            boolean rel = false;
                            for (AnnotationMirror ann : anns) {
                                ann.getAnnotationType().asElement().toString();
                                if (ann.getAnnotationType().asElement().toString().equals("javax.persistence.Id")) {//NOI18N
                                    id = true;//NOI18N
                                } else if (ann.getAnnotationType().asElement().toString().equals("javax.persistence.ManyToOne") || ann.getAnnotationType().asElement().toString().equals("javax.persistence.OneToOne")) {//NOI18N
                                    rel = true;//NOI18N
                                }
                                if (id && rel) {
                                    return null;//in future more strict verification may be done
                                }
                            }

                        }
                        //other cases
                        ElementHandle<TypeElement> classHandle = ElementHandle.create(ctx.getJavaClass());
                        ElementHandle<Element> elemHandle = ElementHandle.create(attrib.getJavaElement());
                        String remoteClassName = ((TypeElement) typeElement).getQualifiedName().toString();

                        Fix fix1 = new CreateUnidirOneToOneRelationship(ctx.getFileObject(),
                                classHandle, elemHandle);

                        Fix fix2 = new CreateOneToOneRelationshipHint(ctx.getFileObject(),
                                classHandle,
                                ctx.getAccessType(),
                                attrib.getName(),
                                remoteClassName);

                        Fix fix3 = new CreateUnidirManyToOneRelationship(ctx.getFileObject(),
                                classHandle,
                                elemHandle);

                        Fix fix4 = new CreateManyToOneRelationshipHint(ctx.getFileObject(),
                                classHandle,
                                ctx.getAccessType(),
                                attrib.getName(),
                                remoteClassName);
                        Tree elementTree = ctx.getCompilationInfo().getTrees().getTree(attrib.getJavaElement());

                        Utilities.TextSpan underlineSpan = Utilities.getUnderlineSpan(
                                ctx.getCompilationInfo(), elementTree);

                        ErrorDescription error = ErrorDescriptionFactory.forSpan(
                                hc,
                                underlineSpan.getStartOffset(),
                                underlineSpan.getEndOffset(),
                                NbBundle.getMessage(RelationshipForEntityTypeAttrDefined.class, "MSG_EntityRelationNotDefined"),
                                fix1, fix2, fix3, fix4);
                        ret.add(error);


                    }
                    return null;
                }
            });
        } catch (IOException ex) {
        }
    }

    return ret;
}
 

private void process(Element e, PaletteItemRegistration pir) throws LayerGenerationException {
        LayerBuilder builder = layer(e);
        TypeMirror activeEditorDrop = type(ActiveEditorDrop.class);

        LayerBuilder.File f = builder.file(pir.paletteid() + "/" + pir.category() + "/" + pir.itemid() + ".xml");
        StringBuilder paletteFile = new StringBuilder();

        paletteFile.append("<!DOCTYPE editor_palette_item PUBLIC '-//NetBeans//Editor Palette Item 1.1//EN' 'http://www.netbeans.org/dtds/editor-palette-item-1_1.dtd'>\n");
        paletteFile.append("<editor_palette_item version=\"1.1\">\n");

        if (pir.body().isEmpty()) {
            // body empty we need a activeEditorDrop
            if (e.getKind() == ElementKind.CLASS && isAssignable(e.asType(), activeEditorDrop)) {
                String className = processingEnv.getElementUtils().getBinaryName((TypeElement) e).toString();
                paletteFile.append(" <class name=\"").append(className).append("\"/>\n");
            } else {
                throw new LayerGenerationException("Class annotated with @PaletteItemRegistration has to implements ActiveEditorDrop", e);
            }
        } else {
            // body not empty put info 
            paletteFile.append("<body>  <![CDATA[");
            paletteFile.append(pir.body());
            paletteFile.append("]]> </body>\n");
        }

// icon shoud be in classpath
        if (!pir.icon16().isEmpty()) {
            builder.validateResource(pir.icon16(), e, pir, "icon16", true);
            paletteFile.append("<icon16 urlvalue=\"").append(pir.icon16()).append("\" />\n");
        } else {
            throw new LayerGenerationException("Icon 16 must be set ", e);
        }
        if (!pir.icon32().isEmpty()) {
            builder.validateResource(pir.icon32(), e, pir, "icon32", true);
            paletteFile.append("<icon32 urlvalue=\"").append(pir.icon32()).append("\" />\n");
        } else {
            throw new LayerGenerationException("Icon 32 must be set ", e);
        }

        paletteFile.append("<inline-description>");
        paletteFile.append("<display-name>");
        paletteFile.append(pir.name());
        paletteFile.append("</display-name>");
        paletteFile.append("<tooltip> <![CDATA[ ");
        paletteFile.append(pir.tooltip());
        paletteFile.append("]]></tooltip>");
        paletteFile.append("</inline-description>");

        paletteFile.append("</editor_palette_item>");

        f.contents(paletteFile.toString());
        f.write();
    }
 

@Override
public Number visitMemberSelect(MemberSelectTree node, Void p) {
    Element e = info.getTrees().getElement(getCurrentPath());

    if (e != null && (e.getKind() != ElementKind.CLASS || ((TypeElement) e).asType().getKind() != TypeKind.ERROR)) {
        //check correct dependency:
        checkDependency(info, e, canShowUI);

        if (isStaticElement(e) && !inImport) {
            rewrite(node, make.QualIdent(e));

            return null;
        }
    }
    
    MemberSelectTree nue = node;
    String selectedName = node.getIdentifier().toString();

    if (selectedName.startsWith("$") && parameterNames.get(selectedName) != null) {
        nue = make.MemberSelect(node.getExpression(), parameterNames.get(selectedName));
    }

    if (nue.getExpression().getKind() == Kind.IDENTIFIER) {
        String name = ((IdentifierTree) nue.getExpression()).getName().toString();

        if (name.startsWith("$") && parameters.get(name) == null) {
            Element implicitThisClass = implicitThis.get(name);
            if (implicitThisClass != null) {
                TreePath findClass = getCurrentPath();
                OUTER: while (findClass != null) {
                    if (TreeUtilities.CLASS_TREE_KINDS.contains(findClass.getLeaf().getKind())) {
                        Element clazz = info.getTrees().getElement(findClass);
                        if (implicitThisClass.equals(clazz)) {
                            //this.<...>, the this may be implicit:
                            rewrite(node, make.Identifier(nue.getIdentifier()));
                            return null;
                        }
                        if (clazz.getKind().isClass() || clazz.getKind().isInterface()) {
                            for (Element currentClassElement : info.getElements().getAllMembers((TypeElement) clazz)) {
                                if (currentClassElement.getSimpleName().equals(node.getIdentifier())) {
                                    //there may be a resolution conflict, let the member select be qualified
                                    //TODO: no conflicts between fields and methods of the same name
                                    //but we current still qualify the name
                                    break OUTER;
                                }
                            }
                        }
                    }
                    findClass = findClass.getParentPath();
                }
                //let visitIdent handle this
            } else {
                //XXX: unbound variable, use identifier instead of member select - may cause problems?
                rewrite(node, make.Identifier(nue.getIdentifier()));
                return null;
            }
        }
    }

    if (nue != node) {
        rewrite(node, nue);
    }
    
    return super.visitMemberSelect(node, p);
}
 

private void checkForErrors(Element element, Class annotationClass) {
    if(element.getEnclosingElement().getKind()!= ElementKind.CLASS) {
        throw new IllegalArgumentException("Annotation can only apply to class fields and methods.");
    }

    final Set<Modifier> modifiers = element.getModifiers();

    switch(element.getKind()){
        case METHOD:
            List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters();
            if(modifiers.contains(Modifier.PRIVATE)
                    || modifiers.contains(Modifier.STATIC)) {
                throw new IllegalArgumentException("Annotated methods must not be private or static");
            } else if (parameters.size() > 2
                    || (parameters.size() < 1 && (annotationClass==ReceiveMessages.class || annotationClass==ReceiveData.class))) {
                throw new IllegalArgumentException("Incorrect number of parameters for method.");
            } else if (parameters.size()==2
                    && (annotationClass==ReceiveMessages.class || annotationClass==ReceiveData.class)
                    && !parameters.get(1).asType().toString().equals(String.class.getName())) {
                throw new IllegalArgumentException("The second parameter must be a String (represents the source node ID)");
            } else if(annotationClass==LocalNode.class
                    && !parameters.get(0).asType().toString().equals(NODE_CLASS)) {
                throw new IllegalArgumentException("@LocalNode annotated method must have a parameter that is a "+NODE_CLASS);
            } else if(annotationClass==RemoteNodes.class
                    && !parameters.get(0).asType().toString().equals("java.util.List<com.google.android.gms.wearable.Node>")) {
                throw new IllegalArgumentException("@RemoteNode annotated method must have a parameter that is a List<Node>");
            }
            break;
        case FIELD:
            if(modifiers.contains(Modifier.PRIVATE)
                    || modifiers.contains(Modifier.STATIC)
                    || modifiers.contains(Modifier.FINAL)) {
                throw new IllegalArgumentException("Annotated fields must not be private, static, nor final");
            } else if(annotationClass==LocalNode.class && !element.asType().toString().equalsIgnoreCase(NODE_CLASS)) {
                throw new IllegalArgumentException("@LocalNode annotated field must be a "+NODE_CLASS);
            } else if(annotationClass==RemoteNodes.class
                    && !element.asType().toString().equalsIgnoreCase("java.util.List<com.google.android.gms.wearable.Node>")) {
                throw new IllegalArgumentException("@RemoteNodes annotated field must be a List<Node>");
            }
            break;
        default:
            throw new IllegalArgumentException("Delivery must be made to a method or field");
    }
}
 

/**
 * @param info
 * @param t1
 * @param t3
 * @return true iff the first type (or its containing class in the case of inner classes)
 * is a subtype of the second.
 * @see Types#isSubtype(javax.lang.model.type.TypeMirror, javax.lang.model.type.TypeMirror)
 */
private static boolean isSubTypeOrInnerOfSubType(CompilationInfo info, Element t1, Element t2) {
    boolean isSubtype = info.getTypes().isSubtype(t1.asType(), t2.asType());
    boolean isInnerClass = t1.getEnclosingElement().getKind() == ElementKind.CLASS;
    return isSubtype || (isInnerClass && info.getTypes().isSubtype(t1.getEnclosingElement().asType(), t2.asType()));
}