public static VariableExpression localVarX(String name) { VariableExpression result = new VariableExpression(name); result.setAccessedVariable(result); return result; }
@Override public void visitVariableExpression(final VariableExpression expression) { super.visitVariableExpression(expression); if ("args".equals(expression.getName())) { expression.setAccessedVariable(arg); } } };
private void adjustToClassVar(VariableExpression expr) { // we only need to check the variable name because the Groovy compiler // already fails if a variable with the same name already exists in the scope. // this means that a closure cannot shadow a class variable expr.setAccessedVariable(fieldNode); final VariableScope variableScope = currentClosure.getVariableScope(); final Iterator<Variable> iterator = variableScope.getReferencedLocalVariablesIterator(); while (iterator.hasNext()) { Variable next = iterator.next(); if (next.getName().equals(variableName)) iterator.remove(); } variableScope.putReferencedClassVariable(fieldNode); }
@Override public void visitVariableExpression(VariableExpression expression) { Variable v = expression.getAccessedVariable(); if (v==null) return; if (!(v instanceof FieldNode)) return; String name = expression.getName(); FieldNode fn = closureClass.getDeclaredField(name); if (fn != null) { // only overwrite if we find something more specific expression.setAccessedVariable(fn); } } };
private void declare(VariableExpression vex) { vex.setInStaticContext(currentScope.isInStaticContext()); declare(vex, vex); vex.setAccessedVariable(vex); }
public void visitVariableExpression(VariableExpression expression) { String name = expression.getName(); Variable v = checkVariableNameForDeclaration(name, expression); if (v == null) return; expression.setAccessedVariable(v); checkVariableContextAccess(v, expression); }
private void fixVar(Variable var) { if (getTarget(var) == null && var instanceof VariableExpression && getState() != null && var.getName() != null) { for (Variable v: getState().keySet()) { if (var.getName().equals(v.getName())) { ((VariableExpression)var).setAccessedVariable(v); break; } } } }
public VariableExpression(Variable variable) { this(variable.getName(), variable.getOriginType()); setAccessedVariable(variable); setModifiers(variable.getModifiers()); }
private Expression copyVarExpr(VariableExpression varExpr) { VariableExpression newVarExpr = new VariableExpression(varExpr.getName(), varExpr.getOriginType()); newVarExpr.setAccessedVariable(varExpr.getAccessedVariable()); newVarExpr.setSourcePosition(varExpr); return newVarExpr; } }
private Expression addGuard(MethodCallExpression mce) { // only add guard to methods of the form: logVar.logMethod(params) if (!(mce.getObjectExpression() instanceof VariableExpression)) { return null; } VariableExpression variableExpression = (VariableExpression) mce.getObjectExpression(); if (!variableExpression.getName().equals(logFieldName) || !(variableExpression.getAccessedVariable() instanceof DynamicVariable)) { return null; } String methodName = mce.getMethodAsString(); if (methodName == null) return null; if (!loggingStrategy.isLoggingMethod(methodName)) return null; // also don't bother with guard if we have "simple" method args // since there is no saving if (usesSimpleMethodArgumentsOnly(mce)) return null; variableExpression.setAccessedVariable(logNode); return loggingStrategy.wrapLoggingMethodCall(variableExpression, methodName, mce); }
List<Expression> expressions = args.getExpressions(); VariableExpression ve = new VariableExpression(thisPara.getName()); ve.setAccessedVariable(thisPara); expressions.add(0, ve);
public static void addSpecialMapConstructors(int modifiers, ClassNode cNode, String message, boolean addNoArg) { Parameter[] parameters = params(new Parameter(LHMAP_TYPE, "__namedArgs")); BlockStatement code = new BlockStatement(); VariableExpression namedArgs = varX("__namedArgs"); namedArgs.setAccessedVariable(parameters[0]); code.addStatement(ifElseS(equalsNullX(namedArgs), illegalArgumentBlock(message), processArgsBlock(cNode, namedArgs))); ConstructorNode init = new ConstructorNode(modifiers, parameters, ClassNode.EMPTY_ARRAY, code); markAsGenerated(cNode, init); cNode.addConstructor(init); // potentially add a no-arg constructor too if (addNoArg) { code = new BlockStatement(); code.addStatement(stmt(ctorX(ClassNode.THIS, ctorX(LHMAP_TYPE)))); init = new ConstructorNode(modifiers, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, code); markAsGenerated(cNode, init); cNode.addConstructor(init); } }
fieldNode = veFieldNode; boolean lhsOfEnclosingAssignment = isLHSOfEnclosingAssignment(vexp); vexp.setAccessedVariable(fieldNode); checkOrMarkPrivateAccess(vexp, fieldNode, lhsOfEnclosingAssignment);
ClassNode type = param.getType(); VariableExpression initialValue = new VariableExpression(paramName); initialValue.setAccessedVariable(param); initialValue.setUseReferenceDirectly(true); ClassNode realType = type;
Parameter[] setterParameterTypes = {new Parameter(node.getType(), "value")}; VariableExpression var = (VariableExpression) ((BinaryExpression) ((ExpressionStatement) setterBlock).getExpression()).getRightExpression(); var.setAccessedVariable(setterParameterTypes[0]); MethodNode setter = new MethodNode(setterName, propNodeModifiers, ClassHelper.VOID_TYPE, setterParameterTypes, ClassNode.EMPTY_ARRAY, setterBlock);
@Override public void visitVariableExpression(VariableExpression expression) { Variable v = expression.getAccessedVariable(); if (v==null) return; if (!(v instanceof FieldNode)) return; String name = expression.getName(); FieldNode fn = closureClass.getDeclaredField(name); if (fn != null) { // only overwrite if we find something more specific expression.setAccessedVariable(fn); } } };
public void visitVariableExpression(VariableExpression expression) { String name = expression.getName(); Variable v = checkVariableNameForDeclaration(name, expression); if (v == null) return; expression.setAccessedVariable(v); checkVariableContextAccess(v, expression); }
public void visitVariableExpression(VariableExpression expression) { String name = expression.getName(); Variable v = checkVariableNameForDeclaration(name, expression); if (v == null) return; expression.setAccessedVariable(v); checkVariableContextAccess(v, expression); }
private void declare(VariableExpression vex) { vex.setInStaticContext(currentScope.isInStaticContext()); declare(vex, vex); vex.setAccessedVariable(vex); }
public VariableExpression(Variable variable) { this(variable.getName(), variable.getOriginType()); setAccessedVariable(variable); setModifiers(variable.getModifiers()); }