private static boolean isCatchVariable(VariableDeclarationNode node) { return elementFromDeclaration(node.getTree()).getKind() == EXCEPTION_PARAMETER; }
private static boolean isCatchVariable(VariableDeclarationNode node) { return elementFromDeclaration(node.getTree()).getKind() == EXCEPTION_PARAMETER; }
@Override public TransferResult<Nullness, NullnessStore> visitAssignment( AssignmentNode node, TransferInput<Nullness, NullnessStore> input) { ReadableUpdates updates = new ReadableUpdates(); Nullness value = values(input).valueOfSubNode(node.getExpression()); Node target = node.getTarget(); if (target instanceof LocalVariableNode) { updates.set((LocalVariableNode) target, value); } if (target instanceof ArrayAccessNode) { setNonnullIfAnalyzeable(updates, ((ArrayAccessNode) target).getArray()); } if (target instanceof FieldAccessNode) { // we don't allow arbitrary access paths to be tracked from assignments // here we still require an access of a field of this, or a static field FieldAccessNode fieldAccessNode = (FieldAccessNode) target; Node receiver = fieldAccessNode.getReceiver(); if ((receiver instanceof ThisLiteralNode || fieldAccessNode.isStatic()) && fieldAccessNode.getElement().getKind().equals(ElementKind.FIELD)) { updates.set(fieldAccessNode, value); } } return updateRegularStore(value, input, updates); }
@Override public ElementKind getKind() { return variableElement.getKind(); }
@Override public ElementKind getKind() { return variableElement.getKind(); }
@Override public T visitEnumConstant(VariableElement variableElement, Void aVoid) { if(variableElement.getKind() == ElementKind.ENUM_CONSTANT){ return (T) Enum.valueOf((Class<? extends Enum>)type, variableElement.getSimpleName().toString()); } return null; }
protected String resolveFieldLink(VariableElement elt, Coordinate coordinate) { switch (elt.getKind()) { case ENUM_CONSTANT: return "enumConstant"; case FIELD: return "field"; default: return "unsupported"; } }
@Override public T visitEnumConstant(VariableElement variableElement, Void aVoid) { if(variableElement.getKind() == ElementKind.ENUM_CONSTANT && type != null && type.isEnum()){ return (T) Enum.valueOf((Class<? extends Enum>) type, variableElement.getSimpleName().toString()); } else if (type != null && type == String.class) { return (T) variableElement.getSimpleName().toString(); } else { return (T) new ASTEnumConstant(variableElement.getSimpleName().toString()); } }
@Override public String resolveFieldLink(VariableElement elt, Coordinate coordinate) { switch (elt.getKind()) { case ENUM_CONSTANT: return "enumConstant"; case FIELD: return "field"; default: return "unsupported"; } }
public List<? extends VariableElement> getFields() { List<VariableElement> fields = new ArrayList<VariableElement>(); List<VariableElement> allFields = ElementFilter.fieldsIn(this.delegate.getEnclosedElements()); for (VariableElement field : allFields) { if (field.getKind() == ElementKind.FIELD && !(field.getModifiers().contains(Modifier.STATIC))) { fields.add(field); } } return fields; }
public List<? extends VariableElement> getFields() { List<VariableElement> fields = new ArrayList<VariableElement>(); List<VariableElement> allFields = ElementFilter.fieldsIn(this.delegate.getEnclosedElements()); for (VariableElement field : allFields) { if (field.getKind() == ElementKind.FIELD && !(field.getModifiers().contains(Modifier.STATIC))) { fields.add(field); } } return fields; }
protected List<VariableElement> loadEnumConstants() { ArrayList<VariableElement> constants = new ArrayList<VariableElement>(); if (isEnum()) { List<VariableElement> fields = ElementFilter.fieldsIn(this.delegate.getEnclosedElements()); for (VariableElement field : fields) { if (field.getKind() == ElementKind.ENUM_CONSTANT) { constants.add(field); } } } return constants; }
protected List<VariableElement> loadEnumConstants() { ArrayList<VariableElement> constants = new ArrayList<VariableElement>(); if (isEnum()) { List<VariableElement> fields = ElementFilter.fieldsIn(this.delegate.getEnclosedElements()); for (VariableElement field : fields) { if (field.getKind() == ElementKind.ENUM_CONSTANT) { constants.add(field); } } } return constants; }
protected DirectlyAccessibleFieldInformation(@Nonnull Element element, @Nonnull TypeMirror type, @Nonnull DeclaredType containingType, @Nonnull VariableElement field) { super(element, type, containingType); Require.that(field.getKind() == ElementKind.FIELD).orThrow("The element $ has to be a field.", SourcePosition.of(field)); this.field = field; }
@Override public Boolean visitVariable(VariableElement element, Void p) { ElementKind kind = element.getKind(); checkArgument(kind.isField(), "checking a variable that isn't a field: %s", kind); return accessibleMember(element); } }
FieldDeclaration newFieldDeclaration( VariableElement fieldElement, List<TypeParameterDeclaration> typeParameterDeclarations) { assertNotNull(fieldElement, typeParameterDeclarations); assertTrue( fieldElement.getKind() == ElementKind.FIELD || fieldElement.getKind() == ElementKind.ENUM_CONSTANT, fieldElement.getKind().toString()); TypeMirror fieldType = resolveTypeParameter(fieldElement.asType(), typeParameterDeclarations); TypeDeclaration typeDeclaration = newTypeDeclaration(fieldType); return new FieldDeclaration(fieldElement, typeDeclaration); }
@Override public MethodModel method() { if(element.getKind() == ElementKind.PARAMETER) { return factory.method((ExecutableElement) element.getEnclosingElement()); } else return null; }
public FieldElement(ProcessingEnvironment processingEnv, ClassElement parentClass, VariableElement fieldElement) { super(processingEnv); if (!fieldElement.getKind().isField()) { throw CodegenException.of().message("Unsupported element kind:" + fieldElement.getKind()).element(fieldElement).build(); } this.parentClass = parentClass; this.originVariableElement = fieldElement; }