private boolean isDataProcessorVariable(String name) { for (VariableExpression var : dataProcessorVars) if (var.getName().equals(name)) return true; return false; }
private boolean isValueRecorderExpression(VariableExpression variableExpression) { return SpockNames.VALUE_RECORDER.equals(variableExpression.getName()); } }
private boolean isErrorCollectorExpression(VariableExpression variableExpression) { return SpockNames.ERROR_COLLECTOR.equals(variableExpression.getName()); }
private static boolean isSuperExpression(Expression expression) { if (expression instanceof VariableExpression) { VariableExpression varExp = (VariableExpression) expression; return varExp.getName().equals("super"); } return false; }
public static boolean isThisExpression(Expression expression) { if (expression instanceof VariableExpression) { VariableExpression varExp = (VariableExpression) expression; return varExp.getName().equals("this"); } return false; }
private void addVariableError(VariableExpression ve) { addError("Apparent variable '" + ve.getName() + "' was found in a static scope but doesn't refer" + " to a local variable, static field or class. Possible causes:\n" + "You attempted to reference a variable in the binding or an instance variable from a static context.\n" + "You misspelled a classname or statically imported field. Please check the spelling.\n" + "You attempted to use a method '" + ve.getName() + "' but left out brackets in a place not allowed by the grammar.", ve); }
@Override public void visitVariableExpression(VariableExpression expression) { throw new GroovyRuntimeException("DataSet currently doesn't support arbitrary variables, only literals: found attempted reference to variable '" + expression.getName() + "'"); }
private Parameter[] getPreviousParameters(int nextDataVariableIndex) { Parameter[] results = new Parameter[nextDataVariableIndex]; for (int i = 0; i < nextDataVariableIndex; i++) results[i] = new Parameter(ClassHelper.DYNAMIC_TYPE, dataProcessorVars.get(i).getName()); return results; }
private void addFeatureParameters() { Parameter[] parameters = new Parameter[dataProcessorVars.size()]; for (int i = 0; i < dataProcessorVars.size(); i++) parameters[i] = new Parameter(ClassHelper.DYNAMIC_TYPE, dataProcessorVars.get(i).getName()); whereBlock.getParent().getAst().setParameters(parameters); }
private Expression unrecord(Expression expr) { if (!(expr instanceof MethodCallExpression)) return expr; MethodCallExpression methodExpr = (MethodCallExpression) expr; Expression targetExpr = methodExpr.getObjectExpression(); if (!(targetExpr instanceof VariableExpression)) return expr; VariableExpression var = (VariableExpression)targetExpr; if (!SpockNames.VALUE_RECORDER.equals(var.getName())) return expr; if(!ValueRecorder.RECORD.equals(methodExpr.getMethodAsString())) return expr; return ((ArgumentListExpression)methodExpr.getArguments()).getExpression(1); }
public static boolean isWildcardRef(Expression expr) { VariableExpression varExpr = ObjectUtil.asInstance(expr, VariableExpression.class); if (varExpr == null || !varExpr.getName().equals(Wildcard.INSTANCE.toString())) return false; Variable accessedVar = varExpr.getAccessedVariable(); if (!(accessedVar instanceof FieldNode)) return false; return ((FieldNode) accessedVar).getOwner().getName().equals(Specification.class.getName()); }
@Override public void variableNotAlwaysInitialized(final VariableExpression var) { if (Modifier.isFinal(var.getAccessedVariable().getModifiers())) throw new RuntimeParserException("The variable [" + var.getName() + "] may be uninitialized", var); } };
private VariableExpression createDataProcessorVariable(Expression varExpr, ASTNode sourcePos) throws InvalidSpecCompileException { if (!(varExpr instanceof VariableExpression)) notAParameterization(sourcePos); VariableExpression typedVarExpr = (VariableExpression)varExpr; verifyDataProcessorVariable(typedVarExpr); VariableExpression result = new VariableExpression(typedVarExpr.getName(), typedVarExpr.getType()); dataProcessorVars.add(result); return result; }
private AnnotationNode createDataProviderAnnotation(Expression dataProviderExpr, int nextDataVariableIndex) { AnnotationNode ann = new AnnotationNode(resources.getAstNodeCache().DataProviderMetadata); ann.addMember(DataProviderMetadata.LINE, new ConstantExpression(dataProviderExpr.getLineNumber())); List<Expression> dataVariableNames = new ArrayList<>(); for (int i = nextDataVariableIndex; i < dataProcessorVars.size(); i++) dataVariableNames.add(new ConstantExpression(dataProcessorVars.get(i).getName())); ann.addMember(DataProviderMetadata.DATA_VARIABLES, new ListExpression(dataVariableNames)); return ann; }
@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); }
@Override public void visitVariableExpression(VariableExpression expr) { result = new ExpressionInfo( TextRegion.of(expr), TextPosition.startOf(expr), expr.getName() ).setRelevant(expr != VariableExpression.THIS_EXPRESSION && expr != VariableExpression.SUPER_EXPRESSION); }
private void loadVariableWithReference(VariableExpression var) { if (!var.isUseReferenceDirectly()) { var.visit(controller.getAcg()); } else { ClosureWriter.loadReference(var.getName(), controller); } }
private Expression copyVarExpr(VariableExpression varExpr) { VariableExpression newVarExpr = new VariableExpression(varExpr.getName(), varExpr.getOriginType()); newVarExpr.setAccessedVariable(varExpr.getAccessedVariable()); newVarExpr.setSourcePosition(varExpr); return newVarExpr; } }
@Override public boolean handleUnresolvedVariableExpression(final VariableExpression vexp) { // <2> if ("robot".equals(vexp.getName())) { storeType(vexp, ClassHelper.make(Robot.class)); setHandled(true); return true; } return false; }