private FieldDefinition findFieldInType(TypeDefinition typeDef, String uniqueStr) { String[] linkParts = uniqueStr.split("\\|"); if (linkParts.length != 4) return null; String fieldName = linkParts[3]; if (fieldName.trim().length() <= 0) return null; List<FieldDefinition> declaredFields = typeDef.getDeclaredFields(); if (declaredFields == null) return null; boolean isFound = false; for (FieldDefinition declaredField : declaredFields) { isFound = (declaredField != null && fieldName.equals(declaredField.getName())); if (isFound) { if (declaredField.isSynthetic()) { return null; } else { return declaredField; } } } return null; }
@Override public String toString() { return fd.getDeclaringType() + "." + fd.getName()+" : "+fd.getSignature(); } }
private FieldDeclaration createField(final FieldDefinition field) { final FieldDeclaration astField = new FieldDeclaration(); final VariableInitializer initializer = new VariableInitializer(field.getName()); astField.setName(field.getName()); astField.addChild(initializer, Roles.VARIABLE); astField.setReturnType(convertType(field.getFieldType())); astField.putUserData(Keys.FIELD_DEFINITION, field); astField.putUserData(Keys.MEMBER_REFERENCE, field); EntityDeclaration.setModifiers( astField, Flags.asModifierSet(scrubAccessModifiers(field.getFlags() & Flags.VarFlags)) ); if (field.hasConstantValue()) { initializer.setInitializer(new PrimitiveExpression(Expression.MYSTERY_OFFSET, field.getConstantValue())); initializer.putUserData(Keys.FIELD_DEFINITION, field); initializer.putUserData(Keys.MEMBER_REFERENCE, field); } for (final CustomAnnotation annotation : field.getAnnotations()) { astField.getAnnotations().add(createAnnotation(annotation)); } return astField; }
private static boolean isSwitchMapField(final FieldReference field) { if (field == null) { return false; } final FieldDefinition definition = field instanceof FieldDefinition ? (FieldDefinition) field : field.resolve(); return definition != null && definition.isSynthetic() && definition.isStatic() && definition.isPrivate() && StringUtilities.startsWith(definition.getName(), "$SWITCH_TABLE$") && MetadataResolver.areEquivalent(BuiltinTypes.Integer.makeArrayType(), definition.getFieldType()); }
protected StringBuilder appendErasedDescription(final StringBuilder sb) { StringBuilder s = sb; for (final Modifier modifier : Flags.asModifierSet(getModifiers())) { s.append(modifier.toString()); s.append(' '); } s = getFieldType().getRawType().appendErasedDescription(s); s.append(' '); s.append(getName()); return s; }
@FieldVisitor public void visit(FieldContext fc, FieldDefinition fd, TypeDefinition td, FieldStats fs) { if(fd.isSynthetic() || fd.isEnumConstant()) return; int flags = fs.getFlags(fd); boolean isConstantType = fd.getFieldType().isPrimitive() || Types.isString(fd.getFieldType()); if(!Flags.testAny(flags, FieldStats.ACCESS)) { if(fd.isStatic() && fd.isFinal() && isConstantType) return; if(fd.getName().equals("lengthOfMatch") && td.getName().endsWith("TokenManager")) return; fc.report(fd.isPublic() || fd.isProtected() ? "UnusedPublicField" : "UnusedPrivateField", fd.isPublic() ? 5 : 0); return; FieldRecord fieldRecord = fields.get(fd.getName()); if (fieldRecord != null && !fd.isStatic() && fd.isFinal() && fieldRecord.constant != null) { fc.report("FieldShouldBeStatic", 0, fieldRecord.firstWrite.getAnnotations()); return; if(fd.getName().startsWith("jj") && td.getName().endsWith("TokenManager")) return; if(fd.getName().equals("errorCode") && td.getSimpleName().equals("TokenMgrError")) return; int priority = 0; String warningType = fd.isPublic() || fd.isProtected() ? "UnreadPublicField" : "UnreadPrivateField"; if(fd.isPublic()) { priority += 5; if(fd.isFinal()) {
right instanceof ArrayCreationExpression)) { final String fieldName = resolvedField.getName(); if (resolvedField.isEnumConstant() && right instanceof ObjectCreationExpression && MetadataResolver.areEquivalent(currentType, resolvedField.getFieldType())) { else if (resolvedField.isSynthetic() && !context.getSettings().getShowSyntheticMembers() && matchesValuesField(resolvedField) && MetadataResolver.areEquivalent(currentType.makeArrayType(), resolvedField.getFieldType())) {
if (f.isStatic() && f.isFinal() && !f.hasConstantValue()) { nv.addExistingName(f.getName());
@Override protected StringBuilder appendName(final StringBuilder sb, final boolean fullName, final boolean dottedName) { if (fullName) { final TypeDefinition declaringType = getDeclaringType(); if (declaringType != null) { return declaringType.appendName(sb, true, false).append('.').append(getName()); } } return sb.append(_name); }
@Override public boolean equals(final Object obj) { if (obj instanceof FieldDefinition) { final FieldDefinition other = (FieldDefinition) obj; return StringUtilities.equals(getName(), other.getName()) && typeNamesMatch(getDeclaringType(), other.getDeclaringType()); } return false; }
private boolean checkWrite(FieldContext fc, FieldDefinition fd, TypeDefinition td, FieldRecord fieldRecord, int flags, boolean isConstantType) { if(!Flags.testAny(flags, FieldStats.WRITE)) { if(fd.isStatic() && fd.isFinal() && isConstantType) return false; WarningAnnotation<?>[] anno = {}; int priority = 0; String warningType = fd.isPublic() || fd.isProtected() ? "UnwrittenPublicField" : "UnwrittenPrivateField"; if (fieldRecord != null && fieldRecord.firstRead != null) { anno = fieldRecord.firstRead.getAnnotations(); } if(fd.isPublic()) { priority += 5; } priority += tweakForSerialization(fd, td); if(fd.getFieldType().getSimpleType() == JvmType.Boolean) { priority += 5; } if(fd.getName().equalsIgnoreCase("debug")) { priority += 5; } fc.report(warningType, priority, anno); return true; } return false; }
void setStaticFinalFields(Frame frame) { frame.fieldValues.forEach((mi, expr) -> { FieldDefinition fd = fields.get(mi); if(fd != null && fd.isStatic() && (fd.isFinal() || (fd.isPrivate() || fd.isPackagePrivate()) && initializedInCtor.contains(fd))) { values.put(mi, expr); } }); }
expr.getCode() == AstCode.GetField || expr.getCode() == AstCode.GetStatic) { FieldDefinition fd = ((FieldReference) expr.getOperand()).resolve(); if(fd != null && !fd.isSynthetic() && fd.getDeclaringType().isEquivalentTo(td)) { FieldRecord fieldRecord = fields.computeIfAbsent(fd.getName(), n -> new FieldRecord()); if(Nodes.isFieldRead(expr)) { if(fieldRecord.firstRead == null) { if(fd.getFieldType().isArray() || value.getInferredType() != null && value.getInferredType().isArray()) { fieldRecord.array = true; if (!isEmptyArray(value)) { if(m.isKnownMutable(fd.getFieldType())) { fieldRecord.mutable = true;
@FieldVisitor public void visitField(FieldDefinition fd, FieldContext fc) { if(fd.getName().equals("serialVersionUID")) { if(!fd.isFinal()) { fc.report("SerialVersionUidNotFinal", 0); } if(!fd.isStatic()) { fc.report("SerialVersionUidNotStatic", 0); } if(fd.getFieldType().getSimpleType() == JvmType.Integer) { fc.report("SerialVersionUidNotLong", 0); } } } }
private void checkSingleMethod(FieldContext fc, FieldDefinition fd, FieldRecord fieldRecord, int flags) { if (fullyAnalyzed && Flags.testAny(flags, FieldStats.READ) && !Flags.testAny(flags, FieldStats.READ_PACKAGE | FieldStats.READ_OUTSIDE | FieldStats.WRITE_PACKAGE | FieldStats.WRITE_OUTSIDE) && fieldRecord != null && fieldRecord.usedInSingleMethod && fieldRecord.firstWrite != null) { // javacc-generated if(fd.getName().startsWith("jj_") && fd.getDeclaringType().getSimpleName().endsWith("Parser") && fieldRecord.firstWrite.md.getName().equals("generateParseException")) return; int priority = AccessLevel.of(fd).select(10, 3, 1, 0); if(!fd.isStatic()) priority += 5; if(fieldRecord.firstWrite.md.isConstructor()) priority += 5; if(fd.getFieldType().isPrimitive()) priority += 3; fc.report("FieldUsedInSingleMethod", priority, fieldRecord.firstWrite.getAnnotations()); } }
@Override public Void visitFieldDeclaration(final FieldDeclaration node, final Void data) { final TypeDefinition currentType = context.getCurrentType(); if (currentType != null && currentType.isEnum()) { final FieldDefinition field = node.getUserData(Keys.FIELD_DEFINITION); if (field != null) { if (field.isEnumConstant()) { _valueFields.put(field.getName(), node); } } } return super.visitFieldDeclaration(node, data); }
public final boolean isPrivate() { return Flags.testAny(getFlags(), Flags.PRIVATE); }
private boolean checkNull(FieldContext fc, FieldDefinition fd, TypeDefinition td, FieldRecord fieldRecord, int flags) { if(!Flags.testAny(flags, FieldStats.WRITE_NONNULL) && Flags.testAny(flags, FieldStats.READ)) { int priority = 0; if(fd.isFinal() && fd.isStatic()) { priority += 20; String lcName = fd.getName().toLowerCase(Locale.ENGLISH); if (lcName.contains("null") || lcName.contains("zero") || lcName.contains("empty")) { priority += 15; } } else if(fd.isPublic()) { priority += 10; } priority += tweakForSerialization(fd, td); fc.report("FieldIsAlwaysNull", priority, getWriteAnnotations(fieldRecord)); return true; } return false; }
@FieldVisitor public void visitField(FieldDefinition fd, FieldContext fc, TypeDefinition td) { if((fd.isPublic() || fd.isProtected()) && (td.isPublic() || td.isProtected()) && fd.isStatic() && !fd.isEnumConstant()) { TypeReference fieldType = fd.getFieldType(); if(!isNotThreadSafe(fieldType)) return; fc.report("StaticNotThreadSafeField", AccessLevel.of(fd).select(0, 20, 100, 100), Roles.FIELD_TYPE.create(fieldType)); } }
final TypeReference valueType = field.getDeclaringType().getResolver().lookupType(typeDescriptor); output.writeAttribute("Signature"); output.write(": "); DecompilerHelpers.writeType(output, field.getFieldType(), NameSyntax.SIGNATURE, false); output.writeLine(); break;