setMethodDefaultValue(mn, m); setAnnotationMetaData(m.getAnnotations(), mn); mn.setGenericsTypes(configureTypeVariable(m.getTypeParameters())); classNode.addMethod(mn);
GENERATED_EMPTY_STATEMENT ); stubbed.setGenericsTypes(method.getGenericsTypes());
result.setGenericsTypes(typeParameters);
private static ClassNode resolveClassNode(final SourceUnit sourceUnit, final CompilationUnit compilationUnit, final MethodNode mn, final ASTNode usage, final ClassNode parsedNode) { ClassNode dummyClass = new ClassNode("dummy", 0, ClassHelper.OBJECT_TYPE); dummyClass.setModule(new ModuleNode(sourceUnit)); dummyClass.setGenericsTypes(mn.getDeclaringClass().getGenericsTypes()); MethodNode dummyMN = new MethodNode( "dummy", 0, parsedNode, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, EmptyStatement.INSTANCE ); dummyMN.setGenericsTypes(mn.getGenericsTypes()); dummyClass.addMethod(dummyMN); ResolveVisitor visitor = new ResolveVisitor(compilationUnit) { @Override public void addError(final String msg, final ASTNode expr) { sourceUnit.addError(new IncorrectTypeHintException(mn, msg, usage.getLineNumber(), usage.getColumnNumber())); } }; visitor.startResolving(dummyClass, sourceUnit); return dummyMN.getReturnType(); }
private MethodNode copyMethod(MethodNode method, String newName) { // can't hurt to set return type to void MethodNode newMethod = new MethodNode(newName, method.getModifiers(), ClassHelper.VOID_TYPE, method.getParameters(), method.getExceptions(), method.getCode()); newMethod.addAnnotations(method.getAnnotations()); newMethod.setSynthetic(method.isSynthetic()); newMethod.setDeclaringClass(method.getDeclaringClass()); newMethod.setSourcePosition(method); newMethod.setVariableScope(method.getVariableScope()); newMethod.setGenericsTypes(method.getGenericsTypes()); newMethod.setAnnotationDefault(method.hasAnnotationDefault()); return newMethod; }
bridge.setGenericsTypes(applyGenericsContextToPlaceHolders(genericsSpec,origGenericsTypes));
); dummyMN.setDeclaringClass(selectedMethod.getDeclaringClass()); dummyMN.setGenericsTypes(selectedMethod.getGenericsTypes()); if (selectedMethod instanceof ExtensionMethodNode) { ExtensionMethodNode orig = (ExtensionMethodNode) selectedMethod; ); dummyMN.setDeclaringClass(orig.getDeclaringClass()); dummyMN.setGenericsTypes(orig.getGenericsTypes());
GenericsType[] newGt = GenericsUtils.applyGenericsContextToPlaceHolders(genericsSpec, originalMethod.getGenericsTypes()); newGt = removeNonPlaceHolders(newGt); forwarder.setGenericsTypes(newGt); } else { methodSpec = GenericsUtils.addMethodGenerics(helperMethod, methodSpec); GenericsType[] newGt = GenericsUtils.applyGenericsContextToPlaceHolders(methodSpec, helperMethod.getGenericsTypes()); forwarder.setGenericsTypes(newGt);
candidate.getExceptions(), stmt(mce)); newMethod.setGenericsTypes(candidate.getGenericsTypes());
Statement delegate = next == null ? createSuperFallback(forwarderMethod, returnType) : createDelegatingForwarder(forwarderMethod, next); MethodNode methodNode = targetNode.addMethod(forwarderName, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, returnType, superForwarderParams, ClassNode.EMPTY_ARRAY, delegate); methodNode.setGenericsTypes(forwarderMethod.getGenericsTypes());
private MethodNode processMethod(ClassNode traitClass, ClassNode traitHelperClass, MethodNode methodNode, ClassNode fieldHelper, Collection<String> knownFields) { Parameter[] initialParams = methodNode.getParameters(); Parameter[] newParams = new Parameter[initialParams.length + 1]; newParams[0] = createSelfParameter(traitClass, methodNode.isStatic()); System.arraycopy(initialParams, 0, newParams, 1, initialParams.length); final int mod = methodNode.isPrivate() ? ACC_PRIVATE : ACC_PUBLIC | (methodNode.isFinal() ? ACC_FINAL : 0); MethodNode mNode = new MethodNode( methodNode.getName(), mod | ACC_STATIC, methodNode.getReturnType(), newParams, methodNode.getExceptions(), processBody(new VariableExpression(newParams[0]), methodNode.getCode(), traitClass, traitHelperClass, fieldHelper, knownFields) ); mNode.setSourcePosition(methodNode); mNode.addAnnotations(filterAnnotations(methodNode.getAnnotations())); mNode.setGenericsTypes(methodNode.getGenericsTypes()); if (methodNode.isAbstract()) { mNode.setModifiers(ACC_PUBLIC | ACC_ABSTRACT); } else { methodNode.addAnnotation(new AnnotationNode(Traits.IMPLEMENTED_CLASSNODE)); } methodNode.setCode(null); if (!methodNode.isPrivate() && !methodNode.isStatic()) { methodNode.setModifiers(ACC_PUBLIC | ACC_ABSTRACT); } return mNode; }
methodNode.setGenericsTypes(generics); methodNode.setAnnotationDefault(hasAnnotationDefault); methodNode.setSyntheticPublic(syntheticPublic);
newMethod.setGenericsTypes(method.getGenericsTypes()); newMethod.putNodeMetaData(DEFAULT_PARAMETER_GENERATED, true);
setMethodDefaultValue(mn, m); setAnnotationMetaData(m.getAnnotations(), mn); mn.setGenericsTypes(configureTypeVariable(m.getTypeParameters())); classNode.addMethod(mn);
methodNode.setGenericsTypes(generics); configureAST(methodNode, methodDef); if (classNode != null) {
candidate.getName(), args))); newMethod.setGenericsTypes(candidate.getGenericsTypes());
isVoid ? stmnt(delegateExpression) : returns(delegateExpression) ); newMethod.setGenericsTypes(method.getGenericsTypes()); injectMethod(classNode, newMethod);
methodNode.setGenericsTypes(generics); methodNode.setAnnotationDefault(hasAnnotationDefault); methodNode.setSyntheticPublic(syntheticPublic);
private static void addActiveMethod(final FieldNode actorNode, final ClassNode owner, final MethodNode original, final boolean blocking) { if (original.isSynthetic()) return; final ArgumentListExpression args = new ArgumentListExpression(); final Parameter[] params = original.getParameters(); final Parameter[] newParams = new Parameter[params.length]; args.addExpression(new VariableExpression("this")); args.addExpression(new ConstantExpression(original.getName())); for (int i = 0; i < newParams.length; i++) { final Parameter newParam = new Parameter(nonGeneric(params[i].getType()), params[i].getName()); newParam.setInitialExpression(params[i].getInitialExpression()); newParams[i] = newParam; args.addExpression(new VariableExpression(newParam)); } final MethodNode newMethod = owner.addMethod(findSuitablePrivateMethodName(owner, original), Modifier.FINAL & Modifier.PRIVATE, new ClassNode(Object.class), newParams, original.getExceptions(), original.getCode()); newMethod.setGenericsTypes(original.getGenericsTypes()); final String submitMethodName = blocking ? "submitAndWait" : "submit"; original.setCode(new ExpressionStatement( new MethodCallExpression( new VariableExpression(actorNode), submitMethodName, args) )); }
newMethod.setGenericsTypes(method.getGenericsTypes());