@Override
public void makeGetPropertySite(
Expression receiver,
final String methodName,
final boolean safe,
final boolean implicitThis) {
Object dynamic =
receiver.getNodeMetaData(StaticCompilationMetadataKeys.RECEIVER_OF_DYNAMIC_PROPERTY);
if (dynamic != null) {
MethodNode target =
safe ? INVOKERHELPER_GETPROPERTYSAFE_METHOD : INVOKERHELPER_GETPROPERTY_METHOD;
MethodCallExpression mce =
new MethodCallExpression(
new ClassExpression(INVOKERHELPER_TYPE),
target.getName(),
new ArgumentListExpression(receiver, new ConstantExpression(methodName)));
mce.setSafe(false);
mce.setImplicitThis(false);
mce.setMethodTarget(target);
mce.visit(controller.getAcg());
return;
}
TypeChooser typeChooser = controller.getTypeChooser();
ClassNode classNode = controller.getClassNode();
ClassNode receiverType =
(ClassNode) receiver.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER);
if (receiverType == null) {
receiverType = typeChooser.resolveType(receiver, classNode);
}
Object type = receiver.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
if (type == null && receiver instanceof VariableExpression) {
Variable variable = ((VariableExpression) receiver).getAccessedVariable();
if (variable instanceof Expression) {
type = ((Expression) variable).getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
}
}
if (type != null) {
// in case a "flow type" is found, it is preferred to use it instead of
// the declaration type
receiverType = (ClassNode) type;
}
boolean isClassReceiver = false;
if (isClassClassNodeWrappingConcreteType(receiverType)) {
isClassReceiver = true;
receiverType = receiverType.getGenericsTypes()[0].getType();
}
MethodVisitor mv = controller.getMethodVisitor();
if (receiverType.isArray() && methodName.equals("length")) {
receiver.visit(controller.getAcg());
ClassNode arrayGetReturnType = typeChooser.resolveType(receiver, classNode);
controller.getOperandStack().doGroovyCast(arrayGetReturnType);
mv.visitInsn(ARRAYLENGTH);
controller.getOperandStack().replace(int_TYPE);
return;
} else if ((receiverType.implementsInterface(COLLECTION_TYPE)
|| COLLECTION_TYPE.equals(receiverType))
&& ("size".equals(methodName) || "length".equals(methodName))) {
MethodCallExpression expr =
new MethodCallExpression(receiver, "size", ArgumentListExpression.EMPTY_ARGUMENTS);
expr.setMethodTarget(COLLECTION_SIZE_METHOD);
expr.setImplicitThis(implicitThis);
expr.setSafe(safe);
expr.visit(controller.getAcg());
return;
}
if (makeGetPropertyWithGetter(receiver, receiverType, methodName, safe, implicitThis)) return;
if (makeGetField(
receiver,
receiverType,
methodName,
implicitThis,
samePackages(receiverType.getPackageName(), classNode.getPackageName()))) return;
if (receiverType.isEnum()) {
mv.visitFieldInsn(
GETSTATIC,
BytecodeHelper.getClassInternalName(receiverType),
methodName,
BytecodeHelper.getTypeDescription(receiverType));
controller.getOperandStack().push(receiverType);
return;
}
if (receiver instanceof ClassExpression) {
if (makeGetField(
receiver,
receiver.getType(),
methodName,
implicitThis,
samePackages(receiver.getType().getPackageName(), classNode.getPackageName()))) return;
if (makeGetPropertyWithGetter(receiver, receiver.getType(), methodName, safe, implicitThis))
return;
if (makeGetPrivateFieldWithBridgeMethod(
receiver, receiver.getType(), methodName, safe, implicitThis)) return;
}
if (isClassReceiver) {
// we are probably looking for a property of the class
if (makeGetPropertyWithGetter(receiver, CLASS_Type, methodName, safe, implicitThis)) return;
if (makeGetField(receiver, CLASS_Type, methodName, false, true)) return;
}
if (makeGetPrivateFieldWithBridgeMethod(receiver, receiverType, methodName, safe, implicitThis))
return;
// GROOVY-5580, it is still possible that we're calling a superinterface property
String getterName = "get" + MetaClassHelper.capitalize(methodName);
if (receiverType.isInterface()) {
Set<ClassNode> allInterfaces = receiverType.getAllInterfaces();
MethodNode getterMethod = null;
for (ClassNode anInterface : allInterfaces) {
getterMethod = anInterface.getGetterMethod(getterName);
if (getterMethod != null) break;
}
// GROOVY-5585
if (getterMethod == null) {
getterMethod = OBJECT_TYPE.getGetterMethod(getterName);
}
if (getterMethod != null) {
MethodCallExpression call =
new MethodCallExpression(receiver, getterName, ArgumentListExpression.EMPTY_ARGUMENTS);
call.setMethodTarget(getterMethod);
call.setImplicitThis(false);
call.setSourcePosition(receiver);
call.visit(controller.getAcg());
return;
}
}
// GROOVY-5568, we would be facing a DGM call, but instead of foo.getText(), have foo.text
List<MethodNode> methods =
findDGMMethodsByNameAndArguments(
controller.getSourceUnit().getClassLoader(),
receiverType,
getterName,
ClassNode.EMPTY_ARRAY);
if (!methods.isEmpty()) {
List<MethodNode> methodNodes = chooseBestMethod(receiverType, methods, ClassNode.EMPTY_ARRAY);
if (methodNodes.size() == 1) {
MethodNode getter = methodNodes.get(0);
MethodCallExpression call =
new MethodCallExpression(receiver, getterName, ArgumentListExpression.EMPTY_ARGUMENTS);
call.setMethodTarget(getter);
call.setImplicitThis(false);
call.setSourcePosition(receiver);
call.visit(controller.getAcg());
return;
}
}
boolean isStaticProperty =
receiver instanceof ClassExpression
&& (receiverType.isDerivedFrom(receiver.getType())
|| receiverType.implementsInterface(receiver.getType()));
if (!isStaticProperty) {
if (receiverType.implementsInterface(MAP_TYPE) || MAP_TYPE.equals(receiverType)) {
// for maps, replace map.foo with map.get('foo')
writeMapDotProperty(receiver, methodName, mv, safe);
return;
}
if (receiverType.implementsInterface(LIST_TYPE) || LIST_TYPE.equals(receiverType)) {
writeListDotProperty(receiver, methodName, mv, safe);
return;
}
}
controller
.getSourceUnit()
.addError(
new SyntaxException(
"Access to "
+ (receiver instanceof ClassExpression ? receiver.getType() : receiverType)
.toString(false)
+ "#"
+ methodName
+ " is forbidden",
receiver.getLineNumber(),
receiver.getColumnNumber(),
receiver.getLastLineNumber(),
receiver.getLastColumnNumber()));
controller.getMethodVisitor().visitInsn(ACONST_NULL);
controller.getOperandStack().push(OBJECT_TYPE);
}
private boolean trySubscript(
final Expression receiver,
final String message,
final Expression arguments,
ClassNode rType,
final ClassNode aType) {
if (getWrapper(rType).isDerivedFrom(Number_TYPE)
&& getWrapper(aType).isDerivedFrom(Number_TYPE)) {
if ("plus".equals(message)
|| "minus".equals(message)
|| "multiply".equals(message)
|| "div".equals(message)) {
writeNumberNumberCall(receiver, message, arguments);
return true;
} else if ("power".equals(message)) {
writePowerCall(receiver, arguments, rType, aType);
return true;
} else if ("mod".equals(message)) {
writeModCall(receiver, arguments, rType, aType);
return true;
}
} else if (STRING_TYPE.equals(rType) && "plus".equals(message)) {
writeStringPlusCall(receiver, message, arguments);
return true;
} else if ("getAt".equals(message)) {
if (rType.isArray() && getWrapper(aType).isDerivedFrom(Number_TYPE)) {
writeArrayGet(receiver, arguments, rType, aType);
return true;
} else {
// check if a getAt method can be found on the receiver
ClassNode current = rType;
MethodNode getAtNode = null;
while (current != null && getAtNode == null) {
getAtNode = current.getMethod("getAt", new Parameter[] {new Parameter(aType, "index")});
if (getAtNode == null && isPrimitiveType(aType)) {
getAtNode =
current.getMethod(
"getAt", new Parameter[] {new Parameter(getWrapper(aType), "index")});
} else if (getAtNode == null && aType.isDerivedFrom(Number_TYPE)) {
getAtNode =
current.getMethod(
"getAt", new Parameter[] {new Parameter(getUnwrapper(aType), "index")});
}
current = current.getSuperClass();
}
if (getAtNode != null) {
MethodCallExpression call = new MethodCallExpression(receiver, "getAt", arguments);
call.setSourcePosition(arguments);
call.setImplicitThis(false);
call.setMethodTarget(getAtNode);
call.visit(controller.getAcg());
return true;
}
// make sure Map#getAt() and List#getAt handled with the bracket syntax are properly
// compiled
ClassNode[] args = {aType};
boolean acceptAnyMethod =
MAP_TYPE.equals(rType)
|| rType.implementsInterface(MAP_TYPE)
|| LIST_TYPE.equals(rType)
|| rType.implementsInterface(LIST_TYPE);
List<MethodNode> nodes =
StaticTypeCheckingSupport.findDGMMethodsByNameAndArguments(
controller.getSourceUnit().getClassLoader(), rType, message, args);
if (nodes.isEmpty()) {
// retry with raw types
rType = rType.getPlainNodeReference();
nodes =
StaticTypeCheckingSupport.findDGMMethodsByNameAndArguments(
controller.getSourceUnit().getClassLoader(), rType, message, args);
}
nodes = StaticTypeCheckingSupport.chooseBestMethod(rType, nodes, args);
if (nodes.size() == 1 || nodes.size() > 1 && acceptAnyMethod) {
MethodNode methodNode = nodes.get(0);
MethodCallExpression call = new MethodCallExpression(receiver, message, arguments);
call.setSourcePosition(arguments);
call.setImplicitThis(false);
call.setMethodTarget(methodNode);
call.visit(controller.getAcg());
return true;
}
if (implementsInterfaceOrIsSubclassOf(rType, MAP_TYPE)) {
// fallback to Map#get
MethodCallExpression call = new MethodCallExpression(receiver, "get", arguments);
call.setMethodTarget(MAP_GET_METHOD);
call.setSourcePosition(arguments);
call.setImplicitThis(false);
call.visit(controller.getAcg());
return true;
}
}
}
return false;
}
