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 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 boolean hasStaticProperty(ClassNode staticImportType, String propName) {
ClassNode classNode = staticImportType;
while (classNode != null) {
for (PropertyNode pn : classNode.getProperties()) {
if (pn.getName().equals(propName) && pn.isStatic()) return true;
}
classNode = classNode.getSuperClass();
}
return false;
}
/**
* Returns whether a classNode has the specified property or not
*
* @param classNode The ClassNode
* @param propertyName The name of the property
* @return True if the property exists in the ClassNode
*/
public static boolean hasProperty(ClassNode classNode, String propertyName) {
if (classNode == null || propertyName == null || "".equals(propertyName.trim())) return false;
List properties = classNode.getProperties();
for (Iterator i = properties.iterator(); i.hasNext(); ) {
PropertyNode pn = (PropertyNode) i.next();
if (pn.getName().equals(propertyName)) return true;
}
return false;
}
private void injectAssociationProperties(ClassNode classNode, List propertiesToAdd) {
for (Iterator i = propertiesToAdd.iterator(); i.hasNext(); ) {
PropertyNode pn = (PropertyNode) i.next();
if (! /*GrailsASTUtils.*/hasProperty(classNode, pn.getName())) {
// if(LOG.isDebugEnabled()) {
// LOG.debug("[GrailsDomainInjector] Adding property [" + pn.getName() + "] to class [" +
// classNode.getName() + "]");
// }
classNode.addProperty(pn);
}
}
}
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;
}
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 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 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 void injectAssociations(ClassNode classNode) {
List properties = classNode.getProperties();
List propertiesToAdd = new ArrayList();
for (Iterator p = properties.iterator(); p.hasNext(); ) {
PropertyNode pn = (PropertyNode) p.next();
final boolean isHasManyProperty =
pn.getName().equals(/*GrailsDomainClassProperty.*/ RELATES_TO_MANY)
|| pn.getName().equals(/*GrailsDomainClassProperty.*/ HAS_MANY);
if (isHasManyProperty) {
Expression e = pn.getInitialExpression();
propertiesToAdd.addAll(createPropertiesForHasManyExpression(e, classNode));
}
final boolean isBelongsTo = pn.getName().equals(/*GrailsDomainClassProperty.*/ BELONGS_TO);
if (isBelongsTo) {
Expression e = pn.getInitialExpression();
propertiesToAdd.addAll(createPropertiesForBelongsToExpression(e, classNode));
}
}
injectAssociationProperties(classNode, propertiesToAdd);
}
private void adjustPropertyNode(PropertyNode pNode, Statement getterBody) {
pNode.setSetterBlock(null);
pNode.setGetterBlock(getterBody);
}
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);
}
private boolean makeGetPropertyWithGetter(
final Expression receiver,
final ClassNode receiverType,
final String methodName,
final boolean safe,
final boolean implicitThis) {
// does a getter exists ?
String getterName = "get" + MetaClassHelper.capitalize(methodName);
MethodNode getterNode = receiverType.getGetterMethod(getterName);
if (getterNode == null) {
getterName = "is" + MetaClassHelper.capitalize(methodName);
getterNode = receiverType.getGetterMethod(getterName);
}
if (getterNode != null
&& receiver instanceof ClassExpression
&& !CLASS_Type.equals(receiverType)
&& !getterNode.isStatic()) {
return false;
}
// GROOVY-5561: if two files are compiled in the same source unit
// and that one references the other, the getters for properties have not been
// generated by the compiler yet (generated by the Verifier)
PropertyNode propertyNode = receiverType.getProperty(methodName);
if (propertyNode != null) {
// it is possible to use a getter
String prefix = "get";
if (boolean_TYPE.equals(propertyNode.getOriginType())) {
prefix = "is";
}
getterName = prefix + MetaClassHelper.capitalize(methodName);
getterNode =
new MethodNode(
getterName,
ACC_PUBLIC,
propertyNode.getOriginType(),
Parameter.EMPTY_ARRAY,
ClassNode.EMPTY_ARRAY,
EmptyStatement.INSTANCE);
getterNode.setDeclaringClass(receiverType);
if (propertyNode.isStatic()) getterNode.setModifiers(ACC_PUBLIC + ACC_STATIC);
}
if (getterNode != null) {
MethodCallExpression call =
new MethodCallExpression(receiver, getterName, ArgumentListExpression.EMPTY_ARGUMENTS);
call.setSourcePosition(receiver);
call.setMethodTarget(getterNode);
call.setImplicitThis(implicitThis);
call.setSafe(safe);
call.visit(controller.getAcg());
return true;
}
if (receiverType instanceof InnerClassNode && !receiverType.isStaticClass()) {
if (makeGetPropertyWithGetter(
receiver, receiverType.getOuterClass(), methodName, safe, implicitThis)) {
return true;
}
}
// go upper level
ClassNode superClass = receiverType.getSuperClass();
if (superClass != null) {
return makeGetPropertyWithGetter(receiver, superClass, methodName, safe, implicitThis);
}
return false;
}
public void visitProperty(PropertyNode node) {
pushState(node.isStatic());
super.visitProperty(node);
popState();
}
public PropertyNode getProperty(String name) {
for (PropertyNode pn : getProperties()) {
if (pn.getName().equals(name)) return pn;
}
return null;
}
