public static boolean isThisExpression(Expression expr) { return expr instanceof VariableExpression && ((VariableExpression) expr).isThisExpression(); }
private void checkSuperOrThisOnLHS(Expression expression) { if (!(expression instanceof VariableExpression)) return; VariableExpression ve = (VariableExpression) expression; if (ve.isThisExpression()) { addError("cannot have 'this' as LHS of an assignment", expression); } else if (ve.isSuperExpression()) { addError("cannot have 'super' as LHS of an assignment", expression); } }
private boolean storeTypeForThis(VariableExpression vexp) { if (vexp == VariableExpression.THIS_EXPRESSION) return true; if (!vexp.isThisExpression()) return false; ClassNode enclosingClassNode = typeCheckingContext.getEnclosingClassNode(); storeType(vexp, makeType(enclosingClassNode, typeCheckingContext.isInStaticContext)); return true; }
@Override public void visitMethodCallExpression(MethodCallExpression call) { Expression objectExpression = call.getObjectExpression(); if (objectExpression instanceof VariableExpression) { VariableExpression ve = (VariableExpression) objectExpression; if (ve.isThisExpression()) { addError("Can't access instance method '" + call.getMethodAsString() + "' for a constructor parameter default value", param); return; } } super.visitMethodCallExpression(call); }
protected Expression expression(AST node, boolean convertToConstant) { Expression expression = expressionSwitch(node); if (convertToConstant && expression instanceof VariableExpression) { // a method name can never be a VariableExpression, so it must converted // to a ConstantExpression then. This is needed as the expression // method doesn't know we want a ConstantExpression instead of a // VariableExpression VariableExpression ve = (VariableExpression) expression; if (!ve.isThisExpression() && !ve.isSuperExpression()) { expression = new ConstantExpression(ve.getName()); } } configureAST(expression, node); return expression; }
VariableExpression ve = (VariableExpression) it; if (ve.isSuperExpression() || ve.isThisExpression()) { return null;
@Override public void visitMethodCallExpression(MethodCallExpression mce) { if (inSpecialConstructorCall && !isInnerClass(currentMethod.getDeclaringClass())) { Expression objectExpression = mce.getObjectExpression(); if (objectExpression instanceof VariableExpression) { VariableExpression ve = (VariableExpression) objectExpression; if (ve.isThisExpression()) { addError("Can't access instance method '" + mce.getMethodAsString() + "' before the class is constructed", mce); return; } } } super.visitMethodCallExpression(mce); }
if (pe.getObjectExpression() instanceof VariableExpression) { VariableExpression vex = (VariableExpression) pe.getObjectExpression(); if (vex.isThisExpression()) { pe.setObjectExpression(thisExpression); return pe;
private void addStaticVariableError(VariableExpression ve) { // closures are always dynamic // propertyExpressions will handle the error a bit differently if (!inSpecialConstructorCall && (inClosure || !ve.isInStaticContext())) return; if (ve.isThisExpression() || ve.isSuperExpression()) return; Variable v = ve.getAccessedVariable(); if (currentMethod != null && currentMethod.isStatic()) { FieldNode fieldNode = getDeclaredOrInheritedField(currentMethod.getDeclaringClass(), ve.getName()); if (fieldNode != null && fieldNode.isStatic()) return; } if (v != null && !(v instanceof DynamicVariable) && v.isInStaticContext()) return; addVariableError(ve); }
@Override public ClassNode resolveType(final Expression exp, final ClassNode current) { ASTNode target = exp instanceof VariableExpression ? getTarget((VariableExpression) exp) : exp; ClassNode inferredType = target.getNodeMetaData(StaticTypesMarker.DECLARATION_INFERRED_TYPE); if (inferredType == null) { inferredType = target.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE); if (inferredType == null && target instanceof VariableExpression && ((VariableExpression) target).getAccessedVariable() instanceof Parameter) { target = (Parameter) ((VariableExpression) target).getAccessedVariable(); inferredType = ((Parameter) target).getOriginType(); } } if (inferredType != null) { if (ClassHelper.VOID_TYPE == inferredType) { // we are in a case of a type inference failure, probably because code was generated // it is better to avoid using this inferredType = super.resolveType(exp, current); } return inferredType; } if (target instanceof VariableExpression && ((VariableExpression) target).isThisExpression()) { // AsmClassGenerator may create "this" expressions that the type checker knows nothing about return current; } return super.resolveType(exp, current); }
private void checkFinalFieldAccess(Expression expression) { if (!(expression instanceof VariableExpression) && !(expression instanceof PropertyExpression)) return; Variable v = null; if (expression instanceof VariableExpression) { VariableExpression ve = (VariableExpression) expression; v = ve.getAccessedVariable(); } else { PropertyExpression propExp = ((PropertyExpression) expression); Expression objectExpression = propExp.getObjectExpression(); if (objectExpression instanceof VariableExpression) { VariableExpression varExp = (VariableExpression) objectExpression; if (varExp.isThisExpression()) { v = currentClass.getDeclaredField(propExp.getPropertyAsString()); } } } if (v instanceof FieldNode) { FieldNode fn = (FieldNode) v; /* * if it is static final but not accessed inside a static constructor, or, * if it is an instance final but not accessed inside a instance constructor, it is an error */ boolean isFinal = fn.isFinal(); boolean isStatic = fn.isStatic(); boolean error = isFinal && ((isStatic && !inStaticConstructor) || (!isStatic && !inConstructor)); if (error) addError("cannot modify" + (isStatic ? " static" : "") + " final field '" + fn.getName() + "' outside of " + (isStatic ? "static initialization block." : "constructor."), expression); } }
&& ((VariableExpression) objectExpression).isThisExpression() && objectExpressionType.equals(current);
&& (call.isImplicitThis() || (objectExpression instanceof VariableExpression && ((VariableExpression) objectExpression).isThisExpression()))) {
implicitThis = true; name = new ConstantExpression("super"); if (objectExpression instanceof VariableExpression && ((VariableExpression) objectExpression).isThisExpression()) { objectExpression = VariableExpression.SUPER_EXPRESSION;
typeCheckingContext.getEnclosingClosure() != null && argumentList.getExpression(0) instanceof VariableExpression && ((VariableExpression) argumentList.getExpression(0)).isThisExpression() && call.getType() instanceof InnerClassNode && call.getType().getOuterClass().equals(args[0]) &&
ClassNode classNode = controller.getClassNode(); ClassNode receiverType = typeChooser.resolveType(receiver, classNode); if (receiver instanceof VariableExpression && ((VariableExpression) receiver).isThisExpression() && !controller.isInClosure()) { receiverType = classNode;
return propertyExpression; if (vexp.isThisExpression()) { VariableExpression res = new VariableExpression(weaved); res.setSourcePosition(exp);
ClassNode receiverType = typeChooser.resolveType(receiver, controller.getClassNode()); String property = message.getText(); boolean isThisExpression = receiver instanceof VariableExpression && ((VariableExpression) receiver).isThisExpression(); if (isAttribute || (isThisExpression &&
boolean isThisOrSuper = false; if (receiver instanceof VariableExpression) { isThisOrSuper = ((VariableExpression) receiver).isThisExpression() || ((VariableExpression) receiver).isSuperExpression(); boolean isThisOrSuper = false; if (receiver instanceof VariableExpression) { isThisOrSuper = ((VariableExpression) receiver).isThisExpression() || ((VariableExpression) receiver).isSuperExpression();
if (object instanceof VariableExpression) { VariableExpression ve = (VariableExpression) object; isExplicitThisOrSuper = !mce.isImplicitThis() && (ve.isThisExpression() || ve.isSuperExpression()); isExplicitSuper = ve.isSuperExpression();