TypeMirror resolvedReturnType = executableType.getReturnType(); Builder builder = overriding(method); builder.returns(TypeName.get(resolvedReturnType)); for (int i = 0, size = builder.parameters.size(); i < size; i++) {
.addModifiers(Modifier.PUBLIC); MethodSpec.Builder methodActivityRulesCreator = MethodSpec.overriding(getOverrideMethod(creator, Constants.METHODNAME_CREATE_ACTIVITY_ROUTER)); methodActivityRulesCreator.addStatement("$T<String,$T> routes = new $T<>()",Map.class, activityRouteMap, HashMap.class); for (Parser parser : activityParser ) { MethodSpec.Builder methodActionRulesCreator = MethodSpec.overriding(getOverrideMethod(creator, Constants.METHODNAME_CREATE_ACTION_ROUTER)); methodActionRulesCreator.addStatement("$T<String,$T> routes = new $T<>()",Map.class, actionRouteMap, HashMap.class); for (Parser parser : actionParser ) { MethodSpec.Builder methodCreatorRulesCreator = MethodSpec.overriding(getOverrideMethod(creator, Constants.METHODNAME_CREATE_CREATOR_ROUTER)); methodCreatorRulesCreator.addStatement("$T<String,$T> routes = new $T<>()",Map.class, creatorRouteMap, HashMap.class); for (Parser parser : creatorParser ) {
.overriding(methodElement) .addStatement(callFormat, callArgs); if (typeToExtend.isInterface()) {
@Override public MethodSpec.Builder overrideMethodBuilder(ExecutableElement abstractMethod, DeclaredType declaredType) { return MethodSpec.overriding(abstractMethod, declaredType, Types); }
@Override public MethodSpec.Builder overrideMethodBuilder(ExecutableElement abstractMethod, DeclaredType declaredType) { return MethodSpec.overriding(abstractMethod, declaredType, Types); }
private MethodSpec emptyComponentMethod(TypeElement typeElement, ExecutableElement baseMethod) { return MethodSpec.overriding(baseMethod, MoreTypes.asDeclared(typeElement.asType()), types) .build(); }
private MethodSpec.Builder createHopMethod(ExecutableElement executableElement) { MethodSpec.Builder hopMethodSpec = MethodSpec.overriding(executableElement).addModifiers(Modifier.FINAL); hopMethodSpec = hopMethodSpec .addStatement("String newState = $L$L()", GENERATE_TAKEOFF_METHOD_PREFIX, executableElement.getSimpleName()); boolean hasReturnValue = executableElement.getReturnType().getKind() != TypeKind.VOID; hopMethodSpec = addSuperMethodCall(executableElement, hopMethodSpec, hasReturnValue); hopMethodSpec.addStatement("$L$L($L)", GENERATE_LAND_METHOD_PREFIX, executableElement.getSimpleName(), "newState") .addStatement("$L = newState", CURRENT_STATE_FIELD_NAME); if (hasReturnValue) { hopMethodSpec.addStatement("return returnValue"); } return hopMethodSpec; }
private void createSubcomponentFactoryMethod(ExecutableElement factoryMethod) { checkState(parent.isPresent()); Collection<ParameterSpec> params = getFactoryMethodParameters(graph).values(); MethodSpec.Builder method = MethodSpec.overriding(factoryMethod, parentType(), types); params.forEach( param -> method.addStatement("$T.checkNotNull($N)", Preconditions.class, param)); method.addStatement( "return new $T($L)", componentImplementation.name(), parameterNames(params)); parent.get().componentImplementation.addMethod(COMPONENT_METHOD, method.build()); }
private List<MethodSpec> buildGetMethodSpecs() { return properties.stream() .map(property -> { final String fieldName = property.getSimpleNameWithoutPrefix(CaseFormat.LOWER_CAMEL); final TypeMirror valueType = property.getReturnType(); final CodeBlock statement = CodeBlocks.createUnmodifiableStatement(valueType, fieldName); return MethodSpec.overriding(property.getMethod()) .addStatement("return $L", statement) .build(); }) .collect(toList()); } }
private List<MethodSpec> getSuperMethodSpecs() { List<MethodSpec> methodSpecs = new ArrayList<>(); this.annotatedClazz .annotatedElement .getEnclosedElements() .stream() .filter(element -> element instanceof ExecutableElement) .map(element -> (ExecutableElement) element) .forEach( method -> { ClassName preferenceRoom = ClassName.get(PreferenceRoom.class); MethodSpec.Builder builder = MethodSpec.overriding(method); MethodSpec methodSpec = builder .addStatement( "$T.inject($N)", preferenceRoom, method.getParameters().get(0).getSimpleName()) .build(); if (methodSpec.returnType != TypeName.get(Void.TYPE)) { throw new VerifyException( String.format( "Returned '%s'. only return type can be void.", methodSpec.returnType.toString())); } methodSpecs.add(methodSpec); }); return methodSpecs; }
@Override protected MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement) { ExecutableElement supertypeMethod = creatorDescriptor.elementForRequirement(requirement); MethodSpec.Builder method = MethodSpec.overriding( supertypeMethod, asDeclared(creatorDescriptor.typeElement().asType()), types); if (!supertypeMethod.getReturnType().getKind().equals(TypeKind.VOID)) { // Take advantage of covariant returns so that we don't have to worry about setter methods // that return type variables. method.returns(className); } return method; } }
private void processInjector(PreferenceComponentAnnotatedClass annotatedClass) throws VerifyException { try { annotatedClass .annotatedElement .getEnclosedElements() .stream() .filter(element -> element instanceof ExecutableElement) .map(element -> (ExecutableElement) element) .forEach( method -> { MethodSpec methodSpec = MethodSpec.overriding(method).build(); ParameterSpec parameterSpec = methodSpec.parameters.get(0); TypeElement injectedElement = processingEnv.getElementUtils().getTypeElement(parameterSpec.type.toString()); generateProcessInjector(annotatedClass, injectedElement); }); } catch (VerifyException e) { showErrorLog(e.getMessage(), annotatedClass.annotatedElement); e.printStackTrace(); } }
/** * Returns a new method spec builder that overrides {@code method} as a member of {@code * enclosing}. This will resolve type parameters: for example overriding {@link * Comparable#compareTo} in a type that implements {@code Comparable<Movie>}, the {@code T} * parameter will be resolved to {@code Movie}. * * <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and * throws declarations. An {@link Override} annotation will be added. * * <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and * parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately. */ public static Builder overriding( ExecutableElement method, DeclaredType enclosing, Types types) { ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method); List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes(); TypeMirror resolvedReturnType = executableType.getReturnType(); Builder builder = overriding(method); builder.returns(TypeName.get(resolvedReturnType)); for (int i = 0, size = builder.parameters.size(); i < size; i++) { ParameterSpec parameter = builder.parameters.get(i); TypeName type = TypeName.get(resolvedParameterTypes.get(i)); builder.parameters.set(i, parameter.toBuilder(type, parameter.name).build()); } return builder; }
/** * Returns a new method spec builder that overrides {@code method} as a member of {@code * enclosing}. This will resolve type parameters: for example overriding {@link * Comparable#compareTo} in a type that implements {@code Comparable<Movie>}, the {@code T} * parameter will be resolved to {@code Movie}. * * <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and * throws declarations. An {@link Override} annotation will be added. * * <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and * parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately. */ public static Builder overriding( ExecutableElement method, DeclaredType enclosing, Types types) { ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method); List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes(); TypeMirror resolvedReturnType = executableType.getReturnType(); Builder builder = overriding(method); builder.returns(TypeName.get(resolvedReturnType)); for (int i = 0, size = builder.parameters.size(); i < size; i++) { ParameterSpec parameter = builder.parameters.get(i); TypeName type = TypeName.get(resolvedParameterTypes.get(i)); builder.parameters.set(i, parameter.toBuilder(type, parameter.name).build()); } return builder; }
private void addImplicitItem(TypeSpec.Builder builder, ImplicitSpec spec, FoundImplicit foundImplicit, TypeMirror implicitInterface, ExecutableElement method) { MethodSpec.Builder methodSpecBuilder = MethodSpec.overriding(method); if ( method.getReturnType().getKind() == TypeKind.TYPEVAR ) { DeclaredType declaredType = (DeclaredType)implicitInterface; if ( declaredType.getTypeArguments().size() == 1 ) { methodSpecBuilder.returns(ClassName.get(declaredType.getTypeArguments().get(0))); } } CodeBlock.Builder codeBlockBuilder = CodeBlock.builder(); if ( method.getReturnType().getKind() != TypeKind.VOID ) { codeBlockBuilder.add("return "); } codeBlockBuilder.add(new ImplicitValue(environment, spec, contextItems, foundImplicit).build()); codeBlockBuilder.add(".$L(", method.getSimpleName()); AtomicBoolean isFirst = new AtomicBoolean(true); method.getParameters().forEach(parameter -> { if ( !isFirst.compareAndSet(true, false) ) { codeBlockBuilder.add(", "); } codeBlockBuilder.add(parameter.getSimpleName().toString()); }); methodSpecBuilder.addCode(codeBlockBuilder.addStatement(")").build()); builder.addMethod(methodSpecBuilder.build()); }
/** Returns the implementation of a component method. */ MethodSpec getComponentMethod(ComponentMethodDescriptor componentMethod) { checkArgument(componentMethod.dependencyRequest().isPresent()); BindingRequest request = bindingRequest(componentMethod.dependencyRequest().get()); return MethodSpec.overriding( componentMethod.methodElement(), MoreTypes.asDeclared(graph.componentTypeElement().asType()), types) .addCode( getBindingExpression(request) .getComponentMethodImplementation(componentMethod, componentImplementation)) .build(); }
.overriding(methodElement) .addStatement(callFormat, callArgs); if (typeToExtend.isInterface()) {
MethodSpec.Builder methodBuilder = MethodSpec.overriding(baseMethod, declaredType, typeUtils);
.collect(Collectors.joining(", ")); MethodSpec.Builder methodSpecBuilder = MethodSpec.overriding(method, parentType, environment.getTypeUtils()); if ( method.getReturnType().getKind() == TypeKind.VOID )
final MethodSpec.Builder methodBuilder = MethodSpec.overriding(am.getSuperMethod()) .beginControlFlow("final $T request = new $T()", parametrizedType, parametrizedType) .addCode("@Override ")