} else { JavaParser.ResolvedField field = (JavaParser.ResolvedField) resolved; if (!field.getContainingClass().matches(FQCN_GRAVITY)) { return false;
if (resolved instanceof ResolvedField) { ResolvedField field = (ResolvedField) resolved; Object value = field.getValue(); if (value != null) { return value; Node astNode = field.findAstNode(); if (astNode instanceof VariableDeclaration) { VariableDeclaration declaration = (VariableDeclaration) astNode;
private static String listAllowedValues(@NonNull Object[] allowedValues) { StringBuilder sb = new StringBuilder(); for (Object allowedValue : allowedValues) { String s; if (allowedValue instanceof Integer) { s = allowedValue.toString(); } else if (allowedValue instanceof ResolvedNode) { ResolvedNode node = (ResolvedNode) allowedValue; if (node instanceof ResolvedField) { ResolvedField field = (ResolvedField) node; String containingClassName = field.getContainingClassName(); containingClassName = containingClassName.substring(containingClassName.lastIndexOf('.') + 1); s = containingClassName + "." + field.getName(); } else { s = node.getSignature(); } } else { continue; } if (sb.length() > 0) { sb.append(", "); } sb.append(s); } return sb.toString(); }
Node astNode = field.findAstNode(); if (astNode instanceof VariableDeclaration) { VariableDeclaration declaration = (VariableDeclaration)astNode; return field.getType();
if (resolve instanceof JavaParser.ResolvedField) { JavaParser.ResolvedField field = (JavaParser.ResolvedField) resolve; Object value = field.getValue(); if (value instanceof String) { checkParameter(context, node, expression, (String)value, true);
private static int calculateValue(JavaContext context, Expression expression) { // This function assumes that the only inputs to the expression are static integer // flags that combined via bitwise operands. if (expression instanceof IntegralLiteral) { return ((IntegralLiteral) expression).astIntValue(); } ResolvedNode resolvedNode = context.resolve(expression); if (resolvedNode instanceof ResolvedField) { Object value = ((ResolvedField) resolvedNode).getValue(); if (value instanceof Integer) { return (Integer) value; } } if (expression instanceof BinaryExpression) { BinaryExpression binaryExpression = (BinaryExpression) expression; BinaryOperator operator = binaryExpression.astOperator(); int leftValue = calculateValue(context, binaryExpression.astLeft()); int rightValue = calculateValue(context, binaryExpression.astRight()); if (operator == BinaryOperator.BITWISE_OR) { return leftValue | rightValue; } if (operator == BinaryOperator.BITWISE_AND) { return leftValue & rightValue; } if (operator == BinaryOperator.BITWISE_XOR) { return leftValue ^ rightValue; } } return 0; }
@Nullable @Override public Node findAstNode() { // Map back from type binding to AST ResolvedClass containingClass = getContainingClass(); TypeDeclaration typeDeclaration = findTypeDeclaration(containingClass.getName()); if (typeDeclaration != null) { for (FieldDeclaration field : typeDeclaration.fields) { if (field.binding == mBinding) { EcjTreeConverter converter = new EcjTreeConverter(); converter.visit(null, field); List<? extends Node> nodes = converter.getAll(); if (nodes.size() == 1) { return nodes.get(0); } break; } } } return super.findAstNode(); }
@Override public boolean equals(Object obj) { if (obj instanceof ResolvedExternalField) { return mSignature.equals(((ResolvedExternalField)obj).mSignature); } else if (obj instanceof ResolvedField) { ResolvedField field = (ResolvedField)obj; if (mSignature.endsWith(field.getName())) { ResolvedClass containingClass = field.getContainingClass(); String signature = containingClass != null ? containingClass.getSignature() + "." + field.getName() : field.getName(); return mSignature.equals(signature); } return false; } else { return false; } }
@Override public boolean isInPackage(@NonNull String pkg, boolean includeSubPackages) { ResolvedClass containingClass = getContainingClass(); if (containingClass == null) { return false; } String packageName = containingClass.getPackageName(); //noinspection SimplifiableIfStatement if (pkg.equals(packageName)) { return true; } return includeSubPackages && packageName.length() > pkg.length() && packageName.charAt(pkg.length()) == '.' && packageName.startsWith(pkg); } }
private static boolean isStringParameter( @NonNull Expression expression, @NonNull JavaContext context) { if (expression instanceof StringLiteral) { return true; } else { ResolvedNode resolvedNode = context.resolve(expression); if (resolvedNode instanceof ResolvedField) { if (((ResolvedField) resolvedNode).getValue() instanceof String) { return true; } } } return false; } }
@Nullable private FieldInfo findField(@NonNull ResolvedField field) { ResolvedClass containingClass = field.getContainingClass(); if (containingClass == null) { return null; } ClassInfo c = findClass(containingClass); if (c == null) { return null; } if (c.fields == null) { return null; } return c.fields.get(field.getName()); }
@Nullable public String getContainingClassName() { ResolvedClass containingClass = getContainingClass(); return containingClass != null ? containingClass.getName() : null; }