@Override
public void makeSingleArgumentCall(
final Expression receiver, final String message, final Expression arguments) {
TypeChooser typeChooser = controller.getTypeChooser();
ClassNode classNode = controller.getClassNode();
ClassNode rType = typeChooser.resolveType(receiver, classNode);
ClassNode aType = typeChooser.resolveType(arguments, classNode);
if (trySubscript(receiver, message, arguments, rType, aType)) {
return;
}
// new try with flow type instead of declaration type
rType = receiver.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
if (rType != null && trySubscript(receiver, message, arguments, rType, aType)) {
return;
}
// todo: more cases
throw new GroovyBugError(
"At line "
+ receiver.getLineNumber()
+ " column "
+ receiver.getColumnNumber()
+ "\n"
+ "On receiver: "
+ receiver.getText()
+ " with message: "
+ message
+ " and arguments: "
+ arguments.getText()
+ "\n"
+ "This method should not have been called. Please try to create a simple example reproducing this error and file"
+ "a bug report at http://jira.codehaus.org/browse/GROOVY");
}
private Expression transformMapEntryExpression(
MapEntryExpression me, ClassNode constructorCallType) {
Expression key = me.getKeyExpression();
Expression value = me.getValueExpression();
ModuleNode module = currentClass.getModule();
if (module != null && key instanceof ConstantExpression) {
Map<String, ImportNode> importNodes = module.getStaticImports();
if (importNodes.containsKey(key.getText())) {
ImportNode importNode = importNodes.get(key.getText());
if (importNode.getType().equals(constructorCallType)) {
String newKey = importNode.getFieldName();
return new MapEntryExpression(
new ConstantExpression(newKey), value.transformExpression(this));
}
}
}
return me;
}
private List createPropertiesForHasManyExpression(Expression e, ClassNode classNode) {
List properties = new ArrayList();
if (e instanceof MapExpression) {
MapExpression me = (MapExpression) e;
List mapEntries = me.getMapEntryExpressions();
for (Iterator j = mapEntries.iterator(); j.hasNext(); ) {
MapEntryExpression mee = (MapEntryExpression) j.next();
Expression keyExpression = mee.getKeyExpression();
String key = keyExpression.getText();
addAssociationForKey(key, properties, classNode);
}
}
return properties;
}
public String getText() {
StringBuilder buffer = new StringBuilder("(");
boolean first = true;
for (Expression expression : expressions) {
if (first) {
first = false;
} else {
buffer.append(", ");
}
buffer.append(expression.getText());
}
buffer.append(")");
return buffer.toString();
}
public String getText() {
return "*" + expression.getText();
}
protected Expression transformMethodCallExpression(MethodCallExpression mce) {
Expression args = transform(mce.getArguments());
Expression method = transform(mce.getMethod());
Expression object = transform(mce.getObjectExpression());
boolean isExplicitThisOrSuper = false;
if (object instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) object;
isExplicitThisOrSuper =
!mce.isImplicitThis() && (ve.getName().equals("this") || ve.getName().equals("super"));
}
if (mce.isImplicitThis() || isExplicitThisOrSuper) {
if (mce.isImplicitThis()) {
Expression ret = findStaticMethodImportFromModule(method, args);
if (ret != null) {
// GRECLIPSE add
if (!((StaticMethodCallExpression) ret).getMethod().equals(method.getText())) {
// store the identifier to facilitate organizing static imports
ret.setNodeMetaData("static.import.alias", method.getText());
}
// GRECLIPSE end
setSourcePosition(ret, mce);
return ret;
}
if (method instanceof ConstantExpression && !inLeftExpression) {
// could be a closure field
String methodName = (String) ((ConstantExpression) method).getValue();
ret = findStaticFieldOrPropAccessorImportFromModule(methodName);
if (ret != null) {
ret = new MethodCallExpression(ret, "call", args);
setSourcePosition(ret, mce);
return ret;
}
}
}
if (method instanceof ConstantExpression) {
ConstantExpression ce = (ConstantExpression) method;
Object value = ce.getValue();
if (value instanceof String) {
String methodName = (String) value;
boolean lookForPossibleStaticMethod = !methodName.equals("call");
if (currentMethod != null && !currentMethod.isStatic()) {
if (currentClass.hasPossibleMethod(methodName, args)) {
lookForPossibleStaticMethod = false;
}
}
if (inSpecialConstructorCall
|| (lookForPossibleStaticMethod
&& currentClass.hasPossibleStaticMethod(methodName, args))) {
StaticMethodCallExpression smce =
new StaticMethodCallExpression(currentClass, methodName, args);
setSourcePosition(smce, mce);
return smce;
}
}
}
}
MethodCallExpression result = new MethodCallExpression(object, method, args);
result.setSafe(mce.isSafe());
result.setImplicitThis(mce.isImplicitThis());
result.setSpreadSafe(mce.isSpreadSafe());
result.setMethodTarget(mce.getMethodTarget());
// GROOVY-6757
result.setGenericsTypes(mce.getGenericsTypes());
setSourcePosition(result, mce);
return result;
}
public String getText() {
return "(" + from.getText() + (!isInclusive() ? "..<" : "..") + to.getText() + ")";
}