Java Code Examples for javax.lang.model.element.NestingKind#ANONYMOUS

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);
}
 

@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;
}
 

@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;
    }
}
 

public static boolean isAnonymousType(TypeMirror type) {
    if (type.getKind() == TypeKind.DECLARED) {
        DeclaredType dt = (DeclaredType) type;
        TypeElement typeElem = (TypeElement) dt.asElement();
        if (typeElem.getNestingKind() == NestingKind.ANONYMOUS) {
            return true;
        }
    }
    return false;
}
 

@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() {
	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;
}
 

public LambdaTypeElement(
    String name, Element enclosingElement, TypeMirror superclass, boolean isWeakOuter) {
  super(name, ElementKind.CLASS, enclosingElement, superclass, NestingKind.ANONYMOUS, null,
        false, false);
  this.isWeakOuter = isWeakOuter;
  addModifiers(Modifier.PRIVATE);
}
 

@Override
protected Problem preCheck(CompilationController info) throws IOException {
    // fire operation start on the registered progress listeners (4 steps)
    fireProgressListenerStart(refactoring.PRE_CHECK, 4);
    Problem preCheckProblem = null;
    info.toPhase(JavaSource.Phase.RESOLVED);
    Element el = treePathHandle.resolveElement(info);
    TreePathHandle sourceType = refactoring.getSourceType();
    
    // check whether the element is valid
    Problem result = isElementAvail(sourceType, info);
    if (result != null) {
        // fatal error -> don't continue with further checks
        return result;
    }
    result = JavaPluginUtils.isSourceElement(el, info);
    if (result != null) {
        return result;
    }
    
    
    refactoring.setClassName(sourceType.resolveElement(info).getSimpleName().toString());
    
    // increase progress (step 1)
    fireProgressListenerStep();
    
    // #1 - check if the class is an inner class
    //            RefObject declCls = (RefObject) sourceType.refImmediateComposite();
    if (el instanceof TypeElement) {
        if (((TypeElement)el).getNestingKind() == NestingKind.ANONYMOUS) {
            // fatal error -> return
            preCheckProblem = new Problem(true, NbBundle.getMessage(InnerToOuterRefactoringPlugin.class, "ERR_InnerToOuter_Anonymous")); // NOI18N
            return preCheckProblem;
        }
        if (!((TypeElement)el).getNestingKind().isNested()) {
            // fatal error -> return
            preCheckProblem = new Problem(true, NbBundle.getMessage(InnerToOuterRefactoringPlugin.class, "ERR_InnerToOuter_MustBeInnerClass")); // NOI18N
            return preCheckProblem;
        }
    } else {
        preCheckProblem = new Problem(true, NbBundle.getMessage(InnerToOuterRefactoringPlugin.class, "ERR_InnerToOuter_MustBeInnerClass")); // NOI18N
        return preCheckProblem;
    }
    
    // increase progress (step 2)
    fireProgressListenerStep();
    
    fireProgressListenerStop();
    return preCheckProblem;
}
 

private static boolean isAnonymous(TypeElement typeElement) {
  return typeElement.getNestingKind() == NestingKind.ANONYMOUS;
}
 

public static boolean isAnonymous(TypeElement type) {
  return type.getNestingKind() == NestingKind.ANONYMOUS;
}
 

public static boolean isLocal(TypeElement type) {
  NestingKind nestingKind = type.getNestingKind();
  return nestingKind == NestingKind.ANONYMOUS || nestingKind == NestingKind.LOCAL;
}