Java NestingKind.MEMBER属性代码示例

public TypeElement lookupStaticClass(DeclaredType type, CharSequence className, TypeMirror classType) {
    for (TypeElement clazz : ElementFilter.typesIn(type.asElement().getEnclosedElements())) {
        final Collection<? extends Modifier> modifiers = clazz.getModifiers();

        if (clazz.getNestingKind() != NestingKind.MEMBER
                || !modifiers.contains(Modifier.STATIC)
                || !modifiers.contains(Modifier.PUBLIC)
                || !clazz.getKind().isClass()) {
            continue;
        }

        if (!clazz.getSimpleName().contentEquals(className)) {
            continue;
        }

        if (!types.isAssignable(clazz.asType(), classType)) {
            continue;
        }

        return clazz;
    }

    return null;
}
 

private static TypeElement validateBeanType(TypeElement beanType) {
  if (!hasParameterlessConstructor(beanType)) {
    throw new ValidationException(BEAN_NO_DEFAULT_CONSTRUCTOR, beanType);
  }
  if (beanType.getModifiers().contains(PRIVATE)) {
    throw new ValidationException(NESTING_KIND, beanType);
  }
  if (beanType.getNestingKind() == NestingKind.MEMBER &&
      !beanType.getModifiers().contains(STATIC)) {
    throw new ValidationException(NESTING_KIND, beanType);
  }
  if (beanType.getModifiers().contains(ABSTRACT)) {
    throw new ValidationException(BEAN_ABSTRACT_CLASS, beanType);
  }
  if (!beanType.getTypeParameters().isEmpty()) {
    throw new ValidationException(TYPE_PARAMS_BEAN, beanType);
  }
  return beanType;
}
 

@TriggerTreeKind(Tree.Kind.BLOCK)
public static ErrorDescription run(HintContext ctx) {
    TreePath path = ctx.getPath();
    if (((BlockTree)path.getLeaf()).isStatic()) {
        return null;
    }
    TreePath parentPath = path.getParentPath();
    if (parentPath == null) {
        return null;
    }
    Tree l = parentPath.getLeaf();
    if (!(l instanceof ClassTree)) {
        return null;
    }
    Element el = ctx.getInfo().getTrees().getElement(parentPath);
    if (el == null || !el.getKind().isClass()) {
        return null;
    }
    TypeElement tel = (TypeElement)el;
    // do not suggest for anonymous classes, local classes or members which are not static.
    if (tel.getNestingKind() != NestingKind.TOP_LEVEL && 
        (tel.getNestingKind() != NestingKind.MEMBER || !tel.getModifiers().contains(Modifier.STATIC))) {
        return null;
    }
    InstanceRefFinder finder = new InstanceRefFinder(ctx.getInfo(), path);
    finder.process();
    if (finder.containsInstanceReferences() || finder.containsReferencesToSuper()) {
        return null;
    }
    
    return ErrorDescriptionFactory.forTree(ctx, path, Bundle.TEXT_InitializerCanBeStatic(),
            new MakeInitStatic(TreePathHandle.create(path, ctx.getInfo())).toEditorFix());
}
 

public static String getFlatName(TypeElement classRepresenter) {
    if (classRepresenter.getNestingKind() == NestingKind.MEMBER) {
        return classRepresenter.getEnclosingElement() + "" + classRepresenter.getSimpleName().toString();
    } else {
        return classRepresenter.getQualifiedName().toString();
    }
}
 

@DefinedBy(Api.LANGUAGE_MODEL)
public NestingKind getNestingKind() {
    complete();
    if (owner.kind == PCK)
        return NestingKind.TOP_LEVEL;
    else if (name.isEmpty())
        return NestingKind.ANONYMOUS;
    else if (owner.kind == MTH)
        return NestingKind.LOCAL;
    else
        return NestingKind.MEMBER;
}
 

@Override
public NestingKind getNestingKind() {
    require(State.FINISHED);
    boolean isTopLevel = enclosingTypeDeclaration == null;
    return isTopLevel
        ? NestingKind.TOP_LEVEL
        : NestingKind.MEMBER;
}
 

@Override
protected UnitCache<VariableElement> doCompile(FieldDeclaration unit) {
    String unitName = NameUtil.getNodeName(getCompileUnit(), unit);

    TypeMirror type = TypeUtil.toMirror(getCompileUnit(), unit.getType());
    Name name = new StringName(unitName);

    ElementKind kind = ElementKind.FIELD;
    Set<Modifier> modifierSet = ModifierUtil.asSet(unit.getModifiers());

    List<Element> members = new ArrayList<>();
    for(VariableDeclarator var : unit.getVariables()) {
        // TODO:
    }

    VariableElement element = new EmulVariableElement(type, kind, parent, members,
        modifierSet, name, name, NestingKind.MEMBER);

    // Children
    NodeToElementCompiler compiler = new NodeToElementCompiler(getCompileUnit(), element);
    for(Node child : unit.getChildrenNodes()) {
        Element childElem = compiler.compile(child);
        if(childElem != null) {
            members.add(childElem);
        }
    }

    return new UnitCache<>(element);
}
 

@Override
public NestingKind getNestingKind() {
	ReferenceBinding refBinding = (ReferenceBinding)_binding;
	if (refBinding.isAnonymousType()) {
		return NestingKind.ANONYMOUS;
	} else if (refBinding.isLocalType()) {
		return NestingKind.LOCAL;
	} else if (refBinding.isMemberType()) {
		return NestingKind.MEMBER;
	}
	return NestingKind.TOP_LEVEL;
}
 

@Override
public Description matchClass(final ClassTree tree, final VisitorState state) {
  final ClassSymbol currentClass = ASTHelpers.getSymbol(tree);
  if (currentClass == null || !currentClass.hasOuterInstance()) {
    return NO_MATCH;
  }
  if (currentClass.getNestingKind() != NestingKind.MEMBER) {
    // local or anonymous classes can't be static
    return NO_MATCH;
  }
  switch (currentClass.owner.enclClass().getNestingKind()) {
    case TOP_LEVEL:
      break;
    case MEMBER:
      // class is nested inside an inner class, so it can't be static
      if (currentClass.owner.enclClass().hasOuterInstance()) {
        return NO_MATCH;
      }
      break;
    case LOCAL:
    case ANONYMOUS:
      // members of local and anonymous classes can't be static
      return NO_MATCH;
  }
  if (tree.getExtendsClause() != null
      && ASTHelpers.getType(tree.getExtendsClause()).tsym.hasOuterInstance()) {
    return NO_MATCH;
  }
  if (CanBeStaticAnalyzer.referencesOuter(tree, currentClass, state)) {
    return NO_MATCH;
  }
  return describeMatch(tree, SuggestedFixes.addModifiers(tree, state, Modifier.STATIC));
}
 

protected void validateEnclosingElement(Element element) {
    TypeElement typeElement = ElementUtil.toTypeElement(element, env);
    if (typeElement == null) {
        return;
    }
    String simpleName = typeElement.getSimpleName().toString();
    if (simpleName.contains(Constants.BINARY_NAME_DELIMITER)
            || simpleName.contains(Constants.METATYPE_NAME_DELIMITER)) {
        throw new AptException(Message.DOMA4277, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
    NestingKind nestingKind = typeElement.getNestingKind();
    if (nestingKind == NestingKind.TOP_LEVEL) {
        return;
    } else if (nestingKind == NestingKind.MEMBER) {
        Set<Modifier> modifiers = typeElement.getModifiers();
        if (modifiers.containsAll(Arrays.asList(Modifier.STATIC,
                Modifier.PUBLIC))) {
            validateEnclosingElement(typeElement.getEnclosingElement());
        } else {
            throw new AptException(Message.DOMA4275, env, typeElement,
                    new Object[] { typeElement.getQualifiedName() });
        }
    } else {
        throw new AptException(Message.DOMA4276, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
}
 

protected void validateEnclosingElement(Element element) {
    TypeElement typeElement = ElementUtil.toTypeElement(element, env);
    if (typeElement == null) {
        return;
    }
    String simpleName = typeElement.getSimpleName().toString();
    if (simpleName.contains(Constants.BINARY_NAME_DELIMITER)
            || simpleName.contains(Constants.METATYPE_NAME_DELIMITER)) {
        throw new AptException(Message.DOMA4417, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
    NestingKind nestingKind = typeElement.getNestingKind();
    if (nestingKind == NestingKind.TOP_LEVEL) {
        return;
    } else if (nestingKind == NestingKind.MEMBER) {
        Set<Modifier> modifiers = typeElement.getModifiers();
        if (modifiers.containsAll(Arrays.asList(Modifier.STATIC,
                Modifier.PUBLIC))) {
            validateEnclosingElement(typeElement.getEnclosingElement());
        } else {
            throw new AptException(Message.DOMA4415, env, typeElement,
                    new Object[] { typeElement.getQualifiedName() });
        }
    } else {
        throw new AptException(Message.DOMA4416, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
}
 

protected void validateEnclosingElement(Element element) {
    TypeElement typeElement = ElementUtil.toTypeElement(element, env);
    if (typeElement == null) {
        return;
    }
    String simpleName = typeElement.getSimpleName().toString();
    if (simpleName.contains(Constants.BINARY_NAME_DELIMITER)
            || simpleName.contains(Constants.METATYPE_NAME_DELIMITER)) {
        throw new AptException(Message.DOMA4317, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
    NestingKind nestingKind = typeElement.getNestingKind();
    if (nestingKind == NestingKind.TOP_LEVEL) {
        return;
    } else if (nestingKind == NestingKind.MEMBER) {
        Set<Modifier> modifiers = typeElement.getModifiers();
        if (modifiers.containsAll(Arrays.asList(Modifier.STATIC,
                Modifier.PUBLIC))) {
            validateEnclosingElement(typeElement.getEnclosingElement());
        } else {
            throw new AptException(Message.DOMA4315, env, typeElement,
                    new Object[] { typeElement.getQualifiedName() });
        }
    } else {
        throw new AptException(Message.DOMA4316, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
}
 

protected void validateEnclosingElement(Element element) {
    TypeElement typeElement = ElementUtil.toTypeElement(element, env);
    if (typeElement == null) {
        return;
    }
    String simpleName = typeElement.getSimpleName().toString();
    if (simpleName.contains(Constants.BINARY_NAME_DELIMITER)
            || simpleName.contains(Constants.METATYPE_NAME_DELIMITER)) {
        throw new AptException(Message.DOMA4280, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
    NestingKind nestingKind = typeElement.getNestingKind();
    if (nestingKind == NestingKind.TOP_LEVEL) {
        return;
    } else if (nestingKind == NestingKind.MEMBER) {
        Set<Modifier> modifiers = typeElement.getModifiers();
        if (modifiers.containsAll(Arrays.asList(Modifier.STATIC,
                Modifier.PUBLIC))) {
            validateEnclosingElement(typeElement.getEnclosingElement());
        } else {
            throw new AptException(Message.DOMA4278, env, typeElement,
                    new Object[] { typeElement.getQualifiedName() });
        }
    } else {
        throw new AptException(Message.DOMA4279, env, typeElement,
                new Object[] { typeElement.getQualifiedName() });
    }
}
 

@Override
public NestingKind getNestingKind() {
  // We'll never need to infer local or anonymous classes, so there are only two options left
  // and we can tell the difference:
  if (getEnclosingElement() instanceof InferredTypeElement) {
    return NestingKind.MEMBER;
  }

  return NestingKind.TOP_LEVEL;
}
 

private static boolean isAccessibleClass(TypeElement te) {
    NestingKind nestingKind = te.getNestingKind();
    return (nestingKind == NestingKind.TOP_LEVEL) || (nestingKind == NestingKind.MEMBER && te.getModifiers().contains(Modifier.STATIC));
}