private Expression findConstant(FieldNode fn) {
if (fn != null && !fn.isEnum() && fn.isStatic() && fn.isFinal()) {
if (fn.getInitialValueExpression() instanceof ConstantExpression) {
return fn.getInitialValueExpression();
}
}
return null;
}
@SuppressWarnings("RedundantIfStatement")
boolean shouldFieldBeIgnored(FieldNode fieldNode) {
if (fieldNode == keyField) return true;
if (fieldNode == ownerField) return true;
if (getAnnotation(fieldNode, IGNORE_ANNOTATION) != null) return true;
if (fieldNode.isFinal()) return true;
if (fieldNode.getName().startsWith("$")) return true;
if ((fieldNode.getModifiers() & ACC_TRANSIENT) != 0) return true;
return false;
}
private void createConstructorMapCommon(ClassNode cNode, BlockStatement body) {
final List<FieldNode> fList = cNode.getFields();
for (FieldNode fNode : fList) {
if (fNode.isPublic()) continue; // public fields will be rejected elsewhere
if (cNode.getProperty(fNode.getName()) != null) continue; // a property
if (fNode.isFinal() && fNode.isStatic()) continue;
if (fNode.getName().contains("$")) continue; // internal field
if (fNode.isFinal() && fNode.getInitialExpression() != null)
body.addStatement(checkFinalArgNotOverridden(cNode, fNode));
body.addStatement(createConstructorStatementDefault(fNode));
}
final Parameter[] params = new Parameter[] {new Parameter(HASHMAP_TYPE, "args")};
doAddConstructor(
cNode,
new ConstructorNode(
ACC_PUBLIC,
params,
ClassNode.EMPTY_ARRAY,
new IfStatement(
equalsNullExpr(new VariableExpression("args")), new EmptyStatement(), body)));
}
private void ensureNotPublic(String cNode, FieldNode fNode) {
String fName = fNode.getName();
// TODO: do we need to lock down things like: $ownClass
if (fNode.isPublic() && !fName.contains("$") && !(fNode.isStatic() && fNode.isFinal())) {
addError(
"Public field '"
+ fName
+ "' not allowed for "
+ MY_TYPE_NAME
+ " class '"
+ cNode
+ "'.",
fNode);
}
}
private void printField(PrintWriter out, FieldNode fieldNode, boolean isInterface) {
if ((fieldNode.getModifiers() & Opcodes.ACC_PRIVATE) != 0) return;
printAnnotations(out, fieldNode);
if (!isInterface) {
printModifiers(out, fieldNode.getModifiers());
}
ClassNode type = fieldNode.getType();
printType(out, type);
out.print(" ");
out.print(fieldNode.getName());
if (isInterface || (fieldNode.getModifiers() & Opcodes.ACC_FINAL) != 0) {
out.print(" = ");
Expression valueExpr = fieldNode.getInitialValueExpression();
if (valueExpr instanceof ConstantExpression) {
valueExpr = Verifier.transformToPrimitiveConstantIfPossible((ConstantExpression) valueExpr);
}
if (valueExpr instanceof ConstantExpression
&& fieldNode.isStatic()
&& fieldNode.isFinal()
&& ClassHelper.isStaticConstantInitializerType(valueExpr.getType())
&& valueExpr.getType().equals(fieldNode.getType())) {
// GROOVY-5150 : Initialize value with a dummy constant so that Java cross compiles
// correctly
if (ClassHelper.STRING_TYPE.equals(valueExpr.getType())) {
out.print("\"" + escapeSpecialChars(valueExpr.getText()) + "\"");
} else if (ClassHelper.char_TYPE.equals(valueExpr.getType())) {
out.print("'" + valueExpr.getText() + "'");
} else {
ClassNode constantType = valueExpr.getType();
out.print('(');
printType(out, type);
out.print(") ");
out.print(valueExpr.getText());
if (ClassHelper.Long_TYPE.equals(ClassHelper.getWrapper(constantType))) out.print('L');
}
} else if (ClassHelper.isPrimitiveType(type)) {
String val = type == ClassHelper.boolean_TYPE ? "false" : "0";
out.print("new " + ClassHelper.getWrapper(type) + "((" + type + ")" + val + ")");
} else {
out.print("null");
}
}
out.println(";");
}
private void checkFinalFieldAccess(Expression expression) {
if (!(expression instanceof VariableExpression) && !(expression instanceof PropertyExpression))
return;
Variable v = null;
if (expression instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) expression;
v = ve.getAccessedVariable();
} else {
PropertyExpression propExp = ((PropertyExpression) expression);
Expression objectExpression = propExp.getObjectExpression();
if (objectExpression instanceof VariableExpression) {
VariableExpression varExp = (VariableExpression) objectExpression;
if (varExp.isThisExpression()) {
v = currentClass.getDeclaredField(propExp.getPropertyAsString());
}
}
}
if (v instanceof FieldNode) {
FieldNode fn = (FieldNode) v;
/*
* if it is static final but not accessed inside a static constructor, or,
* if it is an instance final but not accessed inside a instance constructor, it is an error
*/
boolean isFinal = fn.isFinal();
boolean isStatic = fn.isStatic();
boolean error =
isFinal && ((isStatic && !inStaticConstructor) || (!isStatic && !inConstructor));
if (error)
addError(
"cannot modify"
+ (isStatic ? " static" : "")
+ " final field '"
+ fn.getName()
+ "' outside of "
+ (isStatic ? "static initialization block." : "constructor."),
expression);
}
}
