public boolean isThisCall() { return getType() == ClassNode.THIS; }
public boolean isSuperCall() { return getType() == ClassNode.SUPER; }
public String toString() { return super.toString() + "[type: " + getType() + " arguments: " + arguments + "]"; }
@Override public void visitConstructorCallExpression(ConstructorCallExpression call) { super.visitConstructorCallExpression(call); addToCache(call.getType()); } }
@Override public void visitConstructorCallExpression(ConstructorCallExpression call) { ClassNode type = call.getType(); boolean isAnon = type instanceof InnerClassNode && ((InnerClassNode) type).isAnonymous(); checkGenericsUsage(type, type.redirect(), isAnon); }
protected Expression transformConstructorCallExpression(ConstructorCallExpression cce) { ClassNode type = cce.getType(); resolveOrFail(type, cce); if (Modifier.isAbstract(type.getModifiers())) { addError("You cannot create an instance from the abstract " + getDescription(type) + ".", cce); } return cce.transformExpression(this); }
protected Expression transformConstructorCallExpression(ConstructorCallExpression cce) { inSpecialConstructorCall = cce.isSpecialCall(); Expression expression = cce.getArguments(); if (expression instanceof TupleExpression) { TupleExpression tuple = (TupleExpression) expression; if (tuple.getExpressions().size() == 1) { expression = tuple.getExpression(0); if (expression instanceof NamedArgumentListExpression) { NamedArgumentListExpression namedArgs = (NamedArgumentListExpression) expression; List<MapEntryExpression> entryExpressions = namedArgs.getMapEntryExpressions(); for (int i = 0; i < entryExpressions.size(); i++) { entryExpressions.set(i, (MapEntryExpression) transformMapEntryExpression(entryExpressions.get(i), cce.getType())); } } } } Expression ret = cce.transformExpression(this); inSpecialConstructorCall = false; return ret; }
public String getText() { String text = null; if (isSuperCall()) { text = "super "; } else if (isThisCall()) { text = "this "; } else { text = "new " + getType().getName(); } return text + arguments.getText(); }
public void visitConstructorCallExpression(ConstructorCallExpression call) { ClassNode callType = call.getType(); if (callType.isEnum() && !callType.equals(verifier.getClassNode())) { throw new RuntimeParserException("Enum constructor calls are only allowed inside the enum class", call); } }
protected void writeNormalConstructorCall(ConstructorCallExpression call) { Expression arguments = call.getArguments(); if (arguments instanceof TupleExpression) { TupleExpression tupleExpression = (TupleExpression) arguments; int size = tupleExpression.getExpressions().size(); if (size == 0) { arguments = MethodCallExpression.NO_ARGUMENTS; } } Expression receiverClass = new ClassExpression(call.getType()); controller.getCallSiteWriter().makeCallSite( receiverClass, CallSiteWriter.CONSTRUCTOR, arguments, false, false, false, false); }
@Override protected void writeNormalConstructorCall(ConstructorCallExpression call) { makeCall(call, new ClassExpression(call.getType()), new ConstantExpression("<init>"), call.getArguments(), null, false, false, false); }
public static Expression getInvocationTarget(Expression expr) { if (expr instanceof PropertyExpression) return ((PropertyExpression) expr).getObjectExpression(); if (expr instanceof MethodCallExpression) return ((MethodCallExpression) expr).getObjectExpression(); if (expr instanceof StaticMethodCallExpression) return new ClassExpression(((StaticMethodCallExpression) expr).getOwnerType()); if (expr instanceof ConstructorCallExpression) return new ClassExpression(((ConstructorCallExpression) expr).getType()); return null; }
@Override public void visitConstructorCallExpression(ConstructorCallExpression expr) { ConstructorCallExpression conversion = new ConstructorCallExpression( expr.getType(), convert(expr.getArguments())); conversion.setSourcePosition(expr); result = record(conversion); }
@Override public void visitConstructorCallExpression(ConstructorCallExpression expr) { ConstructorCallExpression result = new ConstructorCallExpression( expr.getType(), replaceExpr(expr.getArguments())); result.setSourcePosition(expr); replaceVisitedExpressionWith(result); }
public Expression transformExpression(ExpressionTransformer transformer) { Expression args = transformer.transform(arguments); ConstructorCallExpression ret = new ConstructorCallExpression(getType(), args); ret.setSourcePosition(this); ret.setUsingAnonymousInnerClass(isUsingAnonymousInnerClass()); ret.copyNodeMetaData(this); return ret; }
public void visitConstructorCallExpression(ConstructorCallExpression call) { visitNode(call); visitType(call.getType()); super.visitConstructorCallExpression(call); }
private void passThisReference(ConstructorCallExpression call) { ClassNode cn = call.getType().redirect(); if (!shouldHandleImplicitThisForInnerClass(cn)) return; boolean isInStaticContext = true; if (currentMethod != null) isInStaticContext = currentMethod.getVariableScope().isInStaticContext(); else if (currentField != null) isInStaticContext = currentField.isStatic(); else if (processingObjInitStatements) isInStaticContext = false; // if constructor call is not in static context, return if (isInStaticContext) { // constructor call is in static context and the inner class is non-static - 1st arg is supposed to be // passed as enclosing "this" instance // Expression args = call.getArguments(); if (args instanceof TupleExpression && ((TupleExpression) args).getExpressions().isEmpty()) { addError("No enclosing instance passed in constructor call of a non-static inner class", call); } return; } insertThis0ToSuperCall(call, cn); }
public void visitConstructorCallExpression(ConstructorCallExpression call) { onLineNumber(call, "visitConstructorCallExpression: \"" + call.getType().getName() + "\":"); if (call.isSpecialCall()) { controller.getInvocationWriter().writeSpecialConstructorCall(call); return; } controller.getInvocationWriter().writeInvokeConstructor(call); controller.getAssertionWriter().record(call); }
protected void inferDiamondType(final ConstructorCallExpression cce, final ClassNode lType) { // check if constructor call expression makes use of the diamond operator ClassNode node = cce.getType(); if (node.isUsingGenerics() && node.getGenericsTypes() != null && node.getGenericsTypes().length == 0) { ArgumentListExpression argumentListExpression = InvocationWriter.makeArgumentList(cce.getArguments()); if (argumentListExpression.getExpressions().isEmpty()) { adjustGenerics(lType, node); } else { ClassNode type = getType(argumentListExpression.getExpression(0)); if (type.isUsingGenerics()) { adjustGenerics(type, node); } } // store inferred type on CCE storeType(cce, node); } }
protected boolean writeAICCall(ConstructorCallExpression call) { if (!call.isUsingAnonymousInnerClass()) return false; ConstructorNode cn = call.getType().getDeclaredConstructors().get(0); OperandStack os = controller.getOperandStack();