/** * @see #getMethod(String, Parameter[]) */ public boolean hasMethod(String name, Parameter[] parameters) { MethodNode other = getMethod(name, parameters); return other != null; }
List<MethodNode> traitMethods = node.getMethods(); for (MethodNode traitMethod : traitMethods) { MethodNode method = classNode.getMethod(traitMethod.getName(), traitMethod.getParameters()); if (method == null) { for (MethodNode methodNode : propertyMethods) {
BlockStatement code = new BlockStatement(); MethodCallExpression cloneCall = new MethodCallExpression(new FieldExpression(values), "clone", MethodCallExpression.NO_ARGUMENTS); cloneCall.setMethodTarget(values.getType().getMethod("clone", Parameter.EMPTY_ARRAY)); code.addStatement(new ReturnStatement(cloneCall)); valuesMethod.setCode(code);
private static String getterName(ClassNode annotatedNode, PropertyNode pNode) { String getterName = "get" + MetaClassHelper.capitalize(pNode.getName()); boolean existingExplicitGetter = annotatedNode.getMethod(getterName, Parameter.EMPTY_ARRAY) != null; if (ClassHelper.boolean_TYPE.equals(pNode.getOriginType()) && !existingExplicitGetter) { getterName = "is" + MetaClassHelper.capitalize(pNode.getName()); } return getterName; }
public static boolean addMethod(ClassNode classNode, MethodNode methodNode, boolean replace) { MethodNode oldMethod = classNode.getMethod(methodNode.getName(), methodNode.getParameters()); if (oldMethod == null) { classNode.addMethod(methodNode); return true; } else if (replace) { classNode.getMethods().remove(oldMethod); classNode.addMethod(methodNode); return true; } return false; }
cn.getModule().addClass(helper); helper.addAnnotation(new AnnotationNode(COMPILESTATIC_CLASSNODE)); MethodNode serializeClass = collector.getClassNode().getMethod("serializeClass", Parameter.EMPTY_ARRAY); collector.setMember("serializeClass", new ClassExpression(helper.getPlainNodeReference()));
private void checkNoAbstractMethodsNonabstractClass(ClassNode node) { if (isAbstract(node.getModifiers())) return; List<MethodNode> abstractMethods = node.getAbstractMethods(); if (abstractMethods == null) return; for (MethodNode method : abstractMethods) { MethodNode sameArgsMethod = node.getMethod(method.getName(), method.getParameters()); if (sameArgsMethod==null || method.getReturnType().equals(sameArgsMethod.getReturnType())) { addError("Can't have an abstract method in a non-abstract class." + " The " + getDescription(node) + " must be declared abstract or" + " the " + getDescription(method) + " must be implemented.", node); } else { addError("Abstract "+getDescription(method)+" is not implemented but a " + "method of the same name but different return type is defined: "+ (sameArgsMethod.isStatic()?"static ":"")+ getDescription(sameArgsMethod), method ); } } }
ClassNode type; if (isMethod) { target = node.getMethod(name, paraTypes); if (target==null) return; if (!target.getDeclaringClass().equals(node)) return;
System.arraycopy(methodNode.getParameters(), 1, params, 0, params.length); Map<String,ClassNode> methodGenericsSpec = new LinkedHashMap<String, ClassNode>(genericsSpec); MethodNode originalMethod = trait.getMethod(name, params);
private void createSharedFieldGetter(Field field) { String getterName = "get" + MetaClassHelper.capitalize(field.getName()); MethodNode getter = spec.getAst().getMethod(getterName, Parameter.EMPTY_ARRAY); if (getter != null) { errorReporter.error(field.getAst(), "@Shared field '%s' conflicts with method '%s'; please rename either of them", field.getName(), getter.getName()); return; } BlockStatement getterBlock = new BlockStatement(); getter = new MethodNode(getterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC, field.getAst().getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock); getterBlock.addStatement( new ReturnStatement( new ExpressionStatement( new AttributeExpression( getSharedInstance(), // use internal name new ConstantExpression(field.getAst().getName()))))); getter.setSourcePosition(field.getAst()); spec.getAst().addMethod(getter); }
private void createSharedFieldSetter(Field field) { String setterName = "set" + MetaClassHelper.capitalize(field.getName()); Parameter[] params = new Parameter[] { new Parameter(field.getAst().getType(), "$spock_value") }; MethodNode setter = spec.getAst().getMethod(setterName, params); if (setter != null) { errorReporter.error(field.getAst(), "@Shared field '%s' conflicts with method '%s'; please rename either of them", field.getName(), setter.getName()); return; } BlockStatement setterBlock = new BlockStatement(); setter = new MethodNode(setterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC, ClassHelper.VOID_TYPE, params, ClassNode.EMPTY_ARRAY, setterBlock); setterBlock.addStatement( new ExpressionStatement( new BinaryExpression( new AttributeExpression( getSharedInstance(), // use internal name new ConstantExpression(field.getAst().getName())), Token.newSymbol(Types.ASSIGN, -1, -1), new VariableExpression("$spock_value")))); setter.setSourcePosition(field.getAst()); spec.getAst().addMethod(setter); }
iterator.setMethodTarget(collectionType.getMethod("iterator", Parameter.EMPTY_ARRAY)); iterator.setImplicitThis(false); iterator.visit(controller.getAcg());
@Override public void visit(ASTNode[] nodes, SourceUnit source) { for (ClassNode classNode : source.getAST().getClasses()) { if (classNode.isDerivedFrom(GROOVY_SCRIPT_COMMAND)) { MethodNode run = classNode.getMethod("run", new Parameter[0]); Statement code = run.getCode(); if (code instanceof BlockStatement) { BlockStatement block = (BlockStatement)code; List<Statement> statements = block.getStatements(); int size = statements.size(); if (size > 0) { Statement last = statements.get(size - 1); if (last instanceof ReturnStatement) { classNode.addField(new FieldNode( FIELD_NAME, Modifier.PUBLIC | Modifier.STATIC, ClassHelper.Boolean_TYPE, classNode, null)); } } } } } } }
/** * @see #getMethod(String, Parameter[]) */ public boolean hasMethod(String name, Parameter[] parameters) { MethodNode other = getMethod(name, parameters); return other != null; }
/** * @see #getMethod(String, Parameter[]) */ public boolean hasMethod(String name, Parameter[] parameters) { MethodNode other = getMethod(name, parameters); return other != null; }
/** * @see #getMethod(String, Parameter[]) */ public boolean hasMethod(String name, Parameter[] parameters) { MethodNode other = getMethod(name, parameters); return other != null; }
/** * @see #getMethod(String, Parameter[]) */ public boolean hasMethod(String name, Parameter[] parameters) { MethodNode other = getMethod(name, parameters); return other != null; }
private static void validatePoolClass(final Expression classExpression, final AnnotatedNode fieldNode, final SourceUnit source) { final Parameter[] parameters = {new Parameter(ClassHelper.CLOSURE_TYPE, "a1"), new Parameter(ClassHelper.boolean_TYPE, "a2")}; final MethodNode asyncFunMethod = classExpression.getType().getMethod("asyncFun", parameters); if (asyncFunMethod == null || !asyncFunMethod.isStatic()) addError("Supplied pool class has no static asyncFun(Closure, boolean) method", fieldNode, source); }
public static boolean isChromatticAnnotedInHierarchy(ClassNode classNode, FieldNode fieldNode) { if (classNode == null) classNode = fieldNode.getDeclaringClass(); ClassNode superClassNode = classNode.getSuperClass(); if (!superClassNode.equals(ClassHelper.OBJECT_TYPE)) { MethodNode superMethodNode = superClassNode.getMethod(getsetName(GetSet.GET, fieldNode.getName()), new Parameter[]{}); if (superMethodNode != null) return true; else isChromatticAnnotedInHierarchy(superClassNode, fieldNode); } return false; } }
@Override public void visitProperty(PropertyNode node) { final ClassNode classNode = node.getDeclaringClass(); final String setterName = "set" + MetaClassHelper.capitalize(node.getName()); final Statement setterBlock = node.getSetterBlock(); final Parameter parameter = new Parameter(node.getType(), "value"); if (CandidateChecks.isClassInvariantCandidate(node) && (setterBlock == null && classNode.getMethod(setterName, new Parameter[]{ parameter } ) == null)) { final Statement setterBlockStatement = createSetterBlock(classNode, node.getField(), parameter); node.setSetterBlock(setterBlockStatement); } }