Java TypeElement.getNestingKind方法代码示例

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
public static TargetDescription create(CompilationInfo info, TypeElement type, TreePath path, boolean allowForDuplicates, boolean iface) {
    boolean canStatic = true;
    if (iface) {
        // interface cannot have static methods
        canStatic = false;
    } else {
        if (type.getNestingKind() == NestingKind.ANONYMOUS || 
            type.getNestingKind() == NestingKind.LOCAL ||
            (type.getNestingKind() != NestingKind.TOP_LEVEL && !type.getModifiers().contains(Modifier.STATIC))) {
            canStatic = false;
        }
    }
    return new TargetDescription(Utilities.target2String(type), 
            ElementHandle.create(type), 
            TreePathHandle.create(path, info),
            allowForDuplicates, 
            type.getSimpleName().length() == 0, iface, canStatic);
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
/**
 * Registers an instance for the resolved constructor. If a 
 * 
 * @param el 
 */
private void addInstanceForConstructor(Element el) {
    TypeElement pt = findEnclosingType(el);
    if (pt == null) {
        return;
    }
    switch (pt.getNestingKind()) {
        case ANONYMOUS:
            // the anonymous class itself may not need an enclosing instance, if its
            // contents do not reference anything from the instance.
            break;
            
        case LOCAL:
            // implicit reference to the enclosing instance, but since a type with no qualname is referenced,
            // the expression / statement can't be probably moved anywhere.
            addLocalReference(pt);
            break;
        case MEMBER:
            // add enclosing type's reference
            if (!pt.getModifiers().contains(Modifier.STATIC)) {
                addRequiredInstance((TypeElement)pt.getEnclosingElement());
            }
            break;
    }
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
public String generateComment(TypeElement clazz, CompilationInfo javac) {
        StringBuilder builder = new StringBuilder(
//                "/**\n" + // NOI18N
                "\n" // NOI18N
                );
        
        if (clazz.getNestingKind() == NestingKind.TOP_LEVEL) {
            builder.append("@author ").append(author).append("\n"); // NOI18N
        }
        
        if (SourceVersion.RELEASE_5.compareTo(srcVersion) <= 0) {
            for (TypeParameterElement param : clazz.getTypeParameters()) {
                builder.append("@param <").append(param.getSimpleName().toString()).append("> \n"); // NOI18N
            }
        }
        
        if (SourceVersion.RELEASE_5.compareTo(srcVersion) <= 0 &&
                JavadocUtilities.isDeprecated(javac, clazz)) {
            builder.append("@deprecated\n"); // NOI18N
        }
        
//        builder.append("*/\n"); // NOI18N

        return builder.toString();
    }
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
/**
 * 获取TypeElement真实的类名
 */
public String getRealClassName(TypeElement typeElement) {
	NestingKind nestingKind = typeElement.getNestingKind();
	if (nestingKind.isNested()) {
		Element enclosingElement = typeElement.getEnclosingElement();
		if (enclosingElement.getKind() == ElementKind.CLASS || enclosingElement.getKind() == ElementKind.INTERFACE){
			String enclosingClassName = getRealClassName((TypeElement) enclosingElement);
			return enclosingClassName + "$" + typeElement.getSimpleName();
		}else {
			mErrorReporter.reportError("the type(" + enclosingElement.getKind()+ ") of enclosing element is not CLASS or INTERFACE.",typeElement);
			return null;
		}
	}else {
		return typeElement.getQualifiedName().toString();
	}
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
private boolean hasStaticRoot(final Element element) {
	final TypeElement parent = (TypeElement) element.getEnclosingElement();

	if (parent == null) {
		return true;
	}

	switch (parent.getNestingKind()) {
		case TOP_LEVEL:
			return true;
		case MEMBER:
			return parent.getModifiers().contains(STATIC);
		case LOCAL:
			return false;
		case ANONYMOUS:
			return false;
	}

	throw new RuntimeException("Should never get here.");
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
private static String getParentChain(final TypeElement targetClass) {
	// if input is top level class return it
	// otherwise return the parent chain plus it

	if (targetClass.getNestingKind() == NestingKind.TOP_LEVEL) {
		return targetClass.getSimpleName().toString();
	} else {
		final Element parent = targetClass.getEnclosingElement();

		if (parent.getKind() != ElementKind.CLASS) {
			throw new RuntimeException("Cannot create parent chain. Non-class parent found.");
		}

		return (getParentChain((TypeElement) parent)) + "_" + targetClass.getSimpleName().toString();
	}
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
private ReplaceConstructorWithBuilderUI(TreePathHandle constructor, CompilationInfo info) {
    this.refactoring = new ReplaceConstructorWithBuilderRefactoring(constructor);
    ExecutableElement contructorElement = (ExecutableElement) constructor.resolveElement(info);
    this.name = contructorElement.getSimpleName().toString();
    MethodTree constTree = (MethodTree) constructor.resolve(info).getLeaf();
    paramaterNames = new ArrayList<String>();
    parameterTypes = new ArrayList<String>();
    parameterTypeVars = new ArrayList<Boolean>();
    boolean varargs = contructorElement.isVarArgs();
    List<? extends VariableElement> parameterElements = contructorElement.getParameters();
    List<? extends VariableTree> parameters = constTree.getParameters();
    for (int i = 0; i < parameters.size(); i++) {
        VariableTree var = parameters.get(i);
        paramaterNames.add(var.getName().toString());
        String type = contructorElement.getParameters().get(i).asType().toString();
        if(varargs && i+1 == parameters.size()) {
            if(var.getType().getKind() == Tree.Kind.ARRAY_TYPE) {
                ArrayTypeTree att = (ArrayTypeTree) var.getType();
                type = att.getType().toString();
                type += "..."; //NOI18N
            }
        }
        parameterTypes.add(type);
        parameterTypeVars.add(parameterElements.get(i).asType().getKind() == TypeKind.TYPEVAR);
    }
    TypeElement typeEl = (TypeElement) contructorElement.getEnclosingElement();
    if(typeEl.getNestingKind() != NestingKind.TOP_LEVEL) {
        PackageElement packageOf = info.getElements().getPackageOf(typeEl);
        builderFQN = packageOf.toString() + "." + typeEl.getSimpleName().toString();
    } else {
        builderFQN = typeEl.getQualifiedName().toString();
    }
    buildMethodName = "create" + typeEl.getSimpleName();
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
@Hint(
    displayName = "#DN_ClassTooComplex",
    description = "#DESC_ClassTooComplex",
    category = "metrics",
    options = { Hint.Options.HEAVY, Hint.Options.QUERY },
    enabled = false
)
@UseOptions(OPTION_COMPLEXITY_LIMIT)
@TriggerTreeKind(Tree.Kind.CLASS)
public static ErrorDescription tooComplexClass(HintContext ctx) {
    ClassTree clazz = (ClassTree)ctx.getPath().getLeaf();
    TypeElement e = (TypeElement)ctx.getInfo().getTrees().getElement(ctx.getPath());
    if (e.getNestingKind() == NestingKind.ANONYMOUS) {
        return null;
    }
    CyclomaticComplexityVisitor v = new CyclomaticComplexityVisitor();
    v.scan(ctx.getPath(), null);
    
    int complexity = v.getComplexity();
    int limit = ctx.getPreferences().getInt(OPTION_COMPLEXITY_LIMIT, DEFAULT_COMPLEXITY_LIMIT);
    if (complexity > limit) {
        return ErrorDescriptionFactory.forName(ctx, 
                ctx.getPath(), 
                TEXT_ClassTooComplex(clazz.getSimpleName().toString(), complexity));
    } else {
        return null;
    }
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
@Override
public boolean isAccessible(Scope scope, TypeElement te) {
    if (te == null || scope == null) {
        return false;
    }
    if (te.getQualifiedName().toString().startsWith("REPL.") && te.getNestingKind() == NestingKind.TOP_LEVEL) {
        return false;
    }
    return delegate.isAccessible(scope, te);
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
@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());
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
/**
 * If the variable is typed as a local class, record the local class; it may need to go along
 * with the factored expression, unless the expression only uses some specific interface
 * implemented by the local class.
 * 
 * @param el 
 */
private void addLocalClassVariable(Element el) {
    TypeMirror tm = el.asType();
    if (tm.getKind() != TypeKind.DECLARED)  {
        return;
    }
    Element e = ((DeclaredType)tm).asElement();
    if (!(e instanceof TypeElement)) {
        return;
    }
    TypeElement t = (TypeElement)e;
    if (t.getNestingKind() == NestingKind.LOCAL) {
        addLocalReference(t);
    }
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
@TriggerPatterns(value = {
    @TriggerPattern(value = JPAAnnotations.ENTITY),
    @TriggerPattern(value = JPAAnnotations.EMBEDDABLE),
    @TriggerPattern(value = JPAAnnotations.MAPPED_SUPERCLASS)})
public static ErrorDescription apply(HintContext hc) {
    if (hc.isCanceled() || (hc.getPath().getLeaf().getKind() != Tree.Kind.IDENTIFIER || hc.getPath().getParentPath().getLeaf().getKind() != Tree.Kind.ANNOTATION)) {//NOI18N
        return null;//we pass only if it is an annotation
    }

    final JPAProblemContext ctx = ModelUtils.getOrCreateCachedContext(hc);
    if (ctx == null || hc.isCanceled()) {
        return null;
    }

    TypeElement subject = ctx.getJavaClass();
    
    if (subject.getNestingKind() == NestingKind.TOP_LEVEL){
        return null;
    }
    TreePath par = hc.getPath();
    while (par != null && par.getParentPath() != null && par.getLeaf().getKind() != Tree.Kind.CLASS) {
        par = par.getParentPath();
    }

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

    return ErrorDescriptionFactory.forSpan(
            hc,
            underlineSpan.getStartOffset(),
            underlineSpan.getEndOffset(),
            NbBundle.getMessage(TopLevelClass.class, "MSG_NestedClassAsEntity"));        
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
ComponentDescriptor( @Nonnull final String name,
                     @Nonnull final PackageElement packageElement,
                     @Nonnull final TypeElement element )
{
  _name = Objects.requireNonNull( name );
  _packageElement = Objects.requireNonNull( packageElement );
  _element = Objects.requireNonNull( element );

  if ( ElementKind.CLASS != element.getKind() )
  {
    throw new ReactProcessorException( "@ReactComponent target must be a class", element );
  }
  else if ( element.getModifiers().contains( Modifier.ABSTRACT ) )
  {
    throw new ReactProcessorException( "@ReactComponent target must not be abstract", element );
  }
  else if ( element.getModifiers().contains( Modifier.FINAL ) )
  {
    throw new ReactProcessorException( "@ReactComponent target must not be final", element );
  }
  else if ( NestingKind.TOP_LEVEL != element.getNestingKind() &&
            !element.getModifiers().contains( Modifier.STATIC ) )
  {
    throw new ReactProcessorException( "@ReactComponent target must not be a non-static nested class", element );
  }

  final List<ExecutableElement> constructors = element.getEnclosedElements().stream().
    filter( m -> m.getKind() == ElementKind.CONSTRUCTOR ).
    map( m -> (ExecutableElement) m ).
    collect( Collectors.toList() );
  if ( !( 1 == constructors.size() &&
          constructors.get( 0 ).getParameters().isEmpty() &&
          !constructors.get( 0 ).getModifiers().contains( Modifier.PRIVATE ) ) )
  {
    throw new ReactProcessorException( "@ReactComponent target must have a single non-private, no-argument " +
                                       "constructor or the default constructor", element );
  }
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
private PackageElement getPackage(final TypeElement type) {
	if (type.getNestingKind() == NestingKind.TOP_LEVEL) {
		return (PackageElement) type.getEnclosingElement();
	} else {
		return getPackage((TypeElement) type.getEnclosingElement());
	}
}
 

import javax.lang.model.element.TypeElement; //导入方法依赖的package包/类
public static String getFlatName(TypeElement classRepresenter) {
    if (classRepresenter.getNestingKind() == NestingKind.MEMBER) {
        return classRepresenter.getEnclosingElement() + "" + classRepresenter.getSimpleName().toString();
    } else {
        return classRepresenter.getQualifiedName().toString();
    }
}