private Statement createConstructorStatement(
ClassNode cNode,
PropertyNode pNode,
List<String> knownImmutableClasses,
List<String> knownImmutables) {
FieldNode fNode = pNode.getField();
final ClassNode fieldType = fNode.getType();
Statement statement = null;
if (fieldType.isArray() || isOrImplements(fieldType, CLONEABLE_TYPE)) {
statement = createConstructorStatementArrayOrCloneable(fNode);
} else if (isKnownImmutableClass(fieldType, knownImmutableClasses)
|| isKnownImmutable(pNode.getName(), knownImmutables)) {
statement = createConstructorStatementDefault(fNode);
} else if (fieldType.isDerivedFrom(DATE_TYPE)) {
statement = createConstructorStatementDate(fNode);
} else if (isOrImplements(fieldType, COLLECTION_TYPE)
|| fieldType.isDerivedFrom(COLLECTION_TYPE)
|| isOrImplements(fieldType, MAP_TYPE)
|| fieldType.isDerivedFrom(MAP_TYPE)) {
statement = createConstructorStatementCollection(fNode);
} else if (fieldType.isResolved()) {
addError(
createErrorMessage(cNode.getName(), fNode.getName(), fieldType.getName(), "compiling"),
fNode);
statement = EmptyStatement.INSTANCE;
} else {
statement = createConstructorStatementGuarded(cNode, fNode);
}
return statement;
}
public PropertyNode addProperty(
String name,
int modifiers,
ClassNode type,
Expression initialValueExpression,
Statement getterBlock,
Statement setterBlock) {
for (PropertyNode pn : getProperties()) {
if (pn.getName().equals(name)) {
if (pn.getInitialExpression() == null && initialValueExpression != null)
pn.getField().setInitialValueExpression(initialValueExpression);
if (pn.getGetterBlock() == null && getterBlock != null) pn.setGetterBlock(getterBlock);
if (pn.getSetterBlock() == null && setterBlock != null) pn.setSetterBlock(setterBlock);
return pn;
}
}
PropertyNode node =
new PropertyNode(
name, modifiers, type, redirect(), initialValueExpression, getterBlock, setterBlock);
addProperty(node);
return node;
}
public void addProperty(PropertyNode node) {
node.setDeclaringClass(redirect());
FieldNode field = node.getField();
addField(field);
final ClassNode r = redirect();
if (r.properties == null) r.properties = new ArrayList<PropertyNode>();
r.properties.add(node);
}
private void createConstructorOrdered(ClassNode cNode, List<PropertyNode> list) {
final MapExpression argMap = new MapExpression();
final Parameter[] orderedParams = new Parameter[list.size()];
int index = 0;
for (PropertyNode pNode : list) {
Parameter param = new Parameter(pNode.getField().getType(), pNode.getField().getName());
orderedParams[index++] = param;
argMap.addMapEntryExpression(
new ConstantExpression(pNode.getName()), new VariableExpression(pNode.getName()));
}
final BlockStatement orderedBody = new BlockStatement();
orderedBody.addStatement(
new ExpressionStatement(
new ConstructorCallExpression(
ClassNode.THIS,
new ArgumentListExpression(new CastExpression(HASHMAP_TYPE, argMap)))));
doAddConstructor(
cNode, new ConstructorNode(ACC_PUBLIC, orderedParams, ClassNode.EMPTY_ARRAY, orderedBody));
}
private void addProperty(ClassNode cNode, PropertyNode pNode) {
final FieldNode fn = pNode.getField();
cNode.getFields().remove(fn);
cNode.addProperty(
pNode.getName(),
pNode.getModifiers() | ACC_FINAL,
pNode.getType(),
pNode.getInitialExpression(),
pNode.getGetterBlock(),
pNode.getSetterBlock());
final FieldNode newfn = cNode.getField(fn.getName());
cNode.getFields().remove(newfn);
cNode.addField(fn);
}
private Variable findClassMember(ClassNode cn, String name) {
if (cn == null) return null;
if (cn.isScript()) {
return new DynamicVariable(name, false);
}
for (FieldNode fn : cn.getFields()) {
if (fn.getName().equals(name)) return fn;
}
for (MethodNode mn : cn.getMethods()) {
String pName = getPropertyName(mn);
// GRECLIPSE: start
// must set the declaringClass
/*old{
if (pName != null && pName.equals(name))
return new PropertyNode(pName, mn.getModifiers(), getPropertyType(mn), cn, null, null, null);
*/
// newcode
if (pName != null && pName.equals(name)) {
PropertyNode property =
new PropertyNode(pName, mn.getModifiers(), getPropertyType(mn), cn, null, null, null);
property.setDeclaringClass(cn);
property.getField().setDeclaringClass(cn);
return property;
}
// GRECLIPSE: end
}
for (PropertyNode pn : cn.getProperties()) {
if (pn.getName().equals(name)) return pn;
}
Variable ret = findClassMember(cn.getSuperClass(), name);
if (ret != null) return ret;
return findClassMember(cn.getOuterClass(), name);
}
private void adjustPropertyForImmutability(PropertyNode pNode, List<PropertyNode> newNodes) {
final FieldNode fNode = pNode.getField();
fNode.setModifiers((pNode.getModifiers() & (~ACC_PUBLIC)) | ACC_FINAL | ACC_PRIVATE);
adjustPropertyNode(pNode, createGetterBody(fNode));
newNodes.add(pNode);
}