Examples with Binding dagger.internal.Binding used on opensource projects

Example 1 with Binding

use of dagger.internal.Binding in project dagger by square.

the class InjectAdapterProcessor method generateInjectAdapter.

/**
   * Write a companion class for {@code type} that extends {@link Binding}.
   *
   * @param constructor the injectable constructor, or null if this binding
   *     supports members injection only.
   */
private void generateInjectAdapter(TypeElement type, ExecutableElement constructor, List<Element> fields) throws IOException {
    String packageName = getPackage(type).getQualifiedName().toString();
    TypeMirror supertype = getApplicationSupertype(type);
    if (supertype != null) {
        supertype = processingEnv.getTypeUtils().erasure(supertype);
    }
    ClassName injectedClassName = ClassName.get(type);
    ClassName adapterClassName = adapterName(injectedClassName, INJECT_ADAPTER_SUFFIX);
    boolean isAbstract = type.getModifiers().contains(ABSTRACT);
    boolean injectMembers = !fields.isEmpty() || supertype != null;
    boolean disambiguateFields = !fields.isEmpty() && (constructor != null) && !constructor.getParameters().isEmpty();
    boolean dependent = injectMembers || ((constructor != null) && !constructor.getParameters().isEmpty());
    TypeSpec.Builder result = TypeSpec.classBuilder(adapterClassName.simpleName()).addOriginatingElement(type).addModifiers(PUBLIC, FINAL).superclass(ParameterizedTypeName.get(ClassName.get(Binding.class), injectedClassName)).addJavadoc("$L", bindingTypeDocs(injectableType(type.asType()), isAbstract, injectMembers, dependent).toString());
    for (Element field : fields) {
        result.addField(memberBindingField(disambiguateFields, field));
    }
    if (constructor != null) {
        for (VariableElement parameter : constructor.getParameters()) {
            result.addField(parameterBindingField(disambiguateFields, parameter));
        }
    }
    if (supertype != null) {
        result.addField(supertypeBindingField(supertype));
    }
    result.addMethod(writeInjectAdapterConstructor(constructor, type, injectedClassName));
    if (dependent) {
        result.addMethod(attachMethod(constructor, fields, disambiguateFields, injectedClassName, supertype, true));
        result.addMethod(getDependenciesMethod(constructor, fields, disambiguateFields, supertype, true));
    }
    if (constructor != null) {
        result.addMethod(getMethod(constructor, disambiguateFields, injectMembers, injectedClassName));
    }
    if (injectMembers) {
        result.addMethod(membersInjectMethod(fields, disambiguateFields, injectedClassName, supertype));
    }
    JavaFile javaFile = JavaFile.builder(packageName, result.build()).addFileComment(AdapterJavadocs.GENERATED_BY_DAGGER).build();
    javaFile.writeTo(processingEnv.getFiler());
}

Example 2 with Binding

use of dagger.internal.Binding in project dagger by square.

the class GraphAnalysisProcessor method process.

/**
   * Perform full-graph analysis on complete modules. This checks that all of
   * the module's dependencies are satisfied.
   */
@Override
public boolean process(Set<? extends TypeElement> types, RoundEnvironment env) {
    if (!env.processingOver()) {
        // passes.
        for (Element e : env.getElementsAnnotatedWith(Module.class)) {
            if (!(e instanceof TypeElement)) {
                error("@Module applies to a type, " + e.getSimpleName() + " is a " + e.getKind(), e);
                continue;
            }
            delayedModuleNames.add(((TypeElement) e).getQualifiedName().toString());
        }
        return false;
    }
    Set<Element> modules = new LinkedHashSet<Element>();
    for (String moduleName : delayedModuleNames) {
        modules.add(elements().getTypeElement(moduleName));
    }
    for (Element element : modules) {
        Map<String, Object> annotation = null;
        try {
            annotation = getAnnotation(Module.class, element);
        } catch (CodeGenerationIncompleteException e) {
            // skip this element. An up-stream compiler error is in play.
            continue;
        }
        TypeElement moduleType = (TypeElement) element;
        if (annotation == null) {
            error("Missing @Module annotation.", moduleType);
            continue;
        }
        if (annotation.get("complete").equals(Boolean.TRUE)) {
            Map<String, Binding<?>> bindings;
            try {
                bindings = processCompleteModule(moduleType, false);
                new ProblemDetector().detectCircularDependencies(bindings.values());
            } catch (ModuleValidationException e) {
                error("Graph validation failed: " + e.getMessage(), e.source);
                continue;
            } catch (InvalidBindingException e) {
                error("Graph validation failed: " + e.getMessage(), elements().getTypeElement(e.type));
                continue;
            } catch (RuntimeException e) {
                if (ERROR_NAMES_TO_PROPAGATE.contains(e.getClass().getName())) {
                    throw e;
                }
                error("Unknown error " + e.getClass().getName() + " thrown by javac in graph validation: " + e.getMessage(), moduleType);
                continue;
            }
            try {
                writeDotFile(moduleType, bindings);
            } catch (IOException e) {
                StringWriter sw = new StringWriter();
                e.printStackTrace(new PrintWriter(sw));
                processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "Graph visualization failed. Please report this as a bug.\n\n" + sw, moduleType);
            }
        }
        if (annotation.get("library").equals(Boolean.FALSE)) {
            Map<String, Binding<?>> bindings = processCompleteModule(moduleType, true);
            try {
                new ProblemDetector().detectUnusedBinding(bindings.values());
            } catch (IllegalStateException e) {
                error("Graph validation failed: " + e.getMessage(), moduleType);
            }
        }
    }
    return false;
}